Ignore:
Timestamp:
11/23/18 14:48:14 (22 months ago)
Author:
oabramkina
Message:

Dev: adding exception handling.

To activate it, compilation flag -DXIOS_EXCEPTION should be added.

Location:
XIOS/dev/dev_olga/src/transformation
Files:
28 edited

Legend:

Unmodified
Added
Removed
  • XIOS/dev/dev_olga/src/transformation/axis_algorithm_duplicate_scalar.cpp

    r1314 r1612  
    2121                                                                     std::map<int, int>& elementPositionInGridDst2AxisPosition, 
    2222                                                                     std::map<int, int>& elementPositionInGridDst2DomainPosition) 
     23TRY 
    2324{ 
    2425  std::vector<CAxis*> axisListDestP = gridDst->getAxis(); 
     
    3132  return (new CAxisAlgorithmDuplicateScalar(axisListDestP[axisDstIndex], scalarListSrcP[scalarSrcIndex], duplicateScalar)); 
    3233} 
     34CATCH 
    3335 
    3436bool CAxisAlgorithmDuplicateScalar::registerTrans() 
     37TRY 
    3538{ 
    3639  CGridTransformationFactory<CAxis>::registerTransformation(TRANS_DUPLICATE_SCALAR_TO_AXIS, create); 
    3740} 
     41CATCH 
    3842 
    3943 
     
    5054 
    5155void CAxisAlgorithmDuplicateScalar::computeIndexSourceMapping_(const std::vector<CArray<double,1>* >& dataAuxInputs) 
     56TRY 
    5257{ 
    5358  this->transformationMapping_.resize(1); 
     
    6974  } 
    7075} 
    71  
     76CATCH 
    7277} 
  • XIOS/dev/dev_olga/src/transformation/axis_algorithm_extract.cpp

    r1558 r1612  
    1919                                                           std::map<int, int>& elementPositionInGridDst2AxisPosition, 
    2020                                                           std::map<int, int>& elementPositionInGridDst2DomainPosition) 
     21TRY 
    2122{ 
    2223  std::vector<CAxis*> axisListDestP = gridDst->getAxis(); 
     
    2930  return (new CAxisAlgorithmExtract(axisListDestP[axisDstIndex], axisListSrcP[axisSrcIndex], extractAxis)); 
    3031} 
     32CATCH 
     33 
    3134bool CAxisAlgorithmExtract::registerTrans() 
     35TRY 
    3236{ 
    3337  CGridTransformationFactory<CAxis>::registerTransformation(TRANS_EXTRACT_AXIS, create); 
    3438} 
     39CATCH 
    3540 
    3641CAxisAlgorithmExtract::CAxisAlgorithmExtract(CAxis* axisDestination, CAxis* axisSource, CExtractAxis* extractAxis) 
    3742: CAxisAlgorithmTransformation(axisDestination, axisSource) 
     43TRY 
    3844{ 
    3945  extractAxis->checkValid(axisSource); 
     
    104110  } 
    105111} 
     112CATCH 
    106113 
    107114/*! 
  • XIOS/dev/dev_olga/src/transformation/axis_algorithm_extract_domain.cpp

    r1260 r1612  
    2525                                                                     std::map<int, int>& elementPositionInGridDst2AxisPosition, 
    2626                                                                     std::map<int, int>& elementPositionInGridDst2DomainPosition) 
     27TRY 
    2728{ 
    2829  std::vector<CAxis*> axisListDestP = gridDst->getAxis(); 
     
    3536  return (new CAxisAlgorithmExtractDomain(axisListDestP[axisDstIndex], domainListSrcP[domainSrcIndex], extractDomain)); 
    3637} 
     38CATCH 
    3739 
    3840//bool CAxisAlgorithmExtractDomain::_dummyRegistered = CAxisAlgorithmExtractDomain::registerTrans(); 
    3941bool CAxisAlgorithmExtractDomain::registerTrans() 
     42TRY 
    4043{ 
    4144  CGridTransformationFactory<CAxis>::registerTransformation(TRANS_EXTRACT_DOMAIN_TO_AXIS, create); 
    4245} 
     46CATCH 
    4347 
    4448 
    4549CAxisAlgorithmExtractDomain::CAxisAlgorithmExtractDomain(CAxis* axisDestination, CDomain* domainSource, CExtractDomainToAxis* algo) 
    4650 : CAxisAlgorithmTransformation(axisDestination, domainSource), pos_(-1), reduction_(0) 
     51TRY 
    4752{ 
    4853  algo->checkValid(axisDestination, domainSource); 
     
    6469  reduction_ = CReductionAlgorithm::createOperation(CReductionAlgorithm::ReductionOperations[op]); 
    6570} 
     71CATCH 
    6672 
    6773void CAxisAlgorithmExtractDomain::apply(const std::vector<std::pair<int,double> >& localIndex, 
     
    7076                                        std::vector<bool>& flagInitial,                      
    7177                                        bool ignoreMissingValue, bool firstPass) 
     78TRY 
    7279{ 
    7380  reduction_->apply(localIndex, dataInput, dataOut, flagInitial, ignoreMissingValue, firstPass); 
    7481} 
     82CATCH 
    7583 
    7684CAxisAlgorithmExtractDomain::~CAxisAlgorithmExtractDomain() 
     85TRY 
    7786{ 
    7887  if (0 != reduction_) delete reduction_; 
    7988} 
     89CATCH 
    8090 
    8191void CAxisAlgorithmExtractDomain::computeIndexSourceMapping_(const std::vector<CArray<double,1>* >& dataAuxInputs) 
     92TRY 
    8293{ 
    8394  this->transformationMapping_.resize(1); 
     
    117128  {} 
    118129} 
    119  
     130CATCH 
    120131} 
  • XIOS/dev/dev_olga/src/transformation/axis_algorithm_interpolate.cpp

    r1412 r1612  
    2929                                                                   std::map<int, int>& elementPositionInGridDst2AxisPosition, 
    3030                                                                   std::map<int, int>& elementPositionInGridDst2DomainPosition) 
     31TRY 
    3132{ 
    3233  std::vector<CAxis*> axisListDestP = gridDst->getAxis(); 
     
    3940  return (new CAxisAlgorithmInterpolate(axisListDestP[axisDstIndex], axisListSrcP[axisSrcIndex], interpolateAxis)); 
    4041} 
     42CATCH 
    4143 
    4244bool CAxisAlgorithmInterpolate::registerTrans() 
     45TRY 
    4346{ 
    4447  CGridTransformationFactory<CAxis>::registerTransformation(TRANS_INTERPOLATE_AXIS, create); 
    4548} 
    46  
     49CATCH 
    4750 
    4851CAxisAlgorithmInterpolate::CAxisAlgorithmInterpolate(CAxis* axisDestination, CAxis* axisSource, CInterpolateAxis* interpAxis) 
    4952: CAxisAlgorithmTransformation(axisDestination, axisSource), coordinate_(), transPosition_() 
     53TRY 
    5054{ 
    5155  interpAxis->checkValid(axisSource); 
     
    5862  } 
    5963} 
     64CATCH 
    6065 
    6166/*! 
     
    6368*/ 
    6469void CAxisAlgorithmInterpolate::computeIndexSourceMapping_(const std::vector<CArray<double,1>* >& dataAuxInputs) 
     70TRY 
    6571{ 
    6672  CTimer::get("CAxisAlgorithmInterpolate::computeIndexSourceMapping_").resume() ; 
     
    8894  CTimer::get("CAxisAlgorithmInterpolate::computeIndexSourceMapping_").suspend() ; 
    8995} 
     96CATCH 
    9097 
    9198/*! 
     
    98105                                                        const std::vector<int>& indexVec, 
    99106                                                        int transPos) 
     107TRY 
    100108{ 
    101109  std::vector<double>::const_iterator itb = axisValue.begin(), ite = axisValue.end(); 
     
    162170  computeWeightedValueAndMapping(interpolatingIndexValues, transPos); 
    163171} 
     172CATCH 
    164173 
    165174/*! 
     
    168177*/ 
    169178void CAxisAlgorithmInterpolate::computeWeightedValueAndMapping(const std::map<int, std::vector<std::pair<int,double> > >& interpolatingIndexValues, int transPos) 
     179TRY 
    170180{ 
    171181  TransformationIndexMap& transMap = this->transformationMapping_[transPos]; 
     
    205215 
    206216} 
     217CATCH 
    207218 
    208219/*! 
     
    213224void CAxisAlgorithmInterpolate::retrieveAllAxisValue(const CArray<double,1>& axisValue, const CArray<bool,1>& axisMask, 
    214225                                                     std::vector<double>& recvBuff, std::vector<int>& indexVec) 
     226TRY 
    215227{ 
    216228  CContext* context = CContext::getCurrent(); 
     
    282294  } 
    283295} 
     296CATCH 
    284297 
    285298/*! 
     
    289302void CAxisAlgorithmInterpolate::fillInAxisValue(std::vector<CArray<double,1> >& vecAxisValue, 
    290303                                                const std::vector<CArray<double,1>* >& dataAuxInputs) 
     304TRY 
    291305{ 
    292306  if (coordinate_.empty()) 
     
    377391  } 
    378392} 
    379  
    380 } 
     393CATCH 
     394 
     395} 
  • XIOS/dev/dev_olga/src/transformation/axis_algorithm_inverse.cpp

    r1542 r1612  
    2727                                                               std::map<int, int>& elementPositionInGridDst2AxisPosition, 
    2828                                                               std::map<int, int>& elementPositionInGridDst2DomainPosition) 
     29TRY 
    2930{ 
    3031  std::vector<CAxis*> axisListDestP = gridDst->getAxis(); 
     
    3738  return (new CAxisAlgorithmInverse(axisListDestP[axisDstIndex], axisListSrcP[axisSrcIndex], inverseAxis)); 
    3839} 
     40CATCH 
    3941 
    4042bool CAxisAlgorithmInverse::registerTrans() 
     43TRY 
    4144{ 
    4245  CGridTransformationFactory<CAxis>::registerTransformation(TRANS_INVERSE_AXIS, create); 
    4346} 
    44  
     47CATCH 
    4548 
    4649CAxisAlgorithmInverse::CAxisAlgorithmInverse(CAxis* axisDestination, CAxis* axisSource, CInverseAxis* inverseAxis) 
    4750 : CAxisAlgorithmTransformation(axisDestination, axisSource) 
     51TRY 
    4852{ 
    4953  if (axisDestination->n_glo.getValue() != axisSource->n_glo.getValue()) 
     
    5559  } 
    5660} 
     61CATCH 
    5762 
    5863void CAxisAlgorithmInverse::computeIndexSourceMapping_(const std::vector<CArray<double,1>* >& dataAuxInputs) 
     64TRY 
    5965{ 
    6066  this->transformationMapping_.resize(1); 
     
    8288  } 
    8389} 
     90CATCH 
    8491 
    8592/*! 
     
    8895*/ 
    8996void CAxisAlgorithmInverse::updateAxisValue() 
     97TRY 
    9098{ 
    9199  CContext* context = CContext::getCurrent(); 
     
    282290    delete [] itLong->second; 
    283291} 
    284  
    285 } 
     292CATCH 
     293 
     294} 
  • XIOS/dev/dev_olga/src/transformation/axis_algorithm_reduce_axis.cpp

    r1314 r1612  
    2424                                                                   std::map<int, int>& elementPositionInGridDst2AxisPosition, 
    2525                                                                   std::map<int, int>& elementPositionInGridDst2DomainPosition) 
     26TRY 
    2627{ 
    2728  std::vector<CAxis*> axisListDestP = gridDst->getAxis(); 
     
    3435  return (new CAxisAlgorithmReduceAxis(axisListDestP[axisDstIndex], axisListSrcP[axisSrcIndex], reduceAxis)); 
    3536} 
     37CATCH 
    3638 
    3739bool CAxisAlgorithmReduceAxis::registerTrans() 
     40TRY 
    3841{ 
    3942  CGridTransformationFactory<CAxis>::registerTransformation(TRANS_REDUCE_AXIS_TO_AXIS, create); 
    4043} 
     44CATCH 
    4145 
    4246 
    4347CAxisAlgorithmReduceAxis::CAxisAlgorithmReduceAxis(CAxis* axisDestination, CAxis* axisSource, CReduceAxisToAxis* algo) 
    4448 : CAxisAlgorithmTransformation(axisDestination, axisSource), reduction_(0) 
     49TRY 
    4550{ 
    4651  eliminateRedondantSrc_= false ; 
     
    7176  reduction_ = CReductionAlgorithm::createOperation(CReductionAlgorithm::ReductionOperations[op]); 
    7277} 
     78CATCH 
    7379 
    7480void CAxisAlgorithmReduceAxis::apply(const std::vector<std::pair<int,double> >& localIndex, 
     
    7783                                       std::vector<bool>& flagInitial,                      
    7884                                       bool ignoreMissingValue, bool firstPass) 
     85TRY 
    7986{ 
    8087  reduction_->apply(localIndex, dataInput, dataOut, flagInitial, ignoreMissingValue, firstPass); 
    8188} 
     89CATCH 
    8290 
    8391void CAxisAlgorithmReduceAxis::updateData(CArray<double,1>& dataOut) 
     92TRY 
    8493{ 
    8594  reduction_->updateData(dataOut); 
    8695} 
     96CATCH 
    8797 
    8898CAxisAlgorithmReduceAxis::~CAxisAlgorithmReduceAxis() 
     99TRY 
    89100{ 
    90101  if (0 != reduction_) delete reduction_; 
    91102} 
     103CATCH 
    92104 
    93105void CAxisAlgorithmReduceAxis::computeIndexSourceMapping_(const std::vector<CArray<double,1>* >& dataAuxInputs) 
     106TRY 
    94107{ 
    95108  this->transformationMapping_.resize(1); 
     
    109122  } 
    110123} 
     124CATCH 
    111125 
    112126} 
  • XIOS/dev/dev_olga/src/transformation/axis_algorithm_reduce_domain.cpp

    r1299 r1612  
    2525                                                                   std::map<int, int>& elementPositionInGridDst2AxisPosition, 
    2626                                                                   std::map<int, int>& elementPositionInGridDst2DomainPosition) 
     27TRY 
    2728{ 
    2829  std::vector<CAxis*> axisListDestP = gridDst->getAxis(); 
     
    3536  return (new CAxisAlgorithmReduceDomain(axisListDestP[axisDstIndex], domainListSrcP[domainSrcIndex], reduceDomain)); 
    3637} 
     38CATCH 
    3739 
    3840bool CAxisAlgorithmReduceDomain::registerTrans() 
     41TRY 
    3942{ 
    4043  CGridTransformationFactory<CAxis>::registerTransformation(TRANS_REDUCE_DOMAIN_TO_AXIS, create); 
    4144} 
     45CATCH 
    4246 
    4347 
    4448CAxisAlgorithmReduceDomain::CAxisAlgorithmReduceDomain(CAxis* axisDestination, CDomain* domainSource, CReduceDomainToAxis* algo) 
    4549 : CAxisAlgorithmTransformation(axisDestination, domainSource), reduction_(0) 
     50TRY 
    4651{ 
    4752  algo->checkValid(axisDestination, domainSource); 
     
    7378  local = algo->local ; 
    7479} 
     80CATCH 
    7581 
    7682void CAxisAlgorithmReduceDomain::apply(const std::vector<std::pair<int,double> >& localIndex, 
     
    7985                                       std::vector<bool>& flagInitial,                      
    8086                                       bool ignoreMissingValue, bool firstPass) 
     87TRY 
    8188{ 
    8289  reduction_->apply(localIndex, dataInput, dataOut, flagInitial, ignoreMissingValue, firstPass); 
    8390} 
     91CATCH 
    8492 
    8593void CAxisAlgorithmReduceDomain::updateData(CArray<double,1>& dataOut) 
     94TRY 
    8695{ 
    8796  reduction_->updateData(dataOut); 
    8897} 
     98CATCH 
    8999 
    90100CAxisAlgorithmReduceDomain::~CAxisAlgorithmReduceDomain() 
     101TRY 
    91102{ 
    92103  if (0 != reduction_) delete reduction_; 
    93104} 
     105CATCH 
    94106 
    95107void CAxisAlgorithmReduceDomain::computeIndexSourceMapping_(const std::vector<CArray<double,1>* >& dataAuxInputs) 
     108TRY 
    96109{ 
    97110  this->transformationMapping_.resize(1); 
     
    174187  {} 
    175188} 
     189CATCH 
    176190 
    177191} 
  • XIOS/dev/dev_olga/src/transformation/axis_algorithm_temporal_splitting.cpp

    r1275 r1612  
    2121                                                                     std::map<int, int>& elementPositionInGridDst2AxisPosition, 
    2222                                                                     std::map<int, int>& elementPositionInGridDst2DomainPosition) 
     23TRY 
    2324{ 
    2425  std::vector<CAxis*> axisListDestP = gridDst->getAxis(); 
     
    3132  return (new CAxisAlgorithmTemporalSplitting(axisListDestP[axisDstIndex], scalarListSrcP[scalarSrcIndex], temporalSplitting)); 
    3233} 
     34CATCH 
    3335 
    3436bool CAxisAlgorithmTemporalSplitting::registerTrans() 
     37TRY 
    3538{ 
    3639  CGridTransformationFactory<CAxis>::registerTransformation(TRANS_TEMPORAL_SPLITTING, create); 
    3740} 
    38  
     41CATCH 
    3942 
    4043CAxisAlgorithmTemporalSplitting::CAxisAlgorithmTemporalSplitting(CAxis* axisDestination, CScalar* scalarSource, CTemporalSplitting* algo) 
     
    5053 
    5154void CAxisAlgorithmTemporalSplitting::computeIndexSourceMapping_(const std::vector<CArray<double,1>* >& dataAuxInputs) 
     55TRY 
    5256{ 
    5357  this->transformationMapping_.resize(1); 
     
    7276  } 
    7377} 
     78CATCH 
    7479 
    7580} 
  • XIOS/dev/dev_olga/src/transformation/axis_algorithm_transformation.cpp

    r1403 r1612  
    2020CAxisAlgorithmTransformation::CAxisAlgorithmTransformation(CAxis* axisDestination, CAxis* axisSource) 
    2121 : CGenericAlgorithmTransformation(), axisDest_(axisDestination), axisSrc_(axisSource), domainSrc_(0),scalarSrc_(0) 
     22TRY 
    2223{ 
    2324  axisDestGlobalSize_ = axisDestination->n_glo.getValue(); 
     
    2829    if ((axisDestination->mask)(idx)) axisDestGlobalIndex_.push_back(ibeginDest+idx); 
    2930} 
     31CATCH 
    3032 
    3133CAxisAlgorithmTransformation::CAxisAlgorithmTransformation(CAxis* axisDestination, CDomain* domainSource) 
    3234 : CGenericAlgorithmTransformation(), axisDest_(axisDestination), axisSrc_(0), domainSrc_(domainSource),scalarSrc_(0) 
     35TRY 
    3336{ 
    3437  axisDestGlobalSize_ = axisDestination->n_glo.getValue(); 
     
    3942    if ((axisDestination->mask)(idx)) axisDestGlobalIndex_.push_back(ibeginDest+idx); 
    4043} 
     44CATCH 
    4145 
    4246CAxisAlgorithmTransformation::CAxisAlgorithmTransformation(CAxis* axisDestination, CScalar* scalarSource) 
    4347 : CGenericAlgorithmTransformation(), axisDest_(axisDestination), axisSrc_(0), domainSrc_(0), scalarSrc_(scalarSource) 
     48TRY 
    4449{ 
    4550  axisDestGlobalSize_ = axisDestination->n_glo.getValue(); 
     
    5055    if ((axisDestination->mask)(idx)) axisDestGlobalIndex_.push_back(ibeginDest+idx); 
    5156} 
     57CATCH 
     58 
    5259CAxisAlgorithmTransformation::~CAxisAlgorithmTransformation() 
    5360{ 
     
    6673                                                              int elementType, 
    6774                                                              CClientClientDHTInt::Index2VectorInfoTypeMap& globalAxisIndexOnProc) 
     75TRY 
    6876{ 
    6977  CContext* context = CContext::getCurrent(); 
     
    124132  globalAxisIndexOnProc = dhtIndexProcRank.getInfoIndexMap(); 
    125133} 
     134CATCH 
    126135 
    127136} 
  • XIOS/dev/dev_olga/src/transformation/axis_algorithm_zoom.cpp

    r1559 r1612  
    1919                                                           std::map<int, int>& elementPositionInGridDst2AxisPosition, 
    2020                                                           std::map<int, int>& elementPositionInGridDst2DomainPosition) 
     21TRY 
    2122{ 
    2223  std::vector<CAxis*> axisListDestP = gridDst->getAxis(); 
     
    2930  return (new CAxisAlgorithmZoom(axisListDestP[axisDstIndex], axisListSrcP[axisSrcIndex], zoomAxis)); 
    3031} 
     32CATCH 
     33 
    3134bool CAxisAlgorithmZoom::registerTrans() 
     35TRY 
    3236{ 
    3337  CGridTransformationFactory<CAxis>::registerTransformation(TRANS_ZOOM_AXIS, create); 
    3438} 
     39CATCH 
    3540 
    3641CAxisAlgorithmZoom::CAxisAlgorithmZoom(CAxis* axisDestination, CAxis* axisSource, CZoomAxis* zoomAxis) 
    3742: CAxisAlgorithmTransformation(axisDestination, axisSource) 
     43TRY 
    3844{ 
    3945  zoomAxis->checkValid(axisSource); 
     
    104110  } 
    105111} 
     112CATCH 
    106113 
    107114/*! 
  • XIOS/dev/dev_olga/src/transformation/domain_algorithm_compute_connectivity.cpp

    r978 r1612  
    2424                                                                     std::map<int, int>& elementPositionInGridDst2AxisPosition, 
    2525                                                                     std::map<int, int>& elementPositionInGridDst2DomainPosition) 
     26TRY 
    2627{ 
    2728  std::vector<CDomain*> domainListDestP = gridDst->getDomains(); 
     
    3435  return (new CDomainAlgorithmComputeConnectivity(domainListDestP[domainDstIndex], domainListSrcP[domainSrcIndex], compute_connectivityDomain)); 
    3536} 
     37CATCH 
    3638 
    3739bool CDomainAlgorithmComputeConnectivity::registerTrans() 
     40TRY 
    3841{ 
    3942  CGridTransformationFactory<CDomain>::registerTransformation(TRANS_COMPUTE_CONNECTIVITY_DOMAIN, create); 
    4043} 
     44CATCH 
    4145 
    4246CDomainAlgorithmComputeConnectivity::CDomainAlgorithmComputeConnectivity(CDomain* domainDestination, CDomain* domainSource, 
    4347                                                                         CComputeConnectivityDomain* compute_connectivityDomain) 
    4448: CDomainAlgorithmTransformation(domainDestination, domainSource) 
     49TRY 
    4550{ 
    4651  this->type_ = (ELEMENT_NO_MODIFICATION_WITHOUT_DATA); 
     
    6469  computeLocalConnectivity(type, domainDestination, nbNeighborMax, nbNeighbor, localNeighbors); 
    6570} 
     71CATCH 
    6672 
    6773/*! 
     
    7884                                                                  CArray<int,1>& nbConnectivity, 
    7985                                                                  CArray<int,2>& localConnectivity) 
     86TRY 
    8087{ 
    8188 
     
    93100    if (nbConnectivityMax < nbConnectivity(idx)) nbConnectivityMax = nbConnectivity(idx); 
    94101} 
    95  
    96  
     102CATCH 
    97103 
    98104/*! 
  • XIOS/dev/dev_olga/src/transformation/domain_algorithm_expand.cpp

    r1553 r1612  
    2626                                                               std::map<int, int>& elementPositionInGridDst2AxisPosition, 
    2727                                                               std::map<int, int>& elementPositionInGridDst2DomainPosition) 
     28TRY 
    2829{ 
    2930  std::vector<CDomain*> domainListDestP = gridDst->getDomains(); 
     
    3637  return (new CDomainAlgorithmExpand(domainListDestP[domainDstIndex], domainListSrcP[domainSrcIndex], expandDomain)); 
    3738} 
     39CATCH 
    3840 
    3941bool CDomainAlgorithmExpand::registerTrans() 
     42TRY 
    4043{ 
    4144  CGridTransformationFactory<CDomain>::registerTransformation(TRANS_EXPAND_DOMAIN, create); 
    4245} 
     46CATCH 
    4347 
    4448CDomainAlgorithmExpand::CDomainAlgorithmExpand(CDomain* domainDestination, 
     
    4751: CDomainAlgorithmTransformation(domainDestination, domainSource), 
    4852  isXPeriodic_(false), isYPeriodic_(false) 
     53TRY 
    4954{ 
    5055  if (domainDestination == domainSource) 
     
    7782  } 
    7883} 
     84CATCH 
    7985 
    8086/*! 
     
    8591void CDomainAlgorithmExpand::expandDomainEdgeConnectivity(CDomain* domainDestination, 
    8692                                                          CDomain* domainSource) 
     93TRY 
    8794{ 
    8895  CContext* context = CContext::getCurrent(); 
     
    104111  }   
    105112} 
     113CATCH 
    106114 
    107115/*! 
     
    112120void CDomainAlgorithmExpand::expandDomainNodeConnectivity(CDomain* domainDestination, 
    113121                                                          CDomain* domainSource) 
     122TRY 
    114123{ 
    115124  CContext* context = CContext::getCurrent(); 
     
    131140  }   
    132141} 
     142CATCH 
    133143 
    134144/*! 
     
    142152                                                               CDomain* domainSource, 
    143153                                                               CArray<int,2>& neighborsDomainSrc) 
     154TRY 
    144155{ 
    145156  int index, globalIndex, idx; 
     
    455466   domainDestination->computeLocalMask() ; 
    456467} 
     468CATCH 
    457469 
    458470/*! 
     
    466478                                                                CDomain* domainSource, 
    467479                                                                CArray<int,2>& neighborsDomainSrc) 
     480TRY 
    468481{ 
    469482 
     
    669682  domainDestination->computeLocalMask() ; 
    670683} 
    671  
     684CATCH 
    672685 
    673686/*! 
  • XIOS/dev/dev_olga/src/transformation/domain_algorithm_extract.cpp

    r1553 r1612  
    1616                                                             std::map<int, int>& elementPositionInGridDst2AxisPosition, 
    1717                                                             std::map<int, int>& elementPositionInGridDst2DomainPosition) 
     18TRY 
    1819{ 
    1920  std::vector<CDomain*> domainListDestP = gridDst->getDomains(); 
     
    2627  return (new CDomainAlgorithmExtract(domainListDestP[domainDstIndex], domainListSrcP[domainSrcIndex], extractDomain)); 
    2728} 
     29CATCH 
    2830 
    2931bool CDomainAlgorithmExtract::registerTrans() 
     32TRY 
    3033{ 
    3134  CGridTransformationFactory<CDomain>::registerTransformation(TRANS_EXTRACT_DOMAIN, create); 
    3235} 
     36CATCH 
    3337 
    3438CDomainAlgorithmExtract::CDomainAlgorithmExtract(CDomain* domainDestination, CDomain* domainSource, CExtractDomain* extractDomain) 
    3539: CDomainAlgorithmTransformation(domainDestination, domainSource) 
     40TRY 
    3641{ 
    3742  extractDomain->checkValid(domainSource); 
     
    220225 
    221226} 
     227CATCH 
    222228 
    223229/*! 
  • XIOS/dev/dev_olga/src/transformation/domain_algorithm_generate_rectilinear.cpp

    r1158 r1612  
    2020                                                                         CGenerateRectilinearDomain* genRectDomain) 
    2121: CDomainAlgorithmTransformation(domainDestination, domainSource), nbDomainDistributedPart_(0) 
     22TRY 
    2223{ 
    2324  type_ = ELEMENT_GENERATION; 
     
    3031  fillInAttributesDomainDestination(); 
    3132} 
     33CATCH 
    3234 
    3335/*! 
     
    4345*/ 
    4446void CDomainAlgorithmGenerateRectilinear::computeDistributionGridSource(CGrid* gridSrc) 
     47TRY 
    4548{ 
    4649  CContext* context = CContext::getCurrent(); 
     
    9497  } 
    9598} 
     99CATCH 
    96100 
    97101/*! 
     
    99103*/ 
    100104void CDomainAlgorithmGenerateRectilinear::computeDistributionGridDestination(CGrid* gridDest) 
     105TRY 
    101106{ 
    102107  // For now, just suppose that the grid contains only one domain 
     
    121126 
    122127} 
     128CATCH 
    123129 
    124130/*! 
     
    126132*/ 
    127133void CDomainAlgorithmGenerateRectilinear::fillInAttributesDomainDestination() 
     134TRY 
    128135{ 
    129136  if (!domainDest_->distributionAttributesHaveValue()) 
     
    131138  domainDest_->fillInLonLat(); 
    132139} 
    133  
     140CATCH 
    134141} 
  • XIOS/dev/dev_olga/src/transformation/domain_algorithm_interpolate.cpp

    r1542 r1612  
    3131                                                                     std::map<int, int>& elementPositionInGridDst2AxisPosition, 
    3232                                                                     std::map<int, int>& elementPositionInGridDst2DomainPosition) 
     33TRY 
    3334{ 
    3435  std::vector<CDomain*> domainListDestP = gridDst->getDomains(); 
     
    4142  return (new CDomainAlgorithmInterpolate(domainListDestP[domainDstIndex], domainListSrcP[domainSrcIndex], interpolateDomain)); 
    4243} 
     44CATCH 
    4345 
    4446bool CDomainAlgorithmInterpolate::registerTrans() 
     47TRY 
    4548{ 
    4649  CGridTransformationFactory<CDomain>::registerTransformation(TRANS_INTERPOLATE_DOMAIN, create); 
    4750} 
     51CATCH 
    4852 
    4953CDomainAlgorithmInterpolate::CDomainAlgorithmInterpolate(CDomain* domainDestination, CDomain* domainSource, CInterpolateDomain* interpDomain) 
    5054: CDomainAlgorithmTransformation(domainDestination, domainSource), interpDomain_(interpDomain), writeToFile_(false), readFromFile_(false) 
     55TRY 
    5156{ 
    5257  CContext* context = CContext::getCurrent(); 
     
    9398     
    9499} 
     100CATCH 
    95101 
    96102/*! 
     
    98104*/ 
    99105void CDomainAlgorithmInterpolate::computeRemap() 
     106TRY 
    100107{ 
    101108  using namespace sphereRemap; 
     
    399406 
    400407} 
     408CATCH 
    401409 
    402410void CDomainAlgorithmInterpolate::processPole(std::map<int,std::vector<std::pair<int,double> > >& interMapValuePole, 
    403411                                              int nbGlobalPointOnPole) 
     412TRY 
    404413{ 
    405414  CContext* context = CContext::getCurrent(); 
     
    468477 
    469478} 
     479CATCH 
    470480 
    471481/*! 
     
    473483*/ 
    474484void CDomainAlgorithmInterpolate::computeIndexSourceMapping_(const std::vector<CArray<double,1>* >& dataAuxInputs) 
     485TRY 
    475486{ 
    476487  if (readFromFile_)   
     
    481492  } 
    482493} 
     494CATCH 
    483495 
    484496void CDomainAlgorithmInterpolate::writeRemapInfo(std::map<int,std::vector<std::pair<int,double> > >& interpMapValue) 
     497TRY 
    485498 
    486499  writeInterpolationInfo(fileToReadWrite_, interpMapValue); 
    487500} 
     501CATCH 
    488502 
    489503void CDomainAlgorithmInterpolate::readRemapInfo() 
     504TRY 
    490505 
    491506  std::map<int,std::vector<std::pair<int,double> > > interpMapValue; 
     
    494509  exchangeRemapInfo(interpMapValue); 
    495510} 
     511CATCH 
    496512 
    497513void CDomainAlgorithmInterpolate::convertRemapInfo(std::map<int,std::vector<std::pair<int,double> > >& interpMapValue) 
     514TRY 
    498515{ 
    499516  CContext* context = CContext::getCurrent(); 
     
    520537  }       
    521538} 
     539CATCH 
    522540 
    523541/*! 
     
    525543*/ 
    526544void CDomainAlgorithmInterpolate::exchangeRemapInfo(std::map<int,std::vector<std::pair<int,double> > >& interpMapValue) 
     545TRY 
    527546{ 
    528547  CContext* context = CContext::getCurrent(); 
     
    704723  delete [] recvBuff; 
    705724} 
     725CATCH 
    706726  
    707727/*! Redefined some functions of CONetCDF4 to make use of them */ 
     
    710730int CDomainAlgorithmInterpolate::WriteNetCdf::addDimensionWrite(const StdString& name,  
    711731                                                                const StdSize size) 
     732TRY 
    712733{ 
    713734  return CONetCDF4::addDimension(name, size);   
    714735} 
     736CATCH 
    715737 
    716738int CDomainAlgorithmInterpolate::WriteNetCdf::addVariableWrite(const StdString& name, nc_type type, 
    717739                                                               const std::vector<StdString>& dim) 
     740TRY 
    718741{ 
    719742  return CONetCDF4::addVariable(name, type, dim); 
    720743} 
     744CATCH 
    721745 
    722746void CDomainAlgorithmInterpolate::WriteNetCdf::endDefinition() 
     747TRY 
    723748{ 
    724749  CONetCDF4::definition_end(); 
    725750} 
     751CATCH 
    726752 
    727753void CDomainAlgorithmInterpolate::WriteNetCdf::writeDataIndex(const CArray<int,1>& data, const StdString& name, 
     
    729755                                                              const std::vector<StdSize>* start, 
    730756                                                              const std::vector<StdSize>* count) 
     757TRY 
    731758{ 
    732759  CONetCDF4::writeData<int,1>(data, name, collective, record, start, count); 
    733760} 
     761CATCH 
    734762 
    735763void CDomainAlgorithmInterpolate::WriteNetCdf::writeDataIndex(const CArray<double,1>& data, const StdString& name, 
     
    737765                                                              const std::vector<StdSize>* start, 
    738766                                                              const std::vector<StdSize>* count) 
     767TRY 
    739768{ 
    740769  CONetCDF4::writeData<double,1>(data, name, collective, record, start, count); 
    741770} 
     771CATCH 
    742772 
    743773/* 
     
    748778void CDomainAlgorithmInterpolate::writeInterpolationInfo(std::string& filename, 
    749779                                                         std::map<int,std::vector<std::pair<int,double> > >& interpMapValue) 
     780TRY 
    750781{ 
    751782  CContext* context = CContext::getCurrent(); 
     
    827858  netCdfWriter.closeFile(); 
    828859} 
     860CATCH 
    829861 
    830862/*! 
     
    836868void CDomainAlgorithmInterpolate::readInterpolationInfo(std::string& filename, 
    837869                                                        std::map<int,std::vector<std::pair<int,double> > >& interpMapValue) 
     870TRY 
    838871{ 
    839872  int ncid ; 
     
    894927      interpMapValue[dstIndex[ind]-indexOffset].push_back(make_pair(srcIndex[ind]-indexOffset,weight[ind])); 
    895928 } 
     929CATCH 
    896930 
    897931void CDomainAlgorithmInterpolate::apply(const std::vector<std::pair<int,double> >& localIndex, 
     
    900934                                            std::vector<bool>& flagInitial, 
    901935                                            bool ignoreMissingValue, bool firstPass  ) 
     936TRY 
    902937{ 
    903938  int nbLocalIndex = localIndex.size();    
     
    941976  } 
    942977} 
     978CATCH 
    943979 
    944980void CDomainAlgorithmInterpolate::updateData(CArray<double,1>& dataOut) 
     981TRY 
    945982{ 
    946983  if (detectMissingValue) 
     
    961998  } 
    962999} 
    963  
    964 } 
     1000CATCH 
     1001 
     1002} 
  • XIOS/dev/dev_olga/src/transformation/domain_algorithm_reorder.cpp

    r1457 r1612  
    1919                                                             std::map<int, int>& elementPositionInGridDst2AxisPosition, 
    2020                                                             std::map<int, int>& elementPositionInGridDst2DomainPosition) 
     21TRY 
    2122{ 
    2223  std::vector<CDomain*> domainListDestP = gridDst->getDomains(); 
     
    2930  return (new CDomainAlgorithmReorder(domainListDestP[domainDstIndex], domainListSrcP[domainSrcIndex], reorderDomain)); 
    3031} 
     32CATCH 
    3133 
    3234bool CDomainAlgorithmReorder::registerTrans() 
     35TRY 
    3336{ 
    3437  CGridTransformationFactory<CDomain>::registerTransformation(TRANS_REORDER_DOMAIN, create); 
    3538} 
     39CATCH 
    3640 
    3741CDomainAlgorithmReorder::CDomainAlgorithmReorder(CDomain* domainDestination, CDomain* domainSource, CReorderDomain* reorderDomain) 
    3842: CDomainAlgorithmTransformation(domainDestination, domainSource) 
     43TRY 
    3944{ 
    4045  reorderDomain->checkValid(domainSource); 
     
    109114    } 
    110115  } 
    111      
    112    
    113116} 
     117CATCH 
    114118 
    115119/*! 
  • XIOS/dev/dev_olga/src/transformation/domain_algorithm_transformation.cpp

    r1403 r1612  
    3636                                                                int elementType, 
    3737                                                                CClientClientDHTInt::Index2VectorInfoTypeMap& globalDomainIndexOnProc) 
     38TRY 
    3839{ 
    3940  CContext* context = CContext::getCurrent(); 
     
    6566  globalDomainIndexOnProc = dhtIndexProcRank.getInfoIndexMap(); 
    6667} 
     68CATCH 
    6769 
    6870} 
  • XIOS/dev/dev_olga/src/transformation/domain_algorithm_zoom.cpp

    r1609 r1612  
    1616                                                             std::map<int, int>& elementPositionInGridDst2AxisPosition, 
    1717                                                             std::map<int, int>& elementPositionInGridDst2DomainPosition) 
     18TRY 
    1819{ 
    1920  std::vector<CDomain*> domainListDestP = gridDst->getDomains(); 
     
    2627  return (new CDomainAlgorithmZoom(domainListDestP[domainDstIndex], domainListSrcP[domainSrcIndex], zoomDomain)); 
    2728} 
     29CATCH 
    2830 
    2931bool CDomainAlgorithmZoom::registerTrans() 
     32TRY 
    3033{ 
    3134  CGridTransformationFactory<CDomain>::registerTransformation(TRANS_ZOOM_DOMAIN, create); 
    3235} 
     36CATCH 
    3337 
    3438CDomainAlgorithmZoom::CDomainAlgorithmZoom(CDomain* domainDestination, CDomain* domainSource, CZoomDomain* zoomDomain) 
    3539: CDomainAlgorithmTransformation(domainDestination, domainSource) 
     40TRY 
    3641{ 
    3742  zoomDomain->checkValid(domainSource); 
     
    269274 
    270275} 
     276CATCH 
    271277 
    272278/*! 
  • XIOS/dev/dev_olga/src/transformation/generic_algorithm_transformation.cpp

    r1599 r1612  
    3434                                            std::vector<bool>& flagInitial, 
    3535                                            bool ignoreMissingValue, bool firstPass  ) 
     36TRY 
    3637{ 
    3738  int nbLocalIndex = localIndex.size();    
     
    6162  } 
    6263} 
     64CATCH 
    6365 
    6466void CGenericAlgorithmTransformation::computePositionElements(CGrid* dst, CGrid* src) 
     67TRY 
    6568{ 
    6669  int idxScalar = 0, idxAxis = 0, idxDomain = 0; 
     
    108111  } 
    109112} 
     113CATCH 
    110114 
    111115bool CGenericAlgorithmTransformation::isDistributedTransformation(int elementPositionInGrid, CGrid* gridSrc, CGrid* gridDst) 
     116TRY 
    112117{ 
    113118 
     
    147152  } 
    148153  return isDistributed_ ; 
    149  
     154} 
     155CATCH 
     156 
    150157/*! 
    151158  This function computes the global indexes of grid source, which the grid destination is in demand. 
     
    160167                                                               CGrid* gridDst, 
    161168                                                               SourceDestinationIndexMap& globaIndexWeightFromSrcToDst) 
     169TRY 
    162170 { 
    163171  CContext* context = CContext::getCurrent(); 
     
    443451  }   
    444452 } 
     453CATCH 
    445454 
    446455/*! 
     
    461470                                                                   std::vector<std::unordered_map<int,std::vector<size_t> > >& globalElementIndexOnProc, 
    462471                                                                   SourceDestinationIndexMap& globaIndexWeightFromSrcToDst) 
     472TRY 
    463473{ 
    464474  SourceDestinationIndexMap globaIndexWeightFromSrcToDst_tmp ; 
     
    640650       } 
    641651     } 
    642  
    643 } 
     652} 
     653CATCH 
    644654 
    645655/*! 
     
    654664                                                                 CArray<size_t,1>& destGlobalIndexPositionInGrid, 
    655665                                                                 std::unordered_map<int,std::vector<size_t> >& globalScalarIndexOnProc) 
     666TRY 
    656667{ 
    657668  CContext* context = CContext::getCurrent(); 
     
    666677  } 
    667678} 
     679CATCH 
    668680 
    669681/*! 
     
    678690                                                               CArray<size_t,1>& destGlobalIndexPositionInGrid, 
    679691                                                               std::unordered_map<int,std::vector<size_t> >& globalAxisIndexOnProc) 
     692TRY 
    680693{ 
    681694  CContext* context = CContext::getCurrent(); 
     
    735748  } 
    736749} 
     750CATCH 
    737751 
    738752/*! 
     
    747761                                                                 CArray<size_t,1>& destGlobalIndexPositionInGrid, 
    748762                                                                 std::unordered_map<int,std::vector<size_t> >& globalDomainIndexOnProc) 
     763TRY 
    749764{ 
    750765  CContext* context = CContext::getCurrent(); 
     
    838853  } 
    839854} 
    840  
    841  
    842  
    843  
     855CATCH 
    844856 
    845857void CGenericAlgorithmTransformation::computeTransformationMappingNonDistributed(int elementPositionInGrid, CGrid* gridSrc, CGrid* gridDst, 
    846858                                                                                 vector<int>& localSrc, vector<int>& localDst, vector<double>& weight, 
    847859                                                                                 int& nlocalIndexDest) 
     860TRY 
    848861{ 
    849862 
     
    10101023                
    10111024} 
     1025CATCH 
    10121026 
    10131027 
     
    10171031                                                                   int& t, vector<vector<vector<pair<int,double> > > >& dstIndWeight, int currentInd, 
    10181032                                                                   vector<int>& localSrc, vector<int>& localDst, vector<double>& weight) 
     1033TRY 
    10191034{ 
    10201035  int masked_ ; 
     
    10991114 
    11001115} 
     1116CATCH 
    11011117 
    11021118/*! 
     
    11061122*/ 
    11071123void CGenericAlgorithmTransformation::computeIndexSourceMapping(const std::vector<CArray<double,1>* >& dataAuxInputs) 
     1124TRY 
    11081125{ 
    11091126  computeIndexSourceMapping_(dataAuxInputs); 
    11101127} 
     1128CATCH 
    11111129 
    11121130std::vector<StdString> CGenericAlgorithmTransformation::getIdAuxInputs() 
     1131TRY 
    11131132{ 
    11141133  return idAuxInputs_; 
    11151134} 
     1135CATCH 
    11161136 
    11171137CGenericAlgorithmTransformation::AlgoTransType CGenericAlgorithmTransformation::type() 
     1138TRY 
    11181139{ 
    11191140  return type_; 
    11201141} 
    1121  
    1122 } 
     1142CATCH 
     1143 
     1144} 
  • XIOS/dev/dev_olga/src/transformation/grid_generate.cpp

    r978 r1612  
    3030*/ 
    3131void CGridGenerate::selectScalarAlgo(int elementPositionInGrid, ETranformationType transType, int transformationOrder) 
     32TRY 
    3233{ 
    3334  CGenericAlgorithmTransformation* algo = 0; 
    3435  algoTransformation_.push_back(algo); 
    3536} 
     37CATCH 
    3638 
    3739/*! 
     
    4345*/ 
    4446void CGridGenerate::selectAxisAlgo(int elementPositionInGrid, ETranformationType transType, int transformationOrder) 
     47TRY 
    4548{ 
    4649  CGenericAlgorithmTransformation* algo = 0; 
    4750  algoTransformation_.push_back(algo); 
    4851} 
     52CATCH 
    4953 
    5054/*! 
     
    5660*/ 
    5761void CGridGenerate::selectDomainAlgo(int elementPositionInGrid, ETranformationType transType, int transformationOrder) 
     62TRY 
    5863{ 
    5964  std::vector<CDomain*> domainListDestP = gridDestination_->getDomains(); 
     
    8994  algoTransformation_.push_back(algo); 
    9095} 
     96CATCH 
    9197 
    9298/*! 
     
    94100*/ 
    95101void CGridGenerate::completeGrid() 
     102TRY 
    96103{ 
    97104  ListAlgoType::const_iterator itb = listAlgos_.begin(), 
     
    110117  } 
    111118} 
     119CATCH 
    112120 
    113121} 
  • XIOS/dev/dev_olga/src/transformation/grid_transformation.cpp

    r1589 r1612  
    3838*/ 
    3939void CGridTransformation::selectScalarAlgo(int elementPositionInGrid, ETranformationType transType, int transformationOrder) 
     40TRY 
    4041{ 
    4142  std::vector<CScalar*> scaListDestP = gridDestination_->getScalars(); 
     
    5960  algoTransformation_.push_back(algo); 
    6061} 
     62CATCH 
    6163 
    6264/*! 
     
    6769*/ 
    6870void CGridTransformation::selectAxisAlgo(int elementPositionInGrid, ETranformationType transType, int transformationOrder) 
     71TRY 
    6972{ 
    7073  std::vector<CAxis*> axisListDestP = gridDestination_->getAxis(); 
     
    8891  algoTransformation_.push_back(algo); 
    8992} 
     93CATCH 
    9094 
    9195/*! 
     
    96100*/ 
    97101void CGridTransformation::selectDomainAlgo(int elementPositionInGrid, ETranformationType transType, int transformationOrder) 
     102TRY 
    98103{ 
    99104  std::vector<CDomain*> domainListDestP = gridDestination_->getDomains(); 
     
    117122  algoTransformation_.push_back(algo); 
    118123} 
     124CATCH 
    119125 
    120126/*! 
     
    123129*/ 
    124130std::map<int,std::pair<int,int> > CGridTransformation::getElementPosition(CGrid* grid) 
     131TRY 
    125132{ 
    126133  std::vector<CScalar*> scalarListP = grid->getScalars();  
     
    155162  return elementPosition;   
    156163} 
     164CATCH 
    157165 
    158166/*! 
     
    163171*/ 
    164172void CGridTransformation::setUpGridDestination(int elementPositionInGrid, ETranformationType transType) 
     173TRY 
    165174{ 
    166175  if (isSpecialTransformation(transType)) return; 
     
    240249  tempGridDests_.push_back(tmpGridDestination_); 
    241250} 
     251CATCH 
    242252 
    243253/*! 
     
    249259*/ 
    250260void CGridTransformation::setUpGridSource(int elementPositionInGrid) 
     261TRY 
    251262{ 
    252263  if (!tempGridSrcs_.empty() && (getNbAlgo()-1) == tempGridSrcs_.size()) 
     
    326337  tempGridSrcs_.push_back(gridSource_); 
    327338} 
     339CATCH 
    328340 
    329341/*! 
     
    336348*/ 
    337349void CGridTransformation::computeAll(const std::vector<CArray<double,1>* >& dataAuxInputs, Time timeStamp) 
     350TRY 
    338351{ 
    339352  if (nbNormalAlgos_ < 1) return; 
     
    454467  } 
    455468} 
     469CATCH 
    456470 
    457471/*! 
     
    460474*/ 
    461475void CGridTransformation::computeTransformationMapping(const SourceDestinationIndexMap& globaIndexWeightFromSrcToDst) 
     476TRY 
    462477{ 
    463478  CContext* context = CContext::getCurrent(); 
     
    682697 
    683698} 
     699CATCH 
    684700 
    685701/*! 
     
    688704*/ 
    689705const std::list<CGridTransformation::SendingIndexGridSourceMap>& CGridTransformation::getLocalIndexToSendFromGridSource() const 
     706TRY 
    690707{ 
    691708  return localIndexToSendFromGridSource_; 
    692709} 
     710CATCH 
    693711 
    694712/*! 
     
    697715*/ 
    698716const std::list<CGridTransformation::RecvIndexGridDestinationMap>& CGridTransformation::getLocalIndexToReceiveOnGridDest() const 
     717TRY 
    699718{ 
    700719  return localIndexToReceiveOnGridDest_; 
    701720} 
     721CATCH 
    702722 
    703723/*! 
     
    706726*/ 
    707727const std::list<size_t>& CGridTransformation::getNbLocalIndexToReceiveOnGridDest() const 
     728TRY 
    708729{ 
    709730  return nbLocalIndexOnGridDest_; 
    710731} 
    711  
    712 } 
     732CATCH 
     733 
     734} 
  • XIOS/dev/dev_olga/src/transformation/grid_transformation_factory_impl.hpp

    r933 r1612  
    110110} 
    111111 
    112  
    113112} 
    114113#endif // __XIOS_GRID_TRANSFORMATION_FACTORY_HPP__ 
  • XIOS/dev/dev_olga/src/transformation/grid_transformation_selector.cpp

    r1558 r1612  
    4747 : gridSource_(source), gridDestination_(destination), isSameGrid_(false), 
    4848  listAlgos_(), algoTypes_(), nbNormalAlgos_(0), nbSpecialAlgos_(0), auxInputs_() 
     49TRY 
    4950{ 
    5051  if (0 == source) 
     
    6263  initializeTransformations(type); 
    6364} 
     65CATCH 
    6466 
    6567/*! 
     
    7072*/ 
    7173void CGridTransformationSelector::initializeTransformations(TransformationType type) 
     74TRY 
    7275{ 
    7376  // Initialize algorithms 
     
    100103  } 
    101104} 
     105CATCH 
    102106 
    103107CGridTransformationSelector::~CGridTransformationSelector() 
     108TRY 
    104109{ 
    105110  std::vector<CGenericAlgorithmTransformation*>::const_iterator itb = algoTransformation_.begin(), it, 
     
    107112  for (it = itb; it != ite; ++it) delete (*it); 
    108113} 
     114CATCH 
    109115 
    110116/*! 
     
    112118*/ 
    113119void CGridTransformationSelector::updateElementPosition() 
     120TRY 
    114121{ 
    115122  int idxScalar = 0, idxAxis = 0, idxDomain = 0; 
     
    163170  } 
    164171} 
     172CATCH 
    165173 
    166174/*! 
     
    168176*/ 
    169177void CGridTransformationSelector::initializeAlgorithms() 
     178TRY 
    170179{ 
    171180  updateElementPosition(); 
     
    188197  } 
    189198} 
     199CATCH 
    190200 
    191201/*! 
     
    197207*/ 
    198208void CGridTransformationSelector::initializeScalarAlgorithms(int scalarPositionInGrid) 
     209TRY 
    199210{ 
    200211  std::vector<CScalar*> scalarListDestP = gridDestination_->getScalars(); 
     
    229240  } 
    230241} 
     242CATCH 
    231243 
    232244/*! 
     
    238250*/ 
    239251void CGridTransformationSelector::initializeAxisAlgorithms(int axisPositionInGrid) 
     252TRY 
    240253{ 
    241254  std::vector<CAxis*> axisListDestP = gridDestination_->getAxis(); 
     
    270283  } 
    271284} 
     285CATCH 
    272286 
    273287/*! 
     
    278292*/ 
    279293void CGridTransformationSelector::initializeDomainAlgorithms(int domPositionInGrid) 
     294TRY 
    280295{ 
    281296  std::vector<CDomain*> domListDestP = gridDestination_->getDomains(); 
     
    309324    } 
    310325  } 
    311  
    312 } 
     326} 
     327CATCH 
    313328 
    314329/*! 
     
    321336*/ 
    322337void CGridTransformationSelector::selectAlgo(int elementPositionInGrid, ETranformationType transType, int transformationOrder, int algoType) 
     338TRY 
    323339{ 
    324340  updateElementPosition(); 
     
    338354  } 
    339355} 
     356CATCH 
    340357 
    341358bool CGridTransformationSelector::isSpecialTransformation(ETranformationType transType) 
     359TRY 
    342360{ 
    343361  bool res = false; 
     
    353371  return res; 
    354372} 
    355  
    356 } 
     373CATCH 
     374 
     375} 
  • XIOS/dev/dev_olga/src/transformation/scalar_algorithm_extract_axis.cpp

    r1260 r1612  
    2626                                                                     std::map<int, int>& elementPositionInGridDst2AxisPosition, 
    2727                                                                     std::map<int, int>& elementPositionInGridDst2DomainPosition) 
     28TRY 
    2829{ 
    2930  std::vector<CScalar*> scalarListDestP = gridDst->getScalars(); 
     
    3637  return (new CScalarAlgorithmExtractAxis(scalarListDestP[scalarDstIndex], axisListSrcP[axisSrcIndex], extractAxis)); 
    3738} 
     39CATCH 
    3840 
    3941bool CScalarAlgorithmExtractAxis::registerTrans() 
     42TRY 
    4043{ 
    4144  CGridTransformationFactory<CScalar>::registerTransformation(TRANS_EXTRACT_AXIS_TO_SCALAR, create); 
    4245} 
     46CATCH 
    4347 
    4448CScalarAlgorithmExtractAxis::CScalarAlgorithmExtractAxis(CScalar* scalarDestination, CAxis* axisSource, CExtractAxisToScalar* algo) 
    4549 : CScalarAlgorithmTransformation(scalarDestination, axisSource), 
    4650   reduction_(0) 
     51TRY 
    4752{ 
    4853  algo->checkValid(scalarDestination, axisSource); 
     
    5156  reduction_ = CReductionAlgorithm::createOperation(CReductionAlgorithm::ReductionOperations[op]); 
    5257} 
     58CATCH 
    5359 
    5460void CScalarAlgorithmExtractAxis::apply(const std::vector<std::pair<int,double> >& localIndex, 
     
    5763                                         std::vector<bool>& flagInitial,                      
    5864                                         bool ignoreMissingValue, bool firstPass) 
     65TRY 
    5966{ 
    6067  reduction_->apply(localIndex, dataInput, dataOut, flagInitial, ignoreMissingValue, firstPass); 
    6168} 
     69CATCH 
    6270 
    6371CScalarAlgorithmExtractAxis::~CScalarAlgorithmExtractAxis() 
     72TRY 
    6473{ 
    6574  if (0 != reduction_) delete reduction_; 
    6675} 
     76CATCH 
    6777 
    6878void CScalarAlgorithmExtractAxis::computeIndexSourceMapping_(const std::vector<CArray<double,1>* >& dataAuxInputs) 
     79TRY 
    6980{ 
    7081  this->transformationMapping_.resize(1); 
     
    7788  transWeight[0].push_back(1.0); 
    7889} 
     90CATCH 
    7991 
    8092} 
  • XIOS/dev/dev_olga/src/transformation/scalar_algorithm_reduce_axis.cpp

    r1297 r1612  
    2727                                                                     std::map<int, int>& elementPositionInGridDst2AxisPosition, 
    2828                                                                     std::map<int, int>& elementPositionInGridDst2DomainPosition) 
     29TRY 
    2930{ 
    3031  std::vector<CScalar*> scalarListDestP = gridDst->getScalars(); 
     
    3738  return (new CScalarAlgorithmReduceAxis(scalarListDestP[scalarDstIndex], axisListSrcP[axisSrcIndex], reduceAxis)); 
    3839} 
     40CATCH 
    3941 
    4042bool CScalarAlgorithmReduceAxis::registerTrans() 
     43TRY 
    4144{ 
    4245  CGridTransformationFactory<CScalar>::registerTransformation(TRANS_REDUCE_AXIS_TO_SCALAR, create); 
    4346} 
     47CATCH 
    4448 
    4549CScalarAlgorithmReduceAxis::CScalarAlgorithmReduceAxis(CScalar* scalarDestination, CAxis* axisSource, CReduceAxisToScalar* algo) 
    4650 : CScalarAlgorithmTransformation(scalarDestination, axisSource), 
    4751   reduction_(0) 
     52TRY 
    4853{ 
    4954  if (algo->operation.isEmpty()) 
     
    8388  reduction_ = CReductionAlgorithm::createOperation(CReductionAlgorithm::ReductionOperations[op]); 
    8489} 
     90CATCH 
    8591 
    8692void CScalarAlgorithmReduceAxis::apply(const std::vector<std::pair<int,double> >& localIndex, const double* dataInput, CArray<double,1>& dataOut, 
    8793                                         std::vector<bool>& flagInitial, bool ignoreMissingValue, bool firstPass) 
     94TRY 
    8895{ 
    8996  reduction_->apply(localIndex, dataInput, dataOut, flagInitial, ignoreMissingValue, firstPass); 
    9097} 
     98CATCH 
    9199 
    92100void CScalarAlgorithmReduceAxis::updateData(CArray<double,1>& dataOut) 
     101TRY 
    93102{ 
    94103  reduction_->updateData(dataOut); 
    95104} 
     105CATCH 
    96106 
    97107CScalarAlgorithmReduceAxis::~CScalarAlgorithmReduceAxis() 
     108TRY 
    98109{ 
    99110  if (0 != reduction_) delete reduction_; 
    100111} 
     112CATCH 
    101113 
    102114void CScalarAlgorithmReduceAxis::computeIndexSourceMapping_(const std::vector<CArray<double,1>* >& dataAuxInputs) 
     115TRY 
    103116{ 
    104117  this->transformationMapping_.resize(1); 
     
    116129  } 
    117130} 
     131CATCH 
    118132 
    119133} 
  • XIOS/dev/dev_olga/src/transformation/scalar_algorithm_reduce_domain.cpp

    r1396 r1612  
    2626                                                                     std::map<int, int>& elementPositionInGridDst2AxisPosition, 
    2727                                                                     std::map<int, int>& elementPositionInGridDst2DomainPosition) 
     28TRY 
    2829{ 
    2930  std::vector<CScalar*> scalarListDestP = gridDst->getScalars(); 
     
    3637  return (new CScalarAlgorithmReduceDomain(scalarListDestP[scalarDstIndex], domainListSrcP[domainSrcIndex], reduceDomain)); 
    3738} 
     39CATCH 
    3840 
    3941bool CScalarAlgorithmReduceDomain::registerTrans() 
     42TRY 
    4043{ 
    4144  CGridTransformationFactory<CScalar>::registerTransformation(TRANS_REDUCE_DOMAIN_TO_SCALAR, create); 
    4245} 
     46CATCH 
    4347 
    4448CScalarAlgorithmReduceDomain::CScalarAlgorithmReduceDomain(CScalar* scalarDestination, CDomain* domainSource, CReduceDomainToScalar* algo) 
    4549 : CScalarAlgorithmTransformation(scalarDestination, domainSource), 
    4650   reduction_(0) 
     51TRY 
    4752{ 
    4853  algo->checkValid(scalarDestination, domainSource); 
     
    8085  local = algo->local ; 
    8186} 
     87CATCH 
    8288 
    8389void CScalarAlgorithmReduceDomain::apply(const std::vector<std::pair<int,double> >& localIndex, 
     
    8692                                         std::vector<bool>& flagInitial,                      
    8793                                         bool ignoreMissingValue, bool firstPass) 
     94TRY 
    8895{ 
    8996  reduction_->apply(localIndex, dataInput, dataOut, flagInitial, ignoreMissingValue, firstPass); 
    9097} 
     98CATCH 
    9199 
    92100void CScalarAlgorithmReduceDomain::updateData(CArray<double,1>& dataOut) 
     101TRY 
    93102{ 
    94103  reduction_->updateData(dataOut); 
    95104} 
     105CATCH 
    96106 
    97107CScalarAlgorithmReduceDomain::~CScalarAlgorithmReduceDomain() 
     108TRY 
    98109{ 
    99110  if (0 != reduction_) delete reduction_; 
    100111} 
     112CATCH 
    101113 
    102114void CScalarAlgorithmReduceDomain::computeIndexSourceMapping_(const std::vector<CArray<double,1>* >& dataAuxInputs) 
     115TRY 
    103116{ 
    104117  this->transformationMapping_.resize(1); 
     
    137150   
    138151} 
     152CATCH 
    139153 
    140154} 
  • XIOS/dev/dev_olga/src/transformation/scalar_algorithm_reduce_scalar.cpp

    r1314 r1612  
    2222                                                                     std::map<int, int>& elementPositionInGridDst2AxisPosition, 
    2323                                                                     std::map<int, int>& elementPositionInGridDst2DomainPosition) 
     24TRY 
    2425{ 
    2526  std::vector<CScalar*> scalarListDestP = gridDst->getScalars(); 
     
    3233  return (new CScalarAlgorithmReduceScalar(scalarListDestP[scalarDstIndex], scalarListSrcP[scalarSrcIndex], reduceScalar)); 
    3334} 
     35CATCH 
    3436 
    3537bool CScalarAlgorithmReduceScalar::registerTrans() 
     38TRY 
    3639{ 
    3740  CGridTransformationFactory<CScalar>::registerTransformation(TRANS_REDUCE_SCALAR_TO_SCALAR, create); 
    3841} 
     42CATCH 
    3943 
    4044CScalarAlgorithmReduceScalar::CScalarAlgorithmReduceScalar(CScalar* scalarDestination, CScalar* scalarSource, CReduceScalarToScalar* algo) 
    4145 : CScalarAlgorithmTransformation(scalarDestination, scalarSource), 
    4246   reduction_(0) 
     47TRY 
    4348{ 
    4449  eliminateRedondantSrc_= false ; 
     
    7984  reduction_ = CReductionAlgorithm::createOperation(CReductionAlgorithm::ReductionOperations[op]); 
    8085} 
     86CATCH 
    8187 
    8288void CScalarAlgorithmReduceScalar::apply(const std::vector<std::pair<int,double> >& localIndex, const double* dataInput, CArray<double,1>& dataOut, 
    8389                                         std::vector<bool>& flagInitial, bool ignoreMissingValue, bool firstPass) 
     90TRY 
    8491{ 
    8592  reduction_->apply(localIndex, dataInput, dataOut, flagInitial, ignoreMissingValue, firstPass); 
    8693} 
     94CATCH 
    8795 
    8896void CScalarAlgorithmReduceScalar::updateData(CArray<double,1>& dataOut) 
     97TRY 
    8998{ 
    9099  reduction_->updateData(dataOut); 
    91100} 
     101CATCH 
    92102 
    93103CScalarAlgorithmReduceScalar::~CScalarAlgorithmReduceScalar() 
     104TRY 
    94105{ 
    95106  if (0 != reduction_) delete reduction_; 
    96107} 
     108CATCH 
    97109 
    98110void CScalarAlgorithmReduceScalar::computeIndexSourceMapping_(const std::vector<CArray<double,1>* >& dataAuxInputs) 
     111TRY 
    99112{ 
    100113  this->transformationMapping_.resize(1); 
     
    108121 
    109122} 
     123CATCH 
    110124 
    111125} 
  • XIOS/dev/dev_olga/src/transformation/scalar_algorithm_transformation.cpp

    r1403 r1612  
    5757                                                                int elementSourceType, 
    5858                                                                CClientClientDHTInt::Index2VectorInfoTypeMap& globalIndexElementSourceOnProc) 
     59TRY 
    5960{ 
    6061  CContext* context = CContext::getCurrent(); 
     
    121122  } 
    122123} 
    123  
     124CATCH 
    124125} 
Note: See TracChangeset for help on using the changeset viewer.