Changeset 621 for XIOS/trunk/src/filter

Timestamp:

06/22/15 13:36:21 (9 years ago)

Author:

mhnguyen

Message:

Implementing generic transformation algorithm (local commit)

+) Change a little bit to make sure everything work in order

Test
+) test_new_features passe with inverse

Location:

XIOS/trunk/src/filter

Files:

• axis_algorithm_transformation.cpp (modified) (1 diff)
• axis_algorithm_transformation.hpp (modified) (3 diffs)
• axis_inverse.cpp (modified) (2 diffs)
• axis_inverse.hpp (modified) (2 diffs)
• axis_zoom.cpp (added)
• axis_zoom.hpp (added)
• concrete_algo.hpp (added)
• grid_transformation.cpp (modified) (9 diffs)
• transformation_mapping.cpp (modified) (1 diff)

XIOS/trunk/src/filter/axis_algorithm_transformation.cpp

@@ -1 +1 @@
 #include "axis_algorithm_transformation.hpp"
+#include "axis_inverse.hpp"
+#include "axis_zoom.hpp"
 
 namespace xios {
 
-CAxisAlgorithmTransformation::CAxisAlgorithmTransformation(CAxis* axisDestination)
+CAxisAlgorithmTransformation::CAxisAlgorithmTransformation(CAxis* axisDestination, CAxis* axisSource, std::vector<ETranformationType>& algos)
  : CGenericAlgorithmTransformation()
 {
-  int niDest = axisDestination->ni.getValue();
-  int ibeginDest = axisDestination->ibegin.getValue();
+  for (int idx = 0; idx < algos.size(); ++idx)
+  {
+    switch (algos[idx])
+    {
+      case TRANS_ZOOM_AXIS:
+        algosOfAnAxis_.push_back(new CAxisZoom(axisDestination, axisSource));
+        break;
+      case TRANS_INVERSE_AXIS:
+        algosOfAnAxis_.push_back(new CAxisInverse(axisDestination, axisSource));
+        break;
+      default:
+        break;
+    }
+  }
+  computeIndexSourceMapping();
+}
 
-  for (int idx = 0; idx < niDest; ++idx) axisDestGlobalIndex_.push_back(ibeginDest+idx);
+CAxisAlgorithmTransformation::~CAxisAlgorithmTransformation()
+{
+  for (int idx = 0; idx < algosOfAnAxis_.size(); ++idx) delete algosOfAnAxis_[idx];
+}
+
+void CAxisAlgorithmTransformation::computeIndexSourceMapping()
+{
+  if (!algosOfAnAxis_.empty())
+  {
+    algosOfAnAxis_[0]->computeIndexSourceMapping(this->transformationMapping_);
+    for (int idx = 1; idx < algosOfAnAxis_.size(); ++idx)
+    {
+      algosOfAnAxis_[idx]->computeIndexSourceMapping(algosOfAnAxis_[idx-1]->getTransformationMapping());
+    }
+    this->transformationMapping_ = algosOfAnAxis_[algosOfAnAxis_.size()-1]->getTransformationMapping();
+  }
 }
 

XIOS/trunk/src/filter/axis_algorithm_transformation.hpp

@@ -4 +4 @@
 #include "generic_algorithm_transformation.hpp"
 #include "axis.hpp"
+#include "concrete_algo.hpp"
 
 namespace xios {
@@ -10 +11 @@
 {
 public:
-  CAxisAlgorithmTransformation(CAxis* axisDestination);
-  virtual ~CAxisAlgorithmTransformation() {}
+  CAxisAlgorithmTransformation(CAxis* axisDestination, CAxis* axisSource, std::vector<ETranformationType>&);
+
+  virtual ~CAxisAlgorithmTransformation();
 
 protected:
@@ -21 +23 @@
                                                         CArray<size_t,1>& globalIndexDestGrid,
                                                         std::vector<CArray<size_t,1> >& globalIndexSrcGrid);
-  virtual void computeIndexSourceMapping() = 0;
-
+  void computeIndexSourceMapping();
 protected:
-  std::vector<int> axisDestGlobalIndex_;
+  std::vector<CConcreteAlgo*> algosOfAnAxis_;
 
 };

XIOS/trunk/src/filter/axis_inverse.cpp

@@ -4 +4 @@
 
 CAxisInverse::CAxisInverse(CAxis* axisDestination, CAxis* axisSource)
- : CAxisAlgorithmTransformation(axisDestination)
+ : CConcreteAlgo()
 {
   if (axisDestination->size.getValue() != axisSource->size.getValue())
@@ -14 +14 @@
   }
 
+
   axisDestGlobalSize_ = axisDestination->size.getValue();
+  int niDest = axisDestination->ni.getValue();
+  int ibeginDest = axisDestination->ibegin.getValue();
 
-  this->computeIndexSourceMapping();
+  for (int idx = 0; idx < niDest; ++idx) axisDestGlobalIndex_.push_back(ibeginDest+idx);
 }
 
-void CAxisInverse::computeIndexSourceMapping()
+void CAxisInverse::computeIndexSourceMapping(const std::map<int, std::vector<int> >& transformationMappingOfPreviousAlgo)
 {
   std::map<int, std::vector<int> >& transMap = this->transformationMapping_;
-  if (!transMap.empty()) transMap.clear();
-
-  int globalIndexSize = axisDestGlobalIndex_.size();
-  for (int idx = 0; idx < globalIndexSize; ++idx)
-    transMap[axisDestGlobalIndex_[idx]].push_back(axisDestGlobalSize_-axisDestGlobalIndex_[idx]-1);
+  if (transformationMappingOfPreviousAlgo.empty())
+  {
+    int globalIndexSize = axisDestGlobalIndex_.size();
+    for (int idx = 0; idx < globalIndexSize; ++idx)
+      transMap[axisDestGlobalIndex_[idx]].push_back(axisDestGlobalSize_-axisDestGlobalIndex_[idx]-1);
+  }
+  else
+  {
+    std::map<int, std::vector<int> >::const_iterator itb = transformationMappingOfPreviousAlgo.begin(), it,
+                                                     ite = transformationMappingOfPreviousAlgo.end();
+    for (it = itb; it != ite; ++it)
+    {
+      transMap[it->first].push_back(axisDestGlobalSize_-it->first-1);
+    }
+  }
 }
 
-
 }

XIOS/trunk/src/filter/axis_inverse.hpp

@@ -2 +2 @@
 #define __XIOS_AXIS_ALGORITHM_INVERSE_HPP__
 
-#include "axis_algorithm_transformation.hpp"
+#include "concrete_algo.hpp"
 #include "axis.hpp"
 
 namespace xios {
 
-class CAxisInverse : public CAxisAlgorithmTransformation
+class CAxisInverse : public CConcreteAlgo
 {
 public:
@@ -13 +13 @@
 
   virtual ~CAxisInverse() {}
+
+  virtual void computeIndexSourceMapping(const std::map<int, std::vector<int> >& transformationMappingOfPreviousAlgo);
+
 protected:
-  virtual void computeIndexSourceMapping();
+  std::vector<int> axisDestGlobalIndex_;
 
 private:

XIOS/trunk/src/filter/grid_transformation.cpp

@@ -2 +2 @@
 #include "axis_inverse.hpp"
 #include "transformation_mapping.hpp"
+#include "transformation_enum.hpp"
+#include "axis_algorithm_transformation.hpp"
 
 namespace xios {
@@ -86 +88 @@
       if (axisListDestP[i]->hasTransformation())
       {
-        CGenericAlgorithmTransformation* algo = new CAxisInverse(axisListDestP[i], axisListSrcP[i]);
+        CGenericAlgorithmTransformation* algo = 0;
+        CAxis::TransMapTypes trans = axisListDestP[i]->getAllTransformations();
+        CAxis::TransMapTypes::const_iterator itb = trans.begin(), it,
+                                             ite = trans.end();
+        std::vector<ETranformationType> algoAxis;
+        for (it = itb; it != ite; ++it)
+        {
+          algoAxis.push_back(it->first);
+        }
+        algo = new CAxisAlgorithmTransformation(axisListDestP[i], axisListSrcP[i], algoAxis);
         algoTransformation_[axisPositionInGrid[i]].push_back(algo);
       }
@@ -98 +109 @@
 }
 
+/*!
+  Compute index mapping representing transformation between two grids
+  Each domain and each axis can contain some information of transformation, these information are then converted into
+form of global index mapping reprensenting transformation between two grids.
+*/
 void CGridTransformation::computeTransformation()
 {
@@ -122 +138 @@
 }
 
+/*!
+  Compute transformation mapping between grid source and grid destination
+  The transformation between grid source and grid destination is represented in form of mapping between global index
+of two grids. Then local index mapping between data on each grid will be found out thanks to these global indexes
+*/
 void CGridTransformation::computeTransformationMapping()
 {
@@ -141 +162 @@
   CArray<size_t,1> globalIndexOnClientSrc = gridSource_->getDistributionClient()->getGlobalDataIndexSendToServer();
 
-
   std::vector<size_t>::const_iterator itbVec, itVec, iteVec;
   CArray<size_t, 1>::iterator itbArr, itArr, iteArr;
 
   std::map<int,std::vector<std::vector<size_t> > >::const_iterator itbMapRecv, itMapRecv, iteMapRecv;
+
   // Find out local index on grid destination (received)
   itbMapRecv = globalIndexToReceive.begin();
@@ -166 +187 @@
         {
           int localIdx = std::distance(itbArr, itArr);
-          (*localIndexToReceiveOnGridDest_[sourceRank][i])(idx) = localIndexOnClientDest(localIdx);
+//          (*localIndexToReceiveOnGridDest_[sourceRank][i])(idx) = localIndexOnClientDest(localIdx); // Local index of un-extracted data (only domain)
+          (*localIndexToReceiveOnGridDest_[sourceRank][i])(idx) = (localIdx); // Local index of extracted data
         }
       }
     }
-
   }
 
@@ -183 +204 @@
     CArray<int,1>* ptr = new CArray<int,1>((itMap->second).size());
     localIndexToSendFromGridSource_[itMap->first] = ptr;
+    int destRank = itMap->first;
     int vecSize = (itMap->second).size();
     for (int idx = 0; idx < vecSize; ++idx)
@@ -190 +212 @@
       {
         int localIdx = std::distance(itbArr, itArr);
-        (*localIndexToSendFromGridSource_[itMap->first])(idx) = localIndexOnClientSrc(localIdx);
-      }
-    }
-  }
-}
-
+//        (*localIndexToSendFromGridSource_[destRank])(idx) = localIndexOnClientSrc(localIdx);
+        (*localIndexToSendFromGridSource_[destRank])(idx) = (localIdx);
+      }
+    }
+  }
+}
+
+/*!
+  Local index of data which need sending from the grid source
+  \return local index of data
+*/
 std::map<int, CArray<int,1>* > CGridTransformation::getLocalIndexToSendFromGridSource()
 {
@@ -201 +228 @@
 }
 
+/*!
+  Local index of data which will be received on the grid destination
+  \return local index of data
+*/
 std::map<int, std::vector<CArray<int,1>* > > CGridTransformation::getLocalIndexToReceiveOnGridDest()
 {

XIOS/trunk/src/filter/transformation_mapping.cpp

@@ -33 +33 @@
 /*!
   Suppose that we have transformations between two grids, which are represented in form of mapping between global indexes of these two grids,
-this function tries to find out which clients a client need to send and receive these global indexes to accomplish the transformations.
+this function tries to find out which clients a client needs to send and receive these global indexes to accomplish the transformations.
   The grid destination is the grid whose global indexes demande global indexes from the grid source
   Grid destination and grid source are also distributed among clients but in a different manner.