Context Navigation

domain.cpp @ 666

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

Change name of several axis attributes and remove some redundant variable of domain

+) Change name of axis attributes to make them consistent with ones of domain
+) Remove zoom_client_* of domain

Test
+) On Curie
+) All tests pass and are 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: 42.4 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 "array_new.hpp"
16	#include "server_distribution_description.hpp"
17	#include "client_server_mapping_distributed.hpp"
18	#include "zoom_domain.hpp"
19	#include "interpolate_from_file_domain.hpp"
20
21	namespace xios {
22
23	/// ////////////////////// DÃ©finitions ////////////////////// ///
24
25	CDomain::CDomain(void)
26	: CObjectTemplate<CDomain>(), CDomainAttributes()
27	, isChecked(false), relFiles(), isClientChecked(false), nbConnectedClients_(), indSrv_(), connectedServerRank_()
28	, hasBounds(false), hasArea(false), isDistributed_(false), nGlobDomain_(), isUnstructed_(false)
29	, global_zoom_ni(0), global_zoom_ibegin(0), global_zoom_nj(0), global_zoom_jbegin(0)
30	, isClientAfterTransformationChecked(false), hasLonLat(false)
31	, lonvalue_client(), latvalue_client(), bounds_lon_client(), bounds_lat_client()
32	{ /* Ne rien faire de plus */ }
33
34	CDomain::CDomain(const StdString & id)
35	: CObjectTemplate<CDomain>(id), CDomainAttributes()
36	, isChecked(false), relFiles(), isClientChecked(false), nbConnectedClients_(), indSrv_(), connectedServerRank_()
37	, hasBounds(false), hasArea(false), isDistributed_(false), nGlobDomain_(), isUnstructed_(false)
38	, global_zoom_ni(0), global_zoom_ibegin(0), global_zoom_nj(0), global_zoom_jbegin(0)
39	, isClientAfterTransformationChecked(false), hasLonLat(false)
40	, lonvalue_client(), latvalue_client(), bounds_lon_client(), bounds_lat_client()
41	{ /* Ne rien faire de plus */ }
42
43	CDomain::~CDomain(void)
44	{
45	}
46
47	///---------------------------------------------------------------
48
49	CDomain* CDomain::createDomain()
50	{
51	CDomain* domain = CDomainGroup::get("domain_definition")->createChild();
52	return domain;
53	}
54
55	void CDomain::duplicateAttributes(CDomain* domain)
56	{
57	domain->setAttributes(this);
58	}
59
60	const std::set<StdString> & CDomain::getRelFiles(void) const
61	{
62	return (this->relFiles);
63	}
64
65	//----------------------------------------------------------------
66	bool CDomain::isEmpty(void) const
67	{
68	return ((this->zoom_ni_srv == 0) \|\|
69	(this->zoom_nj_srv == 0));
70	}
71
72	//----------------------------------------------------------------
73	bool CDomain::IsWritten(const StdString & filename) const
74	{
75	return (this->relFiles.find(filename) != this->relFiles.end());
76	}
77
78	//----------------------------------------------------------------
79	bool CDomain::isDistributed(void) const
80	{
81	return isDistributed_;
82	}
83
84	//----------------------------------------------------------------
85	void CDomain::addRelFile(const StdString & filename)
86	{
87	this->relFiles.insert(filename);
88	}
89
90
91	StdString CDomain::GetName(void) { return (StdString("domain")); }
92	StdString CDomain::GetDefName(void){ return (CDomain::GetName()); }
93	ENodeType CDomain::GetType(void) { return (eDomain); }
94
95	//----------------------------------------------------------------
96
97	void CDomain::checkDomain(void)
98	{
99	if (type.isEmpty())
100	{
101	ERROR("CDomain::checkDomain(void)",
102	<< "[ Id = " << this->getId() << " ] "
103	<< "The domain type is not defined,"
104	<< " check the 'type' value !")
105	}
106
107	if (type==type_attr::unstructured)
108	{
109	if (ni_glo.isEmpty() \|\| ni_glo <= 0 )
110	{
111	ERROR("CDomain::checkAttributes(void)",
112	<< "[ Id = " << this->getId() << " ] "
113	<< "The global domain is badly defined,"
114	<< " check the \'ni_glo\' value !")
115	}
116	isUnstructed_ = true;
117	nj_glo = 1;
118	nj = 1;
119	jbegin = 0;
120	if (ni.isEmpty()) ni = i_index.numElements();
121	j_index.resize(ni);
122	for(int i=0;i<ni;++i) j_index(i)=0;
123
124	if (!area.isEmpty())
125	area.transposeSelf(1, 0);
126	}
127	else if ((ni_glo.isEmpty() \|\| ni_glo.getValue() <= 0 ) \|\|
128	(nj_glo.isEmpty() \|\| nj_glo.getValue() <= 0 ))
129	{
130	ERROR("CDomain::checkAttributes(void)",
131	<< "[ Id = " << this->getId() << " ] "
132	<< "The global domain is badly defined,"
133	<< " check the \'ni_glo\' et \'nj_glo\' values !")
134	}
135
136	isDistributed_ = !ibegin.isEmpty() \|\| !ni.isEmpty() \|\| !jbegin.isEmpty() \|\| !nj.isEmpty();
137
138	checkLocalIDomain();
139	checkLocalJDomain();
140
141	if (i_index.isEmpty())
142	{
143	i_index.resize(ni*nj);
144	for (int j = 0; j < nj; ++j)
145	for (int i = 0; i < ni; ++i) i_index(i+j*ni) = i+ibegin;
146	}
147
148	if (j_index.isEmpty())
149	{
150	j_index.resize(ni*nj);
151	for (int j = 0; j < nj; ++j)
152	for (int i = 0; i < ni; ++i) j_index(i+j*ni) = j+jbegin;
153	}
154	computeNGlobDomain();
155
156	if (0 == global_zoom_ni) global_zoom_ni = ni_glo;
157	if (0 == global_zoom_nj) global_zoom_nj = nj_glo;
158	}
159
160	//----------------------------------------------------------------
161
162	void CDomain::checkLocalIDomain(void)
163	{
164	if (ibegin.isEmpty() && ni.isEmpty())
165	{
166	ibegin = 0;
167	ni = ni_glo;
168	}
169	else if (!i_index.isEmpty())
170	{
171	ibegin = i_index(0);
172	}
173
174	if (ni.getValue() < 0 \|\| ibegin.getValue() < 0 \|\|
175	(ibegin.getValue() + ni.getValue()) > ni_glo.getValue())
176	{
177	ERROR("CDomain::checkLocalIDomain(void)",
178	<< "[ Id = " << this->getId() << " ] "
179	<< "The local domain is wrongly defined,"
180	<< " check the attributes 'ni_glo', 'ni' and 'ibegin'");
181	}
182	}
183
184	//----------------------------------------------------------------
185	void CDomain::checkLocalJDomain(void)
186	{
187	if (jbegin.isEmpty() && nj.isEmpty())
188	{
189	jbegin = 0;
190	nj = nj_glo;
191	}
192	else if (!j_index.isEmpty())
193	{
194	jbegin = j_index(0);
195	}
196
197	if (nj.getValue() < 0 \|\| jbegin.getValue() < 0 \|\|
198	(jbegin.getValue() + nj.getValue()) > nj_glo.getValue())
199	{
200	ERROR("CDomain::checkLocalJDomain(void)",
201	<< "[ Id = " << this->getId() << " ] "
202	<< "The local domain is wrongly defined,"
203	<< " check the attributes 'nj_glo', 'nj' and 'jbegin'");
204	}
205	}
206
207	//----------------------------------------------------------------
208	void CDomain::checkMask(void)
209	{
210	using namespace std;
211
212	int ibegin_mask = 0,
213	jbegin_mask = 0,
214	iend_mask = ibegin.getValue() + ni.getValue() - 1,
215	jend_mask = jbegin.getValue() + nj.getValue() - 1;
216
217	if (!mask_1d.isEmpty() && !mask_2d.isEmpty())
218	ERROR("CDomain::checkMask(void)",
219	<<"Only one mask is used but both mask_1d and mask_2d are defined! "<<endl
220	<<"Define only one mask: mask_1d or mask_2d ");
221
222	if (!mask_1d.isEmpty() && mask_2d.isEmpty())
223	{
224	if (mask_1d.numElements() != i_index.numElements())
225	ERROR("CDomain::checkMask(void)",
226	<<"the mask_1d has not the same size as the local domain"<<endl
227	<<"Local size is "<<i_index.numElements()<<endl
228	<<"Mask size is "<<mask_1d.numElements());
229	}
230
231	if (mask_1d.isEmpty() && !mask_2d.isEmpty())
232	{
233	if ((mask_2d.extent(0) != ni) \|\|
234	(mask_2d.extent(1) != nj))
235	ERROR("CDomain::checkMask(void)",
236	<<"the mask has not the same size as the local domain"<<endl
237	<<"Local size is "<<ni<<"x"<<nj<<endl
238	<<"Mask size is "<<mask_2d.extent(0)<<"x"<<mask_2d.extent(1));
239	}
240
241	if (!mask_2d.isEmpty())
242	{
243	mask_1d.resize(mask_2d.extent(0) * mask_2d.extent(1));
244	for (int j = 0; j < nj; ++j)
245	for (int i = 0; i < ni; ++i) mask_1d(i+j*ni) = mask_2d(i,j);
246	}
247	else
248	{
249	mask_1d.resize(i_index.numElements());
250	for (int i = 0; i < i_index.numElements(); ++i) mask_1d(i) = true;
251	}
252	}
253
254
255	//----------------------------------------------------------------
256	void CDomain::checkDomainData(void)
257	{
258	if (!data_dim.isEmpty() &&
259	!(data_dim.getValue() == 1 \|\| data_dim.getValue() == 2))
260	{
261	ERROR("CDomain::checkAttributes(void)",
262	<< "Data dimension incompatible (must be 1 or 2) !") ;
263	}
264	else if (data_dim.isEmpty())
265	{
266	data_dim.setValue(1);
267	}
268
269	if (data_ibegin.isEmpty())
270	data_ibegin.setValue(0) ;
271	if (data_jbegin.isEmpty())
272	data_jbegin.setValue(0) ;
273
274	if (!data_ni.isEmpty() && (data_ni.getValue() <= 0))
275	{
276	ERROR("CDomain::checkAttributes(void)",
277	<< "Data dimension is negative (data_ni).") ;
278	}
279	else if (data_ni.isEmpty())
280	{
281	data_ni.setValue((data_dim.getValue() == 1)
282	? (ni.getValue() * nj.getValue())
283	: ni.getValue());
284	}
285
286	if (!data_nj.isEmpty() && (data_nj.getValue() <= 0) )
287	{
288	ERROR("CDomain::checkAttributes(void)",
289	<< "Data dimension is negative (data_nj).") ;
290	}
291
292	if (data_nj.isEmpty())
293	data_nj.setValue((data_dim.getValue() == 1)
294	? (ni.getValue() * nj.getValue())
295	: nj.getValue());
296
297	}
298
299	//----------------------------------------------------------------
300	void CDomain::checkCompression(void)
301	{
302	if (!data_i_index.isEmpty())
303	{
304	if (!data_j_index.isEmpty() &&
305	(data_j_index.numElements() != data_i_index.numElements()))
306	{
307	ERROR("CDomain::checkAttributes(void)",
308	<<"Dimension data_j_index incompatible with data_i_index.") ;
309	}
310
311	if (2 == data_dim.getValue())
312	{
313	if (data_j_index.isEmpty())
314	{
315	ERROR("CDomain::checkAttributes(void)",
316	<<"data_j_index must be defined !") ;
317	}
318	}
319	else // (1 == data_dim.getValue())
320	{
321	if (data_j_index.isEmpty())
322	{
323	const int dni = data_ni.getValue();
324	data_j_index.resize(dni);
325	for (int j = 0; j < dni; ++j) data_j_index(j) = 0;
326	}
327	}
328	}
329	else
330	{
331	if ((data_dim.getValue() == 2) && (!data_j_index.isEmpty()))
332	ERROR("CDomain::checkAttributes(void)", << "data_i_index undefined") ;
333
334	if (1 == data_dim.getValue())
335	{
336	const int dni = data_ni.getValue();
337	data_i_index.resize(dni) ;
338	data_j_index.resize(dni) ;
339
340	for (int i = 0; i < dni; ++i)
341	{
342	data_i_index(i) = i;
343	data_j_index(i) = 0;
344	}
345	}
346	else // (data_dim == 2)
347	{
348	const int dni = data_ni.getValue() * data_nj.getValue();
349	data_i_index.resize(dni) ;
350	data_j_index.resize(dni) ;
351
352	for(int count = 0, j = 0; j < data_nj.getValue(); ++j)
353	{
354	for(int i = 0; i < data_ni.getValue(); ++i, ++count)
355	{
356	data_i_index(count) = i;
357	data_j_index(count) = j;
358	}
359	}
360	}
361	}
362	}
363
364	//----------------------------------------------------------------
365	void CDomain::completeLonLatClient(void)
366	{
367	int i,j,k ;
368	CArray<double,1> lonvalue_temp(ni*nj) ;
369	CArray<double,2> bounds_lon_temp(nvertex,ni*nj);
370	CArray<double,1> latvalue_temp(ni*nj) ;
371	CArray<double,2> bounds_lat_temp(nvertex,ni*nj);
372
373	if (!lonvalue_2d.isEmpty())
374	{
375	for (j = 0; j < nj; ++j)
376	for (i = 0; i < ni; ++i)
377	{
378	lonvalue_temp(i+j*ni) = lonvalue_2d(i,j);
379	latvalue_temp(i+j*ni) = latvalue_2d(i,j);
380	if (hasBounds)
381	{
382	k=j*ni+i;
383	for(int n=0;n<nvertex;++n)
384	{
385	bounds_lon_temp(n,k) = bounds_lon_2d(n,i,j);
386	bounds_lat_temp(n,k) = bounds_lat_2d(n,i,j);
387	}
388	}
389	}
390	}
391
392	if (!lonvalue_1d.isEmpty())
393	{
394	if (type_attr::rectilinear == type)
395	{
396	if ((ni == lonvalue_1d.numElements()) && (nj == latvalue_1d.numElements()))
397	{
398	for(j=0;j<nj;++j)
399	for(i=0;i<ni;++i)
400	{
401	k=j*ni+i;
402	lonvalue_temp(k) = lonvalue_1d(i);
403	latvalue_temp(k) = latvalue_1d(j);
404	if (hasBounds)
405	{
406	for(int n=0;n<nvertex;++n)
407	{
408	bounds_lon_temp(n,k) = bounds_lon_1d(n,i);
409	bounds_lat_temp(n,k) = bounds_lat_1d(n,j);
410	}
411	}
412	}
413	}
414	else
415	ERROR("CDomain::completeLonClient(void)",
416	<<"lonvalue_1d and latvalue_1d has not the same size as the local domain"<<endl
417	<<"Local size is "<<ni<<"x " << nj<< endl
418	<<"lonvalue_1d size is "<<lonvalue_1d.numElements()
419	<<"latvalue_1d size is "<<latvalue_1d.numElements());
420	}
421	else if (type==type_attr::curvilinear \|\| type==type_attr::unstructured)
422	{
423	lonvalue_temp=lonvalue_1d;
424	latvalue_temp=latvalue_1d;
425	if (hasBounds)
426	{
427	bounds_lon_temp=bounds_lon_1d;
428	bounds_lat_temp=bounds_lat_1d;
429	}
430	}
431	}
432
433	int i_ind,j_ind;
434	int global_zoom_iend=global_zoom_ibegin+global_zoom_ni-1;
435	int global_zoom_jend=global_zoom_jbegin+global_zoom_nj-1;
436
437	int globalIndexCountZoom = 0;
438	int nbIndex = i_index.numElements();
439	for (i = 0; i < nbIndex; ++i)
440	{
441	i_ind=i_index(i);
442	j_ind=j_index(i);
443
444	if (i_ind >= global_zoom_ibegin && i_ind <= global_zoom_iend && j_ind >= global_zoom_jbegin && j_ind <= global_zoom_jend)
445	{
446	++globalIndexCountZoom;
447	}
448	}
449
450	// Make sure that this attribute is non-empty for every client.
451	if (0 != globalIndexCountZoom)
452	{
453	lonvalue_client.resize(globalIndexCountZoom);
454	latvalue_client.resize(globalIndexCountZoom);
455	if (hasBounds)
456	{
457	bounds_lon_client.resize(nvertex,globalIndexCountZoom);
458	bounds_lat_client.resize(nvertex,globalIndexCountZoom);
459	}
460	}
461
462	int nCountZoom = 0;
463	for (i = 0; i < nbIndex; ++i)
464	{
465	i_ind=i_index(i);
466	j_ind=j_index(i);
467
468	if (i_ind >= global_zoom_ibegin && i_ind <= global_zoom_iend && j_ind >= global_zoom_jbegin && j_ind <= global_zoom_jend)
469	{
470	lonvalue_client(nCountZoom) = lonvalue_temp(i);
471	latvalue_client(nCountZoom) = latvalue_temp(i);
472	if (hasBounds)
473	{
474	for (int n = 0; n < nvertex; ++n)
475	{
476	bounds_lon_client(n,nCountZoom) = bounds_lon_temp(n,i);
477	bounds_lat_client(n,nCountZoom) = bounds_lat_temp(n,i);
478	}
479	}
480	++nCountZoom;
481	}
482	}
483	}
484
485	void CDomain::checkBounds(void)
486	{
487	if (!nvertex.isEmpty() && (0 != nvertex.getValue()))
488	{
489	if (!bounds_lon_1d.isEmpty() && !bounds_lon_2d.isEmpty())
490	ERROR("CDomain::checkBounds(void)",
491	<<"Only one longitude boundary value can be used but both bounds_lon_1d and bounds_lon_2d are defined! "<<endl
492	<<"Define only one longitude boundary value: lonvalue_1d or bounds_lon_2d ");
493
494	if (!bounds_lat_1d.isEmpty() && !bounds_lat_2d.isEmpty())
495	ERROR("CDomain::checkBounds(void)",
496	<<"Only one latitude boundary value can be used but both bounds_lat_1d and bounds_lat_2d are defined! "<<endl
497	<<"Define only one latitude boundary value: bounds_lat_1d or bounds_lat_2d ");
498
499	if ((!bounds_lon_1d.isEmpty() && bounds_lat_1d.isEmpty()) \|\| (bounds_lon_1d.isEmpty() && !bounds_lat_1d.isEmpty()))
500	{
501	ERROR("CDomain::checkBounds(void)",
502	<<"Only bounds_lon_1d or bounds_lat_1d is defined "<<endl
503	<<"Both must be defined ");
504	}
505
506	if ((!bounds_lon_2d.isEmpty() && bounds_lat_2d.isEmpty()) \|\| (bounds_lon_2d.isEmpty() && !bounds_lat_2d.isEmpty()))
507	{
508	ERROR("CDomain::checkBounds(void)",
509	<<"Only bounds_lon_2d or bounds_lat_2d is defined "<<endl
510	<<"Both must be defined ");
511	}
512
513	if (!bounds_lon_1d.isEmpty() && (nvertex.getValue() != bounds_lon_1d.extent(0)))
514	ERROR("CDomain::checkBounds(void)",
515	<<"Only bounds_lon_1d and nvertex are not compatible"<<endl
516	<<"bounds_lon_1d dimension is " << bounds_lon_1d.extent(1)
517	<<"but nvertex is " << nvertex.getValue());
518
519	if (!bounds_lon_2d.isEmpty() && (nvertex.getValue() != bounds_lon_2d.extent(0)))
520	ERROR("CDomain::checkBounds(void)",
521	<<"Only bounds_lon_2d and nvertex are not compatible"<<endl
522	<<"bounds_lon_2d dimension is " << bounds_lon_1d.extent(2)
523	<<"but nvertex is " << nvertex.getValue());
524
525	if (!bounds_lon_1d.isEmpty() && lonvalue_1d.isEmpty())
526	ERROR("CDomain::checkBounds(void)",
527	<<"Both bounds_lon_1d and lonvalue_1d must be defined"<<endl);
528
529	if (!bounds_lon_2d.isEmpty() && lonvalue_2d.isEmpty())
530	ERROR("CDomain::checkBounds(void)",
531	<<"Both bounds_lon_1d and lonvalue_1d must be defined"<<endl);
532
533	if (!bounds_lat_1d.isEmpty() && (nvertex.getValue() != bounds_lat_1d.extent(0)))
534	ERROR("CDomain::checkBounds(void)",
535	<<"Only bounds_lat_1d and nvertex are not compatible"<<endl
536	<<"bounds_lat_1d dimension is " << bounds_lat_1d.extent(1)
537	<<"but nvertex is " << nvertex.getValue());
538
539	if (!bounds_lat_2d.isEmpty() && (nvertex.getValue() != bounds_lat_2d.extent(0)))
540	ERROR("CDomain::checkBounds(void)",
541	<<"Only bounds_lat_2d and nvertex are not compatible"<<endl
542	<<"bounds_lat_2d dimension is " << bounds_lat_1d.extent(2)
543	<<"but nvertex is " << nvertex.getValue());
544
545	if (!bounds_lat_1d.isEmpty() && latvalue_1d.isEmpty())
546	ERROR("CDomain::checkBounds(void)",
547	<<"Both bounds_lat_1d and latvalue_1d must be defined"<<endl);
548
549	if (!bounds_lat_2d.isEmpty() && latvalue_2d.isEmpty())
550	ERROR("CDomain::checkBounds(void)",
551	<<"Both bounds_lat_1d and latvalue_1d must be defined"<<endl);
552	hasBounds=true ;
553	}
554	else
555	{
556	hasBounds=false;
557	nvertex=0 ;
558	}
559	}
560
561	void CDomain::checkArea(void)
562	{
563	hasArea = !area.isEmpty();
564	if (hasArea)
565	{
566	if (area.extent(0) != ni \|\| area.extent(1) != nj)
567	{
568	ERROR("void CDomain::checkArea(void)",
569	"The area attribute must be of size ni x nj.");
570	}
571	}
572	}
573
574	void CDomain::checkLonLat()
575	{
576	hasLonLat = (!latvalue_1d.isEmpty() && !lonvalue_1d.isEmpty()) \|\|
577	(!latvalue_2d.isEmpty() && !lonvalue_2d.isEmpty());
578	if (hasLonLat)
579	{
580	if (!lonvalue_1d.isEmpty() && !lonvalue_2d.isEmpty())
581	ERROR("CDomain::completeLonLatClient(void)",
582	<<"Only one longitude value can be used but both lonvalue_1d and lonvalue_2d are defined! "<<endl
583	<<"Define only one longitude value: lonvalue_1d or lonvalue_2d ");
584
585	if (!lonvalue_1d.isEmpty() && lonvalue_2d.isEmpty())
586	{
587	if (lonvalue_1d.numElements() != i_index.numElements())
588	ERROR("CDomain::completeLonLatClient(void)",
589	<<"lonvalue_1d has not the same size as the local domain"<<endl
590	<<"Local size is "<<i_index.numElements()<<endl
591	<<"lonvalue_1d size is "<<lonvalue_1d.numElements());
592	}
593
594	if (lonvalue_1d.isEmpty() && !lonvalue_2d.isEmpty())
595	{
596	if ((lonvalue_2d.extent(0) != ni) \|\|
597	(lonvalue_2d.extent(1) != nj))
598	ERROR("CDomain::completeLonLatClient(void)",
599	<<"the lonvalue has not the same size as the local domain"<<endl
600	<<"Local size is "<<ni<<"x"<<nj<<endl
601	<<"Lonvalue size is "<<lonvalue_2d.extent(0)<<"x"<<lonvalue_2d.extent(1));
602	}
603
604	if (!latvalue_1d.isEmpty() && !latvalue_2d.isEmpty())
605	ERROR("CDomain::completeLonLatClient(void)",
606	<<"Only one longitude value can be used but both latvalue_1d and latvalue_2d are defined! "<<endl
607	<<"Define only one longitude value: latvalue_1d or latvalue_2d ");
608
609	if (!latvalue_1d.isEmpty() && latvalue_2d.isEmpty())
610	{
611	if (latvalue_1d.numElements() != i_index.numElements())
612	ERROR("CDomain::completeLonLatClient(void)",
613	<<"the latvalue_1d has not the same size as the local domain"<<endl
614	<<"Local size is "<<i_index.numElements()<<endl
615	<<"Mask size is "<<latvalue_1d.numElements());
616	}
617
618	if (latvalue_1d.isEmpty() && !latvalue_2d.isEmpty())
619	{
620	if ((latvalue_2d.extent(0) != ni) \|\|
621	(latvalue_2d.extent(1) != nj))
622	ERROR("CDomain::completeLonLatClient(void)",
623	<<"the mask has not the same size as the local domain"<<endl
624	<<"Local size is "<<ni<<"x"<<nj<<endl
625	<<"Mask size is "<<latvalue_2d.extent(0)<<"x"<<latvalue_2d.extent(1));
626	}
627	}
628	}
629
630	void CDomain::checkAttributesOnClientAfterTransformation()
631	{
632	CContext* context=CContext::getCurrent() ;
633
634	if (this->isClientAfterTransformationChecked) return;
635	if (context->hasClient)
636	{
637	this->checkMask();
638	if (hasLonLat \|\| hasArea) this->computeConnectedServer();
639	if (hasLonLat) this->completeLonLatClient();
640	}
641
642	this->isClientAfterTransformationChecked = true;
643	}
644
645	//----------------------------------------------------------------
646	// Divide function checkAttributes into 2 seperate onescheckBounds
647	// This function only checks all attributes of current domain
648	void CDomain::checkAttributesOnClient()
649	{
650	if (this->isClientChecked) return;
651	CContext* context=CContext::getCurrent();
652
653	this->checkDomain();
654	this->checkBounds();
655	this->checkArea();
656	this->checkLonLat();
657
658	if (context->hasClient)
659	{ // CÃŽtÃ© client uniquement
660	this->checkMask();
661	this->checkDomainData();
662	this->checkCompression();
663	}
664	else
665	{ // CÃŽtÃ© serveur uniquement
666	}
667
668	this->isClientChecked = true;
669	}
670
671	// Send all checked attributes to server
672	void CDomain::sendCheckedAttributes()
673	{
674	if (!this->isClientChecked) checkAttributesOnClient();
675	if (!this->isClientAfterTransformationChecked) checkAttributesOnClientAfterTransformation();
676	CContext* context=CContext::getCurrent() ;
677
678	if (this->isChecked) return;
679	if (context->hasClient)
680	{
681	sendServerAttribut();
682	if (hasLonLat \|\| hasArea) sendLonLatArea();
683	}
684
685	this->isChecked = true;
686	}
687
688	void CDomain::checkAttributes(void)
689	{
690	if (this->isChecked) return;
691	CContext* context=CContext::getCurrent() ;
692
693	this->checkDomain();
694	this->checkLonLat();
695	this->checkBounds();
696	this->checkArea();
697
698	if (context->hasClient)
699	{ // CÃŽtÃ© client uniquement
700	this->checkMask();
701	this->checkDomainData();
702	this->checkCompression();
703
704	}
705	else
706	{ // CÃŽtÃ© serveur uniquement
707	}
708
709	if (context->hasClient)
710	{
711	this->computeConnectedServer();
712	this->completeLonLatClient();
713	this->sendServerAttribut();
714	this->sendLonLatArea();
715	}
716
717	this->isChecked = true;
718	}
719
720	void CDomain::sendServerAttribut(void)
721	{
722	CServerDistributionDescription serverDescription(nGlobDomain_);
723
724	CContext* context = CContext::getCurrent();
725	CContextClient* client = context->client;
726	int nbServer = client->serverSize;
727
728	if (isUnstructed_) serverDescription.computeServerDistribution(nbServer,0);
729	else serverDescription.computeServerDistribution(nbServer,1);
730
731	std::vector<std::vector<int> > serverIndexBegin = serverDescription.getServerIndexBegin();
732	std::vector<std::vector<int> > serverDimensionSizes = serverDescription.getServerDimensionSizes();
733
734	CEventClient event(getType(),EVENT_ID_SERVER_ATTRIBUT);
735	if (client->isServerLeader())
736	{
737	std::list<CMessage> msgs;
738
739	const std::list<int>& ranks = client->getRanksServerLeader();
740	for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank)
741	{
742	// Use const int to ensure CMessage holds a copy of the value instead of just a reference
743	const int ibegin_srv = serverIndexBegin[*itRank][0];
744	const int jbegin_srv = serverIndexBegin[*itRank][1];
745	const int ni_srv = serverDimensionSizes[*itRank][0];
746	const int nj_srv = serverDimensionSizes[*itRank][1];
747	const int iend_srv = ibegin_srv + ni_srv - 1;
748	const int jend_srv = jbegin_srv + nj_srv - 1;
749
750	msgs.push_back(CMessage());
751	CMessage& msg = msgs.back();
752	msg << this->getId() ;
753	msg << ni_srv << ibegin_srv << iend_srv << nj_srv << jbegin_srv << jend_srv;
754	msg << global_zoom_ni << global_zoom_ibegin << global_zoom_nj << global_zoom_jbegin;
755
756	event.push(*itRank,1,msg);
757	}
758	client->sendEvent(event);
759	}
760	else client->sendEvent(event);
761	}
762
763	void CDomain::computeNGlobDomain()
764	{
765	nGlobDomain_.resize(2);
766	nGlobDomain_[0] = ni_glo.getValue();
767	nGlobDomain_[1] = nj_glo.getValue();
768	}
769
770	void CDomain::computeConnectedServer(void)
771	{
772	CContext* context=CContext::getCurrent() ;
773	CContextClient* client=context->client ;
774	int nbServer=client->serverSize;
775	bool doComputeGlobalIndexServer = true;
776
777	int i,j,i_ind,j_ind, nbIndex;
778	int global_zoom_iend=global_zoom_ibegin+global_zoom_ni-1 ;
779	int global_zoom_jend=global_zoom_jbegin+global_zoom_nj-1 ;
780
781	// Precompute number of index
782	int globalIndexCountZoom = 0;
783	nbIndex = i_index.numElements();
784	for (i = 0; i < nbIndex; ++i)
785	{
786	i_ind=i_index(i);
787	j_ind=j_index(i);
788
789	if (i_ind >= global_zoom_ibegin && i_ind <= global_zoom_iend && j_ind >= global_zoom_jbegin && j_ind <= global_zoom_jend)
790	{
791	++globalIndexCountZoom;
792	}
793	}
794
795	// Fill in index
796	CArray<size_t,1> globalIndexDomainZoom(globalIndexCountZoom);
797	CArray<size_t,1> localIndexDomainZoom(globalIndexCountZoom);
798	CArray<size_t,1> globalIndexDomain(nbIndex);
799	size_t globalIndex;
800	int globalIndexCount = 0;
801	globalIndexCountZoom = 0;
802
803	for (i = 0; i < nbIndex; ++i)
804	{
805	i_ind=i_index(i);
806	j_ind=j_index(i);
807	globalIndex = i_ind + j_ind * ni_glo;
808	globalIndexDomain(globalIndexCount) = globalIndex;
809	++globalIndexCount;
810	if (i_ind >= global_zoom_ibegin && i_ind <= global_zoom_iend && j_ind >= global_zoom_jbegin && j_ind <= global_zoom_jend)
811	{
812	globalIndexDomainZoom(globalIndexCountZoom) = globalIndex;
813	localIndexDomainZoom(globalIndexCountZoom) = i;
814	++globalIndexCountZoom;
815	}
816	}
817
818	size_t globalSizeIndex = 1, indexBegin, indexEnd;
819	int range, clientSize = client->clientSize;
820	for (int i = 0; i < nGlobDomain_.size(); ++i) globalSizeIndex *= nGlobDomain_[i];
821	indexBegin = 0;
822	for (int i = 0; i < clientSize; ++i)
823	{
824	range = globalSizeIndex / clientSize;
825	if (i < (globalSizeIndex%clientSize)) ++range;
826	if (i == client->clientRank) break;
827	indexBegin += range;
828	}
829	indexEnd = indexBegin + range - 1;
830
831	CServerDistributionDescription serverDescription(nGlobDomain_);
832	if (isUnstructed_) serverDescription.computeServerGlobalIndexInRange(nbServer, std::make_pair<size_t,size_t>(indexBegin, indexEnd), 0);
833	else serverDescription.computeServerGlobalIndexInRange(nbServer, std::make_pair<size_t,size_t>(indexBegin, indexEnd), 1);
834
835	CClientServerMapping* clientServerMap = new CClientServerMappingDistributed(serverDescription.getGlobalIndexRange(),
836	client->intraComm);
837	clientServerMap->computeServerIndexMapping(globalIndexDomain);
838	const std::map<int, std::vector<size_t> >& globalIndexDomainOnServer = clientServerMap->getGlobalIndexOnServer();
839
840	std::map<int, std::vector<size_t> >::const_iterator it = globalIndexDomainOnServer.begin(),
841	ite = globalIndexDomainOnServer.end();
842	indSrv_.clear();
843	for (; it != ite; ++it)
844	{
845	int rank = it->first;
846	std::vector<size_t>::const_iterator itbVec = (it->second).begin(),
847	iteVec = (it->second).end();
848	int nb = globalIndexDomainZoom.numElements();
849	for (int i = 0; i < nb; ++i)
850	{
851	if (iteVec != std::find(itbVec, iteVec, globalIndexDomainZoom(i)))
852	{
853	indSrv_[rank].push_back(localIndexDomainZoom(i));
854	}
855	}
856	}
857
858	connectedServerRank_.clear();
859	for (it = globalIndexDomainOnServer.begin(); it != ite; ++it) {
860	connectedServerRank_.push_back(it->first);
861	}
862
863	if (!indSrv_.empty())
864	{
865	connectedServerRank_.clear();
866	for (it = indSrv_.begin(); it != indSrv_.end(); ++it)
867	connectedServerRank_.push_back(it->first);
868	}
869	nbConnectedClients_ = clientServerMap->computeConnectedClients(client->serverSize, client->clientSize, client->intraComm, connectedServerRank_);
870
871	delete clientServerMap;
872	}
873
874	const std::map<int, vector<size_t> >& CDomain::getIndexServer() const
875	{
876	return indSrv_;
877	}
878
879	void CDomain::sendIndex()
880	{
881	int ns, n, i, j, ind, nv, idx;
882	CContext* context = CContext::getCurrent();
883	CContextClient* client=context->client;
884
885	CEventClient eventIndex(getType(), EVENT_ID_INDEX);
886
887	list<CMessage> list_msgsIndex;
888	list<CArray<int,1> > list_indi, list_indj;
889
890	std::map<int, std::vector<size_t> >::const_iterator it, iteMap;
891	iteMap = indSrv_.end();
892	for (int k = 0; k < connectedServerRank_.size(); ++k)
893	{
894	int nbData = 0;
895	int rank = connectedServerRank_[k];
896	it = indSrv_.find(rank);
897	if (iteMap != it)
898	nbData = it->second.size();
899
900	list_indi.push_back(CArray<int,1>(nbData));
901	list_indj.push_back(CArray<int,1>(nbData));
902
903	CArray<int,1>& indi = list_indi.back();
904	CArray<int,1>& indj = list_indj.back();
905	const std::vector<size_t>& temp = it->second;
906	for (n = 0; n < nbData; ++n)
907	{
908	idx = static_cast<int>(it->second[n]);
909	indi(n) = i_index(idx);
910	indj(n) = j_index(idx);
911	}
912
913	list_msgsIndex.push_back(CMessage());
914
915	list_msgsIndex.back() << this->getId() << (int)type; // enum ne fonctionne pour les message => ToFix
916	list_msgsIndex.back() << isCurvilinear;
917	list_msgsIndex.back() << list_indi.back() << list_indj.back();
918
919	eventIndex.push(rank, nbConnectedClients_[rank], list_msgsIndex.back());
920	}
921
922	client->sendEvent(eventIndex);
923	}
924
925	void CDomain::sendArea()
926	{
927	if (!hasArea) return;
928
929	int ns, n, i, j, ind, nv, idx;
930	CContext* context = CContext::getCurrent();
931	CContextClient* client=context->client;
932
933	// send area for each connected server
934	CEventClient eventArea(getType(), EVENT_ID_AREA);
935
936	list<CMessage> list_msgsArea;
937	list<CArray<double,1> > list_area;
938
939	std::map<int, std::vector<size_t> >::const_iterator it, iteMap;
940	iteMap = indSrv_.end();
941	for (int k = 0; k < connectedServerRank_.size(); ++k)
942	{
943	int nbData = 0;
944	int rank = connectedServerRank_[k];
945	it = indSrv_.find(rank);
946	if (iteMap != it)
947	nbData = it->second.size();
948	list_area.push_back(CArray<double,1>(nbData));
949
950	const std::vector<size_t>& temp = it->second;
951	for (n = 0; n < nbData; ++n)
952	{
953	idx = static_cast<int>(it->second[n]);
954	i = i_index(idx);
955	j = j_index(idx);
956	if (hasArea)
957	list_area.back()(n) = area(i - ibegin, j - jbegin);
958	}
959
960	list_msgsArea.push_back(CMessage());
961	list_msgsArea.back() << this->getId() << list_area.back();
962	eventArea.push(rank, nbConnectedClients_[rank], list_msgsArea.back());
963	}
964	client->sendEvent(eventArea);
965	}
966
967	void CDomain::sendLonLat()
968	{
969	if (!hasLonLat) return;
970
971	int ns, n, i, j, ind, nv, idx;
972	CContext* context = CContext::getCurrent();
973	CContextClient* client=context->client;
974
975	// send lon lat for each connected server
976	CEventClient eventLon(getType(), EVENT_ID_LON);
977	CEventClient eventLat(getType(), EVENT_ID_LAT);
978
979	list<CMessage> list_msgsLon, list_msgsLat;
980	list<CArray<double,1> > list_lon, list_lat;
981	list<CArray<double,2> > list_boundslon, list_boundslat;
982
983	std::map<int, std::vector<size_t> >::const_iterator it, iteMap;
984	iteMap = indSrv_.end();
985	for (int k = 0; k < connectedServerRank_.size(); ++k)
986	{
987	int nbData = 0;
988	int rank = connectedServerRank_[k];
989	it = indSrv_.find(rank);
990	if (iteMap != it)
991	nbData = it->second.size();
992
993	list_lon.push_back(CArray<double,1>(nbData));
994	list_lat.push_back(CArray<double,1>(nbData));
995
996	if (hasBounds)
997	{
998	list_boundslon.push_back(CArray<double,2>(nvertex, nbData));
999	list_boundslat.push_back(CArray<double,2>(nvertex, nbData));
1000	}
1001
1002	CArray<double,1>& lon = list_lon.back();
1003	CArray<double,1>& lat = list_lat.back();
1004	const std::vector<size_t>& temp = it->second;
1005	for (n = 0; n < nbData; ++n)
1006	{
1007	idx = static_cast<int>(it->second[n]);
1008	lon(n) = lonvalue_client(idx);
1009	lat(n) = latvalue_client(idx);
1010
1011	if (hasBounds)
1012	{
1013	CArray<double,2>& boundslon = list_boundslon.back();
1014	CArray<double,2>& boundslat = list_boundslat.back();
1015
1016	for (nv = 0; nv < nvertex; ++nv)
1017	{
1018	boundslon(nv, n) = bounds_lon_client(nv, idx);
1019	boundslat(nv, n) = bounds_lat_client(nv, idx);
1020	}
1021	}
1022	}
1023
1024	list_msgsLon.push_back(CMessage());
1025	list_msgsLat.push_back(CMessage());
1026
1027	list_msgsLon.back() << this->getId() << list_lon.back();
1028	list_msgsLat.back() << this->getId() << list_lat.back();
1029
1030	if (hasBounds)
1031	{
1032	list_msgsLon.back() << list_boundslon.back();
1033	list_msgsLat.back() << list_boundslat.back();
1034	}
1035
1036	eventLon.push(rank, nbConnectedClients_[rank], list_msgsLon.back());
1037	eventLat.push(rank, nbConnectedClients_[rank], list_msgsLat.back());
1038	}
1039
1040	client->sendEvent(eventLon);
1041	client->sendEvent(eventLat);
1042	}
1043
1044
1045	void CDomain::sendLonLatArea(void)
1046	{
1047	sendIndex();
1048	sendLonLat();
1049	sendArea();
1050	}
1051
1052	bool CDomain::dispatchEvent(CEventServer& event)
1053	{
1054	if (SuperClass::dispatchEvent(event)) return true;
1055	else
1056	{
1057	switch(event.type)
1058	{
1059	case EVENT_ID_SERVER_ATTRIBUT:
1060	recvServerAttribut(event);
1061	return true;
1062	break;
1063	case EVENT_ID_INDEX:
1064	recvIndex(event);
1065	return true;
1066	break;
1067	case EVENT_ID_LON:
1068	recvLon(event);
1069	return true;
1070	break;
1071	case EVENT_ID_LAT:
1072	recvLat(event);
1073	return true;
1074	break;
1075	case EVENT_ID_AREA:
1076	recvArea(event);
1077	return true;
1078	break;
1079	default:
1080	ERROR("bool CContext::dispatchEvent(CEventServer& event)",
1081	<< "Unknown Event");
1082	return false;
1083	}
1084	}
1085	}
1086
1087	void CDomain::recvServerAttribut(CEventServer& event)
1088	{
1089	CBufferIn* buffer=event.subEvents.begin()->buffer;
1090	string domainId ;
1091	*buffer>>domainId ;
1092	get(domainId)->recvServerAttribut(*buffer) ;
1093	}
1094
1095	void CDomain::recvServerAttribut(CBufferIn& buffer)
1096	{
1097	buffer >> ni_srv >> ibegin_srv >> iend_srv >> nj_srv >> jbegin_srv >> jend_srv
1098	>> global_zoom_ni >> global_zoom_ibegin >> global_zoom_nj >> global_zoom_jbegin;
1099
1100	int zoom_iend = global_zoom_ibegin + global_zoom_ni - 1;
1101	int zoom_jend = global_zoom_jbegin + global_zoom_nj - 1;
1102
1103	zoom_ibegin_srv = global_zoom_ibegin > ibegin_srv ? global_zoom_ibegin : ibegin_srv ;
1104	zoom_iend_srv = zoom_iend < iend_srv ? zoom_iend : iend_srv ;
1105	zoom_ni_srv=zoom_iend_srv-zoom_ibegin_srv+1 ;
1106
1107	zoom_jbegin_srv = global_zoom_jbegin > jbegin_srv ? global_zoom_jbegin : jbegin_srv ;
1108	zoom_jend_srv = zoom_jend < jend_srv ? zoom_jend : jend_srv ;
1109	zoom_nj_srv=zoom_jend_srv-zoom_jbegin_srv+1 ;
1110
1111	if (zoom_ni_srv<=0 \|\| zoom_nj_srv<=0)
1112	{
1113	zoom_ibegin_srv=0 ; zoom_iend_srv=0 ; zoom_ni_srv=0 ;
1114	zoom_jbegin_srv=0 ; zoom_jend_srv=0 ; zoom_nj_srv=0 ;
1115	}
1116	lonvalue_srv.resize(zoom_ni_srv*zoom_nj_srv) ;
1117	lonvalue_srv = 0. ;
1118	latvalue_srv.resize(zoom_ni_srv*zoom_nj_srv) ;
1119	latvalue_srv = 0. ;
1120	if (hasBounds)
1121	{
1122	bounds_lon_srv.resize(nvertex,zoom_ni_srv*zoom_nj_srv) ;
1123	bounds_lon_srv = 0. ;
1124	bounds_lat_srv.resize(nvertex,zoom_ni_srv*zoom_nj_srv) ;
1125	bounds_lat_srv = 0. ;
1126	}
1127
1128	if (hasArea)
1129	area_srv.resize(zoom_ni_srv * zoom_nj_srv);
1130	}
1131
1132	void CDomain::recvIndex(CEventServer& event)
1133	{
1134	list<CEventServer::SSubEvent>::iterator it;
1135	for (it = event.subEvents.begin(); it != event.subEvents.end(); ++it)
1136	{
1137	CBufferIn* buffer = it->buffer;
1138	string domainId;
1139	*buffer >> domainId;
1140	get(domainId)->recvIndex(it->rank, *buffer);
1141	}
1142	}
1143
1144	void CDomain::recvIndex(int rank, CBufferIn& buffer)
1145	{
1146	int type_int;
1147	buffer >> type_int >> isCurvilinear >> indiSrv[rank] >> indjSrv[rank];
1148	type.setValue((type_attr::t_enum)type_int); // probleme des type enum avec les buffers : ToFix
1149	}
1150
1151	void CDomain::recvLon(CEventServer& event)
1152	{
1153	list<CEventServer::SSubEvent>::iterator it;
1154	for (it = event.subEvents.begin(); it != event.subEvents.end(); ++it)
1155	{
1156	CBufferIn* buffer = it->buffer;
1157	string domainId;
1158	*buffer >> domainId;
1159	get(domainId)->recvLon(it->rank, *buffer);
1160	}
1161	}
1162
1163	void CDomain::recvLon(int rank, CBufferIn& buffer)
1164	{
1165	CArray<int,1> &indi = indiSrv[rank], &indj = indjSrv[rank];
1166	CArray<double,1> lon;
1167	CArray<double,2> boundslon;
1168
1169	buffer >> lon;
1170	if (hasBounds) buffer >> boundslon;
1171
1172	int i, j, ind_srv;
1173	for (int ind = 0; ind < indi.numElements(); ind++)
1174	{
1175	i = indi(ind); j = indj(ind);
1176	ind_srv = (i - zoom_ibegin_srv) + (j - zoom_jbegin_srv) * zoom_ni_srv;
1177	lonvalue_srv(ind_srv) = lon(ind);
1178	if (hasBounds)
1179	{
1180	for (int nv = 0; nv < nvertex; ++nv)
1181	bounds_lon_srv(nv, ind_srv) = boundslon(nv, ind);
1182	}
1183	}
1184	}
1185
1186	void CDomain::recvLat(CEventServer& event)
1187	{
1188	list<CEventServer::SSubEvent>::iterator it;
1189	for (it = event.subEvents.begin(); it != event.subEvents.end(); ++it)
1190	{
1191	CBufferIn* buffer = it->buffer;
1192	string domainId;
1193	*buffer >> domainId;
1194	get(domainId)->recvLat(it->rank, *buffer);
1195	}
1196	}
1197
1198	void CDomain::recvLat(int rank, CBufferIn& buffer)
1199	{
1200	CArray<int,1> &indi = indiSrv[rank], &indj = indjSrv[rank];
1201	CArray<double,1> lat;
1202	CArray<double,2> boundslat;
1203
1204	buffer >> lat;
1205	if (hasBounds) buffer >> boundslat;
1206
1207	int i, j, ind_srv;
1208	for (int ind = 0; ind < indi.numElements(); ind++)
1209	{
1210	i = indi(ind); j = indj(ind);
1211	ind_srv = (i - zoom_ibegin_srv) + (j - zoom_jbegin_srv) * zoom_ni_srv;
1212	latvalue_srv(ind_srv) = lat(ind);
1213	if (hasBounds)
1214	{
1215	for (int nv = 0; nv < nvertex; nv++)
1216	bounds_lat_srv(nv, ind_srv) = boundslat(nv, ind);
1217	}
1218	}
1219	}
1220
1221	void CDomain::recvArea(CEventServer& event)
1222	{
1223	list<CEventServer::SSubEvent>::iterator it;
1224	for (it = event.subEvents.begin(); it != event.subEvents.end(); ++it)
1225	{
1226	CBufferIn* buffer = it->buffer;
1227	string domainId;
1228	*buffer >> domainId;
1229	get(domainId)->recvArea(it->rank, *buffer);
1230	}
1231	}
1232
1233	void CDomain::recvArea(int rank, CBufferIn& buffer)
1234	{
1235	CArray<int,1> &indi = indiSrv[rank], &indj = indjSrv[rank];
1236	CArray<double,1> clientArea;
1237
1238	buffer >> clientArea;
1239
1240	int i, j, ind_srv;
1241	for (int ind = 0; ind < indi.numElements(); ind++)
1242	{
1243	i = indi(ind); j = indj(ind);
1244	ind_srv = (i - zoom_ibegin_srv) + (j - zoom_jbegin_srv) * zoom_ni_srv;
1245	area_srv(ind_srv) = clientArea(ind);
1246	}
1247	}
1248
1249	bool CDomain::hasTransformation()
1250	{
1251	return (!transformationMap_.empty());
1252	}
1253
1254	void CDomain::setTransformations(const TransMapTypes& domTrans)
1255	{
1256	transformationMap_ = domTrans;
1257	}
1258
1259	CDomain::TransMapTypes CDomain::getAllTransformations(void)
1260	{
1261	return transformationMap_;
1262	}
1263
1264	/*!
1265	Check the validity of all transformations applied on domain
1266	This functions is called AFTER all inherited attributes are solved
1267	*/
1268	void CDomain::checkTransformations()
1269	{
1270	TransMapTypes::const_iterator itb = transformationMap_.begin(), it,
1271	ite = transformationMap_.end();
1272	for (it = itb; it != ite; ++it)
1273	{
1274	(it->second)->checkValid(this);
1275	}
1276	}
1277
1278	void CDomain::solveInheritanceTransformation()
1279	{
1280	if (this->hasTransformation()) return;
1281
1282	std::vector<CDomain*> refDomain;
1283	CDomain* refer_sptr;
1284	CDomain* refer_ptr = this;
1285	while (refer_ptr->hasDirectDomainReference())
1286	{
1287	refDomain.push_back(refer_ptr);
1288	refer_sptr = refer_ptr->getDirectDomainReference();
1289	refer_ptr = refer_sptr;
1290	if (refer_ptr->hasTransformation()) break;
1291	}
1292
1293	if (refer_ptr->hasTransformation())
1294	for (int idx = 0; idx < refDomain.size(); ++idx)
1295	refDomain[idx]->setTransformations(refer_ptr->getAllTransformations());
1296	}
1297
1298	void CDomain::parse(xml::CXMLNode & node)
1299	{
1300	SuperClass::parse(node);
1301
1302	if (node.goToChildElement())
1303	{
1304	StdString zoomDomainDefRoot("zoom_domain_definition");
1305	StdString zoom("zoom_domain");
1306	StdString interpFromFileDomainDefRoot("interpolate_from_file_domain_definition");
1307	StdString interpFromFile("interpolate_from_file_domain");
1308	do
1309	{
1310	if (node.getElementName() == zoom) {
1311	CZoomDomain* tmp = (CZoomDomainGroup::get(zoomDomainDefRoot))->createChild();
1312	tmp->parse(node);
1313	transformationMap_.push_back(std::make_pair(TRANS_ZOOM_DOMAIN,tmp));
1314	}
1315	else if (node.getElementName() == interpFromFile)
1316	{
1317	CInterpolateFromFileDomain* tmp = (CInterpolateFromFileDomainGroup::get(interpFromFileDomainDefRoot))->createChild();
1318	tmp->parse(node);
1319	transformationMap_.push_back(std::make_pair(TRANS_INTERPOLATE_DOMAIN_FROM_FILE,tmp));
1320	}
1321	} while (node.goToNextElement()) ;
1322	node.goToParentElement();
1323	}
1324	}
1325	//----------------------------------------------------------------
1326
1327	DEFINE_REF_FUNC(Domain,domain)
1328
1329	///---------------------------------------------------------------
1330
1331	} // namespace xios

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

Context Navigation

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

Download in other formats: