Context Navigation

source: XIOS/dev/dev_oa/src/node/grid.hpp @ 2034

Last change on this file since 2034 was 2034, checked in by oabramkina, 3 years ago
Adding a possibility of tiled and non-tiled sent on the same domain.
Property copyright set to Software name : XIOS (Xml I/O Server) http://forge.ipsl.jussieu.fr/ioserver Creation date : January 2009 Licence : CeCCIL version2 see license file in root directory : Licence_CeCILL_V2-en.txt or http://www.cecill.info/licences/Licence_CeCILL_V2-en.html Holder : CEA/LSCE (Laboratoire des Sciences du CLimat et de l'Environnement) CNRS/IPSL (Institut Pierre Simon Laplace) Project Manager : Yann Meurdesoif yann.meurdesoif@cea.fr Property svn:executable set to ``*
File size: 25.1 KB

Line
1	#ifndef __XIOS_CGrid__
2	#define __XIOS_CGrid__
3
4	/// XIOS headers ///
5	#include "xios_spl.hpp"
6	#include "group_factory.hpp"
7
8	#include "declare_group.hpp"
9	#include "domain.hpp"
10	#include "axis.hpp"
11	#include "scalar.hpp"
12	#include "array_new.hpp"
13	#include "attribute_array.hpp"
14	#include "distribution_server.hpp"
15	#include "client_server_mapping.hpp"
16	#include "utils.hpp"
17	#include "transformation_enum.hpp"
18
19	namespace xios {
20
21	/// ////////////////////// Declarations ////////////////////// ///
22
23	class CGridGroup;
24	class CGridAttributes;
25	class CDomainGroup;
26	class CAxisGroup;
27	class CScalarGroup;
28	class CGrid;
29	class CDistributionClient;
30	class CDistributionServer;
31	class CServerDistributionDescription;
32	class CClientServerMapping;
33	class CGridTransformation;
34
35	///--------------------------------------------------------------
36
37	// Declare/Define CGridAttribute
38	BEGIN_DECLARE_ATTRIBUTE_MAP(CGrid)
39	# include "grid_attribute.conf"
40	END_DECLARE_ATTRIBUTE_MAP(CGrid)
41
42	///--------------------------------------------------------------
43
44	class CGrid
45	: public CObjectTemplate<CGrid>
46	, public CGridAttributes
47	{
48	/// typedef ///
49	typedef CObjectTemplate<CGrid> SuperClass;
50	typedef CGridAttributes SuperClassAttribute;
51
52	public:
53
54	typedef CGridAttributes RelAttributes;
55	typedef CGridGroup RelGroup;
56
57	enum EEventId
58	{
59	EVENT_ID_INDEX, EVENT_ID_ADD_DOMAIN, EVENT_ID_ADD_AXIS, EVENT_ID_ADD_SCALAR
60	};
61
62	/// Constructeurs ///
63	CGrid(void);
64	explicit CGrid(const StdString& id);
65	CGrid(const CGrid& grid); // Not implemented yet.
66	CGrid(const CGrid* const grid); // Not implemented yet.
67
68	/// Traitements ///
69	// void solveReference(void);
70
71	void checkEligibilityForCompressedOutput();
72
73	void solveDomainAxisRef(bool areAttributesChecked);
74
75	void checkMaskIndex(bool doCalculateIndex);
76
77	// virtual void toBinary (StdOStream& os) const;
78	// virtual void fromBinary(StdIStream& is);
79
80	void addRelFileCompressed(const StdString& filename);
81
82	/// Tests ///
83	bool isCompressible(void) const;
84	bool isWrittenCompressed(const StdString& filename) const;
85
86	public:
87
88	/// Accesseurs ///
89	StdSize getDimension(void);
90
91	StdSize getDataSize(void) const;
92
93	StdSize getTileDataSize(int tileId);
94
95	StdSize getTileSize(int tileId);
96
97	/// Entrees-sorties de champs
98	template <int n>
99	void inputField(const CArray<double,n>& field, CArray<double,1>& stored) const;
100	template <int n>
101	void maskField(const CArray<double,n>& field, CArray<double,1>& stored, bool isTiled = false) const;
102	template <int n>
103	void outputField(const CArray<double,1>& stored, CArray<double,n>& field) const;
104	template <int n>
105	void uncompressField(const CArray<double,n>& data, CArray<double,1>& outData) const;
106	template <int n>
107	void copyTile(const CArray<double,n>& tileData, CArray<double, 1>& stored, int tileId);
108
109	virtual void parse(xml::CXMLNode& node);
110
111	/// Destructeur ///
112	virtual ~CGrid(void);
113
114	public:
115
116	/// Accesseurs statiques ///
117	static StdString GetName(void);
118	static StdString GetDefName(void);
119
120	static ENodeType GetType(void);
121
122	/// Instanciateurs Statiques ///
123	static CGrid* createGrid(CDomain* domain);
124	static CGrid* createGrid(CDomain* domain, CAxis* axis);
125	static CGrid* createGrid(const std::vector<CDomain>& domains, const std::vector<CAxis>& axis,
126	const CArray<int,1>& axisDomainOrder = CArray<int,1>());
127	static CGrid* createGrid(StdString id, const std::vector<CDomain>& domains, const std::vector<CAxis>& axis,
128	const std::vector<CScalar*>& scalars, const CArray<int,1>& axisDomainOrder = CArray<int,1>());
129	static CGrid* createGrid(const std::vector<CDomain>& domains, const std::vector<CAxis>& axis,
130	const std::vector<CScalar*>& scalars, const CArray<int,1>& axisDomainOrder);
131	static StdString generateId(const std::vector<CDomain>& domains, const std::vector<CAxis>& axis,
132	const std::vector<CScalar*>& scalars, const CArray<int,1>& axisDomainOrder = CArray<int,1>());
133	static StdString generateId(const CGrid* gridSrc, const CGrid* gridDest);
134	static CGrid* cloneGrid(const StdString& idNewGrid, CGrid* gridSrc);
135
136	public:
137	void computeIndexServer(void);
138	void computeIndex(void);
139	void computeIndexScalarGrid();
140	void computeWrittenIndex();
141
142	void solveDomainRef(bool checkAtt);
143	void solveAxisRef(bool checkAtt);
144	void solveScalarRef(bool checkAtt);
145	void solveDomainAxisRefInheritance(bool apply = true);
146	void solveTransformations();
147	void solveDomainAxisBaseRef();
148
149	CDomain* addDomain(const std::string& id=StdString());
150	CAxis* addAxis(const std::string& id=StdString());
151	CScalar* addScalar(const std::string& id=StdString());
152	void sendAddDomain(const std::string& id="");
153	void sendAddAxis(const std::string& id="");
154	void sendAddScalar(const std::string& id="");
155	void sendGrid(void) ;
156
157	static void recvAddDomain(CEventServer& event);
158	void recvAddDomain(CBufferIn& buffer);
159	static void recvAddAxis(CEventServer& event);
160	void recvAddAxis(CBufferIn& buffer);
161	static void recvAddScalar(CEventServer& event);
162	void recvAddScalar(CBufferIn& buffer);
163
164	static bool dispatchEvent(CEventServer& event);
165	static void recvIndex(CEventServer& event);
166	void recvIndex(vector<int> ranks, vector<CBufferIn*> buffers);
167	void sendIndex(void);
168	void sendIndexScalarGrid();
169
170	void setContextClient(CContextClient* contextClient);
171
172	void computeDomConServer();
173	std::map<int, int> getDomConServerSide();
174	std::map<int, StdSize> getAttributesBufferSize(CContextClient* client, bool bufferForWriting = false);
175	std::map<int, StdSize> getDataBufferSize(CContextClient* client, const std::string& id = "", bool bufferForWriting = false);
176	std::vector<StdString> getDomainList();
177	std::vector<StdString> getAxisList();
178	std::vector<StdString> getScalarList();
179	std::vector<CDomain*> getDomains();
180	std::vector<CAxis*> getAxis();
181	std::vector<CScalar*> getScalars();
182	CDomain* getDomain(int domainIndex);
183	CAxis* getAxis(int axisIndex);
184	CScalar* getScalar(int scalarIndex);
185	std::vector<int> getAxisOrder();
186	std::vector<int> getGlobalDimension();
187	bool isScalarGrid() const;
188
189	bool doGridHaveDataToWrite();
190	bool doGridHaveDataDistributed(CContextClient* client = 0);
191	size_t getWrittenDataSize() const;
192	int getNumberWrittenIndexes() const;
193	int getTotalNumberWrittenIndexes() const;
194	int getOffsetWrittenIndexes() const;
195
196	CDistributionServer* getDistributionServer();
197	CDistributionClient* getDistributionClient();
198	CGridTransformation* getTransformations();
199
200	void transformGrid(CGrid* transformGridSrc);
201	void completeGrid(CGrid* transformGridSrc = 0);
202	void doAutoDistribution(CGrid* transformGridSrc);
203	bool isTransformed();
204	void setTransformed();
205	bool isGenerated();
206	void setGenerated();
207	void addTransGridSource(CGrid* gridSrc);
208	std::map<CGrid*, std::pair<bool,StdString> >& getTransGridSource();
209	bool hasTransform();
210	size_t getGlobalWrittenSize(void) ;
211	public:
212	CArray<int, 1> storeIndex_client;
213	CArray<int, 1> storeIndexTiled_client;
214	CArray<bool, 1> storeMask_client;
215	CArray<bool, 1> storeMaskTiled_client;
216
217	/** Map containing indexes that will be sent in sendIndex(). */
218	std::map<CContextClient*, map<int, CArray<int, 1> > > storeIndex_toSrv;
219
220	/** Map storing the number of senders. Key = size of receiver's intracomm */
221	std::map<int, std::map<int,int> > nbSenders;
222
223	std::map<CContextClient*, std::map<int,int> > nbReadSenders;
224
225	map<int, CArray<int, 1> > storeIndex_fromSrv; // Support, for now, reading with level-1 server
226
227	map<int, CArray<size_t, 1> > outIndexFromClient; // Deprecated
228
229	map<int, CArray<size_t, 1> > compressedOutIndexFromClient;
230
231	/** Map storing received indexes. Key = sender rank, value = index array. */
232	map<int, CArray<size_t, 1> > outGlobalIndexFromClient;
233
234	/** Map storing received indexes. Key = sender rank, value = index array for tiled domains */
235	map<int, CArray<size_t, 1> > outGlobalIndexFromClientTiled;
236
237	// Manh Ha's comment: " A client receives global index from other clients (via recvIndex)
238	// then does mapping these index into local index of STORE_CLIENTINDEX
239	// In this way, store_clientIndex can be used as an input of a source filter
240	// Maybe we need a flag to determine whether a client wants to write. TODO "
241
242	/** Map storing received data. Key = sender rank, value = data array.
243	* The map is created in CGrid::computeClientIndex and filled upon receiving data in CField::recvUpdateData() */
244	map<int, CArray<size_t, 1> > outLocalIndexStoreOnClient;
245
246	/** Map storing received data. Key = sender rank, value = data array.
247	* The map is created in CGrid::computeClientIndex and filled upon receiving data in CField::recvUpdateData() */
248	map<int, CArray<size_t, 1> > outLocalIndexStoreOnClientTiled;
249
250
251	/** Indexes calculated based on server-like distribution.
252	* They are used for writing/reading data and only calculated for server level that does the writing/reading.
253	* Along with localIndexToWriteOnClient, these indexes are used to correctly place incoming data. */
254	CArray<size_t,1> localIndexToWriteOnServer;
255
256	/** Indexes calculated based on client-like distribution.
257	* They are used for writing/reading data and only calculated for server level that does the writing/reading.
258	* Along with localIndexToWriteOnServer, these indexes are used to correctly place incoming data. */
259	CArray<size_t,1> localIndexToWriteOnClient;
260
261	CArray<size_t,1> indexFromClients;
262
263	bool hasMask(void) const;
264	void checkMask(void);
265	void createMask(void);
266	void modifyMask(const CArray<int,1>& indexToModify, bool valueToModify = false);
267	void modifyMaskSize(const std::vector<int>& newDimensionSize, bool newValue = false);
268
269	void computeGridGlobalDimension(const std::vector<CDomain*>& domains,
270	const std::vector<CAxis*>& axis,
271	const std::vector<CScalar*>& scalars,
272	const CArray<int,1>& axisDomainOrder);
273
274	int getNTiles();
275	bool isTiled(void) const;
276	bool isTiledOnly(void) const;
277
278	private:
279	template<int N>
280	void checkGridMask(CArray<bool,N>& gridMask,
281	const std::vector<CArray<bool,1>* >& domainMasks,
282	const std::vector<CArray<bool,1>* >& axisMasks,
283	const CArray<int,1>& axisDomainOrder,
284	bool createMask = false);
285	template<int N>
286	void modifyGridMask(CArray<bool,N>& gridMask, const CArray<int,1>& indexToModify, bool valueToModify);
287
288	template<int N>
289	void modifyGridMaskSize(CArray<bool,N>& gridMask, const std::vector<int>& eachDimSize, bool newValue);
290
291	void storeField_arr(const double* const data, CArray<double, 1>& stored) const;
292	void restoreField_arr(const CArray<double, 1>& stored, double* const data) const;
293	void uncompressField_arr(const double* const data, CArray<double, 1>& outData) const;
294	void maskField_arr(const double* const data, CArray<double, 1>& stored, bool isTiled = false) const;
295	void copyTile_arr(const double* const tileData, CArray<double, 1>& stored, int tileId);
296
297	void setVirtualDomainGroup(CDomainGroup* newVDomainGroup);
298	void setVirtualAxisGroup(CAxisGroup* newVAxisGroup);
299	void setVirtualScalarGroup(CScalarGroup* newVScalarGroup);
300
301	void setDomainList(const std::vector<CDomain> domains = std::vector<CDomain>());
302	void setAxisList(const std::vector<CAxis> axis = std::vector<CAxis>());
303	void setScalarList(const std::vector<CScalar> scalars = std::vector<CScalar>());
304
305	CDomainGroup* getVirtualDomainGroup() const;
306	CAxisGroup* getVirtualAxisGroup() const;
307	CScalarGroup* getVirtualScalarGroup() const;
308
309	void checkAttributesAfterTransformation();
310	void setTransformationAlgorithms();
311	void computeIndexByElement(const std::vector<std::unordered_map<size_t,std::vector<int> > >& indexServerOnElement,
312	const CContextClient* client,
313	CClientServerMapping::GlobalIndexMap& globalIndexOnServer);
314	int computeGridGlobalDimension(std::vector<int>& globalDim,
315	const std::vector<CDomain*> domains,
316	const std::vector<CAxis*> axis,
317	const std::vector<CScalar*> scalars,
318	const CArray<int,1>& axisDomainOrder);
319	int getDistributedDimension();
320
321	void computeClientIndex();
322	void computeClientIndexTiled();
323	void computeConnectedClients();
324	void computeClientIndexScalarGrid();
325	void computeConnectedClientsScalarGrid();
326
327	void computeTileIndex();
328
329	private:
330
331	/** Clients that have to send a grid. There can be multiple clients in case of secondary server, otherwise only one client. */
332	std::list<CContextClient*> clients;
333	std::set<CContextClient*> clientsSet;
334
335	bool isChecked;
336	bool isDomainAxisChecked;
337	bool isIndexSent;
338
339	int nTiles_;
340	/** True if tiled data is defined on the grid */
341	bool isTiled_;
342	/** True if ONLY tiled data is defined on the grid */
343	bool isTiledOnly_;
344
345	/** Vector containing local domain indexes for each tile */
346	std::vector<CArray<int,1> > storeTileIndex;
347
348	CDomainGroup* vDomainGroup_;
349	CAxisGroup* vAxisGroup_;
350	CScalarGroup* vScalarGroup_;
351	std::vector<std::string> axisList_, domList_, scalarList_;
352	bool isAxisListSet, isDomListSet, isScalarListSet;
353
354	/** Client-like distribution calculated based on the knowledge of the entire grid */
355	CDistributionClient* clientDistribution_;
356
357	/** Client-like distribution calculated based on the knowledge of the entire grid in case of a tiled domain */
358	CDistributionClient* clientDistributionTiled_;
359
360
361	/** Server-like distribution calculated upon receiving indexes */
362	CDistributionServer* serverDistribution_;
363
364	CClientServerMapping* clientServerMap_;
365	size_t writtenDataSize_;
366	int numberWrittenIndexes_, totalNumberWrittenIndexes_, offsetWrittenIndexes_;
367
368	/** Map storing local ranks of connected receivers. Key = size of receiver's intracomm.
369	* It is calculated in computeConnectedClients(). */
370	std::map<int, std::vector<int> > connectedServerRank_;
371
372	/** Map storing the size of data to be send. Key = size of receiver's intracomm
373	* It is calculated in computeConnectedClients(). */
374	std::map<int, std::map<int,size_t> > connectedDataSize_;
375
376	/** Ranks of connected receivers in case of reading. It is calculated in recvIndex(). */
377	std::vector<int> connectedServerRankRead_;
378
379	/** Size of data to be send in case of reading. It is calculated in recvIndex(). */
380	std::map<int,size_t> connectedDataSizeRead_;
381
382	bool isDataDistributed_;
383	//! True if and only if the data defined on the grid can be outputted in a compressed way
384	bool isCompressible_;
385	std::set<std::string> relFilesCompressed;
386
387	bool isTransformed_, isGenerated_;
388	bool computedWrittenIndex_;
389	std::vector<int> axisPositionInGrid_;
390	CGridTransformation* transformations_;
391	bool hasDomainAxisBaseRef_;
392	std::map<CGrid*, std::pair<bool,StdString> > gridSrc_;
393	bool hasTransform_;
394
395	/** Map storing global indexes of server-like (band-wise) distribution for sending to receivers.
396	* Key = size of receiver's intracomm.
397	*/
398	// std::map<CContextClient*, CClientServerMapping::GlobalIndexMap> globalIndexOnServer_;
399	std::map<int, CClientServerMapping::GlobalIndexMap> globalIndexOnServer_;
400
401
402	/** List order of axis and domain in a grid, if there is a domain, it will take value 1 (true), axis 0 (false) */
403	std::vector<int> order_;
404
405	}; // class CGrid
406
407	///--------------------------------------------------------------
408
409	template <int n>
410	void CGrid::inputField(const CArray<double,n>& field, CArray<double,1>& stored) const
411	TRY
412	{
413	//#ifdef __XIOS_DEBUG
414	if (this->getDataSize() != field.numElements())
415	ERROR("void CGrid::inputField(const CArray<double,n>& field, CArray<double,1>& stored) const",
416	<< "[ Awaiting data of size = " << this->getDataSize() << ", "
417	<< "Received data size = " << field.numElements() << " ] "
418	<< "The data array does not have the right size! "
419	<< "Grid = " << this->getId())
420	//#endif
421	this->storeField_arr(field.dataFirst(), stored);
422	}
423	CATCH
424
425	template <int n>
426	void CGrid::copyTile(const CArray<double,n>& tileData, CArray<double,1>& storedData, int tileId)
427	{
428	this->copyTile_arr(tileData.dataFirst(), storedData, tileId);
429	}
430
431	template <int n>
432	void CGrid::maskField(const CArray<double,n>& field, CArray<double,1>& stored, bool isTiled) const
433	{
434	//#ifdef __XIOS_DEBUG
435	if (this->getDataSize() != field.numElements())
436	ERROR("void CGrid::maskField(const CArray<double,n>& field, CArray<double,1>& stored) const",
437	<< "[ Awaiting data of size = " << this->getDataSize() << ", "
438	<< "Received data size = " << field.numElements() << " ] "
439	<< "The data array does not have the right size! "
440	<< "Grid = " << this->getId())
441	//#endif
442	this->maskField_arr(field.dataFirst(), stored, isTiled);
443	}
444
445	// template <int n>
446	// void CGrid::maskFieldTiled(const CArray<double,n>& field, CArray<double,1>& stored) const
447	// {
448	////#ifdef __XIOS_DEBUG
449	// if (this->getDataSize() != field.numElements())
450	// ERROR("void CGrid::maskField(const CArray<double,n>& field, CArray<double,1>& stored) const",
451	// << "[ Awaiting data of size = " << this->getDataSize() << ", "
452	// << "Received data size = " << field.numElements() << " ] "
453	// << "The data array does not have the right size! "
454	// << "Grid = " << this->getId())
455	////#endif
456	// this->maskField_arr(field.dataFirst(), stored, true);
457	// }
458
459	template <int n>
460	void CGrid::outputField(const CArray<double,1>& stored, CArray<double,n>& field) const
461	TRY
462	{
463	//#ifdef __XIOS_DEBUG
464	if (this->getDataSize() != field.numElements())
465	ERROR("void CGrid::outputField(const CArray<double,1>& stored, CArray<double,n>& field) const",
466	<< "[ Size of the data = " << this->getDataSize() << ", "
467	<< "Output data size = " << field.numElements() << " ] "
468	<< "The ouput array does not have the right size! "
469	<< "Grid = " << this->getId())
470	//#endif
471	this->restoreField_arr(stored, field.dataFirst());
472	}
473	CATCH
474
475	/*!
476	This function removes the effect of mask on received data on the server.
477	This function only serve for the checking purpose. TODO: Something must be done to seperate mask and data_index from each other in received data
478	\data data received data with masking effect on the server
479	\outData data without masking effect
480	*/
481	template <int N>
482	void CGrid::uncompressField(const CArray<double,N>& data, CArray<double,1>& outData) const
483	TRY
484	{
485	uncompressField_arr(data.dataFirst(), outData);
486	}
487	CATCH
488
489	template<int N>
490	void CGrid::checkGridMask(CArray<bool,N>& gridMask,
491	const std::vector<CArray<bool,1>* >& domainMasks,
492	const std::vector<CArray<bool,1>* >& axisMasks,
493	const CArray<int,1>& axisDomainOrder,
494	bool createMask)
495	TRY
496	{
497	int idx = 0;
498	int numElement = axisDomainOrder.numElements();
499	int dim = domainMasks.size() * 2 + axisMasks.size();
500	std::vector<CDomain*> domainP = this->getDomains();
501	std::vector<CAxis*> axisP = this->getAxis();
502
503	std::vector<int> idxLoop(dim,0), indexMap(numElement), eachDimSize(dim);
504	std::vector<int> currentIndex(dim);
505	int idxDomain = 0, idxAxis = 0;
506	for (int i = 0; i < numElement; ++i)
507	{
508	indexMap[i] = idx;
509	if (2 == axisDomainOrder(i)) {
510	eachDimSize[indexMap[i]] = domainP[idxDomain]->ni;
511	eachDimSize[indexMap[i]+1] = domainP[idxDomain]->nj;
512	idx += 2; ++idxDomain;
513	}
514	else if (1 == axisDomainOrder(i)) {
515	// eachDimSize[indexMap[i]] = axisMasks[idxAxis]->numElements();
516	eachDimSize[indexMap[i]] = axisP[idxAxis]->n;
517	++idx; ++idxAxis;
518	}
519	else {};
520	}
521
522	if (!gridMask.isEmpty() && !createMask)
523	{
524	for (int i = 0; i < dim; ++i)
525	{
526	if (gridMask.extent(i) != eachDimSize[i])
527	ERROR("CGrid::checkMask(void)",
528	<< "The mask has one dimension whose size is different from the one of the local grid." << std::endl
529	<< "Local size of dimension " << i << " is " << eachDimSize[i] << "." << std::endl
530	<< "Mask size for dimension " << i << " is " << gridMask.extent(i) << "." << std::endl
531	<< "Grid = " << this->getId())
532	}
533	}
534	else {
535	CArrayBoolTraits<CArray<bool,N> >::resizeArray(gridMask,eachDimSize);
536	gridMask = true;
537	}
538
539	int ssize = gridMask.numElements();
540	idx = 0;
541	while (idx < ssize)
542	{
543	for (int i = 0; i < dim-1; ++i)
544	{
545	if (idxLoop[i] == eachDimSize[i])
546	{
547	idxLoop[i] = 0;
548	++idxLoop[i+1];
549	}
550	}
551
552	// Find out outer index
553	idxDomain = idxAxis = 0;
554	bool maskValue = true;
555	for (int i = 0; i < numElement; ++i)
556	{
557	if (2 == axisDomainOrder(i))
558	{
559	int idxTmp = idxLoop[indexMap[i]] + idxLoop[indexMap[i]+1] * eachDimSize[indexMap[i]];
560	if (idxTmp < (*domainMasks[idxDomain]).numElements())
561	maskValue = maskValue && (*domainMasks[idxDomain])(idxTmp);
562	else
563	maskValue = false;
564	++idxDomain;
565	}
566	else if (1 == axisDomainOrder(i))
567	{
568	int idxTmp = idxLoop[indexMap[i]];
569	if (idxTmp < (*axisMasks[idxAxis]).numElements())
570	maskValue = maskValue && (*axisMasks[idxAxis])(idxTmp);
571	else
572	maskValue = false;
573
574	++idxAxis;
575	}
576	}
577
578	int maskIndex = idxLoop[0];
579	int mulDim = 1;
580	for (int k = 1; k < dim; ++k)
581	{
582	mulDim *= eachDimSize[k-1];
583	maskIndex += idxLoop[k]*mulDim;
584	}
585	*(gridMask.dataFirst()+maskIndex) &= maskValue;
586
587	++idxLoop[0];
588	++idx;
589	}
590	}
591	CATCH_DUMP_ATTR
592
593	template<int N>
594	void CGrid::modifyGridMaskSize(CArray<bool,N>& gridMask,
595	const std::vector<int>& eachDimSize,
596	bool newValue)
597	TRY
598	{
599	if (N != eachDimSize.size())
600	{
601	// ERROR("CGrid::modifyGridMaskSize(CArray<bool,N>& gridMask,
602	// const std::vector<int>& eachDimSize,
603	// bool newValue)",
604	// << "Dimension size of the mask is different from input dimension size." << std::endl
605	// << "Mask dimension is " << N << "." << std::endl
606	// << "Input dimension is " << eachDimSize.size() << "." << std::endl
607	// << "Grid = " << this->getId())
608	}
609	CArrayBoolTraits<CArray<bool,N> >::resizeArray(gridMask,eachDimSize);
610	gridMask = newValue;
611	}
612	CATCH_DUMP_ATTR
613
614
615	/*!
616	Modify the current mask of grid, the local index to be modified will take value false
617	\param [in/out] gridMask current mask of grid
618	\param [in] indexToModify local index to modify
619	*/
620	template<int N>
621	void CGrid::modifyGridMask(CArray<bool,N>& gridMask, const CArray<int,1>& indexToModify, bool valueToModify)
622	TRY
623	{
624	int num = indexToModify.numElements();
625	for (int idx = 0; idx < num; ++idx)
626	{
627	*(gridMask.dataFirst()+indexToModify(idx)) = valueToModify;
628	}
629	}
630	CATCH_DUMP_ATTR
631
632	///--------------------------------------------------------------
633
634
635
636	// Declare/Define CGridGroup and CGridDefinition
637	DECLARE_GROUP(CGrid);
638
639	///--------------------------------------------------------------
640
641	} // namespace xios
642
643	#endif // __XIOS_CGrid__

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

Download in other formats: