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

Last change on this file since 676 was 676, checked in by rlacroix, 6 years ago

Add support for indexed output.

If the new field attribute "indexed_output" is set to true and a mask is defined (either at grid, domain or axis level), the indexed data will be outputed instead of the full data with missing values.

See http://cfconventions.org/Data/cf-conventions/cf-conventions-1.5/build/cf-conventions.html#compression-by-gathering for more information.

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