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 | |
---|
27 | namespace 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(void) ; |
---|
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__ |
---|