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

Last change on this file since 568 was 568, checked in by mhnguyen, 7 years ago

Implementing discovering algorithm of server index

+) Implement the algorithm with only one level
+) Remove some redundant functions, corrects some interface

Test
+) On Curie
+) Test passed and results 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
File size: 11.1 KB
Line 
1#ifndef __XMLIO_CGrid__
2#define __XMLIO_CGrid__
3
4/// xios headers ///
5#include "xmlioserver_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_client.hpp"
14#include "distribution_server.hpp"
15#include "server_distribution_description.hpp"
16#include "client_server_mapping.hpp"
17#include "utils.hpp"
18
19namespace xios {
20
21   /// ////////////////////// Déclarations ////////////////////// ///
22
23   class CGridGroup;
24   class CGridAttributes;
25   class CDomainGroup;
26   class CAxisGroup;
27   class CGrid;
28   class CDistributionClient;
29   class CDistributionServer;
30   class CServerDistributionDescription;
31   class CClientServerMapping;
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         /// Constructeurs ///
61         CGrid(void);
62         explicit CGrid(const StdString & id);
63         CGrid(const CGrid & grid);       // Not implemented yet.
64         CGrid(const CGrid * const grid); // Not implemented yet.
65
66         /// Traitements ///
67//         void solveReference(void);
68
69         void solveDomainAxisRef(bool areAttributesChecked);
70
71         void checkMaskIndex(bool doCalculateIndex);
72
73 //        virtual void toBinary  (StdOStream & os) const;
74//         virtual void fromBinary(StdIStream & is);
75
76         /// Tests ///
77         bool hasAxis(void) const;
78
79      public :
80
81         /// Accesseurs ///
82         const std::deque< CArray<int, 1>* > & getStoreIndex(void) const;
83         const std::deque< CArray<int, 1>* > & getOutIIndex(void)  const;
84         const std::deque< CArray<int, 1>* > & getOutJIndex(void)  const;
85         const std::deque< CArray<int, 1>* > & getOutLIndex(void)  const;
86
87         const CAxis*   getRelAxis  (void) const;
88         const CDomain* getRelDomain(void) const;
89
90         StdSize getDimension(void) const;
91
92//         StdSize getLocalSize(void) const;
93//         StdSize getGlobalSize(void) const;
94         StdSize  getDataSize(void) const;
95//         std::vector<StdSize> getLocalShape(void) const;
96//         std::vector<StdSize> getGlobalShape(void) const;
97
98         /// Entrées-sorties de champs ///
99         template <int n>
100            void inputField(const CArray<double,n>& field, CArray<double,1>& stored) const;
101
102         void inputFieldServer(const std::deque< CArray<double, 1>* > storedClient,
103                               CArray<double, 1>&  storedServer) const;
104
105         void outputField(int rank, const CArray<double,1>& stored,  CArray<double,3>& field)  ;
106         void outputField(int rank, const CArray<double,1>& stored,  CArray<double,2>& field)  ;
107         void outputField(int rank, const CArray<double,1>& stored,  CArray<double,1>& field)  ;
108         void outputField(int rank, const CArray<double,1>& stored,  double* field);
109
110         virtual void parse(xml::CXMLNode & node);
111
112         /// Destructeur ///
113         virtual ~CGrid(void);
114
115      public :
116
117         /// Accesseurs statiques ///
118         static StdString GetName(void);
119         static StdString GetDefName(void);
120
121         static ENodeType GetType(void);
122
123         /// Instanciateurs Statiques ///
124         static CGrid* createGrid(CDomain* domain);
125         static CGrid* createGrid(CDomain* domain, CAxis* axis);
126         static CGrid* createGrid(std::vector<CDomain*> domains, std::vector<CAxis*> axis);
127
128      public :
129
130         /// Entrées-sorties de champs (interne) ///
131         void storeField_arr(const double * const data, CArray<double,1>& stored) const;
132
133         /// Traitements protégés ///
134         void computeIndexServer(void);
135         void computeIndex(void);
136
137         void solveDomainRef(bool checkAtt);
138         void solveAxisRef(bool checkAtt);
139         void solveDomainAxisRefInheritance(bool apply = true);
140
141         void sendAddDomain(const std::string& id="");
142         void sendAddAxis(const std::string& id="");
143         void sendAllDomains();
144         void sendAllAxis();
145
146         static void recvAddDomain(CEventServer& event) ;
147         void recvAddDomain(CBufferIn& buffer) ;
148         static void recvAddAxis(CEventServer& event) ;
149         void recvAddAxis(CBufferIn& buffer) ;
150
151         static bool dispatchEvent(CEventServer& event) ;
152         void outputFieldToServer(CArray<double,1>& fieldIn, int rank, CArray<double,1>& fieldOut) ;
153         static void recvIndex(CEventServer& event) ;
154         void recvIndex(int rank, CBufferIn& buffer) ;
155         void sendIndex(void) ;
156
157         void computeDomConServer();
158         std::map<int, int> getDomConServerSide();
159         std::map<int, StdSize> getConnectedServerDataSize();
160         std::vector<StdString> getDomainList();
161         std::vector<StdString> getAxisList();
162         std::vector<CDomain*> getDomains();
163         std::vector<CAxis*> getAxis();
164         std::vector<int> getAxisOrder();
165         std::vector<int> getGlobalDimension();
166
167         bool doGridHaveDataToWrite();
168         bool doGridHaveDataDistributed();
169         size_t getWrittenDataSize() const;
170
171         const CDistributionServer* getDistributionServer() const;
172
173      public:
174
175         /// Propriétés privées ///
176         bool isChecked;
177         bool isDomainAxisChecked;
178         bool isIndexSent;
179
180         std::deque< CArray<int, 1>* > storeIndex ;
181        CArray<int, 1>  storeIndex_client ;
182
183
184         map<int, CArray<int, 1>* >  storeIndex_toSrv ;
185         map<int,int> nbSenders ;
186
187         map<int, CArray<size_t, 1>* > outIndexFromClient;
188         void checkMask(void) ;
189
190      private:
191       template<int N>
192       void checkGridMask(CArray<bool,N>& gridMask,
193                          const std::vector<CArray<bool,2>* >& domainMasks,
194                          const std::vector<CArray<bool,1>* >& axisMasks,
195                          const CArray<bool,1>& axisDomainOrder);
196        void setVirtualDomainGroup(CDomainGroup* newVDomainGroup);
197        void setVirtualDomainGroup();
198        void setVirtualAxisGroup(CAxisGroup* newVAxisGroup);
199        void setVirtualAxisGroup();
200
201        void setAxisList(const std::vector<CAxis*> axis = std::vector<CAxis*>());
202        void setDomainList(const std::vector<CDomain*> domains = std::vector<CDomain*>());
203
204        void computeGridGlobalDimension(const std::vector<CDomain*>& domains,
205                                        const std::vector<CAxis*>& axis,
206                                        const CArray<bool,1>& axisDomainOrder);
207
208        CDomain* addDomain(const std::string& id);
209        CAxis* addAxis(const std::string& id);
210
211        CAxisGroup* getVirtualAxisGroup() const;
212        CDomainGroup* getVirtualDomainGroup() const;
213        std::vector<int> globalDim_;
214      private:
215        CDomainGroup* vDomainGroup_;
216        CAxisGroup* vAxisGroup_;
217        std::vector<std::string> axisList_, domList_;
218        bool isAxisListSet, isDomListSet;
219
220        CDistributionClient* clientDistribution_;
221        CDistributionServer* serverDistribution_;
222        CServerDistributionDescription* serverDistributionDescription_;
223        CClientServerMapping* clientServerMap_;
224        size_t writtenDataSize_;
225   }; // class CGrid
226
227   ///--------------------------------------------------------------
228
229   template <int n>
230   void CGrid::inputField(const CArray<double,n>& field, CArray<double,1>& stored) const
231   {
232      if (this->getDataSize() != field.numElements())
233         ERROR("void CGrid::inputField(const  CArray<double,n>& field, CArray<double,1>& stored) const",
234                << "[ Awaiting size of the data = " << this->getDataSize()       << ", "
235                << "Received data size = "      << field.numElements() << " ] "
236                << "The array of data has not the good size !")
237      this->storeField_arr(field.dataFirst(), stored) ;
238   }
239
240   template<int N>
241   void CGrid::checkGridMask(CArray<bool,N>& gridMask,
242                             const std::vector<CArray<bool,2>* >& domainMasks,
243                             const std::vector<CArray<bool,1>* >& axisMasks,
244                             const CArray<bool,1>& axisDomainOrder)
245   {
246     int idx = 0;
247     int numElement = axisDomainOrder.numElements();
248     int dim = domainMasks.size()*2 + axisMasks.size();
249
250     std::vector<int> idxLoop(dim,0), indexMap(numElement), eachDimSize(dim);
251     std::vector<int> currentIndex(dim);
252     int idxDomain = 0, idxAxis = 0;
253    for (int i = 0; i < numElement; ++i)
254    {
255      indexMap[i] = idx;
256      if (true == axisDomainOrder(i)) {
257          eachDimSize[indexMap[i]]   = domainMasks[idxDomain]->extent(0);
258          eachDimSize[indexMap[i]+1] = domainMasks[idxDomain]->extent(1);
259          idx += 2; ++idxDomain;
260      }
261      else {
262        eachDimSize[indexMap[i]] = axisMasks[idxAxis]->numElements();
263        ++idx; ++idxAxis;
264      }
265    }
266
267    if (!gridMask.isEmpty())
268    {
269      for (int i = 0; i < dim; ++i)
270      {
271        if (gridMask.extent(i) != eachDimSize[i])
272           ERROR("CGrid::checkMask(void)",
273                <<"The mask has one dimension whose size is different from the one of the local grid"<<endl
274                <<"Local size is "<< i << " " << eachDimSize[i]<<endl
275                <<"Mask dimension size is "<<gridMask.extent(i));
276      }
277    }
278    else {
279        CArrayBoolTraits<CArray<bool,N> >::resizeArray(gridMask,eachDimSize);
280        gridMask = true;
281    }
282
283    int ssize = gridMask.numElements();
284    idx = 0;
285    while (idx < ssize)
286    {
287      for (int i = 0; i < dim-1; ++i)
288      {
289        if (idxLoop[i] == eachDimSize[i])
290        {
291          idxLoop[i] = 0;
292          ++idxLoop[i+1];
293        }
294      }
295
296      // Find out outer index
297      idxDomain = idxAxis = 0;
298      bool maskValue = true;
299      for (int i = 0; i < numElement; ++i)
300      {
301        if (axisDomainOrder(i))
302        {
303          maskValue = maskValue && (*domainMasks[idxDomain])(idxLoop[indexMap[i]],
304                                                          idxLoop[indexMap[i]+1]);
305          ++idxDomain;
306        }
307        else
308        {
309          maskValue = maskValue && (*axisMasks[idxAxis])(idxLoop[indexMap[i]]);
310          ++idxAxis;
311        }
312      }
313
314      int maskIndex = idxLoop[0];
315      int mulDim = 1;
316      for (int k = 1; k < dim; ++k)
317      {
318        mulDim *= eachDimSize[k-1];
319        maskIndex += idxLoop[k]*mulDim;
320      }
321      *(gridMask.dataFirst()+maskIndex) = maskValue;
322
323      ++idxLoop[0];
324      ++idx;
325    }
326
327   }
328
329   ///--------------------------------------------------------------
330
331   // Declare/Define CGridGroup and CGridDefinition
332   DECLARE_GROUP(CGrid);
333
334   ///--------------------------------------------------------------
335
336} // namespace xios
337
338#endif // __XMLIO_CGrid__
Note: See TracBrowser for help on using the repository browser.