source: XIOS/dev/dev_ym/XIOS_COUPLING/src/node/grid.hpp @ 1794

Last change on this file since 1794 was 1794, checked in by ymipsl, 22 months ago
  • add some comment about grid map/array/indexes
  • Add some "_" to suffix data members of the class

YM

  • 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.8 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
19namespace 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         /// Entrees-sorties de champs
94         template <int n>
95         void inputField(const CArray<double,n>& field, CArray<double,1>& stored) const;
96         template <int n>
97         void maskField(const CArray<double,n>& field, CArray<double,1>& stored) const;
98         template <int n>
99         void outputField(const CArray<double,1>& stored, CArray<double,n>& field) const; 
100         template <int n>
101         void uncompressField(const CArray<double,n>& data, CArray<double,1>& outData) const; 
102
103         virtual void parse(xml::CXMLNode& node);
104
105         /// Destructeur ///
106         virtual ~CGrid(void);
107
108      public:
109
110         /// Accesseurs statiques ///
111         static StdString GetName(void);
112         static StdString GetDefName(void);
113
114         static ENodeType GetType(void);
115
116         /// Instanciateurs Statiques ///
117         static CGrid* createGrid(CDomain* domain);
118         static CGrid* createGrid(CDomain* domain, CAxis* axis);
119         static CGrid* createGrid(const std::vector<CDomain*>& domains, const std::vector<CAxis*>& axis,
120                                  const CArray<int,1>& axisDomainOrder = CArray<int,1>());
121         static CGrid* createGrid(StdString id, const std::vector<CDomain*>& domains, const std::vector<CAxis*>& axis,
122                                  const std::vector<CScalar*>& scalars, const CArray<int,1>& axisDomainOrder = CArray<int,1>());
123         static CGrid* createGrid(const std::vector<CDomain*>& domains, const std::vector<CAxis*>& axis,
124                                  const std::vector<CScalar*>& scalars, const CArray<int,1>& axisDomainOrder);
125         static StdString generateId(const std::vector<CDomain*>& domains, const std::vector<CAxis*>& axis,
126                                     const std::vector<CScalar*>& scalars, const CArray<int,1>& axisDomainOrder = CArray<int,1>());
127         static StdString generateId(const CGrid* gridSrc, const CGrid* gridDest);
128         static CGrid* cloneGrid(const StdString& idNewGrid, CGrid* gridSrc);
129
130      public:           
131         void computeIndexServer(void);
132         void computeIndex(void);
133         void computeIndexScalarGrid();
134         void computeWrittenIndex();
135
136         void solveDomainRef(bool checkAtt);
137         void solveAxisRef(bool checkAtt);
138         void solveScalarRef(bool checkAtt);
139         void solveDomainAxisRefInheritance(bool apply = true);
140         void solveTransformations();
141         void solveDomainAxisBaseRef();
142
143         CDomain* addDomain(const std::string& id=StdString());
144         CAxis* addAxis(const std::string& id=StdString());
145         CScalar* addScalar(const std::string& id=StdString());
146         void sendAddDomain(const std::string& id,CContextClient* contextClient);
147         void sendAddAxis(const std::string& id,CContextClient* contextClient);
148         void sendAddScalar(const std::string& id,CContextClient* contextClient);
149         void sendAllDomains(CContextClient* contextClient);
150         void sendAllAxis(CContextClient* contextClient);
151         void sendAllScalars(CContextClient* contextClient);
152
153         static void recvAddDomain(CEventServer& event);
154         void recvAddDomain(CBufferIn& buffer);
155         static void recvAddAxis(CEventServer& event);
156         void recvAddAxis(CBufferIn& buffer);
157         static void recvAddScalar(CEventServer& event);
158         void recvAddScalar(CBufferIn& buffer);
159
160         static bool dispatchEvent(CEventServer& event);
161         static void recvIndex(CEventServer& event);
162         void recvIndex(vector<int> ranks, vector<CBufferIn*> buffers);
163         void sendIndex(void);
164         void sendIndexScalarGrid();
165
166         void setContextClient(CContextClient* contextClient);
167
168         void computeDomConServer();
169         std::map<int, int> getDomConServerSide();
170         std::map<int, StdSize> getAttributesBufferSize(CContextClient* client, bool bufferForWriting = false);
171         std::map<int, StdSize> getDataBufferSize(CContextClient* client, const std::string& id = "", bool bufferForWriting = false);
172         std::vector<StdString> getDomainList();
173         std::vector<StdString> getAxisList();
174         std::vector<StdString> getScalarList();
175         std::vector<CDomain*> getDomains();
176         std::vector<CAxis*> getAxis();
177         std::vector<CScalar*> getScalars();
178         CDomain* getDomain(int domainIndex);
179         CAxis* getAxis(int axisIndex);
180         CScalar* getScalar(int scalarIndex);
181         std::vector<int> getAxisOrder();
182         std::vector<int> getGlobalDimension();
183         bool isScalarGrid() const;         
184
185         bool doGridHaveDataToWrite();
186         bool doGridHaveDataDistributed(CContextClient* client = 0);
187         size_t getWrittenDataSize() const;
188         int getNumberWrittenIndexes() const;
189         int getTotalNumberWrittenIndexes() const;
190         int getOffsetWrittenIndexes() const;
191
192         CDistributionServer* getDistributionServer();
193         CDistributionClient* getDistributionClient();
194         CGridTransformation* getTransformations();
195
196         void transformGrid(CGrid* transformGridSrc);
197         void completeGrid(CGrid* transformGridSrc = 0);
198         void doAutoDistribution(CGrid* transformGridSrc);
199         bool isTransformed();
200         void setTransformed();
201         bool isGenerated();
202         void setGenerated();
203         void addTransGridSource(CGrid* gridSrc);
204         std::map<CGrid*, std::pair<bool,StdString> >& getTransGridSource();
205         bool hasTransform();
206         size_t getGlobalWrittenSize(void) ;
207
208         bool hasMask(void) const;
209         void checkMask(void);
210         void createMask(void);
211         void modifyMask(const CArray<int,1>& indexToModify, bool valueToModify = false);
212         void modifyMaskSize(const std::vector<int>& newDimensionSize, bool newValue = false);
213
214         void computeGridGlobalDimension(const std::vector<CDomain*>& domains,
215                                         const std::vector<CAxis*>& axis,
216                                         const std::vector<CScalar*>& scalars,
217                                         const CArray<int,1>& axisDomainOrder);
218
219      private:
220       template<int N>
221       void checkGridMask(CArray<bool,N>& gridMask,
222                          const std::vector<CArray<bool,1>* >& domainMasks,
223                          const std::vector<CArray<bool,1>* >& axisMasks,
224                          const CArray<int,1>& axisDomainOrder,
225                          bool createMask = false);
226        template<int N>
227        void modifyGridMask(CArray<bool,N>& gridMask, const CArray<int,1>& indexToModify, bool valueToModify);
228
229        template<int N>
230        void modifyGridMaskSize(CArray<bool,N>& gridMask, const std::vector<int>& eachDimSize, bool newValue);
231
232        void storeField_arr(const double* const data, CArray<double, 1>& stored) const;
233        void restoreField_arr(const CArray<double, 1>& stored, double* const data) const;
234        void uncompressField_arr(const double* const data, CArray<double, 1>& outData) const;
235        void maskField_arr(const double* const data, CArray<double, 1>& stored) const;
236
237        void setVirtualDomainGroup(CDomainGroup* newVDomainGroup);
238        void setVirtualAxisGroup(CAxisGroup* newVAxisGroup);
239        void setVirtualScalarGroup(CScalarGroup* newVScalarGroup);
240
241        void setDomainList(const std::vector<CDomain*> domains = std::vector<CDomain*>());
242        void setAxisList(const std::vector<CAxis*> axis = std::vector<CAxis*>());
243        void setScalarList(const std::vector<CScalar*> scalars = std::vector<CScalar*>());
244
245        CDomainGroup* getVirtualDomainGroup() const;
246        CAxisGroup* getVirtualAxisGroup() const;
247        CScalarGroup* getVirtualScalarGroup() const;
248
249        void checkAttributesAfterTransformation();
250        void setTransformationAlgorithms();
251        void computeIndexByElement(const std::vector<std::unordered_map<size_t,std::vector<int> > >& indexServerOnElement,
252                                   const CContextClient* client,
253                                   CClientServerMapping::GlobalIndexMap& globalIndexOnServer);
254        int computeGridGlobalDimension(std::vector<int>& globalDim,
255                                       const std::vector<CDomain*> domains,
256                                       const std::vector<CAxis*> axis,
257                                       const std::vector<CScalar*> scalars,
258                                       const CArray<int,1>& axisDomainOrder);
259        int getDistributedDimension();
260
261        void computeClientIndex();
262        void computeConnectedClients();
263        void computeClientIndexScalarGrid(); 
264        void computeConnectedClientsScalarGrid(); 
265
266
267      public:
268/** Array containing the local index of the grid
269 *  storeIndex_client[local_workflow_grid_index] -> local_model_grid_index.
270 *  Used to store field from model into the worklow, or to return field into models. 
271 *  The size of the array is the number of local index of the workflow grid */       
272         CArray<int, 1> storeIndex_client_;
273
274/** Array containing the grid mask masked defined by the mask_nd grid attribute.       
275  * The corresponding masked field value provided by the model will be replaced by a NaN value
276  * in the workflow.  */
277         CArray<bool, 1> storeMask_client_;
278
279/** Map containing the indexes on client side that will be sent to each connected server.
280  * storeIndex_toSrv[&contextClient] -> map concerning the contextClient for which the data will be sent (client side)
281  * storeIndex_toSrv[&contextClient][rank] -> array of indexes that will be sent to each "rank" of the connected servers
282  * storeIndex_toSrv[&contextClient][rank](index_of_buffer_sent_to_server) -> local index of the field of the workflow
283  * grid that will be sent to server */
284         std::map<CContextClient*, map<int, CArray<int, 1> > > storeIndex_toSrv_;
285
286
287/** Map containing the indexes on client side that will be received from each connected server.
288  * This map is used to agreggate field data received from server (for reading) into a single array, which will be an entry
289  * point of the worklow on client side.
290  * storeIndex_toSrv[rank] -> array of indexes that will be received from each "rank" of the connected servers
291  * storeIndex_toSrv[rank](index_of_buffer_received_from_server) -> local index of the field in the "workflow grid"
292  * that has been received from server */
293         std::map<int, CArray<int, 1> > storeIndex_fromSrv_; // Support, for now, reading with level-1 server
294
295
296/** Maps storing the number of participating clients for data sent a specific server for a given contextClient, identified
297  * by the servers communicator size. In future must be direcly identified by context.
298  * nbSender_[context_server_size] -> map the number of client sender by connected rank of servers
299  * nbSender_[context_server_size] [rank_server] -> the number of client participating to a send message for a server of rank "rank_server"
300  * Usefull to indicate in a message the number of participant needed by the transfer protocol */
301         std::map<int, std::map<int,int> > nbSenders_;
302
303
304/** Maps storing the number of participating servers for data sent a specific client for a given contextClient.
305  * Symetric of nbSenders_, but for server side which want to send data to client.
306  * nbReadSender_[context_client_size] -> map the number of server sender by connected rank of clients
307  * nbReadSender_[context_client_size] [rank_client] -> the number of serverq participating to a send message for a client of rank "rank_client"
308  * Usefull to indicate in a message the number of participant needed by the transfer protocol */
309         std::map<CContextClient*, std::map<int,int> > nbReadSenders_;
310
311
312// Manh Ha's comment: " A client receives global index from other clients (via recvIndex)
313// then does mapping these index into local index of STORE_CLIENTINDEX
314// In this way, store_clientIndex can be used as an input of a source filter
315// Maybe we need a flag to determine whether a client wants to write. TODO "
316
317/** Map storing received data on server side. This map is the equivalent of storeIndex_client, but for data not received from model
318  * instead that for client. This map is used to concatenate data received from several clients into a single array on server side
319  * which match the local workflow grid.
320  * outLocalIndexStoreOnClient_[client_rank] -> Array of index from client of rank "client_rank"
321  * outLocalIndexStoreOnClient_[client_rank](index of buffer from client) -> local index of the workflow grid
322  * The map is created in CGrid::computeClientIndex and filled upon receiving data in CField::recvUpdateData().
323  * Symetrically it is also used to send data from a server to sevral client for reading case. */
324         map<int, CArray<size_t, 1> > outLocalIndexStoreOnClient_; 
325
326
327/** Indexes calculated based on server-like distribution.
328 *  They are used for writing/reading data and only calculated for server level that does the writing/reading.
329 *  Along with localIndexToWriteOnClient, these indexes are used to correctly place incoming data. */
330         CArray<size_t,1> localIndexToWriteOnServer;
331
332/** Indexes calculated based on client-like distribution.
333  * They are used for writing/reading data and only calculated for server level that does the writing/reading.
334  * Along with localIndexToWriteOnServer, these indexes are used to correctly place incoming data. */
335         CArray<size_t,1> localIndexToWriteOnClient;
336
337         CArray<size_t,1> indexFromClients;
338
339
340      private:
341
342/** Clients that have to send a grid. There can be multiple clients in case of secondary server, otherwise only one client. */
343        std::list<CContextClient*> clients;
344        std::set<CContextClient*> clientsSet;
345
346/** Map storing received indexes. Key = sender rank, value = index array. */
347         map<int, CArray<size_t, 1> > outGlobalIndexFromClient_;
348
349        bool isChecked;
350        bool isDomainAxisChecked;
351        bool isIndexSent;
352
353        CDomainGroup* vDomainGroup_;
354        CAxisGroup* vAxisGroup_;
355        CScalarGroup* vScalarGroup_;
356        std::vector<std::string> axisList_, domList_, scalarList_;
357        bool isAxisListSet, isDomListSet, isScalarListSet;
358
359/** Client-like distribution calculated based on the knowledge of the entire grid */
360        CDistributionClient* clientDistribution_;
361
362/** Server-like distribution calculated upon receiving indexes */
363        CDistributionServer* serverDistribution_;
364
365        CClientServerMapping* clientServerMap_;
366        size_t writtenDataSize_;
367        int numberWrittenIndexes_, totalNumberWrittenIndexes_, offsetWrittenIndexes_;
368
369/** Map storing local ranks of connected receivers. Key = size of receiver's intracomm.
370  * It is calculated in computeConnectedClients(). */
371        std::map<int, std::vector<int> > connectedServerRank_;
372
373/** Map storing the size of data to be send. Key = size of receiver's intracomm
374  * It is calculated in computeConnectedClients(). */
375        std::map<int, std::map<int,size_t> > connectedDataSize_;
376
377/** Ranks of connected receivers in case of reading. It is calculated in recvIndex(). */
378        std::vector<int> connectedServerRankRead_;
379
380/** Size of data to be send in case of reading. It is calculated in recvIndex(). */
381        std::map<int,size_t> connectedDataSizeRead_;
382
383        bool isDataDistributed_;       
384         //! True if and only if the data defined on the grid can be outputted in a compressed way
385        bool isCompressible_;
386        std::set<std::string> relFilesCompressed;
387
388        bool isTransformed_, isGenerated_;
389        bool computedWrittenIndex_;
390        std::vector<int> axisPositionInGrid_;
391        CGridTransformation* transformations_;
392        bool hasDomainAxisBaseRef_;       
393        std::map<CGrid*, std::pair<bool,StdString> > gridSrc_;
394        bool hasTransform_;
395
396/** Map storing global indexes of server-like (band-wise) distribution for sending to receivers.
397  * Key = size of receiver's intracomm.
398  */
399//        std::map<CContextClient*, CClientServerMapping::GlobalIndexMap> globalIndexOnServer_;
400        std::map<int, CClientServerMapping::GlobalIndexMap> globalIndexOnServer_;
401
402
403/** List order of axis and domain in a grid, if there is a domain, it will take value 2, axis 1, scalar 0 */
404        std::vector<int> order_;
405
406   }; // class CGrid
407
408   ///--------------------------------------------------------------
409
410   template <int n>
411   void CGrid::inputField(const CArray<double,n>& field, CArray<double,1>& stored) const
412   TRY
413   {
414//#ifdef __XIOS_DEBUG
415      if (this->getDataSize() != field.numElements())
416         ERROR("void CGrid::inputField(const  CArray<double,n>& field, CArray<double,1>& stored) const",
417                << "[ Awaiting data of size = " << this->getDataSize() << ", "
418                << "Received data size = "      << field.numElements() << " ] "
419                << "The data array does not have the right size! "
420                << "Grid = " << this->getId())
421//#endif
422      this->storeField_arr(field.dataFirst(), stored);
423   }
424   CATCH
425
426   template <int n>
427   void CGrid::maskField(const CArray<double,n>& field, CArray<double,1>& stored) const
428   {
429//#ifdef __XIOS_DEBUG
430      if (this->getDataSize() != field.numElements())
431         ERROR("void CGrid::inputField(const  CArray<double,n>& field, CArray<double,1>& stored) const",
432                << "[ Awaiting data of size = " << this->getDataSize() << ", "
433                << "Received data size = "      << field.numElements() << " ] "
434                << "The data array does not have the right size! "
435                << "Grid = " << this->getId())
436//#endif
437      this->maskField_arr(field.dataFirst(), stored);
438   }
439
440   template <int n>
441   void CGrid::outputField(const CArray<double,1>& stored, CArray<double,n>& field) const
442   TRY
443   {
444//#ifdef __XIOS_DEBUG
445      if (this->getDataSize() != field.numElements())
446         ERROR("void CGrid::outputField(const CArray<double,1>& stored, CArray<double,n>& field) const",
447                << "[ Size of the data = " << this->getDataSize() << ", "
448                << "Output data size = "   << field.numElements() << " ] "
449                << "The ouput array does not have the right size! "
450                << "Grid = " << this->getId())
451//#endif
452      this->restoreField_arr(stored, field.dataFirst());
453   }
454   CATCH
455
456   /*!
457     This function removes the effect of mask on received data on the server.
458     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
459     \data data received data with masking effect on the server
460     \outData data without masking effect
461   */
462   template <int N>
463   void CGrid::uncompressField(const CArray<double,N>& data, CArray<double,1>& outData) const
464   TRY
465   {     
466     uncompressField_arr(data.dataFirst(), outData);
467   }
468   CATCH
469
470   template<int N>
471   void CGrid::checkGridMask(CArray<bool,N>& gridMask,
472                             const std::vector<CArray<bool,1>* >& domainMasks,
473                             const std::vector<CArray<bool,1>* >& axisMasks,
474                             const CArray<int,1>& axisDomainOrder,
475                             bool createMask)
476   TRY
477   {
478     int idx = 0;
479     int numElement = axisDomainOrder.numElements();
480     int dim = domainMasks.size() * 2 + axisMasks.size();
481     std::vector<CDomain*> domainP = this->getDomains();
482     std::vector<CAxis*> axisP = this->getAxis();
483
484     std::vector<int> idxLoop(dim,0), indexMap(numElement), eachDimSize(dim);
485     std::vector<int> currentIndex(dim);
486     int idxDomain = 0, idxAxis = 0;
487    for (int i = 0; i < numElement; ++i)
488    {
489      indexMap[i] = idx;
490      if (2 == axisDomainOrder(i)) {
491          eachDimSize[indexMap[i]]   = domainP[idxDomain]->ni;
492          eachDimSize[indexMap[i]+1] = domainP[idxDomain]->nj;
493          idx += 2; ++idxDomain;
494      }
495      else if (1 == axisDomainOrder(i)) {
496//        eachDimSize[indexMap[i]] = axisMasks[idxAxis]->numElements();
497        eachDimSize[indexMap[i]] = axisP[idxAxis]->n;
498        ++idx; ++idxAxis;
499      }
500      else {};
501    }
502
503    if (!gridMask.isEmpty() && !createMask)
504    {
505      for (int i = 0; i < dim; ++i)
506      {
507        if (gridMask.extent(i) != eachDimSize[i])
508          ERROR("CGrid::checkMask(void)",
509                << "The mask has one dimension whose size is different from the one of the local grid." << std::endl
510                << "Local size of dimension " << i << " is " << eachDimSize[i] << "." << std::endl
511                << "Mask size for dimension " << i << " is " << gridMask.extent(i) << "." << std::endl
512                << "Grid = " << this->getId())
513      }
514    }
515    else {
516        CArrayBoolTraits<CArray<bool,N> >::resizeArray(gridMask,eachDimSize);
517        gridMask = true;
518    }
519
520    int ssize = gridMask.numElements();
521    idx = 0;
522    while (idx < ssize)
523    {
524      for (int i = 0; i < dim-1; ++i)
525      {
526        if (idxLoop[i] == eachDimSize[i])
527        {
528          idxLoop[i] = 0;
529          ++idxLoop[i+1];
530        }
531      }
532
533      // Find out outer index
534      idxDomain = idxAxis = 0;
535      bool maskValue = true;
536      for (int i = 0; i < numElement; ++i)
537      {
538        if (2 == axisDomainOrder(i))
539        {
540          int idxTmp = idxLoop[indexMap[i]] + idxLoop[indexMap[i]+1] * eachDimSize[indexMap[i]];
541          if (idxTmp < (*domainMasks[idxDomain]).numElements())
542            maskValue = maskValue && (*domainMasks[idxDomain])(idxTmp);
543          else
544            maskValue = false;
545          ++idxDomain;
546        }
547        else if (1 == axisDomainOrder(i))
548        {
549          int idxTmp = idxLoop[indexMap[i]];
550          if (idxTmp < (*axisMasks[idxAxis]).numElements())
551            maskValue = maskValue && (*axisMasks[idxAxis])(idxTmp);
552          else
553            maskValue = false;
554
555          ++idxAxis;
556        }
557      }
558
559      int maskIndex = idxLoop[0];
560      int mulDim = 1;
561      for (int k = 1; k < dim; ++k)
562      {
563        mulDim *= eachDimSize[k-1];
564        maskIndex += idxLoop[k]*mulDim;
565      }
566      *(gridMask.dataFirst()+maskIndex) &= maskValue;
567
568      ++idxLoop[0];
569      ++idx;
570    }
571   }
572   CATCH_DUMP_ATTR
573
574   template<int N>
575   void CGrid::modifyGridMaskSize(CArray<bool,N>& gridMask,
576                                  const std::vector<int>& eachDimSize,
577                                  bool newValue)
578   TRY
579   {
580      if (N != eachDimSize.size())
581      {
582        // ERROR("CGrid::modifyGridMaskSize(CArray<bool,N>& gridMask,
583        //                                  const std::vector<int>& eachDimSize,
584        //                                  bool newValue)",
585        //       << "Dimension size of the mask is different from input dimension size." << std::endl
586        //       << "Mask dimension is " << N << "." << std::endl
587        //       << "Input dimension is " << eachDimSize.size() << "." << std::endl
588        //       << "Grid = " << this->getId())
589      }
590      CArrayBoolTraits<CArray<bool,N> >::resizeArray(gridMask,eachDimSize);
591      gridMask = newValue;
592   }
593   CATCH_DUMP_ATTR
594                                 
595
596   /*!
597     Modify the current mask of grid, the local index to be modified will take value false
598     \param [in/out] gridMask current mask of grid
599     \param [in] indexToModify local index to modify
600   */
601   template<int N>
602   void CGrid::modifyGridMask(CArray<bool,N>& gridMask, const CArray<int,1>& indexToModify, bool valueToModify)
603   TRY
604   {     
605     int num = indexToModify.numElements();
606     for (int idx = 0; idx < num; ++idx)
607     {
608       *(gridMask.dataFirst()+indexToModify(idx)) = valueToModify;
609     }
610   }
611   CATCH_DUMP_ATTR
612
613   ///--------------------------------------------------------------
614
615
616
617   // Declare/Define CGridGroup and CGridDefinition
618   DECLARE_GROUP(CGrid);
619
620   ///--------------------------------------------------------------
621
622} // namespace xios
623
624#endif // __XIOS_CGrid__
Note: See TracBrowser for help on using the repository browser.