source: XIOS3/trunk/src/node/grid.hpp

Last change on this file was 2632, checked in by ymipsl, 4 weeks ago
  • Recheck grid/domain/axis/scalar after reading grid from file, otherwise some attributes are not taking into account.

YM

  • 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: 17.4 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 "scalar.hpp"
12#include "array_new.hpp"
13#include "attribute_array.hpp"
14#include "distribution_server.hpp"
15#include "client_server_mapping.hpp"
16#include "utils.hpp"
17#include "transformation_enum.hpp"
18#include "grid_local_connector.hpp"
19#include "grid_elements.hpp"
20#include "grid_scatterer_connector.hpp"
21#include "grid_gatherer_connector.hpp"
22#include "transformation_path.hpp"
23#include "filter.hpp"
24#include "grid_algorithm.hpp"
25
26
27namespace xios {
28
29   /// ////////////////////// Declarations ////////////////////// ///
30
31   class CGridGroup;
32   class CGridAttributes;
33   class CDomainGroup;
34   class CAxisGroup;
35   class CScalarGroup;
36   class CGrid;
37   class CDistributionClient;
38   class CDistributionServer;
39   class CServerDistributionDescription;
40   class CClientServerMapping;
41 
42   ///--------------------------------------------------------------
43
44   // Declare/Define CGridAttribute
45   BEGIN_DECLARE_ATTRIBUTE_MAP(CGrid)
46#  include "grid_attribute.conf"
47   END_DECLARE_ATTRIBUTE_MAP(CGrid)
48
49   ///--------------------------------------------------------------
50
51   class CGrid
52      : public CObjectTemplate<CGrid>
53      , public CGridAttributes
54   {
55         /// typedef ///
56         typedef CObjectTemplate<CGrid>   SuperClass;
57         typedef CGridAttributes SuperClassAttribute;
58
59      private:
60       
61        // define a structure to store elements (CDomain, CAxis, CScalar) using a void* and a type to cast the pointer
62         enum EElementType { TYPE_SCALAR, TYPE_AXIS, TYPE_DOMAIN } ;
63         struct SElement {void* ptr ; EElementType type ; CScalar* scalar ;  CAxis* axis ; CDomain* domain ; } ;
64         vector<SElement> elements_ ;
65         bool elementsComputed_ = false ; 
66         /** retrieve the vector of elements as a structure containing a void* and the type of pointer */
67         vector<SElement>& getElements(void) { if (!elementsComputed_) computeElements() ; return elements_ ; } 
68         void computeElements(void) ;
69         /** List order of axis and domain in a grid, if there is a domain, it will take value 2, axis 1, scalar 0 */
70         std::vector<int> order_;
71
72      public:
73
74         typedef CGridAttributes RelAttributes;
75         typedef CGridGroup      RelGroup;
76
77         enum EEventId
78         {
79           EVENT_ID_COLLECTIVE=100,
80           EVENT_ID_ADD_DOMAIN, EVENT_ID_ADD_AXIS, EVENT_ID_ADD_SCALAR,
81           EVENT_ID_SEND_MASK,
82           EVENT_ID_NO_COLLECTIVE=1000,
83
84         };
85
86         /// Constructeurs ///
87         CGrid(void);
88         explicit CGrid(const StdString& id);
89         CGrid(const CGrid& grid);       // Not implemented yet.
90         CGrid(const CGrid* const grid); // Not implemented yet.
91
92         /// Traitements ///
93//         void solveReference(void);
94
95         void checkEligibilityForCompressedOutput();
96         
97
98
99         void checkMaskIndex(bool doCalculateIndex);
100
101 //        virtual void toBinary  (StdOStream& os) const;
102//         virtual void fromBinary(StdIStream& is);
103
104         void addRelFileCompressed(const StdString& filename);
105
106         /// Tests ///
107         bool isCompressible(void) const;
108         bool isWrittenCompressed(const StdString& filename) const;
109
110      public:
111
112         /// Accesseurs ///
113         StdSize getDimension(void);
114
115         StdSize  getDataSize(void) ;
116
117         /**
118          * Get the local data grid size, ie the size of the compressed grid (inside the workflow)
119          * \return The size od the compressed grid
120          */
121         StdSize  getLocalDataSize(void) ;
122
123 
124         virtual void parse(xml::CXMLNode& node);
125
126         /// Destructeur ///
127         virtual ~CGrid(void);
128
129      public:
130
131         /// Accesseurs statiques ///
132         static StdString GetName(void);
133         static StdString GetDefName(void);
134
135         static ENodeType GetType(void);
136
137         /// Instanciateurs Statiques ///
138         static CGrid* createGrid(CDomain* domain);
139         static CGrid* createGrid(CDomain* domain, CAxis* axis);
140         static CGrid* createGrid(const std::vector<CDomain*>& domains, const std::vector<CAxis*>& axis,
141                                  const CArray<int,1>& axisDomainOrder = CArray<int,1>());
142         static CGrid* createGrid(StdString id, const std::vector<CDomain*>& domains, const std::vector<CAxis*>& axis,
143                                  const std::vector<CScalar*>& scalars, const CArray<int,1>& axisDomainOrder = CArray<int,1>());
144         static CGrid* createGrid(const std::vector<CDomain*>& domains, const std::vector<CAxis*>& axis,
145                                  const std::vector<CScalar*>& scalars, const CArray<int,1>& axisDomainOrder);
146         static CGrid* get(const string& id, bool noError=false) ; //<! return grid pointer using id
147         static bool has(const string& id) ; //<! return if grid exist using id
148         static CField* getFieldFromId(const string& id) ; //<! return field id if used in grid reference
149         static StdString generateId(const std::vector<CDomain*>& domains, const std::vector<CAxis*>& axis,
150                                     const std::vector<CScalar*>& scalars, const CArray<int,1>& axisDomainOrder = CArray<int,1>());
151         static StdString generateId(const CGrid* gridSrc, const CGrid* gridDest);
152         static CGrid* cloneGrid(const StdString& idNewGrid, CGrid* gridSrc);
153
154         CDomain* getAssociatedDomain(const string& domainId, bool noError=false) ;
155         CAxis*   getAssociatedAxis(const string& axisId, bool noError=false) ;
156         CScalar* getAssociatedScalar(const string& scalarId, bool noError=false) ;
157      public:           
158         void solveDomainAxisRef(bool areAttributesChecked);
159         void checkElementsAttributes(bool recheck=false) ;
160
161         void solveDomainRef(bool checkAtt);
162         void solveAxisRef(bool checkAtt);
163         void solveScalarRef(bool checkAtt);
164         void solveElementsRefInheritance(bool apply = true);
165         bool activateFieldWorkflow(CGarbageCollector& gc) ;
166        // void solveTransformations();
167         void solveDomainAxisBaseRef();
168
169         CDomain* addDomain(const std::string& id=StdString());
170         CAxis* addAxis(const std::string& id=StdString());
171         CScalar* addScalar(const std::string& id=StdString());
172
173      public:
174         void sendGridToFileServer(CContextClient* client, bool inOut) ;
175      private:
176         std::set<CContextClient*> sendGridToFileServer_done_ ;
177     
178      public:
179         void sendGridToCouplerOut(CContextClient* client, const string& fieldId) ;
180      private:
181         std::set<CContextClient*> sendGridToCouplerOut_done_ ;
182
183      public:
184         void makeAliasForCoupling(const string& fieldId) ;
185         string getCouplingAlias(const string& fieldId) ;
186
187      public:
188         void sendAddDomain(const std::string& id,CContextClient* contextClient);
189         void sendAddAxis(const std::string& id,CContextClient* contextClient);
190         void sendAddScalar(const std::string& id,CContextClient* contextClient);
191       
192         static void recvAddDomain(CEventServer& event);
193         void recvAddDomain(CBufferIn& buffer);
194         static void recvAddAxis(CEventServer& event);
195         void recvAddAxis(CBufferIn& buffer);
196         static void recvAddScalar(CEventServer& event);
197         void recvAddScalar(CBufferIn& buffer);
198
199         static bool dispatchEvent(CEventServer& event);
200       
201       public:
202         void setContextClient(CContextClient* contextClient);
203
204         std::map<int, StdSize> getAttributesBufferSize(CContextClient* client, bool bufferForWriting = false);
205         std::map<int, StdSize> getDataBufferSize(CContextClient* client, const std::string& id = "", bool bufferForWriting = false);
206         std::vector<StdString> getDomainList();
207         std::vector<StdString> getAxisList();
208         std::vector<StdString> getScalarList();
209         std::vector<CDomain*> getDomains();
210         std::vector<CAxis*> getAxis();
211         std::vector<CScalar*> getScalars();
212         CDomain* getDomain(int domainIndex);
213         CAxis* getAxis(int axisIndex);
214         CScalar* getScalar(int scalarIndex);
215         std::vector<int> getAxisOrder();
216         std::vector<int> getGlobalDimension();
217         bool isScalarGrid() const;         
218
219         bool doGridHaveDataToWrite();
220         bool doGridHaveDataDistributed(CContextClient* client = 0);
221
222         ///////////////////////////////////////////
223         ////////    TRANSFORMATIONS           /////
224         ///////////////////////////////////////////
225      public:
226         pair<shared_ptr<CFilter>, shared_ptr<CFilter> > buildTransformationGraph(CGarbageCollector& gc, bool isSource, CGrid* gridSrc, double detectMissingValues,
227                                                                                  double defaultValue, CGrid*& newGrid, bool graphEnabled=false, CField* field=0) ;
228      private:
229        shared_ptr<CGridAlgorithm> gridAlgorithm_ = nullptr ;
230      public:
231        void setGridAlgorithm(shared_ptr<CGridAlgorithm> gridAlgorithm) {gridAlgorithm_ = gridAlgorithm;}
232        shared_ptr<CGridAlgorithm> getGridAlgorithm(void) { return gridAlgorithm_ ;}
233       
234        ///////////////////////////////////////////
235      public:
236
237        size_t getGlobalWrittenSize(void) ;
238         
239         bool isCompleted(void) ;
240         void setCompleted(void) ;
241         void unsetCompleted(void) ;
242
243
244         bool hasMask(void) const;
245        /** get mask pointer stored in mask_1d, or mask_2d, or..., or mask_7d */
246         CArray<bool,1> mask_ ;
247         CArray<bool,1>& getMask(void) ;
248
249      private:
250        /** Client-like distribution calculated based on the knowledge of the entire grid */
251       CDistributionClient* clientDistribution_;
252     public: 
253       void computeClientDistribution(void) ;
254     private:
255       bool computeClientDistribution_done_ = false ;
256     public:
257       CDistributionClient* getClientDistribution(void); 
258
259     private:   
260        void setVirtualDomainGroup(CDomainGroup* newVDomainGroup);
261        void setVirtualAxisGroup(CAxisGroup* newVAxisGroup);
262        void setVirtualScalarGroup(CScalarGroup* newVScalarGroup);
263
264        void setDomainList(const std::vector<CDomain*> domains = std::vector<CDomain*>());
265        void setAxisList(const std::vector<CAxis*> axis = std::vector<CAxis*>());
266        void setScalarList(const std::vector<CScalar*> scalars = std::vector<CScalar*>());
267
268        CDomainGroup* getVirtualDomainGroup() const;
269        CAxisGroup* getVirtualAxisGroup() const;
270        CScalarGroup* getVirtualScalarGroup() const;
271
272        int computeGridGlobalDimension(std::vector<int>& globalDim,
273                                       const std::vector<CDomain*> domains,
274                                       const std::vector<CAxis*> axis,
275                                       const std::vector<CScalar*> scalars,
276                                       const CArray<int,1>& axisDomainOrder);
277        int getDistributedDimension();
278      public:
279
280        bool isDataDistributed(void) ; 
281
282      private:
283        bool isChecked;
284        bool isDomainAxisChecked;
285        bool isIndexSent;
286
287        CDomainGroup* vDomainGroup_;
288        CAxisGroup* vAxisGroup_;
289        CScalarGroup* vScalarGroup_;
290        std::vector<std::string> axisList_, domList_, scalarList_;
291        bool isAxisListSet, isDomListSet, isScalarListSet;
292
293/** Map storing local ranks of connected receivers. Key = size of receiver's intracomm.
294  * It is calculated in computeConnectedClients(). */
295        std::map<int, std::vector<int> > connectedServerRank_;
296
297/** Map storing the size of data to be send. Key = size of receiver's intracomm
298  * It is calculated in computeConnectedClients(). */
299        std::map<int, std::map<int,size_t> > connectedDataSize_;
300
301/** Ranks of connected receivers in case of reading. It is calculated in recvIndex(). */
302        std::vector<int> connectedServerRankRead_;
303
304/** Size of data to be send in case of reading. It is calculated in recvIndex(). */
305        std::map<int,size_t> connectedDataSizeRead_;
306     
307         //! True if and only if the data defined on the grid can be outputted in a compressed way
308        bool isCompressible_;
309        std::set<std::string> relFilesCompressed;
310
311       
312        std::vector<int> axisPositionInGrid_;
313        void computeAxisPositionInGrid(void) ;
314        bool computeAxisPositionInGrid_done_ = false ;
315        std::vector<int>& getAxisPositionInGrid(void) { if (!computeAxisPositionInGrid_done_) computeAxisPositionInGrid() ; return axisPositionInGrid_ ;}
316
317        bool hasDomainAxisBaseRef_;       
318        std::map<CGrid*, std::pair<bool,StdString> > gridSrc_;
319
320     //////////////////////////////////////////////////////////////////////////////////////
321     //  this part is related to distribution, element definition, views and connectors  //
322     //////////////////////////////////////////////////////////////////////////////////////
323      public:
324        CGrid* redistributeGridToWriter(void) ;
325      public:
326       CGrid* duplicateSentGrid(void) ;
327      private:
328       static void recvMask(CEventServer& event) ;
329       void receiveMask(CEventServer& event) ;
330
331      private: 
332       shared_ptr<CGridLocalElements> gridLocalElements_= nullptr ;
333        void computeGridLocalElements(void) ;
334      public:
335        shared_ptr<CGridLocalElements> getGridLocalElements(void) { if (gridLocalElements_==nullptr) computeGridLocalElements() ; return gridLocalElements_ ;}
336
337      private:
338        shared_ptr<CGridLocalConnector> modelToWorkflowConnector_ = nullptr ;
339      public:
340        void computeModelToWorkflowConnector(void) ;
341        shared_ptr<CGridLocalConnector> getModelToWorkflowConnector(void) { if (modelToWorkflowConnector_==nullptr) computeModelToWorkflowConnector() ; return modelToWorkflowConnector_;}
342
343      private:
344        shared_ptr<CGridLocalConnector> workflowToModelConnector_ = nullptr;
345      public:
346        void computeWorkflowToModelConnector(void) ;
347        shared_ptr<CGridLocalConnector> getWorkflowToModelConnector(void) { if (workflowToModelConnector_==nullptr) computeWorkflowToModelConnector() ; return workflowToModelConnector_;}
348
349      public: //?
350        void distributeGridToServer(CContextClient* client, bool inOut, const string& fieldId="");
351     
352           
353      private:
354        shared_ptr<CGridLocalConnector> workflowToFullConnector_ = nullptr;
355      public:
356        void computeWorkflowToFullConnector(void) ;
357        shared_ptr<CGridLocalConnector> getWorkflowToFullConnector(void) { if (workflowToFullConnector_==nullptr) computeWorkflowToFullConnector() ; return workflowToFullConnector_;}
358
359      private:
360        shared_ptr<CGridLocalConnector> fullToWorkflowConnector_ = nullptr;
361      public:
362        void computeFullToWorkflowConnector(void) ;
363        shared_ptr<CGridLocalConnector> getFullToWorkflowConnector(void) { if (fullToWorkflowConnector_==nullptr) computeFullToWorkflowConnector() ; return fullToWorkflowConnector_;}
364
365   
366
367      private:
368         shared_ptr<CGridGathererConnector> clientFromClientConnector_ = nullptr ;
369      public:
370         shared_ptr<CGridGathererConnector> getClientFromClientConnector(void) { if (clientFromClientConnector_==nullptr) computeClientFromClientConnector() ; return clientFromClientConnector_;}
371         void computeClientFromClientConnector(void) ;
372
373      private:
374         map<CContextClient*, shared_ptr<CGridScattererConnector>> clientToClientConnector_ ;
375      public:
376         shared_ptr<CGridScattererConnector> getClientToClientConnector(CContextClient* client) { return clientToClientConnector_[client] ;} // make some test to see if connector exits for the given client
377 
378
379      private:
380         map<CContextClient*,shared_ptr<CGridGathererConnector>> clientFromServerConnector_  ;
381      public:
382         shared_ptr<CGridGathererConnector> getClientFromServerConnector(CContextClient* client) { return clientFromServerConnector_[client];}
383         void computeClientFromServerConnector(void) ;
384
385      private:
386         shared_ptr<CGridScattererConnector> serverToClientConnector_=nullptr ;
387      public:
388         shared_ptr<CGridScattererConnector> getServerToClientConnector(void) { if (serverToClientConnector_==nullptr) computeServerToClientConnector() ; return serverToClientConnector_;}
389         void computeServerToClientConnector(void) ;
390      private:
391         map<CContextClient*, shared_ptr<CGridScattererConnector>> clientToServerConnector_ ;
392      public:
393         shared_ptr<CGridScattererConnector> getClientToServerConnector(CContextClient* client) { return clientToServerConnector_[client] ;} // make some test to see if connector exits for the given client
394         
395      private:
396         shared_ptr<CGridGathererConnector> serverFromClientConnector_ = nullptr ;
397      public:
398         shared_ptr<CGridGathererConnector> getServerFromClientConnector(void) { if (serverFromClientConnector_==nullptr) computeServerFromClientConnector() ; return serverFromClientConnector_;}
399         void computeServerFromClientConnector(void) ;
400
401      private:
402         shared_ptr<CGridTransformConnector> redistributeToWriterConnector_ = nullptr ;
403      public:
404         shared_ptr<CGridTransformConnector> getRedistributeToWriterConnector(CGrid* gridSrc) { if (redistributeToWriterConnector_==nullptr) computeRedistributeToWriterConnector(gridSrc) ; return redistributeToWriterConnector_;}
405         void computeRedistributeToWriterConnector(CGrid* gridSrc) ;
406
407
408   }; // class CGrid
409
410   // Declare/Define CGridGroup and CGridDefinition
411   DECLARE_GROUP(CGrid);
412
413   ///--------------------------------------------------------------
414
415} // namespace xios
416
417#endif // __XIOS_CGrid__
Note: See TracBrowser for help on using the repository browser.