source: XIOS/dev/dev_olga/src/transformation/generic_algorithm_transformation.hpp @ 1589

Last change on this file since 1589 was 1589, checked in by oabramkina, 23 months ago

Backporting r1578 and r1586 to dev, cleaning the code before merging it to XIOS 2.5.

File size: 8.7 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#include "client_client_dht_template.hpp"
16
17namespace xios {
18  class CGrid;
19  class CDomain;
20  class CAxis;
21  class CScalar;
22
23  /*!
24  \class CGenericAlgorithmTransformation
25  This class defines the interface for all other inherited algorithms class
26  */
27class CGenericAlgorithmTransformation
28{
29public:
30  enum AlgoTransType {
31    ELEMENT_GENERATION = 0,
32    ELEMENT_MODIFICATION_WITHOUT_DATA = 1,
33    ELEMENT_MODIFICATION_WITH_DATA = 2,
34    ELEMENT_NO_MODIFICATION_WITH_DATA = 3,
35    ELEMENT_NO_MODIFICATION_WITHOUT_DATA = 4
36  } ;
37
38public:
39  // Mapping between global index map of DESTINATION and its local index with pair of global index of SOURCE and weights
40  typedef std::unordered_map<int, std::unordered_map<size_t, std::vector<std::pair<size_t,double> > > > SourceDestinationIndexMap;
41
42protected:
43  typedef std::unordered_map<size_t,int> GlobalLocalMap;
44protected:
45  typedef std::unordered_map<int, std::vector<int> > TransformationIndexMap;
46  typedef std::unordered_map<int, std::vector<double> > TransformationWeightMap;
47  typedef std::unordered_map<int, std::vector<int> > TransformationPositionMap;
48
49public:
50  CGenericAlgorithmTransformation();
51
52  virtual ~CGenericAlgorithmTransformation() {}
53
54  bool isDistributedTransformation(int elementPositionInGrid, CGrid* gridSrc, CGrid* gridDst) ;
55
56  void computeGlobalSourceIndex(int elementPositionInGrid,
57                               CGrid* gridSrc,
58                               CGrid* gridDst,
59                               SourceDestinationIndexMap& globaIndexWeightFromSrcToDst);
60
61    /*!
62    Apply a operation on local data.
63    \param [in] localIndex vector contains local index of local data output and the corresponding weight
64    \param [in] dataInput Pointer to the first element of data input array (in form of buffer)
65    \param [in/out] dataOut Array contains local data
66    \param [in/out] flagInitial vector of boolean to mark the local index already initialized. True means there is a need for initalization
67    \param [in] ignoreMissingValue don't count missing value in operation if this flag is true
68    \param [in] firstPass indicate if it is the first time the apply funtion is called for a same transformation, in order to make a clean initialization
69  */
70  virtual void apply(const std::vector<std::pair<int,double> >& localIndex,
71                     const double* dataInput,
72                     CArray<double,1>& dataOut,
73                     std::vector<bool>& flagInitial,                     
74                     bool ignoreMissingValue, bool firstPass);
75
76  /*!
77   * Update whole dataOut (on necessary).
78   * (Example:  Impose a weight, whose value is only known after being applied an operation, on dataOut)
79   * \param [in/out] dataOut dataOut
80   */
81  virtual void updateData(CArray<double,1>& dataOut);
82
83  std::vector<StdString> getIdAuxInputs();
84  AlgoTransType type();
85  /*!
86  Compute global index mapping from one element of destination grid to the corresponding element of source grid
87  */
88  void computeIndexSourceMapping(const std::vector<CArray<double,1>* >& dataAuxInputs = std::vector<CArray<double,1>* >());
89//  void computeTransformationMappingNonDistributed(int elementPositionInGrid, CGrid* gridSrc, CGrid* gridDst,
90//                                                  vector<int>& localSrc, vector<int>& localDst, vector<double>& weight, vector<bool>& localMaskOnGridDest);
91  void computeTransformationMappingNonDistributed(int elementPositionInGrid, CGrid* gridSrc, CGrid* gridDst,
92                                                  vector<int>& localSrc, vector<int>& localDst, vector<double>& weight, int nbLocalIndexOnGridDest);
93  void nonDistributedrecursiveFunct(int currentPos, bool masked, int elementPositionInGrid,  vector< CArray<bool,1>* >& maskSrc, vector< CArray<bool,1>* >& maskDst,
94                                    int& srcInd, int& srcIndCompressed, vector<int>& nIndexSrc,
95                                    int& t, vector<vector<vector<pair<int,double> > > >& dstIndWeight, int currentInd,
96                                    vector<int>& localSrc, vector<int>& localDst, vector<double>& weight) ;
97
98protected:
99  virtual void computeIndexSourceMapping_(const std::vector<CArray<double,1>* >&) = 0;
100
101  /*!
102  Compute proc which contains global index of an element
103    \param[in] globalElementIndex demanding global index of an element of source grid
104    \param[in] elementType type of source element, 2: domain, 1: axis and 0: scalar
105    \param[out] globalElementIndexOnProc Proc contains the demanding global index
106  */
107  virtual void computeExchangeGlobalIndex(const CArray<size_t,1>& globalElementIndex,
108                                          int elementType,
109                                          CClientClientDHTInt::Index2VectorInfoTypeMap& globalElementIndexOnProc) = 0;
110
111protected:
112  void computeGlobalGridIndexMapping(int elementPositionInGrid,
113                                     const std::vector<int>& srcRank,
114                                     std::unordered_map<int, std::vector<std::pair<int,double> > >& src2DstMap,
115                                     CGrid* gridDst,
116                                     CGrid* gridSrc,
117                                     std::vector<std::unordered_map<int,std::vector<size_t> > >& globalElementIndexOnProc,
118                                     SourceDestinationIndexMap& globaIndexWeightFromSrcToDst);
119
120  void computeExchangeDomainIndex(CDomain* domainDst,
121                                  CDomain* domainSrc,
122                                  CArray<size_t,1>& destGlobalIndexPositionInGrid,
123                                  std::unordered_map<int,std::vector<size_t> >& globalDomainIndexOnProc);
124
125  void computeExchangeAxisIndex(CAxis* axisDst,
126                                CAxis* axisSrc,
127                                CArray<size_t,1>& destGlobalIndexPositionInGrid,
128                                std::unordered_map<int,std::vector<size_t> >& globalAxisIndexOnProc);
129
130  void computeExchangeScalarIndex(CScalar* scalarDst,
131                                  CScalar* scalarSrc,
132                                  CArray<size_t,1>& destGlobalIndexPositionInGrid,
133                                  std::unordered_map<int,std::vector<size_t> >& globalScalarIndexOnProc);
134
135  void computePositionElements(CGrid* dst, CGrid* src);
136
137protected:
138  //! indicate if the transformation is performed on a distributed element
139  bool isDistributed_ ;
140  //! indicate if the method  isDistributedTransformation has been called before
141  bool isDistributedComputed_ ;
142 
143  //! Map between global index of destination element and source element
144  std::vector<TransformationIndexMap> transformationMapping_;
145  //! Weight corresponding of source to destination
146  std::vector<TransformationWeightMap> transformationWeight_;
147  //! Map of global index of destination element and corresponding global index of other elements in the same grid
148  //! By default, one index of an element corresponds to all index of remaining element in the grid. So it's empty
149  std::vector<TransformationPositionMap> transformationPosition_;
150
151  //! Id of auxillary inputs which helps doing transformation dynamically
152  std::vector<StdString> idAuxInputs_;
153  AlgoTransType type_;
154
155  std::set<StdSize> indexElementSrc_;
156
157  std::vector<std::unordered_map<int,std::vector<size_t> > > globalElementIndexOnProc_;
158
159  std::vector<int> procContainSrcElementIdx_;  // List of processes containing source index of transformed elements
160//  std::set<int> procOfNonTransformedElements_; // Processes contain the source index of non-transformed elements
161  std::set<int> commonProc_;
162  std::vector< set<int> > procElementList_ ; // List of processes containing source index of elements
163
164  CClientClientDHTInt::Index2VectorInfoTypeMap globalIndexOfTransformedElementOnProc_;
165 
166  bool computedProcSrcNonTransformedElement_; // Flag to indicate whether we computed proc containing non transformed elements
167
168  std::map<int, int> elementPositionInGridSrc2AxisPosition_, elementPositionInGridSrc2DomainPosition_, elementPositionInGridSrc2ScalarPosition_;
169  std::map<int, int> elementPositionInGridDst2AxisPosition_, elementPositionInGridDst2DomainPosition_, elementPositionInGridDst2ScalarPosition_;
170
171  bool eliminateRedondantSrc_ ; // flag to indicate if the transformation must select only one global source point for all proc.
172                               // In this case it will choose preferentially the current process
173};
174
175}
176#endif // __XIOS_GENERIC_ALGORITHM_TRANSFORMATION_HPP__
Note: See TracBrowser for help on using the repository browser.