Context Navigation

axis.cpp @ 1918

Last change on this file since 1918 was 1918, checked in by ymipsl, 4 years ago

Big update on on going work related to data distribution and transfer between clients and servers.

move all related file into distribution directorie
implement the concept of data "View"
implement the concept of "connector" which make the data transfer between 2 differents "Views"

Property copyright set to
Software name : XIOS (Xml I/O Server)
http://forge.ipsl.jussieu.fr/ioserver
Creation date : January 2009
Licence : CeCCIL version2
see license file in root directory : Licence_CeCILL_V2-en.txt
or http://www.cecill.info/licences/Licence_CeCILL_V2-en.html
Holder : CEA/LSCE (Laboratoire des Sciences du CLimat et de l'Environnement)
CNRS/IPSL (Institut Pierre Simon Laplace)
Project Manager : Yann Meurdesoif
yann.meurdesoif@cea.fr
Property svn:executable set to *

File size: 52.3 KB

Line
1	#include "axis.hpp"
2
3	#include "attribute_template.hpp"
4	#include "object_template.hpp"
5	#include "group_template.hpp"
6	#include "message.hpp"
7	#include "type.hpp"
8	#include "context.hpp"
9	#include "context_client.hpp"
10	#include "context_server.hpp"
11	#include "xios_spl.hpp"
12	#include "server_distribution_description.hpp"
13	#include "client_server_mapping_distributed.hpp"
14	#include "distribution_client.hpp"
15
16	namespace xios {
17
18	/// ////////////////////// Definitions ////////////////////// ///
19
20	CAxis::CAxis(void)
21	: CObjectTemplate<CAxis>()
22	, CAxisAttributes(), isChecked(false), relFiles(), areClientAttributesChecked_(false)
23	, isClientAfterTransformationChecked(false)
24	, hasBounds(false), isCompressible_(false)
25	, numberWrittenIndexes_(), totalNumberWrittenIndexes_(), offsetWrittenIndexes_()
26	, transformationMap_(), hasValue(false), hasLabel(false)
27	, computedWrittenIndex_(false)
28	, clients()
29	{
30	}
31
32	CAxis::CAxis(const StdString & id)
33	: CObjectTemplate<CAxis>(id)
34	, CAxisAttributes(), isChecked(false), relFiles(), areClientAttributesChecked_(false)
35	, isClientAfterTransformationChecked(false)
36	, hasBounds(false), isCompressible_(false)
37	, numberWrittenIndexes_(), totalNumberWrittenIndexes_(), offsetWrittenIndexes_()
38	, transformationMap_(), hasValue(false), hasLabel(false)
39	, computedWrittenIndex_(false)
40	, clients()
41	{
42	}
43
44	CAxis::~CAxis(void)
45	{ /* Ne rien faire de plus */ }
46
47	std::map<StdString, ETranformationType> CAxis::transformationMapList_ = std::map<StdString, ETranformationType>();
48	bool CAxis::dummyTransformationMapList_ = CAxis::initializeTransformationMap(CAxis::transformationMapList_);
49	bool CAxis::initializeTransformationMap(std::map<StdString, ETranformationType>& m)
50	TRY
51	{
52	m["zoom_axis"] = TRANS_ZOOM_AXIS;
53	m["interpolate_axis"] = TRANS_INTERPOLATE_AXIS;
54	m["extract_axis"] = TRANS_EXTRACT_AXIS;
55	m["inverse_axis"] = TRANS_INVERSE_AXIS;
56	m["reduce_domain"] = TRANS_REDUCE_DOMAIN_TO_AXIS;
57	m["reduce_axis"] = TRANS_REDUCE_AXIS_TO_AXIS;
58	m["extract_domain"] = TRANS_EXTRACT_DOMAIN_TO_AXIS;
59	m["temporal_splitting"] = TRANS_TEMPORAL_SPLITTING;
60	m["duplicate_scalar"] = TRANS_DUPLICATE_SCALAR_TO_AXIS;
61
62	}
63	CATCH
64
65	///---------------------------------------------------------------
66
67	const std::set<StdString> & CAxis::getRelFiles(void) const
68	TRY
69	{
70	return (this->relFiles);
71	}
72	CATCH
73
74	bool CAxis::IsWritten(const StdString & filename) const
75	TRY
76	{
77	return (this->relFiles.find(filename) != this->relFiles.end());
78	}
79	CATCH
80
81	bool CAxis::isWrittenCompressed(const StdString& filename) const
82	TRY
83	{
84	return (this->relFilesCompressed.find(filename) != this->relFilesCompressed.end());
85	}
86	CATCH
87
88	bool CAxis::isDistributed(void) const
89	TRY
90	{
91	bool distributed = (!this->begin.isEmpty() && !this->n.isEmpty() && (this->begin + this->n < this->n_glo)) \|\|
92	(!this->n.isEmpty() && (this->n != this->n_glo));
93	// A condition to make sure that if there is only one client, axis
94	// should be considered to be distributed. This should be a temporary solution
95	distributed \|= (1 == CContext::getCurrent()->intraCommSize_);
96	return distributed;
97	}
98	CATCH
99
100	/*!
101	* Test whether the data defined on the axis can be outputted in a compressed way.
102	*
103	* \return true if and only if a mask was defined for this axis
104	*/
105	bool CAxis::isCompressible(void) const
106	TRY
107	{
108	return isCompressible_;
109	}
110	CATCH
111
112	void CAxis::addRelFile(const StdString & filename)
113	TRY
114	{
115	this->relFiles.insert(filename);
116	}
117	CATCH_DUMP_ATTR
118
119	void CAxis::addRelFileCompressed(const StdString& filename)
120	TRY
121	{
122	this->relFilesCompressed.insert(filename);
123	}
124	CATCH_DUMP_ATTR
125
126	//----------------------------------------------------------------
127
128	/*!
129	Returns the number of indexes written by each server.
130	\return the number of indexes written by each server
131	*/
132	int CAxis::getNumberWrittenIndexes(MPI_Comm writtenCom)
133	TRY
134	{
135	int writtenSize;
136	MPI_Comm_size(writtenCom, &writtenSize);
137	return numberWrittenIndexes_[writtenSize];
138	}
139	CATCH_DUMP_ATTR
140
141	/*!
142	Returns the total number of indexes written by the servers.
143	\return the total number of indexes written by the servers
144	*/
145	int CAxis::getTotalNumberWrittenIndexes(MPI_Comm writtenCom)
146	TRY
147	{
148	int writtenSize;
149	MPI_Comm_size(writtenCom, &writtenSize);
150	return totalNumberWrittenIndexes_[writtenSize];
151	}
152	CATCH_DUMP_ATTR
153
154	/*!
155	Returns the offset of indexes written by each server.
156	\return the offset of indexes written by each server
157	*/
158	int CAxis::getOffsetWrittenIndexes(MPI_Comm writtenCom)
159	TRY
160	{
161	int writtenSize;
162	MPI_Comm_size(writtenCom, &writtenSize);
163	return offsetWrittenIndexes_[writtenSize];
164	}
165	CATCH_DUMP_ATTR
166
167	CArray<int, 1>& CAxis::getCompressedIndexToWriteOnServer(MPI_Comm writtenCom)
168	TRY
169	{
170	int writtenSize;
171	MPI_Comm_size(writtenCom, &writtenSize);
172	return compressedIndexToWriteOnServer[writtenSize];
173	}
174	CATCH_DUMP_ATTR
175
176	//----------------------------------------------------------------
177
178	/*!
179	* Compute the minimum buffer size required to send the attributes to the server(s).
180	*
181	* \return A map associating the server rank with its minimum buffer size.
182	*/
183	std::map<int, StdSize> CAxis::getAttributesBufferSize(CContextClient* client, const std::vector<int>& globalDim, int orderPositionInGrid,
184	CServerDistributionDescription::ServerDistributionType distType)
185	TRY
186	{
187
188	std::map<int, StdSize> attributesSizes = getMinimumBufferSizeForAttributes(client);
189
190	// bool isNonDistributed = (n_glo == n);
191	bool isDistributed = (orderPositionInGrid == CServerDistributionDescription::defaultDistributedDimension(globalDim.size(), distType))
192	\|\| (index.numElements() != n_glo);
193
194	if (client->isServerLeader())
195	{
196	// size estimation for sendServerAttribut
197	size_t size = 6 * sizeof(size_t);
198	// size estimation for sendNonDistributedValue
199	if (!isDistributed)
200	{
201	// size = std::max(size, CArray<double,1>::size(n_glo) + (isCompressible_ ? CArray<int,1>::size(n_glo) : 0));
202	size += CArray<int,1>::size(n_glo);
203	size += CArray<int,1>::size(n_glo);
204	size += CArray<bool,1>::size(n_glo);
205	size += CArray<double,1>::size(n_glo);
206	if (hasBounds)
207	size += CArray<double,2>::size(2*n_glo);
208	if (hasLabel)
209	size += CArray<StdString,1>::size(n_glo);
210	}
211	size += CEventClient::headerSize + getId().size() + sizeof(size_t);
212
213	const std::list<int>& ranks = client->getRanksServerLeader();
214	for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank)
215	{
216	if (size > attributesSizes[*itRank])
217	attributesSizes[*itRank] = size;
218	}
219	const std::list<int>& ranksNonLeaders = client->getRanksServerNotLeader();
220	for (std::list<int>::const_iterator itRank = ranksNonLeaders.begin(), itRankEnd = ranksNonLeaders.end(); itRank != itRankEnd; ++itRank)
221	{
222	if (size > attributesSizes[*itRank])
223	attributesSizes[*itRank] = size;
224	}
225
226	}
227
228	if (isDistributed)
229	{
230	// size estimation for sendDistributedValue
231	std::unordered_map<int, vector<size_t> >::const_iterator it, ite = indSrv_[client->serverSize].end();
232	for (it = indSrv_[client->serverSize].begin(); it != ite; ++it)
233	{
234	size_t size = 6 * sizeof(size_t);
235	size += CArray<int,1>::size(it->second.size());
236	size += CArray<int,1>::size(it->second.size());
237	size += CArray<bool,1>::size(it->second.size());
238	size += CArray<double,1>::size(it->second.size());
239	if (hasBounds)
240	size += CArray<double,2>::size(2 * it->second.size());
241	if (hasLabel)
242	size += CArray<StdString,1>::size(it->second.size());
243
244	size += CEventClient::headerSize + getId().size() + sizeof(size_t);
245	if (size > attributesSizes[it->first])
246	attributesSizes[it->first] = size;
247	}
248	}
249	return attributesSizes;
250	}
251	CATCH_DUMP_ATTR
252
253	//----------------------------------------------------------------
254
255	StdString CAxis::GetName(void) { return (StdString("axis")); }
256	StdString CAxis::GetDefName(void){ return (CAxis::GetName()); }
257	ENodeType CAxis::GetType(void) { return (eAxis); }
258
259	//----------------------------------------------------------------
260
261	CAxis* CAxis::createAxis()
262	TRY
263	{
264	CAxis* axis = CAxisGroup::get("axis_definition")->createChild();
265	return axis;
266	}
267	CATCH
268
269	/*!
270	Check common attributes of an axis.
271	This check should be done in the very beginning of work flow
272	*/
273	void CAxis::checkAttributes(void)
274	TRY
275	{
276	if (checkAttributes_done_) return ;
277
278	CContext* context=CContext::getCurrent();
279
280	if (this->n_glo.isEmpty())
281	ERROR("CAxis::checkAttributes(void)",
282	<< "[ id = '" << getId() << "' , context = '" << CObjectFactory::GetCurrentContextId() << "' ] "
283	<< "The axis is wrongly defined, attribute 'n_glo' must be specified");
284	StdSize size = this->n_glo.getValue();
285
286	if (!this->index.isEmpty())
287	{
288	if (n.isEmpty()) n = index.numElements();
289
290	// It's not so correct but if begin is not the first value of index
291	// then data on the local axis has user-defined distribution. In this case, begin has no meaning.
292	if (begin.isEmpty()) begin = index(0);
293	}
294	else
295	{
296	if (!this->begin.isEmpty())
297	{
298	if (begin < 0 \|\| begin > size - 1)
299	ERROR("CAxis::checkAttributes(void)",
300	<< "[ id = '" << getId() << "' , context = '" << CObjectFactory::GetCurrentContextId() << "' ] "
301	<< "The axis is wrongly defined, attribute 'begin' (" << begin.getValue() << ") must be non-negative and smaller than size-1 (" << size - 1 << ").");
302	}
303	else this->begin.setValue(0);
304
305	if (!this->n.isEmpty())
306	{
307	if (n < 0 \|\| n > size)
308	ERROR("CAxis::checkAttributes(void)",
309	<< "[ id = '" << getId() << "' , context = '" << CObjectFactory::GetCurrentContextId() << "' ] "
310	<< "The axis is wrongly defined, attribute 'n' (" << n.getValue() << ") must be non-negative and smaller than size (" << size << ").");
311	}
312	else this->n.setValue(size);
313
314	{
315	index.resize(n);
316	for (int i = 0; i < n; ++i) index(i) = i+begin;
317	}
318	}
319
320	if (!this->value.isEmpty())
321	{
322	StdSize true_size = value.numElements();
323	if (this->n.getValue() != true_size)
324	ERROR("CAxis::checkAttributes(void)",
325	<< "[ id = '" << getId() << "' , context = '" << CObjectFactory::GetCurrentContextId() << "' ] "
326	<< "The axis is wrongly defined, attribute 'value' has a different size (" << true_size
327	<< ") than the one defined by the \'size\' attribute (" << n.getValue() << ").");
328	this->hasValue = true;
329	}
330
331	this->checkBounds();
332	this->checkMask();
333	this->checkData();
334	this->checkLabel();
335	initializeLocalElement() ;
336	addFullView() ;
337	addWorkflowView() ;
338	addModelView() ;
339
340	checkAttributes_done_ = true ;
341	}
342	CATCH_DUMP_ATTR
343
344
345
346	void CAxis::initializeLocalElement(void)
347	{
348	// after checkAttribute index of size n
349	int rank = CContext::getCurrent()->getIntraCommRank() ;
350
351	CArray<size_t,1> ind(n) ;
352	for (int i=0;i<n;i++) ind(i)=index(i) ;
353
354	localElement_ = new CLocalElement(rank, n_glo, ind) ;
355	}
356
357	void CAxis::addFullView(void)
358	{
359	CArray<int,1> index(n) ;
360	for(int i=0; i<n ; i++) index(i)=i ;
361	localElement_ -> addView(CElementView::FULL, index) ;
362	}
363
364	void CAxis::addWorkflowView(void)
365	{
366	// mask + data are included into data_index
367	int nk=data_index.numElements() ;
368	int nMask=0 ;
369	for(int k=0;k<nk;k++) if (data_index(k)>=0 && data_index(k)<n) nMask++ ;
370
371	CArray<int,1> index(nMask) ;
372	nMask=0 ;
373	for(int k=0;k<nk;k++)
374	if (data_index(k)>=0 && data_index(k)<n)
375	{
376	index(nMask) = data_index(k) ;
377	nMask++ ;
378	}
379	localElement_ -> addView(CElementView::WORKFLOW, index) ;
380	}
381
382	void CAxis::addModelView(void)
383	{
384	// information for model view is stored in data_index
385	localElement_->addView(CElementView::MODEL, data_index) ;
386	}
387
388	void CAxis::computeModelToWorkflowConnector(void)
389	{
390	CLocalView* srcView=getLocalView(CElementView::MODEL) ;
391	CLocalView* dstView=getLocalView(CElementView::WORKFLOW) ;
392	modelToWorkflowConnector_ = new CLocalConnector(srcView, dstView);
393	modelToWorkflowConnector_->computeConnector() ;
394	}
395
396	/*!
397	Check the validity of data, fill in values if any, and apply mask.
398	*/
399	void CAxis::checkData()
400	TRY
401	{
402	if (data_begin.isEmpty()) data_begin.setValue(0);
403
404	if (data_n.isEmpty())
405	{
406	data_n.setValue(n);
407	}
408	else if (data_n.getValue() < 0)
409	{
410	ERROR("CAxis::checkData(void)",
411	<< "[ id = " << this->getId() << " , context = '" << CObjectFactory::GetCurrentContextId() << " ] "
412	<< "The data size should be strictly positive ('data_n' = " << data_n.getValue() << ").");
413	}
414
415	if (data_index.isEmpty())
416	{
417	data_index.resize(data_n);
418	for (int i = 0; i < data_n; ++i)
419	{
420	if ((i+data_begin) >= 0 && (i+data_begin<n))
421	{
422	if (mask(i+data_begin))
423	data_index(i) = i+data_begin;
424	else
425	data_index(i) = -1;
426	}
427	else
428	data_index(i) = -1;
429	}
430	}
431	else
432	{
433	if (data_index.numElements() != data_n)
434	{
435	ERROR("CAxis::checkData(void)",
436	<< "[ id = " << this->getId() << " , context = '" << CObjectFactory::GetCurrentContextId() << " ] "
437	<< "The size of data_index = "<< data_index.numElements() << "is not equal to the data size data_n = " << data_n.getValue() << ").");
438	}
439	for (int i = 0; i < data_n; ++i)
440	{
441	if (data_index(i) >= 0 && data_index(i)<n)
442	if (!mask(data_index(i))) data_index(i) = -1;
443	}
444	}
445
446	}
447	CATCH_DUMP_ATTR
448
449	size_t CAxis::getGlobalWrittenSize(void)
450	{
451	return n_glo ;
452	}
453
454	/*!
455	Check validity of mask info and fill in values if any.
456	*/
457	void CAxis::checkMask()
458	TRY
459	{
460	if (!mask.isEmpty())
461	{
462	if (mask.extent(0) != n)
463	{
464	ERROR("CAxis::checkMask(void)",
465	<< "[ id = " << this->getId() << " , context = '" << CObjectFactory::GetCurrentContextId() << " ] "
466	<< "The mask does not have the same size as the local domain." << std::endl
467	<< "Local size is " << n.getValue() << "." << std::endl
468	<< "Mask size is " << mask.extent(0) << ".");
469	}
470	}
471	else
472	{
473	mask.resize(n);
474	mask = true;
475	}
476	}
477	CATCH_DUMP_ATTR
478
479	/*!
480	Check validity of bounds info and fill in values if any.
481	*/
482	void CAxis::checkBounds()
483	TRY
484	{
485	if (!bounds.isEmpty())
486	{
487	if (bounds.extent(0) != 2 \|\| bounds.extent(1) != n)
488	ERROR("CAxis::checkAttributes(void)",
489	<< "The bounds array of the axis [ id = '" << getId() << "' , context = '" << CObjectFactory::GetCurrentContextId() << "' ] must be of dimension 2 x axis size." << std::endl
490	<< "Axis size is " << n.getValue() << "." << std::endl
491	<< "Bounds size is "<< bounds.extent(0) << " x " << bounds.extent(1) << ".");
492	hasBounds = true;
493	}
494	else hasBounds = false;
495	}
496	CATCH_DUMP_ATTR
497
498	void CAxis::checkLabel()
499	TRY
500	{
501	if (!label.isEmpty())
502	{
503	if (label.extent(0) != n)
504	ERROR("CAxis::checkLabel(void)",
505	<< "The label array of the axis [ id = '" << getId() << "' , context = '" << CObjectFactory::GetCurrentContextId() << "' ] must be of dimension of axis size." << std::endl
506	<< "Axis size is " << n.getValue() << "." << std::endl
507	<< "label size is "<< label.extent(0)<< " .");
508	hasLabel = true;
509	}
510	else hasLabel = false;
511	}
512	CATCH_DUMP_ATTR
513
514	/*!
515	Check whether we can do compressed output
516	*/
517	void CAxis::checkEligibilityForCompressedOutput()
518	TRY
519	{
520	// We don't check if the mask is valid here, just if a mask has been defined at this point.
521	isCompressible_ = !mask.isEmpty();
522	}
523	CATCH_DUMP_ATTR
524
525	/*!
526	Dispatch event from the lower communication layer then process event according to its type
527	*/
528	bool CAxis::dispatchEvent(CEventServer& event)
529	TRY
530	{
531	if (SuperClass::dispatchEvent(event)) return true;
532	else
533	{
534	switch(event.type)
535	{
536	case EVENT_ID_DISTRIBUTION_ATTRIBUTE :
537	recvDistributionAttribute(event);
538	return true;
539	break;
540	case EVENT_ID_NON_DISTRIBUTED_ATTRIBUTES:
541	recvNonDistributedAttributes(event);
542	return true;
543	break;
544	case EVENT_ID_DISTRIBUTED_ATTRIBUTES:
545	recvDistributedAttributes(event);
546	return true;
547	break;
548	default :
549	ERROR("bool CAxis::dispatchEvent(CEventServer& event)",
550	<< "Unknown Event");
551	return false;
552	}
553	}
554	}
555	CATCH
556
557	/*!
558	Check attributes on client side (This name is still adequate???)
559	*/
560	void CAxis::checkAttributesOnClient()
561	TRY
562	{
563	if (this->areClientAttributesChecked_) return;
564
565	CContext* context=CContext::getCurrent();
566	if (context->getServiceType()==CServicesManager::CLIENT) this->checkAttributes();
567
568	this->areClientAttributesChecked_ = true;
569	}
570	CATCH_DUMP_ATTR
571
572	/*
573	The (spatial) transformation sometimes can change attributes of an axis (e.g zoom can change mask or generate can change whole attributes)
574	Therefore, we should recheck them.
575	*/
576	// ym : obsolete to be removed
577	void CAxis::checkAttributesOnClientAfterTransformation(const std::vector<int>& globalDim, int orderPositionInGrid,
578	CServerDistributionDescription::ServerDistributionType distType)
579	TRY
580	{
581	CContext* context=CContext::getCurrent() ;
582
583	if (this->isClientAfterTransformationChecked) return;
584	if (context->getServiceType()==CServicesManager::CLIENT \|\| context->getServiceType()==CServicesManager::GATHERER)
585	{
586	/* suppressed because of interface changed
587	if (orderPositionInGrid == CServerDistributionDescription::defaultDistributedDimension(globalDim.size(), distType))
588	computeConnectedClients(globalDim, orderPositionInGrid, distType);
589	else if (index.numElements() != n_glo) computeConnectedClients(globalDim, orderPositionInGrid, CServerDistributionDescription::ROOT_DISTRIBUTION);
590	*/
591	}
592
593	this->isClientAfterTransformationChecked = true;
594	}
595	CATCH_DUMP_ATTR
596
597	/*
598	Send all checked attributes to server? (We dont have notion of server any more so client==server)
599	\param [in] globalDim global dimension of grid containing this axis
600	\param [in] orderPositionInGrid the relative order of this axis in the grid (e.g grid composed of domain+axis -> orderPositionInGrid is 2)
601	\param [in] distType distribution type of the server. For now, we only have band distribution.
602
603	*/
604	//ym obsolete : to be removed
605	void CAxis::sendCheckedAttributes(const std::vector<int>& globalDim, int orderPositionInGrid,
606	CServerDistributionDescription::ServerDistributionType distType)
607	TRY
608	{
609	if (!this->areClientAttributesChecked_) checkAttributesOnClient();
610	if (!this->isClientAfterTransformationChecked) checkAttributesOnClientAfterTransformation(globalDim, orderPositionInGrid, distType);
611	CContext* context = CContext::getCurrent();
612
613	if (this->isChecked) return;
614	if (context->getServiceType()==CServicesManager::CLIENT \|\| context->getServiceType()==CServicesManager::GATHERER) /sendAttributes(globalDim, orderPositionInGrid, distType)/;
615
616	this->isChecked = true;
617	}
618	CATCH_DUMP_ATTR
619
620
621	void CAxis::sendAxisToFileServer(CContextClient* client, const std::vector<int>& globalDim, int orderPositionInGrid)
622	{
623	if (sendAxisToFileServer_done_.count(client)!=0) return ;
624	else sendAxisToFileServer_done_.insert(client) ;
625
626	StdString axisDefRoot("axis_definition");
627	CAxisGroup* axisPtr = CAxisGroup::get(axisDefRoot);
628	axisPtr->sendCreateChild(this->getId(),client);
629	this->sendAllAttributesToServer(client) ;
630	this->sendAttributes(client, globalDim, orderPositionInGrid, CServerDistributionDescription::BAND_DISTRIBUTION) ;
631	}
632
633	void CAxis::sendAxisToCouplerOut(CContextClient* client, const std::vector<int>& globalDim, int orderPositionInGrid, const string& fieldId, int posInGrid)
634	{
635	if (sendAxisToFileServer_done_.count(client)!=0) return ;
636	else sendAxisToFileServer_done_.insert(client) ;
637
638	string axisId="_axis["+std::to_string(posInGrid)+"]_of_"+fieldId ;
639
640	if (!axis_ref.isEmpty())
641	{
642	auto axis_ref_tmp=axis_ref.getValue() ;
643	axis_ref.reset() ; // remove the reference, find an other way to do that more cleanly
644	this->sendAllAttributesToServer(client, axisId) ;
645	axis_ref = axis_ref_tmp ;
646	}
647	else this->sendAllAttributesToServer(client, axisId) ;
648
649	this->sendAttributes(client, globalDim, orderPositionInGrid, CServerDistributionDescription::BAND_DISTRIBUTION, axisId) ;
650	}
651
652	void CAxis::makeAliasForCoupling(const string& fieldId, int posInGrid)
653	{
654	const string axisId = "_axis["+std::to_string(posInGrid)+"]_of_"+fieldId ;
655	this->createAlias(axisId) ;
656	}
657
658	/*!
659	Send attributes from one client to other clients
660	\param[in] globalDim global dimension of grid which contains this axis
661	\param[in] order
662	*/
663	void CAxis::sendAttributes(CContextClient* client, const std::vector<int>& globalDim, int orderPositionInGrid,
664	CServerDistributionDescription::ServerDistributionType distType, const string& axisId)
665	TRY
666	{
667	sendDistributionAttribute(client, globalDim, orderPositionInGrid, distType, axisId);
668
669	// if (index.numElements() == n_glo.getValue())
670	if ((orderPositionInGrid == CServerDistributionDescription::defaultDistributedDimension(globalDim.size(), distType))
671	\|\| (index.numElements() != n_glo))
672	{
673	sendDistributedAttributes(client, axisId);
674	}
675	else
676	{
677	sendNonDistributedAttributes(client, axisId);
678	}
679	}
680	CATCH_DUMP_ATTR
681
682	/*
683	Compute the connection between group of clients (or clients/servers).
684	(E.g: Suppose we have 2 group of clients in two model: A (client role) connect to B (server role),
685	this function calculate number of clients B connect to one client of A)
686	\param [in] globalDim global dimension of grid containing this axis
687	\param [in] orderPositionInGrid the relative order of this axis in the grid (e.g grid composed of domain+axis -> orderPositionInGrid is 2)
688	\param [in] distType distribution type of the server. For now, we only have band distribution.
689	*/
690	void CAxis::computeConnectedClients(CContextClient* client, const std::vector<int>& globalDim, int orderPositionInGrid)
691	TRY
692	{
693	if (computeConnectedClients_done_.count(client)!=0) return ;
694	else computeConnectedClients_done_.insert(client) ;
695
696	CContext* context = CContext::getCurrent();
697	CServerDistributionDescription::ServerDistributionType distType ;
698	int defaultDistributedPos = CServerDistributionDescription::defaultDistributedDimension(globalDim.size(), CServerDistributionDescription::BAND_DISTRIBUTION) ;
699
700	if (orderPositionInGrid == defaultDistributedPos) distType = CServerDistributionDescription::BAND_DISTRIBUTION ;
701	else if (index.numElements() != n_glo) distType = CServerDistributionDescription::ROOT_DISTRIBUTION ;
702	else return ;
703
704	int nbServer = client->serverSize;
705	int range, clientSize = client->clientSize;
706	int rank = client->clientRank;
707
708	if (listNbServer_.count(nbServer) == 0)
709	{
710	listNbServer_.insert(nbServer) ;
711
712	if (connectedServerRank_.find(nbServer) != connectedServerRank_.end())
713	{
714	nbSenders.erase(nbServer);
715	connectedServerRank_.erase(nbServer);
716	}
717
718	size_t ni = this->n.getValue();
719	size_t ibegin = this->begin.getValue();
720	size_t nbIndex = index.numElements();
721
722	// First of all, we should compute the mapping of the global index and local index of the current client
723	if (globalLocalIndexMap_.empty())
724	{
725	for (size_t idx = 0; idx < nbIndex; ++idx)
726	{
727	globalLocalIndexMap_[index(idx)] = idx;
728	}
729	}
730
731	// Calculate the compressed index if any
732	// std::set<int> writtenInd;
733	// if (isCompressible_)
734	// {
735	// for (int idx = 0; idx < data_index.numElements(); ++idx)
736	// {
737	// int ind = CDistributionClient::getAxisIndex(data_index(idx), data_begin, ni);
738	//
739	// if (ind >= 0 && ind < ni && mask(ind))
740	// {
741	// ind += ibegin;
742	// writtenInd.insert(ind);
743	// }
744	// }
745	// }
746
747	// Compute the global index of the current client (process) hold
748	std::vector<int> nGlobAxis(1);
749	nGlobAxis[0] = n_glo.getValue();
750
751	size_t globalSizeIndex = 1, indexBegin, indexEnd;
752	for (int i = 0; i < nGlobAxis.size(); ++i) globalSizeIndex *= nGlobAxis[i];
753	indexBegin = 0;
754	if (globalSizeIndex <= clientSize)
755	{
756	indexBegin = rank%globalSizeIndex;
757	indexEnd = indexBegin;
758	}
759	else
760	{
761	for (int i = 0; i < clientSize; ++i)
762	{
763	range = globalSizeIndex / clientSize;
764	if (i < (globalSizeIndex%clientSize)) ++range;
765	if (i == client->clientRank) break;
766	indexBegin += range;
767	}
768	indexEnd = indexBegin + range - 1;
769	}
770
771	CArray<size_t,1> globalIndex(index.numElements());
772	for (size_t idx = 0; idx < globalIndex.numElements(); ++idx)
773	globalIndex(idx) = index(idx);
774
775	// Describe the distribution of server side
776
777	CServerDistributionDescription serverDescription(nGlobAxis, nbServer, distType);
778
779	std::vector<int> serverZeroIndex;
780	serverZeroIndex = serverDescription.computeServerGlobalIndexInRange(std::make_pair<size_t&,size_t&>(indexBegin, indexEnd), 0);
781
782	std::list<int> serverZeroIndexLeader;
783	std::list<int> serverZeroIndexNotLeader;
784	CContextClient::computeLeader(client->clientRank, client->clientSize, serverZeroIndex.size(), serverZeroIndexLeader, serverZeroIndexNotLeader);
785	for (std::list<int>::iterator it = serverZeroIndexLeader.begin(); it != serverZeroIndexLeader.end(); ++it)
786	it = serverZeroIndex[it];
787
788	// Find out the connection between client and server side
789	CClientServerMapping* clientServerMap = new CClientServerMappingDistributed(serverDescription.getGlobalIndexRange(), client->intraComm);
790	clientServerMap->computeServerIndexMapping(globalIndex, nbServer);
791	CClientServerMapping::GlobalIndexMap& globalIndexAxisOnServer = clientServerMap->getGlobalIndexOnServer();
792
793	indSrv_[nbServer].swap(globalIndexAxisOnServer);
794
795	if (distType==CServerDistributionDescription::ROOT_DISTRIBUTION)
796	{
797	for(int i=1; i<nbServer; ++i) indSrv_[nbServer].insert(pair<int, vector<size_t> >(i,indSrv_[nbServer][0]) ) ;
798	serverZeroIndexLeader.clear() ;
799	}
800
801	CClientServerMapping::GlobalIndexMap::const_iterator it = indSrv_[nbServer].begin(),
802	ite = indSrv_[nbServer].end();
803
804	for (it = indSrv_[nbServer].begin(); it != ite; ++it) connectedServerRank_[nbServer].push_back(it->first);
805
806	for (std::list<int>::const_iterator it = serverZeroIndexLeader.begin(); it != serverZeroIndexLeader.end(); ++it)
807	connectedServerRank_[nbServer].push_back(*it);
808
809	// Even if a client has no index, it must connect to at least one server and
810	// send an "empty" data to this server
811	if (connectedServerRank_[nbServer].empty())
812	connectedServerRank_[nbServer].push_back(client->clientRank % client->serverSize);
813
814	nbSenders[nbServer] = CClientServerMapping::computeConnectedClients(client->serverSize, client->clientSize, client->intraComm, connectedServerRank_[nbServer]);
815
816	delete clientServerMap;
817	}
818	}
819	CATCH_DUMP_ATTR
820
821	/*
822	Compute the index of data to write into file
823	(Different from the previous version, this version of XIOS allows data be written into file (classical role),
824	or transfered to another clients)
825	*/
826	void CAxis::computeWrittenIndex()
827	TRY
828	{
829	if (computedWrittenIndex_) return;
830	computedWrittenIndex_ = true;
831
832	CContext* context=CContext::getCurrent();
833
834	// We describe the distribution of client (server) on which data are written
835	std::vector<int> nBegin(1), nSize(1), nBeginGlobal(1), nGlob(1);
836	nBegin[0] = begin;
837	nSize[0] = n;
838	nBeginGlobal[0] = 0;
839	nGlob[0] = n_glo;
840	CDistributionServer srvDist(context->intraCommSize_, nBegin, nSize, nBeginGlobal, nGlob);
841	const CArray<size_t,1>& writtenGlobalIndex = srvDist.getGlobalIndex();
842
843	// Because all written data are local on a client,
844	// we need to compute the local index on the server from its corresponding global index
845	size_t nbWritten = 0, indGlo;
846	std::unordered_map<size_t,size_t>::const_iterator itb = globalLocalIndexMap_.begin(),
847	ite = globalLocalIndexMap_.end(), it;
848	CArray<size_t,1>::const_iterator itSrvb = writtenGlobalIndex.begin(),
849	itSrve = writtenGlobalIndex.end(), itSrv;
850
851	localIndexToWriteOnServer.resize(writtenGlobalIndex.numElements());
852	nbWritten = 0;
853	for (itSrv = itSrvb; itSrv != itSrve; ++itSrv)
854	{
855	indGlo = *itSrv;
856	if (ite != globalLocalIndexMap_.find(indGlo))
857	{
858	localIndexToWriteOnServer(nbWritten) = globalLocalIndexMap_[indGlo];
859	}
860	else
861	{
862	localIndexToWriteOnServer(nbWritten) = -1;
863	}
864	++nbWritten;
865	}
866
867	}
868	CATCH_DUMP_ATTR
869
870	void CAxis::computeWrittenCompressedIndex(MPI_Comm writtenComm)
871	TRY
872	{
873	int writtenCommSize;
874	MPI_Comm_size(writtenComm, &writtenCommSize);
875	if (compressedIndexToWriteOnServer.find(writtenCommSize) != compressedIndexToWriteOnServer.end())
876	return;
877
878	if (isCompressible())
879	{
880	size_t nbWritten = 0, indGlo;
881	CContext* context=CContext::getCurrent();
882
883	// We describe the distribution of client (server) on which data are written
884	std::vector<int> nBegin(1), nSize(1), nBeginGlobal(1), nGlob(1);
885	nBegin[0] = 0;
886	nSize[0] = n;
887	nBeginGlobal[0] = 0;
888	nGlob[0] = n_glo;
889	CDistributionServer srvDist(context->intraCommSize_, nBegin, nSize, nBeginGlobal, nGlob);
890	const CArray<size_t,1>& writtenGlobalIndex = srvDist.getGlobalIndex();
891	std::unordered_map<size_t,size_t>::const_iterator itb = globalLocalIndexMap_.begin(),
892	ite = globalLocalIndexMap_.end(), it;
893
894	CArray<size_t,1>::const_iterator itSrvb = writtenGlobalIndex.begin(),
895	itSrve = writtenGlobalIndex.end(), itSrv;
896	std::unordered_map<size_t,size_t> localGlobalIndexMap;
897	for (itSrv = itSrvb; itSrv != itSrve; ++itSrv)
898	{
899	indGlo = *itSrv;
900	if (ite != globalLocalIndexMap_.find(indGlo))
901	{
902	localGlobalIndexMap[localIndexToWriteOnServer(nbWritten)] = indGlo;
903	++nbWritten;
904	}
905	}
906	//
907	// nbWritten = 0;
908	// for (int idx = 0; idx < data_index.numElements(); ++idx)
909	// {
910	// if (localGlobalIndexMap.end() != localGlobalIndexMap.find(data_index(idx)))
911	// {
912	// ++nbWritten;
913	// }
914	// }
915	//
916	// compressedIndexToWriteOnServer[writtenCommSize].resize(nbWritten);
917	// nbWritten = 0;
918	// for (int idx = 0; idx < data_index.numElements(); ++idx)
919	// {
920	// if (localGlobalIndexMap.end() != localGlobalIndexMap.find(data_index(idx)))
921	// {
922	// compressedIndexToWriteOnServer[writtenCommSize](nbWritten) = localGlobalIndexMap[data_index(idx)];
923	// ++nbWritten;
924	// }
925	// }
926
927	nbWritten = 0;
928	for (int idx = 0; idx < data_index.numElements(); ++idx)
929	{
930	if (localGlobalIndexMap.end() != localGlobalIndexMap.find(data_index(idx)))
931	{
932	++nbWritten;
933	}
934	}
935
936	compressedIndexToWriteOnServer[writtenCommSize].resize(nbWritten);
937	nbWritten = 0;
938	for (int idx = 0; idx < data_index.numElements(); ++idx)
939	{
940	if (localGlobalIndexMap.end() != localGlobalIndexMap.find(data_index(idx)))
941	{
942	compressedIndexToWriteOnServer[writtenCommSize](nbWritten) = localGlobalIndexMap[data_index(idx)];
943	++nbWritten;
944	}
945	}
946
947	numberWrittenIndexes_[writtenCommSize] = nbWritten;
948
949	bool distributed_glo, distributed=isDistributed() ;
950	MPI_Allreduce(&distributed,&distributed_glo, 1, MPI_INT, MPI_LOR, writtenComm) ;
951	if (distributed_glo)
952	{
953
954	MPI_Allreduce(&numberWrittenIndexes_[writtenCommSize], &totalNumberWrittenIndexes_[writtenCommSize], 1, MPI_INT, MPI_SUM, writtenComm);
955	MPI_Scan(&numberWrittenIndexes_[writtenCommSize], &offsetWrittenIndexes_[writtenCommSize], 1, MPI_INT, MPI_SUM, writtenComm);
956	offsetWrittenIndexes_[writtenCommSize] -= numberWrittenIndexes_[writtenCommSize];
957	}
958	else
959	totalNumberWrittenIndexes_[writtenCommSize] = numberWrittenIndexes_[writtenCommSize];
960	}
961	}
962	CATCH_DUMP_ATTR
963
964	/*!
965	Send distribution information from a group of client (client role) to another group of client (server role)
966	The distribution of a group of client (server role) is imposed by the group of client (client role)
967	\param [in] globalDim global dimension of grid containing this axis
968	\param [in] orderPositionInGrid the relative order of this axis in the grid (e.g grid composed of domain+axis -> orderPositionInGrid is 2)
969	\param [in] distType distribution type of the server. For now, we only have band distribution.
970	*/
971	void CAxis::sendDistributionAttribute(CContextClient* client, const std::vector<int>& globalDim, int orderPositionInGrid,
972	CServerDistributionDescription::ServerDistributionType distType, const string& axisId)
973	TRY
974	{
975	string serverAxisId = axisId.empty() ? this->getId() : axisId ;
976	int nbServer = client->serverSize;
977
978	CServerDistributionDescription serverDescription(globalDim, nbServer);
979	serverDescription.computeServerDistribution();
980
981	std::vector<std::vector<int> > serverIndexBegin = serverDescription.getServerIndexBegin();
982	std::vector<std::vector<int> > serverDimensionSizes = serverDescription.getServerDimensionSizes();
983
984	CEventClient event(getType(),EVENT_ID_DISTRIBUTION_ATTRIBUTE);
985	if (client->isServerLeader())
986	{
987	std::list<CMessage> msgs;
988
989	const std::list<int>& ranks = client->getRanksServerLeader();
990	for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank)
991	{
992	// Use const int to ensure CMessage holds a copy of the value instead of just a reference
993	const int begin = serverIndexBegin[*itRank][orderPositionInGrid];
994	const int ni = serverDimensionSizes[*itRank][orderPositionInGrid];
995
996	msgs.push_back(CMessage());
997	CMessage& msg = msgs.back();
998	msg << serverAxisId;
999	msg << ni << begin;
1000	msg << isCompressible_;
1001
1002	event.push(*itRank,1,msg);
1003	}
1004	client->sendEvent(event);
1005	}
1006	else client->sendEvent(event);
1007	}
1008	CATCH_DUMP_ATTR
1009
1010	/*
1011	Receive distribution attribute from another client
1012	\param [in] event event containing data of these attributes
1013	*/
1014	void CAxis::recvDistributionAttribute(CEventServer& event)
1015	TRY
1016	{
1017	CBufferIn* buffer = event.subEvents.begin()->buffer;
1018	string axisId;
1019	*buffer >> axisId;
1020	get(axisId)->recvDistributionAttribute(*buffer);
1021	}
1022	CATCH
1023
1024	/*
1025	Receive distribution attribute from another client
1026	\param [in] buffer buffer containing data of these attributes
1027	*/
1028	void CAxis::recvDistributionAttribute(CBufferIn& buffer)
1029	TRY
1030	{
1031	int ni_srv, begin_srv;
1032	buffer >> ni_srv >> begin_srv;
1033	buffer >> isCompressible_;
1034
1035	// Set up new local size of axis on the receiving clients
1036	n.setValue(ni_srv);
1037	begin.setValue(begin_srv);
1038	}
1039	CATCH_DUMP_ATTR
1040
1041	/*
1042	Send attributes of axis from a group of client to other group of clients/servers
1043	on supposing that these attributes are not distributed among the sending group
1044	In the future, if new attributes are added, they should also be processed in this function
1045	*/
1046	void CAxis::sendNonDistributedAttributes(CContextClient* client, const string& axisId)
1047	TRY
1048	{
1049	string serverAxisId = axisId.empty() ? this->getId() : axisId ;
1050
1051	CEventClient event(getType(), EVENT_ID_NON_DISTRIBUTED_ATTRIBUTES);
1052	size_t nbIndex = index.numElements();
1053	size_t nbDataIndex = 0;
1054
1055	for (int idx = 0; idx < data_index.numElements(); ++idx)
1056	{
1057	int ind = data_index(idx);
1058	if (ind >= 0 && ind < nbIndex) ++nbDataIndex;
1059	}
1060
1061	CArray<int,1> dataIndex(nbDataIndex);
1062	nbDataIndex = 0;
1063	for (int idx = 0; idx < data_index.numElements(); ++idx)
1064	{
1065	int ind = data_index(idx);
1066	if (ind >= 0 && ind < nbIndex)
1067	{
1068	dataIndex(nbDataIndex) = ind;
1069	++nbDataIndex;
1070	}
1071	}
1072
1073	if (client->isServerLeader())
1074	{
1075	std::list<CMessage> msgs;
1076
1077	const std::list<int>& ranks = client->getRanksServerLeader();
1078	for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank)
1079	{
1080	msgs.push_back(CMessage());
1081	CMessage& msg = msgs.back();
1082	msg << serverAxisId;
1083	msg << index.getValue() << dataIndex << mask.getValue();
1084	msg << hasValue;
1085	if (hasValue) msg << value.getValue();
1086	msg << hasBounds;
1087	if (hasBounds) msg << bounds.getValue();
1088	msg << hasLabel;
1089	if (hasLabel) msg << label.getValue();
1090
1091	event.push(*itRank, 1, msg);
1092	}
1093	client->sendEvent(event);
1094	}
1095	else client->sendEvent(event);
1096	}
1097	CATCH_DUMP_ATTR
1098
1099	/*
1100	Receive the non-distributed attributes from another group of clients
1101	\param [in] event event containing data of these attributes
1102	*/
1103	void CAxis::recvNonDistributedAttributes(CEventServer& event)
1104	TRY
1105	{
1106	list<CEventServer::SSubEvent>::iterator it;
1107	for (it = event.subEvents.begin(); it != event.subEvents.end(); ++it)
1108	{
1109	CBufferIn* buffer = it->buffer;
1110	string axisId;
1111	*buffer >> axisId;
1112	get(axisId)->recvNonDistributedAttributes(it->rank, *buffer);
1113	}
1114	}
1115	CATCH
1116
1117	/*
1118	Receive the non-distributed attributes from another group of clients
1119	\param [in] rank rank of the sender
1120	\param [in] buffer buffer containing data sent from the sender
1121	*/
1122	void CAxis::recvNonDistributedAttributes(int rank, CBufferIn& buffer)
1123	TRY
1124	{
1125	CArray<int,1> tmp_index, tmp_data_index;
1126	CArray<bool,1> tmp_mask;
1127	CArray<double,1> tmp_val;
1128	CArray<double,2> tmp_bnds;
1129	CArray<string,1> tmp_label;
1130
1131	buffer >> tmp_index;
1132	index.reference(tmp_index);
1133	buffer >> tmp_data_index;
1134	data_index.reference(tmp_data_index);
1135	buffer >> tmp_mask;
1136	mask.reference(tmp_mask);
1137
1138	buffer >> hasValue;
1139	if (hasValue)
1140	{
1141	buffer >> tmp_val;
1142	value.reference(tmp_val);
1143	}
1144
1145	buffer >> hasBounds;
1146	if (hasBounds)
1147	{
1148	buffer >> tmp_bnds;
1149	bounds.reference(tmp_bnds);
1150	}
1151
1152	buffer >> hasLabel;
1153	if (hasLabel)
1154	{
1155	buffer >> tmp_label;
1156	label.reference(tmp_label);
1157	}
1158
1159	// Some value should be reset here
1160	data_begin.setValue(0);
1161	data_n.setValue(data_index.numElements());
1162	globalLocalIndexMap_.rehash(std::ceil(index.numElements()/globalLocalIndexMap_.max_load_factor()));
1163	// for (int idx = 0; idx < index.numElements(); ++idx) globalLocalIndexMap_[idx] = index(idx);
1164	for (int idx = 0; idx < index.numElements(); ++idx) globalLocalIndexMap_[index(idx)] = idx;
1165	}
1166	CATCH_DUMP_ATTR
1167
1168	/*
1169	Send axis attributes from a group of clients to another group of clients/servers
1170	supposing that these attributes are distributed among the clients of the sending group
1171	In future, if new attributes are added, they should also be processed in this function
1172	*/
1173	void CAxis::sendDistributedAttributes(CContextClient* client, const string& axisId)
1174	TRY
1175	{
1176	string serverAxisId = axisId.empty() ? this->getId() : axisId ;
1177
1178	int ind, idx;
1179	int nbServer = client->serverSize;
1180
1181	CEventClient eventData(getType(), EVENT_ID_DISTRIBUTED_ATTRIBUTES);
1182
1183	list<CMessage> listData;
1184	list<CArray<int,1> > list_indi, list_dataInd;
1185	list<CArray<double,1> > list_val;
1186	list<CArray<double,2> > list_bounds;
1187	list<CArray<string,1> > list_label;
1188
1189	// Cut off the ghost points
1190	int nbIndex = index.numElements();
1191	CArray<int,1> dataIndex(nbIndex);
1192	dataIndex = -1;
1193	for (idx = 0; idx < data_index.numElements(); ++idx)
1194	{
1195	if (0 <= data_index(idx) && data_index(idx) < nbIndex)
1196	dataIndex(data_index(idx)) = 1;
1197	}
1198
1199	std::unordered_map<int, std::vector<size_t> >::const_iterator it, iteMap;
1200	iteMap = indSrv_[nbServer].end();
1201	for (int k = 0; k < connectedServerRank_[nbServer].size(); ++k)
1202	{
1203	int nbData = 0, nbDataCount = 0;
1204	int rank = connectedServerRank_[nbServer][k];
1205	it = indSrv_[nbServer].find(rank);
1206	if (iteMap != it)
1207	nbData = it->second.size();
1208
1209	list_indi.push_back(CArray<int,1>(nbData));
1210	list_dataInd.push_back(CArray<int,1>(nbData));
1211
1212	if (hasValue)
1213	list_val.push_back(CArray<double,1>(nbData));
1214
1215	if (hasBounds)
1216	list_bounds.push_back(CArray<double,2>(2,nbData));
1217
1218	if (hasLabel)
1219	list_label.push_back(CArray<string,1>(nbData));
1220
1221	CArray<int,1>& indi = list_indi.back();
1222	CArray<int,1>& dataIndi = list_dataInd.back();
1223	dataIndi = -1;
1224
1225	for (int n = 0; n < nbData; ++n)
1226	{
1227	idx = static_cast<int>(it->second[n]);
1228	indi(n) = idx;
1229
1230	ind = globalLocalIndexMap_[idx];
1231	dataIndi(n) = dataIndex(ind);
1232
1233	if (hasValue)
1234	{
1235	CArray<double,1>& val = list_val.back();
1236	val(n) = value(ind);
1237	}
1238
1239	if (hasBounds)
1240	{
1241	CArray<double,2>& boundsVal = list_bounds.back();
1242	boundsVal(0, n) = bounds(0,ind);
1243	boundsVal(1, n) = bounds(1,ind);
1244	}
1245
1246	if (hasLabel)
1247	{
1248	CArray<string,1>& labelVal = list_label.back();
1249	labelVal(n) = label(ind);
1250	}
1251	}
1252
1253	listData.push_back(CMessage());
1254	listData.back() << serverAxisId
1255	<< list_indi.back() << list_dataInd.back();
1256
1257	listData.back() << hasValue;
1258	if (hasValue)
1259	listData.back() << list_val.back();
1260
1261	listData.back() << hasBounds;
1262	if (hasBounds)
1263	listData.back() << list_bounds.back();
1264
1265	listData.back() << hasLabel;
1266	if (hasLabel)
1267	listData.back() << list_label.back();
1268
1269	eventData.push(rank, nbSenders[nbServer][rank], listData.back());
1270	}
1271
1272	client->sendEvent(eventData);
1273	}
1274	CATCH_DUMP_ATTR
1275
1276	/*
1277	Receive the distributed attributes from another group of clients
1278	\param [in] event event containing data of these attributes
1279	*/
1280	void CAxis::recvDistributedAttributes(CEventServer& event)
1281	TRY
1282	{
1283	string axisId;
1284	vector<int> ranks;
1285	vector<CBufferIn*> buffers;
1286
1287	list<CEventServer::SSubEvent>::iterator it;
1288	for (it = event.subEvents.begin(); it != event.subEvents.end(); ++it)
1289	{
1290	ranks.push_back(it->rank);
1291	CBufferIn* buffer = it->buffer;
1292	*buffer >> axisId;
1293	buffers.push_back(buffer);
1294	}
1295	get(axisId)->recvDistributedAttributes(ranks, buffers);
1296	}
1297	CATCH
1298
1299	/*
1300	Receive the non-distributed attributes from another group of clients
1301	\param [in] ranks rank of the sender
1302	\param [in] buffers buffer containing data sent from the sender
1303	*/
1304	void CAxis::recvDistributedAttributes(vector<int>& ranks, vector<CBufferIn*> buffers)
1305	TRY
1306	{
1307	int nbReceived = ranks.size(), idx, ind, gloInd, locInd;
1308	vector<CArray<int,1> > vec_indi(nbReceived), vec_dataInd(nbReceived);
1309	vector<CArray<double,1> > vec_val(nbReceived);
1310	vector<CArray<double,2> > vec_bounds(nbReceived);
1311	vector<CArray<string,1> > vec_label(nbReceived);
1312
1313	for (idx = 0; idx < nbReceived; ++idx)
1314	{
1315	CBufferIn& buffer = *buffers[idx];
1316	buffer >> vec_indi[idx];
1317	buffer >> vec_dataInd[idx];
1318
1319	buffer >> hasValue;
1320	if (hasValue)
1321	buffer >> vec_val[idx];
1322
1323	buffer >> hasBounds;
1324	if (hasBounds)
1325	buffer >> vec_bounds[idx];
1326
1327	buffer >> hasLabel;
1328	if (hasLabel)
1329	buffer >> vec_label[idx];
1330	}
1331
1332	// Estimate size of index array
1333	int nbIndexGlob = 0;
1334	for (idx = 0; idx < nbReceived; ++idx)
1335	{
1336	nbIndexGlob += vec_indi[idx].numElements();
1337	}
1338
1339	// Recompute global index
1340	// Take account of the overlapped index
1341	index.resize(nbIndexGlob);
1342	globalLocalIndexMap_.rehash(std::ceil(index.numElements()/globalLocalIndexMap_.max_load_factor()));
1343	nbIndexGlob = 0;
1344	int nbIndLoc = 0;
1345	for (idx = 0; idx < nbReceived; ++idx)
1346	{
1347	CArray<int,1>& tmp = vec_indi[idx];
1348	for (ind = 0; ind < tmp.numElements(); ++ind)
1349	{
1350	gloInd = tmp(ind);
1351	nbIndLoc = (gloInd % n_glo)-begin;
1352	if (0 == globalLocalIndexMap_.count(gloInd))
1353	{
1354	index(nbIndexGlob) = gloInd % n_glo;
1355	globalLocalIndexMap_[gloInd] = nbIndexGlob;
1356	++nbIndexGlob;
1357	}
1358	}
1359	}
1360
1361	// Resize index to its real size
1362	if (nbIndexGlob==0) index.resize(nbIndexGlob) ;
1363	else index.resizeAndPreserve(nbIndexGlob);
1364
1365	int nbData = nbIndexGlob;
1366	CArray<int,1> nonCompressedData(nbData);
1367	nonCompressedData = -1;
1368	// Mask is incorporated into data_index and is not sent/received anymore
1369	mask.reset();
1370	if (hasValue)
1371	value.resize(nbData);
1372	if (hasBounds)
1373	bounds.resize(2,nbData);
1374	if (hasLabel)
1375	label.resize(nbData);
1376
1377	nbData = 0;
1378	for (idx = 0; idx < nbReceived; ++idx)
1379	{
1380	CArray<int,1>& indi = vec_indi[idx];
1381	CArray<int,1>& dataIndi = vec_dataInd[idx];
1382	int nb = indi.numElements();
1383	for (int n = 0; n < nb; ++n)
1384	{
1385	locInd = globalLocalIndexMap_[size_t(indi(n))];
1386
1387	nonCompressedData(locInd) = (-1 == nonCompressedData(locInd)) ? dataIndi(n) : nonCompressedData(locInd);
1388
1389	if (hasValue)
1390	value(locInd) = vec_val[idx](n);
1391
1392	if (hasBounds)
1393	{
1394	bounds(0,locInd) = vec_bounds[idx](0,n);
1395	bounds(1,locInd) = vec_bounds[idx](1,n);
1396	}
1397
1398	if (hasLabel)
1399	label(locInd) = vec_label[idx](n);
1400	}
1401	}
1402
1403	int nbCompressedData = 0;
1404	for (idx = 0; idx < nonCompressedData.numElements(); ++idx)
1405	{
1406	if (0 <= nonCompressedData(idx))
1407	++nbCompressedData;
1408	}
1409
1410	data_index.resize(nbCompressedData);
1411	nbCompressedData = 0;
1412	for (idx = 0; idx < nonCompressedData.numElements(); ++idx)
1413	{
1414	if (0 <= nonCompressedData(idx))
1415	{
1416	data_index(nbCompressedData) = idx % n;
1417	++nbCompressedData;
1418	}
1419	}
1420
1421	data_begin.setValue(0);
1422	data_n.setValue(data_index.numElements());
1423	}
1424	CATCH_DUMP_ATTR
1425
1426	/*!
1427	Compare two axis objects.
1428	They are equal if only if they have identical attributes as well as their values.
1429	Moreover, they must have the same transformations.
1430	\param [in] axis Compared axis
1431	\return result of the comparison
1432	*/
1433	bool CAxis::isEqual(CAxis* obj)
1434	TRY
1435	{
1436	vector<StdString> excludedAttr;
1437	excludedAttr.push_back("axis_ref");
1438
1439	bool objEqual = SuperClass::isEqual(obj, excludedAttr);
1440	if (!objEqual) return objEqual;
1441
1442	TransMapTypes thisTrans = this->getAllTransformations();
1443	TransMapTypes objTrans = obj->getAllTransformations();
1444
1445	TransMapTypes::const_iterator it, itb, ite;
1446	std::vector<ETranformationType> thisTransType, objTransType;
1447	for (it = thisTrans.begin(); it != thisTrans.end(); ++it)
1448	thisTransType.push_back(it->first);
1449	for (it = objTrans.begin(); it != objTrans.end(); ++it)
1450	objTransType.push_back(it->first);
1451
1452	if (thisTransType.size() != objTransType.size()) return false;
1453	for (int idx = 0; idx < thisTransType.size(); ++idx)
1454	objEqual &= (thisTransType[idx] == objTransType[idx]);
1455
1456	return objEqual;
1457	}
1458	CATCH_DUMP_ATTR
1459
1460	/*
1461	Add transformation into axis. This function only servers for Fortran interface
1462	\param [in] transType transformation type
1463	\param [in] id identifier of the transformation object
1464	*/
1465	CTransformation<CAxis>* CAxis::addTransformation(ETranformationType transType, const StdString& id)
1466	TRY
1467	{
1468	transformationMap_.push_back(std::make_pair(transType, CTransformation<CAxis>::createTransformation(transType,id)));
1469	return transformationMap_.back().second;
1470	}
1471	CATCH_DUMP_ATTR
1472
1473	/*
1474	Check whether an axis has (spatial) transformation
1475	*/
1476	bool CAxis::hasTransformation()
1477	TRY
1478	{
1479	return (!transformationMap_.empty());
1480	}
1481	CATCH_DUMP_ATTR
1482
1483	/*
1484	Set transformation
1485	\param [in] axisTrans transformation to set
1486	*/
1487	void CAxis::setTransformations(const TransMapTypes& axisTrans)
1488	TRY
1489	{
1490	transformationMap_ = axisTrans;
1491	}
1492	CATCH_DUMP_ATTR
1493
1494	/*
1495	Return all transformation held by the axis
1496	\return transformation the axis has
1497	*/
1498	CAxis::TransMapTypes CAxis::getAllTransformations(void)
1499	TRY
1500	{
1501	return transformationMap_;
1502	}
1503	CATCH_DUMP_ATTR
1504
1505	/*
1506	Duplicate transformation of another axis
1507	\param [in] src axis whose transformations are copied
1508	*/
1509	void CAxis::duplicateTransformation(CAxis* src)
1510	TRY
1511	{
1512	if (src->hasTransformation())
1513	{
1514	this->setTransformations(src->getAllTransformations());
1515	}
1516	}
1517	CATCH_DUMP_ATTR
1518
1519	/*!
1520	* Go through the hierarchy to find the axis from which the transformations must be inherited
1521	*/
1522	void CAxis::solveInheritanceTransformation()
1523	TRY
1524	{
1525	if (hasTransformation() \|\| !hasDirectAxisReference())
1526	return;
1527
1528	CAxis* axis = this;
1529	std::vector<CAxis*> refAxis;
1530	while (!axis->hasTransformation() && axis->hasDirectAxisReference())
1531	{
1532	refAxis.push_back(axis);
1533	axis = axis->getDirectAxisReference();
1534	}
1535
1536	if (axis->hasTransformation())
1537	for (size_t i = 0; i < refAxis.size(); ++i)
1538	refAxis[i]->setTransformations(axis->getAllTransformations());
1539	}
1540	CATCH_DUMP_ATTR
1541
1542	void CAxis::setContextClient(CContextClient* contextClient)
1543	TRY
1544	{
1545	if (clientsSet.find(contextClient)==clientsSet.end())
1546	{
1547	clients.push_back(contextClient) ;
1548	clientsSet.insert(contextClient);
1549	}
1550	}
1551	CATCH_DUMP_ATTR
1552
1553	void CAxis::parse(xml::CXMLNode & node)
1554	TRY
1555	{
1556	SuperClass::parse(node);
1557
1558	if (node.goToChildElement())
1559	{
1560	StdString nodeElementName;
1561	do
1562	{
1563	StdString nodeId("");
1564	if (node.getAttributes().end() != node.getAttributes().find("id"))
1565	{ nodeId = node.getAttributes()["id"]; }
1566
1567	nodeElementName = node.getElementName();
1568	std::map<StdString, ETranformationType>::const_iterator ite = transformationMapList_.end(), it;
1569	it = transformationMapList_.find(nodeElementName);
1570	if (ite != it)
1571	{
1572	transformationMap_.push_back(std::make_pair(it->second, CTransformation<CAxis>::createTransformation(it->second,
1573	nodeId,
1574	&node)));
1575	}
1576	else
1577	{
1578	ERROR("void CAxis::parse(xml::CXMLNode & node)",
1579	<< "The transformation " << nodeElementName << " has not been supported yet.");
1580	}
1581	} while (node.goToNextElement()) ;
1582	node.goToParentElement();
1583	}
1584	}
1585	CATCH_DUMP_ATTR
1586
1587	DEFINE_REF_FUNC(Axis,axis)
1588
1589	///---------------------------------------------------------------
1590
1591	} // namespace xios

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: XIOS/dev/dev_ym/XIOS_COUPLING/src/node/axis.cpp @ 1918

Download in other formats: