Changeset 623 for XIOS/trunk/src/filter

Timestamp:

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

Author:

mhnguyen

Message:

Implementing transformation algorithm: zoom axis (local commit)

+) Implement zoom axis: zoomed points are points not masked
+) Correct some minor bugs

Test
+) Ok with normal cases: zoom in the last of transformation list
+) There is still a bug in case of zoom then inverse

Location:

XIOS/trunk/src/filter

Files:

• axis_algorithm_inverse.cpp (moved) (moved from XIOS/trunk/src/filter/axis_inverse.cpp) (2 diffs)
• axis_algorithm_inverse.hpp (moved) (moved from XIOS/trunk/src/filter/axis_inverse.hpp) (1 diff)
• axis_algorithm_zoom.cpp (added)
• axis_algorithm_zoom.hpp (moved) (moved from XIOS/trunk/src/filter/axis_zoom.hpp) (1 diff)
• axis_zoom.cpp (deleted)
• concrete_algo.hpp (deleted)
• generic_algorithm_transformation.hpp (modified) (1 diff)
• grid_transformation.cpp (modified) (16 diffs)
• grid_transformation.hpp (modified) (3 diffs)
• transformation_mapping.cpp (modified) (5 diffs)
• transformation_mapping.hpp (modified) (1 diff)

XIOS/trunk/src/filter/axis_algorithm_inverse.cpp

@@ -1 @@
-#include "axis_inverse.hpp"
+#include "axis_algorithm_inverse.hpp"
 
 namespace xios {
 
-CAxisInverse::CAxisInverse(CAxis* axisDestination, CAxis* axisSource)
+CAxisAlgorithmInverse::CAxisAlgorithmInverse(CAxis* axisDestination, CAxis* axisSource)
  : CAxisAlgorithmTransformation(axisDestination, axisSource)
 {
   if (axisDestination->size.getValue() != axisSource->size.getValue())
   {
-    ERROR("CAxisInverse::CAxisInverse(CAxis* axisDestination, CAxis* axisSource)",
+    ERROR("CAxisAlgorithmInverse::CAxisAlgorithmInverse(CAxis* axisDestination, CAxis* axisSource)",
            << "Two axis have different size"
            << "Size of axis source " <<axisSource->getId() << " is " << axisSource->size.getValue()  << std::endl
@@ -19 +19 @@
   int ibeginDest = axisDestination->ibegin.getValue();
 
-  for (int idx = 0; idx < niDest; ++idx) axisDestGlobalIndex_.push_back(ibeginDest+idx);
+  for (int idx = 0; idx < niDest; ++idx)
+    if ((axisDestination->mask)(idx)) axisDestGlobalIndex_.push_back(ibeginDest+idx);
   this->computeIndexSourceMapping();
 }
 
-void CAxisInverse::computeIndexSourceMapping()
+void CAxisAlgorithmInverse::computeIndexSourceMapping()
 {
   std::map<int, std::vector<int> >& transMap = this->transformationMapping_;

XIOS/trunk/src/filter/axis_algorithm_inverse.hpp

@@ -7 +7 @@
 namespace xios {
 
-class CAxisInverse : public CAxisAlgorithmTransformation //public CConcreteAlgo
+class CAxisAlgorithmInverse : public CAxisAlgorithmTransformation
 {
 public:
-  CAxisInverse(CAxis* axisDestination, CAxis* axisSource);
+  CAxisAlgorithmInverse(CAxis* axisDestination, CAxis* axisSource);
 
-  virtual ~CAxisInverse() {}
+  virtual ~CAxisAlgorithmInverse() {}
 
   virtual void computeIndexSourceMapping();

XIOS/trunk/src/filter/axis_algorithm_zoom.hpp

@@ -8 +8 @@
 namespace xios {
 
-class CAxisZoom : public CAxisAlgorithmTransformation
+class CAxisAlgorithmZoom : public CAxisAlgorithmTransformation
 {
 public:
-  CAxisZoom(CAxis* axisDestination, CAxis* axisSource, CZoomAxis* zoomAxis);
+  CAxisAlgorithmZoom(CAxis* axisDestination, CAxis* axisSource, CZoomAxis* zoomAxis);
 
-  virtual ~CAxisZoom() {}
+  virtual ~CAxisAlgorithmZoom() {}
 
   virtual void computeIndexSourceMapping();
 
+private:
+  void updateAxisDestinationMask();
+  void updateZoom();
 private:
   StdSize zoomBegin_;

XIOS/trunk/src/filter/generic_algorithm_transformation.hpp

@@ -20 +20 @@
                                 std::map<size_t, std::set<size_t> >& globaIndexMapFromDestToSource);
 
-                                  /*!
+  /*!
   Compute global index mapping from one element of destination grid to the corresponding element of source grid
   */

XIOS/trunk/src/filter/grid_transformation.cpp

@@ +1 @@
+/*!
+   \file grid_transformation.cpp
+   \author Ha NGUYEN
+   \since 14 May 2015
+   \date 09 June 2015
+
+   \brief Interface for all transformations.
+ */
 #include "grid_transformation.hpp"
-#include "axis_inverse.hpp"
-#include "axis_zoom.hpp"
+#include "axis_algorithm_inverse.hpp"
+#include "axis_algorithm_zoom.hpp"
 #include "context.hpp"
 #include "context_client.hpp"
@@ -35 +43 @@
   {
     CAxis* axis = CAxis::createAxis();
-    axisSrcTmp[idx]->duplicateAttributes(axis);
+    axis->setAttributes(axisSrcTmp[idx]);
     axisSrc.push_back(axis);
   }
@@ -42 +50 @@
   {
     CDomain* domain = CDomain::createDomain();
-    domainSrcTmp[idx]->duplicateAttributes(domain);
+    domain->setAttributes(domainSrcTmp[idx]);
     domainSrc.push_back(domain);
   }
@@ -168 +176 @@
     case TRANS_ZOOM_AXIS:
       zoomAxis = dynamic_cast<CZoomAxis*> (it->second);
-      algo = new CAxisZoom(axisListDestP[axisIndex], axisListSrcP[axisIndex], zoomAxis);
+      algo = new CAxisAlgorithmZoom(axisListDestP[axisIndex], axisListSrcP[axisIndex], zoomAxis);
       break;
     case TRANS_INVERSE_AXIS:
-      algo = new CAxisInverse(axisListDestP[axisIndex], axisListSrcP[axisIndex]);
+      algo = new CAxisAlgorithmInverse(axisListDestP[axisIndex], axisListSrcP[axisIndex]);
       break;
     default:
@@ -196 +204 @@
     case TRANS_INVERSE_AXIS:
       axisIndex =  elementPosition2AxisPositionInGrid_[elementPositionInGrid];
-      axisListDestP[axisIndex]->duplicateAttributes(axisListSrcP[axisIndex]);
+      axisListSrcP[axisIndex]->duplicateAttributes(axisListDestP[axisIndex]);
       break;
     default:
@@ -226 +234 @@
     const CArray<size_t,1>& globalIndexGridDestSendToServer = distributionClientDest.getGlobalDataIndexSendToServer();
 
+   std::cout << "global index grid  dest send to server " << globalIndexGridDestSendToServer << std::endl;
     // ComputeTransformation of global index of each element
     std::vector<int> gridDestinationDimensionSize = gridDestination_->getGlobalDimension();
@@ -241 +250 @@
   }
 
- std::cout << "global index destination 0 " << *globalIndexOfCurrentGridSource_ << std::endl;
- std::cout << "global index destination 1 " << *globalIndexOfOriginalGridSource_ << std::endl;
+ std::cout << "global index destination 0 final " << *globalIndexOfCurrentGridSource_ << std::endl;
+ std::cout << "global index destination 1 final " << *globalIndexOfOriginalGridSource_ << std::endl;
+  updateFinalGridDestination();
   computeFinalTransformationMapping();
 }
@@ -248 +258 @@
 
 /*!
-  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.
+  After applying the algorithms, there are some informations on grid destination needing change, for now, there are:
+   +) mask
 */
-void CGridTransformation::computeTransformation()
-{
-//  const CArray<size_t,1>& globalIndexGridDestSendToServer = gridDestination_->getDistributionClient()->getGlobalDataIndexSendToServer();
-//  std::list<std::pair<int,CGenericAlgorithmTransformation*> >::const_iterator itbMap, itMap, iteMap;
-//  itbMap = algoTransformation_.begin();
-//  iteMap = algoTransformation_.end();
-//
-//  std::vector<CGenericAlgorithmTransformation*>::const_iterator itbVec, itVec, iteVec;
-//
-//  for (itMap = itbMap; itMap != iteMap; ++itMap)
-//  {
-//    int elementPosition = itMap->first;
-//    itbVec = (itMap->second).begin();
-//    iteVec = (itMap->second).end();
-//    for (itVec = itbVec; itVec != iteVec; ++itVec)
-//    {
-//      (*itVec)->computeGlobalSourceIndex(elementPosition,
-//                                         gridDestinationDimensionSize_,
-//                                         globalIndexGridDestSendToServer,
-//                                         globaIndexMapFromDestToSource_);
-//    }
-//  }
+void CGridTransformation::updateFinalGridDestination()
+{
+  CContext* context = CContext::getCurrent();
+  CContextClient* client=context->client;
+
+  //First of all, retrieve info of local mask of grid destination
+  CDistributionClient distributionClientDest(client->clientRank, gridDestination_);
+  const CArray<int, 1>& localMaskIndexOnClientDest = distributionClientDest.getLocalMaskIndexOnClient();
+  std::cout << "local mask " << localMaskIndexOnClientDest << std::endl;
+
+  const CArray<size_t,1>& globalIndexOnClientDest = distributionClientDest.getGlobalDataIndexSendToServer();
+  std::cout << "global index " << globalIndexOnClientDest <<  std::endl;
+  CArray<size_t, 1>::const_iterator itbArr, itArr, iteArr;
+  itbArr = globalIndexOnClientDest.begin();
+  iteArr = globalIndexOnClientDest.end();
+
+  // Then find out which index became invalid (become masked after being applied the algorithms, or demande some masked points from grid source)
+  int num = globalIndexOfOriginalGridSource_->numElements();
+  const size_t sfmax = NumTraits<unsigned long>::sfmax();
+  int maskIndexNum = 0;
+  for (int idx = 0; idx < num; ++idx)
+  {
+    if (sfmax == (*globalIndexOfOriginalGridSource_)(idx))
+    {
+      size_t maskedGlobalIndex = (*globalIndexOfCurrentGridSource_)(idx);
+      itArr = std::find(itbArr, iteArr, maskedGlobalIndex);
+      if (iteArr != itArr) ++maskIndexNum;
+    }
+  }
+
+  CArray<int,1>* maskIndexToModify = new CArray<int,1>(maskIndexNum);
+  maskIndexNum = 0;
+  for (int idx = 0; idx < num; ++idx)
+  {
+    if (sfmax == (*globalIndexOfOriginalGridSource_)(idx))
+    {
+      size_t maskedGlobalIndex = (*globalIndexOfCurrentGridSource_)(idx);
+      itArr = std::find(itbArr, iteArr, maskedGlobalIndex);
+      if (iteArr != itArr)
+      {
+        int localIdx = std::distance(itbArr, itArr);
+        (*maskIndexToModify)(maskIndexNum) = (localMaskIndexOnClientDest)(localIdx);
+        ++maskIndexNum;
+      }
+    }
+  }
+
+  std::cout << "index to modify " << *maskIndexToModify << std::endl;
+  gridDestination_->modifyMask(*maskIndexToModify);
+
+  delete maskIndexToModify;
 }
 
@@ -302 +340 @@
  for (itSend = itbSend; itSend != iteSend; ++itSend) sendBuffSize += (itSend->second).size();
 
+ std::cout << "global index destination 0 before" << *globalIndexOfCurrentGridSource_ << std::endl;
+ std::cout << "global index destination 1 before" << *globalIndexOfOriginalGridSource_ << std::endl;
+
+ typedef unsigned long Scalar;
  unsigned long* sendBuff, *currentSendBuff;
  if (0 != sendBuffSize) sendBuff = new unsigned long [sendBuffSize];
+ for (StdSize idx = 0; idx < sendBuffSize; ++idx) sendBuff[idx] = NumTraits<Scalar>::sfmax();
+
  int currentBuffPosition = 0;
  for (itSend = itbSend; itSend != iteSend; ++itSend)
@@ -332 +376 @@
  unsigned long* recvBuff, *currentRecvBuff;
  if (0 != recvBuffSize) recvBuff = new unsigned long [recvBuffSize];
+ for (StdSize idx = 0; idx < recvBuffSize; ++idx) recvBuff[idx] = NumTraits<Scalar>::sfmax();
+
  int currentRecvBuffPosition = 0;
  for (itRecv = itbRecv; itRecv != iteRecv; ++itRecv)
@@ -353 +399 @@
  }
 
- globalIndexOfCurrentGridSource_->resize(nbCurrentGridSource);
- globalIndexOfOriginalGridSource_->resize(nbCurrentGridSource);
+ if (globalIndexOfCurrentGridSource_->numElements()  != nbCurrentGridSource)
+ {
+   if ((0 != nbCurrentGridSource) && (0 != globalIndexOfCurrentGridSource_))
+   {
+     delete globalIndexOfCurrentGridSource_;
+     globalIndexOfCurrentGridSource_ = new CArray<size_t,1>(nbCurrentGridSource);
+   }
+ }
+
+ if (globalIndexOfOriginalGridSource_->numElements() != nbCurrentGridSource)
+ {
+   if ((0 != nbCurrentGridSource) && (0 != globalIndexOfOriginalGridSource_))
+   {
+     delete globalIndexOfOriginalGridSource_;
+     globalIndexOfOriginalGridSource_ = new CArray<size_t,1>(nbCurrentGridSource);
+   }
+ }
+
  int k = 0;
  currentRecvBuff = recvBuff;
@@ -372 +434 @@
  }
 
+ std::cout << "global index destination 0 after " << *globalIndexOfCurrentGridSource_ << std::endl;
+ std::cout << "global index destination 1 after " << *globalIndexOfOriginalGridSource_ << std::endl;
  if (0 != sendBuffSize) delete [] sendBuff;
  if (0 != recvBuffSize) delete [] recvBuff;
@@ -391 +455 @@
 
   int nb = globalIndexOfCurrentGridSource_->numElements();
+  const size_t sfmax = NumTraits<unsigned long>::sfmax();
   for (int idx = 0; idx < nb; ++idx)
   {
-    globaIndexMapFromDestToSource[(*globalIndexOfCurrentGridSource_)(idx)].insert((*globalIndexOfOriginalGridSource_)(idx));
+    if (sfmax != (*globalIndexOfOriginalGridSource_)(idx))
+      globaIndexMapFromDestToSource[(*globalIndexOfCurrentGridSource_)(idx)].insert((*globalIndexOfOriginalGridSource_)(idx));
   }
 
@@ -403 +469 @@
 
   CDistributionClient distributionClientDest(client->clientRank, gridDestination_);
-  CDistributionClient distributionClientSrc(client->clientRank, gridSource_);
-
-  CArray<int, 1> localIndexOnClientDest = distributionClientDest.getLocalDataIndexOnClient(); //gridDestination_->getDistributionClient()->getLocalDataIndexOnClient();
-  CArray<size_t,1> globalIndexOnClientDest = distributionClientDest.getGlobalDataIndexSendToServer(); //gridDestination_->getDistributionClient()->getGlobalDataIndexSendToServer();
+  CDistributionClient distributionClientSrc(client->clientRank, originalGridSource_);
+
+//  const CArray<int, 1>& localIndexOnClientDest = distributionClientDest.getLocalDataIndexOnClient(); //gridDestination_->getDistributionClient()->getLocalDataIndexOnClient();
+  const CArray<int, 1>& localIndexOnClientDest = distributionClientDest.getLocalDataIndexSendToServer();
+  const CArray<size_t,1>& globalIndexOnClientDest = distributionClientDest.getGlobalDataIndexSendToServer(); //gridDestination_->getDistributionClient()->getGlobalDataIndexSendToServer();
 
  std::cout << "dest: local index " << localIndexOnClientDest << std::endl;
  std::cout << "dest: global index " << globalIndexOnClientDest << std::endl;
-  CArray<int, 1> localIndexOnClientSrc = distributionClientSrc.getLocalDataIndexOnClient(); //gridSource_->getDistributionClient()->getLocalDataIndexOnClient();
-  CArray<size_t,1> globalIndexOnClientSrc = distributionClientSrc.getGlobalDataIndexSendToServer(); //gridSource_->getDistributionClient()->getGlobalDataIndexSendToServer();
+  const CArray<int, 1>& localIndexOnClientSrc = distributionClientSrc.getLocalDataIndexOnClient(); //gridSource_->getDistributionClient()->getLocalDataIndexOnClient();
+  const CArray<size_t,1>& globalIndexOnClientSrc = distributionClientSrc.getGlobalDataIndexSendToServer(); //gridSource_->getDistributionClient()->getGlobalDataIndexSendToServer();
  std::cout << "src: local index " << localIndexOnClientSrc << std::endl;
  std::cout << "src: global index " << globalIndexOnClientSrc << std::endl;
   std::vector<size_t>::const_iterator itbVec, itVec, iteVec;
-  CArray<size_t, 1>::iterator itbArr, itArr, iteArr;
+  CArray<size_t, 1>::const_iterator itbArr, itArr, iteArr;
 
   std::map<int,std::vector<std::vector<size_t> > >::const_iterator itbMapRecv, itMapRecv, iteMapRecv;
@@ -439 +506 @@
         {
           int localIdx = std::distance(itbArr, itArr);
-//          (*localIndexToReceiveOnGridDest_[sourceRank][i])(idx) = localIndexOnClientDest(localIdx); // Local index of un-extracted data (only domain)
-          (*localIndexToReceiveOnGridDest_[sourceRank][i])(idx) = (localIdx); // Local index of extracted data
+          (*localIndexToReceiveOnGridDest_[sourceRank][i])(idx) = localIndexOnClientDest(localIdx); // Local index of un-extracted data (only domain)
+//          (*localIndexToReceiveOnGridDest_[sourceRank][i])(idx) = (localIdx); // Local index of extracted data
         }
       }
     }
+//    std::cout << "local index to receive from source Rank = " << sourceRank << (*localIndexToReceiveOnGridDest_[sourceRank][i]) << std::endl;
   }
 
@@ -468 +536 @@
       }
     }
+    std::cout << "local index to send to dest Rank = " << destRank << (*localIndexToSendFromGridSource_[destRank]) << std::endl;
   }
 }

XIOS/trunk/src/filter/grid_transformation.hpp

@@ +1 @@
+/*!
+   \file grid_transformation.hpp
+   \author Ha NGUYEN
+   \since 14 May 2015
+   \date 09 June 2015
+
+   \brief Interface for all transformations.
+ */
 #ifndef __XIOS_GRID_TRANSFORMATION_HPP__
 #define __XIOS_GRID_TRANSFORMATION_HPP__
@@ -12 +20 @@
 class CGrid;
 
+/*!
+  \class CGridTransformation
+  This class is an interface for all transformations to interact with the rest of XIOS.
+The class, firstly, tries to get all information relating to requested transformations by retrieving directly from grid.
+Then with all these information, all necessary transformations will be be created by generic class \class CGenericAlgorithmTransformation.
+Because there are information exchange among clients to accomplish the transformations (e.g: some index need retrieving from other clients),
+this class uses class \class CTransformationMapping to fulfill this demand.
+For each transformation, a new temporary grid source is created.
+For a consequential transformations (e.g: inversing -> zoom -> inversing -> ...),
+the grid destination of current transformation will be grid source of the next transformation
+*/
 class CGridTransformation
 {
@@ -38 +57 @@
   void computeFinalTransformationMapping();
   void computeTransformationFromOriginalGridSource(const std::map<size_t, std::set<size_t> >& globaIndexMapFromDestToSource);
+  void updateFinalGridDestination();
 
 private:
+  //! Grid source on transformation
   CGrid* gridSource_;
+
+  //! Grid destination on transformation
   CGrid* gridDestination_;
+
+  //! The grid source of the first transformation (original grid source)
   CGrid* originalGridSource_;
 
+  //! Grid source dimension size
   std::vector<int> gridSourceDimensionSize_;
+
+  //! Grid destination dimension size
   std::vector<int> gridDestinationDimensionSize_;
 
 private:
   typedef std::list<std::pair<int,std::pair<ETranformationType,int> > > ListAlgoType;
+  //! List of algorithm types and their order
+  ListAlgoType listAlgos_;
 
   // Mapping between position of an element in grid and its transformation (if any)
   std::list<CGenericAlgorithmTransformation*> algoTransformation_;
-  ListAlgoType listAlgos_;
+
+  //! Mapping of (grid) global index representing tranformation.
   std::map<size_t, std::set<size_t> > globaIndexMapFromDestToSource_;
 
+  //! Local index of data to send from grid source
   std::map<int, CArray<int,1>* > localIndexToSendFromGridSource_;
+
+  //! Local index of data to receive on grid destination
   std::map<int, std::vector<CArray<int,1>* > > localIndexToReceiveOnGridDest_;
 
+  //! Position of axis and domain in grid
   std::map<int, int> elementPosition2AxisPositionInGrid_, elementPosition2DomainPositionInGrid_;
 
+  //! (Grid) Global index of grid source
   CArray<size_t,1>* globalIndexOfCurrentGridSource_;
   CArray<size_t,1>* globalIndexOfOriginalGridSource_;

XIOS/trunk/src/filter/transformation_mapping.cpp

@@ +1 @@
+/*!
+   \file transformation_mapping.cpp
+   \author Ha NGUYEN
+   \since 14 May 2015
+   \date 09 June 2015
+
+   \brief Take charge of communication among clients to exchange transformed data.
+ */
+
 #include "transformation_mapping.hpp"
 #include <boost/unordered_map.hpp>
@@ -14 +23 @@
   int clientRank = client->clientRank;
 
-  CDistributionClient distributionClientDest(client->clientRank, gridSource_);
+  CDistributionClient distributionClientSrc(client->clientRank, gridSource_);
 
-  const CArray<size_t,1>& globalIndexGridSrc = distributionClientDest.getGlobalDataIndexSendToServer(); //gridSource_->getDistributionClient()->getGlobalDataIndexSendToServer();
+  const CArray<size_t,1>& globalIndexGridSrc = distributionClientSrc.getGlobalDataIndexSendToServer(); //gridSource_->getDistributionClient()->getGlobalDataIndexSendToServer();
   boost::unordered_map<size_t,int> globalIndexOfServer;
   int globalIndexSize = globalIndexGridSrc.numElements();
@@ -24 +33 @@
   }
 
+  std::cout << "global index grid src " << globalIndexGridSrc << std::endl;
   gridIndexClientClientMapping_ = new CClientServerMappingDistributed(globalIndexOfServer,
                                                                       client->intraComm,
@@ -151 +161 @@
 }
 
+/*!
+  Return (grid) global index on grid destination. This mapping contains the rank of client source (that sends info to grid destination)
+and the corresponding global index to write on grid destination.
+  \return global index mapping to receive on grid destination
+*/
 const std::map<int,std::vector<std::vector<size_t> > >& CTransformationMapping::getGlobalIndexReceivedOnGridDestMapping() const
 {
@@ -156 +171 @@
 }
 
+/*!
+  Return (grid) global index on grid source. This mapping contains the rank of client destination (which receives transformation info) and
+the corresponding global index to send
+  \return global index mapping to send on grid source
+*/
 const std::map<int,std::vector<size_t> >& CTransformationMapping::getGlobalIndexSendToGridDestMapping() const
 {

XIOS/trunk/src/filter/transformation_mapping.hpp

@@ +1 @@
+/*!
+   \file transformation_mapping.hpp
+   \author Ha NGUYEN
+   \since 14 May 2015
+   \date 09 June 2015
+
+   \brief Take charge of communication among clients to exchange transformed data.
+ */
 #ifndef __XIOS_TRANSFORMATION_MAPPING_HPP__
 #define __XIOS_TRANSFORMATION_MAPPING_HPP__