Changeset 619


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

Implementing the first prototype of filter

+) Create new class filter
+) Implement class for specific algorithm
+) Implement inversing algorithm

Test
+) On Curie
+) Grid with one axis: passed

Location:
XIOS/trunk
Files:
19 added
19 edited

Legend:

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

    r586 r619  
    1010     <field id="field_A"  operation="average" freq_op="3600s" grid_ref="grid_A" /> 
    1111     <field id="field_Axis"  operation="average" freq_op="3600s" grid_ref="grid_Axis" /> 
     12     <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" /> 
    1214     <field id="field_All_Axis" operation="average" freq_op="3600s" grid_ref="grid_All_Axis" /> 
    1315     <field id="field_Scalar" operation="average" freq_op="3600s" grid_ref="ScalarGrid" /> 
     
    1719   <file_definition type="multiple_file" par_access="collective" output_freq="6h" output_level="10" enabled=".TRUE."> 
    1820     <file id="output" name="output"> 
    19 <!--        <field field_ref="field_A" />--> 
     21        <field field_ref="field_A" /> 
    2022     </file> 
    2123     <file id="output_Axis" name="output_Axis" type="one_file"> 
    22         <field field_ref="field_Axis" /> 
     24<!--        <field field_ref="field_Axis" />--> 
     25     </file> 
     26     <file id="output_Axis_transformed" name="output_Axis_transformed" type="one_file"> 
     27        <field field_ref="field_Axis_transformed" /> 
    2328     </file> 
    2429     <file id="output_All_Axis" name="output_All_Axis" type="one_file"> 
     
    3540     <axis id="axis_B" /> 
    3641     <axis id="axis_C" zoom_size="2" zoom_end="2"/> 
    37      <axis id="axis_D" zoom_size="2" zoom_end="3"/> 
     42     <axis id="axis_D" /> 
     43     <axis id="axis_E" axis_ref="axis_B"> 
     44        <transformation type="inverse" /> 
     45<!--        <transformation type="zoom" />--> 
     46     </axis> 
    3847   </axis_definition> 
    3948 
     
    5059       <grid id="grid_Axis"> 
    5160         <axis axis_ref="axis_D" /> 
     61       </grid> 
     62       <grid id="grid_Two_Axis"> 
     63         <axis axis_ref="axis_A" /> 
     64         <axis axis_ref="axis_B" /> 
     65       </grid> 
     66       <grid id="grid_Axis_tranformed"> 
     67         <axis axis_ref="axis_A" /> 
     68         <axis axis_ref="axis_E" /> 
    5269       </grid> 
    5370       <grid id="grid_All_Axis"> 
  • XIOS/trunk/src/config/node_type.conf

    • Property svn:executable set to *
    r591 r619  
    3131#endif //__XIOS_CCalendarWrapper__ 
    3232 
     33#ifdef __XIOS_CTransformation__ 
     34   DECLARE_NODE(Transformation, transformation) 
     35#endif //__XIOS_CTransformation__ 
     36 
    3337#ifdef __XIOS_CContext__ 
    3438   DECLARE_NODE_PAR(Context, context) 
  • XIOS/trunk/src/group_factory_decl.cpp

    r501 r619  
    2525  macro(CContextGroup) 
    2626  macro(CVariableGroup) 
     27  macro(CTransformationGroup) 
    2728} 
  • XIOS/trunk/src/group_template_decl.cpp

    r501 r619  
    66#  define macro(T) \ 
    77  template class CGroupTemplate<C##T, C##T##Group, C##T##Attributes> ; 
    8    
    9   macro(Context)  
    10   macro(Field)  
    11   macro(File)  
    12   macro(Domain)  
    13   macro(Grid)  
    14   macro(Axis)  
    15   macro(Variable)  
    16    
     8 
     9  macro(Context) 
     10  macro(Field) 
     11  macro(File) 
     12  macro(Domain) 
     13  macro(Grid) 
     14  macro(Axis) 
     15  macro(Variable) 
     16  macro(Transformation) 
     17 
    1718 
    1819} 
  • XIOS/trunk/src/node/axis.cpp

    r609 r619  
    8787 
    8888      StdSize true_size = value.numElements(); 
    89       if (size != true_size) 
     89      if (this->ni.getValue() != true_size) 
    9090         ERROR("CAxis::checkAttributes(void)", 
    9191               << "The array \'value\' of axis [ id = '" << getId() << "' , context = '" << CObjectFactory::GetCurrentContextId() << "' ] has a different size that the one defined by the \'size\' attribute"); 
     
    306306  } 
    307307 
     308  bool CAxis::hasTransformation() 
     309  { 
     310    return (!transformations_.empty()); 
     311  } 
     312 
     313  void CAxis::setTransformations(const std::vector<ETransformationType>& transformations) 
     314  { 
     315    transformations_ = transformations; 
     316  } 
     317 
     318  void CAxis::solveInheritanceTransformation() 
     319  { 
     320    if (this->hasTransformation()) return; 
     321 
     322    std::vector<CAxis*> refAxis; 
     323    CAxis* refer_sptr; 
     324    CAxis* refer_ptr = this; 
     325    while (refer_ptr->hasDirectAxisReference()) 
     326    { 
     327      refAxis.push_back(refer_ptr); 
     328      refer_sptr = refer_ptr->getDirectAxisReference(); 
     329      refer_ptr  = refer_sptr; 
     330      if (refer_ptr->hasTransformation()) break; 
     331    } 
     332 
     333    if (refer_ptr->hasTransformation()) 
     334      for (int idx = 0; idx < refAxis.size(); ++idx) 
     335        refAxis[idx]->setTransformations(refer_ptr->getTransformations()); 
     336  } 
     337 
     338  void CAxis::parse(xml::CXMLNode & node) 
     339  { 
     340    SuperClass::parse(node); 
     341 
     342    if (node.goToChildElement()) 
     343    { 
     344      StdString tranformation("transformation"); 
     345      do 
     346      { 
     347        if (node.getElementName() == tranformation) { 
     348           this->getVirtualTransformationGroup()->parseChild(node); 
     349           transformations_.push_back(eInverse); 
     350        } 
     351      } while (node.goToNextElement()) ; 
     352      node.goToParentElement(); 
     353    } 
     354  } 
     355 
     356  const std::vector<ETransformationType>& CAxis::getTransformations() 
     357  { 
     358    return transformations_; 
     359  } 
     360 
    308361   DEFINE_REF_FUNC(Axis,axis) 
    309362 
  • XIOS/trunk/src/node/axis.hpp

    • Property svn:executable set to *
    r595 r619  
    55#include "xios_spl.hpp" 
    66#include "group_factory.hpp" 
     7#include "virtual_node.hpp" 
    78 
    89#include "declare_group.hpp" 
    910#include "declare_ref_func.hpp" 
     11#include "declare_virtual_node.hpp" 
    1012#include "attribute_array.hpp" 
    1113#include "attribute_enum.hpp" 
    1214#include "attribute_enum_impl.hpp" 
    1315#include "server_distribution_description.hpp" 
     16#include "transformation.hpp" 
     17#include "transformation_enum.hpp" 
    1418 
    1519namespace xios { 
     
    1923   class CAxisAttributes; 
    2024   class CAxis; 
     25   class CTransformationGroup; 
     26   class CVirtualTransformationGroup; 
    2127 
     28   DECLARE_VIRTUAL_NODE(TransformationGroup); 
    2229   ///-------------------------------------------------------------- 
    2330 
     
    3239      : public CObjectTemplate<CAxis> 
    3340      , public CAxisAttributes 
     41      , public CVirtualTransformationGroup 
    3442   { 
    3543         enum EEventId 
     
    6977         virtual ~CAxis(void); 
    7078 
     79         virtual void parse(xml::CXMLNode & node); 
     80 
    7181         /// Accesseurs statiques /// 
    7282         static StdString GetName(void); 
     
    8393         void sendCheckedAttributes(const std::vector<int>& globalDim, int orderPositionInGrid, 
    8494                                    CServerDistributionDescription::ServerDistributionType disType = CServerDistributionDescription::BAND_DISTRIBUTION); 
     95 
     96         bool hasTransformation(); 
     97         void setTransformations(const std::vector<ETransformationType>&); 
     98         const std::vector<ETransformationType>& getTransformations(); 
     99         void solveInheritanceTransformation(); 
     100 
    85101      public: 
    86102        int zoom_begin_srv, zoom_end_srv, zoom_size_srv; 
     
    92108         void checkZoom(); 
    93109 
     110 
     111         void checkTransformation(); 
    94112      private: 
    95  
    96113         bool isChecked; 
    97114         bool areClientAttributesChecked_; 
    98115         std::set<StdString> relFiles; 
     116         std::vector<ETransformationType> transformations_; 
    99117         bool isDistributed_; 
    100118 
  • XIOS/trunk/src/node/context.cpp

    r598 r619  
    894894       { 
    895895         const std::pair<StdString, StdString>& prDomAxisId = enabledFields[j]->getRefDomainAxisIds(); 
    896          domainIds.insert(prDomAxisId.first); 
    897          axisIds.insert(prDomAxisId.second); 
     896         if ("" != prDomAxisId.first) domainIds.insert(prDomAxisId.first); 
     897         if ("" != prDomAxisId.second) axisIds.insert(prDomAxisId.second); 
    898898       } 
    899899     } 
  • XIOS/trunk/src/node/field.cpp

    r603 r619  
    1313#include "context_server.hpp" 
    1414#include <set> 
     15#include "axis_filter.hpp" 
     16#include "invert_algorithm.hpp" 
    1517 
    1618namespace xios{ 
     
    2729      , foperation(), hasInstantData(false), hasExpression(false) 
    2830      , active(false) , hasOutputFile(false),hasFieldOut(false), slotUpdateDate(NULL) 
    29       , processed(false), domAxisIds_("", ""), areAllReferenceSolved(false), areAllExpressionBuilt(false) 
     31      , processed(false), domAxisIds_("", ""), areAllReferenceSolved(false), areAllExpressionBuilt(false), filter(0) 
    3032      , isReadDataRequestPending(false) 
    3133      { setVirtualVariableGroup(); } 
     
    4042      , foperation(), hasInstantData(false), hasExpression(false) 
    4143      , active(false), hasOutputFile(false), hasFieldOut(false), slotUpdateDate(NULL) 
    42       , processed(false), domAxisIds_("", ""), areAllReferenceSolved(false), areAllExpressionBuilt(false) 
     44      , processed(false), domAxisIds_("", ""), areAllReferenceSolved(false), areAllExpressionBuilt(false), filter(0) 
    4345      , isReadDataRequestPending(false) 
    4446   { setVirtualVariableGroup(); } 
     
    5153      if (hasExpression) delete expression; 
    5254      if (slotUpdateDate != NULL) delete slotUpdateDate; 
     55      if (0 != filter) delete filter; 
    5356 
    5457   } 
     
    172175            int rank=(*it).first ; 
    173176            CArray<int,1>& index = *(it->second) ; 
     177                       std::cout << "rank " << index << std::endl; 
     178                       std::cout << "data " << data << std::endl; 
    174179            CArray<double,1> data_tmp(index.numElements()) ; 
    175180            for(int n=0;n<data_tmp.numElements();n++) data_tmp(n)=data(index(n)) ; 
     
    527532      return(this->last_operation); 
    528533   } 
    529  
    530    //---------------------------------------------------------------- 
    531  
    532 //   void CField::processEnabledField(void) 
    533 //   { 
    534 //      if (!processed) 
    535 //      { 
    536 //        processed = true; 
    537 //        solveRefInheritance(true); 
    538 //        solveBaseReference(); 
    539 //        solveOperation(); 
    540 //        solveGridReference(); 
    541 // 
    542 //        if (hasDirectFieldReference()) baseRefObject->processEnabledField(); 
    543 //        buildExpression(); 
    544 //        active = true; 
    545 //      } 
    546 //    } 
    547534 
    548535   void CField::solveAllReferenceEnabledField(bool doSending2Sever) 
     
    562549     } 
    563550     solveGridDomainAxisRef(doSending2Sever); 
     551     if (context->hasClient) 
     552     { 
     553       solveTransformedGrid(); 
     554     } 
    564555     solveCheckMaskIndex(doSending2Sever); 
    565556   } 
     
    576567     { 
    577568       areAllExpressionBuilt = true; 
    578 //       solveCheckMaskIndex(true); 
    579 //       solveCheckMaskIndex(); 
    580        if (hasDirectFieldReference()) baseRefObject->buildAllExpressionEnabledField(); 
     569       if (hasDirectFieldReference() && (grid_ref.isEmpty())) baseRefObject->buildAllExpressionEnabledField(); 
    581570       buildExpression(); 
    582571       active = true; 
     
    770759   } 
    771760 
     761   CGrid* CField::getGridRefOfBaseReference() 
     762   { 
     763     solveRefInheritance(true); 
     764     solveBaseReference(); 
     765     baseRefObject->solveGridReference(); 
     766 
     767     return baseRefObject->grid; 
     768   } 
     769 
     770   void CField::solveTransformedGrid() 
     771   { 
     772     if (!grid_ref.isEmpty() && (!field_ref.isEmpty())) 
     773     { 
     774       CField* fieldRef  = this; 
     775       CGrid* gridRefOfFieldRef = 0; 
     776       while (fieldRef->hasDirectFieldReference()) 
     777       { 
     778         if ((!(fieldRef->grid_ref.isEmpty())) && 
     779             (fieldRef->grid_ref.getValue() != grid_ref.getValue())) 
     780         { 
     781           gridRefOfFieldRef = fieldRef->getGridRefOfBaseReference(); 
     782           fieldRef->addReference(this); 
     783           fieldRef->solveGridDomainAxisRef(false); 
     784           fieldRef->solveCheckMaskIndex(false); 
     785           break; 
     786         } 
     787         CField* tmp = fieldRef->getDirectFieldReference(); 
     788         fieldRef = tmp; 
     789       } 
     790 
     791       if ((0 == gridRefOfFieldRef) && 
     792           (!(fieldRef->grid_ref.isEmpty())) && 
     793           (fieldRef->grid_ref.getValue() != grid_ref.getValue())) 
     794       { 
     795         gridRefOfFieldRef = fieldRef->getGridRefOfBaseReference(); 
     796         fieldRef->addReference(this); 
     797         fieldRef->solveGridDomainAxisRef(false); 
     798         fieldRef->solveCheckMaskIndex(false); 
     799       } 
     800 
     801       CGrid* relGridRef = CGrid::get(grid_ref.getValue()); 
     802       if ((0 != gridRefOfFieldRef) && (relGridRef != gridRefOfFieldRef) && (!(relGridRef->isTransformed()))) 
     803       { 
     804         gridRefOfFieldRef->transformGrid(relGridRef); 
     805         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(); 
     815       } 
     816     } 
     817   } 
     818 
     819 
     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; 
     835        } 
     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 
     852   } 
     853 
    772854   ///------------------------------------------------------------------- 
    773855 
  • XIOS/trunk/src/node/field.hpp

    • Property svn:executable set to *
    r599 r619  
    1515#include "expr_node.hpp" 
    1616#include "declare_ref_func.hpp" 
     17#include "generic_filter.hpp" 
     18#include "transformation_enum.hpp" 
    1719 
    1820 
     
    2830   class CGrid; 
    2931   class CContext ; 
     32   class CGenericFilter; 
     33 
    3034   ///-------------------------------------------------------------- 
    3135 
     
    9296 
    9397         template <int N> bool updateData(const CArray<double, N>&   data); 
     98         template <int N> bool updateFilteredData(CArray<double, N>&   data); 
     99         template<int N> 
     100         void updateDataWithoutOperation(const CArray<double, N>& data); 
    94101         bool updateDataFromExpression(const CArray<double, 1>&   data); 
    95102         void setDataFromExpression(const CArray<double, 1>& _data) ; 
     
    116123         void buildAllExpressionEnabledField(); 
    117124         void solveGridDomainAxisRef(bool checkAtt); 
    118  
     125         void solveTransformedGrid(); 
     126         CGrid* getGridRefOfBaseReference(); 
    119127 
    120128//         virtual void fromBinary(StdIStream & is); 
     
    171179 
    172180        const std::pair<StdString, StdString>& getRefDomainAxisIds(); 
     181 
     182        const std::vector<CField*>& getFilterSources(); 
     183        void applyFilter(); 
     184        void setAlgorithms(); 
    173185      public : 
    174186         /// Propriétés privées /// 
     
    193205         CArray<double, 1> data; 
    194206         CArray<double, 1> instantData; 
     207         CArray<double, 1> filteredData; 
    195208         bool hasInstantData ; 
    196209         map<int, CArray<double,1>* > data_srv ; 
     
    214227         std::pair<StdString,StdString> domAxisIds_; 
    215228         bool isReadDataRequestPending; 
     229         std::vector<CField*> filterSources_; 
     230         std::vector<CGenericAlgorithm*> algorithms_; 
     231         std::vector<ETransformationType> transformations_; 
    216232         DECLARE_REF_FUNC(Field,field) 
    217 //       public: 
    218 //         bool hasDirectFieldReference(void) const; 
    219 //         CField* getDirectFieldReference(void) const; 
    220 //         CField* getBaseFieldReference(void) const; 
    221 //         void addReference(CField* field); 
    222 //         const std::vector<CField*> & getAllReference(void) const; 
    223 //void solveRefInheritance(bool apply); 
    224 //void solveBaseReference(void); 
    225 //         void removeRefInheritance(); 
    226 //         const StdString & getBaseFieldId(void) const; 
    227 // 
    228 //         std::vector<CField*> refObject; 
    229 //         CField* baseRefObject; 
    230  
    231233 
    232234   }; // class CField 
  • XIOS/trunk/src/node/field_impl.hpp

    r599 r619  
    2525    { 
    2626      const std::vector<CField*>& refField=getAllReference(); 
    27       std::vector<CField*>::const_iterator  it = refField.begin(), end = refField.end(); 
    28  
    29       for (; it != end; it++) (*it)->setData(_data); 
    30       if (hasOutputFile || hasFieldOut) updateData(_data); 
     27      std::vector<CField*>::const_iterator  it = refField.begin(), end = refField.end(), 
     28                                            itFilterSrc, iteFilterSrc; 
     29 
     30      for (; it != end; it++) 
     31      { 
     32        const std::vector<CField*>& fieldFilterSources = (*it)->getFilterSources(); 
     33        if (!fieldFilterSources.empty()) 
     34        { 
     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; 
     40          if ((*it)->hasOutputFile || (*it)->hasFieldOut) (*it)->updateFilteredData((*it)->filteredData); 
     41        } 
     42        else 
     43        { 
     44          (*it)->setData(_data); 
     45          if (hasOutputFile || hasFieldOut) updateData(_data); 
     46        } 
     47 
     48      } 
     49 
    3150    } 
    3251  } 
     
    5069  } 
    5170 
    52    template <int N> 
    53    bool CField::updateData(const CArray<double, N>& _data) 
     71   template<int N> 
     72   void CField::updateDataWithoutOperation(const CArray<double, N>& _data) 
     73   { 
     74     if (this->data.numElements() != this->grid->storeIndex_client.numElements()) 
     75     { 
     76        this->data.resize(this->grid->storeIndex_client.numElements()); 
     77        this->grid->inputField(_data, this->data); 
     78     } 
     79   } 
     80 
     81   template<int N> 
     82   bool CField::updateFilteredData(CArray<double, N>& filteredData) 
    5483   { 
    5584      CContext* context=CContext::getCurrent(); 
     
    7099      if (doOperation) 
    71100      { 
    72          if (this->data.numElements() != this->grid->storeIndex_client.numElements()) 
    73          { 
    74             this->data.resize(this->grid->storeIndex_client.numElements()); 
    75          } 
    76  
    77          CArray<double,1> input(data.numElements()); 
    78          this->grid->inputField(_data, input); 
    79          (*this->foperation)(input); 
     101         if (this->data.numElements() != filteredData.numElements()) 
     102         { 
     103            this->data.resize(filteredData.numElements()); 
     104         } 
     105 
     106         (*this->foperation)(filteredData); 
    80107 
    81108         *last_operation = currDate; 
     
    106133         } 
    107134 
    108          if (hasFieldOut) 
    109          { 
    110            fieldOut->setDataFromExpression(data); 
    111          } 
     135//         if (hasFieldOut) 
     136//         { 
     137//           fieldOut->setDataFromExpression(data); 
     138//         } 
    112139         return (true); 
    113140      } 
     
    116143   } 
    117144 
    118    bool CField::updateDataFromExpression(const CArray<double, 1>& _data) 
     145   template <int N> 
     146   bool CField::updateData(const CArray<double, N>& _data) 
    119147   { 
    120148      CContext* context=CContext::getCurrent(); 
     
    140168         } 
    141169 
    142         (*this->foperation)(_data); 
     170         CArray<double,1> input(data.numElements()); 
     171         this->grid->inputField(_data, input); 
     172         (*this->foperation)(input); 
    143173 
    144174         *last_operation = currDate; 
     
    179209   } 
    180210 
     211   bool CField::updateDataFromExpression(const CArray<double, 1>& _data) 
     212   { 
     213      CContext* context=CContext::getCurrent(); 
     214      const CDate & currDate = context->getCalendar()->getCurrentDate(); 
     215      const CDate opeDate      = *last_operation + freq_operation; 
     216      const CDate writeDate    = *last_Write     + freq_write; 
     217      bool doOperation, doWrite; 
     218 
     219 
     220      info(50) << "CField::updateData " << currDate <<  " : send data to " << this->getBaseFieldId() << std::endl; 
     221      info(50) << "Next operation "  << opeDate<<std::endl; 
     222 
     223      doOperation = (opeDate <= currDate); 
     224      if (isOnceOperation) 
     225        if (isFirstOperation) doOperation=true; 
     226        else doOperation=false; 
     227 
     228      if (doOperation) 
     229      { 
     230         if (this->data.numElements() != this->grid->storeIndex_client.numElements()) 
     231         { 
     232            this->data.resize(this->grid->storeIndex_client.numElements()); 
     233         } 
     234 
     235        (*this->foperation)(_data); 
     236 
     237         *last_operation = currDate; 
     238         info(50) << "(*last_operation = currDate) : " << *last_operation << " = " << currDate << std::endl; 
     239      } 
     240 
     241      doWrite = (writeDate < (currDate + freq_operation)); 
     242      if (isOnceOperation) 
     243      { 
     244        if(isFirstOperation) 
     245        { 
     246          doWrite=true; 
     247          isFirstOperation=false; 
     248        } 
     249        else doWrite=false; 
     250      } 
     251 
     252      if (doWrite) 
     253      { 
     254         this->foperation->final(); 
     255         *last_Write = writeDate; 
     256         if (hasOutputFile) 
     257         { 
     258           info(50) << "(*last_Write = currDate) : " << *last_Write << " = " << currDate << std::endl; 
     259           CTimer::get("XIOS Send Data").resume(); 
     260           sendUpdateData(); 
     261           CTimer::get("XIOS Send Data").suspend(); 
     262         } 
     263 
     264         if (hasFieldOut) 
     265         { 
     266           fieldOut->setDataFromExpression(data); 
     267         } 
     268         return (true); 
     269      } 
     270 
     271      return (false); 
     272   } 
     273 
    181274  template <int N> 
    182275  void CField::getData(CArray<double, N>& _data) const 
  • XIOS/trunk/src/node/grid.cpp

    r600 r619  
    1414#include "array_new.hpp" 
    1515#include "client_server_mapping_distributed.hpp" 
     16#include "invert_algorithm.hpp" 
     17#include "visitable.hpp" 
    1618 
    1719namespace xios { 
     
    2426      , vDomainGroup_(), vAxisGroup_(), axisList_(), isAxisListSet(false), isDomListSet(false), clientDistribution_(0), isIndexSent(false) 
    2527      , serverDistribution_(0), serverDistributionDescription_(0), clientServerMap_(0), writtenDataSize_(0), globalDim_() 
    26       , connectedDataSize_(), connectedServerRank_(), isDataDistributed_(true) 
     28      , connectedDataSize_(), connectedServerRank_(), isDataDistributed_(true), algorithms_(), transformations_(), isTransformed_(false) 
    2729   { 
    2830     setVirtualDomainGroup(); 
     
    3537      , vDomainGroup_(), vAxisGroup_(), axisList_(), isAxisListSet(false), isDomListSet(false), clientDistribution_(0), isIndexSent(false) 
    3638      , serverDistribution_(0), serverDistributionDescription_(0), clientServerMap_(0), writtenDataSize_(0), globalDim_() 
    37       , connectedDataSize_(), connectedServerRank_(), isDataDistributed_(true) 
     39      , connectedDataSize_(), connectedServerRank_(), isDataDistributed_(true), algorithms_(), transformations_(), isTransformed_(false) 
    3840   { 
    3941     setVirtualDomainGroup(); 
     
    5153    if (0 != serverDistribution_) delete serverDistribution_; 
    5254    if (0 != serverDistributionDescription_) delete serverDistributionDescription_; 
     55    for (std::vector<CGenericAlgorithm*>::iterator it = algorithms_.begin(); it != algorithms_.end(); ++it) delete *it; 
    5356   } 
    5457 
     
    10931096        pAxis->solveRefInheritance(apply); 
    10941097        pAxis->solveBaseReference(); 
     1098        pAxis->solveInheritanceTransformation(); 
    10951099        if ((!pAxis->axis_ref.isEmpty()) && (pAxis->name.isEmpty())) 
    10961100          pAxis->name.setValue(pAxis->getBaseAxisReference()->getId()); 
    10971101      } 
    10981102    } 
     1103  } 
     1104 
     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() 
     1151  { 
     1152    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_; 
     1168  } 
     1169 
     1170  void CGrid::transformGrid(CGrid* transformedGrid) 
     1171  { 
     1172    if (transformedGrid->isTransformed()) return; 
     1173    transformedGrid->setTransformed(); 
     1174    if (axis_domain_order.numElements() != transformedGrid->axis_domain_order.numElements()) 
     1175    { 
     1176      ERROR("CGrid::transformGrid(CGrid* transformedGrid)", 
     1177           << "Two grids have different dimension size" 
     1178           << "Dimension of grid source " <<this->getId() << " is " << axis_domain_order.numElements() << std::endl 
     1179           << "Dimension of grid destination " <<transformedGrid->getId() << " is " << transformedGrid->axis_domain_order.numElements()); 
     1180    } 
     1181    else 
     1182    { 
     1183      int ssize = axis_domain_order.numElements(); 
     1184      for (int i = 0; i < ssize; ++i) 
     1185        if (axis_domain_order(i) != (transformedGrid->axis_domain_order)(i)) 
     1186          ERROR("CGrid::transformGrid(CGrid* transformedGrid)", 
     1187                << "Grids " <<this->getId() <<" and " << transformedGrid->getId() 
     1188                << " don't have elements in the same order"); 
     1189    } 
     1190 
     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; 
    10991209  } 
    11001210 
  • XIOS/trunk/src/node/grid.hpp

    r600 r619  
    1616#include "client_server_mapping.hpp" 
    1717#include "utils.hpp" 
     18#include "transformation_enum.hpp" 
     19#include "visitor.hpp" 
    1820 
    1921namespace xios { 
     
    5860         } ; 
    5961 
     62         enum EElementType 
     63         { 
     64           GRID_ONLY_AXIS, GRID_ONLY_DOMAIN, GRID_AXIS_DOMAIN 
     65         }; 
     66 
    6067         /// Constructeurs /// 
    6168         CGrid(void); 
     
    140147         void solveAxisRef(bool checkAtt); 
    141148         void solveDomainAxisRefInheritance(bool apply = true); 
     149         void solveTransformations(); 
    142150 
    143151         void sendAddDomain(const std::string& id=""); 
     
    175183         const CDistributionServer* getDistributionServer() const; 
    176184 
     185         void transformGrid(CGrid* transformedGrid); 
     186         bool isTransformed(); 
     187         void setTransformed(); 
     188         EElementType getGridElementType(); 
     189 
     190         std::vector<ETransformationType> getTransformations(); 
     191         const std::vector<CGenericAlgorithm*>& getTransformationAlgo(); 
     192 
    177193      public: 
    178194 
     
    191207         void checkMask(void) ; 
    192208 
     209         std::vector<CGenericAlgorithm*> algorithms_; 
    193210      private: 
    194211       template<int N> 
     
    214231        CAxisGroup* getVirtualAxisGroup() const; 
    215232        CDomainGroup* getVirtualDomainGroup() const; 
     233 
     234 
     235        void setTransformationAlgorithms(); 
     236 
    216237        std::vector<int> globalDim_; 
    217238      private: 
     
    229250        std::vector<int> connectedServerRank_; 
    230251        bool isDataDistributed_; 
     252 
     253 
     254        std::vector<ETransformationType> transformations_; 
     255        bool isTransformed_; 
    231256   }; // class CGrid 
    232257 
  • XIOS/trunk/src/node/node_enum.hpp

    r591 r619  
    1818         eVariable,gVariable, 
    1919         eContext,gContext, 
    20          eCalendarWrapper 
     20         eCalendarWrapper, 
     21         eTransformation 
    2122 
    2223//#include "node_type.conf" 
  • XIOS/trunk/src/node/node_type.hpp

    r591 r619  
    99#include "variable.hpp" 
    1010#include "context.hpp" 
     11#include "transformation.hpp" 
    1112 
    1213#endif // __XIOS_NODE_TYPE__ 
  • XIOS/trunk/src/object_factory_decl.cpp

    r549 r619  
    2424  macro(CCalendarWrapper) 
    2525  macro(CVariable) 
     26  macro(CTransformation) 
    2627 
    2728  macro(CFieldGroup) 
     
    3233  macro(CContextGroup) 
    3334  macro(CVariableGroup) 
     35  macro(CTransformationGroup) 
    3436} 
  • XIOS/trunk/src/object_template_decl.cpp

    r591 r619  
    88#include "axis.hpp" 
    99#include "variable.hpp" 
     10#include "transformation.hpp" 
    1011 
    1112 
     
    2021  template class CObjectTemplate<CAxis>; 
    2122  template class CObjectTemplate<CVariable>; 
     23  template class CObjectTemplate<CTransformation>; 
    2224 
    2325  template class CObjectTemplate<CContextGroup>; 
     
    2830  template class CObjectTemplate<CAxisGroup>; 
    2931  template class CObjectTemplate<CVariableGroup>; 
     32  template class CObjectTemplate<CTransformationGroup>; 
    3033} 
  • XIOS/trunk/src/test/test_new_features.f90

    r587 r619  
    1717  INTEGER,PARAMETER :: ni_glo=100 
    1818  INTEGER,PARAMETER :: nj_glo=100 
    19   INTEGER,PARAMETER :: llm=5 
     19  INTEGER,PARAMETER :: llm=10 
    2020  DOUBLE PRECISION  :: lval(llm)=1, tsTemp 
    2121  TYPE(xios_field) :: field_hdl 
     
    2626  DOUBLE PRECISION,DIMENSION(ni_glo,nj_glo) :: lon_glo,lat_glo 
    2727  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(:) 
     28  DOUBLE PRECISION,ALLOCATABLE :: lon(:,:),lat(:,:),field_A(:,:,:), field_All_Axis(:,:,:), lonvalue(:) , field_Axis(:), lvaln(:), field_Two_Axis(:,:) 
    2929  INTEGER :: ni,ibegin,iend,nj,jbegin,jend, nAxis, axisBegin, axisEnd 
    3030  INTEGER :: i,j,l,ts,n 
     
    6767  axisBegin = 0 
    6868  nAxis = llm 
    69 !  DO n=0, size -1 
    70 !    nAxis = llm/size 
    71 !    IF (n<MOD(llm,size)) nAxis=nAxis+1 
    72 !    IF (n==rank) exit 
    73 !    axisBegin=axisBegin+nAxis 
    74 !  ENDDO 
     69  DO n=0, size -1 
     70    nAxis = llm/size 
     71    IF (n<MOD(llm,size)) nAxis=nAxis+1 
     72    IF (n==rank) exit 
     73    axisBegin=axisBegin+nAxis 
     74  ENDDO 
    7575  axisEnd=axisBegin+nAxis-1 
    7676 
    77   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)) 
     77  DO i=1,llm 
     78    lval(i) = i 
     79  ENDDO 
     80 
     81 
     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)) 
    7883  lon(:,:)=lon_glo(ibegin+1:iend+1,jbegin+1:jend+1) 
    7984  lat(:,:)=lat_glo(ibegin+1:iend+1,jbegin+1:jend+1) 
     
    8186  field_Axis(1:nAxis)  = field_A_glo(1,1,axisBegin+1:axisEnd+1) 
    8287  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) 
     89  lvaln(1:nAxis) = lval(axisBegin+1:axisEnd+1) 
    8390 
    8491  CALL xios_context_initialize("test",comm) 
     
    9299  CALL xios_set_axis_attr("axis_B", size=nj_glo, ibegin=jbegin, ni=nj, value=lval_nj) 
    93100  CALL xios_set_axis_attr("axis_C", size=llm, value=lval) 
    94   CALL xios_set_axis_attr("axis_D", size=llm, ibegin=axisBegin, ni=nAxis, value=lval) 
     101  CALL xios_set_axis_attr("axis_D", size=llm, ibegin=axisBegin, ni=nAxis, value=lvaln) 
    95102  CALL xios_set_domain_attr("domain_A",ni_glo=ni_glo, nj_glo=nj_glo, ibegin=ibegin, ni=ni,jbegin=jbegin,nj=nj) 
    96103  CALL xios_set_domain_attr("domain_A",data_dim=2, data_ibegin=-1, data_ni=ni+2, data_jbegin=-2, data_nj=nj+4) 
     
    99106  CALL xios_set_fieldgroup_attr("field_definition",enabled=.TRUE.) 
    100107 
    101   CALL xios_get_handle("field_definition",fieldgroup_hdl) 
    102   CALL xios_add_child(fieldgroup_hdl,field_hdl,"field_B") 
    103   CALL xios_set_attr(field_hdl,field_ref="field_A",name="field_B") 
    104  
    105   CALL xios_get_handle("output",file_hdl) 
    106   CALL xios_add_child(file_hdl,field_hdl) 
    107   CALL xios_set_attr(field_hdl,field_ref="field_A",name="field_C") 
    108  
    109   CALL xios_get_handle("output_All_Axis",file_hdl) 
    110   CALL xios_add_child(file_hdl,field_hdl) 
    111   CALL xios_set_attr(field_hdl,field_ref="field_All_Axis",name="field_C") 
     108!  CALL xios_get_handle("field_definition",fieldgroup_hdl) 
     109!  CALL xios_add_child(fieldgroup_hdl,field_hdl,"field_B") 
     110!  CALL xios_set_attr(field_hdl,field_ref="field_A",name="field_B") 
     111! 
     112!  CALL xios_get_handle("output",file_hdl) 
     113!  CALL xios_add_child(file_hdl,field_hdl) 
     114!  CALL xios_set_attr(field_hdl,field_ref="field_A",name="field_C") 
     115! 
     116!  CALL xios_get_handle("output_All_Axis",file_hdl) 
     117!  CALL xios_add_child(file_hdl,field_hdl) 
     118!  CALL xios_set_attr(field_hdl,field_ref="field_All_Axis",name="field_C") 
    112119 
    113120  dtime%second = 3600 
     
    146153  DO ts=1,24*10 
    147154    CALL xios_update_calendar(ts) 
    148     CALL xios_send_field("field_A",field_A) 
     155!    CALL xios_send_field("field_A",field_A) 
    149156    CALL xios_send_field("field_Axis",field_Axis) 
    150     CALL xios_send_field("field_All_Axis",field_All_Axis) 
    151     tsTemp = ts 
    152     CALL xios_send_scalar("field_Scalar", tsTemp) 
     157 
     158    CALL xios_send_field("field_Two_Axis",field_Two_Axis) 
     159!    CALL xios_send_field("field_All_Axis",field_All_Axis) 
     160!    tsTemp = ts 
     161!    CALL xios_send_scalar("field_Scalar", tsTemp) 
    153162    CALL wait_us(5000) ; 
    154163  ENDDO 
  • XIOS/trunk/src/type/type_util.hpp

    r549 r619  
    2020    class CVariable; 
    2121    class CVariableGroup; 
     22    class CTransformation; 
     23    class CTransformationGroup; 
    2224 
    2325  template <typename T> inline string getStrType(void); 
     
    5658  macro(CVariable) 
    5759  macro(CVariableGroup) 
     60  macro(CTransformation) 
     61  macro(CTransformationGroup) 
    5862 
    5963#undef macro 
  • XIOS/trunk/src/xml_parser_decl.cpp

    r501 r619  
    77#include "file.hpp" 
    88#include "variable.hpp" 
    9  
     9#include "transformation.hpp" 
    1010 
    1111namespace xios 
     
    1414  { 
    1515    template void CXMLParser::ParseInclude<CContext>(StdIStream & stream, const string& fluxId, CContext& object) ; 
    16   
     16 
    1717 #   define macro(T) \ 
    1818    template void CXMLParser::ParseInclude< CGroupTemplate<C##T, C##T##Group, C##T##Attributes> >(StdIStream & stream, const string& fluxId, CGroupTemplate<C##T, C##T##Group, C##T##Attributes>& object) ; 
    19      
    20     macro( Context )  
    21     macro( Axis )  
    22     macro( Domain )  
    23     macro( Grid )  
    24     macro( Field )  
    25     macro( File )  
    26     macro( Variable )  
     19 
     20    macro( Context ) 
     21    macro( Axis ) 
     22    macro( Domain ) 
     23    macro( Grid ) 
     24    macro( Field ) 
     25    macro( File ) 
     26    macro( Variable ) 
     27    macro( Transformation ) 
    2728  } 
    2829} 
Note: See TracChangeset for help on using the changeset viewer.