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

Last change on this file since 584 was 584, checked in by mhnguyen, 9 years ago

Implementing new hash algorithm and fixing bug related to zoom

+) Replace boost hash with hash algorithm of Jenkins
+) Domain, if an attribute is non-empty for one client, it should also be non-empty for others inspite of zoom
+) Replace the way to find the number of client connecting to a server to make sure every server receive a message

Test
+) On Curie
+) test_client: passed and results are same like before
+) test_complete: passed, results are partially the same, the different part comes from added working operation

  • 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.2 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        std::map<int,size_t> connectedDataSize_;
226        std::vector<int> connectedServerRank_;
227   }; // class CGrid
228
229   ///--------------------------------------------------------------
230
231   template <int n>
232   void CGrid::inputField(const CArray<double,n>& field, CArray<double,1>& stored) const
233   {
234      if (this->getDataSize() != field.numElements())
235         ERROR("void CGrid::inputField(const  CArray<double,n>& field, CArray<double,1>& stored) const",
236                << "[ Awaiting size of the data = " << this->getDataSize()       << ", "
237                << "Received data size = "      << field.numElements() << " ] "
238                << "The array of data has not the good size !")
239      this->storeField_arr(field.dataFirst(), stored) ;
240   }
241
242   template<int N>
243   void CGrid::checkGridMask(CArray<bool,N>& gridMask,
244                             const std::vector<CArray<bool,2>* >& domainMasks,
245                             const std::vector<CArray<bool,1>* >& axisMasks,
246                             const CArray<bool,1>& axisDomainOrder)
247   {
248     int idx = 0;
249     int numElement = axisDomainOrder.numElements();
250     int dim = domainMasks.size()*2 + axisMasks.size();
251
252     std::vector<int> idxLoop(dim,0), indexMap(numElement), eachDimSize(dim);
253     std::vector<int> currentIndex(dim);
254     int idxDomain = 0, idxAxis = 0;
255    for (int i = 0; i < numElement; ++i)
256    {
257      indexMap[i] = idx;
258      if (true == axisDomainOrder(i)) {
259          eachDimSize[indexMap[i]]   = domainMasks[idxDomain]->extent(0);
260          eachDimSize[indexMap[i]+1] = domainMasks[idxDomain]->extent(1);
261          idx += 2; ++idxDomain;
262      }
263      else {
264        eachDimSize[indexMap[i]] = axisMasks[idxAxis]->numElements();
265        ++idx; ++idxAxis;
266      }
267    }
268
269    if (!gridMask.isEmpty())
270    {
271      for (int i = 0; i < dim; ++i)
272      {
273        if (gridMask.extent(i) != eachDimSize[i])
274           ERROR("CGrid::checkMask(void)",
275                <<"The mask has one dimension whose size is different from the one of the local grid"<<endl
276                <<"Local size is "<< i << " " << eachDimSize[i]<<endl
277                <<"Mask dimension size is "<<gridMask.extent(i));
278      }
279    }
280    else {
281        CArrayBoolTraits<CArray<bool,N> >::resizeArray(gridMask,eachDimSize);
282        gridMask = true;
283    }
284
285    int ssize = gridMask.numElements();
286    idx = 0;
287    while (idx < ssize)
288    {
289      for (int i = 0; i < dim-1; ++i)
290      {
291        if (idxLoop[i] == eachDimSize[i])
292        {
293          idxLoop[i] = 0;
294          ++idxLoop[i+1];
295        }
296      }
297
298      // Find out outer index
299      idxDomain = idxAxis = 0;
300      bool maskValue = true;
301      for (int i = 0; i < numElement; ++i)
302      {
303        if (axisDomainOrder(i))
304        {
305          maskValue = maskValue && (*domainMasks[idxDomain])(idxLoop[indexMap[i]],
306                                                          idxLoop[indexMap[i]+1]);
307          ++idxDomain;
308        }
309        else
310        {
311          maskValue = maskValue && (*axisMasks[idxAxis])(idxLoop[indexMap[i]]);
312          ++idxAxis;
313        }
314      }
315
316      int maskIndex = idxLoop[0];
317      int mulDim = 1;
318      for (int k = 1; k < dim; ++k)
319      {
320        mulDim *= eachDimSize[k-1];
321        maskIndex += idxLoop[k]*mulDim;
322      }
323      *(gridMask.dataFirst()+maskIndex) = maskValue;
324
325      ++idxLoop[0];
326      ++idx;
327    }
328
329   }
330
331   ///--------------------------------------------------------------
332
333   // Declare/Define CGridGroup and CGridDefinition
334   DECLARE_GROUP(CGrid);
335
336   ///--------------------------------------------------------------
337
338} // namespace xios
339
340#endif // __XMLIO_CGrid__
Note: See TracBrowser for help on using the repository browser.