Context Navigation

← Previous Change
Next Change →

Changeset 1622 for XIOS/trunk/src/node

Timestamp:

12/11/18 13:22:07 (5 years ago)

Author:

oabramkina

Message:

Exception handling on trunk.

To activate it, compilation flag -DXIOS_EXCEPTION should be added.

Location:

XIOS/trunk/src/node

Files:

: 10 edited

axis.cpp (modified) (69 diffs)
context.cpp (modified) (91 diffs)
context.hpp (modified) (2 diffs)
domain.cpp (modified) (108 diffs)
field.cpp (modified) (68 diffs)
field_impl.hpp (modified) (3 diffs)
file.cpp (modified) (87 diffs)
file.hpp (modified) (1 diff)
grid.cpp (modified) (118 diffs)
grid.hpp (modified) (10 diffs)

Legend:

: Unmodified
: Added
: Removed

XIOS/trunk/src/node/axis.cpp

r1566	r1622
48	48	bool CAxis::dummyTransformationMapList_ = CAxis::initializeTransformationMap(CAxis::transformationMapList_);
49	49	bool CAxis::initializeTransformationMap(std::map<StdString, ETranformationType>& m)
	50	TRY
50	51	{
51	52	m["zoom_axis"] = TRANS_ZOOM_AXIS;
…	…
60	61
61	62	}
	63	CATCH
62	64
63	65	///---------------------------------------------------------------
64	66
65	67	const std::set<StdString> & CAxis::getRelFiles(void) const
	68	TRY
66	69	{
67	70	return (this->relFiles);
68	71	}
	72	CATCH
69	73
70	74	bool CAxis::IsWritten(const StdString & filename) const
	75	TRY
71	76	{
72	77	return (this->relFiles.find(filename) != this->relFiles.end());
73	78	}
	79	CATCH
74	80
75	81	bool CAxis::isWrittenCompressed(const StdString& filename) const
	82	TRY
76	83	{
77	84	return (this->relFilesCompressed.find(filename) != this->relFilesCompressed.end());
78	85	}
	86	CATCH
79	87
80	88	bool CAxis::isDistributed(void) const
	89	TRY
81	90	{
82	91	bool distributed = (!this->begin.isEmpty() && !this->n.isEmpty() && (this->begin + this->n < this->n_glo)) \|\|
83	92	(!this->n.isEmpty() && (this->n != this->n_glo));
84		// A ~~same stupid~~ condition to make sure that if there is only one client, axis
	93	// A condition to make sure that if there is only one client, axis
85	94	// should be considered to be distributed. This should be a temporary solution
86	95	distributed \|= (1 == CContext::getCurrent()->client->clientSize);
87	96	return distributed;
88	97	}
	98	CATCH
89	99
90	100	/*!
…	…
94	104	*/
95	105	bool CAxis::isCompressible(void) const
	106	TRY
96	107	{
97	108	return isCompressible_;
98	109	}
	110	CATCH
99	111
100	112	void CAxis::addRelFile(const StdString & filename)
	113	TRY
101	114	{
102	115	this->relFiles.insert(filename);
103	116	}
	117	CATCH_DUMP_ATTR
104	118
105	119	void CAxis::addRelFileCompressed(const StdString& filename)
	120	TRY
106	121	{
107	122	this->relFilesCompressed.insert(filename);
108	123	}
	124	CATCH_DUMP_ATTR
109	125
110	126	//----------------------------------------------------------------
…	…
115	131	*/
116	132	int CAxis::getNumberWrittenIndexes(MPI_Comm writtenCom)
	133	TRY
117	134	{
118	135	int writtenSize;
…	…
120	137	return numberWrittenIndexes_[writtenSize];
121	138	}
	139	CATCH_DUMP_ATTR
122	140
123	141	/*!
…	…
126	144	*/
127	145	int CAxis::getTotalNumberWrittenIndexes(MPI_Comm writtenCom)
	146	TRY
128	147	{
129	148	int writtenSize;
…	…
131	150	return totalNumberWrittenIndexes_[writtenSize];
132	151	}
	152	CATCH_DUMP_ATTR
133	153
134	154	/*!
…	…
137	157	*/
138	158	int CAxis::getOffsetWrittenIndexes(MPI_Comm writtenCom)
	159	TRY
139	160	{
140	161	int writtenSize;
…	…
142	163	return offsetWrittenIndexes_[writtenSize];
143	164	}
	165	CATCH_DUMP_ATTR
144	166
145	167	CArray<int, 1>& CAxis::getCompressedIndexToWriteOnServer(MPI_Comm writtenCom)
	168	TRY
146	169	{
147	170	int writtenSize;
…	…
149	172	return compressedIndexToWriteOnServer[writtenSize];
150	173	}
	174	CATCH_DUMP_ATTR
	175
151	176	//----------------------------------------------------------------
152	177
…	…
158	183	std::map<int, StdSize> CAxis::getAttributesBufferSize(CContextClient* client, const std::vector<int>& globalDim, int orderPositionInGrid,
159	184	CServerDistributionDescription::ServerDistributionType distType)
	185	TRY
160	186	{
161	187
…	…
221	247	}
222	248	}
223
224	249	return attributesSizes;
225	250	}
	251	CATCH_DUMP_ATTR
226	252
227	253	//----------------------------------------------------------------
…	…
234	260
235	261	CAxis* CAxis::createAxis()
	262	TRY
236	263	{
237	264	CAxis* axis = CAxisGroup::get("axis_definition")->createChild();
238	265	return axis;
239	266	}
	267	CATCH
240	268
241	269	/*!
…	…
244	272	*/
245	273	void CAxis::checkAttributes(void)
	274	TRY
246	275	{
247	276	if (this->n_glo.isEmpty())
…	…
285	314	}
286	315
287		// Remove this check because it doen't make sense in case of a hole or overlapping axes
	316	// Remove this check because it doesn't make sense in case of a hole or overlapping axes
288	317	if (!this->value.isEmpty())
289	318	{
…	…
306	335	}
307	336	}
	337	CATCH_DUMP_ATTR
308	338
309	339	/*!
…	…
311	341	*/
312	342	void CAxis::checkData()
	343	TRY
313	344	{
314	345	if (data_begin.isEmpty()) data_begin.setValue(0);
…	…
331	362	}
332	363	}
	364	CATCH_DUMP_ATTR
333	365
334	366	size_t CAxis::getGlobalWrittenSize(void)
…	…
341	373	*/
342	374	void CAxis::checkMask()
	375	TRY
343	376	{
344	377	if (!mask.isEmpty())
…	…
360	393	}
361	394	}
	395	CATCH_DUMP_ATTR
362	396
363	397	/*!
…	…
365	399	*/
366	400	void CAxis::checkBounds()
	401	TRY
367	402	{
368	403	if (!bounds.isEmpty())
…	…
377	412	else hasBounds = false;
378	413	}
	414	CATCH_DUMP_ATTR
379	415
380	416	void CAxis::checkLabel()
	417	TRY
381	418	{
382	419	if (!label.isEmpty())
…	…
391	428	else hasLabel = false;
392	429	}
	430	CATCH_DUMP_ATTR
393	431
394	432	/*!
…	…
396	434	*/
397	435	void CAxis::checkEligibilityForCompressedOutput()
	436	TRY
398	437	{
399	438	// We don't check if the mask is valid here, just if a mask has been defined at this point.
400	439	isCompressible_ = !mask.isEmpty();
401	440	}
	441	CATCH_DUMP_ATTR
402	442
403	443	/*!
…	…
405	445	*/
406	446	bool CAxis::dispatchEvent(CEventServer& event)
	447	TRY
407	448	{
408	449	if (SuperClass::dispatchEvent(event)) return true;
…	…
430	471	}
431	472	}
	473	CATCH
432	474
433	475	/*!
…	…
435	477	*/
436	478	void CAxis::checkAttributesOnClient()
	479	TRY
437	480	{
438	481	if (this->areClientAttributesChecked_) return;
…	…
443	486	this->areClientAttributesChecked_ = true;
444	487	}
	488	CATCH_DUMP_ATTR
445	489
446	490	/*
…	…
450	494	void CAxis::checkAttributesOnClientAfterTransformation(const std::vector<int>& globalDim, int orderPositionInGrid,
451	495	CServerDistributionDescription::ServerDistributionType distType)
	496	TRY
452	497	{
453	498	CContext* context=CContext::getCurrent() ;
…	…
463	508	this->isClientAfterTransformationChecked = true;
464	509	}
	510	CATCH_DUMP_ATTR
465	511
466	512	/*
…	…
473	519	void CAxis::sendCheckedAttributes(const std::vector<int>& globalDim, int orderPositionInGrid,
474	520	CServerDistributionDescription::ServerDistributionType distType)
	521	TRY
475	522	{
476	523	if (!this->areClientAttributesChecked_) checkAttributesOnClient();
…	…
483	530	this->isChecked = true;
484	531	}
	532	CATCH_DUMP_ATTR
485	533
486	534	/*!
…	…
491	539	void CAxis::sendAttributes(const std::vector<int>& globalDim, int orderPositionInGrid,
492	540	CServerDistributionDescription::ServerDistributionType distType)
	541	TRY
493	542	{
494	543	sendDistributionAttribute(globalDim, orderPositionInGrid, distType);
…	…
505	554	}
506	555	}
	556	CATCH_DUMP_ATTR
507	557
508	558	/*
…	…
516	566	void CAxis::computeConnectedClients(const std::vector<int>& globalDim, int orderPositionInGrid,
517	567	CServerDistributionDescription::ServerDistributionType distType)
	568	TRY
518	569	{
519	570	CContext* context = CContext::getCurrent();
…	…
635	686	}
636	687	}
	688	CATCH_DUMP_ATTR
637	689
638	690	/*
…	…
642	694	*/
643	695	void CAxis::computeWrittenIndex()
	696	TRY
644	697	{
645	698	if (computedWrittenIndex_) return;
…	…
688	741	}
689	742	}
	743	CATCH_DUMP_ATTR
690	744
691	745	void CAxis::computeWrittenCompressedIndex(MPI_Comm writtenComm)
	746	TRY
692	747	{
693	748	int writtenCommSize;
…	…
758	813	}
759	814	}
	815	CATCH_DUMP_ATTR
760	816
761	817	/*!
…	…
768	824	void CAxis::sendDistributionAttribute(const std::vector<int>& globalDim, int orderPositionInGrid,
769	825	CServerDistributionDescription::ServerDistributionType distType)
	826	TRY
770	827	{
771	828	std::list<CContextClient*>::iterator it;
…	…
806	863	}
807	864	}
	865	CATCH_DUMP_ATTR
808	866
809	867	/*
…	…
812	870	*/
813	871	void CAxis::recvDistributionAttribute(CEventServer& event)
	872	TRY
814	873	{
815	874	CBufferIn* buffer = event.subEvents.begin()->buffer;
…	…
818	877	get(axisId)->recvDistributionAttribute(*buffer);
819	878	}
	879	CATCH
820	880
821	881	/*
…	…
824	884	*/
825	885	void CAxis::recvDistributionAttribute(CBufferIn& buffer)
	886	TRY
826	887	{
827	888	int ni_srv, begin_srv;
…	…
833	894	begin.setValue(begin_srv);
834	895	}
	896	CATCH_DUMP_ATTR
835	897
836	898	/*
…	…
840	902	*/
841	903	void CAxis::sendNonDistributedAttributes()
	904	TRY
842	905	{
843	906	std::list<CContextClient*>::iterator it;
…	…
893	956	}
894	957	}
	958	CATCH_DUMP_ATTR
895	959
896	960	/*
…	…
899	963	*/
900	964	void CAxis::recvNonDistributedAttributes(CEventServer& event)
	965	TRY
901	966	{
902	967	list<CEventServer::SSubEvent>::iterator it;
…	…
909	974	}
910	975	}
	976	CATCH
911	977
912	978	/*
…	…
916	982	*/
917	983	void CAxis::recvNonDistributedAttributes(int rank, CBufferIn& buffer)
	984	TRY
918	985	{
919	986	CArray<int,1> tmp_index, tmp_data_index;
…	…
957	1024	for (int idx = 0; idx < index.numElements(); ++idx) globalLocalIndexMap_[index(idx)] = idx;
958	1025	}
	1026	CATCH_DUMP_ATTR
959	1027
960	1028	/*
…	…
964	1032	*/
965	1033	void CAxis::sendDistributedAttributes(void)
	1034	TRY
966	1035	{
967	1036	int ns, n, i, j, ind, nv, idx;
…	…
1069	1138	}
1070	1139	}
	1140	CATCH_DUMP_ATTR
1071	1141
1072	1142	/*
…	…
1075	1145	*/
1076	1146	void CAxis::recvDistributedAttributes(CEventServer& event)
	1147	TRY
1077	1148	{
1078	1149	string axisId;
…	…
1090	1161	get(axisId)->recvDistributedAttributes(ranks, buffers);
1091	1162	}
	1163	CATCH
1092	1164
1093	1165	/*
…	…
1097	1169	*/
1098	1170	void CAxis::recvDistributedAttributes(vector<int>& ranks, vector<CBufferIn*> buffers)
	1171	TRY
1099	1172	{
1100	1173	int nbReceived = ranks.size(), idx, ind, gloInd, locInd;
…	…
1219	1292	data_begin.setValue(0);
1220	1293	}
1221
	1294	CATCH_DUMP_ATTR
1222	1295
1223	1296	/*!
…	…
1229	1302	*/
1230	1303	bool CAxis::isEqual(CAxis* obj)
	1304	TRY
1231	1305	{
1232	1306	vector<StdString> excludedAttr;
…	…
1252	1326	return objEqual;
1253	1327	}
	1328	CATCH_DUMP_ATTR
1254	1329
1255	1330	/*
…	…
1259	1334	*/
1260	1335	CTransformation<CAxis>* CAxis::addTransformation(ETranformationType transType, const StdString& id)
	1336	TRY
1261	1337	{
1262	1338	transformationMap_.push_back(std::make_pair(transType, CTransformation<CAxis>::createTransformation(transType,id)));
1263	1339	return transformationMap_.back().second;
1264	1340	}
	1341	CATCH_DUMP_ATTR
1265	1342
1266	1343	/*
…	…
1268	1345	*/
1269	1346	bool CAxis::hasTransformation()
	1347	TRY
1270	1348	{
1271	1349	return (!transformationMap_.empty());
1272	1350	}
	1351	CATCH_DUMP_ATTR
1273	1352
1274	1353	/*
…	…
1277	1356	*/
1278	1357	void CAxis::setTransformations(const TransMapTypes& axisTrans)
	1358	TRY
1279	1359	{
1280	1360	transformationMap_ = axisTrans;
1281	1361	}
	1362	CATCH_DUMP_ATTR
1282	1363
1283	1364	/*
…	…
1286	1367	*/
1287	1368	CAxis::TransMapTypes CAxis::getAllTransformations(void)
	1369	TRY
1288	1370	{
1289	1371	return transformationMap_;
1290	1372	}
	1373	CATCH_DUMP_ATTR
1291	1374
1292	1375	/*
…	…
1295	1378	*/
1296	1379	void CAxis::duplicateTransformation(CAxis* src)
	1380	TRY
1297	1381	{
1298	1382	if (src->hasTransformation())
…	…
1301	1385	}
1302	1386	}
	1387	CATCH_DUMP_ATTR
1303	1388
1304	1389	/*!
…	…
1306	1391	*/
1307	1392	void CAxis::solveInheritanceTransformation()
	1393	TRY
1308	1394	{
1309	1395	if (hasTransformation() \|\| !hasDirectAxisReference())
…	…
1322	1408	refAxis[i]->setTransformations(axis->getAllTransformations());
1323	1409	}
	1410	CATCH_DUMP_ATTR
1324	1411
1325	1412	void CAxis::setContextClient(CContextClient* contextClient)
	1413	TRY
1326	1414	{
1327	1415	if (clientsSet.find(contextClient)==clientsSet.end())
…	…
1330	1418	clientsSet.insert(contextClient);
1331	1419	}
1332		}
	1420	}
	1421	CATCH_DUMP_ATTR
1333	1422
1334	1423	void CAxis::parse(xml::CXMLNode & node)
	1424	TRY
1335	1425	{
1336	1426	SuperClass::parse(node);
…	…
1363	1453	}
1364	1454	}
	1455	CATCH_DUMP_ATTR
1365	1456
1366	1457	DEFINE_REF_FUNC(Axis,axis)

XIOS/trunk/src/node/context.cpp

r1542	r1622
33	33	, idServer_(), client(0), server(0)
34	34	, allProcessed(false), countChildCtx_(0)
	35
35	36	{ /* Ne rien faire de plus */ }
36	37
…	…
65	66	*/
66	67	CContextGroup* CContext::getRoot(void)
	68	TRY
67	69	{
68	70	if (root.get()==NULL) root=std::shared_ptr<CContextGroup>(new CContextGroup(xml::CXMLNode::GetRootName()));
69	71	return root.get();
70	72	}
	73	CATCH
71	74
72	75	//----------------------------------------------------------------
…	…
77	80	*/
78	81	std::shared_ptr<CCalendar> CContext::getCalendar(void) const
	82	TRY
79	83	{
80	84	return (this->calendar);
81	85	}
	86	CATCH
82	87
83	88	//----------------------------------------------------------------
…	…
88	93	*/
89	94	void CContext::setCalendar(std::shared_ptr<CCalendar> newCalendar)
	95	TRY
90	96	{
91	97	this->calendar = newCalendar;
92	98	}
	99	CATCH_DUMP_ATTR
93	100
94	101	//----------------------------------------------------------------
…	…
98	105	*/
99	106	void CContext::parse(xml::CXMLNode & node)
	107	TRY
100	108	{
101	109	CContext::SuperClass::parse(node);
…	…
152	160	}
153	161	}
	162	CATCH_DUMP_ATTR
154	163
155	164	//----------------------------------------------------------------
156	165	//! Show tree structure of context
157	166	void CContext::ShowTree(StdOStream & out)
	167	TRY
158	168	{
159	169	StdString currentContextId = CContext::getCurrent() -> getId();
…	…
176	186	CContext::setCurrent(currentContextId);
177	187	}
178
	188	CATCH
179	189
180	190	//----------------------------------------------------------------
…	…
182	192	//! Convert context object into string (to print)
183	193	StdString CContext::toString(void) const
	194	TRY
184	195	{
185	196	StdOStringStream oss;
…	…
201	212
202	213	}
203
204	214	oss << "</" << CContext::GetName() << " >";
205
206	215	return (oss.str());
207	216	}
	217	CATCH
208	218
209	219	//----------------------------------------------------------------
…	…
216	226	*/
217	227	void CContext::solveDescInheritance(bool apply, const CAttributeMap * const UNUSED(parent))
	228	TRY
