Changeset 980


Ignore:
Timestamp:
10/24/16 16:16:40 (4 years ago)
Author:
mhnguyen
Message:

Minor improvements:

+) Change some type of variable to avoid some error-prone inputs
+) Change some class name to make it meaningful

Test
+) On Curie
+) Okie

Location:
XIOS/trunk/src
Files:
14 edited

Legend:

Unmodified
Added
Removed
  • XIOS/trunk/src/config/extract_domain_to_axis_attribute.conf

    r895 r980  
    11/* Direction to apply operation (i, j) */ 
    2 DECLARE_ATTRIBUTE(StdString,     direction) 
     2DECLARE_ENUM2(direction, iDir, jDir) 
    33 
    44/* Position of extracted slice */ 
  • XIOS/trunk/src/config/reduce_axis_to_scalar_attribute.conf

    r888 r980  
    1 DECLARE_ATTRIBUTE(StdString, operation) 
     1DECLARE_ENUM4(operation, min, max, sum, average) 
    22 
    33 
  • XIOS/trunk/src/config/reduce_domain_to_axis_attribute.conf

    r938 r980  
    1 DECLARE_ATTRIBUTE(StdString, operation) 
     1DECLARE_ENUM4(operation, min, max, sum, average) 
    22 
    33/* Direction to apply operation (i, j) */ 
  • XIOS/trunk/src/interface/c_attr/icreduce_axis_to_scalar_attr.cpp

    r891 r980  
    2323    if (!cstr2string(operation, operation_size, operation_str)) return; 
    2424    CTimer::get("XIOS").resume(); 
    25     reduce_axis_to_scalar_hdl->operation.setValue(operation_str); 
     25    reduce_axis_to_scalar_hdl->operation.fromString(operation_str); 
    2626    CTimer::get("XIOS").suspend(); 
    2727  } 
     
    3030  { 
    3131    CTimer::get("XIOS").resume(); 
    32     if (!string_copy(reduce_axis_to_scalar_hdl->operation.getInheritedValue(), operation, operation_size)) 
     32    if (!string_copy(reduce_axis_to_scalar_hdl->operation.getInheritedStringValue(), operation, operation_size)) 
    3333      ERROR("void cxios_get_reduce_axis_to_scalar_operation(reduce_axis_to_scalar_Ptr reduce_axis_to_scalar_hdl, char * operation, int operation_size)", << "Input string is too short"); 
    3434    CTimer::get("XIOS").suspend(); 
  • XIOS/trunk/src/node/extract_domain_to_axis.cpp

    r895 r980  
    5151    int domain_nj_glo = domainSrc->nj_glo; 
    5252 
    53     StdString dirLists[]= {"i","j"}; 
    54     std::set<StdString> dirString(dirLists, dirLists + sizeof(dirLists)/sizeof(dirLists[0])); 
    55  
    5653    if (this->direction.isEmpty()) 
    5754      ERROR("CExtractDomainToAxis::checkValid(CAxis* axisDst, CDomain* domainSrc)", 
    58              << "A direction to apply the operation must be defined. It should be: 'i' or 'j'" 
     55             << "A direction to apply the operation must be defined. It should be: 'iDir' or 'jDir'" 
    5956             << "Domain source " <<domainSrc->getId() << std::endl 
    6057             << "Axis destination " << axisDst->getId()); 
    61  
    62     StdString direction = this->direction; 
    63     if (dirString.end() == dirString.find(direction)) 
     58  
     59    if (this->position.isEmpty()) 
     60      ERROR("CExtractDomainToAxis::checkValid(CAxis* axisDst, CDomain* domainSrc)", 
     61             << "Position to extract axis must be defined. " << std::endl 
     62             << "Domain source " <<domainSrc->getId() << std::endl 
     63             << "Axis destination " << axisDst->getId()); 
     64     
     65    switch (direction) 
    6466    { 
    65       ERROR("CExtractDomainToAxis::checkValid(CAxis* axisDst, CDomain* domainSrc)", 
    66        << "Direction '" << direction << " is undefined. Please make sure to use a supported one: i or j" 
    67        << "Domain source " <<domainSrc->getId() << std::endl 
    68        << "Axis destination " << axisDst->getId()); 
    69     } 
    70     else 
    71     { 
    72       if (0 == direction.compare("j")) 
    73       { 
     67      case direction_attr::jDir: 
    7468        if (axis_n_glo != domain_ni_glo) 
    75          ERROR("CExtractDomainToAxis::checkValid(CAxis* axisDst, CDomain* domainSrc)", 
    76            << "Extract domain along j, axis destination should have n_glo equal to ni_glo of domain source" 
    77            << "Domain source " <<domainSrc->getId() << " has nj_glo " << domain_ni_glo << std::endl 
    78            << "Axis destination " << axisDst->getId() << " has n_glo " << axis_n_glo); 
    79       } 
    80       if (0 == direction.compare("i")) 
    81       { 
    82         if (axis_n_glo != domain_nj_glo) 
    83          ERROR("CExtractDomainToAxis::checkValid(CAxis* axisDst, CDomain* domainSrc)", 
    84            << "Extract domain along i, axis destination should have n_glo equal to nj_glo of domain source" 
    85            << "Domain source " <<domainSrc->getId() << " has nj_glo " << domain_nj_glo << std::endl 
    86            << "Axis destination " << axisDst->getId() << " has n_glo " << axis_n_glo); 
    87       } 
    88     } 
    89  
    90     int position = this->position; 
    91     if (0 == direction.compare("j")) 
    92     { 
    93       if ((position < 0) || (position > domain_ni_glo)) 
     69          ERROR("CExtractDomainToAxis::checkValid(CAxis* axisDst, CDomain* domainSrc)", 
     70            << "Extract domain along j, axis destination should have n_glo equal to ni_glo of domain source" 
     71            << "Domain source " <<domainSrc->getId() << " has nj_glo " << domain_ni_glo << std::endl 
     72            << "Axis destination " << axisDst->getId() << " has n_glo " << axis_n_glo); 
     73        if ((position < 0) || (position > domain_ni_glo)) 
    9474        ERROR("CExtractDomainToAxis::checkValid(CAxis* axisDst, CDomain* domainSrc)", 
    9575          << "Extract domain along j, position should be inside 0 and ni_glo of domain source" 
     
    9777          << "Axis destination " << axisDst->getId() << std::endl 
    9878          << "Position " << position); 
    99     } 
    100     if (0 == direction.compare("i")) 
    101     { 
    102       if ((position < 0) || (position > domain_nj_glo)) 
     79         break; 
     80 
     81      case direction_attr::iDir: 
     82        if (axis_n_glo != domain_nj_glo) 
     83          ERROR("CExtractDomainToAxis::checkValid(CAxis* axisDst, CDomain* domainSrc)", 
     84            << "Extract domain along i, axis destination should have n_glo equal to nj_glo of domain source" 
     85            << "Domain source " <<domainSrc->getId() << " has nj_glo " << domain_nj_glo << std::endl 
     86            << "Axis destination " << axisDst->getId() << " has n_glo " << axis_n_glo); 
     87        if ((position < 0) || (position > domain_nj_glo)) 
    10388        ERROR("CExtractDomainToAxis::checkValid(CAxis* axisDst, CDomain* domainSrc)", 
    10489          << "Extract domain along i, position should be inside 0 and nj_glo of domain source" 
     
    10691          << "Axis destination " << axisDst->getId() << std::endl 
    10792          << "Position " << position); 
     93        break; 
     94 
     95      default: 
     96        break; 
    10897    } 
    109  
    11098  } 
    11199 
  • XIOS/trunk/src/node/reduce_axis_to_scalar.cpp

    r891 r980  
    3939  void CReduceAxisToScalar::checkValid(CScalar* scalarDst) 
    4040  { 
    41 //    int axisIBegin, axisNi, axisGlobalSize; 
    42 //    int begin, end, n; 
    43 // 
    44 //    axisIBegin = axisDest->begin.getValue(); 
    45 //    axisNi     = axisDest->n.getValue(); 
    46 //    axisGlobalSize   = axisDest->n_glo.getValue(); 
    47 // 
    48 //    begin = (this->begin.isEmpty()) ?  0 : this->begin.getValue(); 
    49 //    n     = (this->n.isEmpty()) ?  axisGlobalSize : this->n.getValue(); 
    50 //    end   = begin+n-1; 
    51 // 
    52 //    if (begin < 0 || begin > axisGlobalSize - 1 || end < 0 || end > axisGlobalSize - 1 
    53 //        || n < 1 || n > axisGlobalSize || begin > end) 
    54 //      ERROR("CReduceAxisToScalar::checkValid(CAxis* axisDest)", 
    55 //            << "One or more attributes among 'begin' (" << begin << "), 'end' (" << end << "), 'n' (" << n << ") " 
    56 //            << "of axis transformation [ id = '" << axisDest->getId() << "' , context = '" << CObjectFactory::GetCurrentContextId() << "' ] are not well specified"); 
    57 // 
    58 //    this->begin.setValue(begin); 
    59 //    this->n.setValue(n); 
    60  
    6141  } 
    6242 
  • XIOS/trunk/src/node/reduce_domain_to_axis.cpp

    r938 r980  
    5151    int domain_nj_glo = domainSrc->nj_glo; 
    5252 
    53     StdString opLists[]= {"sum","min","max"}; 
    54     std::set<StdString> opString(opLists, opLists + sizeof(opLists)/sizeof(opLists[0])); 
    55  
    5653    if (this->operation.isEmpty()) 
    5754      ERROR("CReduceDomainToAxis::checkValid(CAxis* axisDst, CDomain* domainSrc)", 
     
    6057             << "Axis destination " << axisDst->getId()); 
    6158 
    62     StdString op = this->operation; 
    63     if (opString.end() == opString.find(op)) 
     59    if (this->direction.isEmpty()) 
    6460      ERROR("CReduceDomainToAxis::checkValid(CAxis* axisDst, CDomain* domainSrc)", 
    65          << "Operation '" << op << "' not found. Please make sure to use a supported one" 
    66          << "Domain source " <<domainSrc->getId() << std::endl 
    67          << "Axis destination " << axisDst->getId()); 
     61             << "A direction to apply the operation must be defined. It should be: 'iDir' or 'jDir'" 
     62             << "Domain source " <<domainSrc->getId() << std::endl 
     63             << "Axis destination " << axisDst->getId()); 
    6864 
    6965    if (this->direction.isEmpty()) 
     
    7268             << "Domain source " <<domainSrc->getId() << std::endl 
    7369             << "Axis destination " << axisDst->getId()); 
     70 
     71     
     72    switch (direction) 
     73    { 
     74      case direction_attr::jDir: 
     75        if (axis_n_glo != domain_ni_glo) 
     76          ERROR("CReduceDomainToAxis::checkValid(CAxis* axisDst, CDomain* domainSrc)", 
     77            << "Extract domain along j, axis destination should have n_glo equal to ni_glo of domain source" 
     78            << "Domain source " <<domainSrc->getId() << " has nj_glo " << domain_ni_glo << std::endl 
     79            << "Axis destination " << axisDst->getId() << " has n_glo " << axis_n_glo); 
     80         break; 
     81 
     82      case direction_attr::iDir: 
     83        if (axis_n_glo != domain_nj_glo) 
     84          ERROR("CReduceDomainToAxis::checkValid(CAxis* axisDst, CDomain* domainSrc)", 
     85            << "Extract domain along i, axis destination should have n_glo equal to nj_glo of domain source" 
     86            << "Domain source " <<domainSrc->getId() << " has nj_glo " << domain_nj_glo << std::endl 
     87            << "Axis destination " << axisDst->getId() << " has n_glo " << axis_n_glo); 
     88        break; 
     89 
     90      default: 
     91        break; 
     92    } 
    7493  } 
    7594 
  • XIOS/trunk/src/transformation/axis_algorithm_extract_domain.cpp

    r979 r980  
    4848  algo->checkValid(axisDestination, domainSource); 
    4949  StdString op = "extract"; 
    50   StdString direction = algo->direction; 
    51   dir_ = (0 == direction.compare("i")) ? iDir : jDir; 
     50 
     51  switch (algo->direction) 
     52  { 
     53    case CExtractDomainToAxis::direction_attr::jDir: 
     54      dir_ = jDir; 
     55      break; 
     56    case CExtractDomainToAxis::direction_attr::iDir: 
     57      dir_ = iDir; 
     58      break; 
     59    default: 
     60      break; 
     61  } 
     62 
    5263  pos_ = algo->position; 
    5364  reduction_ = CReductionAlgorithm::createOperation(CReductionAlgorithm::ReductionOperations[op]); 
  • XIOS/trunk/src/transformation/axis_algorithm_reduce_domain.cpp

    r979 r980  
    4646{ 
    4747  algo->checkValid(axisDestination, domainSource); 
    48   StdString op = algo->operation; 
     48  StdString op; 
     49  switch (algo->operation) 
     50  { 
     51    case CReduceDomainToAxis::operation_attr::sum: 
     52      op = "sum"; 
     53      break; 
     54    case CReduceDomainToAxis::operation_attr::min: 
     55      op = "min"; 
     56      break; 
     57    case CReduceDomainToAxis::operation_attr::max: 
     58      op = "max"; 
     59      break; 
     60    case CReduceDomainToAxis::operation_attr::average: 
     61      op = "average"; 
     62      break; 
     63    default: 
     64        ERROR("CAxisAlgorithmReduceDomain::CAxisAlgorithmReduceDomain(CAxis* axisDestination, CDomain* domainSource, CReduceDomainToAxis* algo)", 
     65         << "Operation is wrongly defined. Supported operations: sum, min, max, average." << std::endl 
     66         << "Domain source " <<domainSource->getId() << std::endl 
     67         << "Axis destination " << axisDestination->getId()); 
     68 
     69  } 
     70 
    4971  dir_ = (CReduceDomainToAxis::direction_attr::iDir == algo->direction)  ? iDir : jDir; 
    5072  reduction_ = CReductionAlgorithm::createOperation(CReductionAlgorithm::ReductionOperations[op]); 
  • XIOS/trunk/src/transformation/grid_transformation_selector.cpp

    r978 r980  
    1919{ 
    2020  //! Scalar 
    21   CScalarAlgorithmReduceScalar::registerTrans(); 
    22   CScalarAlgorithmExtractScalar::registerTrans(); 
     21  CScalarAlgorithmReduceAxis::registerTrans(); 
     22  CScalarAlgorithmExtractAxis::registerTrans(); 
    2323  CScalarAlgorithmReduceDomain::registerTrans(); 
    2424 
  • XIOS/trunk/src/transformation/scalar_algorithm_extract_axis.cpp

    r977 r980  
    1717 
    1818namespace xios { 
    19 CGenericAlgorithmTransformation* CScalarAlgorithmExtractScalar::create(CGrid* gridDst, CGrid* gridSrc, 
     19CGenericAlgorithmTransformation* CScalarAlgorithmExtractAxis::create(CGrid* gridDst, CGrid* gridSrc, 
    2020                                                                     CTransformation<CScalar>* transformation, 
    2121                                                                     int elementPositionInGrid, 
     
    3434  int axisSrcIndex = elementPositionInGridSrc2AxisPosition[elementPositionInGrid]; 
    3535 
    36   return (new CScalarAlgorithmExtractScalar(scalarListDestP[scalarDstIndex], axisListSrcP[axisSrcIndex], extractAxis)); 
     36  return (new CScalarAlgorithmExtractAxis(scalarListDestP[scalarDstIndex], axisListSrcP[axisSrcIndex], extractAxis)); 
    3737} 
    3838 
    39 bool CScalarAlgorithmExtractScalar::registerTrans() 
     39bool CScalarAlgorithmExtractAxis::registerTrans() 
    4040{ 
    4141  CGridTransformationFactory<CScalar>::registerTransformation(TRANS_EXTRACT_AXIS_TO_SCALAR, create); 
    4242} 
    4343 
    44 CScalarAlgorithmExtractScalar::CScalarAlgorithmExtractScalar(CScalar* scalarDestination, CAxis* axisSource, CExtractAxisToScalar* algo) 
     44CScalarAlgorithmExtractAxis::CScalarAlgorithmExtractAxis(CScalar* scalarDestination, CAxis* axisSource, CExtractAxisToScalar* algo) 
    4545 : CScalarAlgorithmTransformation(scalarDestination, axisSource), 
    4646   reduction_(0) 
     
    5252} 
    5353 
    54 void CScalarAlgorithmExtractScalar::apply(const std::vector<std::pair<int,double> >& localIndex, 
     54void CScalarAlgorithmExtractAxis::apply(const std::vector<std::pair<int,double> >& localIndex, 
    5555                                         const double* dataInput, 
    5656                                         CArray<double,1>& dataOut, 
     
    6161} 
    6262 
    63 CScalarAlgorithmExtractScalar::~CScalarAlgorithmExtractScalar() 
     63CScalarAlgorithmExtractAxis::~CScalarAlgorithmExtractAxis() 
    6464{ 
    6565  if (0 != reduction_) delete reduction_; 
    6666} 
    6767 
    68 void CScalarAlgorithmExtractScalar::computeIndexSourceMapping_(const std::vector<CArray<double,1>* >& dataAuxInputs) 
     68void CScalarAlgorithmExtractAxis::computeIndexSourceMapping_(const std::vector<CArray<double,1>* >& dataAuxInputs) 
    6969{ 
    7070  this->transformationMapping_.resize(1); 
  • XIOS/trunk/src/transformation/scalar_algorithm_extract_axis.hpp

    r960 r980  
    2121 
    2222/*! 
    23   \class CScalarAlgorithmExtractScalar 
     23  \class CScalarAlgorithmExtractAxis 
    2424  Extract a scalar from an axis 
    2525*/ 
    26 class CScalarAlgorithmExtractScalar : public CScalarAlgorithmTransformation 
     26class CScalarAlgorithmExtractAxis : public CScalarAlgorithmTransformation 
    2727{ 
    2828public: 
    29   CScalarAlgorithmExtractScalar(CScalar* scalarDestination, CAxis* axisSource, CExtractAxisToScalar* algo); 
     29  CScalarAlgorithmExtractAxis(CScalar* scalarDestination, CAxis* axisSource, CExtractAxisToScalar* algo); 
    3030 
    3131  virtual void apply(const std::vector<std::pair<int,double> >& localIndex, 
     
    3535                     const double& defaultValue); 
    3636 
    37   virtual ~CScalarAlgorithmExtractScalar(); 
     37  virtual ~CScalarAlgorithmExtractAxis(); 
    3838 
    3939  static bool registerTrans(); 
  • XIOS/trunk/src/transformation/scalar_algorithm_reduce_axis.cpp

    r979 r980  
    1818 
    1919namespace xios { 
    20 CGenericAlgorithmTransformation* CScalarAlgorithmReduceScalar::create(CGrid* gridDst, CGrid* gridSrc, 
     20CGenericAlgorithmTransformation* CScalarAlgorithmReduceAxis::create(CGrid* gridDst, CGrid* gridSrc, 
    2121                                                                     CTransformation<CScalar>* transformation, 
    2222                                                                     int elementPositionInGrid, 
     
    3535  int axisSrcIndex = elementPositionInGridSrc2AxisPosition[elementPositionInGrid]; 
    3636 
    37   return (new CScalarAlgorithmReduceScalar(scalarListDestP[scalarDstIndex], axisListSrcP[axisSrcIndex], reduceAxis)); 
     37  return (new CScalarAlgorithmReduceAxis(scalarListDestP[scalarDstIndex], axisListSrcP[axisSrcIndex], reduceAxis)); 
    3838} 
    3939 
    40 bool CScalarAlgorithmReduceScalar::registerTrans() 
     40bool CScalarAlgorithmReduceAxis::registerTrans() 
    4141{ 
    4242  CGridTransformationFactory<CScalar>::registerTransformation(TRANS_REDUCE_AXIS_TO_SCALAR, create); 
    4343} 
    4444 
    45 CScalarAlgorithmReduceScalar::CScalarAlgorithmReduceScalar(CScalar* scalarDestination, CAxis* axisSource, CReduceAxisToScalar* algo) 
     45CScalarAlgorithmReduceAxis::CScalarAlgorithmReduceAxis(CScalar* scalarDestination, CAxis* axisSource, CReduceAxisToScalar* algo) 
    4646 : CScalarAlgorithmTransformation(scalarDestination, axisSource), 
    4747   reduction_(0) 
    4848{ 
    4949  if (algo->operation.isEmpty()) 
    50     ERROR("CScalarAlgorithmReduceScalar::CScalarAlgorithmReduceScalar(CAxis* axisDestination, CAxis* axisSource, CReduceAxisToScalar* algo)", 
     50    ERROR("CScalarAlgorithmReduceAxis::CScalarAlgorithmReduceAxis(CAxis* axisDestination, CAxis* axisSource, CReduceAxisToScalar* algo)", 
    5151           << "Operation must be defined." 
    5252           << "Axis source " <<axisSource->getId() << std::endl 
    5353           << "Scalar destination " << scalarDestination->getId()); 
    54   StdString op = algo->operation; 
     54  StdString op; 
     55  switch (algo->operation) 
     56  { 
     57    case CReduceAxisToScalar::operation_attr::sum: 
     58      op = "sum"; 
     59      break; 
     60    case CReduceAxisToScalar::operation_attr::min: 
     61      op = "min"; 
     62      break; 
     63    case CReduceAxisToScalar::operation_attr::max: 
     64      op = "max"; 
     65      break; 
     66    case CReduceAxisToScalar::operation_attr::average: 
     67      op = "average"; 
     68      break; 
     69    default: 
     70        ERROR("CScalarAlgorithmReduceAxis::CScalarAlgorithmReduceAxis(CScalar* scalarDestination, CAxis* axisSource, CReduceAxisToScalar* algo)", 
     71         << "Operation is wrongly defined. Supported operations: sum, min, max, average." << std::endl 
     72         << "Domain source " <<axisSource->getId() << std::endl 
     73         << "Scalar destination " << scalarDestination->getId()); 
     74 
     75  } 
     76   
    5577  if (CReductionAlgorithm::ReductionOperations.end() == CReductionAlgorithm::ReductionOperations.find(op)) 
    56     ERROR("CScalarAlgorithmReduceScalar::CScalarAlgorithmReduceScalar(CAxis* axisDestination, CAxis* axisSource, CReduceAxisToScalar* algo)", 
     78    ERROR("CScalarAlgorithmReduceAxis::CScalarAlgorithmReduceAxis(CAxis* axisDestination, CAxis* axisSource, CReduceAxisToScalar* algo)", 
    5779       << "Operation '" << op << "' not found. Please make sure to use a supported one" 
    5880       << "Axis source " <<axisSource->getId() << std::endl 
     
    6284} 
    6385 
    64 void CScalarAlgorithmReduceScalar::apply(const std::vector<std::pair<int,double> >& localIndex, 
     86void CScalarAlgorithmReduceAxis::apply(const std::vector<std::pair<int,double> >& localIndex, 
    6587                                         const double* dataInput, 
    6688                                         CArray<double,1>& dataOut, 
     
    7193} 
    7294 
    73 void CScalarAlgorithmReduceScalar::updateData(CArray<double,1>& dataOut) 
     95void CScalarAlgorithmReduceAxis::updateData(CArray<double,1>& dataOut) 
    7496{ 
    7597  reduction_->updateData(dataOut); 
    7698} 
    7799 
    78 CScalarAlgorithmReduceScalar::~CScalarAlgorithmReduceScalar() 
     100CScalarAlgorithmReduceAxis::~CScalarAlgorithmReduceAxis() 
    79101{ 
    80102  if (0 != reduction_) delete reduction_; 
    81103} 
    82104 
    83 void CScalarAlgorithmReduceScalar::computeIndexSourceMapping_(const std::vector<CArray<double,1>* >& dataAuxInputs) 
     105void CScalarAlgorithmReduceAxis::computeIndexSourceMapping_(const std::vector<CArray<double,1>* >& dataAuxInputs) 
    84106{ 
    85107  this->transformationMapping_.resize(1); 
  • XIOS/trunk/src/transformation/scalar_algorithm_reduce_axis.hpp

    r979 r980  
    2121 
    2222/*! 
    23   \class CScalarAlgorithmReduceScalar 
     23  \class CScalarAlgorithmReduceAxis 
    2424  Reducing an axis to a scalar 
    2525*/ 
    26 class CScalarAlgorithmReduceScalar : public CScalarAlgorithmTransformation 
     26class CScalarAlgorithmReduceAxis : public CScalarAlgorithmTransformation 
    2727{ 
    2828public: 
    29   CScalarAlgorithmReduceScalar(CScalar* scalarDestination, CAxis* axisSource, CReduceAxisToScalar* algo); 
     29  CScalarAlgorithmReduceAxis(CScalar* scalarDestination, CAxis* axisSource, CReduceAxisToScalar* algo); 
    3030 
    3131  virtual void apply(const std::vector<std::pair<int,double> >& localIndex, 
     
    3737  virtual void updateData(CArray<double,1>& dataOut); 
    3838   
    39   virtual ~CScalarAlgorithmReduceScalar(); 
     39  virtual ~CScalarAlgorithmReduceAxis(); 
    4040 
    4141  static bool registerTrans(); 
Note: See TracChangeset for help on using the changeset viewer.