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

Last change on this file since 593 was 593, checked in by rlacroix, 7 years ago

Add a new interface xios_recv_field to get local instant data from a field.

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