218	229	{
219	230	#define DECLARE_NODE(Name_, name_) \
…	…
223	234	#include "node_type.conf"
224	235	}
	236	CATCH_DUMP_ATTR
225	237
226	238	//----------------------------------------------------------------
…	…
228	240	//! Verify if all root definition in the context have child.
229	241	bool CContext::hasChild(void) const
	242	TRY
230	243	{
231	244	return (
…	…
236	249	false);
237	250	}
	251	CATCH
238	252
239	253	//----------------------------------------------------------------
240	254
241	255	void CContext::CleanTree(void)
	256	TRY
242	257	{
243	258	#define DECLARE_NODE(Name_, name_) C##Name_##Definition::ClearAllAttributes();
…	…
245	260	#include "node_type.conf"
246	261	}
	262	CATCH
	263
247	264	///---------------------------------------------------------------
248	265
249	266	//! Initialize client side
250	267	void CContext::initClient(MPI_Comm intraComm, MPI_Comm interComm, CContext* cxtServer /= 0/)
	268	TRY
251	269	{
252	270
…	…
298	316	}
299	317	}
	318	CATCH_DUMP_ATTR
300	319
301	320	/*!
…	…
306	325	*/
307	326	void CContext::setClientServerBuffer(CContextClient* contextClient, bool bufferForWriting)
	327	TRY
308	328	{
309	329	// Estimated minimum event size for small events (10 is an arbitrary constant just for safety)
…	…
352	372	}
353	373	contextClient->setBufferSize(bufferSize, maxEventSize);
354
355		}
	374	}
	375	CATCH_DUMP_ATTR
356	376
357	377	//! Verify whether a context is initialized
358	378	bool CContext::isInitialized(void)
	379	TRY
359	380	{
360	381	return hasClient;
361	382	}
	383	CATCH_DUMP_ATTR
362	384
363	385	void CContext::initServer(MPI_Comm intraComm, MPI_Comm interComm, CContext* cxtClient /= 0/)
	386	TRY
364	387	{
365	388	hasServer=true;
…	…
394	417	client = new CContextClient(this,intraCommClient,interCommClient, cxtClient);
395	418	}
	419	CATCH_DUMP_ATTR
396	420
397	421	//! Try to send the buffers and receive possible answers
398	422	bool CContext::checkBuffersAndListen(bool enableEventsProcessing /= true/)
	423	TRY
399	424	{
400	425	bool clientReady, serverFinished;
…	…
434	459	}
435	460	}
	461	CATCH_DUMP_ATTR
436	462
437	463	//! Terminate a context
438	464	void CContext::finalize(void)
	465	TRY
439	466	{
440	467	if (hasClient && !hasServer) // For now we only use server level 1 to read data
…	…
527	554	}
528	555	}
	556	CATCH_DUMP_ATTR
529	557
530	558	//! Free internally allocated communicators
531	559	void CContext::freeComms(void)
	560	TRY
532	561	{
533	562	for (std::list<MPI_Comm>::iterator it = comms.begin(); it != comms.end(); ++it)
…	…
535	564	comms.clear();
536	565	}
	566	CATCH_DUMP_ATTR
537	567
538	568	//! Deallocate buffers allocated by clientContexts
539	569	void CContext::releaseClientBuffers(void)
	570	TRY
540	571	{
541	572	client->releaseBuffers();
…	…
543	574	clientPrimServer[i]->releaseBuffers();
544	575	}
	576	CATCH_DUMP_ATTR
545	577
546	578	void CContext::postProcessingGlobalAttributes()
	579	TRY
547	580	{
548	581	if (allProcessed) return;
…	…
608	641	allProcessed = true;
609	642	}
	643	CATCH_DUMP_ATTR
610	644
611	645	void CContext::sendPostProcessingGlobalAttributes()
	646	TRY
612	647	{
613	648	// Use correct context client to send message
…	…
634	669	}
635	670	}
	671	CATCH_DUMP_ATTR
636	672
637	673	void CContext::recvPostProcessingGlobalAttributes(CEventServer& event)
	674	TRY
638	675	{
639	676	CBufferIn* buffer=event.subEvents.begin()->buffer;
…	…
642	679	get(id)->recvPostProcessingGlobalAttributes(*buffer);
643	680	}
	681	CATCH
644	682
645	683	void CContext::recvPostProcessingGlobalAttributes(CBufferIn& buffer)
	684	TRY
646	685	{
647	686	postProcessingGlobalAttributes();
648	687	}
	688	CATCH_DUMP_ATTR
649	689
650	690	/*!
…	…
657	697	and the active fields (fields will be written onto active files)
658	698	*/
	699
659	700	void CContext::closeDefinition(void)
	701	TRY
660	702	{
661	703	CTimer::get("Context : close definition").resume() ;
…	…
688	730	CTimer::get("Context : close definition").suspend() ;
689	731	}
	732	CATCH_DUMP_ATTR
690	733
691	734	void CContext::findAllEnabledFieldsInFiles(const std::vector<CFile*>& activeFiles)
	735	TRY
692	736	{
693	737	for (unsigned int i = 0; i < activeFiles.size(); i++)
694	738	(void)activeFiles[i]->getEnabledFields();
695	739	}
	740	CATCH_DUMP_ATTR
696	741
697	742	void CContext::readAttributesOfEnabledFieldsInReadModeFiles()
	743	TRY
698	744	{
699	745	for (unsigned int i = 0; i < this->enabledReadModeFiles.size(); ++i)
700	746	(void)this->enabledReadModeFiles[i]->readAttributesOfEnabledFieldsInReadMode();
701	747	}
	748	CATCH_DUMP_ATTR
702	749
703	750	void CContext::sendGridComponentEnabledFieldsInFiles(const std::vector<CFile*>& activeFiles)
	751	TRY
704	752	{
705	753	int size = activeFiles.size();
…	…
709	757	}
710	758	}
	759	CATCH_DUMP_ATTR
711	760
712	761	/*!
…	…
715	764	*/
716	765	void CContext::sendGridEnabledFieldsInFiles(const std::vector<CFile*>& activeFiles)
	766	TRY
717	767	{
718	768	int size = activeFiles.size();
…	…
722	772	}
723	773	}
	774	CATCH_DUMP_ATTR
724	775
725	776	void CContext::checkGridEnabledFields()
	777	TRY
726	778	{
727	779	int size = enabledFiles.size();
…	…
731	783	}
732	784	}
	785	CATCH_DUMP_ATTR
733	786
734	787	/*!
…	…
737	790	*/
738	791	void CContext::checkGridEnabledFieldsInFiles(const std::vector<CFile*>& activeFiles)
	792	TRY
739	793	{
740	794	int size = activeFiles.size();
…	…
744	798	}
745	799	}
	800	CATCH_DUMP_ATTR
746	801
747	802	/*!
…	…
751	806	*/
752	807	void CContext::solveOnlyRefOfEnabledFields(bool sendToServer)
	808	TRY
753	809	{
754	810	int size = this->enabledFiles.size();
…	…
763	819	}
764	820	}
	821	CATCH_DUMP_ATTR
765	822
766	823	/*!
…	…
771	828	*/
772	829	void CContext::solveAllRefOfEnabledFieldsAndTransform(bool sendToServer)
	830	TRY
773	831	{
774	832	int size = this->enabledFiles.size();
…	…
778	836	}
779	837	}
	838	CATCH_DUMP_ATTR
780	839
781	840	void CContext::buildFilterGraphOfEnabledFields()
	841	TRY
782	842	{
783	843	int size = this->enabledFiles.size();
…	…
787	847	}
788	848	}
	849	CATCH_DUMP_ATTR
789	850
790	851	void CContext::postProcessFilterGraph()
	852	TRY
791	853	{
792	854	int size = enabledFiles.size();
…	…
796	858	}
797	859	}
	860	CATCH_DUMP_ATTR
798	861
799	862	void CContext::startPrefetchingOfEnabledReadModeFiles()
	863	TRY
800	864	{
801	865	int size = enabledReadModeFiles.size();
…	…
805	869	}
806	870	}
	871	CATCH_DUMP_ATTR
807	872
808	873	void CContext::doPreTimestepOperationsForEnabledReadModeFiles()
	874	TRY
809	875	{
810	876	int size = enabledReadModeFiles.size();
…	…
814	880	}
815	881	}
	882	CATCH_DUMP_ATTR
816	883
817	884	void CContext::doPostTimestepOperationsForEnabledReadModeFiles()
	885	TRY
818	886	{
819	887	int size = enabledReadModeFiles.size();
…	…
823	891	}
824	892	}
	893	CATCH_DUMP_ATTR
825	894
826	895	void CContext::findFieldsWithReadAccess(void)
	896	TRY
827	897	{
828	898	fieldsWithReadAccess.clear();
…	…
838	908	}
839	909	}
	910	CATCH_DUMP_ATTR
840	911
841	912	void CContext::solveAllRefOfFieldsWithReadAccess()
	913	TRY
842	914	{
843	915	for (size_t i = 0; i < fieldsWithReadAccess.size(); ++i)
844	916	fieldsWithReadAccess[i]->solveAllReferenceEnabledField(false);
845	917	}
	918	CATCH_DUMP_ATTR
846	919
847	920	void CContext::buildFilterGraphOfFieldsWithReadAccess()
	921	TRY
848	922	{
849	923	for (size_t i = 0; i < fieldsWithReadAccess.size(); ++i)
850	924	fieldsWithReadAccess[i]->buildFilterGraph(garbageCollector, true);
851	925	}
	926	CATCH_DUMP_ATTR
852	927
853	928	void CContext::solveAllInheritance(bool apply)
	929	TRY
854	930	{
855	931	// RÃ©solution des hÃ©ritages descendants (cÃ d des hÃ©ritages de groupes)
…	…
874	950
875	951	}
	952	CATCH_DUMP_ATTR
876	953
877	954	void CContext::findEnabledFiles(void)
	955	TRY
878	956	{
879	957	const std::vector<CFile*> allFiles = CFile::getAll();
…	…
924	1002
925	1003	}
	1004	CATCH_DUMP_ATTR
926	1005
927	1006	void CContext::distributeFiles(void)
	1007	TRY
928	1008	{
929	1009	bool distFileMemory=false ;
…	…
933	1013	else distributeFileOverBandwith() ;
934	1014	}
935
	1015	CATCH_DUMP_ATTR
936	1016
937	1017	void CContext::distributeFileOverBandwith(void)
	1018	TRY
938	1019	{
939	1020	double eps=std::numeric_limits<double>::epsilon()*10 ;
…	…
1015	1096	}
1016	1097	}
	1098	CATCH_DUMP_ATTR
1017	1099
1018	1100	void CContext::distributeFileOverMemoryBandwith(void)
	1101	TRY
1019	1102	{
1020	1103	// If primary server
…	…
1107	1190	}
1108	1191	}
1109
1110
	1192	CATCH_DUMP_ATTR
1111	1193
1112	1194	/*!
…	…
1114	1196	*/
1115	1197	void CContext::findEnabledWriteModeFiles(void)
	1198	TRY
1116	1199	{
1117	1200	int size = this->enabledFiles.size();
…	…
1123	1206	}
1124	1207	}
	1208	CATCH_DUMP_ATTR
1125	1209
1126	1210	/*!
…	…
1128	1212	*/
1129	1213	void CContext::findEnabledReadModeFiles(void)
	1214	TRY
1130	1215	{
1131	1216	int size = this->enabledFiles.size();
…	…
1136	1221	}
1137	1222	}
	1223	CATCH_DUMP_ATTR
1138	1224
1139	1225	void CContext::closeAllFile(void)
	1226	TRY
1140	1227	{
1141	1228	std::vector<CFile*>::const_iterator
…	…
1148	1235	}
1149	1236	}
	1237	CATCH_DUMP_ATTR
1150	1238
1151	1239	/*!
…	…
1157	1245	*/
1158	1246	bool CContext::dispatchEvent(CEventServer& event)
	1247	TRY
1159	1248	{
1160	1249
…	…
1198	1287	}
1199	1288	}
	1289	CATCH
1200	1290
1201	1291	//! Client side: Send a message to server to make it close
1202	1292	void CContext::sendCloseDefinition(void)
	1293	TRY
1203	1294	{
1204	1295	// Use correct context client to send message
…	…
1223	1314	}
1224	1315	}
	1316	CATCH_DUMP_ATTR
1225	1317
1226	1318	//! Server side: Receive a message of client announcing a context close
1227	1319	void CContext::recvCloseDefinition(CEventServer& event)
	1320	TRY
1228	1321	{
1229	1322	CBufferIn* buffer=event.subEvents.begin()->buffer;
…	…
1232	1325	get(id)->closeDefinition();
1233	1326	}
	1327	CATCH
1234	1328
1235	1329	//! Client side: Send a message to update calendar in each time step
1236	1330	void CContext::sendUpdateCalendar(int step)
	1331	TRY
1237	1332	{
1238	1333	// Use correct context client to send message
…	…
1258	1353	}
1259	1354	}
	1355	CATCH_DUMP_ATTR
1260	1356
1261	1357	//! Server side: Receive a message of client annoucing calendar update
1262	1358	void CContext::recvUpdateCalendar(CEventServer& event)
	1359	TRY
1263	1360	{
1264	1361	CBufferIn* buffer=event.subEvents.begin()->buffer;
…	…
1267	1364	get(id)->recvUpdateCalendar(*buffer);
1268	1365	}
	1366	CATCH
1269	1367
1270	1368	//! Server side: Receive a message of client annoucing calendar update
1271	1369	void CContext::recvUpdateCalendar(CBufferIn& buffer)
	1370	TRY
1272	1371	{
1273	1372	int step;
…	…
1279	1378	}
1280	1379	}
	1380	CATCH_DUMP_ATTR
1281	1381
1282	1382	//! Client side: Send a message to create header part of netcdf file
1283	1383	void CContext::sendCreateFileHeader(void)
	1384	TRY
1284	1385	{
1285	1386	// Use correct context client to send message
…	…
1306	1407	}
1307	1408	}
	1409	CATCH_DUMP_ATTR
1308	1410
1309	1411	//! Server side: Receive a message of client annoucing the creation of header part of netcdf file
1310	1412	void CContext::recvCreateFileHeader(CEventServer& event)
	1413	TRY
1311	1414	{
1312	1415	CBufferIn* buffer=event.subEvents.begin()->buffer;
…	…
1315	1418	get(id)->recvCreateFileHeader(*buffer);
1316	1419	}
	1420	CATCH
1317	1421
1318	1422	//! Server side: Receive a message of client annoucing the creation of header part of netcdf file
1319	1423	void CContext::recvCreateFileHeader(CBufferIn& buffer)
	1424	TRY
1320	1425	{
1321	1426	if (!hasClient && hasServer)
1322	1427	createFileHeader();
1323	1428	}
	1429	CATCH_DUMP_ATTR
1324	1430
1325	1431	//! Client side: Send a message to do some post processing on server
1326	1432	void CContext::sendProcessingGridOfEnabledFields()
	1433	TRY
1327	1434	{
1328	1435	// Use correct context client to send message
…	…
1348	1455	}
1349	1456	}
	1457	CATCH_DUMP_ATTR
1350	1458
1351	1459	//! Server side: Receive a message to do some post processing
1352	1460	void CContext::recvProcessingGridOfEnabledFields(CEventServer& event)
	1461	TRY
1353	1462	{
1354	1463	CBufferIn* buffer=event.subEvents.begin()->buffer;
…	…
1356	1465	*buffer>>id;
1357	1466	}
	1467	CATCH
1358	1468
1359	1469	//! Client side: Send a message to do some post processing on server
1360	1470	void CContext::sendPostProcessing()
	1471	TRY
1361	1472	{
1362	1473	// Use correct context client to send message
…	…
1382	1493	}
1383	1494	}
	1495	CATCH_DUMP_ATTR
1384	1496
1385	1497	//! Server side: Receive a message to do some post processing
1386	1498	void CContext::recvPostProcessing(CEventServer& event)
	1499	TRY
1387	1500	{
1388	1501	CBufferIn* buffer=event.subEvents.begin()->buffer;
…	…
1391	1504	get(id)->recvPostProcessing(*buffer);
1392	1505	}
	1506	CATCH
1393	1507
1394	1508	//! Server side: Receive a message to do some post processing
1395	1509	void CContext::recvPostProcessing(CBufferIn& buffer)
	1510	TRY
1396	1511	{
1397	1512	CCalendarWrapper::get(CCalendarWrapper::GetDefName())->createCalendar();
1398	1513	postProcessing();
1399	1514	}
	1515	CATCH_DUMP_ATTR
1400	1516
1401	1517	const StdString& CContext::getIdServer()
	1518	TRY
1402	1519	{
1403	1520	if (hasClient)
…	…
1409	1526	if (hasServer) return (this->getId());
1410	1527	}
	1528	CATCH_DUMP_ATTR
1411	1529
1412	1530	const StdString& CContext::getIdServer(const int i)
	1531	TRY
1413	1532	{
1414	1533	idServer_ = this->getId();
…	…
1417	1536	return idServer_;
1418	1537	}
1419
	1538	CATCH_DUMP_ATTR
1420	1539
1421	1540	/*!
…	…
1426	1545	*/
1427	1546	void CContext::postProcessing()
	1547	TRY
1428	1548	{
1429	1549	if (isPostProcessed) return;
…	…
1488	1608	isPostProcessed = true;
1489	1609	}
	1610	CATCH_DUMP_ATTR
