source: XIOS/trunk/src/transformation/generic_algorithm_transformation.hpp @ 862

Last change on this file since 862 was 862, checked in by mhnguyen, 5 years ago

Chaning the way to process transformation to improve the performance.
Instead of exchanging global index and weights on full GRID, each process only
sends and receives the global index and weights on each ELEMENT, which can reduce
the message size of DHT.

+) Domain and axis now have their own exchange function to transfer global index and weight
+) Generic transformation now plays the role of "synthesizer" for all elements
+) Grid transformation now plays the role of transformation mapping, e.x: exchange final global index and weight
among processes.

Test
+) On Curie
+) Pass on all basic tests
+) Dynamic interpolation on axis hasn't been tested (and it seems to need more change to make it rework)

File size: 6.6 KB
Line 
1/*!
2   \file generic_algorithm_transformation.hpp
3   \author Ha NGUYEN
4   \since 14 May 2015
5   \date 29 June 2015
6
7   \brief Interface for all transformation algorithms.
8 */
9#ifndef __XIOS_GENERIC_ALGORITHM_TRANSFORMATION_HPP__
10#define __XIOS_GENERIC_ALGORITHM_TRANSFORMATION_HPP__
11
12#include <map>
13#include <set>
14#include "array_new.hpp"
15
16namespace xios {
17  class CGrid;
18  class CDomain;
19  class CAxis;
20
21  /*!
22  \class CGenericAlgorithmTransformation
23  This class defines the interface for all other inherted algorithms class
24  */
25class CGenericAlgorithmTransformation
26{
27protected:
28  typedef std::vector<std::pair<int, std::pair<size_t,double> > > DestinationGlobalIndex;
29public:
30  // Stupid global index map, it must be replaced by tuple
31  // Mapping between global index map of DESTINATION and its local index with pair of global index of SOURCE and weights
32  typedef boost::unordered_map<size_t, DestinationGlobalIndex> DestinationIndexMap;
33  //
34  typedef boost::unordered_map<int, boost::unordered_map<size_t, std::vector<std::pair<size_t,double> > > > SourceDestinationIndexMap;
35
36protected:
37  typedef boost::unordered_map<size_t,int> GlobalLocalMap;
38protected:
39  typedef boost::unordered_map<int, std::vector<int> > TransformationIndexMap;
40  typedef boost::unordered_map<int, std::vector<double> > TransformationWeightMap;
41  typedef boost::unordered_map<int, std::vector<int> > TransformationPositionMap;
42
43public:
44  CGenericAlgorithmTransformation();
45
46  virtual ~CGenericAlgorithmTransformation() {}
47
48//  void computeGlobalSourceIndex(int elementPositionInGrid,
49//                                const std::vector<int>& gridDestGlobalDim,
50//                                const std::vector<int>& gridSrcGlobalDim,
51//                                const GlobalLocalMap& globalLocalIndexGridDestSendToServer,
52//                                DestinationIndexMap& globaIndexWeightFromDestToSource);
53
54  void computeGlobalSourceIndex(int elementPositionInGrid,
55                               CGrid* gridSrc,
56                               CGrid* gridDst,
57                               SourceDestinationIndexMap& globaIndexWeightFromSrcToDst);
58
59  std::vector<StdString> getIdAuxInputs();
60
61  /*!
62  Compute global index mapping from one element of destination grid to the corresponding element of source grid
63  */
64  void computeIndexSourceMapping(const std::vector<CArray<double,1>* >& dataAuxInputs = std::vector<CArray<double,1>* >());
65
66protected:
67  /*!
68  Compute an array of global index from a global index on an element
69    \param[in] destGlobalIndex global index on an element of destination grid
70    \param[in] srcGlobalIndex global index(es) on an element of source grid (which are needed by one index on element destination)
71    \param[in] elementPositionInGrid position of the element in the grid (for example: a grid with one domain and one axis, position of domain is 1, position of axis is 2)
72    \param[in] gridDestGlobalDim dimension size of destination grid (it should share the same size for all dimension, maybe except the element on which transformation is performed)
73    \param[in] globalLocalIndexDestSendToServerMap pair of global index and local index of destination grid which are to be sent to server(s), this array is already acsending sorted
74    \param[in/out] globalLocalIndexDestMap array of global index (for 2d grid, this array maybe a line, for 3d, this array may represent a plan). It should be preallocated
75    \param[in/out] globalIndexSrcGrid array of global index of source grid (for 2d grid, this array is a line, for 3d, this array represents a plan). It should be preallocated
76  */
77  virtual void computeGlobalGridIndexFromGlobalIndexElement(int destGlobalIndex,
78                                                        const std::vector<int>& srcGlobalIndex,
79                                                        const std::vector<int>& destGlobalIndexPositionInGrid,
80                                                        int elementPositionInGrid,
81                                                        const std::vector<int>& gridDestGlobalDim,
82                                                        const std::vector<int>& gridSrcGlobalDim,
83                                                        const GlobalLocalMap& globalLocalIndexDestSendToServerMap,
84                                                        std::vector<std::pair<size_t,int> >& globalLocalIndexDestMap,
85                                                        std::vector<std::vector<size_t> >& globalIndexSrcGrid) = 0;
86
87  virtual void computeIndexSourceMapping_(const std::vector<CArray<double,1>* >&) = 0;
88
89  virtual void computeExchangeGlobalIndex(const CArray<size_t,1>& globalElementIndex,
90                                          boost::unordered_map<int,std::vector<size_t> >& globalElementIndexOnProc) = 0;
91
92  void computeGlobalGridIndexMapping(int elementPositionInGrid,
93                                     const std::vector<int>& srcRank,
94                                     boost::unordered_map<int, std::vector<std::pair<int,double> > >& src2DstMap,
95                                     CGrid* gridDst,
96                                     CGrid* gridSrc,
97                                     std::vector<boost::unordered_map<int,std::vector<size_t> > >& globalElementIndexOnProc,
98                                     SourceDestinationIndexMap& globaIndexWeightFromSrcToDst);
99
100  void computeExchangeDomainIndex(CDomain* domainDst,
101                                  CDomain* domainSrc,
102                                  CArray<size_t,1>& destGlobalIndexPositionInGrid,
103                                  boost::unordered_map<int,std::vector<size_t> >& globalDomainIndexOnProc);
104
105  void computeExchangeAxisIndex(CAxis* axisDst,
106                                CAxis* axisSrc,
107                                CArray<size_t,1>& destGlobalIndexPositionInGrid,
108                                boost::unordered_map<int,std::vector<size_t> >& globalAxisIndexOnProc);
109
110protected:
111  //! Map between global index of destination element and source element
112  std::vector<TransformationIndexMap> transformationMapping_;
113  //! Weight corresponding of source to destination
114  std::vector<TransformationWeightMap> transformationWeight_;
115  //! Map of global index of destination element and corresponding global index of other elements in the same grid
116  //! By default, one index of an element corresponds to all index of remaining element in the grid. So it's empty
117  std::vector<TransformationPositionMap> transformationPosition_;
118
119  //! Id of auxillary inputs which help doing transformation dynamically
120  std::vector<StdString> idAuxInputs_;
121};
122
123}
124#endif // __XIOS_GENERIC_ALGORITHM_TRANSFORMATION_HPP__
Note: See TracBrowser for help on using the repository browser.