Changeset 620


Ignore:
Timestamp:
06/22/15 13:36:17 (6 years ago)
Author:
mhnguyen
Message:

Implementing generic transformation algorithm (local commit)

+) Implement 3 important classes:

-gridTransformation to read transformation info from grid and interface with the rest of XIOS
-transformationMapping to be in charge of sending/receiving transformation info among clients
-transformationAlgorithm to represent various algorithms

+) Make some change on field to use the new classes

Test
+) Only test_new_features with inversed axis

Location:
XIOS/trunk
Files:
10 added
10 deleted
10 edited

Legend:

Unmodified
Added
Removed
  • XIOS/trunk/inputs/Version2/iodef.xml

    r619 r620  
    1111     <field id="field_Axis"  operation="average" freq_op="3600s" grid_ref="grid_Axis" /> 
    1212     <field id="field_Two_Axis"  operation="average" freq_op="3600s" grid_ref="grid_Two_Axis" /> 
    13      <field id="field_Axis_transformed"  operation="average" freq_op="3600s" field_ref="field_Two_Axis" grid_ref="grid_Axis_tranformed" /> 
     13     <field id="field_Axis_transformed"  operation="average" freq_op="3600s" field_ref="field_Axis" grid_ref="grid_Axis_tranformed" /> 
    1414     <field id="field_All_Axis" operation="average" freq_op="3600s" grid_ref="grid_All_Axis" /> 
    1515     <field id="field_Scalar" operation="average" freq_op="3600s" grid_ref="ScalarGrid" /> 
     
    1919   <file_definition type="multiple_file" par_access="collective" output_freq="6h" output_level="10" enabled=".TRUE."> 
    2020     <file id="output" name="output"> 
    21         <field field_ref="field_A" /> 
     21<!--        <field field_ref="field_A" />--> 
    2222     </file> 
    2323     <file id="output_Axis" name="output_Axis" type="one_file"> 
     
    4141     <axis id="axis_C" zoom_size="2" zoom_end="2"/> 
    4242     <axis id="axis_D" /> 
    43      <axis id="axis_E" axis_ref="axis_B"> 
     43     <axis id="axis_E" axis_ref="axis_D"> 
    4444        <transformation type="inverse" /> 
    4545<!--        <transformation type="zoom" />--> 
     
    6565       </grid> 
    6666       <grid id="grid_Axis_tranformed"> 
    67          <axis axis_ref="axis_A" /> 
     67<!--         <axis axis_ref="axis_A" />--> 
    6868         <axis axis_ref="axis_E" /> 
    6969       </grid> 
  • XIOS/trunk/src/client_server_mapping_distributed.hpp

    r591 r620  
    3737 
    3838    virtual void computeServerIndexMapping(const CArray<size_t,1>& globalIndexOnClientSendToServer); 
    39  
    40 //    virtual void computeServerIndexMapping(const CArray<size_t,1>& globalIndexOnClientSendToServer, 
    41 //                                           const CArray<int,1>& localIndexOnClientSendToServer); 
    4239 
    4340    std::vector<int> computeConnectedServerRank(const CArray<size_t,1> globalIndexClient); 
     
    8582    void resetReceivingRequestAndCount(); 
    8683 
    87   private: 
     84  protected: 
    8885    //! Mapping of global index to the corresponding server 
    8986    boost::unordered_map<size_t,int> globalIndexToServerMapping_; 
  • XIOS/trunk/src/node/axis.cpp

    r619 r620  
    8585      } 
    8686      else this->ni.setValue(size); 
    87  
     87      std::cout <<  "value " <<  value <<  std::endl; 
    8888      StdSize true_size = value.numElements(); 
    8989      if (this->ni.getValue() != true_size) 
     
    311311  } 
    312312 
    313   void CAxis::setTransformations(const std::vector<ETransformationType>& transformations) 
     313  void CAxis::setTransformations(const std::vector<CTransformation*>& transformations) 
    314314  { 
    315315    transformations_ = transformations; 
     316  } 
     317 
     318  std::vector<CTransformation*> CAxis::getAllTransformations(void) 
     319  { 
     320    if (!hasTransformation()) 
     321      setTransformations(this->getVirtualTransformationGroup()->getAllChildren()); 
     322 
     323    return transformations_; 
    316324  } 
    317325 
     
    333341    if (refer_ptr->hasTransformation()) 
    334342      for (int idx = 0; idx < refAxis.size(); ++idx) 
    335         refAxis[idx]->setTransformations(refer_ptr->getTransformations()); 
     343        refAxis[idx]->setTransformations(refer_ptr->getAllTransformations()); 
    336344  } 
    337345 
     
    347355        if (node.getElementName() == tranformation) { 
    348356           this->getVirtualTransformationGroup()->parseChild(node); 
    349            transformations_.push_back(eInverse); 
    350357        } 
    351358      } while (node.goToNextElement()) ; 
    352359      node.goToParentElement(); 
    353360    } 
    354   } 
    355  
    356   const std::vector<ETransformationType>& CAxis::getTransformations() 
    357   { 
    358     return transformations_; 
    359   } 
    360  
    361    DEFINE_REF_FUNC(Axis,axis) 
     361    setTransformations(this->getVirtualTransformationGroup()->getAllChildren()); 
     362  } 
     363 
     364  DEFINE_REF_FUNC(Axis,axis) 
    362365 
    363366   ///--------------------------------------------------------------- 
  • XIOS/trunk/src/node/axis.hpp

    r619 r620  
    9595 
    9696         bool hasTransformation(); 
    97          void setTransformations(const std::vector<ETransformationType>&); 
    98          const std::vector<ETransformationType>& getTransformations(); 
    9997         void solveInheritanceTransformation(); 
     98         std::vector<CTransformation*> getAllTransformations(); 
    10099 
    101100      public: 
     
    109108 
    110109 
    111          void checkTransformation(); 
     110 
     111         void setTransformations(const std::vector<CTransformation*>&); 
    112112      private: 
    113113         bool isChecked; 
    114114         bool areClientAttributesChecked_; 
    115115         std::set<StdString> relFiles; 
    116          std::vector<ETransformationType> transformations_; 
     116         std::vector<CTransformation*> transformations_; 
    117117         bool isDistributed_; 
    118118 
  • XIOS/trunk/src/node/field.cpp

    r619 r620  
    549549     } 
    550550     solveGridDomainAxisRef(doSending2Sever); 
     551     solveCheckMaskIndex(doSending2Sever); 
    551552     if (context->hasClient) 
    552553     { 
    553554       solveTransformedGrid(); 
    554555     } 
    555      solveCheckMaskIndex(doSending2Sever); 
    556556   } 
    557557 
     
    804804         gridRefOfFieldRef->transformGrid(relGridRef); 
    805805         filterSources_.push_back(fieldRef); 
    806          transformations_ = relGridRef->getTransformations(); 
    807          switch (gridRefOfFieldRef->getGridElementType()) { 
    808          case CGrid::GRID_ONLY_AXIS: 
    809            filter = new CAxisFilter(gridRefOfFieldRef, relGridRef); 
    810            break; 
    811          default: 
    812            break; 
    813          } 
    814          setAlgorithms(); 
     806//         transformations_ = relGridRef->getTransformations(); 
     807//         switch (gridRefOfFieldRef->getGridElementType()) { 
     808//         case CGrid::GRID_ONLY_AXIS: 
     809////           filter = new CAxisFilter(gridRefOfFieldRef, relGridRef); 
     810////           break; 
     811//         default: 
     812//           filter = new CAxisFilter(gridRefOfFieldRef, relGridRef); 
     813//           break; 
     814//         } 
     815//         setAlgorithms(); 
    815816       } 
    816817     } 
     
    818819 
    819820 
    820   void CField::setAlgorithms() 
    821   { 
    822     std::vector<ETransformationType>::iterator itTrans  = transformations_.begin(), 
    823                                                iteTrans = transformations_.end(); 
    824     std::set<ETransformationType> tmp; 
    825     for (; itTrans != iteTrans; ++itTrans) 
    826     { 
    827       if (tmp.end() == tmp.find(*itTrans)) 
    828       { 
    829         switch (*itTrans) { 
    830         case eInverse: 
    831           algorithms_.push_back(new CInvertAlgorithm()); 
    832           break; 
    833         default: 
    834           break; 
     821//  void CField::setAlgorithms() 
     822//  { 
     823//    std::vector<ETransformationType>::iterator itTrans  = transformations_.begin(), 
     824//                                               iteTrans = transformations_.end(); 
     825//    std::set<ETransformationType> tmp; 
     826//    for (; itTrans != iteTrans; ++itTrans) 
     827//    { 
     828//      if (tmp.end() == tmp.find(*itTrans)) 
     829//      { 
     830//        switch (*itTrans) { 
     831//        case eInverse: 
     832//          algorithms_.push_back(new CInvertAlgorithm()); 
     833//          break; 
     834//        default: 
     835//          break; 
     836//        } 
     837//      } 
     838//      tmp.insert(*itTrans); 
     839//    } 
     840//  } 
     841 
     842   const std::vector<CField*>& CField::getFilterSources() 
     843   { 
     844     return filterSources_; 
     845   } 
     846 
     847   void CField::applyFilter(const CArray<double, 1>& dataToSend, CArray<double,1>& dataToReceive) 
     848   { 
     849     std::vector<CField*>::iterator  itFilterSrc, iteFilterSrc; 
     850     if (!filterSources_.empty()) 
     851     { 
     852        itFilterSrc = filterSources_.begin(); iteFilterSrc = filterSources_.end(); 
     853        for (; itFilterSrc != iteFilterSrc; ++itFilterSrc) 
     854        { 
     855          if (0 != (*itFilterSrc)->grid->getTransformations()) 
     856          { 
     857             const std::map<int, CArray<int,1>* >& localIndexToSend = (*itFilterSrc)->grid->getTransformations()->getLocalIndexToSendFromGridSource(); 
     858             const std::map<int, std::vector<CArray<int,1>* > > localIndexToReceive = (*itFilterSrc)->grid->getTransformations()->getLocalIndexToReceiveOnGridDest(); 
     859             sendAndReceiveTransformedData(localIndexToSend, dataToSend, 
     860                                           localIndexToReceive, dataToReceive); 
     861          } 
     862 
    835863        } 
    836       } 
    837       tmp.insert(*itTrans); 
    838     } 
    839   } 
    840  
    841    const std::vector<CField*>& CField::getFilterSources() 
    842    { 
    843      return filterSources_; 
    844    } 
    845  
    846    void CField::applyFilter() 
    847    { 
    848      filter->setInputs(filterSources_); 
    849      filter->setOutput(this); 
    850      filter->apply(algorithms_); 
    851  
     864 
     865//        std::cout << "it data " << (*it)->data << std::endl; 
     866//        std::cout << "it filtered data " << (*it)->filteredData << std::endl; 
     867     } 
     868   } 
     869 
     870   void CField::sendAndReceiveTransformedData(const std::map<int, CArray<int,1>* >& localIndexToSend, 
     871                                              const CArray<double, 1>& dataSrc, 
     872                                              const std::map<int, std::vector<CArray<int,1>* > >& localIndexToReceive, 
     873                                              CArray<double,1>& dataDest) 
     874   { 
     875     CContext* context = CContext::getCurrent(); 
     876     CContextClient* client=context->client; 
     877 
     878     // Sending data from field sources to do transformations 
     879     std::map<int, CArray<int,1>* >::const_iterator itbSend = localIndexToSend.begin(), itSend, 
     880                                                    iteSend = localIndexToSend.end(); 
     881     int sendBuffSize = 0; 
     882     for (itSend = itbSend; itSend != iteSend; ++itSend) sendBuffSize = (sendBuffSize < (itSend->second)->numElements()) 
     883                                                                        ? (itSend->second)->numElements(): sendBuffSize; 
     884     double* sendBuff; 
     885     if (0 != sendBuffSize) sendBuff = new double [sendBuffSize]; 
     886     for (itSend = itbSend; itSend != iteSend; ++itSend) 
     887     { 
     888       int destRank = itSend->first; 
     889       CArray<int,1>* localIndex_p = itSend->second; 
     890       int countSize = localIndex_p->numElements(); 
     891       for (int idx = 0; idx < countSize; ++idx) 
     892       { 
     893         sendBuff[idx] = dataSrc((*localIndex_p)(idx)); 
     894       } 
     895       MPI_Send(sendBuff, countSize, MPI_DOUBLE, destRank, 12, client->intraComm); 
     896     } 
     897 
     898     // Receiving data on destination fields 
     899     std::map<int, std::vector<CArray<int,1>* > >::const_iterator itbRecv = localIndexToReceive.begin(), itRecv, 
     900                                                                  iteRecv = localIndexToReceive.end(); 
     901     int recvBuffSize = 0; 
     902     for (itRecv = itbRecv; itRecv != iteRecv; ++itRecv) recvBuffSize = (recvBuffSize < (itRecv->second).size()) 
     903                                                                        ? (itRecv->second).size() : recvBuffSize; 
     904     double* recvBuff; 
     905     if (0 != recvBuffSize) recvBuff = new double [recvBuffSize]; 
     906     for (itRecv = itbRecv; itRecv != iteRecv; ++itRecv) 
     907     { 
     908       MPI_Status status; 
     909       int srcRank = itRecv->first; 
     910       int countSize = (itRecv->second).size(); 
     911       MPI_Recv(recvBuff, recvBuffSize, MPI_DOUBLE, srcRank, 12, client->intraComm, &status); 
     912       for (int idx = 0; idx < countSize; ++idx) 
     913       { 
     914         CArray<int,1>* localIndex_p = (itRecv->second)[idx]; 
     915         int numIndex = localIndex_p->numElements(); 
     916         for (int i = 0; i < numIndex; ++i) 
     917         { 
     918           dataDest((*localIndex_p)(i)) = recvBuff[idx]; 
     919         } 
     920       } 
     921     } 
     922 
     923     if (0 != sendBuffSize) delete [] sendBuff; 
     924     if (0 != recvBuffSize) delete [] recvBuff; 
    852925   } 
    853926 
  • XIOS/trunk/src/node/field.hpp

    r619 r620  
    9898         template <int N> bool updateFilteredData(CArray<double, N>&   data); 
    9999         template<int N> 
    100          void updateDataWithoutOperation(const CArray<double, N>& data); 
     100         void updateDataWithoutOperation(const CArray<double, N>& _data, CArray<double,1>& updatedData); 
    101101         bool updateDataFromExpression(const CArray<double, 1>&   data); 
    102102         void setDataFromExpression(const CArray<double, 1>& _data) ; 
     
    181181 
    182182        const std::vector<CField*>& getFilterSources(); 
    183         void applyFilter(); 
    184         void setAlgorithms(); 
     183        void applyFilter(const CArray<double, 1>& dataToSend, CArray<double,1>& dataToReceive); 
     184        void sendAndReceiveTransformedData(const std::map<int, CArray<int,1>* >& localIndexToSend, 
     185                                           const CArray<double, 1>& dataSrc, 
     186                                           const std::map<int, std::vector<CArray<int,1>* > >& localIndexToReceive, 
     187                                           CArray<double,1>& dataDest); 
    185188      public : 
    186189         /// Propriétés privées /// 
  • XIOS/trunk/src/node/field_impl.hpp

    r619 r620  
    3333        if (!fieldFilterSources.empty()) 
    3434        { 
    35           itFilterSrc = fieldFilterSources.begin(); iteFilterSrc = fieldFilterSources.end(); 
    36           for (; itFilterSrc != iteFilterSrc; ++itFilterSrc) (*itFilterSrc)->updateDataWithoutOperation(_data); 
    37           (*it)->applyFilter(); 
    38           std::cout << "it data " << (*it)->data << std::endl; 
    39           std::cout << "it filtered data " << (*it)->filteredData << std::endl; 
     35          itFilterSrc  = fieldFilterSources.begin(); 
     36          iteFilterSrc = fieldFilterSources.end(); 
     37          for (; itFilterSrc != iteFilterSrc; ++itFilterSrc) 
     38          { 
     39            (*itFilterSrc)->updateDataWithoutOperation(_data, (*itFilterSrc)->data); 
     40            (*it)->updateDataWithoutOperation(_data, (*it)->filteredData); 
     41            (*it)->applyFilter((*itFilterSrc)->data, (*it)->filteredData); 
     42          } 
    4043          if ((*it)->hasOutputFile || (*it)->hasFieldOut) (*it)->updateFilteredData((*it)->filteredData); 
     44//          itFilterSrc = fieldFilterSources.begin(); iteFilterSrc = fieldFilterSources.end(); 
     45//          for (; itFilterSrc != iteFilterSrc; ++itFilterSrc) (*itFilterSrc)->updateDataWithoutOperation(_data); 
     46//          (*it)->applyFilter(); 
     47//          std::cout << "it data " << (*it)->data << std::endl; 
     48//          std::cout << "it filtered data " << (*it)->filteredData << std::endl; 
     49//          if ((*it)->hasOutputFile || (*it)->hasFieldOut) (*it)->updateFilteredData((*it)->filteredData); 
    4150        } 
    4251        else 
     
    7079 
    7180   template<int N> 
    72    void CField::updateDataWithoutOperation(const CArray<double, N>& _data) 
     81   void CField::updateDataWithoutOperation(const CArray<double, N>& _data, CArray<double,1>& updatedData) 
    7382   { 
    74      if (this->data.numElements() != this->grid->storeIndex_client.numElements()) 
     83     if (updatedData.numElements() != this->grid->storeIndex_client.numElements()) 
    7584     { 
    76         this->data.resize(this->grid->storeIndex_client.numElements()); 
    77         this->grid->inputField(_data, this->data); 
     85        updatedData.resize(this->grid->storeIndex_client.numElements()); 
     86        this->grid->inputField(_data, updatedData); 
    7887     } 
    7988   } 
  • XIOS/trunk/src/node/grid.cpp

    r619 r620  
    1414#include "array_new.hpp" 
    1515#include "client_server_mapping_distributed.hpp" 
    16 #include "invert_algorithm.hpp" 
    17 #include "visitable.hpp" 
    1816 
    1917namespace xios { 
     
    2624      , vDomainGroup_(), vAxisGroup_(), axisList_(), isAxisListSet(false), isDomListSet(false), clientDistribution_(0), isIndexSent(false) 
    2725      , serverDistribution_(0), serverDistributionDescription_(0), clientServerMap_(0), writtenDataSize_(0), globalDim_() 
    28       , connectedDataSize_(), connectedServerRank_(), isDataDistributed_(true), algorithms_(), transformations_(), isTransformed_(false) 
     26      , connectedDataSize_(), connectedServerRank_(), isDataDistributed_(true), transformations_(0), isTransformed_(false) 
     27      , axisPositionInGrid_() 
    2928   { 
    3029     setVirtualDomainGroup(); 
     
    3736      , vDomainGroup_(), vAxisGroup_(), axisList_(), isAxisListSet(false), isDomListSet(false), clientDistribution_(0), isIndexSent(false) 
    3837      , serverDistribution_(0), serverDistributionDescription_(0), clientServerMap_(0), writtenDataSize_(0), globalDim_() 
    39       , connectedDataSize_(), connectedServerRank_(), isDataDistributed_(true), algorithms_(), transformations_(), isTransformed_(false) 
     38      , connectedDataSize_(), connectedServerRank_(), isDataDistributed_(true), transformations_(0), isTransformed_(false) 
     39      , axisPositionInGrid_() 
    4040   { 
    4141     setVirtualDomainGroup(); 
     
    5353    if (0 != serverDistribution_) delete serverDistribution_; 
    5454    if (0 != serverDistributionDescription_) delete serverDistributionDescription_; 
    55     for (std::vector<CGenericAlgorithm*>::iterator it = algorithms_.begin(); it != algorithms_.end(); ++it) delete *it; 
     55    if (0 != transformations_) delete transformations_; 
    5656   } 
    5757 
     
    324324      { 
    325325        int idx = 0; 
    326         std::vector<int> axisPositionMap; 
     326        axisPositionInGrid_.resize(0); 
    327327        for (int i = 0; i < axis_domain_order.numElements(); ++i) 
    328328        { 
    329329          if (false == axis_domain_order(i)) 
    330330          { 
    331             axisPositionMap.push_back(idx); 
     331            axisPositionInGrid_.push_back(idx); 
    332332            ++idx; 
    333333          } 
     
    339339        { 
    340340          if (sendAtt) 
    341             axisListP[i]->sendCheckedAttributes(globalDim_,axisPositionMap[i]); 
     341            axisListP[i]->sendCheckedAttributes(globalDim_,axisPositionInGrid_[i]); 
    342342          else 
    343             axisListP[i]->checkAttributesOnClient(globalDim_,axisPositionMap[i]); 
     343            axisListP[i]->checkAttributesOnClient(globalDim_,axisPositionInGrid_[i]); 
    344344          ++idx; 
    345345        } 
     
    347347      } 
    348348   } 
     349 
     350   std::vector<int> CGrid::getAxisPositionInGrid() const 
     351   { 
     352     return axisPositionInGrid_; 
     353   } 
     354 
    349355 
    350356   //--------------------------------------------------------------- 
     
    759765  { 
    760766    return serverDistribution_; 
     767  } 
     768 
     769  const CDistributionClient* CGrid::getDistributionClient() const 
     770  { 
     771    return clientDistribution_; 
    761772  } 
    762773 
     
    11031114  } 
    11041115 
    1105   CGrid::EElementType CGrid::getGridElementType() 
    1106   { 
    1107     EElementType gridType = GRID_ONLY_AXIS; 
    1108     int numElements = axis_domain_order.numElements(); 
    1109     if (1 == numElements) 
    1110     { 
    1111       if (true == axis_domain_order(0)) gridType = GRID_ONLY_DOMAIN; 
    1112     } 
    1113     else gridType = GRID_AXIS_DOMAIN; 
    1114   } 
    1115  
    1116   void CGrid::solveTransformations() 
    1117   { 
    1118     std::vector<CAxis*> axisPtr = getAxis(); 
    1119     for (std::vector<CAxis*>::iterator it = axisPtr.begin(); it != axisPtr.end(); ++it) 
    1120     { 
    1121       std::vector<ETransformationType> axisTransformation = (*it)->getTransformations(); 
    1122       std::vector<ETransformationType>::iterator itTrans  = axisTransformation.begin(), 
    1123                                                  iteTrans = axisTransformation.end(); 
    1124       for (;itTrans != iteTrans; ++ itTrans) 
    1125         transformations_.push_back(*itTrans); 
    1126     } 
    1127   } 
    1128  
    1129   void CGrid::setTransformationAlgorithms() 
    1130   { 
    1131     std::vector<ETransformationType>::iterator itTrans  = transformations_.begin(), 
    1132                                                iteTrans = transformations_.end(); 
    1133     std::set<ETransformationType> tmp; 
    1134     for (; itTrans != iteTrans; ++itTrans) 
    1135     { 
    1136       if (tmp.end() == tmp.find(*itTrans)) 
    1137       { 
    1138         switch (*itTrans) { 
    1139         case eInverse: 
    1140           algorithms_.push_back(new CInvertAlgorithm()); 
    1141           break; 
    1142         default: 
    1143           break; 
    1144         } 
    1145       } 
    1146       tmp.insert(*itTrans); 
    1147     } 
    1148   } 
    1149  
    1150   std::vector<ETransformationType> CGrid::getTransformations() 
     1116  bool CGrid::isTransformed() 
     1117  { 
     1118    return isTransformed_; 
     1119  } 
     1120 
     1121  void CGrid::setTransformed() 
     1122  { 
     1123    isTransformed_ = true; 
     1124  } 
     1125 
     1126  CGridTransformation* CGrid::getTransformations() 
    11511127  { 
    11521128    return transformations_; 
    1153   } 
    1154  
    1155   bool CGrid::isTransformed() 
    1156   { 
    1157     return isTransformed_; 
    1158   } 
    1159  
    1160   void CGrid::setTransformed() 
    1161   { 
    1162     isTransformed_ = true; 
    1163   } 
    1164  
    1165   const std::vector<CGenericAlgorithm*>& CGrid::getTransformationAlgo() 
    1166   { 
    1167     return algorithms_; 
    11681129  } 
    11691130 
     
    11891150    } 
    11901151 
    1191     EElementType gridType = getGridElementType(); 
    1192     CGenericTransformation* gTransform = 0; 
    1193     switch (gridType) { 
    1194     case GRID_ONLY_AXIS: 
    1195       gTransform = new CAxisTransformation(this->getAxis(), transformedGrid->getAxis()); 
    1196       break; 
    1197     case GRID_ONLY_DOMAIN: 
    1198       break; 
    1199     case GRID_AXIS_DOMAIN: 
    1200       break; 
    1201     default: 
    1202       break; 
    1203     } 
    1204  
    1205     transformedGrid->solveTransformations(); 
    1206     transformedGrid->setTransformationAlgorithms(); 
    1207     gTransform->apply(transformedGrid->algorithms_); 
    1208     if (0 != gTransform) delete gTransform; 
     1152    transformations_ = new CGridTransformation(transformedGrid, this); 
     1153    transformations_->computeTransformationMapping(); 
     1154    std::cout << "send index " << *(transformations_->getLocalIndexToSendFromGridSource()[0]) << std::endl; 
     1155    std::cout << "receive index " << *(transformations_->getLocalIndexToReceiveOnGridDest()[0][0]) << std::endl; 
    12091156  } 
    12101157 
  • XIOS/trunk/src/node/grid.hpp

    • Property svn:executable set to *
    r619 r620  
    1717#include "utils.hpp" 
    1818#include "transformation_enum.hpp" 
    19 #include "visitor.hpp" 
     19#include "grid_transformation.hpp" 
    2020 
    2121namespace xios { 
     
    3232   class CServerDistributionDescription; 
    3333   class CClientServerMapping; 
     34   class CGridTransformation; 
    3435 
    3536   ///-------------------------------------------------------------- 
     
    176177         std::vector<int> getGlobalDimension(); 
    177178         bool isScalarGrid() const; 
     179         std::vector<int> getAxisPositionInGrid() const; 
    178180 
    179181         bool doGridHaveDataToWrite(); 
     
    182184 
    183185         const CDistributionServer* getDistributionServer() const; 
     186         const CDistributionClient* getDistributionClient() const; 
     187         CGridTransformation* getTransformations(); 
    184188 
    185189         void transformGrid(CGrid* transformedGrid); 
    186190         bool isTransformed(); 
    187191         void setTransformed(); 
    188          EElementType getGridElementType(); 
    189  
    190          std::vector<ETransformationType> getTransformations(); 
    191          const std::vector<CGenericAlgorithm*>& getTransformationAlgo(); 
     192//         EElementType getGridElementType(); 
     193// 
     194//         std::vector<ETransformationType> getTransformations(); 
     195//         const std::vector<CGenericAlgorithm*>& getTransformationAlgo(); 
    192196 
    193197      public: 
     
    207211         void checkMask(void) ; 
    208212 
    209          std::vector<CGenericAlgorithm*> algorithms_; 
    210213      private: 
    211214       template<int N> 
     
    252255 
    253256 
    254         std::vector<ETransformationType> transformations_; 
     257//        std::vector<ETransformationType> transformations_; 
    255258        bool isTransformed_; 
     259        std::vector<int> axisPositionInGrid_; 
     260        CGridTransformation* transformations_; 
    256261   }; // class CGrid 
    257262 
  • XIOS/trunk/src/test/test_new_features.f90

    r619 r620  
    1515  CHARACTER(len=15) :: calendar_type 
    1616  TYPE(xios_context) :: ctx_hdl 
    17   INTEGER,PARAMETER :: ni_glo=100 
    18   INTEGER,PARAMETER :: nj_glo=100 
    19   INTEGER,PARAMETER :: llm=10 
     17  INTEGER,PARAMETER :: ni_glo=5 
     18  INTEGER,PARAMETER :: nj_glo=5 
     19  INTEGER,PARAMETER :: llm=5 
    2020  DOUBLE PRECISION  :: lval(llm)=1, tsTemp 
    2121  TYPE(xios_field) :: field_hdl 
     
    2525 
    2626  DOUBLE PRECISION,DIMENSION(ni_glo,nj_glo) :: lon_glo,lat_glo 
    27   DOUBLE PRECISION :: field_A_glo(ni_glo,nj_glo,llm), lval_ni(ni_glo), lval_nj(nj_glo) 
    28   DOUBLE PRECISION,ALLOCATABLE :: lon(:,:),lat(:,:),field_A(:,:,:), field_All_Axis(:,:,:), lonvalue(:) , field_Axis(:), lvaln(:), field_Two_Axis(:,:) 
     27  DOUBLE PRECISION :: field_A_glo(ni_glo,nj_glo,llm), lval_ni_glo(ni_glo), lval_nj_glo(nj_glo) 
     28  DOUBLE PRECISION,ALLOCATABLE :: lon(:,:),lat(:,:),field_A(:,:,:), field_All_Axis(:,:,:), lonvalue(:) , field_Axis(:), lvaln(:), lval_ni(:), lval_nj(:), field_Two_Axis(:,:) 
    2929  INTEGER :: ni,ibegin,iend,nj,jbegin,jend, nAxis, axisBegin, axisEnd 
    3030  INTEGER :: i,j,l,ts,n 
     
    4747      lon_glo(i,j)=(i-1)+(j-1)*ni_glo 
    4848      lat_glo(i,j)=1000+(i-1)+(j-1)*ni_glo 
    49       lval_ni(i) = i-1 
     49      lval_ni_glo(i) = i-1 
    5050      DO l=1,llm 
    5151        field_A_glo(i,j,l)=(i-1)+(j-1)*ni_glo+10000*l 
    5252      ENDDO 
    5353    ENDDO 
    54     lval_nj(j) = j-1 
     54    lval_nj_glo(j) = j-1 
    5555  ENDDO 
    5656  ni=ni_glo ; ibegin=0 
     
    8080 
    8181 
    82   ALLOCATE(lon(ni,nj),lat(ni,nj),field_A(0:ni+1,-1:nj+2,llm),lonvalue(ni*nj), field_Axis(nAxis), field_All_Axis(1:ni,1:nj,llm), lvaln(nAxis), field_Two_Axis(ni_glo,1:nj)) 
     82  ALLOCATE(lon(ni,nj),lat(ni,nj),field_A(0:ni+1,-1:nj+2,llm),lonvalue(ni*nj), field_Axis(nAxis), field_All_Axis(1:ni,1:nj,llm), lvaln(nAxis), lval_ni(ni), lval_nj(nj), field_Two_Axis(ni_glo,1:nj)) 
    8383  lon(:,:)=lon_glo(ibegin+1:iend+1,jbegin+1:jend+1) 
    8484  lat(:,:)=lat_glo(ibegin+1:iend+1,jbegin+1:jend+1) 
     
    8686  field_Axis(1:nAxis)  = field_A_glo(1,1,axisBegin+1:axisEnd+1) 
    8787  field_All_Axis(1:ni,1:nj,:) = field_A_glo(ibegin+1:iend+1,jbegin+1:jend+1,:) 
    88   field_Two_Axis(:,1:nAxis)  = field_A_glo(:,jbegin+1:jend+1,1) 
     88  field_Two_Axis(:,1:nj)  = field_A_glo(:,jbegin+1:jend+1,1) 
    8989  lvaln(1:nAxis) = lval(axisBegin+1:axisEnd+1) 
     90  lval_nj(1:nj) = lval_nj_glo(jbegin+1:jend+1); 
     91  lval_ni(1:ni) = lval_ni_glo(ibegin+1:iend+1); 
    9092 
    9193  CALL xios_context_initialize("test",comm) 
     
    103105  CALL xios_set_domain_attr("domain_A",data_dim=2, data_ibegin=-1, data_ni=ni+2, data_jbegin=-2, data_nj=nj+4) 
    104106  CALL xios_set_domain_attr("domain_A",lonvalue=RESHAPE(lon,(/ni*nj/)),latvalue=RESHAPE(lat,(/ni*nj/))) 
    105   CALL xios_set_domain_attr("domain_A",zoom_ibegin=40, zoom_ni=20, zoom_jbegin=40, zoom_nj=10) 
     107!  CALL xios_set_domain_attr("domain_A",zoom_ibegin=40, zoom_ni=20, zoom_jbegin=40, zoom_nj=10) 
    106108  CALL xios_set_fieldgroup_attr("field_definition",enabled=.TRUE.) 
    107109 
Note: See TracChangeset for help on using the changeset viewer.