1490	1611
1491	1612	/*!
…	…
1498	1619	std::map<int, StdSize> CContext::getAttributesBufferSize(std::map<int, StdSize>& maxEventSize,
1499	1620	CContextClient* contextClient, bool bufferForWriting /= "false"/)
	1621	TRY
1500	1622	{
1501	1623	// As calendar attributes are sent even if there are no active files or fields, maps are initialized according the size of calendar attributes
…	…
1529	1651	return attributesSize;
1530	1652	}
	1653	CATCH_DUMP_ATTR
1531	1654
1532	1655	/*!
…	…
1539	1662	std::map<int, StdSize> CContext::getDataBufferSize(std::map<int, StdSize>& maxEventSize,
1540	1663	CContextClient* contextClient, bool bufferForWriting /= "false"/)
	1664	TRY
1541	1665	{
1542	1666	std::map<int, StdSize> dataSize;
…	…
1547	1671	for (size_t i = 0; i < numEnabledFiles; ++i)
1548	1672	{
1549		~~// CFile* file = this->enabledFiles[i];~~
1550	1673	CFile* file = fileList[i];
1551	1674	if (file->getContextClient() == contextClient)
…	…
1575	1698	return dataSize;
1576	1699	}
	1700	CATCH_DUMP_ATTR
1577	1701
1578	1702	//! Client side: Send infomation of active files (files are enabled to write out)
1579	1703	void CContext::sendEnabledFiles(const std::vector<CFile*>& activeFiles)
	1704	TRY
1580	1705	{
1581	1706	int size = activeFiles.size();
…	…
1595	1720	}
1596	1721	}
	1722	CATCH_DUMP_ATTR
1597	1723
1598	1724	//! Client side: Send information of active fields (ones are written onto files)
1599	1725	void CContext::sendEnabledFieldsInFiles(const std::vector<CFile*>& activeFiles)
	1726	TRY
1600	1727	{
1601	1728	int size = activeFiles.size();
…	…
1605	1732	}
1606	1733	}
	1734	CATCH_DUMP_ATTR
1607	1735
1608	1736	//! Client side: Check if the defined axis, domains and grids are eligible for compressed indexed output
1609	1737	void CContext::checkAxisDomainsGridsEligibilityForCompressedOutput()
	1738	TRY
1610	1739	{
1611	1740	if (!hasClient) return;
…	…
1623	1752	(*it)->checkEligibilityForCompressedOutput();
1624	1753	}
	1754	CATCH_DUMP_ATTR
1625	1755
1626	1756	//! Client side: Prepare the timeseries by adding the necessary files
1627	1757	void CContext::prepareTimeseries()
	1758	TRY
1628	1759	{
1629	1760	if (!hasClient) return;
…	…
1723	1854	}
1724	1855	}
	1856	CATCH_DUMP_ATTR
1725	1857
1726	1858	//! Client side: Send information of reference grid of active fields
1727	1859	void CContext::sendRefGrid(const std::vector<CFile*>& activeFiles)
	1860	TRY
1728	1861	{
1729	1862	std::set<StdString> gridIds;
…	…
1757	1890	}
1758	1891	}
	1892	CATCH_DUMP_ATTR
1759	1893
1760	1894	//! Client side: Send information of reference domain, axis and scalar of active fields
1761	1895	void CContext::sendRefDomainsAxisScalars(const std::vector<CFile*>& activeFiles)
	1896	TRY
1762	1897	{
1763	1898	std::set<StdString> domainIds, axisIds, scalarIds;
…	…
1818	1953	}
1819	1954	}
	1955	CATCH_DUMP_ATTR
1820	1956
1821	1957	//! Update calendar in each time step
1822	1958	void CContext::updateCalendar(int step)
	1959	TRY
1823	1960	{
1824	1961	int prevStep = calendar->getStep();
…	…
1850	1987	<< "Illegal calendar update: previous step was " << prevStep << ", new step " << step << "is in the past!")
1851	1988	}
	1989	CATCH_DUMP_ATTR
1852	1990
1853	1991	void CContext::initReadFiles(void)
	1992	TRY
1854	1993	{
1855	1994	vector<CFile*>::const_iterator it;
…	…
1860	1999	}
1861	2000	}
	2001	CATCH_DUMP_ATTR
1862	2002
1863	2003	//! Server side: Create header of netcdf file
1864	2004	void CContext::createFileHeader(void)
	2005	TRY
1865	2006	{
1866	2007	vector<CFile*>::const_iterator it;
…	…
1872	2013	}
1873	2014	}
	2015	CATCH_DUMP_ATTR
1874	2016
1875	2017	//! Get current context
1876	2018	CContext* CContext::getCurrent(void)
	2019	TRY
1877	2020	{
1878	2021	return CObjectFactory::GetObject<CContext>(CObjectFactory::GetCurrentContextId()).get();
1879	2022	}
	2023	CATCH
1880	2024
1881	2025	/*!
…	…
1884	2028	*/
1885	2029	void CContext::setCurrent(const string& id)
	2030	TRY
1886	2031	{
1887	2032	CObjectFactory::SetCurrentContextId(id);
1888	2033	CGroupFactory::SetCurrentContextId(id);
1889	2034	}
	2035	CATCH
1890	2036
1891	2037	/*!
…	…
1895	2041	*/
1896	2042	CContext* CContext::create(const StdString& id)
	2043	TRY
1897	2044	{
1898	2045	CContext::setCurrent(id);
…	…
1910	2057	return (context);
1911	2058	}
1912
	2059	CATCH
1913	2060
1914	2061	//! Server side: Receive a message to do some post processing
1915	2062	void CContext::recvRegistry(CEventServer& event)
	2063	TRY
1916	2064	{
1917	2065	CBufferIn* buffer=event.subEvents.begin()->buffer;
…	…
1920	2068	get(id)->recvRegistry(*buffer);
1921	2069	}
	2070	CATCH
1922	2071
1923	2072	void CContext::recvRegistry(CBufferIn& buffer)
	2073	TRY
1924	2074	{
1925	2075	if (server->intraCommRank==0)
…	…
1930	2080	}
1931	2081	}
	2082	CATCH_DUMP_ATTR
1932	2083
1933	2084	void CContext::sendRegistry(void)
	2085	TRY
1934	2086	{
1935	2087	registryOut->hierarchicalGatherRegistry() ;
…	…
1957	2109	}
1958	2110	}
	2111	CATCH_DUMP_ATTR
1959	2112
1960	2113	/*!
…	…
1963	2116	*/
1964	2117	bool CContext::isFinalized(void)
	2118	TRY
1965	2119	{
1966	2120	return finalized;
1967	2121	}
	2122	CATCH_DUMP_ATTR
	2123	///--------------------------------------------------------------
	2124	StdString CContext::dumpClassAttributes(void)
	2125	{
	2126	StdString str;
	2127	str.append("enabled files=\"");
	2128	int size = this->enabledFiles.size();
	2129	for (int i = 0; i < size; ++i)
	2130	{
	2131	str.append(enabledFiles[i]->getId());
	2132	str.append(" ");
	2133	}
	2134	str.append("\"");
	2135	return str;
	2136	}
1968	2137
1969	2138	} // namespace xios

XIOS/trunk/src/node/context.hpp

-                      r1542
+                      r1622
          void initServer(MPI_Comm intraComm, MPI_Comm interComm, CContext* cxtClient = 0);
          bool isInitialized(void);
+         StdString dumpClassAttributes(void);
          // Put sever or client into loop state
 …
          void distributeFileOverMemoryBandwith() ;
          // Send context close definition
          void sendCloseDefinition(void);

XIOS/trunk/src/node/domain.cpp

r1578	r1622
58	58
59	59	void CDomain::assignMesh(const StdString meshName, const int nvertex)
	60	TRY
60	61	{
61	62	mesh = CMesh::getMesh(meshName, nvertex);
62	63	}
	64	CATCH_DUMP_ATTR
63	65
64	66	CDomain* CDomain::createDomain()
	67	TRY
65	68	{
66	69	CDomain* domain = CDomainGroup::get("domain_definition")->createChild();
67	70	return domain;
68	71	}
	72	CATCH
69	73
70	74	std::map<StdString, ETranformationType> CDomain::transformationMapList_ = std::map<StdString, ETranformationType>();
…	…
72	76
73	77	bool CDomain::initializeTransformationMap(std::map<StdString, ETranformationType>& m)
	78	TRY
74	79	{
75	80	m["zoom_domain"] = TRANS_ZOOM_DOMAIN;
…	…
81	86	m["extract_domain"] = TRANS_EXTRACT_DOMAIN;
82	87	}
	88	CATCH
83	89
84	90	const std::set<StdString> & CDomain::getRelFiles(void) const
	91	TRY
85	92	{
86	93	return (this->relFiles);
87	94	}
88
	95	CATCH
89	96
90	97	/*!
…	…
93	100	*/
94	101	int CDomain::getNumberWrittenIndexes(MPI_Comm writtenCom)
	102	TRY
95	103	{
96	104	int writtenSize;
…	…
98	106	return numberWrittenIndexes_[writtenSize];
99	107	}
	108	CATCH_DUMP_ATTR
100	109
101	110	/*!
…	…
104	113	*/
105	114	int CDomain::getTotalNumberWrittenIndexes(MPI_Comm writtenCom)
	115	TRY
106	116	{
107	117	int writtenSize;
…	…
109	119	return totalNumberWrittenIndexes_[writtenSize];
110	120	}
	121	CATCH_DUMP_ATTR
111	122
112	123	/*!
…	…
115	126	*/
116	127	int CDomain::getOffsetWrittenIndexes(MPI_Comm writtenCom)
	128	TRY
117	129	{
118	130	int writtenSize;
…	…
120	132	return offsetWrittenIndexes_[writtenSize];
121	133	}
	134	CATCH_DUMP_ATTR
122	135
123	136	CArray<int, 1>& CDomain::getCompressedIndexToWriteOnServer(MPI_Comm writtenCom)
	137	TRY
124	138	{
125	139	int writtenSize;
…	…
127	141	return compressedIndexToWriteOnServer[writtenSize];
128	142	}
	143	CATCH_DUMP_ATTR
129	144
130	145	//----------------------------------------------------------------
…	…
136	151	*/
137	152	std::map<int, StdSize> CDomain::getAttributesBufferSize(CContextClient* client, bool bufferForWriting /= false/)
	153	TRY
138	154	{
139	155
…	…
182	198	return attributesSizes;
183	199	}
	200	CATCH_DUMP_ATTR
184	201
185	202	//----------------------------------------------------------------
186	203
187	204	bool CDomain::isEmpty(void) const
	205	TRY
188	206	{
189	207	return ((this->i_index.isEmpty()) \|\| (0 == this->i_index.numElements()));
190	208	}
	209	CATCH
191	210
192	211	//----------------------------------------------------------------
193	212
194	213	bool CDomain::IsWritten(const StdString & filename) const
	214	TRY
195	215	{
196	216	return (this->relFiles.find(filename) != this->relFiles.end());
197	217	}
	218	CATCH
198	219
199	220	bool CDomain::isWrittenCompressed(const StdString& filename) const
	221	TRY
200	222	{
201	223	return (this->relFilesCompressed.find(filename) != this->relFilesCompressed.end());
202	224	}
	225	CATCH
203	226
204	227	//----------------------------------------------------------------
205	228
206	229	bool CDomain::isDistributed(void) const
	230	TRY
207	231	{
208	232	bool distributed = !((!ni.isEmpty() && (ni == ni_glo) && !nj.isEmpty() && (nj == nj_glo)) \|\|
…	…
212	236	return distributed;
213	237	}
	238	CATCH
214	239
215	240	//----------------------------------------------------------------
…	…
221	246	*/
222	247	bool CDomain::isCompressible(void) const
	248	TRY
223	249	{
224	250	return isCompressible_;
225	251	}
	252	CATCH
226	253
227	254	void CDomain::addRelFile(const StdString & filename)
	255	TRY
228	256	{
229	257	this->relFiles.insert(filename);
230	258	}
	259	CATCH_DUMP_ATTR
231	260
232	261	void CDomain::addRelFileCompressed(const StdString& filename)
	262	TRY
233	263	{
234	264	this->relFilesCompressed.insert(filename);
235	265	}
	266	CATCH_DUMP_ATTR
236	267
237	268	StdString CDomain::GetName(void) { return (StdString("domain")); }
…	…
246	277	*/
247	278	bool CDomain::distributionAttributesHaveValue() const
	279	TRY
248	280	{
249	281	bool hasValues = true;
…	…
257	289	return hasValues;
258	290	}
	291	CATCH
259	292
260	293	/*!
…	…
266	299	*/
267	300	void CDomain::redistribute(int nbLocalDomain)
	301	TRY
268	302	{
269	303	if (this->isRedistributed_) return;
…	…
428	462	checkDomain();
429	463	}
	464	CATCH_DUMP_ATTR
430	465
431	466	/*!
…	…
433	468	*/
434	469	void CDomain::fillInLonLat()
	470	TRY
435	471	{
436	472	switch (type)
…	…
450	486	}
451	487	completeLonLatClient() ;
452
453		}
	488	}
	489	CATCH_DUMP_ATTR
454	490
455	491	/*!
…	…
459	495	*/
460	496	void CDomain::fillInRectilinearLonLat()
	497	TRY
461	498	{
462	499	if (!lonvalue_rectilinear_read_from_file.isEmpty() && lonvalue_2d.isEmpty() && lonvalue_1d.isEmpty())
…	…
527	564	}
528	565	}
	566	CATCH_DUMP_ATTR
529	567
530	568	/*
…	…
533	571	*/
534	572	void CDomain::fillInCurvilinearLonLat()
	573	TRY
535	574	{
536	575	if (!lonvalue_curvilinear_read_from_file.isEmpty() && lonvalue_2d.isEmpty() && lonvalue_1d.isEmpty())
…	…
575	614	bounds_latvalue_curvilinear_read_from_file.free();
576	615	}
577
578		}
	616	}
	617	CATCH_DUMP_ATTR
579	618
580	619	/*
…	…
583	622	*/
584	623	void CDomain::fillInUnstructuredLonLat()
	624	TRY
585	625	{
586	626	if (i_index.isEmpty())
…	…
634	674	}
635	675	}
	676	CATCH_DUMP_ATTR
636	677
637	678	/*
…	…
639	680	*/
640	681	void CDomain::AllgatherRectilinearLonLat(CArray<double,1>& lon, CArray<double,1>& lat, CArray<double,1>& lon_g, CArray<double,1>& lat_g)
	682	TRY
641	683	{
642	684	CContext* context = CContext::getCurrent();
…	…
670	712	delete[] nj_g ;
671	713	}
	714	CATCH_DUMP_ATTR
672	715
673	716	void CDomain::fillInRectilinearBoundLonLat(CArray<double,1>& lon, CArray<double,1>& lat,
674	717	CArray<double,2>& boundsLon, CArray<double,2>& boundsLat)
675		{
	718	TRY
	719	{
676	720	int i,j,k;
677	721
…	…
772	816	}
773	817	}
	818	CATCH_DUMP_ATTR
774	819
775	820	/*
…	…
777	822	*/
778	823	void CDomain::checkDomain(void)
	824	TRY
779	825	{
780	826	if (type.isEmpty())
…	…
868	914	}
869	915	}
	916	CATCH_DUMP_ATTR
870	917
871	918	size_t CDomain::getGlobalWrittenSize(void)
…	…
877	924	// Check validity of local domain on using the combination of 3 parameters: ibegin, ni and i_index
878	925	void CDomain::checkLocalIDomain(void)
	926	TRY
879	927	{
880	928	// If ibegin and ni are provided then we use them to check the validity of local domain
…	…
935	983	}
936	984	}
	985	CATCH_DUMP_ATTR
937	986
938	987	// Check validity of local domain on using the combination of 3 parameters: jbegin, nj and j_index
939	988	void CDomain::checkLocalJDomain(void)
	989	TRY
940	990	{
941	991	// If jbegin and nj are provided then we use them to check the validity of local domain
…	…
986	1036	}
987	1037	}
	1038	CATCH_DUMP_ATTR
988	1039
989	1040	//----------------------------------------------------------------
990	1041
991	1042	void CDomain::checkMask(void)
	1043	TRY
992	1044	{
993	1045	if (!mask_1d.isEmpty() && !mask_2d.isEmpty())
…	…
1035	1087	}
1036	1088	}
	1089	CATCH_DUMP_ATTR
1037	1090
1038	1091	//----------------------------------------------------------------
1039	1092
1040	1093	void CDomain::checkDomainData(void)
	1094	TRY
1041	1095	{
1042	1096	if (data_dim.isEmpty())
…	…
1078	1132	}
1079	1133	}
	1134	CATCH_DUMP_ATTR
1080	1135
1081	1136	//----------------------------------------------------------------
1082	1137
1083	1138	void CDomain::checkCompression(void)
	1139	TRY
1084	1140	{
1085	1141	if (!data_i_index.isEmpty())
…	…
1148	1204	}
1149	1205	}
	1206	CATCH_DUMP_ATTR
1150	1207
1151	1208	//----------------------------------------------------------------
1152	1209	void CDomain::computeLocalMask(void)
	1210	TRY
1153	1211	{
1154	1212	localMask.resize(i_index.numElements()) ;
…	…
1182	1240	}
1183	1241	}
	1242	CATCH_DUMP_ATTR
1184	1243
1185	1244	void CDomain::checkEligibilityForCompressedOutput(void)
	1245	TRY
1186	1246	{
1187	1247	// We don't check if the mask or the indexes are valid here, just if they have been defined at this point.
1188	1248	isCompressible_ = !mask_1d.isEmpty() \|\| !mask_2d.isEmpty() \|\| !data_i_index.isEmpty();
1189	1249	}
	1250	CATCH_DUMP_ATTR
1190	1251
1191	1252	//----------------------------------------------------------------
…	…
1196	1257	*/
1197	1258	void CDomain::completeLonLatClient(void)
	1259	TRY
1198	1260	{
1199	1261	bool lonlatValueExisted = (0 != lonvalue.numElements()) \|\| (0 != latvalue.numElements());
…	…
1309	1371	}
1310	1372	}
	1373	CATCH_DUMP_ATTR
1311	1374
1312	1375	/*
…	…
1314	1377	*/
1315	1378	void CDomain::convertLonLatValue(void)
	1379	TRY
1316	1380	{
1317	1381	bool lonlatValueExisted = (0 != lonvalue.numElements()) \|\| (0 != latvalue.numElements());
…	…
1411	1475	}
1412	1476	}
1413
	1477	CATCH_DUMP_ATTR
1414	1478
1415	1479	void CDomain::checkBounds(void)
	1480	TRY
1416	1481	{
1417	1482	bool hasBoundValues = (0 != bounds_lonvalue.numElements()) \|\| (0 != bounds_latvalue.numElements());
…	…
1505	1570	}
1506	1571	}
	1572	CATCH_DUMP_ATTR
1507	1573
1508	1574	void CDomain::checkArea(void)
	1575	TRY
1509	1576	{
1510	1577	bool hasAreaValue = (!areavalue.isEmpty() && 0 != areavalue.numElements());
…	…
1534	1601	}
1535	1602	}
	1603	CATCH_DUMP_ATTR
1536	1604
1537	1605	void CDomain::checkLonLat()
	1606	TRY
1538	1607	{
1539	1608	if (!hasLonLat) hasLonLat = (!latvalue_1d.isEmpty() && !lonvalue_1d.isEmpty()) \|\|
…	…
1595	1664	}
1596	1665	}
	1666	CATCH_DUMP_ATTR
1597	1667
1598	1668	void CDomain::checkAttributesOnClientAfterTransformation()
	1669	TRY
1599	1670	{
1600	1671	CContext* context=CContext::getCurrent() ;
…	…
1611	1682	this->isClientAfterTransformationChecked = true;
1612	1683	}
	1684	CATCH_DUMP_ATTR
1613	1685
1614	1686	//----------------------------------------------------------------
…	…
1616	1688	// This function only checks all attributes of current domain
1617	1689	void CDomain::checkAttributesOnClient()
	1690	TRY
1618	1691	{
1619	1692	if (this->isClientChecked) return;
…	…
1641	1714	this->isClientChecked = true;
1642	1715	}
	1716	CATCH_DUMP_ATTR
1643	1717
1644	1718	// Send all checked attributes to server
1645	1719	void CDomain::sendCheckedAttributes()
	1720	TRY
1646	1721	{
1647	1722	if (!this->isClientChecked) checkAttributesOnClient();
…	…
1656	1731	this->isChecked = true;
1657	1732	}
	1733	CATCH_DUMP_ATTR
1658	1734
1659	1735	void CDomain::checkAttributes(void)
	1736	TRY
1660	1737	{
1661	1738	if (this->isChecked) return;
…	…
1687	1764	this->isChecked = true;
1688	1765	}
	1766	CATCH_DUMP_ATTR
1689	1767
1690	1768	/*!
…	…
1695	1773	*/
1696	1774	void CDomain::computeConnectedClients()
	1775	TRY
1697	1776	{
1698	1777	CContext* context=CContext::getCurrent() ;
…	…
1799	1878	}
1800	1879	}
	1880	CATCH_DUMP_ATTR
1801	1881
1802	1882	/*!
…	…
1806	1886	*/
1807	1887	void CDomain::computeWrittenIndex()
	1888	TRY
1808	1889	{
1809	1890	if (computedWrittenIndex_) return;
…	…
1900	1981	// }
1901	1982	}
	1983	CATCH_DUMP_ATTR
1902	1984
1903	1985	void CDomain::computeWrittenCompressedIndex(MPI_Comm writtenComm)
	1986	TRY
1904	1987	{
1905	1988	int writtenCommSize;
…	…
1969	2052	}
1970	2053	}
	2054	CATCH_DUMP_ATTR
1971	2055
1972	2056	/*!
…	…
1975	2059	*/
1976	2060	void CDomain::sendAttributes()
	2061	TRY
1977	2062	{
1978	2063	sendDistributionAttributes();
…	…
1983	2068	sendDataIndex();
1984	2069	}
1985
	2070	CATCH
1986	2071	/*!
1987	2072	Send global index from client to connected client(s)
1988	2073	*/
1989	2074	void CDomain::sendIndex()
	2075	TRY
1990	2076	{
1991	2077	int ns, n, i, j, ind, nv, idx;
…	…
2030	2116	}
2031	2117	}
	2118	CATCH_DUMP_ATTR
2032	2119
2033	2120	/*!
…	…
2037	2124	*/
2038	2125	void CDomain::sendDistributionAttributes(void)
	2126	TRY
2039	2127	{
2040	2128	std::list<CContextClient*>::iterator it;
…	…
2083	2171	}
2084	2172	}
	2173	CATCH_DUMP_ATTR
2085	2174
2086	2175	/*!
…	…
2088	2177	*/
2089	2178	void CDomain::sendMask()
	2179	TRY
2090	2180	{
2091	2181	int ns, n, i, j, ind, nv, idx;
…	…
2127	2217	}
2128	2218	}
	2219	CATCH_DUMP_ATTR
2129	2220
2130	2221	/*!
…	…
2132	2223	*/
2133	2224	void CDomain::sendArea()
	2225	TRY
2134	2226	{
2135	2227	if (!hasArea) return;
…	…
2175	2267	}
2176	2268	}
	2269	CATCH_DUMP_ATTR
2177	2270
2178	2271	/*!
…	…
2182	2275	*/
2183	2276	void CDomain::sendLonLat()
	2277	TRY
2184	2278	{
2185	2279	if (!hasLonLat) return;
…	…
2270	2364	}
2271	2365	}
	2366	CATCH_DUMP_ATTR
2272	2367
2273	2368	/*!
…	…
2278	2373	*/
2279	2374	void CDomain::sendDataIndex()
	2375	TRY
2280	2376	{
2281	2377	int ns, n, i, j, ind, nv, idx;
…	…
2346	2442	}
2347	2443	}
	2444	CATCH
2348	2445
2349	2446	bool CDomain::dispatchEvent(CEventServer& event)
	2447	TRY
2350	2448	{
2351	2449	if (SuperClass::dispatchEvent(event)) return true;
…	…
2389	2487	}
2390	2488	}
	2489	CATCH
2391	2490
2392	2491	/*!
…	…
2395	2494	*/
2396	2495	void CDomain::recvIndex(CEventServer& event)
	2496	TRY
2397	2497	{
2398	2498	string domainId;
…	…
2408	2508	get(domainId)->recvIndex(rankBuffers);
2409	2509	}
	2510	CATCH
2410	2511
2411	2512	/*!
…	…
2415	2516	*/
2416	2517	void CDomain::recvIndex(std::map<int, CBufferIn*>& rankBuffers)
	2518	TRY
2417	2519	{
2418	2520	int nbReceived = rankBuffers.size(), i, ind, index, type_int, iIndex, jIndex;
…	…
2479	2581	}
2480	2582	}
	2583	CATCH
2481	2584
2482	2585	/*!
…	…
2485	2588	*/
2486	2589	void CDomain::recvDistributionAttributes(CEventServer& event)
	2590	TRY
2487	2591	{
2488	2592	CBufferIn* buffer=event.subEvents.begin()->buffer;
…	…
2491	2595	get(domainId)->recvDistributionAttributes(*buffer);
2492	2596	}
	2597	CATCH
2493	2598
2494	2599	/*!
…	…
2498	2603	*/
2499	2604	void CDomain::recvDistributionAttributes(CBufferIn& buffer)
	2605	TRY
2500	2606	{
2501	2607	int ni_tmp, ibegin_tmp, nj_tmp, jbegin_tmp;
…	…
2513	2619
2514	2620	}
	2621	CATCH_DUMP_ATTR
2515	2622
2516	2623	/*!
…	…
2519	2626	*/
2520	2627	void CDomain::recvMask(CEventServer& event)
	2628	TRY
2521	2629	{
2522	2630	string domainId;
…	…
2532	2640	get(domainId)->recvMask(rankBuffers);
2533	2641	}
2534
	2642	CATCH
2535	2643
2536	2644	/*!
…	…
2539	2647	*/
2540	2648	void CDomain::recvMask(std::map<int, CBufferIn*>& rankBuffers)
	2649	TRY
2541	2650	{
2542	2651	int nbReceived = rankBuffers.size(), i, ind, index, lInd;
…	…
2582	2691	domainMask=mask_1d ;
2583	2692	}
	2693	CATCH_DUMP_ATTR
2584	2694
2585	2695	/*!
…	…
2588	2698	*/
2589	2699	void CDomain::recvLon(CEventServer& event)
	2700	TRY
2590	2701	{
2591	2702	string domainId;
…	…
2601	2712	get(domainId)->recvLon(rankBuffers);
2602	2713	}
	2714	CATCH
2603	2715
2604	2716	/*!
…	…
2607	2719	*/
2608	2720	void CDomain::recvLon(std::map<int, CBufferIn*>& rankBuffers)
	2721	TRY
2609	2722	{
2610	2723	int nbReceived = rankBuffers.size(), i, ind, index, iindex, jindex, lInd;
…	…
2666	2779	}
2667	2780	}
	2781	CATCH_DUMP_ATTR
2668	2782
2669	2783	/*!
…	…
2672	2786	*/
2673	2787	void CDomain::recvLat(CEventServer& event)
	2788	TRY
2674	2789	{
2675	2790	string domainId;
…	…
2685	2800	get(domainId)->recvLat(rankBuffers);
2686	2801	}
	2802	CATCH
2687	2803
2688	2804	/*!
…	…
2691	2807	*/
2692	2808	void CDomain::recvLat(std::map<int, CBufferIn*>& rankBuffers)
	2809	TRY
2693	2810	{
2694	2811	int nbReceived = rankBuffers.size(), i, ind, index, iindex, jindex, lInd;
…	…
2752	2869	}
2753	2870	}
	2871	CATCH_DUMP_ATTR
2754	2872
2755	2873	/*!
…	…
2758	2876	*/
2759	2877	void CDomain::recvArea(CEventServer& event)
	2878	TRY
2760	2879	{
2761	2880	string domainId;
…	…
2771	2890	get(domainId)->recvArea(rankBuffers);
2772	2891	}
	2892	CATCH
2773	2893
2774	2894	/*!
…	…
2777	2897	*/
2778	2898	void CDomain::recvArea(std::map<int, CBufferIn*>& rankBuffers)
	2899	TRY
2779	2900	{
2780	2901	int nbReceived = rankBuffers.size(), i, ind, index, lInd;
…	…
2822	2943	}
2823	2944	}
	2945	CATCH_DUMP_ATTR
2824	2946
2825	2947	/*!
…	…
2831	2953	*/
2832	2954	bool CDomain::isEqual(CDomain* obj)
	2955	TRY
2833	2956	{
2834	2957	vector<StdString> excludedAttr;
…	…
2853	2976	return objEqual;
2854	2977	}
	2978	CATCH_DUMP_ATTR
2855	2979
2856	2980	/*!
…	…
2859	2983	*/
2860	2984	void CDomain::recvDataIndex(CEventServer& event)
	2985	TRY
2861	2986	{
2862	2987	string domainId;
…	…
2872	2997	get(domainId)->recvDataIndex(rankBuffers);
2873	2998	}
	2999	CATCH
2874	3000
2875	3001	/*!
…	…
2883	3009	*/
2884	3010	void CDomain::recvDataIndex(std::map<int, CBufferIn*>& rankBuffers)
	3011	TRY
2885	3012	{
2886	3013	int nbReceived = rankBuffers.size(), i, ind, index, indexI, indexJ, type_int, lInd;
…	…
2954	3081	data_jbegin.setValue(0);
2955	3082	}
	3083	CATCH_DUMP_ATTR
2956	3084
2957	3085	CTransformation<CDomain>* CDomain::addTransformation(ETranformationType transType, const StdString& id)
	3086	TRY
2958	3087	{
2959	3088	transformationMap_.push_back(std::make_pair(transType, CTransformation<CDomain>::createTransformation(transType,id)));
2960	3089	return transformationMap_.back().second;
2961	3090	}
	3091	CATCH_DUMP_ATTR
2962	3092
2963	3093	/*!
…	…
2966	3096	*/
2967	3097	bool CDomain::hasTransformation()
	3098	TRY
2968	3099	{
2969	3100	return (!transformationMap_.empty());
2970	3101	}
	3102	CATCH_DUMP_ATTR
2971	3103
2972	3104	/*!
…	…
2975	3107	*/
2976	3108	void CDomain::setTransformations(const TransMapTypes& domTrans)
	3109	TRY
2977	3110	{
2978	3111	transformationMap_ = domTrans;
2979	3112	}
	3113	CATCH_DUMP_ATTR
2980	3114
2981	3115	/*!
…	…
2984	3118	*/
2985	3119	CDomain::TransMapTypes CDomain::getAllTransformations(void)
	3120	TRY
2986	3121	{
2987	3122	return transformationMap_;
2988	3123	}
	3124	CATCH_DUMP_ATTR
2989	3125
2990	3126	void CDomain::duplicateTransformation(CDomain* src)
	3127	TRY
2991	3128	{
2992	3129	if (src->hasTransformation())
…	…
2995	3132	}
2996	3133	}
	3134	CATCH_DUMP_ATTR
2997	3135
2998	3136	/*!
…	…
3000	3138	*/
3001	3139	void CDomain::solveInheritanceTransformation()
	3140	TRY
3002	3141	{
3003	3142	if (hasTransformation() \|\| !hasDirectDomainReference())
…	…
3016	3155	refDomains[i]->setTransformations(domain->getAllTransformations());
3017	3156	}
	3157	CATCH_DUMP_ATTR
3018	3158
3019	3159	void CDomain::setContextClient(CContextClient* contextClient)
	3160	TRY
3020	3161	{
3021	3162	if (clientsSet.find(contextClient)==clientsSet.end())
…	…
3025	3166	}
3026	3167	}
	3168	CATCH_DUMP_ATTR
3027	3169
3028	3170	/*!
…	…
3032	3174	*/
3033	3175	void CDomain::parse(xml::CXMLNode & node)
	3176	TRY
3034	3177	{
3035	3178	SuperClass::parse(node);
…	…
3062	3205	}
3063	3206	}
	3207	CATCH_DUMP_ATTR
3064	3208	//----------------------------------------------------------------
3065	3209

XIOS/trunk/src/node/field.cpp

r1574	r1622
71	71
72	72	void CField::setVirtualVariableGroup(CVariableGroup* newVVariableGroup)
	73	TRY
73	74	{
74	75	this->vVariableGroup = newVVariableGroup;
75	76	}
	77	CATCH
76	78
77	79	CVariableGroup* CField::getVirtualVariableGroup(void) const
	80	TRY
78	81	{
79	82	return this->vVariableGroup;
80	83	}
	84	CATCH
81	85
82	86	std::vector<CVariable*> CField::getAllVariables(void) const
	87	TRY
83	88	{
84	89	return this->vVariableGroup->getAllChildren();
85	90	}
	91	CATCH
86	92
87	93	void CField::solveDescInheritance(bool apply, const CAttributeMap* const parent)
	94	TRY
88	95	{
89	96	SuperClassAttribute::setAttributes(parent, apply);
90	97	this->getVirtualVariableGroup()->solveDescInheritance(apply, NULL);
91	98	}
	99	CATCH_DUMP_ATTR
92	100
93	101	//----------------------------------------------------------------
94	102
95	103	bool CField::dispatchEvent(CEventServer& event)
	104	TRY
96	105	{
97	106	if (SuperClass::dispatchEvent(event)) return true;
…	…
131	140	}
132	141	}
	142	CATCH
133	143
134	144	void CField::sendUpdateData(const CArray<double,1>& data)
	145	TRY
135	146	{
136	147	CTimer::get("Field : send data").resume();
…	…
189	200	CTimer::get("Field : send data").suspend();
190	201	}
	202	CATCH_DUMP_ATTR
191	203
192	204	void CField::recvUpdateData(CEventServer& event)
	205	TRY
193	206	{
194	207	std::map<int,CBufferIn*> rankBuffers;
…	…
207	220	CTimer::get("Field : recv data").suspend();
208	221	}
	222	CATCH
209	223
210	224	void CField::recvUpdateData(std::map<int,CBufferIn*>& rankBuffers)
	225	TRY
211	226	{
212	227	CContext* context = CContext::getCurrent();
…	…
249	264	recvDataSrv.reset() ;
250	265	}
	266	CATCH_DUMP_ATTR
251	267
252	268	void CField::writeUpdateData(const CArray<double,1>& data)
	269	TRY
253	270	{
254	271	CContext* context = CContext::getCurrent();
…	…
277	294	}
278	295	}
	296	CATCH_DUMP_ATTR
279	297
280	298	void CField::writeField(void)
	299	TRY
281	300	{
282	301	if (!getRelFile()->isEmptyZone())
…	…
290	309	}
291	310	}
	311	CATCH_DUMP_ATTR
292	312
293	313	/*
…	…
299	319	*/
300	320	bool CField::sendReadDataRequest(const CDate& tsDataRequested)
	321	TRY
301	322	{
302	323	CContext* context = CContext::getCurrent();
…	…
330	351	return !isEOF;
331	352	}
	353	CATCH_DUMP_ATTR
332	354
333	355	/*!
…	…
336	358	*/
337	359	bool CField::sendReadDataRequestIfNeeded(void)
	360	TRY
338	361	{
339	362	const CDate& currentDate = CContext::getCurrent()->getCalendar()->getCurrentDate();
…	…
353	376	return dataRequested;
354	377	}
	378	CATCH_DUMP_ATTR
355	379
356	380	void CField::recvReadDataRequest(CEventServer& event)
	381	TRY
357	382	{
358	383	CBufferIn* buffer = event.subEvents.begin()->buffer;
…	…
361	386	get(fieldId)->recvReadDataRequest();
362	387	}
	388	CATCH
363	389
364	390	/*!
…	…
369	395	*/
370	396	void CField::recvReadDataRequest(void)
	397	TRY
371	398	{
372	399	CContext* context = CContext::getCurrent();
…	…
449	476	}
450	477	}
	478	CATCH_DUMP_ATTR
451	479
452	480	/*!
…	…
456	484	*/
457	485	CField::EReadField CField::readField(void)
	486	TRY
458	487	{
459	488	CContext* context = CContext::getCurrent();
…	…
508	537	return readState;
509	538	}
	539	CATCH_DUMP_ATTR
510	540
511	541	/*
…	…
516	546	*/
517	547	void CField::recvReadDataReady(CEventServer& event)
	548	TRY
518	549	{
519	550	string fieldId;
…	…
531	562	get(fieldId)->recvReadDataReady(ranks, buffers);
532	563	}
	564	CATCH
533	565
534	566	/*!
…	…
538	570	*/
539	571	void CField::recvReadDataReady(vector<int> ranks, vector<CBufferIn*> buffers)
	572	TRY
540	573	{
541	574	CContext* context = CContext::getCurrent();
…	…
574	607	serverSourceFilter->streamDataFromServer(lastDataReceivedFromServer, data);
575	608	}
	609	CATCH_DUMP_ATTR
576	610
577	611	void CField::checkForLateDataFromServer(void)
	612	TRY
578	613	{
579	614	CContext* context = CContext::getCurrent();
…	…
607	642	}
608	643	}
	644	CATCH_DUMP_ATTR
609	645
610	646	void CField::checkIfMustAutoTrigger(void)
	647	TRY
611	648	{
612	649	mustAutoTrigger = serverSourceFilter ? serverSourceFilter->mustAutoTrigger() : false;
613	650	}
	651	CATCH_DUMP_ATTR
614	652
615	653	void CField::autoTriggerIfNeeded(void)
	654	TRY
616	655	{
617	656	if (mustAutoTrigger)
618	657	serverSourceFilter->trigger(CContext::getCurrent()->getCalendar()->getCurrentDate());
619	658	}
	659	CATCH_DUMP_ATTR
620	660
621	661	//----------------------------------------------------------------
622	662
623	663	void CField::setRelFile(CFile* _file)
	664	TRY
624	665	{
625	666	this->file = _file;
626	667	hasOutputFile = true;
627	668	}
	669	CATCH_DUMP_ATTR
628	670
629	671	//----------------------------------------------------------------
…	…
636	678
637	679	CGrid* CField::getRelGrid(void) const
	680	TRY
638	681	{
639	682	return this->grid;
640	683	}
	684	CATCH
641	685
642	686	//----------------------------------------------------------------
643	687
644	688	CFile* CField::getRelFile(void) const
	689	TRY
645	690	{
646	691	return this->file;
647	692	}
	693	CATCH
648	694
649	695	int CField::getNStep(void) const
	696	TRY
650	697	{
651	698	return this->nstep;
652	699	}
	700	CATCH
653	701
654	702	func::CFunctor::ETimeType CField::getOperationTimeType() const
	703	TRY
655	704	{
656	705	return operationTimeType;
657	706	}
	707	CATCH
658	708
659	709	//----------------------------------------------------------------
660	710
661	711	void CField::incrementNStep(void)
	712	TRY
662	713	{
663	714	this->nstep++;
664	715	}
	716	CATCH_DUMP_ATTR
665	717
666	718	void CField::resetNStep(int nstep /= 0/)
	719	TRY
667	720	{
668	721	this->nstep = nstep;
669	722	}
	723	CATCH_DUMP_ATTR
670	724
671	725	void CField::resetNStepMax(void)
	726	TRY
672	727	{
673	728	this->nstepMax = 0;
674	729	nstepMaxRead = false;
675	730	}
	731	CATCH_DUMP_ATTR
676	732
677	733	//----------------------------------------------------------------
678	734
679	735	bool CField::isActive(bool atCurrentTimestep /= false/) const
	736	TRY
680	737	{
681	738	if (clientSourceFilter)
…	…
689	746	return false;
690	747	}
	748	CATCH
691	749
692	750	//----------------------------------------------------------------
693	751
694	752	bool CField::wasWritten() const
	753	TRY
695	754	{
696	755	return written;
697	756	}
	757	CATCH
698	758
699	759	void CField::setWritten()
	760	TRY
700	761	{
701	762	written = true;
702	763	}
	764	CATCH_DUMP_ATTR
703	765
704	766	//----------------------------------------------------------------
705	767
706	768	bool CField::getUseCompressedOutput() const
	769	TRY
707	770	{
708	771	return useCompressedOutput;
709	772	}
	773	CATCH
710	774
711	775	void CField::setUseCompressedOutput()
	776	TRY
712	777	{
713	778	useCompressedOutput = true;
714	779	}
	780	CATCH_DUMP_ATTR
715	781
716	782	//----------------------------------------------------------------
717	783
718	784	std::shared_ptr<COutputPin> CField::getInstantDataFilter()
	785	TRY
719	786	{
720	787	return instantDataFilter;
721	788	}
	789	CATCH_DUMP_ATTR
722	790
723	791	//----------------------------------------------------------------
…	…
728	796	*/
729	797	void CField::buildGridTransformationGraph()
	798	TRY
730	799	{
731	800	CContext* context = CContext::getCurrent();
…	…
738	807	}
739	808	}
	809	CATCH_DUMP_ATTR
740	810
741	811	/*!
…	…
743	813	*/
744	814	void CField::generateNewTransformationGridDest()
	815	TRY
745	816	{
746	817	CContext* context = CContext::getCurrent();
…	…
797	868	}
798	869	}
	870	CATCH_DUMP_ATTR
799	871
800	872	void CField::updateRef(CGrid* grid)
	873	TRY
801	874	{
802	875	if (!grid_ref.isEmpty()) grid_ref.setValue(grid->getId());
…	…
820	893	}
821	894	}
	895	CATCH_DUMP_ATTR
822	896
823	897	/*!
…	…
826	900	*/
827	901	void CField::solveAllEnabledFieldsAndTransform()
	902	TRY
828	903	{
829	904	CContext* context = CContext::getCurrent();
…	…
862	937	}
863	938	}
	939	CATCH_DUMP_ATTR
864	940
865	941	void CField::checkGridOfEnabledFields()
	942	TRY
866	943	{
867	944	if (!isGridChecked)
…	…
871	948	}
872	949	}
	950	CATCH_DUMP_ATTR
873	951
874	952	void CField::sendGridComponentOfEnabledFields()
	953	TRY
875	954	{
876	955	solveGridDomainAxisRef(true);
877	956	// solveCheckMaskIndex(true);
878	957	}
	958	CATCH_DUMP_ATTR
879	959
880	960	void CField::sendGridOfEnabledFields()
	961	TRY
881	962	{
882	963	// solveGridDomainAxisRef(true);
883	964	solveCheckMaskIndex(true);
884	965	}
	966	CATCH_DUMP_ATTR
885	967
886	968	void CField::solveOnlyReferenceEnabledField(bool doSending2Server)
	969	TRY
887	970	{
888	971	CContext* context = CContext::getCurrent();
…	…
910	993	}
911	994	}
912
	995	CATCH_DUMP_ATTR
	996
913	997	void CField::solveAllReferenceEnabledField(bool doSending2Server)
	998	TRY
914	999	{
915	1000	CContext* context = CContext::getCurrent();
…	…
940	1025	solveCheckMaskIndex(doSending2Server);
941	1026	}
	1027	CATCH_DUMP_ATTR
942	1028
943	1029	std::map<int, StdSize> CField::getGridAttributesBufferSize(CContextClient* client, bool bufferForWriting /= "false"/)
	1030	TRY
944	1031	{
945	1032	return grid->getAttributesBufferSize(client, bufferForWriting);
946	1033	}
	1034	CATCH_DUMP_ATTR
947	1035
948	1036	std::map<int, StdSize> CField::getGridDataBufferSize(CContextClient* client, bool bufferForWriting /= "false"/)
	1037	TRY
949	1038	{
950	1039	return grid->getDataBufferSize(client, getId(), bufferForWriting);
951	1040	}
	1041	CATCH_DUMP_ATTR
952	1042
953	1043	size_t CField::getGlobalWrittenSize()
	1044	TRY
954	1045	{
955	1046	return grid->getGlobalWrittenSize();
956	1047	}
	1048	CATCH_DUMP_ATTR
957	1049
958	1050	//----------------------------------------------------------------
959	1051
960	1052	void CField::solveServerOperation(void)
	1053	TRY
961	1054	{
962	1055	CContext* context = CContext::getCurrent();
…	…
1001	1094	operationTimeType = functor->timeType();
1002	1095	}
	1096	CATCH_DUMP_ATTR
1003	1097
1004	1098	//----------------------------------------------------------------
…	…
1013	1107	*/
1014	1108	void CField::buildFilterGraph(CGarbageCollector& gc, bool enableOutput)
	1109	TRY
1015	1110	{
1016	1111	if (!isReferenceSolvedAndTransformed) solveAllEnabledFieldsAndTransform();
…	…
1118	1213	}
1119	1214	}
	1215	CATCH_DUMP_ATTR
1120	1216
1121	1217	/*!
…	…
1127	1223	*/
1128	1224	std::shared_ptr<COutputPin> CField::getFieldReference(CGarbageCollector& gc)
	1225	TRY
1129	1226	{
1130	1227	if (instantDataFilter \|\| field_ref.isEmpty())
…	…
1150	1247	return filters.second;
1151	1248	}
	1249	CATCH_DUMP_ATTR
1152	1250
1153	1251	/*!
…	…
1161	1259	*/
1162	1260	std::shared_ptr<COutputPin> CField::getSelfReference(CGarbageCollector& gc)
	1261	TRY
1163	1262	{
1164	1263	if (instantDataFilter \|\| !hasExpression())
…	…
1203	1302	return selfReferenceFilter;
1204	1303	}
	1304	CATCH_DUMP_ATTR
1205	1305
1206	1306	/*!
…	…
1214	1314	*/
1215	1315	std::shared_ptr<COutputPin> CField::getTemporalDataFilter(CGarbageCollector& gc, CDuration outFreq)
	1316	TRY
1216	1317	{
1217	1318	std::map<CDuration, std::shared_ptr<COutputPin> >::iterator it = temporalDataFilters.find(outFreq);
…	…
1237	1338	return it->second;
1238	1339	}
	1340	CATCH_DUMP_ATTR
1239	1341
1240	1342	/*!
…	…
1248	1350
1249	1351	std::shared_ptr<COutputPin> CField::getSelfTemporalDataFilter(CGarbageCollector& gc, CDuration outFreq)
	1352	TRY
1250	1353	{
1251	1354	if (instantDataFilter \|\| !hasExpression())
…	…
1278	1381	}
1279	1382	}
	1383	CATCH_DUMP_ATTR
1280	1384
1281	1385	//----------------------------------------------------------------
…	…
1296	1400
1297	1401	void CField::solveGridReference(void)
	1402	TRY
1298	1403	{
1299	1404	if (grid_ref.isEmpty() && domain_ref.isEmpty() && axis_ref.isEmpty() && scalar_ref.isEmpty())
…	…
1379	1484	}
1380	1485	}
	1486	CATCH_DUMP_ATTR
1381	1487
1382	1488	void CField::solveGridDomainAxisRef(bool checkAtt)
	1489	TRY
1383	1490	{
1384	1491	grid->solveDomainAxisRef(checkAtt);
1385	1492	}
	1493	CATCH_DUMP_ATTR
1386	1494
1387	1495	void CField::solveCheckMaskIndex(bool doSendingIndex)
	1496	TRY
1388	1497	{
1389	1498	grid->checkMaskIndex(doSendingIndex);
1390	1499	}
	1500	CATCH_DUMP_ATTR
1391	1501
1392	1502	void CField::solveTransformedGrid()
	1503	TRY
1393	1504	{
1394	1505	if (grid && !grid->isTransformed() && hasDirectFieldReference() && grid != getDirectFieldReference()->grid)
…	…
1439	1550	}
1440	1551	}
	1552	CATCH_DUMP_ATTR
1441	1553
1442	1554	void CField::solveGenerateGrid()
	1555	TRY
1443	1556	{
1444	1557	if (grid && !grid->isTransformed() && hasDirectFieldReference() && grid != getDirectFieldReference()->grid)
…	…
1447	1560	grid->completeGrid();
1448	1561	}
	1562	CATCH_DUMP_ATTR
1449	1563
1450	1564	void CField::solveGridDomainAxisBaseRef()
	1565	TRY
1451	1566	{
1452	1567	grid->solveDomainAxisRef(false);
1453	1568	grid->solveDomainAxisBaseRef();
1454	1569	}
	1570	CATCH_DUMP_ATTR
1455	1571
1456	1572	///-------------------------------------------------------------------
…	…
1458	1574	template <>
1459	1575	void CGroupTemplate<CField, CFieldGroup, CFieldAttributes>::solveRefInheritance(void)
	1576	TRY
1460	1577	{
1461	1578	if (this->group_ref.isEmpty()) return;
…	…
1481	1598	}
1482	1599	}
	1600	CATCH_DUMP_ATTR
1483	1601
1484	1602	void CField::scaleFactorAddOffset(double scaleFactor, double addOffset)
	1603	TRY
1485	1604	{
1486	1605	recvDataSrv = (recvDataSrv - addOffset) / scaleFactor;
1487	1606	}
	1607	CATCH_DUMP_ATTR
1488	1608
1489	1609	void CField::invertScaleFactorAddOffset(double scaleFactor, double addOffset)
	1610	TRY
1490	1611	{
1491	1612	recvDataSrv = recvDataSrv * scaleFactor + addOffset;
1492	1613	}
	1614	CATCH_DUMP_ATTR
1493	1615
1494	1616	void CField::outputField(CArray<double,1>& fieldOut)
	1617	TRY
1495	1618	{
1496	1619	CArray<size_t,1>& outIndexClient = grid->localIndexToWriteOnClient;
…	…
1501	1624	}
1502	1625	}
	1626	CATCH_DUMP_ATTR
1503	1627
1504	1628	void CField::inputField(CArray<double,1>& fieldIn)
	1629	TRY
1505	1630	{
1506	1631	CArray<size_t,1>& outIndexClient = grid->localIndexToWriteOnClient;
…	…
1510	1635	recvDataSrv(outIndexClient(idx)) = fieldIn(outIndexServer(idx));
1511	1636	}
1512
1513		}
	1637	}
	1638	CATCH_DUMP_ATTR
1514	1639
1515	1640	void CField::outputCompressedField(CArray<double,1>& fieldOut)
	1641	TRY
1516	1642	{
1517	1643	CArray<size_t,1>& outIndexClient = grid->localIndexToWriteOnClient;
…	…
1522	1648	}
1523	1649	}
	1650	CATCH_DUMP_ATTR
1524	1651
1525	1652	///-------------------------------------------------------------------
1526	1653
1527	1654	void CField::parse(xml::CXMLNode& node)
	1655	TRY
1528	1656	{
1529	1657	string newContent ;
…	…
1540	1668	if (node.getContent(newContent)) content=newContent ;
1541	1669	}
	1670	CATCH_DUMP_ATTR
1542	1671
1543	1672	/*!
…	…
1547	1676	*/
1548	1677	const std::vector<StdString>& CField::getRefDomainAxisIds()
	1678	TRY
1549	1679	{
1550	1680	CGrid* cgPtr = getRelGrid();
…	…
1575	1705	return (domAxisScalarIds_);
1576	1706	}
	1707	CATCH_DUMP_ATTR
1577	1708
1578	1709	CVariable* CField::addVariable(const string& id)
	1710	TRY
1579	1711	{
1580	1712	return vVariableGroup->createChild(id);
1581	1713	}
	1714	CATCH
1582	1715
1583	1716	CVariableGroup* CField::addVariableGroup(const string& id)
	1717	TRY
1584	1718	{
1585	1719	return vVariableGroup->createChildGroup(id);
1586	1720	}
	1721	CATCH
1587	1722
1588	1723	void CField::setContextClient(CContextClient* contextClient)
	1724	TRY
1589	1725	{
1590	1726	CContext* context = CContext::getCurrent();
…	…
1602	1738	}
1603	1739	}
	1740	CATCH_DUMP_ATTR
1604	1741
1605	1742	CContextClient* CField::getContextClient()
	1743	TRY
1606	1744	{
1607	1745	return client;
1608	1746	}
	1747	CATCH
1609	1748
1610	1749	void CField::sendAddAllVariables(CContextClient* client)
	1750	TRY
1611	1751	{
1612	1752	std::vector<CVariable*> allVar = getAllVariables();
…	…
1621	1761	}
1622	1762	}
1623
	1763	CATCH_DUMP_ATTR
1624	1764
1625	1765	/*!
…	…
1629	1769
1630	1770	void CField::sendAllAttributesToServer(CContextClient* client)
	1771	TRY
1631	1772	{
1632	1773	if (grid_ref.isEmpty())
…	…
1638	1779	else SuperClass::sendAllAttributesToServer(client) ;
1639	1780	}
	1781	CATCH_DUMP_ATTR
1640	1782
1641	1783	void CField::sendAddVariable(const string& id, CContextClient* client)
	1784	TRY
1642	1785	{
1643	1786	sendAddItem(id, (int)EVENT_ID_ADD_VARIABLE, client);
1644	1787	}
	1788	CATCH_DUMP_ATTR
1645	1789
1646	1790	void CField::sendAddVariableGroup(const string& id, CContextClient* client)
	1791	TRY
1647	1792	{
1648	1793	sendAddItem(id, (int)EVENT_ID_ADD_VARIABLE_GROUP, client);
1649	1794	}
	1795	CATCH_DUMP_ATTR
1650	1796
1651	1797	void CField::recvAddVariable(CEventServer& event)
	1798	TRY
1652	1799	{
1653	1800
…	…
1657	1804	get(id)->recvAddVariable(*buffer);
1658	1805	}
	1806	CATCH
1659	1807
1660	1808	void CField::recvAddVariable(CBufferIn& buffer)
	1809	TRY
1661	1810	{
1662	1811	string id;
…	…
1664	1813	addVariable(id);
1665	1814	}
	1815	CATCH_DUMP_ATTR
1666	1816
1667	1817	void CField::recvAddVariableGroup(CEventServer& event)
	1818	TRY
1668	1819	{
1669	1820
…	…
1673	1824	get(id)->recvAddVariableGroup(*buffer);
1674	1825	}
	1826	CATCH
1675	1827
1676	1828	void CField::recvAddVariableGroup(CBufferIn& buffer)
	1829	TRY
1677	1830	{
1678	1831	string id;
…	…
1680	1833	addVariableGroup(id);
1681	1834	}
	1835	CATCH_DUMP_ATTR
1682	1836
1683	1837	/*!
…	…
1685	1839	*/
1686	1840	void CField::checkTimeAttributes(CDuration* freqOp)
	1841	TRY
1687	1842	{
1688	1843	bool isFieldRead = file && !file->mode.isEmpty() && file->mode == CFile::mode_attr::read;
…	…
1706	1861	freq_offset.setValue(isFieldRead ? NoneDu : (freq_op.getValue() - TimeStep));
1707	1862	}
	1863	CATCH_DUMP_ATTR
1708	1864
1709	1865	/*!
…	…
1712	1868	*/
1713	1869	const string& CField::getExpression(void)
	1870	TRY
1714	1871	{
1715	1872	if (!expr.isEmpty() && content.empty())
…	…
1721	1878	return content;
1722	1879	}
	1880	CATCH_DUMP_ATTR
1723	1881
1724	1882	bool CField::hasExpression(void) const
	1883	TRY
1725	1884	{
1726	1885	return (!expr.isEmpty() \|\| !content.empty());
1727	1886	}
1728
	1887	CATCH
1729	1888
1730	1889	DEFINE_REF_FUNC(Field,field)

XIOS/trunk/src/node/field_impl.hpp

r1201	r1622
17	17	template <int N>
18	18	void CField::setData(const CArray<double, N>& _data)
	19	TRY
19	20	{
20	21	if (clientSourceFilter)
…	…
27	28	<< "Impossible to receive data from the model for a field [ id = " << getId() << " ] with a reference or an arithmetic operation.");
28	29	}
	30	CATCH_DUMP_ATTR
29	31
30	32	template <int N>
31	33	void CField::getData(CArray<double, N>& _data) const
	34	TRY
32	35	{
33	36	if (storeFilter)
…	…
45	48	}
46	49	}
	50	CATCH
47	51	} // namespace xios
48	52

XIOS/trunk/src/node/file.cpp

r1542	r1622
53	53
54	54	const StdString CFile::getFileOutputName(void) const
	55	TRY
55	56	{
56	57	return (name.isEmpty() ? getId() : name) + (name_suffix.isEmpty() ? StdString("") : name_suffix.getValue());
57	58	}
	59	CATCH
58	60
59	61	//----------------------------------------------------------------
…	…
65	67	*/
66	68	std::shared_ptr<CDataOutput> CFile::getDataOutput(void) const
	69	TRY
67	70	{
68	71	return data_out;
69	72	}
	73	CATCH
70	74
71	75	/*!
…	…
76	80	*/
77	81	std::shared_ptr<CDataInput> CFile::getDataInput(void) const
	82	TRY
78	83	{
79	84	return data_in;
80	85	}
	86	CATCH
81	87
82	88	/*!
…	…
88	94	*/
89	95	CFieldGroup* CFile::getVirtualFieldGroup(void) const
	96	TRY
90	97	{
91	98	return (this->vFieldGroup);
92	99	}
	100	CATCH
93	101
94	102	/*!
…	…
100	108	*/
101	109	CVariableGroup* CFile::getVirtualVariableGroup(void) const
	110	TRY
102	111	{
103	112	return (this->vVariableGroup);
104	113	}
	114	CATCH
105	115
106	116	//! Get all fields of a file
107	117	std::vector<CField*> CFile::getAllFields(void) const
	118	TRY
108	119	{
109	120	return (this->vFieldGroup->getAllChildren());
110	121	}
	122	CATCH
111	123
112	124	//! Get all variables of a file
113	125	std::vector<CVariable*> CFile::getAllVariables(void) const
	126	TRY
114	127	{
115	128	return (this->vVariableGroup->getAllChildren());
116	129	}
	130	CATCH
117	131
118	132	//----------------------------------------------------------------
…	…
129	143	int default_level,
130	144	bool default_enabled)
	145	TRY
131	146	{
132	147	if (!this->enabledFields.empty())
…	…
145	160	{
146	161	if (! (*it)->enabled.getValue()) continue;
147		~~// { it--; this->enabledFields.erase(it+1); continue; }~~
148	162	}
149	163	else // Si l'attribut 'enabled' n'est pas dfini ...
150	164	{
151	165	if (!default_enabled) continue;
152		~~// { it--; this->enabledFields.erase(it+1); continue; }~~
153	166	}
154	167
…	…
156	169	{
157	170	if ((*it)->level.getValue() > _outputlevel) continue;
158		~~// { it--; this->enabledFields.erase(it+1); continue; }~~
159	171	}
160	172	else // Si l'attribut 'level' n'est pas dfini ...
161	173	{
162	174	if (default_level > _outputlevel) continue;
163		~~// { it--; this->enabledFields.erase(it+1); continue; }~~
164	175	}
165	176
166		~~// CField* field_tmp=(*it).get();~~
167		~~// shared_ptr<CField> sptfield=*it;~~
168		~~// field_tmp->refObject.push_back(sptfield);~~
169	177	newEnabledFields.push_back(*it);
170		~~// Le champ est finalement actif, on y ajoute sa propre reference.~~
171		~~// (it)->refObject.push_back(it);~~
172	178	// Le champ est finalement actif, on y ajoute la rfrence au champ de base.
173	179	(*it)->setRelFile(CFile::get(this));
…	…
177	183	return (this->enabledFields);
178	184	}
	185	CATCH_DUMP_ATTR
179	186
180	187	//----------------------------------------------------------------
181	188	//! Change virtual field group to a new one
182	189	void CFile::setVirtualFieldGroup(CFieldGroup* newVFieldGroup)
	190	TRY
183	191	{
184	192	this->vFieldGroup = newVFieldGroup;
185	193	}
	194	CATCH_DUMP_ATTR
186	195
187	196	//! Change virtual variable group to new one
188	197	void CFile::setVirtualVariableGroup(CVariableGroup* newVVariableGroup)
	198	TRY
189	199	{
190	200	this->vVariableGroup = newVVariableGroup;
191	201	}
	202	CATCH_DUMP_ATTR
192	203
193	204	//----------------------------------------------------------------
194	205	bool CFile::isSyncTime(void)
	206	TRY
195	207	{
196	208	CContext* context = CContext::getCurrent();
…	…
206	218	return false;
207	219	}
	220	CATCH_DUMP_ATTR
208	221
209	222	//! Initialize a file in order to write into it
210	223	void CFile::initWrite(void)
	224	TRY
211	225	{
212	226	CContext* context = CContext::getCurrent();
…	…
261	275	if (time_counter_name.isEmpty()) time_counter_name = "time_counter";
262	276	}
	277	CATCH_DUMP_ATTR
263	278
264	279	//! Initialize a file in order to write into it
265	280	void CFile::initRead(void)
	281	TRY
266	282	{
267	283	if (checkRead) return;
…	…
269	285	checkRead = true;
270	286	}
	287	CATCH_DUMP_ATTR
271	288
272	289	/*!
…	…
274	291	*/
275	292	void CFile::createSubComFile()
	293	TRY
276	294	{
277	295	CContext* context = CContext::getCurrent();
…	…
292	310	if (allZoneEmpty) MPI_Comm_free(&fileComm);
293	311	}
	312	CATCH_DUMP_ATTR
294	313
295	314	/*
…	…
299	318	*/
300	319	void CFile::checkWriteFile(void)
	320	TRY
301	321	{
302	322	CContext* context = CContext::getCurrent();
…	…
315	335	}
316	336	}
	337	CATCH_DUMP_ATTR
317	338
318	339	/*
…	…
323	344	*/
324	345	void CFile::checkReadFile(void)
	346	TRY
325	347	{
326	348	CContext* context = CContext::getCurrent();
…	…
340	362	}
341	363	}
	364	CATCH_DUMP_ATTR
342	365
343	366	/*!
…	…
346	369	*/
347	370	bool CFile::isEmptyZone()
	371	TRY
348	372	{
349	373	return allZoneEmpty;
350	374	}
	375	CATCH_DUMP_ATTR
351	376
352	377	/*!
…	…
357	382	*/
358	383	bool CFile::checkSync(void)
	384	TRY
359	385	{
360	386	CContext* context = CContext::getCurrent();
…	…
371	397	return false;
372	398	}
	399	CATCH_DUMP_ATTR
373	400
374	401	/*!
…	…
379	406	*/
380	407	bool CFile::checkSplit(void)
	408	TRY
381	409	{
382	410	CContext* context = CContext::getCurrent();
…	…
402	430	return false;
403	431	}
	432	CATCH_DUMP_ATTR
404	433
405	434	/*!
…	…
408	437	*/
409	438	void CFile::createHeader(void)
	439	TRY
410	440	{
411	441	CContext* context = CContext::getCurrent();
…	…
594	624	}
595	625	}
	626	CATCH_DUMP_ATTR
596	627
597	628	/*!
…	…
599	630	*/
600	631	void CFile::openInReadMode()
	632	TRY
601	633	{
602	634	CContext* context = CContext::getCurrent();
…	…
675	707	}
676	708	}
	709	CATCH_DUMP_ATTR
677	710
678	711	//! Close file
679	712	void CFile::close(void)
	713	TRY
680	714	{
681	715	if (!allZoneEmpty)
…	…
690	724	if (fileComm != MPI_COMM_NULL) MPI_Comm_free(&fileComm);
691	725	}
	726	CATCH_DUMP_ATTR
	727
692	728	//----------------------------------------------------------------
693	729
694	730	void CFile::readAttributesOfEnabledFieldsInReadMode()
	731	TRY
695	732	{
696	733	if (enabledFields.empty()) return;
…	…
722	759	close();
723	760	}
724
	761	CATCH_DUMP_ATTR
725	762
726	763	/*!
…	…
729	766	*/
730	767	void CFile::parse(xml::CXMLNode & node)
	768	TRY
731	769	{
732	770	SuperClass::parse(node);
…	…
741	779	node.goToParentElement();
742	780	}
743
744		}
	781	}
	782	CATCH_DUMP_ATTR
	783
745	784	//----------------------------------------------------------------
746	785
…	…
750	789	*/
751	790	StdString CFile::toString(void) const
	791	TRY
752	792	{
753	793	StdOStringStream oss;
…	…
762	802	return (oss.str());
763	803	}
	804	CATCH
764	805
765	806	//----------------------------------------------------------------
…	…
772	813	*/
773	814	void CFile::solveDescInheritance(bool apply, const CAttributeMap * const parent)
	815	TRY
774	816	{
775	817	SuperClassAttribute::setAttributes(parent,apply);
…	…
777	819	this->getVirtualVariableGroup()->solveDescInheritance(apply, NULL);
778	820	}
	821	CATCH_DUMP_ATTR
779	822
780	823	//----------------------------------------------------------------
…	…
789	832	*/
790	833	void CFile::solveOnlyRefOfEnabledFields(bool sendToServer)
	834	TRY
791	835	{
792	836	int size = this->enabledFields.size();
…	…
796	840	}
797	841	}
	842	CATCH_DUMP_ATTR
798	843
799	844	void CFile::checkGridOfEnabledFields()
	845	TRY
800	846	{
801	847	int size = this->enabledFields.size();
…	…
805	851	}
806	852	}
	853	CATCH_DUMP_ATTR
807	854
808	855	void CFile::sendGridComponentOfEnabledFields()
	856	TRY
809	857	{
810	858	int size = this->enabledFields.size();
…	…
814	862	}
815	863	}
	864	CATCH_DUMP_ATTR
816	865
817	866	/*!
…	…
820	869	*/
821	870	void CFile::sortEnabledFieldsForUgrid()
	871	TRY
822	872	{
823	873	int size = this->enabledFields.size();
…	…
868	918	}
869	919	}
	920	CATCH_DUMP_ATTR
870	921
871	922	void CFile::sendGridOfEnabledFields()
	923	TRY
872	924	{
873	925	int size = this->enabledFields.size();
…	…
877	929	}
878	930	}
	931	CATCH_DUMP_ATTR
879	932
880	933	void CFile::generateNewTransformationGridDest()
	934	TRY
881	935	{
882	936	int size = this->enabledFields.size();
…	…
886	940	}
887	941	}
	942	CATCH_DUMP_ATTR
888	943
889	944	/*!
…	…
896	951	*/
897	952	void CFile::solveAllRefOfEnabledFieldsAndTransform(bool sendToServer)
	953	TRY
898	954	{
899	955	int size = this->enabledFields.size();
…	…
903	959	}
904	960	}
	961	CATCH_DUMP_ATTR
905	962
906	963	/*!
…	…
910	967	*/
911	968	void CFile::buildFilterGraphOfEnabledFields(CGarbageCollector& gc)
	969	TRY
912	970	{
913	971	int size = this->enabledFields.size();
…	…
917	975	}
918	976	}
	977	CATCH_DUMP_ATTR
919	978
920	979	/*!
…	…
922	981	*/
923	982	void CFile::postProcessFilterGraph()
	983	TRY
924	984	{
925	985	int size = this->enabledFields.size();
…	…
929	989	}
930	990	}
	991	CATCH_DUMP_ATTR
931	992
932	993	/*!
…	…
934	995	*/
935	996	void CFile::prefetchEnabledReadModeFields(void)
	997	TRY
936	998	{
937	999	if (mode.isEmpty() \|\| mode.getValue() != mode_attr::read)
…	…
942	1004	this->enabledFields[i]->sendReadDataRequest(CContext::getCurrent()->getCalendar()->getCurrentDate());
943	1005	}
	1006	CATCH_DUMP_ATTR
944	1007
945	1008	/*!
…	…
949	1012	*/
950	1013	void CFile::doPreTimestepOperationsForEnabledReadModeFields(void)
	1014	TRY
951	1015	{
952	1016	if (mode.isEmpty() \|\| mode.getValue() != mode_attr::read)
…	…
960	1024	}
961	1025	}
	1026	CATCH_DUMP_ATTR
962	1027
963	1028	/*!
…	…
966	1031	*/
967	1032	void CFile::doPostTimestepOperationsForEnabledReadModeFields(void)
	1033	TRY
968	1034	{
969	1035	if (mode.isEmpty() \|\| mode.getValue() != mode_attr::read)
…	…
976	1042	}
977	1043	}
	1044	CATCH_DUMP_ATTR
978	1045
979	1046	void CFile::solveFieldRefInheritance(bool apply)
	1047	TRY
980	1048	{
981	1049	// Rsolution des hritages par rfrence de chacun des champs contenus dans le fichier.
…	…
984	1052	allF[i]->solveRefInheritance(apply);
985	1053	}
	1054	CATCH_DUMP_ATTR
986	1055
987	1056	//----------------------------------------------------------------
…	…
996	1065	*/
997	1066	CField* CFile::addField(const string& id)
	1067	TRY
998	1068	{
999	1069	return vFieldGroup->createChild(id);
1000	1070	}
	1071	CATCH_DUMP_ATTR
1001	1072
1002	1073	/*!
…	…
1008	1079	*/
1009	1080	CFieldGroup* CFile::addFieldGroup(const string& id)
	1081	TRY
1010	1082	{
1011	1083	return vFieldGroup->createChildGroup(id);
1012	1084	}
	1085	CATCH_DUMP_ATTR
1013	1086
1014	1087	/*!
…	…
1023	1096	*/
1024	1097	CVariable* CFile::addVariable(const string& id)
	1098	TRY
1025	1099	{
1026	1100	return vVariableGroup->createChild(id);
1027	1101	}
	1102	CATCH_DUMP_ATTR
1028	1103
1029	1104	/*!
…	…
1035	1110	*/
1036	1111	CVariableGroup* CFile::addVariableGroup(const string& id)
	1112	TRY
1037	1113	{
1038	1114	return vVariableGroup->createChildGroup(id);
1039	1115	}
	1116	CATCH_DUMP_ATTR
1040	1117
1041	1118	void CFile::setContextClient(CContextClient* newContextClient)
	1119	TRY
1042	1120	{
1043	1121	client = newContextClient;
…	…
1048	1126	}
1049	1127	}
	1128	CATCH_DUMP_ATTR
1050	1129
1051	1130	CContextClient* CFile::getContextClient()
	1131	TRY
1052	1132	{
1053	1133	return client;
1054	1134	}
	1135	CATCH_DUMP_ATTR
1055	1136
1056	1137	void CFile::setReadContextClient(CContextClient* readContextclient)
	1138	TRY
1057	1139	{
1058	1140	read_client = readContextclient;
1059	1141	}
	1142	CATCH_DUMP_ATTR
1060	1143
1061	1144	CContextClient* CFile::getReadContextClient()
	1145	TRY
1062	1146	{
1063	1147	return read_client;
1064	1148	}
	1149	CATCH_DUMP_ATTR
1065	1150
1066	1151	/*!
…	…
1069	1154	*/
1070	1155	void CFile::sendAddField(const string& id, CContextClient* client)
	1156	TRY
1071	1157	{
1072	1158	sendAddItem(id, EVENT_ID_ADD_FIELD, client);
1073	1159	}
	1160	CATCH_DUMP_ATTR
1074	1161
1075	1162	/*!
…	…
1078	1165	*/
1079	1166	void CFile::sendAddFieldGroup(const string& id, CContextClient* client)
	1167	TRY
1080	1168	{
1081	1169	sendAddItem(id, (int)EVENT_ID_ADD_FIELD_GROUP, client);
1082	1170	}
	1171	CATCH_DUMP_ATTR
1083	1172
1084	1173	/*!
…	…
1087	1176	*/
1088	1177	void CFile::recvAddField(CEventServer& event)
	1178	TRY
1089	1179	{
1090	1180
…	…
1094	1184	get(id)->recvAddField(*buffer);
1095	1185	}
	1186	CATCH
1096	1187
1097	1188	/*!
…	…
1100	1191	*/
1101	1192	void CFile::recvAddField(CBufferIn& buffer)
	1193	TRY
1102	1194	{
1103	1195	string id;
…	…
1105	1197	addField(id);
1106	1198	}
	1199	CATCH_DUMP_ATTR
1107	1200
1108	1201	/*!
…	…
1111	1204	*/
1112	1205	void CFile::recvAddFieldGroup(CEventServer& event)
	1206	TRY
1113	1207	{
1114	1208
…	…
1118	1212	get(id)->recvAddFieldGroup(*buffer);
1119	1213	}
	1214	CATCH
1120	1215
1121	1216	/*!
…	…
1124	1219	*/
1125	1220	void CFile::recvAddFieldGroup(CBufferIn& buffer)
	1221	TRY
1126	1222	{
1127	1223	string id;
…	…
1129	1225	addFieldGroup(id);
1130	1226	}
	1227	CATCH_DUMP_ATTR
1131	1228
1132	1229	/*!
…	…
1137	1234	*/
1138	1235	void CFile::sendAddAllVariables(CContextClient* client)
	1236	TRY
1139	1237	{
1140	1238	std::vector<CVariable*> allVar = getAllVariables();
…	…
1149	1247	}
1150	1248	}
	1249	CATCH_DUMP_ATTR
1151	1250
1152	1251	/*!
…	…
1156	1255	*/
1157	1256	void CFile::sendAddVariableGroup(const string& id, CContextClient* client)
	1257	TRY
1158	1258	{
1159	1259	sendAddItem(id, (int)EVENT_ID_ADD_VARIABLE_GROUP, client);
1160	1260	}
	1261	CATCH_DUMP_ATTR
1161	1262
1162	1263	/*
…	…
1166	1267	*/
1167	1268	void CFile::sendAddVariable(const string& id, CContextClient* client)
	1269	TRY
1168	1270	{
1169	1271	sendAddItem(id, (int)EVENT_ID_ADD_VARIABLE, client);
1170	1272	}
	1273	CATCH_DUMP_ATTR
1171	1274
1172	1275	/*!
…	…
1175	1278	*/
1176	1279	void CFile::recvAddVariable(CEventServer& event)
1177		{
1178
	1280	TRY
	1281	{
1179	1282	CBufferIn* buffer = event.subEvents.begin()->buffer;
1180	1283	string id;
…	…
1182	1285	get(id)->recvAddVariable(*buffer);
1183	1286	}
	1287	CATCH
1184	1288
1185	1289	/*!
…	…
1188	1292	*/
1189	1293	void CFile::recvAddVariable(CBufferIn& buffer)
	1294	TRY
1190	1295	{
1191	1296	string id;
…	…
1193	1298	addVariable(id);
1194	1299	}
	1300	CATCH_DUMP_ATTR
1195	1301
1196	1302	/*!
…	…
1199	1305	*/
1200	1306	void CFile::recvAddVariableGroup(CEventServer& event)
	1307	TRY
1201	1308	{
1202	1309
…	…
1206	1313	get(id)->recvAddVariableGroup(*buffer);
1207	1314	}
	1315	CATCH
1208	1316
1209	1317	/*!
…	…
1212	1320	*/
1213	1321	void CFile::recvAddVariableGroup(CBufferIn& buffer)
	1322	TRY
1214	1323	{
1215	1324	string id;
…	…
1217	1326	addVariableGroup(id);
1218	1327	}
	1328	CATCH_DUMP_ATTR
1219	1329
1220	1330	/*!
…	…
1226	1336	*/
1227	1337	void CFile::sendEnabledFields(CContextClient* client)
	1338	TRY
1228	1339	{
1229	1340	size_t size = this->enabledFields.size();
…	…
1237	1348	}
1238	1349	}
1239
	1350	CATCH_DUMP_ATTR
1240	1351
1241	1352	/*!
…	…
1247	1358	*/
1248	1359	bool CFile::dispatchEvent(CEventServer& event)
	1360	TRY
1249	1361	{
1250	1362	if (SuperClass::dispatchEvent(event)) return true;
…	…
1278	1390	}
1279	1391	}
1280
1281
1282
	1392	CATCH
	1393
	1394	///--------------------------------------------------------------
	1395	/*!
	1396	*/
	1397	StdString CFile::dumpClassAttributes(void)
	1398	{
	1399	StdString str;
	1400	CContext* context = CContext::getCurrent();
	1401	str.append("context=\"");
	1402	str.append(context->getId());
	1403	str.append("\"");
	1404	str.append(" enabled fields=\"");
	1405	int size = this->enabledFields.size();
	1406	for (int i = 0; i < size; ++i)
	1407	{
	1408	str.append(this->enabledFields[i]->getId());
	1409	str.append(" ");
	1410	}
	1411	str.append("\"");
	1412	return str;
	1413	}
1283	1414
1284	1415	///---------------------------------------------------------------

XIOS/trunk/src/node/file.hpp

r1542	r1622
81	81	int default_level = 1,
82	82	bool default_enabled = true);
	83
	84	StdString dumpClassAttributes(void);
83	85
84	86	public :

XIOS/trunk/src/node/grid.cpp

r1562	r1622
82	82
83	83	StdSize CGrid::getDimension(void)
	84	TRY
84	85	{
85	86	return getGlobalDimension().size();
86	87	}
	88	CATCH_DUMP_ATTR
87	89
88	90	//---------------------------------------------------------------
89	91
90	92	StdSize CGrid::getDataSize(void) const
	93	TRY
91	94	{
92	95	StdSize retvalue = 1;
…	…
98	101	return retvalue;
99	102	}
	103	CATCH
100	104
101	105	/*!
…	…
106	110	*/
107	111	std::map<int, StdSize> CGrid::getAttributesBufferSize(CContextClient* client, bool bufferForWriting)
	112	TRY
108	113	{
109	114	std::map<int, StdSize> attributesSizes = getMinimumBufferSizeForAttributes(client);
…	…
147	152	return attributesSizes;
148	153	}
	154	CATCH_DUMP_ATTR
149	155
150	156	/*!
…	…
156	162	*/
157	163	std::map<int, StdSize> CGrid::getDataBufferSize(CContextClient* client, const std::string& id /= ""/, bool bufferForWriting /= "false"/)
	164	TRY
158	165	{
159	166	// The record index is sometimes sent along with the data but we always
…	…
180	187	return dataSizes;
181	188	}
	189	CATCH_DUMP_ATTR
182	190
183	191	size_t CGrid::getGlobalWrittenSize(void)
	192	TRY
184	193	{
185	194	std::vector<CDomain*> domainP = this->getDomains();
…	…
191	200	return globalGridSize ;
192	201	}
193
	202	CATCH_DUMP_ATTR
194	203
195	204	void CGrid::checkAttributesAfterTransformation()
	205	TRY
196	206	{
197	207	setAxisList();
…	…
228	238	}
229	239	}
	240	CATCH_DUMP_ATTR
230	241
231	242	//---------------------------------------------------------------
…	…
237	248	*/
238	249	bool CGrid::isCompressible(void) const
	250	TRY
239	251	{
240	252	return isCompressible_;
241	253	}
	254	CATCH
242	255
243	256	//---------------------------------------------------------------
244	257
245	258	void CGrid::addRelFileCompressed(const StdString& filename)
	259	TRY
246	260	{
247	261	this->relFilesCompressed.insert(filename);
248	262	}
	263	CATCH_DUMP_ATTR
249	264
250	265	bool CGrid::isWrittenCompressed(const StdString& filename) const
	266	TRY
251	267	{
252	268	return (this->relFilesCompressed.find(filename) != this->relFilesCompressed.end());
253	269	}
	270	CATCH
254	271
255	272	//---------------------------------------------------------------
…	…
258	275	*/
259	276	void CGrid::solveDomainAxisRef(bool areAttributesChecked)
	277	TRY
260	278	{
261	279	if (this->isDomainAxisChecked) return;
…	…
266	284	this->isDomainAxisChecked = areAttributesChecked;
267	285	}
	286	CATCH_DUMP_ATTR
268	287
269	288	/*
…	…
272	291	*/
273	292	void CGrid::solveDomainAxisBaseRef()
	293	TRY
274	294	{
275	295	if (this->hasDomainAxisBaseRef_) return;
…	…
297	317	this->hasDomainAxisBaseRef_ = true;
298	318	}
	319	CATCH_DUMP_ATTR
299	320
300	321	void CGrid::checkEligibilityForCompressedOutput()
	322	TRY
301	323	{
302	324	// We don't check if the mask is valid here, just if a mask has been defined at this point.
303	325	isCompressible_ = !mask_1d.isEmpty() \|\| !mask_2d.isEmpty() \|\| !mask_3d.isEmpty();
304	326	}
	327	CATCH_DUMP_ATTR
305	328
306	329	void CGrid::checkMaskIndex(bool doSendingIndex)
	330	TRY
307	331	{
308	332	CContext* context = CContext::getCurrent();
…	…
339	363	this->isChecked = true;
340	364	}
	365	CATCH_DUMP_ATTR
341	366
342	367	/*
…	…
344	369	*/
345	370	void CGrid::createMask(void)
	371	TRY
346	372	{
347	373	using namespace std;
…	…
381	407	}
382	408	}
	409	CATCH_DUMP_ATTR
383	410
384	411	/*
…	…
386	413	*/
387	414	void CGrid::checkMask(void)
	415	TRY
388	416	{
389	417	using namespace std;
…	…
423	451	}
424	452	}
425
	453	CATCH_DUMP_ATTR
426	454
427	455	/*!
…	…
433	461
434	462	void CGrid::getLocalMask(CArray<bool,1>& localMask)
	463	TRY
435	464	{
436	465	std::vector<CDomain*> domainP = this->getDomains();
…	…
468	497	}
469	498	}
	499	CATCH_DUMP_ATTR
470	500
471	501	/*
…	…
476	506	*/
477	507	void CGrid::modifyMask(const CArray<int,1>& indexToModify, bool modifyValue)
	508	TRY
478	509	{
479	510	using namespace std;
…	…
511	542	}
512	543	}
	544	CATCH_DUMP_ATTR
513	545
514	546	/*
…	…
518	550	*/
519	551	void CGrid::modifyMaskSize(const std::vector<int>& newDimensionSize, bool newValue)
	552	TRY
520	553	{
521	554	std::vector<CDomain*> domainP = this->getDomains();
…	…
552	585	}
553	586	}
	587	CATCH_DUMP_ATTR
554	588
555	589	//---------------------------------------------------------------
556	590
557	591	void CGrid::solveDomainRef(bool sendAtt)
	592	TRY
558	593	{
559	594	setDomainList();
…	…
568	603	}
569	604	}
	605	CATCH_DUMP_ATTR
570	606
571	607	//---------------------------------------------------------------
572	608
573	609	void CGrid::solveAxisRef(bool sendAtt)
	610	TRY
574	611	{
575	612	setAxisList();
…	…
599	636	}
600	637	}
	638	CATCH_DUMP_ATTR
601	639
602	640	//---------------------------------------------------------------
603	641
604	642	void CGrid::solveScalarRef(bool sendAtt)
	643	TRY
605	644	{
606	645	setScalarList();
…	…
616	655	}
617	656	}
	657	CATCH_DUMP_ATTR
618	658
619	659	/*!
…	…
621	661	*/
622	662	void CGrid::computeWrittenIndex()
	663	TRY
623	664	{
624	665	if (computedWrittenIndex_) return;
…	…
680	721	}
681	722	}
	723	CATCH_DUMP_ATTR
682	724
683	725	//---------------------------------------------------------------
…	…
690	732	*/
691	733	void CGrid::computeClientIndex()
	734	TRY
692	735	{
693	736	CContext* context = CContext::getCurrent();
…	…
746	789	}
747	790	}
	791	CATCH_DUMP_ATTR
748	792
749	793	/*!
…	…
751	795	*/
752	796	void CGrid::computeConnectedClients()
	797	TRY
753	798	{
754	799	CContext* context = CContext::getCurrent();
…	…
844	889	}
845	890	}
	891	CATCH_DUMP_ATTR
846	892
847	893	/*!
…	…
853	899	*/
854	900	void CGrid::computeIndex(void)
	901	TRY
855	902	{
856	903	CContext* context = CContext::getCurrent();
…	…
879	926	}
880	927	}
	928	CATCH_DUMP_ATTR
881	929
882	930	/*!
…	…
892	940	const CContextClient* client,
893	941	CClientServerMapping::GlobalIndexMap& globalIndexOnServer)
	942	TRY
894	943	{
895	944	int serverSize = client->serverSize;
…	…
1058	1107	}
1059	1108	}
1060		//----------------------------------------------------------------
	1109	CATCH_DUMP_ATTR
	1110	//----------------------------------------------------------------
1061	1111
1062	1112	CGrid* CGrid::createGrid(CDomain* domain)
	1113	TRY
1063	1114	{
1064	1115	std::vector<CDomain*> vecDom(1, domain);
…	…
1067	1118	return createGrid(vecDom, vecAxis);
1068	1119	}
	1120	CATCH
1069	1121
1070	1122	CGrid* CGrid::createGrid(CDomain* domain, CAxis* axis)
1071		{
	1123	TRY
	1124	{
1072	1125	std::vector<CDomain*> vecDom(1, domain);
1073	1126	std::vector<CAxis*> vecAxis(1, axis);
…	…
1075	1128	return createGrid(vecDom, vecAxis);
1076	1129	}
	1130	CATCH
1077	1131
1078	1132	CGrid* CGrid::createGrid(const std::vector<CDomain>& domains, const std::vector<CAxis>& axis,
1079	1133	const CArray<int,1>& axisDomainOrder)
	1134	TRY
1080	1135	{
1081	1136	std::vector<CScalar*> vecScalar;
1082	1137	return createGrid(generateId(domains, axis, vecScalar, axisDomainOrder), domains, axis, vecScalar, axisDomainOrder);
1083	1138	}
	1139	CATCH
1084	1140
1085	1141	CGrid* CGrid::createGrid(const std::vector<CDomain>& domains, const std::vector<CAxis>& axis,
1086	1142	const std::vector<CScalar*>& scalars, const CArray<int,1>& axisDomainOrder)
	1143	TRY
1087	1144	{
1088	1145	return createGrid(generateId(domains, axis, scalars, axisDomainOrder), domains, axis, scalars, axisDomainOrder);
1089	1146	}
	1147	CATCH
1090	1148
1091	1149	CGrid* CGrid::createGrid(StdString id, const std::vector<CDomain>& domains, const std::vector<CAxis>& axis,
1092	1150	const std::vector<CScalar*>& scalars, const CArray<int,1>& axisDomainOrder)
	1151	TRY
1093	1152	{
1094	1153	if (axisDomainOrder.numElements() > 0 && axisDomainOrder.numElements() != (domains.size() + axis.size() + scalars.size()))
…	…
1132	1191	return grid;
1133	1192	}
	1193	CATCH
1134	1194
1135	1195	CGrid* CGrid::cloneGrid(const StdString& idNewGrid, CGrid* gridSrc)
	1196	TRY
1136	1197	{
1137	1198	std::vector<CDomain*> domainSrcTmp = gridSrc->getDomains(), domainSrc;
…	…
1173	1234	return grid;
1174	1235	}
	1236	CATCH
1175	1237
1176	1238	StdString CGrid::generateId(const std::vector<CDomain>& domains, const std::vector<CAxis>& axis,
1177	1239	const std::vector<CScalar*>& scalars, const CArray<int,1>& axisDomainOrder)
	1240	TRY
1178	1241	{
1179	1242	if (axisDomainOrder.numElements() > 0 && axisDomainOrder.numElements() != (domains.size() + axis.size() + scalars.size()))
…	…
1216	1279	return id.str();
1217	1280	}
	1281	CATCH
1218	1282
1219	1283	StdString CGrid::generateId(const CGrid* gridSrc, const CGrid* gridDest)
	1284	TRY
1220	1285	{
1221	1286	StdString idSrc = gridSrc->getId();
…	…
1227	1292	return id.str();
1228	1293	}
	1294	CATCH
1229	1295
1230	1296	//----------------------------------------------------------------
1231	1297
1232	1298	CDomainGroup* CGrid::getVirtualDomainGroup() const
	1299	TRY
1233	1300	{
1234	1301	return this->vDomainGroup_;
1235	1302	}
	1303	CATCH
1236	1304
1237	1305	CAxisGroup* CGrid::getVirtualAxisGroup() const
	1306	TRY
1238	1307	{
1239	1308	return this->vAxisGroup_;
1240	1309	}
	1310	CATCH
1241	1311
1242	1312	CScalarGroup* CGrid::getVirtualScalarGroup() const
	1313	TRY
1243	1314	{
1244	1315	return this->vScalarGroup_;
1245	1316	}
	1317	CATCH
1246	1318
1247	1319	/*
…	…
1279	1351
1280	1352	void CGrid::storeField_arr(const double* const data, CArray<double, 1>& stored) const
	1353	TRY
1281	1354	{
1282	1355	const StdSize size = storeIndex_client.numElements();
…	…
1285	1358	for(StdSize i = 0; i < size; i++) stored(i) = data[storeIndex_client(i)];
1286	1359	}
	1360	CATCH
1287	1361
1288	1362	void CGrid::restoreField_arr(const CArray<double, 1>& stored, double* const data) const
	1363	TRY
1289	1364	{
1290	1365	const StdSize size = storeIndex_client.numElements();
…	…
1292	1367	for(StdSize i = 0; i < size; i++) data[storeIndex_client(i)] = stored(i);
1293	1368	}
	1369	CATCH
1294	1370
1295	1371	void CGrid::uncompressField_arr(const double* const data, CArray<double, 1>& out) const
	1372	TRY
1296	1373	{
1297	1374	const std::vector<int>& localMaskedDataIndex = clientDistribution_->getLocalMaskedDataIndexOnClient();
…	…
1299	1376	for(int i = 0; i < size; ++i) out(localMaskedDataIndex[i]) = data[i];
1300	1377	}
1301
	1378	CATCH
1302	1379
1303	1380	void CGrid::computeClientIndexScalarGrid()
	1381	TRY
1304	1382	{
1305	1383	CContext* context = CContext::getCurrent();
…	…
1335	1413	}
1336	1414	}
	1415	CATCH_DUMP_ATTR
1337	1416
1338	1417	void CGrid::computeConnectedClientsScalarGrid()
	1418	TRY
1339	1419	{
1340	1420	CContext* context = CContext::getCurrent();
…	…
1381	1461	}
1382	1462	}
	1463	CATCH_DUMP_ATTR
1383	1464
1384	1465	void CGrid::sendIndexScalarGrid()
	1466	TRY
1385	1467	{
1386	1468	CContext* context = CContext::getCurrent();
…	…
1446	1528	}
1447	1529	}
	1530	CATCH_DUMP_ATTR
1448	1531
1449	1532	void CGrid::sendIndex(void)
	1533	TRY
1450	1534	{
1451	1535	CContext* context = CContext::getCurrent();
…	…
1567	1651	}
1568	1652	}
	1653	CATCH_DUMP_ATTR
1569	1654
1570	1655	void CGrid::recvIndex(CEventServer& event)
	1656	TRY
1571	1657	{
1572	1658	string gridId;
…	…
1584	1670	get(gridId)->recvIndex(ranks, buffers);
1585	1671	}
	1672	CATCH
1586	1673
1587	1674	void CGrid::recvIndex(vector<int> ranks, vector<CBufferIn*> buffers)
	1675	TRY
1588	1676	{
1589	1677	CContext* context = CContext::getCurrent();
…	…
1791	1879	}
1792	1880	}
	1881	CATCH_DUMP_ATTR
1793	1882
1794	1883	/*
…	…
1806	1895	const std::vector<CScalar*> scalars,
1807	1896	const CArray<int,1>& axisDomainOrder)
1808		{
	1897	TRY
	1898	{
1809	1899	// globalDim.resize(domains.size()*2+axis.size()+scalars.size());
1810	1900	globalDim.resize(domains.size()*2+axis.size());
…	…
1846	1936	return positionDimensionDistributed;
1847	1937	}
	1938	CATCH_DUMP_ATTR
1848	1939
1849	1940	// Retrieve the global dimension of grid
1850	1941	std::vector<int> CGrid::getGlobalDimension()
	1942	TRY
1851	1943	{
1852	1944	std::vector<int> globalDim;
…	…
1855	1947	return globalDim;
1856	1948	}
	1949	CATCH_DUMP_ATTR
1857	1950
1858	1951	// Retrieve dimension on which we do distribution (Very often, it should be 2nd dimension)
1859	1952	int CGrid::getDistributedDimension()
	1953	TRY
1860	1954	{
1861	1955	std::vector<int> globalDim;
1862	1956	return computeGridGlobalDimension(globalDim, getDomains(), getAxis(), getScalars(), axis_domain_order);
1863	1957	}
	1958	CATCH_DUMP_ATTR
1864	1959
1865	1960	bool CGrid::isScalarGrid() const
	1961	TRY
1866	1962	{
1867	1963	return (axisList_.empty() && domList_.empty());
1868	1964	}
	1965	CATCH
1869	1966
1870	1967	/*!
…	…
1874	1971	*/
1875	1972	bool CGrid::doGridHaveDataToWrite()
	1973	TRY
1876	1974	{
1877	1975	return (0 != writtenDataSize_);
1878	1976	}
	1977	CATCH_DUMP_ATTR
1879	1978
1880	1979	/*!
…	…
1885	1984	*/
1886	1985	size_t CGrid::getWrittenDataSize() const
	1986	TRY
1887	1987	{
1888	1988	return writtenDataSize_;
1889	1989	}
	1990	CATCH
1890	1991
1891	1992	/*!
…	…
1894	1995	*/
1895	1996	int CGrid::getNumberWrittenIndexes() const
	1997	TRY
1896	1998	{
1897	1999	return numberWrittenIndexes_;
1898	2000	}
	2001	CATCH
1899	2002
1900	2003	/*!
…	…
1903	2006	*/
1904	2007	int CGrid::getTotalNumberWrittenIndexes() const
	2008	TRY
1905	2009	{
1906	2010	return totalNumberWrittenIndexes_;
1907	2011	}
	2012	CATCH
1908	2013
1909	2014	/*!
…	…
1912	2017	*/
1913	2018	int CGrid::getOffsetWrittenIndexes() const
	2019	TRY
1914	2020	{
1915	2021	return offsetWrittenIndexes_;
1916	2022	}
	2023	CATCH
1917	2024
1918	2025	CDistributionServer* CGrid::getDistributionServer()
	2026	TRY
1919	2027	{
1920	2028	return serverDistribution_;
1921	2029	}
	2030	CATCH_DUMP_ATTR
1922	2031
1923	2032	CDistributionClient* CGrid::getDistributionClient()
	2033	TRY
1924	2034	{
1925	2035	return clientDistribution_;
1926	2036	}
	2037	CATCH_DUMP_ATTR
1927	2038
1928	2039	bool CGrid::doGridHaveDataDistributed(CContextClient* client)
	2040	TRY
1929	2041	{
1930	2042	if (isScalarGrid()) return false;
…	…
1936	2048	return isDataDistributed_;
1937	2049	}
	2050	CATCH_DUMP_ATTR
1938	2051
1939	2052	/*!
…	…
1945	2058	*/
1946	2059	bool CGrid::dispatchEvent(CEventServer& event)
	2060	TRY
1947	2061	{
1948	2062
…	…
1978	2092	}
1979	2093	}
	2094	CATCH
1980	2095
1981	2096	///---------------------------------------------------------------
1982	2097
1983	2098	CDomain* CGrid::addDomain(const std::string& id)
	2099	TRY
1984	2100	{
1985	2101	order_.push_back(2);
…	…
1988	2104	return vDomainGroup_->createChild(id);
1989	2105	}
	2106	CATCH_DUMP_ATTR
1990	2107
1991	2108	CAxis* CGrid::addAxis(const std::string& id)
	2109	TRY
1992	2110	{
1993	2111	order_.push_back(1);
…	…
1996	2114	return vAxisGroup_->createChild(id);
1997	2115	}
	2116	CATCH_DUMP_ATTR
1998	2117
1999	2118	CScalar* CGrid::addScalar(const std::string& id)
	2119	TRY
2000	2120	{
2001	2121	order_.push_back(0);
…	…
2004	2124	return vScalarGroup_->createChild(id);
2005	2125	}
	2126	CATCH_DUMP_ATTR
2006	2127
2007	2128	//! Change virtual field group to a new one
2008	2129	void CGrid::setVirtualDomainGroup(CDomainGroup* newVDomainGroup)
	2130	TRY
2009	2131	{
2010	2132	this->vDomainGroup_ = newVDomainGroup;
2011	2133	}
	2134	CATCH_DUMP_ATTR
2012	2135
2013	2136	//! Change virtual variable group to new one
2014	2137	void CGrid::setVirtualAxisGroup(CAxisGroup* newVAxisGroup)
	2138	TRY
2015	2139	{
2016	2140	this->vAxisGroup_ = newVAxisGroup;
2017	2141	}
	2142	CATCH_DUMP_ATTR
2018	2143
2019	2144	//! Change virtual variable group to new one
2020	2145	void CGrid::setVirtualScalarGroup(CScalarGroup* newVScalarGroup)
	2146	TRY
2021	2147	{
2022	2148	this->vScalarGroup_ = newVScalarGroup;
2023	2149	}
	2150	CATCH_DUMP_ATTR
2024	2151
2025	2152	/*!
…	…
2028	2155	*/
2029	2156	void CGrid::sendAddDomain(const string& id)
2030		{
	2157	TRY
	2158	{
2031	2159	sendAddItem(id, (int)EVENT_ID_ADD_DOMAIN);
2032	2160	}
	2161	CATCH_DUMP_ATTR
2033	2162
2034	2163	/*!
…	…
2037	2166	*/
2038	2167	void CGrid::sendAddAxis(const string& id)
	2168	TRY
2039	2169	{
2040	2170	sendAddItem(id, (int)EVENT_ID_ADD_AXIS);
2041	2171	}
	2172	CATCH_DUMP_ATTR
2042	2173
2043	2174	/*!
…	…
2046	2177	*/
2047	2178	void CGrid::sendAddScalar(const string& id)
	2179	TRY
2048	2180	{
2049	2181	sendAddItem(id, (int)EVENT_ID_ADD_SCALAR);
2050	2182	}
	2183	CATCH_DUMP_ATTR
2051	2184
2052	2185	/*!
…	…
2055	2188	*/
2056	2189	void CGrid::recvAddDomain(CEventServer& event)
	2190	TRY
2057	2191	{
2058	2192
…	…
2062	2196	get(id)->recvAddDomain(*buffer);
2063	2197	}
	2198	CATCH
2064	2199
2065	2200	/*!
…	…
2068	2203	*/
2069	2204	void CGrid::recvAddDomain(CBufferIn& buffer)
	2205	TRY
2070	2206	{
2071	2207	string id;
…	…
2073	2209	addDomain(id);
2074	2210	}
	2211	CATCH_DUMP_ATTR
2075	2212
2076	2213	/*!
…	…
2079	2216	*/
2080	2217	void CGrid::recvAddAxis(CEventServer& event)
	2218	TRY
2081	2219	{
2082	2220
…	…
2086	2224	get(id)->recvAddAxis(*buffer);
2087	2225	}
	2226	CATCH
2088	2227
2089	2228	/*!
…	…
2092	2231	*/
2093	2232	void CGrid::recvAddAxis(CBufferIn& buffer)
	2233	TRY
2094	2234	{
2095	2235	string id;
…	…
2097	2237	addAxis(id);
2098	2238	}
	2239	CATCH_DUMP_ATTR
2099	2240
2100	2241	/*!
…	…
2103	2244	*/
2104	2245	void CGrid::recvAddScalar(CEventServer& event)
	2246	TRY
2105	2247	{
2106	2248
…	…
2110	2252	get(id)->recvAddScalar(*buffer);
2111	2253	}
	2254	CATCH
2112	2255
2113	2256	/*!
…	…
2116	2259	*/
2117	2260	void CGrid::recvAddScalar(CBufferIn& buffer)
	2261	TRY
2118	2262	{
2119	2263	string id;
…	…
2121	2265	addScalar(id);
2122	2266	}
	2267	CATCH_DUMP_ATTR
2123	2268
2124	2269	/*!
…	…
2129	2274	*/
2130	2275	void CGrid::solveDomainAxisRefInheritance(bool apply)
	2276	TRY
2131	2277	{
2132	2278	CContext* context = CContext::getCurrent();
…	…
2169	2315	}
2170	2316	}
	2317	CATCH_DUMP_ATTR
2171	2318
2172	2319	bool CGrid::isTransformed()
	2320	TRY
2173	2321	{
2174	2322	return isTransformed_;
2175	2323	}
	2324	CATCH_DUMP_ATTR
2176	2325
2177	2326	void CGrid::setTransformed()
	2327	TRY
2178	2328	{
2179	2329	isTransformed_ = true;
2180	2330	}
	2331	CATCH_DUMP_ATTR
2181	2332
2182	2333	CGridTransformation* CGrid::getTransformations()
	2334	TRY
2183	2335	{
2184	2336	return transformations_;
2185	2337	}
	2338	CATCH_DUMP_ATTR
2186	2339
2187	2340	void CGrid::addTransGridSource(CGrid* gridSrc)
	2341	TRY
2188	2342	{
2189	2343	if (gridSrc_.end() == gridSrc_.find(gridSrc))
2190	2344	gridSrc_.insert(make_pair(gridSrc,make_pair(false,"")));
2191	2345	}
	2346	CATCH_DUMP_ATTR
2192	2347
2193	2348	std::map<CGrid*,std::pair<bool,StdString> >& CGrid::getTransGridSource()
	2349	TRY
2194	2350	{
2195	2351	return gridSrc_;
2196	2352	}
	2353	CATCH_DUMP_ATTR
2197	2354
2198	2355	/*!
…	…
2201	2358	*/
2202	2359	void CGrid::completeGrid(CGrid* transformGridSrc)
	2360	TRY
2203	2361	{
2204	2362	if (0 != transformGridSrc)
…	…
2219	2377	gridGenerate.completeGrid();
2220	2378	}
	2379	CATCH_DUMP_ATTR
2221	2380
2222	2381	bool CGrid::isGenerated()
	2382	TRY
2223	2383	{
2224	2384	return isGenerated_;
2225	2385	}
	2386	CATCH
2226	2387
2227	2388	void CGrid::setGenerated()
	2389	TRY
2228	2390	{
2229	2391	isGenerated_ = true;
2230	2392	}
	2393	CATCH_DUMP_ATTR
2231	2394
2232	2395	void CGrid::transformGrid(CGrid* transformGridSrc)
	2396	TRY
2233	2397	{
2234	2398	if (!transformGridSrc)
…	…
2256	2420	transformGridSrc->checkMaskIndex(false);
2257	2421	}
	2422	CATCH_DUMP_ATTR
2258	2423
2259	2424	bool CGrid::hasTransform()
	2425	TRY
2260	2426	{
2261	2427	if (hasTransform_) return hasTransform_;
…	…
2271	2437	return hasTransform_;
2272	2438	}
	2439	CATCH_DUMP_ATTR
2273	2440
2274	2441	/*!
…	…
2277	2444	*/
2278	2445	std::vector<CDomain*> CGrid::getDomains()
	2446	TRY
2279	2447	{
2280	2448	std::vector<CDomain*> domList;
…	…
2285	2453	return domList;
2286	2454	}
	2455	CATCH_DUMP_ATTR
2287	2456
2288	2457	/*!
…	…
2291	2460	*/
2292	2461	std::vector<CAxis*> CGrid::getAxis()
	2462	TRY
2293	2463	{
2294	2464	std::vector<CAxis*> aList;
…	…
2298	2468	return aList;
2299	2469	}
	2470	CATCH_DUMP_ATTR
2300	2471
2301	2472	/*!
…	…
2304	2475	*/
2305	2476	std::vector<CScalar*> CGrid::getScalars()
	2477	TRY
2306	2478	{
2307	2479	std::vector<CScalar*> sList;
…	…
2311	2483	return sList;
2312	2484	}
	2485	CATCH_DUMP_ATTR
2313	2486
2314	2487	/*!
…	…
2317	2490	*/
2318	2491	CDomain* CGrid::getDomain(int domainIndex)
	2492	TRY
2319	2493	{
2320	2494	std::vector<CDomain*> domainListP = this->getDomains();
…	…
2334	2508	return domainListP[domainIndex];
2335	2509	}
	2510	CATCH_DUMP_ATTR
2336	2511
2337	2512	/*!
…	…
2340	2515	*/
2341	2516	CAxis* CGrid::getAxis(int axisIndex)
	2517	TRY
2342	2518	{
2343	2519	std::vector<CAxis*> axisListP = this->getAxis();
…	…
2357	2533	return axisListP[axisIndex];
2358	2534	}
	2535	CATCH_DUMP_ATTR
2359	2536
2360	2537	/*!
…	…
2363	2540	*/
2364	2541	CScalar* CGrid::getScalar(int scalarIndex)
	2542	TRY
2365	2543	{
2366	2544	std::vector<CScalar*> scalarListP = this->getScalars();
…	…
2380	2558	return scalarListP[scalarIndex];
2381	2559	}
	2560	CATCH_DUMP_ATTR
2382	2561
2383	2562	/*!
…	…
2386	2565	*/
2387	2566	void CGrid::setDomainList(const std::vector<CDomain*> domains)
	2567	TRY
2388	2568	{
2389	2569	if (isDomListSet) return;
…	…
2406	2586	isDomListSet = true;
2407	2587	}
2408
2409		}
	2588	}
	2589	CATCH_DUMP_ATTR
2410	2590
2411	2591	/*!
…	…
2414	2594	*/
2415	2595	void CGrid::setAxisList(const std::vector<CAxis*> axis)
	2596	TRY
2416	2597	{
2417	2598	if (isAxisListSet) return;
…	…
2435	2616	}
2436	2617	}
	2618	CATCH_DUMP_ATTR
2437	2619
2438	2620	/*!
…	…
2441	2623	*/
2442	2624	void CGrid::setScalarList(const std::vector<CScalar*> scalars)
	2625	TRY
2443	2626	{
2444	2627	if (isScalarListSet) return;
…	…
2462	2645	}
2463	2646	}
	2647	CATCH_DUMP_ATTR
2464	2648
2465	2649	/*!
…	…
2468	2652	*/
2469	2653	std::vector<StdString> CGrid::getDomainList()
	2654	TRY
2470	2655	{
2471	2656	setDomainList();
2472	2657	return domList_;
2473	2658	}
	2659	CATCH
2474	2660
2475	2661	/*!
…	…
2478	2664	*/
2479	2665	std::vector<StdString> CGrid::getAxisList()
	2666	TRY
2480	2667	{
2481	2668	setAxisList();
2482	2669	return axisList_;
2483	2670	}
	2671	CATCH
2484	2672
2485	2673	/*!
…	…
2488	2676	*/
2489	2677	std::vector<StdString> CGrid::getScalarList()
	2678	TRY
2490	2679	{
2491	2680	setScalarList();
2492	2681	return scalarList_;
2493	2682	}
	2683	CATCH
2494	2684
2495	2685	/*!
…	…
2497	2687	*/
2498	2688	void CGrid::sendAllDomains()
	2689	TRY
2499	2690	{
2500	2691	std::vector<CDomain*> domList = this->getVirtualDomainGroup()->getAllChildren();
…	…
2506	2697	}
2507	2698	}
	2699	CATCH_DUMP_ATTR
2508	2700
2509	2701	/*!
…	…
2511	2703	*/
2512	2704	void CGrid::sendAllAxis()
	2705	TRY
2513	2706	{
2514	2707	std::vector<CAxis*> aList = this->getVirtualAxisGroup()->getAllChildren();
…	…
2521	2714	}
2522	2715	}
	2716	CATCH_DUMP_ATTR
2523	2717
2524	2718	/*!
…	…
2526	2720	*/
2527	2721	void CGrid::sendAllScalars()
	2722	TRY
2528	2723	{
2529	2724	std::vector<CScalar*> sList = this->getVirtualScalarGroup()->getAllChildren();
…	…
2536	2731	}
2537	2732	}
	2733	CATCH_DUMP_ATTR
2538	2734
2539	2735	void CGrid::setContextClient(CContextClient* contextClient)
	2736	TRY
2540	2737	{
2541	2738	if (clientsSet.find(contextClient)==clientsSet.end())
…	…
2549	2746	this->getAxis()[i]->setContextClient(contextClient);
2550	2747	}
	2748	CATCH_DUMP_ATTR
2551	2749
2552	2750	/*!
…	…
2554	2752	*/
2555	2753	void CGrid::parse(xml::CXMLNode& node)
	2754	TRY
2556	2755	{
2557	2756	SuperClass::parse(node);
…	…
2594	2793	setScalarList();
2595	2794	}
	2795	CATCH_DUMP_ATTR
	2796
2596	2797	} // namespace xios

XIOS/trunk/src/node/grid.hpp

-                      r1564
+                      r1622
    template <int n>
    void CGrid::inputField(const CArray<double,n>& field, CArray<double,1>& stored) const
+   TRY
+   {
 //#ifdef __XIOS_DEBUG
 …
       this->storeField_arr(field.dataFirst(), stored);
+   }
+   CATCH
    template <int n>
    void CGrid::outputField(const CArray<double,1>& stored, CArray<double,n>& field) const
+   TRY
+   {
 //#ifdef __XIOS_DEBUG
 …
       this->restoreField_arr(stored, field.dataFirst());
+   }
+   CATCH
    /*!
 …
    template <int N>
    void CGrid::uncompressField(const CArray<double,N>& data, CArray<double,1>& outData) const
+   TRY
+   {
      uncompressField_arr(data.dataFirst(), outData);
+   }
+   CATCH
    template<int N>
 …
                              const CArray<int,1>& axisDomainOrder,
                              bool createMask)
+   TRY
+   {
      if (!gridMask.isEmpty() || createMask)
 …
+     }
+   }
+   CATCH_DUMP_ATTR
    template<int N>
 …
                                   const std::vector<int>& eachDimSize,
                                   bool newValue)
+   TRY
+   {
       if (N != eachDimSize.size())
 …
       gridMask = newValue;
+   }
+   CATCH_DUMP_ATTR
 …
    template<int N>
    void CGrid::modifyGridMask(CArray<bool,N>& gridMask, const CArray<int,1>& indexToModify, bool valueToModify)
+   TRY
+   {
      int num = indexToModify.numElements();
 …
+     }
+   }
+   CATCH_DUMP_ATTR
    ///--------------------------------------------------------------
+/*!
+  A grid can have multiple dimension, so can its mask in the form of multi-dimension array.
+It's not a good idea to store all multi-dimension arrays corresponding to each mask.
+One of the ways is to convert this array into 1-dimension one and every process is taken place on it.
+  \param [in] multi-dimension array grid mask
+*/
+template<int N>
+void CGrid::getLocalMask(const CArray<bool,N>& gridMask, CArray<bool,1>& localMask)
+{
+  if (gridMask.isEmpty()) return ;
+  int dim = gridMask.dimensions();
+  std::vector<int> dimensionSizes(dim);
+  for (int i = 0; i < dim; ++i) dimensionSizes[i] = gridMask.extent(i);
+  std::vector<int> idxLoop(dim,0);
+  int ssize = gridMask.numElements(), idx = 0;
+  localMask.resize(ssize);
+  while (idx < ssize)
+  /*!
+    A grid can have multiple dimension, so can its mask in the form of multi-dimension array.
+  It's not a good idea to store all multi-dimension arrays corresponding to each mask.
+  One of the ways is to convert this array into 1-dimension one and every process is taken place on it.
+    \param [in] multi-dimension array grid mask
+  */
+  template<int N>
+  void CGrid::getLocalMask(const CArray<bool,N>& gridMask, CArray<bool,1>& localMask)
+  TRY
+  {
+    for (int i = 0; i < dim-1; ++i)
+    if (gridMask.isEmpty()) return ;
+    int dim = gridMask.dimensions();
+    std::vector<int> dimensionSizes(dim);
+    for (int i = 0; i < dim; ++i) dimensionSizes[i] = gridMask.extent(i);
+    std::vector<int> idxLoop(dim,0);
+    int ssize = gridMask.numElements(), idx = 0;
+    localMask.resize(ssize);
+    while (idx < ssize)
+    {
       if (idxLoop[i] == dimensionSizes[i])
+      for (int i = 0; i < dim-1; ++i)
+      {
+        idxLoop[i] = 0;
+        ++idxLoop[i+1];
+        if (idxLoop[i] == dimensionSizes[i])
+        {
+          idxLoop[i] = 0;
+          ++idxLoop[i+1];
+        }
+      }
+      int maskIndex = idxLoop[0];
+      int mulDim = 1;
+      for (int k = 1; k < dim; ++k)
+      {
+        mulDim *= dimensionSizes[k-1];
+        maskIndex += idxLoop[k]*mulDim;
+      }
+      localMask(maskIndex) = *(gridMask.dataFirst()+maskIndex);
+      ++idxLoop[0];
+      ++idx;
+    }
-    int maskIndex = idxLoop[0];
-    int mulDim = 1;
-    for (int k = 1; k < dim; ++k)
+    {
-      mulDim *= dimensionSizes[k-1];
-      maskIndex += idxLoop[k]*mulDim;
+    }
-    localMask(maskIndex) = *(gridMask.dataFirst()+maskIndex);
-    ++idxLoop[0];
-    ++idx;
+  }
+}
+   CATCH_DUMP_ATTR
    // Declare/Define CGridGroup and CGridDefinition

Note: See TracChangeset for help on using the changeset viewer.

Download in other formats: