source: XIOS/dev/dev_olga/src/node/grid.hpp @ 1178

Last change on this file since 1178 was 1178, checked in by mhnguyen, 5 years ago

Fixing bug: Writting scalar into file

+) Update writing scalar with new grid distribution system

Test
+) On Curie
+) Work

  • 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: 18.4 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   /// ////////////////////// Déclarations ////////////////////// ///
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         /// Entrées-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 outputField(const CArray<double,1>& stored, CArray<double,n>& field) const;     
98
99         virtual void parse(xml::CXMLNode& node);
100
101         /// Destructeur ///
102         virtual ~CGrid(void);
103
104      public:
105
106         /// Accesseurs statiques ///
107         static StdString GetName(void);
108         static StdString GetDefName(void);
109
110         static ENodeType GetType(void);
111
112         /// Instanciateurs Statiques ///
113         static CGrid* createGrid(CDomain* domain);
114         static CGrid* createGrid(CDomain* domain, CAxis* axis);
115         static CGrid* createGrid(const std::vector<CDomain*>& domains, const std::vector<CAxis*>& axis,
116                                  const CArray<int,1>& axisDomainOrder = CArray<int,1>());
117         static CGrid* createGrid(StdString id, const std::vector<CDomain*>& domains, const std::vector<CAxis*>& axis,
118                                  const std::vector<CScalar*>& scalars, const CArray<int,1>& axisDomainOrder = CArray<int,1>());
119         static CGrid* createGrid(const std::vector<CDomain*>& domains, const std::vector<CAxis*>& axis,
120                                  const std::vector<CScalar*>& scalars, const CArray<int,1>& axisDomainOrder);
121         static StdString generateId(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 StdString generateId(const CGrid* gridSrc, const CGrid* gridDest);
124         static CGrid* cloneGrid(const StdString& idNewGrid, CGrid* gridSrc);
125
126      public:           
127         void computeIndexServer(void);
128         void computeIndex(void);
129         void computeIndexScalarGrid();
130         void computeWrittenIndex();
131
132         void solveDomainRef(bool checkAtt);
133         void solveAxisRef(bool checkAtt);
134         void solveScalarRef(bool checkAtt);
135         void solveDomainAxisRefInheritance(bool apply = true);
136         void solveTransformations();
137         void solveDomainAxisBaseRef();
138
139         CDomain* addDomain(const std::string& id=StdString());
140         CAxis* addAxis(const std::string& id=StdString());
141         CScalar* addScalar(const std::string& id=StdString());
142         void sendAddDomain(const std::string& id="");
143         void sendAddAxis(const std::string& id="");
144         void sendAddScalar(const std::string& id="");
145         void sendAllDomains();
146         void sendAllAxis();
147         void sendAllScalars();
148
149         static void recvAddDomain(CEventServer& event);
150         void recvAddDomain(CBufferIn& buffer);
151         static void recvAddAxis(CEventServer& event);
152         void recvAddAxis(CBufferIn& buffer);
153         static void recvAddScalar(CEventServer& event);
154         void recvAddScalar(CBufferIn& buffer);
155
156         static bool dispatchEvent(CEventServer& event);
157         static void recvIndex(CEventServer& event);
158         void recvIndex(vector<int> ranks, vector<CBufferIn*> buffers);
159         void sendIndex(void);
160         void sendIndexScalarGrid();
161
162         void computeDomConServer();
163         std::map<int, int> getDomConServerSide();
164         std::map<int, StdSize> getAttributesBufferSize();
165         std::vector<std::map<int, StdSize> > getDataBufferSize(const std::string& id = "");
166         std::vector<StdString> getDomainList();
167         std::vector<StdString> getAxisList();
168         std::vector<StdString> getScalarList();
169         std::vector<CDomain*> getDomains();
170         std::vector<CAxis*> getAxis();
171         std::vector<CScalar*> getScalars();
172         CDomain* getDomain(int domainIndex);
173         CAxis* getAxis(int axisIndex);
174         CScalar* getScalar(int scalarIndex);
175         std::vector<int> getAxisOrder();
176         std::vector<int> getGlobalDimension();
177         bool isScalarGrid() const;
178         std::vector<int> getAxisPositionInGrid() const;
179
180         bool doGridHaveDataToWrite();
181         bool doGridHaveDataDistributed();
182         size_t getWrittenDataSize() const;
183         int getNumberWrittenIndexes() const;
184         int getTotalNumberWrittenIndexes() const;
185         int getOffsetWrittenIndexes() const;
186
187         CDistributionServer* getDistributionServer();
188         CDistributionClient* getDistributionClient();
189         CGridTransformation* getTransformations();
190
191         void transformGrid(CGrid* transformGridSrc);
192         void completeGrid(CGrid* transformGridSrc = 0);
193         void doAutoDistribution(CGrid* transformGridSrc);
194         bool isTransformed();
195         void setTransformed();
196         bool isGenerated();
197         void setGenerated();
198         void addTransGridSource(CGrid* gridSrc);
199         std::map<CGrid*, std::pair<bool,StdString> >& getTransGridSource();
200         bool hasTransform();
201
202      public:
203
204         /// Propriétés privées ///
205         bool isChecked;
206         bool isDomainAxisChecked;
207         bool isIndexSent;
208
209         CArray<int, 1> storeIndex_client;
210
211         map<int, CArray<int, 1> > storeIndex_toSrv;
212         map<int, CArray<int, 1> > storeIndex_fromSrv;
213         std::vector<map<int,int> > nbSenders, nbReadSenders;
214
215         map<int, CArray<size_t, 1> > outIndexFromClient, compressedOutIndexFromClient, outGlobalIndexFromClient;
216
217         // A client receives global index from other clients (via recvIndex)
218         // then does mapping these index into local index of STORE_CLIENTINDEX
219         // In this way, store_clientIndex can be used as an input of a source filter
220         // Maybe we need a flag to determine whether a client wants to write. TODO
221         map<int, CArray<size_t, 1> > outLocalIndexStoreOnClient; 
222
223         // If a client wants to write out data, it'll use this index.
224         // A client receives global index of data from other clients (via recvIndex),
225         // then does remapping these index into local index to WRITE into a file
226         CArray<size_t,1> localIndexToWriteOnClient, localIndexToWriteOnServer;
227
228         CArray<size_t,1> indexFromClients;
229         void checkMask(void);
230         void createMask(void);
231         void modifyMask(const CArray<int,1>& indexToModify, bool valueToModify = false);
232         void modifyMaskSize(const std::vector<int>& newDimensionSize, bool newValue = false);
233
234         void computeGridGlobalDimension(const std::vector<CDomain*>& domains,
235                                         const std::vector<CAxis*>& axis,
236                                         const std::vector<CScalar*>& scalars,
237                                         const CArray<int,1>& axisDomainOrder);
238
239      private:
240       template<int N>
241       void checkGridMask(CArray<bool,N>& gridMask,
242                          const std::vector<CArray<bool,1>* >& domainMasks,
243                          const std::vector<CArray<bool,1>* >& axisMasks,
244                          const CArray<int,1>& axisDomainOrder,
245                          bool createMask = false);
246        template<int N>
247        void modifyGridMask(CArray<bool,N>& gridMask, const CArray<int,1>& indexToModify, bool valueToModify);
248
249        template<int N>
250        void modifyGridMaskSize(CArray<bool,N>& gridMask, const std::vector<int>& eachDimSize, bool newValue);
251
252        void storeField_arr(const double* const data, CArray<double, 1>& stored) const;
253        void restoreField_arr(const CArray<double, 1>& stored, double* const data) const;
254
255        void setVirtualDomainGroup(CDomainGroup* newVDomainGroup);
256        void setVirtualAxisGroup(CAxisGroup* newVAxisGroup);
257        void setVirtualScalarGroup(CScalarGroup* newVScalarGroup);
258
259        void setDomainList(const std::vector<CDomain*> domains = std::vector<CDomain*>());
260        void setAxisList(const std::vector<CAxis*> axis = std::vector<CAxis*>());
261        void setScalarList(const std::vector<CScalar*> scalars = std::vector<CScalar*>());
262
263        CDomainGroup* getVirtualDomainGroup() const;
264        CAxisGroup* getVirtualAxisGroup() const;
265        CScalarGroup* getVirtualScalarGroup() const;
266
267        void checkAttributesAfterTransformation();
268        void setTransformationAlgorithms();
269        void computeIndexByElement(const std::vector<boost::unordered_map<size_t,std::vector<int> > >& indexServerOnElement,
270                                   CClientServerMapping::GlobalIndexMap& globalIndexOnServer);
271        int computeGridGlobalDimension(std::vector<int>& globalDim,
272                                       const std::vector<CDomain*> domains,
273                                       const std::vector<CAxis*> axis,
274                                       const std::vector<CScalar*> scalars,
275                                       const CArray<int,1>& axisDomainOrder);
276        int getDistributedDimension();
277
278        void computeClientIndex();
279        void computeConnectedClients();
280        void computeClientIndexScalarGrid();
281        void computeConnectedClientsScalarGrid();       
282
283      private:
284        CDomainGroup* vDomainGroup_;
285        CAxisGroup* vAxisGroup_;
286        CScalarGroup* vScalarGroup_;
287        std::vector<std::string> axisList_, domList_, scalarList_;
288        bool isAxisListSet, isDomListSet, isScalarListSet;
289
290        CDistributionClient* clientDistribution_;
291        CDistributionServer* serverDistribution_;
292        CClientServerMapping* clientServerMap_;
293        size_t writtenDataSize_;
294        int numberWrittenIndexes_, totalNumberWrittenIndexes_, offsetWrittenIndexes_;
295        std::vector<std::map<int,size_t> > connectedDataSize_;
296        std::vector<std::vector<int> > connectedServerRank_;
297        bool isDataDistributed_;       
298         //! True if and only if the data defined on the grid can be outputted in a compressed way
299        bool isCompressible_;
300        std::set<std::string> relFilesCompressed;
301
302        bool isTransformed_, isGenerated_;
303        bool computedWrittenIndex_;
304        std::vector<int> axisPositionInGrid_;
305        CGridTransformation* transformations_;
306        bool hasDomainAxisBaseRef_;       
307        std::map<CGrid*, std::pair<bool,StdString> > gridSrc_;
308        bool hasTransform_;
309        CClientServerMapping::GlobalIndexMap globalIndexOnServer_;
310            // List order of axis and domain in a grid, if there is a domain, it will take value 1 (true), axis 0 (false)
311        std::vector<int> order_;
312   }; // class CGrid
313
314   ///--------------------------------------------------------------
315
316   template <int n>
317   void CGrid::inputField(const CArray<double,n>& field, CArray<double,1>& stored) const
318   {
319      if (this->getDataSize() != field.numElements())
320         ERROR("void CGrid::inputField(const  CArray<double,n>& field, CArray<double,1>& stored) const",
321                << "[ Awaiting data of size = " << this->getDataSize() << ", "
322                << "Received data size = "      << field.numElements() << " ] "
323                << "The data array does not have the right size! "
324                << "Grid = " << this->GetName())
325      this->storeField_arr(field.dataFirst(), stored);
326   }
327
328   template <int n>
329   void CGrid::outputField(const CArray<double,1>& stored, CArray<double,n>& field) const
330   {
331      if (this->getDataSize() != field.numElements())
332         ERROR("void CGrid::outputField(const CArray<double,1>& stored, CArray<double,n>& field) const",
333                << "[ Size of the data = " << this->getDataSize() << ", "
334                << "Output data size = "   << field.numElements() << " ] "
335                << "The ouput array does not have the right size! "
336                << "Grid = " << this->GetName())
337      this->restoreField_arr(stored, field.dataFirst());
338   }
339
340   template<int N>
341   void CGrid::checkGridMask(CArray<bool,N>& gridMask,
342                             const std::vector<CArray<bool,1>* >& domainMasks,
343                             const std::vector<CArray<bool,1>* >& axisMasks,
344                             const CArray<int,1>& axisDomainOrder,
345                             bool createMask)
346   {
347     int idx = 0;
348     int numElement = axisDomainOrder.numElements();
349     int dim = domainMasks.size() * 2 + axisMasks.size();
350     std::vector<CDomain*> domainP = this->getDomains();
351
352     std::vector<int> idxLoop(dim,0), indexMap(numElement), eachDimSize(dim);
353     std::vector<int> currentIndex(dim);
354     int idxDomain = 0, idxAxis = 0;
355    for (int i = 0; i < numElement; ++i)
356    {
357      indexMap[i] = idx;
358      if (2 == axisDomainOrder(i)) {
359          eachDimSize[indexMap[i]]   = domainP[idxDomain]->ni;
360          eachDimSize[indexMap[i]+1] = domainP[idxDomain]->nj;
361          idx += 2; ++idxDomain;
362      }
363      else if (1 == axisDomainOrder(i)) {
364        eachDimSize[indexMap[i]] = axisMasks[idxAxis]->numElements();
365        ++idx; ++idxAxis;
366      }
367      else {};
368    }
369
370    if (!gridMask.isEmpty() && !createMask)
371    {
372      for (int i = 0; i < dim; ++i)
373      {
374        if (gridMask.extent(i) != eachDimSize[i])
375          ERROR("CGrid::checkMask(void)",
376                << "The mask has one dimension whose size is different from the one of the local grid." << std::endl
377                << "Local size of dimension " << i << " is " << eachDimSize[i] << "." << std::endl
378                << "Mask size for dimension " << i << " is " << gridMask.extent(i) << "." << std::endl
379                << "Grid = " << this->GetName())
380      }
381    }
382    else {
383        CArrayBoolTraits<CArray<bool,N> >::resizeArray(gridMask,eachDimSize);
384        gridMask = true;
385    }
386
387    int ssize = gridMask.numElements();
388    idx = 0;
389    while (idx < ssize)
390    {
391      for (int i = 0; i < dim-1; ++i)
392      {
393        if (idxLoop[i] == eachDimSize[i])
394        {
395          idxLoop[i] = 0;
396          ++idxLoop[i+1];
397        }
398      }
399
400      // Find out outer index
401      idxDomain = idxAxis = 0;
402      bool maskValue = true;
403      for (int i = 0; i < numElement; ++i)
404      {
405        if (2 == axisDomainOrder(i))
406        {
407          maskValue = maskValue && (*domainMasks[idxDomain])(idxLoop[indexMap[i]] + idxLoop[indexMap[i]+1] * eachDimSize[indexMap[i]]);
408          ++idxDomain;
409        }
410        else if (1 == axisDomainOrder(i))
411        {
412          maskValue = maskValue && (*axisMasks[idxAxis])(idxLoop[indexMap[i]]);
413          ++idxAxis;
414        }
415      }
416
417      int maskIndex = idxLoop[0];
418      int mulDim = 1;
419      for (int k = 1; k < dim; ++k)
420      {
421        mulDim *= eachDimSize[k-1];
422        maskIndex += idxLoop[k]*mulDim;
423      }
424      *(gridMask.dataFirst()+maskIndex) &= maskValue;
425
426      ++idxLoop[0];
427      ++idx;
428    }
429
430   }
431
432   template<int N>
433   void CGrid::modifyGridMaskSize(CArray<bool,N>& gridMask,
434                                  const std::vector<int>& eachDimSize,
435                                  bool newValue)
436   {
437      if (N != eachDimSize.size())
438      {
439        // ERROR("CGrid::modifyGridMaskSize(CArray<bool,N>& gridMask,
440        //                                  const std::vector<int>& eachDimSize,
441        //                                  bool newValue)",
442        //       << "Dimension size of the mask is different from input dimension size." << std::endl
443        //       << "Mask dimension is " << N << "." << std::endl
444        //       << "Input dimension is " << eachDimSize.size() << "." << std::endl
445        //       << "Grid = " << this->GetName())
446      }
447      CArrayBoolTraits<CArray<bool,N> >::resizeArray(gridMask,eachDimSize);
448      gridMask = newValue;
449   }
450                                 
451
452   /*!
453     Modify the current mask of grid, the local index to be modified will take value false
454     \param [in/out] gridMask current mask of grid
455     \param [in] indexToModify local index to modify
456   */
457   template<int N>
458   void CGrid::modifyGridMask(CArray<bool,N>& gridMask, const CArray<int,1>& indexToModify, bool valueToModify)
459   {     
460     int num = indexToModify.numElements();
461     for (int idx = 0; idx < num; ++idx)
462     {
463       *(gridMask.dataFirst()+indexToModify(idx)) = valueToModify;
464     }
465   }
466   ///--------------------------------------------------------------
467
468   // Declare/Define CGridGroup and CGridDefinition
469   DECLARE_GROUP(CGrid);
470
471   ///--------------------------------------------------------------
472
473} // namespace xios
474
475#endif // __XIOS_CGrid__
Note: See TracBrowser for help on using the repository browser.