source: XIOS/trunk/src/node/grid.hpp @ 1078

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

Adding rectilinear and curvilinear domain for expand_domain transformation
-) Rectilinear/curvilinear is expanded not only locally but also globally, its global size ni_glo, nj_glo become ni_glo+2 and nj_glo+2
-) Two attributes i_periodic, j_periodic are only used for rectilinear/curvilinear to process priodic condition

+) Do some minor modification

Test
+) Add test_connectivity_expand
+) On Curie
+) Work (but need more real tests)

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