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

Last change on this file since 664 was 664, checked in by mhnguyen, 6 years ago

Changing some domain attributes

+) Longitude and latitude from now on can be 2 dimension array

Test
+) On Curie
+) test_client, test_complete pass and are correct

  • 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: 12.3 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 "array_new.hpp"
12#include "attribute_array.hpp"
13#include "distribution_server.hpp"
14#include "client_server_mapping.hpp"
15#include "utils.hpp"
16#include "transformation_enum.hpp"
17
18namespace xios {
19
20   /// ////////////////////// Déclarations ////////////////////// ///
21
22   class CGridGroup;
23   class CGridAttributes;
24   class CDomainGroup;
25   class CAxisGroup;
26   class CGrid;
27   class CDistributionClient;
28   class CDistributionServer;
29   class CServerDistributionDescription;
30   class CClientServerMapping;
31   class CGridTransformation;
32
33   ///--------------------------------------------------------------
34
35   // Declare/Define CGridAttribute
36   BEGIN_DECLARE_ATTRIBUTE_MAP(CGrid)
37#  include "grid_attribute.conf"
38   END_DECLARE_ATTRIBUTE_MAP(CGrid)
39
40   ///--------------------------------------------------------------
41
42   class CGrid
43      : public CObjectTemplate<CGrid>
44      , public CGridAttributes
45   {
46         /// typedef ///
47         typedef CObjectTemplate<CGrid>   SuperClass;
48         typedef CGridAttributes SuperClassAttribute;
49
50      public :
51
52         typedef CGridAttributes RelAttributes;
53         typedef CGridGroup      RelGroup;
54
55         enum EEventId
56         {
57           EVENT_ID_INDEX, EVENT_ID_ADD_DOMAIN, EVENT_ID_ADD_AXIS
58         };
59
60         enum EElementType
61         {
62           GRID_ONLY_AXIS, GRID_ONLY_DOMAIN, GRID_AXIS_DOMAIN
63         };
64
65         /// Constructeurs ///
66         CGrid(void);
67         explicit CGrid(const StdString& id);
68         CGrid(const CGrid& grid);       // Not implemented yet.
69         CGrid(const CGrid* const grid); // Not implemented yet.
70
71         /// Traitements ///
72//         void solveReference(void);
73
74         void solveDomainAxisRef(bool areAttributesChecked);
75
76         void checkMaskIndex(bool doCalculateIndex);
77
78 //        virtual void toBinary  (StdOStream& os) const;
79//         virtual void fromBinary(StdIStream& is);
80
81         /// Tests ///
82         bool hasAxis(void) const;
83
84      public :
85
86         /// Accesseurs ///
87         StdSize getDimension(void) const;
88
89         StdSize  getDataSize(void) const;
90
91         /// Entrées-sorties de champs ///
92         template <int n>
93         void inputField(const CArray<double,n>& field, CArray<double,1>& stored) const;
94         template <int n>
95         void outputField(const CArray<double,1>& stored, CArray<double,n>& field) const;
96
97         void outputField(int rank, const CArray<double,1>& stored, double* field);
98         void inputField(int rank, const double* const field, CArray<double,1>& stored);
99
100         virtual void parse(xml::CXMLNode& node);
101
102         /// Destructeur ///
103         virtual ~CGrid(void);
104
105      public :
106
107         /// Accesseurs statiques ///
108         static StdString GetName(void);
109         static StdString GetDefName(void);
110
111         static ENodeType GetType(void);
112
113         /// Instanciateurs Statiques ///
114         static CGrid* createGrid(CDomain* domain);
115         static CGrid* createGrid(CDomain* domain, CAxis* axis);
116         static CGrid* createGrid(std::vector<CDomain*> domains, std::vector<CAxis*> axis, CArray<bool,1> axisDomainOrder = CArray<bool,1>());
117
118      public :
119
120         /// Entrées-sorties de champs (interne) ///
121         void storeField_arr(const double* const data, CArray<double,1>& stored) const;
122         void restoreField_arr(const CArray<double,1>& stored, double* const data) const;
123
124         /// Traitements protégés ///
125         void computeIndexServer(void);
126         void computeIndex(void);
127         void computeIndexScalarGrid();
128
129         void solveDomainRef(bool checkAtt);
130         void solveAxisRef(bool checkAtt);
131         void solveDomainAxisRefInheritance(bool apply = true);
132         void solveTransformations();
133
134         void sendAddDomain(const std::string& id="");
135         void sendAddAxis(const std::string& id="");
136         void sendAllDomains();
137         void sendAllAxis();
138
139         static void recvAddDomain(CEventServer& event);
140         void recvAddDomain(CBufferIn& buffer);
141         static void recvAddAxis(CEventServer& event);
142         void recvAddAxis(CBufferIn& buffer);
143
144         static bool dispatchEvent(CEventServer& event);
145         static void recvIndex(CEventServer& event);
146         void recvIndex(vector<int> ranks, vector<CBufferIn*> buffers);
147         void sendIndex(void);
148         void sendIndexScalarGrid();
149
150         void computeDomConServer();
151         std::map<int, int> getDomConServerSide();
152         std::map<int, StdSize> getConnectedServerDataSize();
153         std::vector<StdString> getDomainList();
154         std::vector<StdString> getAxisList();
155         std::vector<CDomain*> getDomains();
156         std::vector<CAxis*> getAxis();
157         std::vector<int> getAxisOrder();
158         std::vector<int> getGlobalDimension();
159         bool isScalarGrid() const;
160         std::vector<int> getAxisPositionInGrid() const;
161
162         bool doGridHaveDataToWrite();
163         bool doGridHaveDataDistributed();
164         size_t getWrittenDataSize() const;
165
166         const CDistributionServer* getDistributionServer() const;
167         const CDistributionClient* getDistributionClient() const;
168         CGridTransformation* getTransformations();
169
170         void transformGrid(CGrid* transformGridSrc);
171         bool isTransformed();
172         void setTransformed();
173
174      public:
175
176         /// Propriétés privées ///
177         bool isChecked;
178         bool isDomainAxisChecked;
179         bool isIndexSent;
180
181         CArray<int, 1> storeIndex_client;
182
183         map<int, CArray<int, 1> > storeIndex_toSrv;
184         map<int,int> nbSenders;
185
186         map<int, CArray<size_t, 1> > outIndexFromClient;
187         void checkMask(void);
188         void modifyMask(const CArray<int,1>& indexToModify);
189
190      private:
191       template<int N>
192       void checkGridMask(CArray<bool,N>& gridMask,
193                          const std::vector<CArray<bool,1>* >& domainMasks,
194                          const std::vector<CArray<bool,1>* >& axisMasks,
195                          const CArray<bool,1>& axisDomainOrder);
196        template<int N>
197        void modifyGridMask(CArray<bool,N>& gridMask, const CArray<int,1>& indexToModify);
198
199        void setVirtualDomainGroup(CDomainGroup* newVDomainGroup);
200        void setVirtualDomainGroup();
201        void setVirtualAxisGroup(CAxisGroup* newVAxisGroup);
202        void setVirtualAxisGroup();
203
204        void setAxisList(const std::vector<CAxis*> axis = std::vector<CAxis*>());
205        void setDomainList(const std::vector<CDomain*> domains = std::vector<CDomain*>());
206
207        void computeGridGlobalDimension(const std::vector<CDomain*>& domains,
208                                        const std::vector<CAxis*>& axis,
209                                        const CArray<bool,1>& axisDomainOrder);
210
211        CDomain* addDomain(const std::string& id);
212        CAxis* addAxis(const std::string& id);
213
214        CAxisGroup* getVirtualAxisGroup() const;
215        CDomainGroup* getVirtualDomainGroup() const;
216
217        void checkAttributesAfterTransformation();
218
219
220        void setTransformationAlgorithms();
221
222        std::vector<int> globalDim_;
223      private:
224        CDomainGroup* vDomainGroup_;
225        CAxisGroup* vAxisGroup_;
226        std::vector<std::string> axisList_, domList_;
227        bool isAxisListSet, isDomListSet;
228
229        CDistributionClient* clientDistribution_;
230        CDistributionServer* serverDistribution_;
231        CClientServerMapping* clientServerMap_;
232        size_t writtenDataSize_;
233        std::map<int,size_t> connectedDataSize_;
234        std::vector<int> connectedServerRank_;
235        bool isDataDistributed_;
236        int positionDimensionDistributed_;
237
238        bool isTransformed_;
239        std::vector<int> axisPositionInGrid_;
240        CGridTransformation* transformations_;
241   }; // class CGrid
242
243   ///--------------------------------------------------------------
244
245   template <int n>
246   void CGrid::inputField(const CArray<double,n>& field, CArray<double,1>& stored) const
247   {
248      if (this->getDataSize() != field.numElements())
249         ERROR("void CGrid::inputField(const  CArray<double,n>& field, CArray<double,1>& stored) const",
250                << "[ Awaiting size of the data = " << this->getDataSize()       << ", "
251                << "Received data size = "      << field.numElements() << " ] "
252                << "The array of data has not the good size !")
253      this->storeField_arr(field.dataFirst(), stored);
254   }
255
256   template <int n>
257   void CGrid::outputField(const CArray<double,1>& stored, CArray<double,n>& field) const
258   {
259      if (this->getDataSize() != field.numElements())
260         ERROR("void CGrid::outputField(const CArray<double,1>& stored, CArray<double,n>& field) const",
261                << "[ Size of the data = " << this->getDataSize() << ", "
262                << "Output data size = "   << field.numElements() << " ] "
263                << "The ouput array does not have not the right size!")
264      this->restoreField_arr(stored, field.dataFirst());
265   }
266
267   template<int N>
268   void CGrid::checkGridMask(CArray<bool,N>& gridMask,
269                             const std::vector<CArray<bool,1>* >& domainMasks,
270                             const std::vector<CArray<bool,1>* >& axisMasks,
271                             const CArray<bool,1>& axisDomainOrder)
272   {
273     int idx = 0;
274     int numElement = axisDomainOrder.numElements();
275     int dim = domainMasks.size() * 2 + axisMasks.size();
276     std::vector<CDomain*> domainP = this->getDomains();
277
278     std::vector<int> idxLoop(dim,0), indexMap(numElement), eachDimSize(dim);
279     std::vector<int> currentIndex(dim);
280     int idxDomain = 0, idxAxis = 0;
281    for (int i = 0; i < numElement; ++i)
282    {
283      indexMap[i] = idx;
284      if (true == axisDomainOrder(i)) {
285          eachDimSize[indexMap[i]]   = domainP[idxDomain]->ni;
286          eachDimSize[indexMap[i]+1] = domainP[idxDomain]->nj;
287          idx += 2; ++idxDomain;
288      }
289      else {
290        eachDimSize[indexMap[i]] = axisMasks[idxAxis]->numElements();
291        ++idx; ++idxAxis;
292      }
293    }
294
295    if (!gridMask.isEmpty())
296    {
297      for (int i = 0; i < dim; ++i)
298      {
299        if (gridMask.extent(i) != eachDimSize[i])
300           ERROR("CGrid::checkMask(void)",
301                <<"The mask has one dimension whose size is different from the one of the local grid"<<endl
302                <<"Local size is "<< i << " " << eachDimSize[i]<<endl
303                <<"Mask dimension size is "<<gridMask.extent(i));
304      }
305    }
306    else {
307        CArrayBoolTraits<CArray<bool,N> >::resizeArray(gridMask,eachDimSize);
308        gridMask = true;
309    }
310
311    int ssize = gridMask.numElements();
312    idx = 0;
313    while (idx < ssize)
314    {
315      for (int i = 0; i < dim-1; ++i)
316      {
317        if (idxLoop[i] == eachDimSize[i])
318        {
319          idxLoop[i] = 0;
320          ++idxLoop[i+1];
321        }
322      }
323
324      // Find out outer index
325      idxDomain = idxAxis = 0;
326      bool maskValue = true;
327      for (int i = 0; i < numElement; ++i)
328      {
329        if (axisDomainOrder(i))
330        {
331          maskValue = maskValue && (*domainMasks[idxDomain])(idxLoop[indexMap[i]] + idxLoop[indexMap[i]+1] * eachDimSize[indexMap[i]]);
332          ++idxDomain;
333        }
334        else
335        {
336          maskValue = maskValue && (*axisMasks[idxAxis])(idxLoop[indexMap[i]]);
337          ++idxAxis;
338        }
339      }
340
341      int maskIndex = idxLoop[0];
342      int mulDim = 1;
343      for (int k = 1; k < dim; ++k)
344      {
345        mulDim *= eachDimSize[k-1];
346        maskIndex += idxLoop[k]*mulDim;
347      }
348      *(gridMask.dataFirst()+maskIndex) &= maskValue;
349
350      ++idxLoop[0];
351      ++idx;
352    }
353
354   }
355
356   /*!
357     Modify the current mask of grid, the local index to be modified will take value false
358     \param [in/out] gridMask current mask of grid
359     \param [in] indexToModify local index to modify
360   */
361   template<int N>
362   void CGrid::modifyGridMask(CArray<bool,N>& gridMask, const CArray<int,1>& indexToModify)
363   {
364     bool valueToModify = false;
365     int num = indexToModify.numElements();
366     for (int idx = 0; idx < num; ++idx)
367     {
368       *(gridMask.dataFirst()+indexToModify(idx)) = valueToModify;
369     }
370   }
371   ///--------------------------------------------------------------
372
373   // Declare/Define CGridGroup and CGridDefinition
374   DECLARE_GROUP(CGrid);
375
376   ///--------------------------------------------------------------
377
378} // namespace xios
379
380#endif // __XIOS_CGrid__
Note: See TracBrowser for help on using the repository browser.