source: XIOS3/trunk/src/node/axis.hpp @ 2386

Last change on this file since 2386 was 2386, checked in by jderouillat, 2 years ago

Set the code structure to compute the hash value of an element based on its attributs, use for now before writing an element in a file

  • 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: 12.4 KB
Line 
1#ifndef __XIOS_CAxis__
2#define __XIOS_CAxis__
3
4/// XIOS headers ///
5#include "xios_spl.hpp"
6#include "group_factory.hpp"
7#include "virtual_node.hpp"
8
9#include "declare_group.hpp"
10#include "declare_ref_func.hpp"
11#include "declare_virtual_node.hpp"
12#include "attribute_array.hpp"
13#include "attribute_enum.hpp"
14#include "attribute_enum_impl.hpp"
15#include "server_distribution_description.hpp"
16#include "transformation.hpp"
17#include "transformation_enum.hpp"
18#include "transformation_path.hpp"
19#include "element.hpp"
20#include "local_connector.hpp"
21#include "scatterer_connector.hpp"
22#include "gatherer_connector.hpp"
23#include "distribution_type.hpp"
24#include "generic_algorithm_transformation.hpp"
25#include "grid_transformation_factory_impl.hpp"
26
27
28namespace xios
29{
30   /// ////////////////////// Déclarations ////////////////////// ///
31
32   class CAxisGroup;
33   class CAxisAttributes;
34   class CAxis;
35   class CField;
36
37   ///--------------------------------------------------------------
38
39   // Declare/Define CAxisAttribute
40   BEGIN_DECLARE_ATTRIBUTE_MAP(CAxis)
41#  include "axis_attribute.conf"
42   END_DECLARE_ATTRIBUTE_MAP(CAxis)
43
44   ///--------------------------------------------------------------
45
46   class CAxis
47      : public CObjectTemplate<CAxis>
48      , public CAxisAttributes
49   {
50               /// typedef ///
51         typedef CObjectTemplate<CAxis>   SuperClass;
52         typedef CAxisAttributes SuperClassAttribute;
53         
54      public:
55         enum EEventId
56         {
57           EVENT_ID_COLLECTIVE=100,
58           EVENT_ID_AXIS_DISTRIBUTION,
59           EVENT_ID_SEND_DISTRIBUTED_ATTRIBUTE,
60           EVENT_ID_NO_COLLECTIVE=1000,
61         } ;
62
63      public:
64         typedef CAxisAttributes RelAttributes;
65         typedef CAxisGroup      RelGroup;
66
67      public:
68         /// Constructeurs ///
69         CAxis(void);
70         explicit CAxis(const StdString & id);
71         CAxis(const CAxis & axis);       // Not implemented yet.
72         CAxis(const CAxis * const axis); // Not implemented yet.
73         static void releaseStaticAllocation(void) ; // release static allocation on heap
74
75         static CAxis* createAxis();
76         static CAxis* get(const string& id, bool noError=false) ; //<! return axis pointer using id
77         static bool has(const string& id) ; //<! return domain pointer using id
78         static CField*  getFieldFromId(const string& id) ;
79
80         /// Accesseurs ///
81         const std::set<StdString> & getRelFiles(void) const;
82 
83         std::map<int, StdSize> getAttributesBufferSize(CContextClient* client, const std::vector<int>& globalDim, int orderPositionInGrid,
84                                                        CServerDistributionDescription::ServerDistributionType disType = CServerDistributionDescription::BAND_DISTRIBUTION);
85
86         /// Test ///
87         bool IsWritten(const StdString & filename) const;
88         bool isWrittenCompressed(const StdString& filename) const;
89         bool isDistributed(void) const;
90       
91      public:
92        /*!
93            \brief return if the axis can be written or not in a compressed way.
94            ie if there are some masked or indexed point on the domain. Valid only on server side.
95            \return true if domain can be writtedn in a compressed way
96         */ 
97         bool isCompressible(void) { if (!isCompressibleComputed_) computeIsCompressible() ; return isCompressible_ ;} 
98      private:
99         bool isCompressible_ ; /** specify if the domain can be written in a compressed way */ 
100         bool isCompressibleComputed_=false ; /** Indicate if compressability has been computed*/
101         void computeIsCompressible() ;
102       
103      public:
104
105         /// Mutateur ///
106         void addRelFile(const StdString & filename);
107         void addRelFileCompressed(const StdString& filename);
108
109         
110
111         /// Destructeur ///
112         virtual ~CAxis(void);
113
114         virtual void parse(xml::CXMLNode & node);
115
116         void setContextClient(CContextClient* contextClient);
117
118         /// Accesseurs statiques ///
119         static StdString GetName(void);
120         static StdString GetDefName(void);
121         static ENodeType GetType(void);
122
123         static bool dispatchEvent(CEventServer& event);         
124       
125         /// Vérifications ///
126         void checkAttributes(void);
127         bool checkAttributes_done_ = false ;
128         bool checkGeometricAttributes(bool generateError) ; 
129         void setGeometricAttributes(const CAxis& axisSrc) ;
130         void resetGeometricAttributes(void) ;
131
132         int computeAttributesHash( MPI_Comm comm );
133
134         size_t getGlobalWrittenSize(void) ;
135
136      //////////////////////////
137      ///// transformations ////
138      //////////////////////////
139      public:
140        typedef CTransformation<CAxis>::TransformationMapTypes TransMapTypes;
141      private:
142        static bool initializeTransformationMap(std::map<StdString, ETranformationType>& m);
143        static std::map<StdString, ETranformationType> transformationMapList_;
144        static bool dummyTransformationMapList_;
145        TransMapTypes transformationMap_;         
146
147      public:
148        CTransformation<CAxis>* addTransformation(ETranformationType transType, const StdString& id="");
149        CTransformation<CAxis>* addTransformation(ETranformationType transType, CTransformation<CAxis>* transformation) ;
150        void setTransformations(const TransMapTypes&);         
151        void duplicateTransformation(CAxis*);
152        TransMapTypes getAllTransformations();
153        bool hasTransformation();
154        void solveInheritanceTransformation_old(); // to remove later
155        void solveInheritanceTransformation();
156      private:
157        bool solveInheritanceTransformation_done_= false ;
158      public:
159        bool activateFieldWorkflow(CGarbageCollector& gc) ;
160      private:
161        bool activateFieldWorkflow_done_=false ;
162      private:
163        shared_ptr<CGenericAlgorithmTransformation> transformationAlgorithm_ = nullptr ;
164      public:
165        void setTransformationAlgorithm(shared_ptr<CGenericAlgorithmTransformation> transformationAlgorithm) { transformationAlgorithm_=transformationAlgorithm ;}
166        shared_ptr<CGenericAlgorithmTransformation> getTransformationAlgorithm(void) { return transformationAlgorithm_ ;}   
167      private:
168        CTransformationPaths transformationPaths_ ;
169      public:
170        CTransformationPaths getTransformationPaths(void) {return transformationPaths_;} 
171        void setTransformationPaths(const CTransformationPaths& transformationPaths) { transformationPaths_=transformationPaths ;}
172
173      ////////////////////////////
174         bool isEqual(CAxis* axis);
175
176      public: 
177        bool hasValue;       
178        bool hasBounds;
179        bool hasLabel;
180
181      private:
182         bool checkData(bool generateError);
183         bool checkMask(bool generateError);
184         bool checkBounds(bool generateError);
185         bool checkLabel(bool generateError);
186     
187      public:
188         void sendAxisToCouplerOut(CContextClient* client, const std::vector<int>& globalDim, int orderPositionInGrid, const string& fieldId, int posInGrid) ;
189      private:
190         std::set<CContextClient*> sendAxisToCouplerOut_done_ ;
191   
192      public:
193         void makeAliasForCoupling(const string& fieldId, int posInGrid) ;
194         string getCouplingAlias(const string& fieldId, int posInGrid) ;
195
196      private:
197
198/** Clients that have to send a axis. There can be multiple clients in case of secondary server, otherwise only one client. */
199         std::list<CContextClient*> clients;
200         std::set<CContextClient*> clientsSet;
201
202      private:
203         /** define if the axis is completed or not ie all attributes have been received before in case
204             of grid reading from file or coupling */ 
205         bool isCompleted_=true ; 
206      public:     
207         /*!
208           \brief Check if a axis is completed
209           Before make any axis processing, we must be sure that all axis informations have
210           been sent, for exemple when reading a grid in a file or when grid elements are sent by an
211           other context (coupling). So all direct reference of the axis (axis_ref) must be also completed
212           \return true if axis and axis reference are completed
213          */
214         bool isCompleted(void)
215         {
216           if (hasDirectAxisReference()) if (!getDirectAxisReference()->isCompleted()) return false;
217           else return isCompleted_ ;
218
219           MISSING_RETURN( "bool CAxis::isCompleted() " );
220           return true;
221         }
222         void setCompleted(void) { isCompleted_=true ; }
223         void unsetCompleted(void) { isCompleted_=false ; }
224     
225      private:
226         bool isChecked;
227         std::set<StdString> relFiles, relFilesCompressed;
228          std::map<int, std::unordered_map<int, vector<size_t> > > indSrv_; // Global index of each client sent to server
229         std::map<int, std::vector<int> > connectedServerRank_;
230
231       //////////////////////////////////////////////////////////////////////////////////////
232       //  this part is related to distribution, element definition, views and connectors  //
233       //////////////////////////////////////////////////////////////////////////////////////
234         
235        private:
236         shared_ptr<CLocalElement> localElement_ ;
237         void initializeLocalElement(void) ;
238        public: 
239         shared_ptr<CLocalElement> getLocalElement(void) { if (localElement_==nullptr) initializeLocalElement() ; return localElement_ ; }
240         shared_ptr<CLocalView> getLocalView(CElementView::type type) { return getLocalElement()->getView(type) ;}
241        private:
242         void addFullView(void) ;
243         void addWorkflowView(void) ;
244         void addModelView(void) ;
245
246        private:
247         shared_ptr<CLocalConnector> modelToWorkflowConnector_ ;
248         void computeModelToWorkflowConnector(void)  ;
249        public:
250         shared_ptr<CLocalConnector> getModelToWorkflowConnector(void) { if (modelToWorkflowConnector_==nullptr) computeModelToWorkflowConnector() ; return modelToWorkflowConnector_ ;}
251       
252       public:
253         void computeRemoteElement(CContextClient* client, EDistributionType) ;
254         void distributeToServer(CContextClient* client, std::map<int, CArray<size_t,1>>& globalIndexOut, std::map<int, CArray<size_t,1>>& globalIndexIn, 
255                                 shared_ptr<CScattererConnector>& scattererConnector, const string& axisId="") ;
256
257         static void recvAxisDistribution(CEventServer& event) ;
258         void receivedAxisDistribution(CEventServer& event, int phasis) ;
259         void setServerMask(CArray<bool,1>& serverMask, CContextClient* client ) ;
260         void sendDistributedAttributes(CContextClient* client, shared_ptr<CScattererConnector> scattererConnector, const string& axisId) ;
261         static void recvDistributedAttributes(CEventServer& event) ;
262         void recvDistributedAttributes(CEventServer& event, const string& type) ;
263       private:
264         map<CContextClient*, shared_ptr<CDistributedElement>> remoteElement_ ;
265       public: 
266         shared_ptr<CDistributedElement> getRemoteElement(CContextClient* client) {return remoteElement_[client] ;}
267       private:
268         map<CContextClient*, shared_ptr<CScattererConnector>> clientToServerConnector_ ;
269       public: 
270         shared_ptr<CScattererConnector> getClientToServerConnector(CContextClient* client) { return clientToServerConnector_[client] ;}
271       private:
272         shared_ptr<CGathererConnector>  gathererConnector_ ;
273       public:
274         shared_ptr<CGathererConnector> getGathererConnector(void) { return gathererConnector_ ;}
275       private:
276         shared_ptr<CGathererConnector> serverFromClientConnector_ ;
277         shared_ptr<CDistributedElement> elementFrom_ ;
278       public:
279        shared_ptr<CGathererConnector> getServerFromClientConnector(void) { return serverFromClientConnector_ ;}
280
281       private:
282         shared_ptr<CScattererConnector> serverToClientConnector_ = nullptr ;
283         shared_ptr<CDistributedElement> elementTo_ ;
284       public: 
285         shared_ptr<CScattererConnector> getServerToClientConnector(void) { return serverToClientConnector_ ;} 
286
287       private:
288          map<CContextClient*,shared_ptr<CGathererConnector>>  clientFromServerConnector_  ;
289       public: 
290        shared_ptr<CGathererConnector> getClientFromServerConnector(CContextClient* client) { return clientFromServerConnector_[client] ;} 
291
292         DECLARE_REF_FUNC(Axis,axis)
293   }; // class CAxis
294
295   ///--------------------------------------------------------------
296
297   // Declare/Define CAxisGroup and CAxisDefinition
298   DECLARE_GROUP(CAxis);
299} // namespace xios
300
301#endif // __XIOS_CAxis__
Note: See TracBrowser for help on using the repository browser.