Context Navigation

domain.cpp @ 715

Last change on this file since 715 was 715, checked in by mhnguyen, 9 years ago

Temporary modification of auto-generate domain. This should be changed to a better solution

+) Divide a rectangular domain into parts being equal to number of procs

Test
+) On local with 2 procs, mode server and attached.
+) test_remap passes and result is correct

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: 64.3 KB

Line
1	#include "domain.hpp"
2
3	#include "attribute_template.hpp"
4	#include "object_template.hpp"
5	#include "group_template.hpp"
6
7	#include "xios_spl.hpp"
8	#include "event_client.hpp"
9	#include "event_server.hpp"
10	#include "buffer_in.hpp"
11	#include "message.hpp"
12	#include "type.hpp"
13	#include "context.hpp"
14	#include "context_client.hpp"
15	#include "context_server.hpp"
16	#include "array_new.hpp"
17	#include "distribution_client.hpp"
18	#include "server_distribution_description.hpp"
19	#include "client_server_mapping_distributed.hpp"
20	#include "zoom_domain.hpp"
21	#include "interpolate_domain.hpp"
22	#include "generate_rectilinear_domain.hpp"
23
24	#include <algorithm>
25
26	namespace xios {
27
28	/// ////////////////////// DÃ©finitions ////////////////////// ///
29
30	CDomain::CDomain(void)
31	: CObjectTemplate<CDomain>(), CDomainAttributes()
32	, isChecked(false), relFiles(), isClientChecked(false), nbConnectedClients_(), indSrv_(), connectedServerRank_()
33	, hasBounds(false), hasArea(false), isDistributed_(false), nGlobDomain_(), isCompressible_(false), isUnstructed_(false)
34	, global_zoom_ni(0), global_zoom_ibegin(0), global_zoom_nj(0), global_zoom_jbegin(0)
35	, isClientAfterTransformationChecked(false), hasLonLat(false)
36	, lonvalue_client(), latvalue_client(), bounds_lon_client(), bounds_lat_client()
37	, srcObject_(0), isRedistributed_(false)
38	{ /* Ne rien faire de plus */ }
39
40	CDomain::CDomain(const StdString & id)
41	: CObjectTemplate<CDomain>(id), CDomainAttributes()
42	, isChecked(false), relFiles(), isClientChecked(false), nbConnectedClients_(), indSrv_(), connectedServerRank_()
43	, hasBounds(false), hasArea(false), isDistributed_(false), nGlobDomain_(), isCompressible_(false), isUnstructed_(false)
44	, global_zoom_ni(0), global_zoom_ibegin(0), global_zoom_nj(0), global_zoom_jbegin(0)
45	, isClientAfterTransformationChecked(false), hasLonLat(false)
46	, lonvalue_client(), latvalue_client(), bounds_lon_client(), bounds_lat_client()
47	, srcObject_(0), isRedistributed_(false)
48	{ /* Ne rien faire de plus */ }
49
50	CDomain::~CDomain(void)
51	{
52	}
53
54	///---------------------------------------------------------------
55
56	CDomain* CDomain::createDomain()
57	{
58	CDomain* domain = CDomainGroup::get("domain_definition")->createChild();
59	return domain;
60	}
61
62	void CDomain::duplicateAttributes(CDomain* domain)
63	{
64	domain->setAttributes(this);
65	}
66
67	const std::set<StdString> & CDomain::getRelFiles(void) const
68	{
69	return (this->relFiles);
70	}
71
72	//----------------------------------------------------------------
73
74	const std::vector<int>& CDomain::getIndexesToWrite(void) const
75	{
76	return indexesToWrite;
77	}
78
79	/*!
80	Returns the number of indexes written by each server.
81	\return the number of indexes written by each server
82	*/
83	int CDomain::getNumberWrittenIndexes() const
84	{
85	return numberWrittenIndexes_;
86	}
87
88	/*!
89	Returns the total number of indexes written by the servers.
90	\return the total number of indexes written by the servers
91	*/
92	int CDomain::getTotalNumberWrittenIndexes() const
93	{
94	return totalNumberWrittenIndexes_;
95	}
96
97	/*!
98	Returns the offset of indexes written by each server.
99	\return the offset of indexes written by each server
100	*/
101	int CDomain::getOffsetWrittenIndexes() const
102	{
103	return offsetWrittenIndexes_;
104	}
105
106	//----------------------------------------------------------------
107
108	bool CDomain::isEmpty(void) const
109	{
110	return ((this->zoom_ni_srv == 0) \|\|
111	(this->zoom_nj_srv == 0));
112	}
113
114	//----------------------------------------------------------------
115
116	bool CDomain::IsWritten(const StdString & filename) const
117	{
118	return (this->relFiles.find(filename) != this->relFiles.end());
119	}
120
121	bool CDomain::isWrittenCompressed(const StdString& filename) const
122	{
123	return (this->relFilesCompressed.find(filename) != this->relFilesCompressed.end());
124	}
125
126	//----------------------------------------------------------------
127
128	bool CDomain::isDistributed(void) const
129	{
130	return isDistributed_;
131	}
132
133	//----------------------------------------------------------------
134
135	/*!
136	* Test whether the data defined on the domain can be outputted in a compressed way.
137	*
138	* \return true if and only if a mask was defined for this domain
139	*/
140	bool CDomain::isCompressible(void) const
141	{
142	return isCompressible_;
143	}
144
145	//----------------------------------------------------------------
146
147	void CDomain::addRelFile(const StdString & filename)
148	{
149	this->relFiles.insert(filename);
150	}
151
152	void CDomain::addRelFileCompressed(const StdString& filename)
153	{
154	this->relFilesCompressed.insert(filename);
155	}
156
157
158	StdString CDomain::GetName(void) { return (StdString("domain")); }
159	StdString CDomain::GetDefName(void){ return (CDomain::GetName()); }
160	ENodeType CDomain::GetType(void) { return (eDomain); }
161
162	//----------------------------------------------------------------
163
164	/*!
165	Redistribute RECTILINEAR domain with a number of local domains.
166	All attributes ni,nj,ibegin,jbegin (if defined) will be rewritten
167	The optional attributes lonvalue, latvalue will be added. Because this function only serves (for now)
168	for interpolation from unstructured domain to rectilinear one, range of latvalue is 0-360 and lonvalue is -90 - +90
169	\param [in] nbLocalDomain number of local domain on the domain destination
170	*/
171	void CDomain::redistribute(int nbLocalDomain)
172	{
173	if (this->isRedistributed_) return;
174	if (type_attr::rectilinear == type)
175	{
176	CContext* context = CContext::getCurrent();
177	CContextClient* client = context->client;
178	int rankClient = client->clientRank;
179	int rankOnDomain = rankClient%nbLocalDomain;
180
181	if (ni_glo.isEmpty() \|\| ni_glo <= 0 )
182	{
183	ERROR("CDomain::redistribute(int nbLocalDomain)",
184	<< "[ Id = " << this->getId() << " ] "
185	<< "The global domain is badly defined,"
186	<< " check the \'ni_glo\' value !")
187	}
188
189	if (nj_glo.isEmpty() \|\| nj_glo <= 0 )
190	{
191	ERROR("CDomain::redistribute(int nbLocalDomain)",
192	<< "[ Id = " << this->getId() << " ] "
193	<< "The global domain is badly defined,"
194	<< " check the \'nj_glo\' value !")
195	}
196
197	int globalDomainSize = ni_glo * nj_glo;
198	if (globalDomainSize <= nbLocalDomain)
199	{
200	for (int idx = 0; idx < nbLocalDomain; ++idx)
201	{
202	if (rankOnDomain < globalDomainSize)
203	{
204	int iIdx = rankOnDomain % ni_glo;
205	int jIdx = rankOnDomain / ni_glo;
206	ibegin.setValue(iIdx); jbegin.setValue(jIdx);
207	ni.setValue(1); nj.setValue(1);
208	}
209	else
210	{
211	ibegin.setValue(0); jbegin.setValue(0);
212	ni.setValue(0); nj.setValue(0);
213	}
214	}
215	}
216	else
217	{
218	float njGlo = nj_glo.getValue();
219	float niGlo = ni_glo.getValue();
220	int nbProcOnX, nbProcOnY, range;
221
222	// Compute (approximately) number of segment on x and y axis
223	float yOverXRatio = njGlo/niGlo;
224
225	nbProcOnX = std::ceil(std::sqrt(nbLocalDomain/yOverXRatio));
226	nbProcOnY = std::ceil(((float)nbLocalDomain)/nbProcOnX);
227
228	// Simple distribution: Sweep from top to bottom, left to right
229	// Calculate local begin on x
230	std::vector<int> ibeginVec(nbProcOnX,0), jbeginVec(nbProcOnY,0);
231	std::vector<int> niVec(nbProcOnX), njVec(nbProcOnY);
232	for (int i = 1; i < nbProcOnX; ++i)
233	{
234	range = ni_glo / nbProcOnX;
235	if (i < (ni_glo%nbProcOnX)) ++range;
236	niVec[i-1] = range;
237	ibeginVec[i] = ibeginVec[i-1] + niVec[i-1];
238	}
239	niVec[nbProcOnX-1] = ni_glo - ibeginVec[nbProcOnX-1];
240
241	// Calculate local begin on y
242	for (int j = 1; j < nbProcOnY; ++j)
243	{
244	range = nj_glo / nbProcOnY;
245	if (j < (nj_glo%nbProcOnY)) ++range;
246	njVec[j-1] = range;
247	jbeginVec[j] = jbeginVec[j-1] + njVec[j-1];
248	}
249	njVec[nbProcOnY-1] = nj_glo - jbeginVec[nbProcOnY-1];
250
251	// Now assign value to ni, ibegin, nj, jbegin
252	int iIdx = rankOnDomain % nbProcOnX;
253	int jIdx = rankOnDomain / nbProcOnX;
254
255	if (rankOnDomain != (nbLocalDomain-1))
256	{
257	ibegin.setValue(ibeginVec[iIdx]);
258	jbegin.setValue(jbeginVec[jIdx]);
259	nj.setValue(njVec[jIdx]);
260	ni.setValue(niVec[iIdx]);
261	}
262	else // just merge all the remaining rectangle into the last one
263	{
264	ibegin.setValue(ibeginVec[iIdx]);
265	jbegin.setValue(jbeginVec[jIdx]);
266	nj.setValue(njVec[jIdx]);
267	ni.setValue(ni_glo - ibeginVec[iIdx]);
268	}
269	}
270
271	// Now fill other attributes
272	fillInRectilinearLonLat();
273	this->isRedistributed_ = true;
274	info <<"now, we are here " << std::endl;
275	info << "domain " << this->getId() << " ni " << ni.getValue() << " nj " << nj.getValue() << std::endl;
276	}
277	}
278
279	/*!
280	Fill in the values for lonvalue_1d and latvalue_1d of rectilinear domain
281	Range of longitude value from 0 - 360
282	Range of latitude value from -90 - +90
283	*/
284	void CDomain::fillInRectilinearLonLat()
285	{
286	if (!lonvalue_2d.isEmpty()) lonvalue_2d.free();
287	if (!latvalue_2d.isEmpty()) latvalue_1d.free();
288	lonvalue_1d.resize(ni);
289	latvalue_1d.resize(nj);
290
291	double lonStep = double(360/ni_glo.getValue());
292	double latStep = double(180/nj_glo.getValue());
293
294	// Assign lon value
295	for (int i = 0; i < ni; ++i)
296	{
297	lonvalue_1d(i) = static_cast<double>(ibegin + i) * lonStep -180 + lonStep/2;
298	}
299
300	for (int j = 0; j < nj; ++j)
301	{
302	latvalue_1d(j) = static_cast<double>(jbegin + j) * latStep - 90 + latStep/2;
303	}
304	}
305
306	void CDomain::fillInRectilinearBoundLonLat(CArray<double,2>& boundsLon, CArray<double,2>& boundsLat)
307	{
308	int i,j,k;
309	const int nvertexValue = 4;
310
311	boundsLon.resize(nvertexValue,ni*nj);
312	boundsLat.resize(nvertexValue,nj*ni);
313
314	double lonStep = double(360/ni_glo.getValue());
315	double latStep = double(180/nj_glo.getValue());
316
317	for(j=0;j<nj;++j)
318	for(i=0;i<ni;++i)
319	{
320	k=j*ni+i;
321	boundsLon(0,k) = boundsLon(1,k) = (0 != (ibegin + i)) ? (ibegin + i) * lonStep -180
322	: -180;
323	boundsLon(2,k) = boundsLon(3,k) = ((ibegin + i + 1) != ni_glo) ? (ibegin + i +1) * lonStep -180
324	: 180;
325
326	boundsLat(1,k) = boundsLat(2,k) = (0 != (jbegin + j)) ? (jbegin + j) * latStep - 90
327	: -90;
328	boundsLat(0,k) = boundsLat(3,k) = ((jbegin + j +1) != nj_glo) ? (jbegin + j +1) * latStep - 90
329	: +90;
330	}
331	}
332
333	/*!
334	Temporary function to verify whether a rectilinear domain is created automatically.
335	The domain is distributed into number of parts which are equal to number of clients (intracomm)
336	*/
337	void CDomain::checkGenerate()
338	{
339	TransMapTypes trans = this->getAllTransformations();
340	TransMapTypes::const_iterator it = trans.begin(), ite = trans.end();
341	int transOrder = 0;
342	for (; it != ite; ++it, ++transOrder)
343	{
344	ETranformationType transType = it->first;
345	if ((TRANS_GENERATE_RECTILINEAR_DOMAIN == transType) && (0 == transOrder))
346	{
347	CContext* context = CContext::getCurrent();
348	CContextClient* client = context->client;
349	int nbClient;
350	MPI_Comm_size(client->intraComm,&nbClient);
351	this->redistribute(nbClient);
352	break;
353	}
354	}
355	}
356
357
358	void CDomain::checkDomain(void)
359	{
360	if (type.isEmpty())
361	{
362	ERROR("CDomain::checkDomain(void)",
363	<< "[ id = " << this->getId() << " , context = '" << CObjectFactory::GetCurrentContextId() << " ] "
364	<< "The domain type is mandatory, "
365	<< "please define the 'type' attribute.")
366	}
367
368	if (type == type_attr::unstructured)
369	{
370	if (ni_glo.isEmpty())
371	{
372	ERROR("CDomain::checkDomain(void)",
373	<< "[ id = " << this->getId() << " , context = '" << CObjectFactory::GetCurrentContextId() << " ] "
374	<< "The global domain is badly defined, "
375	<< "the mandatory 'ni_glo' attribute is missing.")
376	}
377	else if (ni_glo <= 0)
378	{
379	ERROR("CDomain::checkDomain(void)",
380	<< "[ id = " << this->getId() << " , context = '" << CObjectFactory::GetCurrentContextId() << " ] "
381	<< "The global domain is badly defined, "
382	<< "'ni_glo' attribute should be strictly positive so 'ni_glo = " << ni_glo.getValue() << "' is invalid.")
383	}
384	isUnstructed_ = true;
385	nj_glo = 1;
386	nj = 1;
387	jbegin = 0;
388	if (ni.isEmpty()) ni = i_index.numElements();
389	j_index.resize(ni);
390	for(int i=0;i<ni;++i) j_index(i)=0;
391
392	if (!area.isEmpty())
393	area.transposeSelf(1, 0);
394	}
395
396	if (ni_glo.isEmpty())
397	{
398	ERROR("CDomain::checkDomain(void)",
399	<< "[ id = " << this->getId() << " , context = '" << CObjectFactory::GetCurrentContextId() << " ] "
400	<< "The global domain is badly defined, "
401	<< "the mandatory 'ni_glo' attribute is missing.")
402	}
403	else if (ni_glo <= 0)
404	{
405	ERROR("CDomain::checkDomain(void)",
406	<< "[ id = " << this->getId() << " , context = '" << CObjectFactory::GetCurrentContextId() << " ] "
407	<< "The global domain is badly defined, "
408	<< "'ni_glo' attribute should be strictly positive so 'ni_glo = " << ni_glo.getValue() << "' is invalid.")
409	}
410
411	if (nj_glo.isEmpty())
412	{
413	ERROR("CDomain::checkDomain(void)",
414	<< "[ id = " << this->getId() << " , context = '" << CObjectFactory::GetCurrentContextId() << " ] "
415	<< "The global domain is badly defined, "
416	<< "the mandatory 'nj_glo' attribute is missing.")
417	}
418	else if (nj_glo <= 0)
419	{
420	ERROR("CDomain::checkDomain(void)",
421	<< "[ id = " << this->getId() << " , context = '" << CObjectFactory::GetCurrentContextId() << " ] "
422	<< "The global domain is badly defined, "
423	<< "'nj_glo' attribute should be strictly positive so 'nj_glo = " << nj_glo.getValue() << "' is invalid.")
424	}
425
426	isDistributed_ = !ibegin.isEmpty() \|\| !ni.isEmpty() \|\| !jbegin.isEmpty() \|\| !nj.isEmpty();
427
428	checkLocalIDomain();
429	checkLocalJDomain();
430
431	if (i_index.isEmpty())
432	{
433	i_index.resize(ni*nj);
434	for (int j = 0; j < nj; ++j)
435	for (int i = 0; i < ni; ++i) i_index(i+j*ni) = i+ibegin;
436	}
437
438	if (j_index.isEmpty())
439	{
440	j_index.resize(ni*nj);
441	for (int j = 0; j < nj; ++j)
442	for (int i = 0; i < ni; ++i) j_index(i+j*ni) = j+jbegin;
443	}
444	computeNGlobDomain();
445
446	if (0 == global_zoom_ni) global_zoom_ni = ni_glo;
447	if (0 == global_zoom_nj) global_zoom_nj = nj_glo;
448	}
449
450	//----------------------------------------------------------------
451
452	void CDomain::checkLocalIDomain(void)
453	{
454	if (ibegin.isEmpty() && ni.isEmpty())
455	{
456	ibegin = 0;
457	ni = ni_glo;
458	}
459	else if (!i_index.isEmpty())
460	{
461	if (ibegin.isEmpty()) ibegin = i_index(0);
462	}
463
464	if (ni.getValue() < 0 \|\| ibegin.getValue() < 0 \|\|
465	(ibegin.getValue() + ni.getValue()) > ni_glo.getValue())
466	{
467	ERROR("CDomain::checkLocalIDomain(void)",
468	<< "[ id = " << this->getId() << " , context = '" << CObjectFactory::GetCurrentContextId() << " ] "
469	<< "The local domain is wrongly defined,"
470	<< " check the attributes 'ni_glo' (" << ni_glo.getValue() << "), 'ni' (" << ni.getValue() << ") and 'ibegin' (" << ibegin.getValue() << ")");
471	}
472	}
473
474	void CDomain::checkLocalJDomain(void)
475	{
476	if (jbegin.isEmpty() && nj.isEmpty())
477	{
478	jbegin = 0;
479	nj = nj_glo;
480	}
481	else if (!j_index.isEmpty())
482	{
483	if (jbegin.isEmpty()) jbegin = j_index(0);
484	}
485
486	if (nj.getValue() < 0 \|\| jbegin.getValue() < 0 \|\|
487	(jbegin.getValue() + nj.getValue()) > nj_glo.getValue())
488	{
489	ERROR("CDomain::checkLocalJDomain(void)",
490	<< "[ id = " << this->getId() << " , context = '" << CObjectFactory::GetCurrentContextId() << " ] "
491	<< "The local domain is wrongly defined,"
492	<< " check the attributes 'nj_glo' (" << nj_glo.getValue() << "), 'nj' (" << nj.getValue() << ") and 'jbegin' (" << jbegin.getValue() << ")");
493	}
494	}
495
496	//----------------------------------------------------------------
497
498	void CDomain::checkMask(void)
499	{
500	if (!mask_1d.isEmpty() && !mask_2d.isEmpty())
501	ERROR("CDomain::checkMask(void)",
502	<< "[ id = " << this->getId() << " , context = '" << CObjectFactory::GetCurrentContextId() << " ] "
503	<< "Both mask_1d and mask_2d are defined but only one can be used at the same time." << std::endl
504	<< "Please define only one mask: 'mask_1d' or 'mask_2d'.");
505
506	if (!mask_1d.isEmpty() && mask_2d.isEmpty())
507	{
508	if (mask_1d.numElements() != i_index.numElements())
509	ERROR("CDomain::checkMask(void)",
510	<< "[ id = " << this->getId() << " , context = '" << CObjectFactory::GetCurrentContextId() << " ] "
511	<< "'mask_1d' does not have the same size as the local domain." << std::endl
512	<< "Local size is " << i_index.numElements() << "." << std::endl
513	<< "Mask size is " << mask_1d.numElements() << ".");
514	}
515
516	if (mask_1d.isEmpty() && !mask_2d.isEmpty())
517	{
518	if (mask_2d.extent(0) != ni \|\| mask_2d.extent(1) != nj)
519	ERROR("CDomain::checkMask(void)",
520	<< "[ id = " << this->getId() << " , context = '" << CObjectFactory::GetCurrentContextId() << " ] "
521	<< "The mask does not have the same size as the local domain." << std::endl
522	<< "Local size is " << ni.getValue() << " x " << nj.getValue() << "." << std::endl
523	<< "Mask size is " << mask_2d.extent(0) << " x " << mask_2d.extent(1) << ".");
524	}
525
526	if (!mask_2d.isEmpty())
527	{
528	mask_1d.resize(mask_2d.extent(0) * mask_2d.extent(1));
529	for (int j = 0; j < nj; ++j)
530	for (int i = 0; i < ni; ++i) mask_1d(i+j*ni) = mask_2d(i,j);
531	mask_2d.free();
532	}
533	else if (mask_1d.isEmpty())
534	{
535	mask_1d.resize(i_index.numElements());
536	for (int i = 0; i < i_index.numElements(); ++i) mask_1d(i) = true;
537	}
538	}
539
540	//----------------------------------------------------------------
541
542	void CDomain::checkDomainData(void)
543	{
544	if (data_dim.isEmpty())
545	{
546	data_dim.setValue(1);
547	}
548	else if (!(data_dim.getValue() == 1 \|\| data_dim.getValue() == 2))
549	{
550	ERROR("CDomain::checkDomainData(void)",
551	<< "[ id = " << this->getId() << " , context = '" << CObjectFactory::GetCurrentContextId() << " ] "
552	<< "The data dimension is invalid, 'data_dim' must be 1 or 2 not << " << data_dim.getValue() << ".");
553	}
554
555	if (data_ibegin.isEmpty())
556	data_ibegin.setValue(0);
557	if (data_jbegin.isEmpty())
558	data_jbegin.setValue(0);
559
560	if (data_ni.isEmpty())
561	{
562	data_ni.setValue((data_dim == 1) ? (ni.getValue() * nj.getValue()) : ni.getValue());
563	}
564	else if (data_ni.getValue() < 0)
565	{
566	ERROR("CDomain::checkDomainData(void)",
567	<< "[ id = " << this->getId() << " , context = '" << CObjectFactory::GetCurrentContextId() << " ] "
568	<< "The data size cannot be negative ('data_ni' = " << data_ni.getValue() << ").");
569	}
570
571	if (data_nj.isEmpty())
572	{
573	data_nj.setValue((data_dim.getValue() == 1) ? (ni.getValue() * nj.getValue()) : nj.getValue());
574	}
575	else if (data_nj.getValue() < 0)
576	{
577	ERROR("CDomain::checkDomainData(void)",
578	<< "[ id = " << this->getId() << " , context = '" << CObjectFactory::GetCurrentContextId() << " ] "
579	<< "The data size cannot be negative ('data_nj' = " << data_nj.getValue() << ").");
580	}
581	}
582
583	//----------------------------------------------------------------
584
585	void CDomain::checkCompression(void)
586	{
587	if (!data_i_index.isEmpty())
588	{
589	if (!data_j_index.isEmpty() &&
590	data_j_index.numElements() != data_i_index.numElements())
591	{
592	ERROR("CDomain::checkCompression(void)",
593	<< "[ id = " << this->getId() << " , context = '" << CObjectFactory::GetCurrentContextId() << " ] "
594	<< "'data_i_index' and 'data_j_index' arrays must have the same size." << std::endl
595	<< "'data_i_index' size = " << data_i_index.numElements() << std::endl
596	<< "'data_j_index' size = " << data_j_index.numElements());
597	}
598
599	if (2 == data_dim)
600	{
601	if (data_j_index.isEmpty())
602	{
603	ERROR("CDomain::checkCompression(void)",
604	<< "[ id = " << this->getId() << " , context = '" << CObjectFactory::GetCurrentContextId() << " ] "
605	<< "'data_j_index' must be defined when 'data_i_index' is set and 'data_dim' is 2.");
606	}
607	}
608	else // (1 == data_dim)
609	{
610	if (data_j_index.isEmpty())
611	{
612	data_j_index.resize(data_ni);
613	for (int j = 0; j < data_ni; ++j) data_j_index(j) = 0;
614	}
615	}
616	}
617	else
618	{
619	if (data_dim == 2 && !data_j_index.isEmpty())
620	ERROR("CDomain::checkCompression(void)",
621	<< "[ id = " << this->getId() << " , context = '" << CObjectFactory::GetCurrentContextId() << " ] "
622	<< "'data_i_index' must be defined when 'data_j_index' is set and 'data_dim' is 2.");
623
624	if (1 == data_dim)
625	{
626	data_i_index.resize(data_ni);
627	data_j_index.resize(data_ni);
628
629	for (int i = 0; i < data_ni; ++i)
630	{
631	data_i_index(i) = i;
632	data_j_index(i) = 0;
633	}
634	}
635	else // (data_dim == 2)
636	{
637	const int dsize = data_ni * data_nj;
638	data_i_index.resize(dsize);
639	data_j_index.resize(dsize);
640
641	for(int count = 0, j = 0; j < data_nj; ++j)
642	{
643	for(int i = 0; i < data_ni; ++i, ++count)
644	{
645	data_i_index(count) = i;
646	data_j_index(count) = j;
647	}
648	}
649	}
650	}
651	}
652
653	//----------------------------------------------------------------
654
655	void CDomain::checkEligibilityForCompressedOutput(void)
656	{
657	// We don't check if the mask or the indexes are valid here, just if they have been defined at this point.
658	isCompressible_ = !mask_1d.isEmpty() \|\| !mask_2d.isEmpty() \|\| !data_i_index.isEmpty();
659	}
660
661	//----------------------------------------------------------------
662
663	void CDomain::completeLonLatClient(void)
664	{
665	int i,j,k ;
666	CArray<double,1> lonvalue_temp(ni * nj);
667	CArray<double,2> bounds_lon_temp(nvertex, ni * nj);
668	CArray<double,1> latvalue_temp(ni * nj);
669	CArray<double,2> bounds_lat_temp(nvertex, ni * nj);
670
671	if (!lonvalue_2d.isEmpty())
672	{
673	for (j = 0; j < nj; ++j)
674	for (i = 0; i < ni; ++i)
675	{
676	lonvalue_temp(i + j * ni) = lonvalue_2d(i,j);
677	latvalue_temp(i + j * ni) = latvalue_2d(i,j);
678	if (hasBounds)
679	{
680	k = j * ni + i;
681	for (int n = 0; n < nvertex; ++n)
682	{
683	bounds_lon_temp(n,k) = bounds_lon_2d(n,i,j);
684	bounds_lat_temp(n,k) = bounds_lat_2d(n,i,j);
685	}
686	}
687	}
688	lonvalue_1d.free();
689	}
690
691	if (!lonvalue_1d.isEmpty())
692	{
693	if (type_attr::rectilinear == type)
694	{
695	if (ni == lonvalue_1d.numElements() && nj == latvalue_1d.numElements())
696	{
697	for (j = 0; j < nj; ++j)
698	for (i = 0; i < ni; ++i)
699	{
700	k = j * ni + i;
701	lonvalue_temp(k) = lonvalue_1d(i);
702	latvalue_temp(k) = latvalue_1d(j);
703	if (hasBounds)
704	{
705	for (int n = 0; n < nvertex; ++n)
706	{
707	bounds_lon_temp(n,k) = bounds_lon_1d(n,i);
708	bounds_lat_temp(n,k) = bounds_lat_1d(n,j);
709	}
710	}
711	}
712	}
713	else
714	ERROR("CDomain::completeLonClient(void)",
715	<< "[ id = " << this->getId() << " , context = '" << CObjectFactory::GetCurrentContextId() << " ] "
716	<< "'lonvalue_1d' and 'latvalue_1d' does not have the same size as the local domain." << std::endl
717	<< "'lonvalue_1d' size is " << lonvalue_1d.numElements() << " but it should be " << ni.getValue() << '.' << std::endl
718	<< "'latvalue_1d' size is " << latvalue_1d.numElements() << " but it should be " << nj.getValue() << '.');
719	}
720	else if (type == type_attr::curvilinear \|\| type == type_attr::unstructured)
721	{
722	lonvalue_temp = lonvalue_1d;
723	latvalue_temp = latvalue_1d;
724	if (hasBounds)
725	{
726	bounds_lon_temp = bounds_lon_1d;
727	bounds_lat_temp = bounds_lat_1d;
728	}
729	}
730	lonvalue_2d.free();
731	}
732
733	int i_ind,j_ind;
734	int global_zoom_iend=global_zoom_ibegin+global_zoom_ni-1;
735	int global_zoom_jend=global_zoom_jbegin+global_zoom_nj-1;
736
737	int globalIndexCountZoom = 0;
738	int nbIndex = i_index.numElements();
739	for (i = 0; i < nbIndex; ++i)
740	{
741	i_ind=i_index(i);
742	j_ind=j_index(i);
743
744	if (i_ind >= global_zoom_ibegin && i_ind <= global_zoom_iend && j_ind >= global_zoom_jbegin && j_ind <= global_zoom_jend)
745	{
746	++globalIndexCountZoom;
747	}
748	}
749
750	// Make sure that this attribute is non-empty for every client.
751	if (0 != globalIndexCountZoom)
752	{
753	lonvalue_client.resize(globalIndexCountZoom);
754	latvalue_client.resize(globalIndexCountZoom);
755	if (hasBounds)
756	{
757	bounds_lon_client.resize(nvertex,globalIndexCountZoom);
758	bounds_lat_client.resize(nvertex,globalIndexCountZoom);
759	}
760	}
761
762	int nCountZoom = 0;
763	for (i = 0; i < nbIndex; ++i)
764	{
765	i_ind=i_index(i);
766	j_ind=j_index(i);
767
768	if (i_ind >= global_zoom_ibegin && i_ind <= global_zoom_iend && j_ind >= global_zoom_jbegin && j_ind <= global_zoom_jend)
769	{
770	lonvalue_client(nCountZoom) = lonvalue_temp(i);
771	latvalue_client(nCountZoom) = latvalue_temp(i);
772	if (hasBounds)
773	{
774	for (int n = 0; n < nvertex; ++n)
775	{
776	bounds_lon_client(n,nCountZoom) = bounds_lon_temp(n,i);
777	bounds_lat_client(n,nCountZoom) = bounds_lat_temp(n,i);
778	}
779	}
780	++nCountZoom;
781	}
782	}
783	}
784
785	void CDomain::checkBounds(void)
786	{
787	if (!nvertex.isEmpty() && nvertex > 0)
788	{
789	if (!bounds_lon_1d.isEmpty() && !bounds_lon_2d.isEmpty())
790	ERROR("CDomain::checkBounds(void)",
791	<< "[ id = " << this->getId() << " , context = '" << CObjectFactory::GetCurrentContextId() << " ] "
792	<< "Only one longitude boundary attribute can be used but both 'bounds_lon_1d' and 'bounds_lon_2d' are defined." << std::endl
793	<< "Define only one longitude boundary attribute: 'bounds_lon_1d' or 'bounds_lon_2d'.");
794
795	if (!bounds_lat_1d.isEmpty() && !bounds_lat_2d.isEmpty())
796	ERROR("CDomain::checkBounds(void)",
797	<< "[ id = " << this->getId() << " , context = '" << CObjectFactory::GetCurrentContextId() << " ] "
798	<< "Only one latitude boundary attribute can be used but both 'bounds_lat_1d' and 'bounds_lat_2d' are defined." << std::endl
799	<< "Define only one latitude boundary attribute: 'bounds_lat_1d' or 'bounds_lat_2d'.");
800
801	if ((!bounds_lon_1d.isEmpty() && bounds_lat_1d.isEmpty()) \|\| (bounds_lon_1d.isEmpty() && !bounds_lat_1d.isEmpty()))
802	{
803	ERROR("CDomain::checkBounds(void)",
804	<< "[ id = " << this->getId() << " , context = '" << CObjectFactory::GetCurrentContextId() << " ] "
805	<< "Only 'bounds_lon_1d' or 'bounds_lat_1d' is defined." << std::endl
806	<< "Please define either both attributes or none.");
807	}
808
809	if ((!bounds_lon_2d.isEmpty() && bounds_lat_2d.isEmpty()) \|\| (bounds_lon_2d.isEmpty() && !bounds_lat_2d.isEmpty()))
810	{
811	ERROR("CDomain::checkBounds(void)",
812	<< "[ id = " << this->getId() << " , context = '" << CObjectFactory::GetCurrentContextId() << " ] "
813	<< "Only 'bounds_lon_2d' or 'bounds_lat_2d' is defined." << std::endl
814	<< "Please define either both attributes or none.");
815	}
816
817	if (!bounds_lon_1d.isEmpty() && nvertex.getValue() != bounds_lon_1d.extent(0))
818	ERROR("CDomain::checkBounds(void)",
819	<< "[ id = " << this->getId() << " , context = '" << CObjectFactory::GetCurrentContextId() << " ] "
820	<< "'bounds_lon_1d' dimension is not compatible with 'nvertex'." << std::endl
821	<< "'bounds_lon_1d' dimension is " << bounds_lon_1d.extent(1)
822	<< " but nvertex is " << nvertex.getValue() << ".");
823
824	if (!bounds_lon_2d.isEmpty() && nvertex.getValue() != bounds_lon_2d.extent(0))
825	ERROR("CDomain::checkBounds(void)",
826	<< "[ id = " << this->getId() << " , context = '" << CObjectFactory::GetCurrentContextId() << " ] "
827	<< "'bounds_lon_2d' dimension is not compatible with 'nvertex'." << std::endl
828	<< "'bounds_lon_2d' dimension is " << bounds_lon_2d.extent(2)
829	<< " but nvertex is " << nvertex.getValue() << ".");
830
831	if (!bounds_lon_1d.isEmpty() && lonvalue_1d.isEmpty())
832	ERROR("CDomain::checkBounds(void)",
833	<< "[ id = " << this->getId() << " , context = '" << CObjectFactory::GetCurrentContextId() << " ] "
834	<< "Since 'bounds_lon_1d' is defined, 'lonvalue_1d' must be defined too." << std::endl);
835
836	if (!bounds_lon_2d.isEmpty() && lonvalue_2d.isEmpty())
837	ERROR("CDomain::checkBounds(void)",
838	<< "[ id = " << this->getId() << " , context = '" << CObjectFactory::GetCurrentContextId() << " ] "
839	<< "Since 'bounds_lon_2d' is defined, 'lonvalue_2d' must be defined too." << std::endl);
840
841	if (!bounds_lat_1d.isEmpty() && nvertex.getValue() != bounds_lat_1d.extent(0))
842	ERROR("CDomain::checkBounds(void)",
843	<< "[ id = " << this->getId() << " , context = '" << CObjectFactory::GetCurrentContextId() << " ] "
844	<< "'bounds_lat_1d' dimension is not compatible with 'nvertex'." << std::endl
845	<< "'bounds_lat_1d' dimension is " << bounds_lat_1d.extent(1)
846	<< " but nvertex is " << nvertex.getValue() << ".");
847
848	if (!bounds_lat_2d.isEmpty() && nvertex.getValue() != bounds_lat_2d.extent(0))
849	ERROR("CDomain::checkBounds(void)",
850	<< "[ id = " << this->getId() << " , context = '" << CObjectFactory::GetCurrentContextId() << " ] "
851	<< "'bounds_lat_2d' dimension is not compatible with 'nvertex'." << std::endl
852	<< "'bounds_lat_2d' dimension is " << bounds_lat_2d.extent(2)
853	<< " but nvertex is " << nvertex.getValue() << ".");
854
855	if (!bounds_lat_1d.isEmpty() && latvalue_1d.isEmpty())
856	ERROR("CDomain::checkBounds(void)",
857	<< "[ id = " << this->getId() << " , context = '" << CObjectFactory::GetCurrentContextId() << " ] "
858	<< "Since 'bounds_lat_1d' is defined, 'latvalue_1d' must be defined too." << std::endl);
859
860	if (!bounds_lat_2d.isEmpty() && latvalue_2d.isEmpty())
861	ERROR("CDomain::checkBounds(void)",
862	<< "Since 'bounds_lat_2d' is defined, 'latvalue_2d' must be defined too." << std::endl);
863
864	hasBounds = true;
865	}
866	else
867	{
868	hasBounds = false;
869	nvertex = 0;
870	}
871	}
872
873	void CDomain::checkArea(void)
874	{
875	hasArea = !area.isEmpty();
876	if (hasArea)
877	{
878	if (area.extent(0) != ni \|\| area.extent(1) != nj)
879	{
880	ERROR("CDomain::checkArea(void)",
881	<< "[ id = " << this->getId() << " , context = '" << CObjectFactory::GetCurrentContextId() << " ] "
882	<< "The area does not have the same size as the local domain." << std::endl
883	<< "Local size is " << ni.getValue() << " x " << nj.getValue() << "." << std::endl
884	<< "Area size is " << area.extent(0) << " x " << area.extent(1) << ".");
885	}
886	}
887	}
888
889	void CDomain::checkLonLat()
890	{
891	hasLonLat = (!latvalue_1d.isEmpty() && !lonvalue_1d.isEmpty()) \|\|
892	(!latvalue_2d.isEmpty() && !lonvalue_2d.isEmpty());
893	if (hasLonLat)
894	{
895	if (!lonvalue_1d.isEmpty() && !lonvalue_2d.isEmpty())
896	ERROR("CDomain::completeLonLatClient(void)",
897	<< "[ id = " << this->getId() << " , context = '" << CObjectFactory::GetCurrentContextId() << " ] "
898	<< "Only one longitude attribute can be used but both 'lonvalue_1d' and 'lonvalue_2d' are defined." << std::endl
899	<< "Define only one longitude attribute: 'lonvalue_1d' or 'lonvalue_2d'.");
900
901	if (!lonvalue_1d.isEmpty() && lonvalue_2d.isEmpty())
902	{
903	if ((type_attr::rectilinear != type) && (lonvalue_1d.numElements() != i_index.numElements()))
904	ERROR("CDomain::completeLonLatClient(void)",
905	<< "[ id = " << this->getId() << " , context = '" << CObjectFactory::GetCurrentContextId() << " ] "
906	<< "'lonvalue_1d' does not have the same size as the local domain." << std::endl
907	<< "Local size is " << i_index.numElements() << "." << std::endl
908	<< "'lonvalue_1d' size is " << lonvalue_1d.numElements() << ".");
909	}
910
911	if (lonvalue_1d.isEmpty() && !lonvalue_2d.isEmpty())
912	{
913	if (lonvalue_2d.extent(0) != ni \|\| lonvalue_2d.extent(1) != nj)
914	ERROR("CDomain::completeLonLatClient(void)",
915	<< "[ id = " << this->getId() << " , context = '" << CObjectFactory::GetCurrentContextId() << " ] "
916	<< "'lonvalue_2d' does not have the same size as the local domain." << std::endl
917	<< "Local size is " << ni.getValue() << " x " << nj.getValue() << "." << std::endl
918	<< "'lonvalue_2d' size is " << lonvalue_2d.extent(0) << " x " << lonvalue_2d.extent(1) << ".");
919	}
920
921	if (!latvalue_1d.isEmpty() && !latvalue_2d.isEmpty())
922	ERROR("CDomain::completeLonLatClient(void)",
923	<< "[ id = " << this->getId() << " , context = '" << CObjectFactory::GetCurrentContextId() << " ] "
924	<< "Only one latitude attribute can be used but both 'latvalue_1d' and 'latvalue_2d' are defined." << std::endl
925	<< "Define only one latitude attribute: 'latvalue_1d' or 'latvalue_2d'.");
926
927	if (!latvalue_1d.isEmpty() && latvalue_2d.isEmpty())
928	{
929	if ((type_attr::rectilinear != type) && (latvalue_1d.numElements() != i_index.numElements()))
930	ERROR("CDomain::completeLonLatClient(void)",
931	<< "[ id = " << this->getId() << " , context = '" << CObjectFactory::GetCurrentContextId() << " ] "
932	<< "'latvalue_1d' does not have the same size as the local domain." << std::endl
933	<< "Local size is " << i_index.numElements() << "." << std::endl
934	<< "'latvalue_1d' size is " << latvalue_1d.numElements() << ".");
935	}
936
937	if (latvalue_1d.isEmpty() && !latvalue_2d.isEmpty())
938	{
939	if (latvalue_2d.extent(0) != ni \|\| latvalue_2d.extent(1) != nj)
940	ERROR("CDomain::completeLonLatClient(void)",
941	<< "[ id = " << this->getId() << " , context = '" << CObjectFactory::GetCurrentContextId() << " ] "
942	<< "'latvalue_2d' does not have the same size as the local domain." << std::endl
943	<< "Local size is " << ni.getValue() << " x " << nj.getValue() << "." << std::endl
944	<< "'latvalue_2d' size is " << latvalue_2d.extent(0) << " x " << latvalue_2d.extent(1) << ".");
945	}
946	}
947	}
948
949	void CDomain::checkAttributesOnClientAfterTransformation()
950	{
951	CContext* context=CContext::getCurrent() ;
952
953	if (this->isClientAfterTransformationChecked) return;
954	if (context->hasClient)
955	{
956	this->checkMask();
957	if (hasLonLat \|\| hasArea) this->computeConnectedServer();
958	if (hasLonLat) this->completeLonLatClient();
959	}
960
961	this->isClientAfterTransformationChecked = true;
962	}
963
964	//----------------------------------------------------------------
965	// Divide function checkAttributes into 2 seperate ones
966	// This function only checks all attributes of current domain
967	void CDomain::checkAttributesOnClient()
968	{
969	if (this->isClientChecked) return;
970	CContext* context=CContext::getCurrent();
971
972	this->checkGenerate();
973	this->checkDomain();
974	this->checkBounds();
975	this->checkArea();
976	this->checkLonLat();
977
978	if (context->hasClient)
979	{ // CÃŽtÃ© client uniquement
980	this->checkMask();
981	this->checkDomainData();
982	this->checkCompression();
983	}
984	else
985	{ // CÃŽtÃ© serveur uniquement
986	}
987
988	this->isClientChecked = true;
989	}
990
991	// Send all checked attributes to server
992	void CDomain::sendCheckedAttributes()
993	{
994	if (!this->isClientChecked) checkAttributesOnClient();
995	if (!this->isClientAfterTransformationChecked) checkAttributesOnClientAfterTransformation();
996	CContext* context=CContext::getCurrent() ;
997
998	if (this->isChecked) return;
999	if (context->hasClient)
1000	{
1001	sendServerAttribut();
1002	if (hasLonLat \|\| hasArea) sendLonLatArea();
1003	}
1004	this->isChecked = true;
1005	}
1006
1007	void CDomain::checkAttributes(void)
1008	{
1009	if (this->isChecked) return;
1010	CContext* context=CContext::getCurrent() ;
1011
1012	this->checkDomain();
1013	this->checkLonLat();
1014	this->checkBounds();
1015	this->checkArea();
1016
1017	if (context->hasClient)
1018	{ // CÃŽtÃ© client uniquement
1019	this->checkMask();
1020	this->checkDomainData();
1021	this->checkCompression();
1022
1023	}
1024	else
1025	{ // CÃŽtÃ© serveur uniquement
1026	}
1027
1028	if (context->hasClient)
1029	{
1030	this->computeConnectedServer();
1031	this->completeLonLatClient();
1032	this->sendServerAttribut();
1033	this->sendLonLatArea();
1034	}
1035
1036	this->isChecked = true;
1037	}
1038
1039	void CDomain::sendServerAttribut(void)
1040	{
1041	CServerDistributionDescription serverDescription(nGlobDomain_);
1042
1043	CContext* context = CContext::getCurrent();
1044	CContextClient* client = context->client;
1045	int nbServer = client->serverSize;
1046
1047	if (isUnstructed_) serverDescription.computeServerDistribution(nbServer,0);
1048	else serverDescription.computeServerDistribution(nbServer,1);
1049
1050	std::vector<std::vector<int> > serverIndexBegin = serverDescription.getServerIndexBegin();
1051	std::vector<std::vector<int> > serverDimensionSizes = serverDescription.getServerDimensionSizes();
1052
1053	CEventClient event(getType(),EVENT_ID_SERVER_ATTRIBUT);
1054	if (client->isServerLeader())
1055	{
1056	std::list<CMessage> msgs;
1057
1058	const std::list<int>& ranks = client->getRanksServerLeader();
1059	for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank)
1060	{
1061	// Use const int to ensure CMessage holds a copy of the value instead of just a reference
1062	const int ibegin_srv = serverIndexBegin[*itRank][0];
1063	const int jbegin_srv = serverIndexBegin[*itRank][1];
1064	const int ni_srv = serverDimensionSizes[*itRank][0];
1065	const int nj_srv = serverDimensionSizes[*itRank][1];
1066	const int iend_srv = ibegin_srv + ni_srv - 1;
1067	const int jend_srv = jbegin_srv + nj_srv - 1;
1068
1069	msgs.push_back(CMessage());
1070	CMessage& msg = msgs.back();
1071	msg << this->getId() ;
1072	msg << ni_srv << ibegin_srv << iend_srv << nj_srv << jbegin_srv << jend_srv;
1073	msg << global_zoom_ni << global_zoom_ibegin << global_zoom_nj << global_zoom_jbegin;
1074	msg << isCompressible_;
1075
1076	event.push(*itRank,1,msg);
1077	}
1078	client->sendEvent(event);
1079	}
1080	else client->sendEvent(event);
1081	}
1082
1083	void CDomain::computeNGlobDomain()
1084	{
1085	nGlobDomain_.resize(2);
1086	nGlobDomain_[0] = ni_glo.getValue();
1087	nGlobDomain_[1] = nj_glo.getValue();
1088	}
1089
1090	void CDomain::computeConnectedServer(void)
1091	{
1092	CContext* context=CContext::getCurrent() ;
1093	CContextClient* client=context->client ;
1094	int nbServer=client->serverSize;
1095	bool doComputeGlobalIndexServer = true;
1096
1097	int i,j,i_ind,j_ind, nbIndex;
1098	int global_zoom_iend=global_zoom_ibegin+global_zoom_ni-1 ;
1099	int global_zoom_jend=global_zoom_jbegin+global_zoom_nj-1 ;
1100
1101	// Precompute number of index
1102	int globalIndexCountZoom = 0;
1103	nbIndex = i_index.numElements();
1104	for (i = 0; i < nbIndex; ++i)
1105	{
1106	i_ind=i_index(i);
1107	j_ind=j_index(i);
1108
1109	if (i_ind >= global_zoom_ibegin && i_ind <= global_zoom_iend && j_ind >= global_zoom_jbegin && j_ind <= global_zoom_jend)
1110	{
1111	++globalIndexCountZoom;
1112	}
1113	}
1114
1115	int globalIndexWrittenCount = 0;
1116	if (isCompressible_)
1117	{
1118	for (i = 0; i < data_i_index.numElements(); ++i)
1119	{
1120	i_ind = CDistributionClient::getDomainIndex(data_i_index(i), data_j_index(i),
1121	data_ibegin, data_jbegin, data_dim, ni,
1122	j_ind);
1123	if (i_ind >= 0 && i_ind < ni && j_ind >= 0 && j_ind < nj && mask_1d(i_ind + j_ind * ni))
1124	{
1125	i_ind += ibegin;
1126	j_ind += jbegin;
1127	if (i_ind >= global_zoom_ibegin && i_ind <= global_zoom_iend && j_ind >= global_zoom_jbegin && j_ind <= global_zoom_jend)
1128	++globalIndexWrittenCount;
1129	}
1130	}
1131	}
1132
1133	// Fill in index
1134	CArray<size_t,1> globalIndexDomainZoom(globalIndexCountZoom);
1135	CArray<size_t,1> localIndexDomainZoom(globalIndexCountZoom);
1136	CArray<size_t,1> globalIndexDomain(nbIndex);
1137	size_t globalIndex;
1138	int globalIndexCount = 0;
1139	globalIndexCountZoom = 0;
1140
1141	for (i = 0; i < nbIndex; ++i)
1142	{
1143	i_ind=i_index(i);
1144	j_ind=j_index(i);
1145	globalIndex = i_ind + j_ind * ni_glo;
1146	globalIndexDomain(globalIndexCount) = globalIndex;
1147	++globalIndexCount;
1148	if (i_ind >= global_zoom_ibegin && i_ind <= global_zoom_iend && j_ind >= global_zoom_jbegin && j_ind <= global_zoom_jend)
1149	{
1150	globalIndexDomainZoom(globalIndexCountZoom) = globalIndex;
1151	localIndexDomainZoom(globalIndexCountZoom) = i;
1152	++globalIndexCountZoom;
1153	}
1154	}
1155
1156	CArray<int,1> globalIndexWrittenDomain(globalIndexWrittenCount);
1157	if (isCompressible_)
1158	{
1159	globalIndexWrittenCount = 0;
1160	for (i = 0; i < data_i_index.numElements(); ++i)
1161	{
1162	i_ind = CDistributionClient::getDomainIndex(data_i_index(i), data_j_index(i),
1163	data_ibegin, data_jbegin, data_dim, ni,
1164	j_ind);
1165	if (i_ind >= 0 && i_ind < ni && j_ind >= 0 && j_ind < nj && mask_1d(i_ind + j_ind * ni))
1166	{
1167	i_ind += ibegin;
1168	j_ind += jbegin;
1169	if (i_ind >= global_zoom_ibegin && i_ind <= global_zoom_iend && j_ind >= global_zoom_jbegin && j_ind <= global_zoom_jend)
1170	{
1171	globalIndexWrittenDomain(globalIndexWrittenCount) = i_ind + j_ind * ni_glo;
1172	++globalIndexWrittenCount;
1173	}
1174	}
1175	}
1176	}
1177
1178	size_t globalSizeIndex = 1, indexBegin, indexEnd;
1179	int range, clientSize = client->clientSize;
1180	for (int i = 0; i < nGlobDomain_.size(); ++i) globalSizeIndex *= nGlobDomain_[i];
1181	indexBegin = 0;
1182	for (int i = 0; i < clientSize; ++i)
1183	{
1184	range = globalSizeIndex / clientSize;
1185	if (i < (globalSizeIndex%clientSize)) ++range;
1186	if (i == client->clientRank) break;
1187	indexBegin += range;
1188	}
1189	indexEnd = indexBegin + range - 1;
1190
1191	CServerDistributionDescription serverDescription(nGlobDomain_);
1192	if (isUnstructed_) serverDescription.computeServerGlobalIndexInRange(nbServer, std::make_pair<size_t,size_t>(indexBegin, indexEnd), 0);
1193	else serverDescription.computeServerGlobalIndexInRange(nbServer, std::make_pair<size_t,size_t>(indexBegin, indexEnd), 1);
1194
1195	CClientServerMapping* clientServerMap = new CClientServerMappingDistributed(serverDescription.getGlobalIndexRange(),
1196	client->intraComm);
1197	clientServerMap->computeServerIndexMapping(globalIndexDomain);
1198	const std::map<int, std::vector<size_t> >& globalIndexDomainOnServer = clientServerMap->getGlobalIndexOnServer();
1199
1200	std::map<int, std::vector<size_t> >::const_iterator it = globalIndexDomainOnServer.begin(),
1201	ite = globalIndexDomainOnServer.end();
1202	typedef XIOSBinarySearchWithIndex<size_t> BinarySearch;
1203	std::vector<int>::iterator itVec;
1204
1205	indSrv_.clear();
1206	indWrittenSrv_.clear();
1207	for (; it != ite; ++it)
1208	{
1209	int rank = it->first;
1210	int indexSize = it->second.size();
1211	std::vector<int> permutIndex(indexSize);
1212	XIOSAlgorithms::fillInIndex(indexSize, permutIndex);
1213	XIOSAlgorithms::sortWithIndex<size_t, CVectorStorage>(it->second, permutIndex);
1214	BinarySearch binSearch(it->second);
1215	int nb = globalIndexDomainZoom.numElements();
1216	for (int i = 0; i < nb; ++i)
1217	{
1218	if (binSearch.search(permutIndex.begin(), permutIndex.end(), globalIndexDomainZoom(i), itVec))
1219	{
1220	indSrv_[rank].push_back(localIndexDomainZoom(i));
1221	}
1222	}
1223	for (int i = 0; i < globalIndexWrittenDomain.numElements(); ++i)
1224	{
1225	if (binSearch.search(permutIndex.begin(), permutIndex.end(), globalIndexWrittenDomain(i), itVec))
1226	{
1227	indWrittenSrv_[rank].push_back(globalIndexWrittenDomain(i));
1228	}
1229	}
1230	}
1231
1232	connectedServerRank_.clear();
1233	for (it = globalIndexDomainOnServer.begin(); it != ite; ++it) {
1234	connectedServerRank_.push_back(it->first);
1235	}
1236
1237	if (!indSrv_.empty())
1238	{
1239	connectedServerRank_.clear();
1240	for (it = indSrv_.begin(); it != indSrv_.end(); ++it)
1241	connectedServerRank_.push_back(it->first);
1242	}
1243	nbConnectedClients_ = clientServerMap->computeConnectedClients(client->serverSize, client->clientSize, client->intraComm, connectedServerRank_);
1244
1245	delete clientServerMap;
1246	}
1247
1248	const std::map<int, vector<size_t> >& CDomain::getIndexServer() const
1249	{
1250	return indSrv_;
1251	}
1252
1253	/*!
1254	Send index from client to server(s)
1255	*/
1256	void CDomain::sendIndex()
1257	{
1258	int ns, n, i, j, ind, nv, idx;
1259	CContext* context = CContext::getCurrent();
1260	CContextClient* client=context->client;
1261
1262	CEventClient eventIndex(getType(), EVENT_ID_INDEX);
1263
1264	list<CMessage> list_msgsIndex;
1265	list<CArray<int,1> > list_indi, list_indj, list_writtenInd;
1266
1267	std::map<int, std::vector<size_t> >::const_iterator it, iteMap;
1268	iteMap = indSrv_.end();
1269	for (int k = 0; k < connectedServerRank_.size(); ++k)
1270	{
1271	int nbData = 0;
1272	int rank = connectedServerRank_[k];
1273	it = indSrv_.find(rank);
1274	if (iteMap != it)
1275	nbData = it->second.size();
1276
1277	list_indi.push_back(CArray<int,1>(nbData));
1278	list_indj.push_back(CArray<int,1>(nbData));
1279
1280	CArray<int,1>& indi = list_indi.back();
1281	CArray<int,1>& indj = list_indj.back();
1282	const std::vector<size_t>& temp = it->second;
1283	for (n = 0; n < nbData; ++n)
1284	{
1285	idx = static_cast<int>(it->second[n]);
1286	indi(n) = i_index(idx);
1287	indj(n) = j_index(idx);
1288	}
1289
1290	list_msgsIndex.push_back(CMessage());
1291
1292	list_msgsIndex.back() << this->getId() << (int)type; // enum ne fonctionne pour les message => ToFix
1293	list_msgsIndex.back() << isCurvilinear;
1294	list_msgsIndex.back() << list_indi.back() << list_indj.back();
1295
1296	if (isCompressible_)
1297	{
1298	std::vector<int>& writtenIndSrc = indWrittenSrv_[rank];
1299	list_writtenInd.push_back(CArray<int,1>(writtenIndSrc.size()));
1300	CArray<int,1>& writtenInd = list_writtenInd.back();
1301
1302	for (n = 0; n < writtenInd.numElements(); ++n)
1303	writtenInd(n) = writtenIndSrc[n];
1304
1305	list_msgsIndex.back() << writtenInd;
1306	}
1307
1308	eventIndex.push(rank, nbConnectedClients_[rank], list_msgsIndex.back());
1309	}
1310
1311	client->sendEvent(eventIndex);
1312	}
1313
1314	/*!
1315	Send area from client to server(s)
1316	*/
1317	void CDomain::sendArea()
1318	{
1319	if (!hasArea) return;
1320
1321	int ns, n, i, j, ind, nv, idx;
1322	CContext* context = CContext::getCurrent();
1323	CContextClient* client=context->client;
1324
1325	// send area for each connected server
1326	CEventClient eventArea(getType(), EVENT_ID_AREA);
1327
1328	list<CMessage> list_msgsArea;
1329	list<CArray<double,1> > list_area;
1330
1331	std::map<int, std::vector<size_t> >::const_iterator it, iteMap;
1332	iteMap = indSrv_.end();
1333	for (int k = 0; k < connectedServerRank_.size(); ++k)
1334	{
1335	int nbData = 0;
1336	int rank = connectedServerRank_[k];
1337	it = indSrv_.find(rank);
1338	if (iteMap != it)
1339	nbData = it->second.size();
1340	list_area.push_back(CArray<double,1>(nbData));
1341
1342	const std::vector<size_t>& temp = it->second;
1343	for (n = 0; n < nbData; ++n)
1344	{
1345	idx = static_cast<int>(it->second[n]);
1346	i = i_index(idx);
1347	j = j_index(idx);
1348	if (hasArea)
1349	list_area.back()(n) = area(i - ibegin, j - jbegin);
1350	}
1351
1352	list_msgsArea.push_back(CMessage());
1353	list_msgsArea.back() << this->getId() << list_area.back();
1354	eventArea.push(rank, nbConnectedClients_[rank], list_msgsArea.back());
1355	}
1356	client->sendEvent(eventArea);
1357	}
1358
1359	/*!
1360	Send longitude and latitude from client to servers
1361	Each client send long and lat information to corresponding connected server(s).
1362	Because longitude and latitude are optional, this function only called if latitude and longitude exist
1363	*/
1364	void CDomain::sendLonLat()
1365	{
1366	if (!hasLonLat) return;
1367
1368	int ns, n, i, j, ind, nv, idx;
1369	CContext* context = CContext::getCurrent();
1370	CContextClient* client=context->client;
1371
1372	// send lon lat for each connected server
1373	CEventClient eventLon(getType(), EVENT_ID_LON);
1374	CEventClient eventLat(getType(), EVENT_ID_LAT);
1375
1376	list<CMessage> list_msgsLon, list_msgsLat;
1377	list<CArray<double,1> > list_lon, list_lat;
1378	list<CArray<double,2> > list_boundslon, list_boundslat;
1379
1380	std::map<int, std::vector<size_t> >::const_iterator it, iteMap;
1381	iteMap = indSrv_.end();
1382	for (int k = 0; k < connectedServerRank_.size(); ++k)
1383	{
1384	int nbData = 0;
1385	int rank = connectedServerRank_[k];
1386	it = indSrv_.find(rank);
1387	if (iteMap != it)
1388	nbData = it->second.size();
1389
1390	list_lon.push_back(CArray<double,1>(nbData));
1391	list_lat.push_back(CArray<double,1>(nbData));
1392
1393	if (hasBounds)
1394	{
1395	list_boundslon.push_back(CArray<double,2>(nvertex, nbData));
1396	list_boundslat.push_back(CArray<double,2>(nvertex, nbData));
1397	}
1398
1399	CArray<double,1>& lon = list_lon.back();
1400	CArray<double,1>& lat = list_lat.back();
1401	const std::vector<size_t>& temp = it->second;
1402	for (n = 0; n < nbData; ++n)
1403	{
1404	idx = static_cast<int>(it->second[n]);
1405	lon(n) = lonvalue_client(idx);
1406	lat(n) = latvalue_client(idx);
1407
1408	if (hasBounds)
1409	{
1410	CArray<double,2>& boundslon = list_boundslon.back();
1411	CArray<double,2>& boundslat = list_boundslat.back();
1412
1413	for (nv = 0; nv < nvertex; ++nv)
1414	{
1415	boundslon(nv, n) = bounds_lon_client(nv, idx);
1416	boundslat(nv, n) = bounds_lat_client(nv, idx);
1417	}
1418	}
1419	}
1420
1421	list_msgsLon.push_back(CMessage());
1422	list_msgsLat.push_back(CMessage());
1423
1424	list_msgsLon.back() << this->getId() << list_lon.back();
1425	list_msgsLat.back() << this->getId() << list_lat.back();
1426
1427	if (hasBounds)
1428	{
1429	list_msgsLon.back() << list_boundslon.back();
1430	list_msgsLat.back() << list_boundslat.back();
1431	}
1432
1433	eventLon.push(rank, nbConnectedClients_[rank], list_msgsLon.back());
1434	eventLat.push(rank, nbConnectedClients_[rank], list_msgsLat.back());
1435	}
1436
1437	client->sendEvent(eventLon);
1438	client->sendEvent(eventLat);
1439	}
1440
1441	/*!
1442	Send some optional information to server(s)
1443	In the future, this function can be extended with more optional information to send
1444	*/
1445	void CDomain::sendLonLatArea(void)
1446	{
1447	sendIndex();
1448	sendLonLat();
1449	sendArea();
1450	}
1451
1452	bool CDomain::dispatchEvent(CEventServer& event)
1453	{
1454	if (SuperClass::dispatchEvent(event)) return true;
1455	else
1456	{
1457	switch(event.type)
1458	{
1459	case EVENT_ID_SERVER_ATTRIBUT:
1460	recvServerAttribut(event);
1461	return true;
1462	break;
1463	case EVENT_ID_INDEX:
1464	recvIndex(event);
1465	return true;
1466	break;
1467	case EVENT_ID_LON:
1468	recvLon(event);
1469	return true;
1470	break;
1471	case EVENT_ID_LAT:
1472	recvLat(event);
1473	return true;
1474	break;
1475	case EVENT_ID_AREA:
1476	recvArea(event);
1477	return true;
1478	break;
1479	default:
1480	ERROR("bool CContext::dispatchEvent(CEventServer& event)",
1481	<< "Unknown Event");
1482	return false;
1483	}
1484	}
1485	}
1486
1487	/*!
1488	Receive attributes event from clients(s)
1489	\param[in] event event contain info about rank and associated attributes
1490	*/
1491	void CDomain::recvServerAttribut(CEventServer& event)
1492	{
1493	CBufferIn* buffer=event.subEvents.begin()->buffer;
1494	string domainId ;
1495	*buffer>>domainId ;
1496	get(domainId)->recvServerAttribut(*buffer) ;
1497	}
1498
1499	/*!
1500	Receive attributes from client(s): zoom info and begin and n of each server
1501	\param[in] rank rank of client source
1502	\param[in] buffer message containing attributes info
1503	*/
1504	void CDomain::recvServerAttribut(CBufferIn& buffer)
1505	{
1506	buffer >> ni_srv >> ibegin_srv >> iend_srv >> nj_srv >> jbegin_srv >> jend_srv
1507	>> global_zoom_ni >> global_zoom_ibegin >> global_zoom_nj >> global_zoom_jbegin
1508	>> isCompressible_;
1509
1510	int zoom_iend = global_zoom_ibegin + global_zoom_ni - 1;
1511	int zoom_jend = global_zoom_jbegin + global_zoom_nj - 1;
1512
1513	zoom_ibegin_srv = global_zoom_ibegin > ibegin_srv ? global_zoom_ibegin : ibegin_srv ;
1514	zoom_iend_srv = zoom_iend < iend_srv ? zoom_iend : iend_srv ;
1515	zoom_ni_srv=zoom_iend_srv-zoom_ibegin_srv+1 ;
1516
1517	zoom_jbegin_srv = global_zoom_jbegin > jbegin_srv ? global_zoom_jbegin : jbegin_srv ;
1518	zoom_jend_srv = zoom_jend < jend_srv ? zoom_jend : jend_srv ;
1519	zoom_nj_srv=zoom_jend_srv-zoom_jbegin_srv+1 ;
1520
1521	if (zoom_ni_srv<=0 \|\| zoom_nj_srv<=0)
1522	{
1523	zoom_ibegin_srv=0 ; zoom_iend_srv=0 ; zoom_ni_srv=0 ;
1524	zoom_jbegin_srv=0 ; zoom_jend_srv=0 ; zoom_nj_srv=0 ;
1525	}
1526	lonvalue_srv.resize(zoom_ni_srv*zoom_nj_srv) ;
1527	lonvalue_srv = 0. ;
1528	latvalue_srv.resize(zoom_ni_srv*zoom_nj_srv) ;
1529	latvalue_srv = 0. ;
1530	if (hasBounds)
1531	{
1532	bounds_lon_srv.resize(nvertex,zoom_ni_srv*zoom_nj_srv) ;
1533	bounds_lon_srv = 0. ;
1534	bounds_lat_srv.resize(nvertex,zoom_ni_srv*zoom_nj_srv) ;
1535	bounds_lat_srv = 0. ;
1536	}
1537
1538	if (hasArea)
1539	area_srv.resize(zoom_ni_srv * zoom_nj_srv);
1540	}
1541
1542	/*!
1543	Receive index event from clients(s)
1544	\param[in] event event contain info about rank and associated index
1545	*/
1546	void CDomain::recvIndex(CEventServer& event)
1547	{
1548	CDomain* domain;
1549
1550	list<CEventServer::SSubEvent>::iterator it;
1551	for (it = event.subEvents.begin(); it != event.subEvents.end(); ++it)
1552	{
1553	CBufferIn* buffer = it->buffer;
1554	string domainId;
1555	*buffer >> domainId;
1556	domain = get(domainId);
1557	domain->recvIndex(it->rank, *buffer);
1558	}
1559
1560	if (domain->isCompressible_)
1561	{
1562	std::sort(domain->indexesToWrite.begin(), domain->indexesToWrite.end());
1563
1564	CContextServer* server = CContext::getCurrent()->server;
1565	domain->numberWrittenIndexes_ = domain->indexesToWrite.size();
1566	MPI_Allreduce(&domain->numberWrittenIndexes_, &domain->totalNumberWrittenIndexes_, 1, MPI_INT, MPI_SUM, server->intraComm);
1567	MPI_Scan(&domain->numberWrittenIndexes_, &domain->offsetWrittenIndexes_, 1, MPI_INT, MPI_SUM, server->intraComm);
1568	domain->offsetWrittenIndexes_ -= domain->numberWrittenIndexes_;
1569	}
1570	}
1571
1572	/*!
1573	Receive index information from client(s)
1574	\param[in] rank rank of client source
1575	\param[in] buffer message containing index info
1576	*/
1577	void CDomain::recvIndex(int rank, CBufferIn& buffer)
1578	{
1579	int type_int;
1580	buffer >> type_int >> isCurvilinear >> indiSrv[rank] >> indjSrv[rank];
1581	type.setValue((type_attr::t_enum)type_int); // probleme des type enum avec les buffers : ToFix
1582
1583	if (isCompressible_)
1584	{
1585	CArray<int, 1> writtenIndexes;
1586	buffer >> writtenIndexes;
1587	indexesToWrite.reserve(indexesToWrite.size() + writtenIndexes.numElements());
1588	for (int i = 0; i < writtenIndexes.numElements(); ++i)
1589	indexesToWrite.push_back(writtenIndexes(i));
1590	}
1591	}
1592
1593	/*!
1594	Receive longitude event from clients(s)
1595	\param[in] event event contain info about rank and associated longitude
1596	*/
1597	void CDomain::recvLon(CEventServer& event)
1598	{
1599	list<CEventServer::SSubEvent>::iterator it;
1600	for (it = event.subEvents.begin(); it != event.subEvents.end(); ++it)
1601	{
1602	CBufferIn* buffer = it->buffer;
1603	string domainId;
1604	*buffer >> domainId;
1605	get(domainId)->recvLon(it->rank, *buffer);
1606	}
1607	}
1608
1609	/*!
1610	Receive longitude information from client(s)
1611	\param[in] rank rank of client source
1612	\param[in] buffer message containing longitude info
1613	*/
1614	void CDomain::recvLon(int rank, CBufferIn& buffer)
1615	{
1616	CArray<int,1> &indi = indiSrv[rank], &indj = indjSrv[rank];
1617	CArray<double,1> lon;
1618	CArray<double,2> boundslon;
1619
1620	buffer >> lon;
1621	if (hasBounds) buffer >> boundslon;
1622
1623	int i, j, ind_srv;
1624	for (int ind = 0; ind < indi.numElements(); ind++)
1625	{
1626	i = indi(ind); j = indj(ind);
1627	ind_srv = (i - zoom_ibegin_srv) + (j - zoom_jbegin_srv) * zoom_ni_srv;
1628	lonvalue_srv(ind_srv) = lon(ind);
1629	if (hasBounds)
1630	{
1631	for (int nv = 0; nv < nvertex; ++nv)
1632	bounds_lon_srv(nv, ind_srv) = boundslon(nv, ind);
1633	}
1634	}
1635	}
1636
1637	/*!
1638	Receive latitude event from clients(s)
1639	\param[in] event event contain info about rank and associated latitude
1640	*/
1641	void CDomain::recvLat(CEventServer& event)
1642	{
1643	list<CEventServer::SSubEvent>::iterator it;
1644	for (it = event.subEvents.begin(); it != event.subEvents.end(); ++it)
1645	{
1646	CBufferIn* buffer = it->buffer;
1647	string domainId;
1648	*buffer >> domainId;
1649	get(domainId)->recvLat(it->rank, *buffer);
1650	}
1651	}
1652
1653	/*!
1654	Receive latitude information from client(s)
1655	\param[in] rank rank of client source
1656	\param[in] buffer message containing latitude info
1657	*/
1658	void CDomain::recvLat(int rank, CBufferIn& buffer)
1659	{
1660	CArray<int,1> &indi = indiSrv[rank], &indj = indjSrv[rank];
1661	CArray<double,1> lat;
1662	CArray<double,2> boundslat;
1663
1664	buffer >> lat;
1665	if (hasBounds) buffer >> boundslat;
1666
1667	int i, j, ind_srv;
1668	for (int ind = 0; ind < indi.numElements(); ind++)
1669	{
1670	i = indi(ind); j = indj(ind);
1671	ind_srv = (i - zoom_ibegin_srv) + (j - zoom_jbegin_srv) * zoom_ni_srv;
1672	latvalue_srv(ind_srv) = lat(ind);
1673	if (hasBounds)
1674	{
1675	for (int nv = 0; nv < nvertex; nv++)
1676	bounds_lat_srv(nv, ind_srv) = boundslat(nv, ind);
1677	}
1678	}
1679	}
1680
1681	/*!
1682	Receive area event from clients(s)
1683	\param[in] event event contain info about rank and associated area
1684	*/
1685	void CDomain::recvArea(CEventServer& event)
1686	{
1687	list<CEventServer::SSubEvent>::iterator it;
1688	for (it = event.subEvents.begin(); it != event.subEvents.end(); ++it)
1689	{
1690	CBufferIn* buffer = it->buffer;
1691	string domainId;
1692	*buffer >> domainId;
1693	get(domainId)->recvArea(it->rank, *buffer);
1694	}
1695	}
1696
1697	/*!
1698	Receive area information from client(s)
1699	\param[in] rank rank of client source
1700	\param[in] buffer message containing area info
1701	*/
1702	void CDomain::recvArea(int rank, CBufferIn& buffer)
1703	{
1704	CArray<int,1> &indi = indiSrv[rank], &indj = indjSrv[rank];
1705	CArray<double,1> clientArea;
1706
1707	buffer >> clientArea;
1708
1709	int i, j, ind_srv;
1710	for (int ind = 0; ind < indi.numElements(); ind++)
1711	{
1712	i = indi(ind); j = indj(ind);
1713	ind_srv = (i - zoom_ibegin_srv) + (j - zoom_jbegin_srv) * zoom_ni_srv;
1714	area_srv(ind_srv) = clientArea(ind);
1715	}
1716	}
1717
1718	/*!
1719	Check whether a domain has transformation
1720	\return true if domain has transformation
1721	*/
1722	bool CDomain::hasTransformation()
1723	{
1724	return (!transformationMap_.empty());
1725	}
1726
1727	/*!
1728	Set transformation for current domain. It's the method to move transformation in hierarchy
1729	\param [in] domTrans transformation on domain
1730	*/
1731	void CDomain::setTransformations(const TransMapTypes& domTrans)
1732	{
1733	transformationMap_ = domTrans;
1734	}
1735
1736	/*!
1737	Get all transformation current domain has
1738	\return all transformation
1739	*/
1740	CDomain::TransMapTypes CDomain::getAllTransformations(void)
1741	{
1742	return transformationMap_;
1743	}
1744
1745	/*!
1746	Check the validity of all transformations applied on domain
1747	This functions is called AFTER all inherited attributes are solved
1748	*/
1749	void CDomain::checkTransformations()
1750	{
1751	TransMapTypes::const_iterator itb = transformationMap_.begin(), it,
1752	ite = transformationMap_.end();
1753	for (it = itb; it != ite; ++it)
1754	{
1755	(it->second)->checkValid(this);
1756	}
1757	}
1758
1759	/*!
1760	A current domain will go up the hierarchy to find out the domain from which it has transformation
1761	*/
1762	void CDomain::solveInheritanceTransformation()
1763	{
1764	if (this->hasTransformation()) return;
1765
1766	std::vector<CDomain*> refDomain;
1767	CDomain* refer_sptr;
1768	CDomain* refer_ptr = this;
1769	while (refer_ptr->hasDirectDomainReference())
1770	{
1771	refDomain.push_back(refer_ptr);
1772	refer_sptr = refer_ptr->getDirectDomainReference();
1773	refer_ptr = refer_sptr;
1774	if (refer_ptr->hasTransformation()) break;
1775	}
1776
1777	if (refer_ptr->hasTransformation())
1778	for (int idx = 0; idx < refDomain.size(); ++idx)
1779	refDomain[idx]->setTransformations(refer_ptr->getAllTransformations());
1780	}
1781
1782	void CDomain::solveSrcInheritance()
1783	{
1784	if (!domain_src.isEmpty())
1785	{
1786	if (!CDomain::has(this->domain_src.getValue())) \
1787	ERROR("CDomain::solveSrcInheritance()", \
1788	<< "[ src_name = " << this->domain_src.getValue() << "]" \
1789	<< " invalid domain name !");
1790
1791	srcObject_ = CDomain::get(this->domain_src.getValue());
1792	}
1793	}
1794
1795	CDomain* CDomain::getDomainSrc()
1796	{
1797	return srcObject_;
1798	}
1799
1800	/*!
1801	Parse children nodes of a domain in xml file.
1802	Whenver there is a new transformation, its type and name should be added into this function
1803	\param node child node to process
1804	*/
1805	void CDomain::parse(xml::CXMLNode & node)
1806	{
1807	SuperClass::parse(node);
1808
1809	if (node.goToChildElement())
1810	{
1811	StdString zoomDomainDefRoot("zoom_domain_definition");
1812	StdString zoom("zoom_domain");
1813	StdString interpDomainDefRoot("interpolate_domain_definition");
1814	StdString interpFromFile("interpolate_domain");
1815	StdString generateRectilinearDefRoot("generate_rectilinear_domain_definition");
1816	StdString generateRectilinear("generate_rectilinear_domain");
1817	do
1818	{
1819	if (node.getElementName() == zoom) {
1820	CZoomDomain* tmp = (CZoomDomainGroup::get(zoomDomainDefRoot))->createChild();
1821	tmp->parse(node);
1822	transformationMap_.push_back(std::make_pair(TRANS_ZOOM_DOMAIN,tmp));
1823	}
1824	else if (node.getElementName() == interpFromFile)
1825	{
1826	CInterpolateDomain* tmp = (CInterpolateDomainGroup::get(interpDomainDefRoot))->createChild();
1827	tmp->parse(node);
1828	transformationMap_.push_back(std::make_pair(TRANS_INTERPOLATE_DOMAIN,tmp));
1829	}
1830	else if (node.getElementName() == generateRectilinear)
1831	{
1832	CGenerateRectilinearDomain* tmp = (CGenerateRectilinearDomainGroup::get(generateRectilinearDefRoot))->createChild();
1833	tmp->parse(node);
1834	transformationMap_.push_back(std::make_pair(TRANS_GENERATE_RECTILINEAR_DOMAIN,tmp));
1835	}
1836	} while (node.goToNextElement()) ;
1837	node.goToParentElement();
1838	}
1839	}
1840	//----------------------------------------------------------------
1841
1842	DEFINE_REF_FUNC(Domain,domain)
1843
1844	///---------------------------------------------------------------
1845
1846	} // namespace xios

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

Context Navigation

source: XIOS/trunk/src/node/domain.cpp @ 715

Download in other formats: