Context Navigation

← Previous Change
Next Change →

Changeset 1612 for XIOS/dev/dev_olga/src/node

Timestamp:

11/23/18 14:48:14 (6 years ago)

Author:

oabramkina

Message:

Dev: adding exception handling.

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

Location:

XIOS/dev/dev_olga/src/node

Files:

: 8 edited

axis.cpp (modified) (68 diffs)
context.cpp (modified) (91 diffs)
context.hpp (modified) (2 diffs)
domain.cpp (modified) (104 diffs)
field.cpp (modified) (68 diffs)
file.cpp (modified) (87 diffs)
file.hpp (modified) (1 diff)
grid.cpp (modified) (117 diffs)

Legend:

: Unmodified
: Added
: Removed

XIOS/dev/dev_olga/src/node/axis.cpp

r1600	r1612
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	CContext* context=CContext::getCurrent();
…	…
311	340	}
312	341	}
	342	CATCH_DUMP_ATTR
313	343
314	344	/*!
…	…
317	347
318	348	void CAxis::checkData()
	349	TRY
319	350	{
320	351	if (data_begin.isEmpty()) data_begin.setValue(0);
…	…
363	394
364	395	}
	396	CATCH_DUMP_ATTR
365	397
366	398	size_t CAxis::getGlobalWrittenSize(void)
…	…
373	405	*/
374	406	void CAxis::checkMask()
	407	TRY
375	408	{
376	409	if (!mask.isEmpty())
…	…
391	424	}
392	425	}
	426	CATCH_DUMP_ATTR
393	427
394	428	/*!
…	…
396	430	*/
397	431	void CAxis::checkBounds()
	432	TRY
398	433	{
399	434	if (!bounds.isEmpty())
…	…
408	443	else hasBounds = false;
409	444	}
	445	CATCH_DUMP_ATTR
410	446
411	447	void CAxis::checkLabel()
	448	TRY
412	449	{
413	450	if (!label.isEmpty())
…	…
422	459	else hasLabel = false;
423	460	}
	461	CATCH_DUMP_ATTR
424	462
425	463	/*!
…	…
427	465	*/
428	466	void CAxis::checkEligibilityForCompressedOutput()
	467	TRY
429	468	{
430	469	// We don't check if the mask is valid here, just if a mask has been defined at this point.
431	470	isCompressible_ = !mask.isEmpty();
432	471	}
	472	CATCH_DUMP_ATTR
433	473
434	474	/*!
…	…
436	476	*/
437	477	bool CAxis::dispatchEvent(CEventServer& event)
	478	TRY
438	479	{
439	480	if (SuperClass::dispatchEvent(event)) return true;
…	…
461	502	}
462	503	}
	504	CATCH
463	505
464	506	/*!
…	…
466	508	*/
467	509	void CAxis::checkAttributesOnClient()
	510	TRY
468	511	{
469	512	if (this->areClientAttributesChecked_) return;
…	…
474	517	this->areClientAttributesChecked_ = true;
475	518	}
	519	CATCH_DUMP_ATTR
476	520
477	521	/*
…	…
481	525	void CAxis::checkAttributesOnClientAfterTransformation(const std::vector<int>& globalDim, int orderPositionInGrid,
482	526	CServerDistributionDescription::ServerDistributionType distType)
	527	TRY
483	528	{
484	529	CContext* context=CContext::getCurrent() ;
…	…
494	539	this->isClientAfterTransformationChecked = true;
495	540	}
	541	CATCH_DUMP_ATTR
496	542
497	543	/*
…	…
504	550	void CAxis::sendCheckedAttributes(const std::vector<int>& globalDim, int orderPositionInGrid,
505	551	CServerDistributionDescription::ServerDistributionType distType)
	552	TRY
506	553	{
507	554	if (!this->areClientAttributesChecked_) checkAttributesOnClient();
…	…
514	561	this->isChecked = true;
515	562	}
	563	CATCH_DUMP_ATTR
516	564
517	565	/*!
…	…
522	570	void CAxis::sendAttributes(const std::vector<int>& globalDim, int orderPositionInGrid,
523	571	CServerDistributionDescription::ServerDistributionType distType)
	572	TRY
524	573	{
525	574	sendDistributionAttribute(globalDim, orderPositionInGrid, distType);
…	…
536	585	}
537	586	}
	587	CATCH_DUMP_ATTR
538	588
539	589	/*
…	…
547	597	void CAxis::computeConnectedClients(const std::vector<int>& globalDim, int orderPositionInGrid,
548	598	CServerDistributionDescription::ServerDistributionType distType)
	599	TRY
549	600	{
550	601	CContext* context = CContext::getCurrent();
…	…
666	717	}
667	718	}
	719	CATCH_DUMP_ATTR
668	720
669	721	/*
…	…
673	725	*/
674	726	void CAxis::computeWrittenIndex()
	727	TRY
675	728	{
676	729	if (computedWrittenIndex_) return;
…	…
714	767
715	768	}
	769	CATCH_DUMP_ATTR
716	770
717	771	void CAxis::computeWrittenCompressedIndex(MPI_Comm writtenComm)
	772	TRY
718	773	{
719	774	int writtenCommSize;
…	…
804	859	}
805	860	}
	861	CATCH_DUMP_ATTR
806	862
807	863	/*!
…	…
814	870	void CAxis::sendDistributionAttribute(const std::vector<int>& globalDim, int orderPositionInGrid,
815	871	CServerDistributionDescription::ServerDistributionType distType)
	872	TRY
816	873	{
817	874	std::list<CContextClient*>::iterator it;
…	…
852	909	}
853	910	}
	911	CATCH_DUMP_ATTR
854	912
855	913	/*
…	…
858	916	*/
859	917	void CAxis::recvDistributionAttribute(CEventServer& event)
	918	TRY
860	919	{
861	920	CBufferIn* buffer = event.subEvents.begin()->buffer;
…	…
864	923	get(axisId)->recvDistributionAttribute(*buffer);
865	924	}
	925	CATCH
866	926
867	927	/*
…	…
870	930	*/
871	931	void CAxis::recvDistributionAttribute(CBufferIn& buffer)
	932	TRY
872	933	{
873	934	int ni_srv, begin_srv;
…	…
879	940	begin.setValue(begin_srv);
880	941	}
	942	CATCH_DUMP_ATTR
881	943
882	944	/*
…	…
886	948	*/
887	949	void CAxis::sendNonDistributedAttributes()
	950	TRY
888	951	{
889	952	std::list<CContextClient*>::iterator it;
…	…
939	1002	}
940	1003	}
	1004	CATCH_DUMP_ATTR
941	1005
942	1006	/*
…	…
945	1009	*/
946	1010	void CAxis::recvNonDistributedAttributes(CEventServer& event)
	1011	TRY
947	1012	{
948	1013	list<CEventServer::SSubEvent>::iterator it;
…	…
955	1020	}
956	1021	}
	1022	CATCH
957	1023
958	1024	/*
…	…
962	1028	*/
963	1029	void CAxis::recvNonDistributedAttributes(int rank, CBufferIn& buffer)
	1030	TRY
964	1031	{
965	1032	CArray<int,1> tmp_index, tmp_data_index;
…	…
1003	1070	for (int idx = 0; idx < index.numElements(); ++idx) globalLocalIndexMap_[index(idx)] = idx;
1004	1071	}
	1072	CATCH_DUMP_ATTR
1005	1073
1006	1074	/*
…	…
1010	1078	*/
1011	1079	void CAxis::sendDistributedAttributes(void)
	1080	TRY
1012	1081	{
1013	1082	int ind, idx;
…	…
1113	1182	}
1114	1183	}
	1184	CATCH_DUMP_ATTR
1115	1185
1116	1186	/*
…	…
1119	1189	*/
1120	1190	void CAxis::recvDistributedAttributes(CEventServer& event)
	1191	TRY
1121	1192	{
1122	1193	string axisId;
…	…
1134	1205	get(axisId)->recvDistributedAttributes(ranks, buffers);
1135	1206	}
	1207	CATCH
1136	1208
1137	1209	/*
…	…
1141	1213	*/
1142	1214	void CAxis::recvDistributedAttributes(vector<int>& ranks, vector<CBufferIn*> buffers)
	1215	TRY
1143	1216	{
1144	1217	int nbReceived = ranks.size(), idx, ind, gloInd, locInd;
…	…
1259	1332	data_n.setValue(data_index.numElements());
1260	1333	}
	1334	CATCH_DUMP_ATTR
1261	1335
1262	1336	/*!
…	…
1268	1342	*/
1269	1343	bool CAxis::isEqual(CAxis* obj)
	1344	TRY
1270	1345	{
1271	1346	vector<StdString> excludedAttr;
…	…
1291	1366	return objEqual;
1292	1367	}
	1368	CATCH_DUMP_ATTR
1293	1369
1294	1370	/*
…	…
1298	1374	*/
1299	1375	CTransformation<CAxis>* CAxis::addTransformation(ETranformationType transType, const StdString& id)
	1376	TRY
1300	1377	{
1301	1378	transformationMap_.push_back(std::make_pair(transType, CTransformation<CAxis>::createTransformation(transType,id)));
1302	1379	return transformationMap_.back().second;
1303	1380	}
	1381	CATCH_DUMP_ATTR
1304	1382
1305	1383	/*
…	…
1307	1385	*/
1308	1386	bool CAxis::hasTransformation()
	1387	TRY
1309	1388	{
1310	1389	return (!transformationMap_.empty());
1311	1390	}
	1391	CATCH_DUMP_ATTR
1312	1392
1313	1393	/*
…	…
1316	1396	*/
1317	1397	void CAxis::setTransformations(const TransMapTypes& axisTrans)
	1398	TRY
1318	1399	{
1319	1400	transformationMap_ = axisTrans;
1320	1401	}
	1402	CATCH_DUMP_ATTR
1321	1403
1322	1404	/*
…	…
1325	1407	*/
1326	1408	CAxis::TransMapTypes CAxis::getAllTransformations(void)
	1409	TRY
1327	1410	{
1328	1411	return transformationMap_;
1329	1412	}
	1413	CATCH_DUMP_ATTR
1330	1414
1331	1415	/*
…	…
1334	1418	*/
1335	1419	void CAxis::duplicateTransformation(CAxis* src)
	1420	TRY
1336	1421	{
1337	1422	if (src->hasTransformation())
…	…
1340	1425	}
1341	1426	}
	1427	CATCH_DUMP_ATTR
1342	1428
1343	1429	/*!
…	…
1345	1431	*/
1346	1432	void CAxis::solveInheritanceTransformation()
	1433	TRY
1347	1434	{
1348	1435	if (hasTransformation() \|\| !hasDirectAxisReference())
…	…
1361	1448	refAxis[i]->setTransformations(axis->getAllTransformations());
1362	1449	}
	1450	CATCH_DUMP_ATTR
1363	1451
1364	1452	void CAxis::setContextClient(CContextClient* contextClient)
	1453	TRY
1365	1454	{
1366	1455	if (clientsSet.find(contextClient)==clientsSet.end())
…	…
1370	1459	}
1371	1460	}
	1461	CATCH_DUMP_ATTR
1372	1462
1373	1463	void CAxis::parse(xml::CXMLNode & node)
	1464	TRY
1374	1465	{
1375	1466	SuperClass::parse(node);
…	…
1402	1493	}
1403	1494	}
	1495	CATCH_DUMP_ATTR
1404	1496
1405	1497	DEFINE_REF_FUNC(Axis,axis)

XIOS/dev/dev_olga/src/node/context.cpp

r1542	r1612
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/dev/dev_olga/src/node/context.hpp

-                      r1542
+                      r1612
          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/dev/dev_olga/src/node/domain.cpp

r1600	r1612
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
…	…
176	192	return attributesSizes;
177	193	}
	194	CATCH_DUMP_ATTR
178	195
179	196	//----------------------------------------------------------------
180	197
181	198	bool CDomain::isEmpty(void) const
	199	TRY
182	200	{
183	201	return ((this->i_index.isEmpty()) \|\| (0 == this->i_index.numElements()));
184	202	}
	203	CATCH
185	204
186	205	//----------------------------------------------------------------
187	206
188	207	bool CDomain::IsWritten(const StdString & filename) const
	208	TRY
189	209	{
190	210	return (this->relFiles.find(filename) != this->relFiles.end());
191	211	}
	212	CATCH
192	213
193	214	bool CDomain::isWrittenCompressed(const StdString& filename) const
	215	TRY
194	216	{
195	217	return (this->relFilesCompressed.find(filename) != this->relFilesCompressed.end());
196	218	}
	219	CATCH
197	220
198	221	//----------------------------------------------------------------
199	222
200	223	bool CDomain::isDistributed(void) const
	224	TRY
201	225	{
202	226	bool distributed = !((!ni.isEmpty() && (ni == ni_glo) && !nj.isEmpty() && (nj == nj_glo)) \|\|
…	…
206	230	return distributed;
207	231	}
	232	CATCH
208	233
209	234	//----------------------------------------------------------------
…	…
215	240	*/
216	241	bool CDomain::isCompressible(void) const
	242	TRY
217	243	{
218	244	return isCompressible_;
219	245	}
	246	CATCH
220	247
221	248	void CDomain::addRelFile(const StdString & filename)
	249	TRY
222	250	{
223	251	this->relFiles.insert(filename);
224	252	}
	253	CATCH_DUMP_ATTR
225	254
226	255	void CDomain::addRelFileCompressed(const StdString& filename)
	256	TRY
227	257	{
228	258	this->relFilesCompressed.insert(filename);
229	259	}
	260	CATCH_DUMP_ATTR
230	261
231	262	StdString CDomain::GetName(void) { return (StdString("domain")); }
…	…
240	271	*/
241	272	bool CDomain::distributionAttributesHaveValue() const
	273	TRY
242	274	{
243	275	bool hasValues = true;
…	…
251	283	return hasValues;
252	284	}
	285	CATCH
253	286
254	287	/*!
…	…
260	293	*/
261	294	void CDomain::redistribute(int nbLocalDomain)
	295	TRY
262	296	{
263	297	if (this->isRedistributed_) return;
…	…
422	456	checkDomain();
423	457	}
	458	CATCH_DUMP_ATTR
424	459
425	460	/*!
…	…
427	462	*/
428	463	void CDomain::fillInLonLat()
	464	TRY
429	465	{
430	466	switch (type)
…	…
444	480	}
445	481	completeLonLatClient() ;
446
447		}
	482	}
	483	CATCH_DUMP_ATTR
448	484
449	485	/*!
…	…
453	489	*/
454	490	void CDomain::fillInRectilinearLonLat()
	491	TRY
455	492	{
456	493	if (!lonvalue_rectilinear_read_from_file.isEmpty() && lonvalue_2d.isEmpty() && lonvalue_1d.isEmpty())
…	…
462	499	lon_end.setValue(lonvalue_rectilinear_read_from_file(ni_glo-1));
463	500	}
464		else
	501	else if (!hasLonInReadFile_)
465	502	{
466	503	if (!lonvalue_2d.isEmpty()) lonvalue_2d.free();
…	…
496	533	lat_end.setValue(latvalue_rectilinear_read_from_file(nj_glo-1));
497	534	}
498		else
	535	else if (!hasLatInReadFile_)
499	536	{
500	537	if (!latvalue_2d.isEmpty()) latvalue_1d.free();
…	…
521	558	}
522	559	}
	560	CATCH_DUMP_ATTR
523	561
524	562	/*
…	…
527	565	*/
528	566	void CDomain::fillInCurvilinearLonLat()
	567	TRY
529	568	{
530	569	if (!lonvalue_curvilinear_read_from_file.isEmpty() && lonvalue_2d.isEmpty() && lonvalue_1d.isEmpty())
…	…
569	608	bounds_latvalue_curvilinear_read_from_file.free();
570	609	}
571
572		}
	610	}
	611	CATCH_DUMP_ATTR
573	612
574	613	/*
…	…
577	616	*/
578	617	void CDomain::fillInUnstructuredLonLat()
	618	TRY
579	619	{
580	620	if (i_index.isEmpty())
…	…
628	668	}
629	669	}
	670	CATCH_DUMP_ATTR
630	671
631	672	/*
…	…
633	674	*/
634	675	void CDomain::AllgatherRectilinearLonLat(CArray<double,1>& lon, CArray<double,1>& lat, CArray<double,1>& lon_g, CArray<double,1>& lat_g)
	676	TRY
635	677	{
636	678	CContext* context = CContext::getCurrent();
…	…
664	706	delete[] nj_g ;
665	707	}
	708	CATCH_DUMP_ATTR
666	709
667	710	void CDomain::fillInRectilinearBoundLonLat(CArray<double,1>& lon, CArray<double,1>& lat,
668	711	CArray<double,2>& boundsLon, CArray<double,2>& boundsLat)
669		{
	712	TRY
	713	{
670	714	int i,j,k;
671	715
…	…
766	810	}
767	811	}
	812	CATCH_DUMP_ATTR
768	813
769	814	/*
…	…
771	816	*/
772	817	void CDomain::checkDomain(void)
	818	TRY
773	819	{
774	820	if (type.isEmpty())
…	…
862	908	}
863	909	}
	910	CATCH_DUMP_ATTR
864	911
865	912	size_t CDomain::getGlobalWrittenSize(void)
…	…
871	918	// Check validity of local domain on using the combination of 3 parameters: ibegin, ni and i_index
872	919	void CDomain::checkLocalIDomain(void)
	920	TRY
873	921	{
874	922	// If ibegin and ni are provided then we use them to check the validity of local domain
…	…
929	977	}
930	978	}
	979	CATCH_DUMP_ATTR
931	980
932	981	// Check validity of local domain on using the combination of 3 parameters: jbegin, nj and j_index
933	982	void CDomain::checkLocalJDomain(void)
	983	TRY
934	984	{
935	985	// If jbegin and nj are provided then we use them to check the validity of local domain
…	…
980	1030	}
981	1031	}
	1032	CATCH_DUMP_ATTR
982	1033
983	1034	//----------------------------------------------------------------
984	1035
985	1036	void CDomain::checkMask(void)
	1037	TRY
986	1038	{
987	1039	if (!mask_1d.isEmpty() && !mask_2d.isEmpty())
…	…
1029	1081	}
1030	1082	}
	1083	CATCH_DUMP_ATTR
1031	1084
1032	1085	//----------------------------------------------------------------
1033	1086
1034	1087	void CDomain::checkDomainData(void)
	1088	TRY
1035	1089	{
1036	1090	if (data_dim.isEmpty())
…	…
1072	1126	}
1073	1127	}
	1128	CATCH_DUMP_ATTR
1074	1129
1075	1130	//----------------------------------------------------------------
1076	1131
1077	1132	void CDomain::checkCompression(void)
	1133	TRY
1078	1134	{
1079	1135	int i,j,ind;
…	…
1202	1258	}
1203	1259	}
	1260	CATCH_DUMP_ATTR
1204	1261
1205	1262	//----------------------------------------------------------------
1206	1263	void CDomain::computeLocalMask(void)
	1264	TRY
1207	1265	{
1208	1266	localMask.resize(i_index.numElements()) ;
…	…
1236	1294	}
1237	1295	}
	1296	CATCH_DUMP_ATTR
1238	1297
1239	1298	void CDomain::checkEligibilityForCompressedOutput(void)
	1299	TRY
1240	1300	{
1241	1301	// We don't check if the mask or the indexes are valid here, just if they have been defined at this point.
1242	1302	isCompressible_ = !mask_1d.isEmpty() \|\| !mask_2d.isEmpty() \|\| !data_i_index.isEmpty();
1243	1303	}
	1304	CATCH_DUMP_ATTR
1244	1305
1245	1306	//----------------------------------------------------------------
…	…
1250	1311	*/
1251	1312	void CDomain::completeLonLatClient(void)
	1313	TRY
1252	1314	{
1253	1315	bool lonlatValueExisted = (0 != lonvalue.numElements()) \|\| (0 != latvalue.numElements());
…	…
1363	1425	}
1364	1426	}
	1427	CATCH_DUMP_ATTR
1365	1428
1366	1429	/*
…	…
1368	1431	*/
1369	1432	void CDomain::convertLonLatValue(void)
	1433	TRY
1370	1434	{
1371	1435	bool lonlatValueExisted = (0 != lonvalue.numElements()) \|\| (0 != latvalue.numElements());
…	…
1465	1529	}
1466	1530	}
1467
	1531	CATCH_DUMP_ATTR
1468	1532
1469	1533	void CDomain::checkBounds(void)
	1534	TRY
1470	1535	{
1471	1536	bool hasBoundValues = (0 != bounds_lonvalue.numElements()) \|\| (0 != bounds_latvalue.numElements());
…	…
1559	1624	}
1560	1625	}
	1626	CATCH_DUMP_ATTR
1561	1627
1562	1628	void CDomain::checkArea(void)
	1629	TRY
1563	1630	{
1564	1631	bool hasAreaValue = (!areavalue.isEmpty() && 0 != areavalue.numElements());
…	…
1588	1655	}
1589	1656	}
	1657	CATCH_DUMP_ATTR
1590	1658
1591	1659	void CDomain::checkLonLat()
	1660	TRY
1592	1661	{
1593	1662	if (!hasLonLat) hasLonLat = (!latvalue_1d.isEmpty() && !lonvalue_1d.isEmpty()) \|\|
…	…
1649	1718	}
1650	1719	}
	1720	CATCH_DUMP_ATTR
1651	1721
1652	1722	void CDomain::checkAttributesOnClientAfterTransformation()
	1723	TRY
1653	1724	{
1654	1725	CContext* context=CContext::getCurrent() ;
…	…
1665	1736	this->isClientAfterTransformationChecked = true;
1666	1737	}
	1738	CATCH_DUMP_ATTR
1667	1739
1668	1740	//----------------------------------------------------------------
…	…
1670	1742	// This function only checks all attributes of current domain
1671	1743	void CDomain::checkAttributesOnClient()
	1744	TRY
1672	1745	{
1673	1746	if (this->isClientChecked) return;
…	…
1695	1768	this->isClientChecked = true;
1696	1769	}
	1770	CATCH_DUMP_ATTR
1697	1771
1698	1772	// Send all checked attributes to server
1699	1773	void CDomain::sendCheckedAttributes()
	1774	TRY
1700	1775	{
1701	1776	if (!this->isClientChecked) checkAttributesOnClient();
…	…
1710	1785	this->isChecked = true;
1711	1786	}
	1787	CATCH_DUMP_ATTR
1712	1788
1713	1789	void CDomain::checkAttributes(void)
	1790	TRY
1714	1791	{
1715	1792	if (this->isChecked) return;
…	…
1741	1818	this->isChecked = true;
1742	1819	}
	1820	CATCH_DUMP_ATTR
1743	1821
1744	1822	/*!
…	…
1749	1827	*/
1750	1828	void CDomain::computeConnectedClients()
	1829	TRY
1751	1830	{
1752	1831	CContext* context=CContext::getCurrent() ;
…	…
1876	1955	}
1877	1956	}
	1957	CATCH_DUMP_ATTR
1878	1958
1879	1959	/*!
…	…
1883	1963	*/
1884	1964	void CDomain::computeWrittenIndex()
	1965	TRY
1885	1966	{
1886	1967	if (computedWrittenIndex_) return;
…	…
1920	2001	}
1921	2002	}
	2003	CATCH_DUMP_ATTR
1922	2004
1923	2005	void CDomain::computeWrittenCompressedIndex(MPI_Comm writtenComm)
	2006	TRY
1924	2007	{
1925	2008	int writtenCommSize;
…	…
1989	2072	}
1990	2073	}
	2074	CATCH_DUMP_ATTR
1991	2075
1992	2076	/*!
…	…
1995	2079	*/
1996	2080	void CDomain::sendAttributes()
	2081	TRY
1997	2082	{
1998	2083	sendDistributionAttributes();
…	…
2002	2087	sendDataIndex();
2003	2088	}
2004
	2089	CATCH
2005	2090	/*!
2006	2091	Send global index from client to connected client(s)
2007	2092	*/
2008	2093	void CDomain::sendIndex()
	2094	TRY
2009	2095	{
2010	2096	int ns, n, i, j, ind, nv, idx;
…	…
2049	2135	}
2050	2136	}
	2137	CATCH_DUMP_ATTR
2051	2138
2052	2139	/*!
…	…
2056	2143	*/
2057	2144	void CDomain::sendDistributionAttributes(void)
	2145	TRY
2058	2146	{
2059	2147	std::list<CContextClient*>::iterator it;
…	…
2102	2190	}
2103	2191	}
	2192	CATCH_DUMP_ATTR
2104	2193
2105	2194	/*!
…	…
2107	2196	*/
2108	2197	void CDomain::sendArea()
	2198	TRY
2109	2199	{
2110	2200	if (!hasArea) return;
…	…
2150	2240	}
2151	2241	}
	2242	CATCH_DUMP_ATTR
2152	2243
2153	2244	/*!
…	…
2157	2248	*/
2158	2249	void CDomain::sendLonLat()
	2250	TRY
2159	2251	{
2160	2252	if (!hasLonLat) return;
…	…
2245	2337	}
2246	2338	}
	2339	CATCH_DUMP_ATTR
2247	2340
2248	2341	/*!
…	…
2253	2346	*/
2254	2347	void CDomain::sendDataIndex()
	2348	TRY
2255	2349	{
2256	2350	int ns, n, i, j, ind, nv, idx;
…	…
2321	2415	}
2322	2416	}
	2417	CATCH
2323	2418
2324	2419	bool CDomain::dispatchEvent(CEventServer& event)
	2420	TRY
2325	2421	{
2326	2422	if (SuperClass::dispatchEvent(event)) return true;
…	…
2360	2456	}
2361	2457	}
	2458	CATCH
2362	2459
2363	2460	/*!
…	…
2366	2463	*/
2367	2464	void CDomain::recvIndex(CEventServer& event)
	2465	TRY
2368	2466	{
2369	2467	string domainId;
…	…
2379	2477	get(domainId)->recvIndex(rankBuffers);
2380	2478	}
	2479	CATCH
2381	2480
2382	2481	/*!
…	…
2386	2485	*/
2387	2486	void CDomain::recvIndex(std::map<int, CBufferIn*>& rankBuffers)
	2487	TRY
2388	2488	{
2389	2489	int nbReceived = rankBuffers.size(), i, ind, index, type_int, iIndex, jIndex;
…	…
2445	2545	domainMask.resize(0); // Mask is not defined anymore on servers
2446	2546	}
	2547	CATCH
2447	2548
2448	2549	/*!
…	…
2451	2552	*/
2452	2553	void CDomain::recvDistributionAttributes(CEventServer& event)
	2554	TRY
2453	2555	{
2454	2556	CBufferIn* buffer=event.subEvents.begin()->buffer;
…	…
2457	2559	get(domainId)->recvDistributionAttributes(*buffer);
2458	2560	}
	2561	CATCH
2459	2562
2460	2563	/*!
…	…
2464	2567	*/
2465	2568	void CDomain::recvDistributionAttributes(CBufferIn& buffer)
	2569	TRY
2466	2570	{
2467	2571	int ni_tmp, ibegin_tmp, nj_tmp, jbegin_tmp;
…	…
2479	2583
2480	2584	}
2481
	2585	CATCH_DUMP_ATTR
2482	2586	/*!
2483	2587	Receive longitude event from clients(s)
…	…
2485	2589	*/
2486	2590	void CDomain::recvLon(CEventServer& event)
	2591	TRY
2487	2592	{
2488	2593	string domainId;
…	…
2498	2603	get(domainId)->recvLon(rankBuffers);
2499	2604	}
	2605	CATCH
2500	2606
2501	2607	/*!
…	…
2504	2610	*/
2505	2611	void CDomain::recvLon(std::map<int, CBufferIn*>& rankBuffers)
	2612	TRY
2506	2613	{
2507	2614	int nbReceived = rankBuffers.size(), i, ind, index, iindex, jindex, lInd;
…	…
2563	2670	}
2564	2671	}
	2672	CATCH_DUMP_ATTR
2565	2673
2566	2674	/*!
…	…
2569	2677	*/
2570	2678	void CDomain::recvLat(CEventServer& event)
	2679	TRY
2571	2680	{
2572	2681	string domainId;
…	…
2582	2691	get(domainId)->recvLat(rankBuffers);
2583	2692	}
	2693	CATCH
2584	2694
2585	2695	/*!
…	…
2588	2698	*/
2589	2699	void CDomain::recvLat(std::map<int, CBufferIn*>& rankBuffers)
	2700	TRY
2590	2701	{
2591	2702	int nbReceived = rankBuffers.size(), i, ind, index, iindex, jindex, lInd;
…	…
2649	2760	}
2650	2761	}
	2762	CATCH_DUMP_ATTR
2651	2763
2652	2764	/*!
…	…
2655	2767	*/
2656	2768	void CDomain::recvArea(CEventServer& event)
	2769	TRY
2657	2770	{
2658	2771	string domainId;
…	…
2668	2781	get(domainId)->recvArea(rankBuffers);
2669	2782	}
	2783	CATCH
2670	2784
2671	2785	/*!
…	…
2674	2788	*/
2675	2789	void CDomain::recvArea(std::map<int, CBufferIn*>& rankBuffers)
	2790	TRY
2676	2791	{
2677	2792	int nbReceived = rankBuffers.size(), i, ind, index, lInd;
…	…
2719	2834	}
2720	2835	}
	2836	CATCH_DUMP_ATTR
2721	2837
2722	2838	/*!
…	…
2728	2844	*/
2729	2845	bool CDomain::isEqual(CDomain* obj)
	2846	TRY
2730	2847	{
2731	2848	vector<StdString> excludedAttr;
…	…
2750	2867	return objEqual;
2751	2868	}
	2869	CATCH_DUMP_ATTR
2752	2870
2753	2871	/*!
…	…
2756	2874	*/
2757	2875	void CDomain::recvDataIndex(CEventServer& event)
	2876	TRY
2758	2877	{
2759	2878	string domainId;
…	…
2769	2888	get(domainId)->recvDataIndex(rankBuffers);
2770	2889	}
	2890	CATCH
2771	2891
2772	2892	/*!
…	…
2780	2900	*/
2781	2901	void CDomain::recvDataIndex(std::map<int, CBufferIn*>& rankBuffers)
	2902	TRY
2782	2903	{
2783	2904	int nbReceived = rankBuffers.size(), i, ind, index, indexI, indexJ, type_int, lInd;
…	…
2846	2967	data_jbegin.setValue(0);
2847	2968	}
	2969	CATCH_DUMP_ATTR
2848	2970
2849	2971	CTransformation<CDomain>* CDomain::addTransformation(ETranformationType transType, const StdString& id)
	2972	TRY
2850	2973	{
2851	2974	transformationMap_.push_back(std::make_pair(transType, CTransformation<CDomain>::createTransformation(transType,id)));
2852	2975	return transformationMap_.back().second;
2853	2976	}
	2977	CATCH_DUMP_ATTR
2854	2978
2855	2979	/*!
…	…
2858	2982	*/
2859	2983	bool CDomain::hasTransformation()
	2984	TRY
2860	2985	{
2861	2986	return (!transformationMap_.empty());
2862	2987	}
	2988	CATCH_DUMP_ATTR
2863	2989
2864	2990	/*!
…	…
2867	2993	*/
2868	2994	void CDomain::setTransformations(const TransMapTypes& domTrans)
	2995	TRY
2869	2996	{
2870	2997	transformationMap_ = domTrans;
2871	2998	}
	2999	CATCH_DUMP_ATTR
2872	3000
2873	3001	/*!
…	…
2876	3004	*/
2877	3005	CDomain::TransMapTypes CDomain::getAllTransformations(void)
	3006	TRY
2878	3007	{
2879	3008	return transformationMap_;
2880	3009	}
	3010	CATCH_DUMP_ATTR
2881	3011
2882	3012	void CDomain::duplicateTransformation(CDomain* src)
	3013	TRY
2883	3014	{
2884	3015	if (src->hasTransformation())
…	…
2887	3018	}
2888	3019	}
	3020	CATCH_DUMP_ATTR
2889	3021
2890	3022	/*!
…	…
2892	3024	*/
2893	3025	void CDomain::solveInheritanceTransformation()
	3026	TRY
2894	3027	{
2895	3028	if (hasTransformation() \|\| !hasDirectDomainReference())
…	…
2908	3041	refDomains[i]->setTransformations(domain->getAllTransformations());
2909	3042	}
	3043	CATCH_DUMP_ATTR
2910	3044
2911	3045	void CDomain::setContextClient(CContextClient* contextClient)
	3046	TRY
2912	3047	{
2913	3048	if (clientsSet.find(contextClient)==clientsSet.end())
…	…
2917	3052	}
2918	3053	}
	3054	CATCH_DUMP_ATTR
2919	3055
2920	3056	/*!
…	…
2924	3060	*/
2925	3061	void CDomain::parse(xml::CXMLNode & node)
	3062	TRY
2926	3063	{
2927	3064	SuperClass::parse(node);
…	…
2954	3091	}
2955	3092	}
	3093	CATCH_DUMP_ATTR
2956	3094	//----------------------------------------------------------------
2957	3095

XIOS/dev/dev_olga/src/node/field.cpp

r1594	r1612
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	}
	1887	CATCH
1728	1888
1729	1889	bool CField::hasGridMask(void) const
	1890	TRY
1730	1891	{
1731	1892	return (this->grid->hasMask());
1732	1893	}
	1894	CATCH
1733	1895
1734	1896	DEFINE_REF_FUNC(Field,field)

XIOS/dev/dev_olga/src/node/file.cpp

r1542	r1612
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/dev/dev_olga/src/node/file.hpp

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

XIOS/dev/dev_olga/src/node/grid.cpp

r1594	r1612
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	}
341
	365	CATCH_DUMP_ATTR
342	366	bool CGrid::hasMask() const
	367	TRY
343	368	{
344	369	return (!mask_1d.isEmpty() \|\| !mask_2d.isEmpty() \|\| !mask_3d.isEmpty() \|\|
345	370	!mask_4d.isEmpty() \|\| !mask_5d.isEmpty() \|\| !mask_6d.isEmpty() \|\| !mask_7d.isEmpty());
346	371	}
	372	CATCH
347	373
348	374	/*
…	…
350	376	*/
351	377	void CGrid::createMask(void)
	378	TRY
352	379	{
353	380	using namespace std;
…	…
387	414	}
388	415	}
	416	CATCH_DUMP_ATTR
389	417
390	418	/*
…	…
392	420	*/
393	421	void CGrid::checkMask(void)
	422	TRY
394	423	{
395	424	using namespace std;
…	…
429	458	}
430	459	}
431
	460	CATCH_DUMP_ATTR
	461
432	462	/*
433	463	Modify value of mask in a certain index
…	…
437	467	*/
438	468	void CGrid::modifyMask(const CArray<int,1>& indexToModify, bool modifyValue)
	469	TRY
439	470	{
440	471	using namespace std;
…	…
472	503	}
473	504	}
	505	CATCH_DUMP_ATTR
474	506
475	507	/*
…	…
479	511	*/
480	512	void CGrid::modifyMaskSize(const std::vector<int>& newDimensionSize, bool newValue)
	513	TRY
481	514	{
482	515	std::vector<CDomain*> domainP = this->getDomains();
…	…
513	546	}
514	547	}
	548	CATCH_DUMP_ATTR
515	549
516	550	//---------------------------------------------------------------
517	551
518	552	void CGrid::solveDomainRef(bool sendAtt)
	553	TRY
519	554	{
520	555	setDomainList();
…	…
529	564	}
530	565	}
	566	CATCH_DUMP_ATTR
531	567
532	568	//---------------------------------------------------------------
533	569
534	570	void CGrid::solveAxisRef(bool sendAtt)
	571	TRY
535	572	{
536	573	setAxisList();
…	…
560	597	}
561	598	}
	599	CATCH_DUMP_ATTR
562	600
563	601	//---------------------------------------------------------------
564	602
565	603	void CGrid::solveScalarRef(bool sendAtt)
	604	TRY
566	605	{
567	606	setScalarList();
…	…
577	616	}
578	617	}
	618	CATCH_DUMP_ATTR
579	619
580	620	/*!
…	…
582	622	*/
583	623	void CGrid::computeWrittenIndex()
	624	TRY
584	625	{
585	626	if (computedWrittenIndex_) return;
…	…
641	682	}
642	683	}
	684	CATCH_DUMP_ATTR
643	685
644	686	//---------------------------------------------------------------
…	…
651	693	*/
652	694	void CGrid::computeClientIndex()
	695	TRY
653	696	{
654	697	CContext* context = CContext::getCurrent();
…	…
711	754	}
712	755	}
	756	CATCH_DUMP_ATTR
713	757
714	758	/*!
…	…
716	760	*/
717	761	void CGrid::computeConnectedClients()
	762	TRY
718	763	{
719	764	CContext* context = CContext::getCurrent();
…	…
833	878	}
834	879	}
	880	CATCH_DUMP_ATTR
835	881
836	882	/*!
…	…
842	888	*/
843	889	void CGrid::computeIndex(void)
	890	TRY
844	891	{
845	892	CContext* context = CContext::getCurrent();
…	…
868	915	}
869	916	}
	917	CATCH_DUMP_ATTR
870	918
871	919	/*!
…	…
881	929	const CContextClient* client,
882	930	CClientServerMapping::GlobalIndexMap& globalIndexOnServer)
	931	TRY
883	932	{
884	933	int serverSize = client->serverSize;
…	…
1047	1096	}
1048	1097	}
1049		//----------------------------------------------------------------
	1098	CATCH_DUMP_ATTR
	1099	//----------------------------------------------------------------
1050	1100
1051	1101	CGrid* CGrid::createGrid(CDomain* domain)
	1102	TRY
1052	1103	{
1053	1104	std::vector<CDomain*> vecDom(1, domain);
…	…
1056	1107	return createGrid(vecDom, vecAxis);
1057	1108	}
	1109	CATCH
1058	1110
1059	1111	CGrid* CGrid::createGrid(CDomain* domain, CAxis* axis)
1060		{
	1112	TRY
	1113	{
1061	1114	std::vector<CDomain*> vecDom(1, domain);
1062	1115	std::vector<CAxis*> vecAxis(1, axis);
…	…
1064	1117	return createGrid(vecDom, vecAxis);
1065	1118	}
	1119	CATCH
1066	1120
1067	1121	CGrid* CGrid::createGrid(const std::vector<CDomain>& domains, const std::vector<CAxis>& axis,
1068	1122	const CArray<int,1>& axisDomainOrder)
	1123	TRY
1069	1124	{
1070	1125	std::vector<CScalar*> vecScalar;
1071	1126	return createGrid(generateId(domains, axis, vecScalar, axisDomainOrder), domains, axis, vecScalar, axisDomainOrder);
1072	1127	}
	1128	CATCH
1073	1129
1074	1130	CGrid* CGrid::createGrid(const std::vector<CDomain>& domains, const std::vector<CAxis>& axis,
1075	1131	const std::vector<CScalar*>& scalars, const CArray<int,1>& axisDomainOrder)
	1132	TRY
1076	1133	{
1077	1134	return createGrid(generateId(domains, axis, scalars, axisDomainOrder), domains, axis, scalars, axisDomainOrder);
1078	1135	}
	1136	CATCH
1079	1137
1080	1138	CGrid* CGrid::createGrid(StdString id, const std::vector<CDomain>& domains, const std::vector<CAxis>& axis,
1081	1139	const std::vector<CScalar*>& scalars, const CArray<int,1>& axisDomainOrder)
	1140	TRY
1082	1141	{
1083	1142	if (axisDomainOrder.numElements() > 0 && axisDomainOrder.numElements() != (domains.size() + axis.size() + scalars.size()))
…	…
1121	1180	return grid;
1122	1181	}
	1182	CATCH
1123	1183
1124	1184	CGrid* CGrid::cloneGrid(const StdString& idNewGrid, CGrid* gridSrc)
	1185	TRY
1125	1186	{
1126	1187	std::vector<CDomain*> domainSrcTmp = gridSrc->getDomains(), domainSrc;
…	…
1162	1223	return grid;
1163	1224	}
	1225	CATCH
1164	1226
1165	1227	StdString CGrid::generateId(const std::vector<CDomain>& domains, const std::vector<CAxis>& axis,
1166	1228	const std::vector<CScalar*>& scalars, const CArray<int,1>& axisDomainOrder)
	1229	TRY
1167	1230	{
1168	1231	if (axisDomainOrder.numElements() > 0 && axisDomainOrder.numElements() != (domains.size() + axis.size() + scalars.size()))
…	…
1205	1268	return id.str();
1206	1269	}
	1270	CATCH
1207	1271
1208	1272	StdString CGrid::generateId(const CGrid* gridSrc, const CGrid* gridDest)
	1273	TRY
1209	1274	{
1210	1275	StdString idSrc = gridSrc->getId();
…	…
1216	1281	return id.str();
1217	1282	}
	1283	CATCH
1218	1284
1219	1285	//----------------------------------------------------------------
1220	1286
1221	1287	CDomainGroup* CGrid::getVirtualDomainGroup() const
	1288	TRY
1222	1289	{
1223	1290	return this->vDomainGroup_;
1224	1291	}
	1292	CATCH
1225	1293
1226	1294	CAxisGroup* CGrid::getVirtualAxisGroup() const
	1295	TRY
1227	1296	{
1228	1297	return this->vAxisGroup_;
1229	1298	}
	1299	CATCH
1230	1300
1231	1301	CScalarGroup* CGrid::getVirtualScalarGroup() const
	1302	TRY
1232	1303	{
1233	1304	return this->vScalarGroup_;
1234	1305	}
	1306	CATCH
1235	1307
1236	1308	/*
…	…
1268	1340
1269	1341	void CGrid::storeField_arr(const double* const data, CArray<double, 1>& stored) const
	1342	TRY
1270	1343	{
1271	1344	const StdSize size = storeIndex_client.numElements();
…	…
1274	1347	for(StdSize i = 0; i < size; i++) stored(i) = data[storeIndex_client(i)];
1275	1348	}
	1349	CATCH
1276	1350
1277	1351	void CGrid::restoreField_arr(const CArray<double, 1>& stored, double* const data) const
	1352	TRY
1278	1353	{
1279	1354	const StdSize size = storeIndex_client.numElements();
…	…
1281	1356	for(StdSize i = 0; i < size; i++) data[storeIndex_client(i)] = stored(i);
1282	1357	}
	1358	CATCH
1283	1359
1284	1360	void CGrid::maskField_arr(const double* const data, CArray<double, 1>& stored) const
…	…
1295	1371
1296	1372	void CGrid::uncompressField_arr(const double* const data, CArray<double, 1>& out) const
	1373	TRY
1297	1374	{
1298	1375	const std::vector<int>& localMaskedDataIndex = clientDistribution_->getLocalMaskedDataIndexOnClient();
…	…
1300	1377	for(int i = 0; i < size; ++i) out(localMaskedDataIndex[i]) = data[i];
1301	1378	}
1302
	1379	CATCH
1303	1380
1304	1381	void CGrid::computeClientIndexScalarGrid()
	1382	TRY
1305	1383	{
1306	1384	CContext* context = CContext::getCurrent();
…	…
1336	1414	}
1337	1415	}
	1416	CATCH_DUMP_ATTR
1338	1417
1339	1418	void CGrid::computeConnectedClientsScalarGrid()
	1419	TRY
1340	1420	{
1341	1421	CContext* context = CContext::getCurrent();
…	…
1382	1462	}
1383	1463	}
	1464	CATCH_DUMP_ATTR
1384	1465
1385	1466	void CGrid::sendIndexScalarGrid()
	1467	TRY
1386	1468	{
1387	1469	CContext* context = CContext::getCurrent();
…	…
1447	1529	}
1448	1530	}
	1531	CATCH_DUMP_ATTR
1449	1532
1450	1533	void CGrid::sendIndex(void)
	1534	TRY
1451	1535	{
1452	1536	CContext* context = CContext::getCurrent();
…	…
1568	1652	}
1569	1653	}
	1654	CATCH_DUMP_ATTR
1570	1655
1571	1656	void CGrid::recvIndex(CEventServer& event)
	1657	TRY
1572	1658	{
1573	1659	string gridId;
…	…
1585	1671	get(gridId)->recvIndex(ranks, buffers);
1586	1672	}
	1673	CATCH
1587	1674
1588	1675	void CGrid::recvIndex(vector<int> ranks, vector<CBufferIn*> buffers)
	1676	TRY
1589	1677	{
1590	1678	CContext* context = CContext::getCurrent();
…	…
1756	1844	}
1757	1845	}
	1846	CATCH_DUMP_ATTR
1758	1847
1759	1848	/*
…	…
1771	1860	const std::vector<CScalar*> scalars,
1772	1861	const CArray<int,1>& axisDomainOrder)
1773		{
	1862	TRY
	1863	{
1774	1864	// globalDim.resize(domains.size()*2+axis.size()+scalars.size());
1775	1865	globalDim.resize(domains.size()*2+axis.size());
…	…
1811	1901	return positionDimensionDistributed;
1812	1902	}
	1903	CATCH_DUMP_ATTR
1813	1904
1814	1905	// Retrieve the global dimension of grid
1815	1906	std::vector<int> CGrid::getGlobalDimension()
	1907	TRY
1816	1908	{
1817	1909	std::vector<int> globalDim;
…	…
1820	1912	return globalDim;
1821	1913	}
	1914	CATCH_DUMP_ATTR
1822	1915
1823	1916	// Retrieve dimension on which we do distribution (Very often, it should be 2nd dimension)
1824	1917	int CGrid::getDistributedDimension()
	1918	TRY
1825	1919	{
1826	1920	std::vector<int> globalDim;
1827	1921	return computeGridGlobalDimension(globalDim, getDomains(), getAxis(), getScalars(), axis_domain_order);
1828	1922	}
	1923	CATCH_DUMP_ATTR
1829	1924
1830	1925	bool CGrid::isScalarGrid() const
	1926	TRY
1831	1927	{
1832	1928	return (axisList_.empty() && domList_.empty());
1833	1929	}
	1930	CATCH
1834	1931
1835	1932	/*!
…	…
1839	1936	*/
1840	1937	bool CGrid::doGridHaveDataToWrite()
	1938	TRY
1841	1939	{
1842	1940	return (0 != writtenDataSize_);
1843	1941	}
	1942	CATCH_DUMP_ATTR
1844	1943
1845	1944	/*!
…	…
1850	1949	*/
1851	1950	size_t CGrid::getWrittenDataSize() const
	1951	TRY
1852	1952	{
1853	1953	return writtenDataSize_;
1854	1954	}
	1955	CATCH
1855	1956
1856	1957	/*!
…	…
1859	1960	*/
1860	1961	int CGrid::getNumberWrittenIndexes() const
	1962	TRY
1861	1963	{
1862	1964	return numberWrittenIndexes_;
1863	1965	}
	1966	CATCH
1864	1967
1865	1968	/*!
…	…
1868	1971	*/
1869	1972	int CGrid::getTotalNumberWrittenIndexes() const
	1973	TRY
1870	1974	{
1871	1975	return totalNumberWrittenIndexes_;
1872	1976	}
	1977	CATCH
1873	1978
1874	1979	/*!
…	…
1877	1982	*/
1878	1983	int CGrid::getOffsetWrittenIndexes() const
	1984	TRY
1879	1985	{
1880	1986	return offsetWrittenIndexes_;
1881	1987	}
	1988	CATCH
1882	1989
1883	1990	CDistributionServer* CGrid::getDistributionServer()
	1991	TRY
1884	1992	{
1885	1993	return serverDistribution_;
1886	1994	}
	1995	CATCH_DUMP_ATTR
1887	1996
1888	1997	CDistributionClient* CGrid::getDistributionClient()
	1998	TRY
1889	1999	{
1890	2000	return clientDistribution_;
1891	2001	}
	2002	CATCH_DUMP_ATTR
1892	2003
1893	2004	bool CGrid::doGridHaveDataDistributed(CContextClient* client)
	2005	TRY
1894	2006	{
1895	2007	if (isScalarGrid()) return false;
…	…
1901	2013	return isDataDistributed_;
1902	2014	}
	2015	CATCH_DUMP_ATTR
1903	2016
1904	2017	/*!
…	…
1910	2023	*/
1911	2024	bool CGrid::dispatchEvent(CEventServer& event)
	2025	TRY
1912	2026	{
1913	2027
…	…
1943	2057	}
1944	2058	}
	2059	CATCH
1945	2060
1946	2061	///---------------------------------------------------------------
1947	2062
1948	2063	CDomain* CGrid::addDomain(const std::string& id)
	2064	TRY
1949	2065	{
1950	2066	order_.push_back(2);
…	…
1953	2069	return vDomainGroup_->createChild(id);
1954	2070	}
	2071	CATCH_DUMP_ATTR
1955	2072
1956	2073	CAxis* CGrid::addAxis(const std::string& id)
	2074	TRY
1957	2075	{
1958	2076	order_.push_back(1);
…	…
1961	2079	return vAxisGroup_->createChild(id);
1962	2080	}
	2081	CATCH_DUMP_ATTR
1963	2082
1964	2083	CScalar* CGrid::addScalar(const std::string& id)
	2084	TRY
1965	2085	{
1966	2086	order_.push_back(0);
…	…
1969	2089	return vScalarGroup_->createChild(id);
1970	2090	}
	2091	CATCH_DUMP_ATTR
1971	2092
1972	2093	//! Change virtual field group to a new one
1973	2094	void CGrid::setVirtualDomainGroup(CDomainGroup* newVDomainGroup)
	2095	TRY
1974	2096	{
1975	2097	this->vDomainGroup_ = newVDomainGroup;
1976	2098	}
	2099	CATCH_DUMP_ATTR
1977	2100
1978	2101	//! Change virtual variable group to new one
1979	2102	void CGrid::setVirtualAxisGroup(CAxisGroup* newVAxisGroup)
	2103	TRY
1980	2104	{
1981	2105	this->vAxisGroup_ = newVAxisGroup;
1982	2106	}
	2107	CATCH_DUMP_ATTR
1983	2108
1984	2109	//! Change virtual variable group to new one
1985	2110	void CGrid::setVirtualScalarGroup(CScalarGroup* newVScalarGroup)
	2111	TRY
1986	2112	{
1987	2113	this->vScalarGroup_ = newVScalarGroup;
1988	2114	}
	2115	CATCH_DUMP_ATTR
1989	2116
1990	2117	/*!
…	…
1993	2120	*/
1994	2121	void CGrid::sendAddDomain(const string& id)
1995		{
	2122	TRY
	2123	{
1996	2124	sendAddItem(id, (int)EVENT_ID_ADD_DOMAIN);
1997	2125	}
	2126	CATCH_DUMP_ATTR
1998	2127
1999	2128	/*!
…	…
2002	2131	*/
2003	2132	void CGrid::sendAddAxis(const string& id)
	2133	TRY
2004	2134	{
2005	2135	sendAddItem(id, (int)EVENT_ID_ADD_AXIS);
2006	2136	}
	2137	CATCH_DUMP_ATTR
2007	2138
2008	2139	/*!
…	…
2011	2142	*/
2012	2143	void CGrid::sendAddScalar(const string& id)
	2144	TRY
2013	2145	{
2014	2146	sendAddItem(id, (int)EVENT_ID_ADD_SCALAR);
2015	2147	}
	2148	CATCH_DUMP_ATTR
2016	2149
2017	2150	/*!
…	…
2020	2153	*/
2021	2154	void CGrid::recvAddDomain(CEventServer& event)
	2155	TRY
2022	2156	{
2023	2157
…	…
2027	2161	get(id)->recvAddDomain(*buffer);
2028	2162	}
	2163	CATCH
2029	2164
2030	2165	/*!
…	…
2033	2168	*/
2034	2169	void CGrid::recvAddDomain(CBufferIn& buffer)
	2170	TRY
2035	2171	{
2036	2172	string id;
…	…
2038	2174	addDomain(id);
2039	2175	}
	2176	CATCH_DUMP_ATTR
2040	2177
2041	2178	/*!
…	…
2044	2181	*/
2045	2182	void CGrid::recvAddAxis(CEventServer& event)
	2183	TRY
2046	2184	{
2047	2185
…	…
2051	2189	get(id)->recvAddAxis(*buffer);
2052	2190	}
	2191	CATCH
2053	2192
2054	2193	/*!
…	…
2057	2196	*/
2058	2197	void CGrid::recvAddAxis(CBufferIn& buffer)
	2198	TRY
2059	2199	{
2060	2200	string id;
…	…
2062	2202	addAxis(id);
2063	2203	}
	2204	CATCH_DUMP_ATTR
2064	2205
2065	2206	/*!
…	…
2068	2209	*/
2069	2210	void CGrid::recvAddScalar(CEventServer& event)
	2211	TRY
2070	2212	{
2071	2213
…	…
2075	2217	get(id)->recvAddScalar(*buffer);
2076	2218	}
	2219	CATCH
2077	2220
2078	2221	/*!
…	…
2081	2224	*/
2082	2225	void CGrid::recvAddScalar(CBufferIn& buffer)
	2226	TRY
2083	2227	{
2084	2228	string id;
…	…
2086	2230	addScalar(id);
2087	2231	}
	2232	CATCH_DUMP_ATTR
2088	2233
2089	2234	/*!
…	…
2094	2239	*/
2095	2240	void CGrid::solveDomainAxisRefInheritance(bool apply)
	2241	TRY
2096	2242	{
2097	2243	CContext* context = CContext::getCurrent();
…	…
2134	2280	}
2135	2281	}
	2282	CATCH_DUMP_ATTR
2136	2283
2137	2284	bool CGrid::isTransformed()
	2285	TRY
2138	2286	{
2139	2287	return isTransformed_;
2140	2288	}
	2289	CATCH_DUMP_ATTR
2141	2290
2142	2291	void CGrid::setTransformed()
	2292	TRY
2143	2293	{
2144	2294	isTransformed_ = true;
2145	2295	}
	2296	CATCH_DUMP_ATTR
2146	2297
2147	2298	CGridTransformation* CGrid::getTransformations()
	2299	TRY
2148	2300	{
2149	2301	return transformations_;
2150	2302	}
	2303	CATCH_DUMP_ATTR
2151	2304
2152	2305	void CGrid::addTransGridSource(CGrid* gridSrc)
	2306	TRY
2153	2307	{
2154	2308	if (gridSrc_.end() == gridSrc_.find(gridSrc))
2155	2309	gridSrc_.insert(make_pair(gridSrc,make_pair(false,"")));
2156	2310	}
	2311	CATCH_DUMP_ATTR
2157	2312
2158	2313	std::map<CGrid*,std::pair<bool,StdString> >& CGrid::getTransGridSource()
	2314	TRY
2159	2315	{
2160	2316	return gridSrc_;
2161	2317	}
	2318	CATCH_DUMP_ATTR
2162	2319
2163	2320	/*!
…	…
2166	2323	*/
2167	2324	void CGrid::completeGrid(CGrid* transformGridSrc)
	2325	TRY
2168	2326	{
2169	2327	if (0 != transformGridSrc)
…	…
2184	2342	gridGenerate.completeGrid();
2185	2343	}
	2344	CATCH_DUMP_ATTR
2186	2345
2187	2346	bool CGrid::isGenerated()
	2347	TRY
2188	2348	{
2189	2349	return isGenerated_;
2190	2350	}
	2351	CATCH
2191	2352
2192	2353	void CGrid::setGenerated()
	2354	TRY
2193	2355	{
2194	2356	isGenerated_ = true;
2195	2357	}
	2358	CATCH_DUMP_ATTR
2196	2359
2197	2360	void CGrid::transformGrid(CGrid* transformGridSrc)
	2361	TRY
2198	2362	{
2199	2363	if (!transformGridSrc)
…	…
2221	2385	transformGridSrc->checkMaskIndex(false);
2222	2386	}
	2387	CATCH_DUMP_ATTR
2223	2388
2224	2389	bool CGrid::hasTransform()
	2390	TRY
2225	2391	{
2226	2392	if (hasTransform_) return hasTransform_;
…	…
2236	2402	return hasTransform_;
2237	2403	}
	2404	CATCH_DUMP_ATTR
2238	2405
2239	2406	/*!
…	…
2242	2409	*/
2243	2410	std::vector<CDomain*> CGrid::getDomains()
	2411	TRY
2244	2412	{
2245	2413	std::vector<CDomain*> domList;
…	…
2250	2418	return domList;
2251	2419	}
	2420	CATCH_DUMP_ATTR
2252	2421
2253	2422	/*!
…	…
2256	2425	*/
2257	2426	std::vector<CAxis*> CGrid::getAxis()
	2427	TRY
2258	2428	{
2259	2429	std::vector<CAxis*> aList;
…	…
2263	2433	return aList;
2264	2434	}
	2435	CATCH_DUMP_ATTR
2265	2436
2266	2437	/*!
…	…
2269	2440	*/
2270	2441	std::vector<CScalar*> CGrid::getScalars()
	2442	TRY
2271	2443	{
2272	2444	std::vector<CScalar*> sList;
…	…
2276	2448	return sList;
2277	2449	}
	2450	CATCH_DUMP_ATTR
2278	2451
2279	2452	/*!
…	…
2282	2455	*/
2283	2456	CDomain* CGrid::getDomain(int domainIndex)
	2457	TRY
2284	2458	{
2285	2459	std::vector<CDomain*> domainListP = this->getDomains();
…	…
2299	2473	return domainListP[domainIndex];
2300	2474	}
	2475	CATCH_DUMP_ATTR
2301	2476
2302	2477	/*!
…	…
2305	2480	*/
2306	2481	CAxis* CGrid::getAxis(int axisIndex)
	2482	TRY
2307	2483	{
2308	2484	std::vector<CAxis*> axisListP = this->getAxis();
…	…
2322	2498	return axisListP[axisIndex];
2323	2499	}
	2500	CATCH_DUMP_ATTR
2324	2501
2325	2502	/*!
…	…
2328	2505	*/
2329	2506	CScalar* CGrid::getScalar(int scalarIndex)
	2507	TRY
2330	2508	{
2331	2509	std::vector<CScalar*> scalarListP = this->getScalars();
…	…
2345	2523	return scalarListP[scalarIndex];
2346	2524	}
	2525	CATCH_DUMP_ATTR
2347	2526
2348	2527	/*!
…	…
2351	2530	*/
2352	2531	void CGrid::setDomainList(const std::vector<CDomain*> domains)
	2532	TRY
2353	2533	{
2354	2534	if (isDomListSet) return;
…	…
2371	2551	isDomListSet = true;
2372	2552	}
2373
2374		}
	2553	}
	2554	CATCH_DUMP_ATTR
2375	2555
2376	2556	/*!
…	…
2379	2559	*/
2380	2560	void CGrid::setAxisList(const std::vector<CAxis*> axis)
	2561	TRY
2381	2562	{
2382	2563	if (isAxisListSet) return;
…	…
2400	2581	}
2401	2582	}
	2583	CATCH_DUMP_ATTR
2402	2584
2403	2585	/*!
…	…
2406	2588	*/
2407	2589	void CGrid::setScalarList(const std::vector<CScalar*> scalars)
	2590	TRY
2408	2591	{
2409	2592	if (isScalarListSet) return;
…	…
2427	2610	}
2428	2611	}
	2612	CATCH_DUMP_ATTR
2429	2613
2430	2614	/*!
…	…
2433	2617	*/
2434	2618	std::vector<StdString> CGrid::getDomainList()
	2619	TRY
2435	2620	{
2436	2621	setDomainList();
2437	2622	return domList_;
2438	2623	}
	2624	CATCH
2439	2625
2440	2626	/*!
…	…
2443	2629	*/
2444	2630	std::vector<StdString> CGrid::getAxisList()
	2631	TRY
2445	2632	{
2446	2633	setAxisList();
2447	2634	return axisList_;
2448	2635	}
	2636	CATCH
2449	2637
2450	2638	/*!
…	…
2453	2641	*/
2454	2642	std::vector<StdString> CGrid::getScalarList()
	2643	TRY
2455	2644	{
2456	2645	setScalarList();
2457	2646	return scalarList_;
2458	2647	}
	2648	CATCH
2459	2649
2460	2650	/*!
…	…
2462	2652	*/
2463	2653	void CGrid::sendAllDomains()
	2654	TRY
2464	2655	{
2465	2656	std::vector<CDomain*> domList = this->getVirtualDomainGroup()->getAllChildren();
…	…
2471	2662	}
2472	2663	}
	2664	CATCH_DUMP_ATTR
2473	2665
2474	2666	/*!
…	…
2476	2668	*/
2477	2669	void CGrid::sendAllAxis()
	2670	TRY
2478	2671	{
2479	2672	std::vector<CAxis*> aList = this->getVirtualAxisGroup()->getAllChildren();
…	…
2486	2679	}
2487	2680	}
	2681	CATCH_DUMP_ATTR
2488	2682
2489	2683	/*!
…	…
2491	2685	*/
2492	2686	void CGrid::sendAllScalars()
	2687	TRY
2493	2688	{
2494	2689	std::vector<CScalar*> sList = this->getVirtualScalarGroup()->getAllChildren();
…	…
2501	2696	}
2502	2697	}
	2698	CATCH_DUMP_ATTR
2503	2699
2504	2700	void CGrid::setContextClient(CContextClient* contextClient)
	2701	TRY
2505	2702	{
2506	2703	if (clientsSet.find(contextClient)==clientsSet.end())
…	…
2514	2711	this->getAxis()[i]->setContextClient(contextClient);
2515	2712	}
	2713	CATCH_DUMP_ATTR
2516	2714
2517	2715	/*!
…	…
2519	2717	*/
2520	2718	void CGrid::parse(xml::CXMLNode& node)
	2719	TRY
2521	2720	{
2522	2721	SuperClass::parse(node);
…	…
2559	2758	setScalarList();
2560	2759	}
	2760	CATCH_DUMP_ATTR
	2761
2561	2762	} // namespace xios

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

Download in other formats: