Index: /XIOS/trunk/src/config/extract_domain_to_axis_attribute.conf
===================================================================
--- /XIOS/trunk/src/config/extract_domain_to_axis_attribute.conf	(revision 979)
+++ /XIOS/trunk/src/config/extract_domain_to_axis_attribute.conf	(revision 980)
@@ -1,4 +1,4 @@
 /* Direction to apply operation (i, j) */
-DECLARE_ATTRIBUTE(StdString,     direction)
+DECLARE_ENUM2(direction, iDir, jDir)
 
 /* Position of extracted slice */
Index: /XIOS/trunk/src/config/reduce_axis_to_scalar_attribute.conf
===================================================================
--- /XIOS/trunk/src/config/reduce_axis_to_scalar_attribute.conf	(revision 979)
+++ /XIOS/trunk/src/config/reduce_axis_to_scalar_attribute.conf	(revision 980)
@@ -1,3 +1,3 @@
-DECLARE_ATTRIBUTE(StdString, operation)
+DECLARE_ENUM4(operation, min, max, sum, average)
 
 
Index: /XIOS/trunk/src/config/reduce_domain_to_axis_attribute.conf
===================================================================
--- /XIOS/trunk/src/config/reduce_domain_to_axis_attribute.conf	(revision 979)
+++ /XIOS/trunk/src/config/reduce_domain_to_axis_attribute.conf	(revision 980)
@@ -1,3 +1,3 @@
-DECLARE_ATTRIBUTE(StdString, operation)
+DECLARE_ENUM4(operation, min, max, sum, average)
 
 /* Direction to apply operation (i, j) */
Index: /XIOS/trunk/src/interface/c_attr/icreduce_axis_to_scalar_attr.cpp
===================================================================
--- /XIOS/trunk/src/interface/c_attr/icreduce_axis_to_scalar_attr.cpp	(revision 979)
+++ /XIOS/trunk/src/interface/c_attr/icreduce_axis_to_scalar_attr.cpp	(revision 980)
@@ -23,5 +23,5 @@
     if (!cstr2string(operation, operation_size, operation_str)) return;
     CTimer::get("XIOS").resume();
-    reduce_axis_to_scalar_hdl->operation.setValue(operation_str);
+    reduce_axis_to_scalar_hdl->operation.fromString(operation_str);
     CTimer::get("XIOS").suspend();
   }
@@ -30,5 +30,5 @@
   {
     CTimer::get("XIOS").resume();
-    if (!string_copy(reduce_axis_to_scalar_hdl->operation.getInheritedValue(), operation, operation_size))
+    if (!string_copy(reduce_axis_to_scalar_hdl->operation.getInheritedStringValue(), operation, operation_size))
       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");
     CTimer::get("XIOS").suspend();
Index: /XIOS/trunk/src/node/extract_domain_to_axis.cpp
===================================================================
--- /XIOS/trunk/src/node/extract_domain_to_axis.cpp	(revision 979)
+++ /XIOS/trunk/src/node/extract_domain_to_axis.cpp	(revision 980)
@@ -51,45 +51,25 @@
     int domain_nj_glo = domainSrc->nj_glo;
 
-    StdString dirLists[]= {"i","j"};
-    std::set<StdString> dirString(dirLists, dirLists + sizeof(dirLists)/sizeof(dirLists[0]));
-
     if (this->direction.isEmpty())
       ERROR("CExtractDomainToAxis::checkValid(CAxis* axisDst, CDomain* domainSrc)",
-             << "A direction to apply the operation must be defined. It should be: 'i' or 'j'"
+             << "A direction to apply the operation must be defined. It should be: 'iDir' or 'jDir'"
              << "Domain source " <<domainSrc->getId() << std::endl
              << "Axis destination " << axisDst->getId());
-
-    StdString direction = this->direction;
-    if (dirString.end() == dirString.find(direction))
+ 
+    if (this->position.isEmpty())
+      ERROR("CExtractDomainToAxis::checkValid(CAxis* axisDst, CDomain* domainSrc)",
+             << "Position to extract axis must be defined. " << std::endl
+             << "Domain source " <<domainSrc->getId() << std::endl
+             << "Axis destination " << axisDst->getId());
+    
+    switch (direction)
     {
-      ERROR("CExtractDomainToAxis::checkValid(CAxis* axisDst, CDomain* domainSrc)",
-       << "Direction '" << direction << " is undefined. Please make sure to use a supported one: i or j"
-       << "Domain source " <<domainSrc->getId() << std::endl
-       << "Axis destination " << axisDst->getId());
-    }
-    else
-    {
-      if (0 == direction.compare("j"))
-      {
+      case direction_attr::jDir:
         if (axis_n_glo != domain_ni_glo)
-         ERROR("CExtractDomainToAxis::checkValid(CAxis* axisDst, CDomain* domainSrc)",
-           << "Extract domain along j, axis destination should have n_glo equal to ni_glo of domain source"
-           << "Domain source " <<domainSrc->getId() << " has nj_glo " << domain_ni_glo << std::endl
-           << "Axis destination " << axisDst->getId() << " has n_glo " << axis_n_glo);
-      }
-      if (0 == direction.compare("i"))
-      {
-        if (axis_n_glo != domain_nj_glo)
-         ERROR("CExtractDomainToAxis::checkValid(CAxis* axisDst, CDomain* domainSrc)",
-           << "Extract domain along i, axis destination should have n_glo equal to nj_glo of domain source"
-           << "Domain source " <<domainSrc->getId() << " has nj_glo " << domain_nj_glo << std::endl
-           << "Axis destination " << axisDst->getId() << " has n_glo " << axis_n_glo);
-      }
-    }
-
-    int position = this->position;
-    if (0 == direction.compare("j"))
-    {
-      if ((position < 0) || (position > domain_ni_glo))
+          ERROR("CExtractDomainToAxis::checkValid(CAxis* axisDst, CDomain* domainSrc)",
+            << "Extract domain along j, axis destination should have n_glo equal to ni_glo of domain source"
+            << "Domain source " <<domainSrc->getId() << " has nj_glo " << domain_ni_glo << std::endl
+            << "Axis destination " << axisDst->getId() << " has n_glo " << axis_n_glo);
+        if ((position < 0) || (position > domain_ni_glo))
         ERROR("CExtractDomainToAxis::checkValid(CAxis* axisDst, CDomain* domainSrc)",
           << "Extract domain along j, position should be inside 0 and ni_glo of domain source"
@@ -97,8 +77,13 @@
           << "Axis destination " << axisDst->getId() << std::endl
           << "Position " << position);
-    }
-    if (0 == direction.compare("i"))
-    {
-      if ((position < 0) || (position > domain_nj_glo))
+         break;
+
+      case direction_attr::iDir:
+        if (axis_n_glo != domain_nj_glo)
+          ERROR("CExtractDomainToAxis::checkValid(CAxis* axisDst, CDomain* domainSrc)",
+            << "Extract domain along i, axis destination should have n_glo equal to nj_glo of domain source"
+            << "Domain source " <<domainSrc->getId() << " has nj_glo " << domain_nj_glo << std::endl
+            << "Axis destination " << axisDst->getId() << " has n_glo " << axis_n_glo);
+        if ((position < 0) || (position > domain_nj_glo))
         ERROR("CExtractDomainToAxis::checkValid(CAxis* axisDst, CDomain* domainSrc)",
           << "Extract domain along i, position should be inside 0 and nj_glo of domain source"
@@ -106,6 +91,9 @@
           << "Axis destination " << axisDst->getId() << std::endl
           << "Position " << position);
+        break;
+
+      default:
+        break;
     }
-
   }
 
Index: /XIOS/trunk/src/node/reduce_axis_to_scalar.cpp
===================================================================
--- /XIOS/trunk/src/node/reduce_axis_to_scalar.cpp	(revision 979)
+++ /XIOS/trunk/src/node/reduce_axis_to_scalar.cpp	(revision 980)
@@ -39,24 +39,4 @@
   void CReduceAxisToScalar::checkValid(CScalar* scalarDst)
   {
-//    int axisIBegin, axisNi, axisGlobalSize;
-//    int begin, end, n;
-//
-//    axisIBegin = axisDest->begin.getValue();
-//    axisNi     = axisDest->n.getValue();
-//    axisGlobalSize   = axisDest->n_glo.getValue();
-//
-//    begin = (this->begin.isEmpty()) ?  0 : this->begin.getValue();
-//    n     = (this->n.isEmpty()) ?  axisGlobalSize : this->n.getValue();
-//    end   = begin+n-1;
-//
-//    if (begin < 0 || begin > axisGlobalSize - 1 || end < 0 || end > axisGlobalSize - 1
-//        || n < 1 || n > axisGlobalSize || begin > end)
-//      ERROR("CReduceAxisToScalar::checkValid(CAxis* axisDest)",
-//            << "One or more attributes among 'begin' (" << begin << "), 'end' (" << end << "), 'n' (" << n << ") "
-//            << "of axis transformation [ id = '" << axisDest->getId() << "' , context = '" << CObjectFactory::GetCurrentContextId() << "' ] are not well specified");
-//
-//    this->begin.setValue(begin);
-//    this->n.setValue(n);
-
   }
 
Index: /XIOS/trunk/src/node/reduce_domain_to_axis.cpp
===================================================================
--- /XIOS/trunk/src/node/reduce_domain_to_axis.cpp	(revision 979)
+++ /XIOS/trunk/src/node/reduce_domain_to_axis.cpp	(revision 980)
@@ -51,7 +51,4 @@
     int domain_nj_glo = domainSrc->nj_glo;
 
-    StdString opLists[]= {"sum","min","max"};
-    std::set<StdString> opString(opLists, opLists + sizeof(opLists)/sizeof(opLists[0]));
-
     if (this->operation.isEmpty())
       ERROR("CReduceDomainToAxis::checkValid(CAxis* axisDst, CDomain* domainSrc)",
@@ -60,10 +57,9 @@
              << "Axis destination " << axisDst->getId());
 
-    StdString op = this->operation;
-    if (opString.end() == opString.find(op))
+    if (this->direction.isEmpty())
       ERROR("CReduceDomainToAxis::checkValid(CAxis* axisDst, CDomain* domainSrc)",
-         << "Operation '" << op << "' not found. Please make sure to use a supported one"
-         << "Domain source " <<domainSrc->getId() << std::endl
-         << "Axis destination " << axisDst->getId());
+             << "A direction to apply the operation must be defined. It should be: 'iDir' or 'jDir'"
+             << "Domain source " <<domainSrc->getId() << std::endl
+             << "Axis destination " << axisDst->getId());
 
     if (this->direction.isEmpty())
@@ -72,4 +68,27 @@
              << "Domain source " <<domainSrc->getId() << std::endl
              << "Axis destination " << axisDst->getId());
+
+    
+    switch (direction)
+    {
+      case direction_attr::jDir:
+        if (axis_n_glo != domain_ni_glo)
+          ERROR("CReduceDomainToAxis::checkValid(CAxis* axisDst, CDomain* domainSrc)",
+            << "Extract domain along j, axis destination should have n_glo equal to ni_glo of domain source"
+            << "Domain source " <<domainSrc->getId() << " has nj_glo " << domain_ni_glo << std::endl
+            << "Axis destination " << axisDst->getId() << " has n_glo " << axis_n_glo);
+         break;
+
+      case direction_attr::iDir:
+        if (axis_n_glo != domain_nj_glo)
+          ERROR("CReduceDomainToAxis::checkValid(CAxis* axisDst, CDomain* domainSrc)",
+            << "Extract domain along i, axis destination should have n_glo equal to nj_glo of domain source"
+            << "Domain source " <<domainSrc->getId() << " has nj_glo " << domain_nj_glo << std::endl
+            << "Axis destination " << axisDst->getId() << " has n_glo " << axis_n_glo);
+        break;
+
+      default:
+        break;
+    }
   }
 
Index: /XIOS/trunk/src/transformation/axis_algorithm_extract_domain.cpp
===================================================================
--- /XIOS/trunk/src/transformation/axis_algorithm_extract_domain.cpp	(revision 979)
+++ /XIOS/trunk/src/transformation/axis_algorithm_extract_domain.cpp	(revision 980)
@@ -48,6 +48,17 @@
   algo->checkValid(axisDestination, domainSource);
   StdString op = "extract";
-  StdString direction = algo->direction;
-  dir_ = (0 == direction.compare("i")) ? iDir : jDir;
+
+  switch (algo->direction)
+  {
+    case CExtractDomainToAxis::direction_attr::jDir:
+      dir_ = jDir;
+      break;
+    case CExtractDomainToAxis::direction_attr::iDir:
+      dir_ = iDir;
+      break;
+    default:
+      break;
+  }
+
   pos_ = algo->position;
   reduction_ = CReductionAlgorithm::createOperation(CReductionAlgorithm::ReductionOperations[op]);
Index: /XIOS/trunk/src/transformation/axis_algorithm_reduce_domain.cpp
===================================================================
--- /XIOS/trunk/src/transformation/axis_algorithm_reduce_domain.cpp	(revision 979)
+++ /XIOS/trunk/src/transformation/axis_algorithm_reduce_domain.cpp	(revision 980)
@@ -46,5 +46,27 @@
 {
   algo->checkValid(axisDestination, domainSource);
-  StdString op = algo->operation;
+  StdString op;
+  switch (algo->operation)
+  {
+    case CReduceDomainToAxis::operation_attr::sum:
+      op = "sum";
+      break;
+    case CReduceDomainToAxis::operation_attr::min:
+      op = "min";
+      break;
+    case CReduceDomainToAxis::operation_attr::max:
+      op = "max";
+      break;
+    case CReduceDomainToAxis::operation_attr::average:
+      op = "average";
+      break;
+    default:
+        ERROR("CAxisAlgorithmReduceDomain::CAxisAlgorithmReduceDomain(CAxis* axisDestination, CDomain* domainSource, CReduceDomainToAxis* algo)",
+         << "Operation is wrongly defined. Supported operations: sum, min, max, average." << std::endl
+         << "Domain source " <<domainSource->getId() << std::endl
+         << "Axis destination " << axisDestination->getId());
+
+  }
+
   dir_ = (CReduceDomainToAxis::direction_attr::iDir == algo->direction)  ? iDir : jDir;
   reduction_ = CReductionAlgorithm::createOperation(CReductionAlgorithm::ReductionOperations[op]);
Index: /XIOS/trunk/src/transformation/grid_transformation_selector.cpp
===================================================================
--- /XIOS/trunk/src/transformation/grid_transformation_selector.cpp	(revision 979)
+++ /XIOS/trunk/src/transformation/grid_transformation_selector.cpp	(revision 980)
@@ -19,6 +19,6 @@
 {
   //! Scalar
-  CScalarAlgorithmReduceScalar::registerTrans();
-  CScalarAlgorithmExtractScalar::registerTrans();
+  CScalarAlgorithmReduceAxis::registerTrans();
+  CScalarAlgorithmExtractAxis::registerTrans();
   CScalarAlgorithmReduceDomain::registerTrans();
 
Index: /XIOS/trunk/src/transformation/scalar_algorithm_extract_axis.cpp
===================================================================
--- /XIOS/trunk/src/transformation/scalar_algorithm_extract_axis.cpp	(revision 979)
+++ /XIOS/trunk/src/transformation/scalar_algorithm_extract_axis.cpp	(revision 980)
@@ -17,5 +17,5 @@
 
 namespace xios {
-CGenericAlgorithmTransformation* CScalarAlgorithmExtractScalar::create(CGrid* gridDst, CGrid* gridSrc,
+CGenericAlgorithmTransformation* CScalarAlgorithmExtractAxis::create(CGrid* gridDst, CGrid* gridSrc,
                                                                      CTransformation<CScalar>* transformation,
                                                                      int elementPositionInGrid,
@@ -34,13 +34,13 @@
   int axisSrcIndex = elementPositionInGridSrc2AxisPosition[elementPositionInGrid];
 
-  return (new CScalarAlgorithmExtractScalar(scalarListDestP[scalarDstIndex], axisListSrcP[axisSrcIndex], extractAxis));
+  return (new CScalarAlgorithmExtractAxis(scalarListDestP[scalarDstIndex], axisListSrcP[axisSrcIndex], extractAxis));
 }
 
-bool CScalarAlgorithmExtractScalar::registerTrans()
+bool CScalarAlgorithmExtractAxis::registerTrans()
 {
   CGridTransformationFactory<CScalar>::registerTransformation(TRANS_EXTRACT_AXIS_TO_SCALAR, create);
 }
 
-CScalarAlgorithmExtractScalar::CScalarAlgorithmExtractScalar(CScalar* scalarDestination, CAxis* axisSource, CExtractAxisToScalar* algo)
+CScalarAlgorithmExtractAxis::CScalarAlgorithmExtractAxis(CScalar* scalarDestination, CAxis* axisSource, CExtractAxisToScalar* algo)
  : CScalarAlgorithmTransformation(scalarDestination, axisSource),
    reduction_(0)
@@ -52,5 +52,5 @@
 }
 
-void CScalarAlgorithmExtractScalar::apply(const std::vector<std::pair<int,double> >& localIndex,
+void CScalarAlgorithmExtractAxis::apply(const std::vector<std::pair<int,double> >& localIndex,
                                          const double* dataInput,
                                          CArray<double,1>& dataOut,
@@ -61,10 +61,10 @@
 }
 
-CScalarAlgorithmExtractScalar::~CScalarAlgorithmExtractScalar()
+CScalarAlgorithmExtractAxis::~CScalarAlgorithmExtractAxis()
 {
   if (0 != reduction_) delete reduction_;
 }
 
-void CScalarAlgorithmExtractScalar::computeIndexSourceMapping_(const std::vector<CArray<double,1>* >& dataAuxInputs)
+void CScalarAlgorithmExtractAxis::computeIndexSourceMapping_(const std::vector<CArray<double,1>* >& dataAuxInputs)
 {
   this->transformationMapping_.resize(1);
Index: /XIOS/trunk/src/transformation/scalar_algorithm_extract_axis.hpp
===================================================================
--- /XIOS/trunk/src/transformation/scalar_algorithm_extract_axis.hpp	(revision 979)
+++ /XIOS/trunk/src/transformation/scalar_algorithm_extract_axis.hpp	(revision 980)
@@ -21,11 +21,11 @@
 
 /*!
-  \class CScalarAlgorithmExtractScalar
+  \class CScalarAlgorithmExtractAxis
   Extract a scalar from an axis
 */
-class CScalarAlgorithmExtractScalar : public CScalarAlgorithmTransformation
+class CScalarAlgorithmExtractAxis : public CScalarAlgorithmTransformation
 {
 public:
-  CScalarAlgorithmExtractScalar(CScalar* scalarDestination, CAxis* axisSource, CExtractAxisToScalar* algo);
+  CScalarAlgorithmExtractAxis(CScalar* scalarDestination, CAxis* axisSource, CExtractAxisToScalar* algo);
 
   virtual void apply(const std::vector<std::pair<int,double> >& localIndex,
@@ -35,5 +35,5 @@
                      const double& defaultValue);
 
-  virtual ~CScalarAlgorithmExtractScalar();
+  virtual ~CScalarAlgorithmExtractAxis();
 
   static bool registerTrans();
Index: /XIOS/trunk/src/transformation/scalar_algorithm_reduce_axis.cpp
===================================================================
--- /XIOS/trunk/src/transformation/scalar_algorithm_reduce_axis.cpp	(revision 979)
+++ /XIOS/trunk/src/transformation/scalar_algorithm_reduce_axis.cpp	(revision 980)
@@ -18,5 +18,5 @@
 
 namespace xios {
-CGenericAlgorithmTransformation* CScalarAlgorithmReduceScalar::create(CGrid* gridDst, CGrid* gridSrc,
+CGenericAlgorithmTransformation* CScalarAlgorithmReduceAxis::create(CGrid* gridDst, CGrid* gridSrc,
                                                                      CTransformation<CScalar>* transformation,
                                                                      int elementPositionInGrid,
@@ -35,24 +35,46 @@
   int axisSrcIndex = elementPositionInGridSrc2AxisPosition[elementPositionInGrid];
 
-  return (new CScalarAlgorithmReduceScalar(scalarListDestP[scalarDstIndex], axisListSrcP[axisSrcIndex], reduceAxis));
+  return (new CScalarAlgorithmReduceAxis(scalarListDestP[scalarDstIndex], axisListSrcP[axisSrcIndex], reduceAxis));
 }
 
-bool CScalarAlgorithmReduceScalar::registerTrans()
+bool CScalarAlgorithmReduceAxis::registerTrans()
 {
   CGridTransformationFactory<CScalar>::registerTransformation(TRANS_REDUCE_AXIS_TO_SCALAR, create);
 }
 
-CScalarAlgorithmReduceScalar::CScalarAlgorithmReduceScalar(CScalar* scalarDestination, CAxis* axisSource, CReduceAxisToScalar* algo)
+CScalarAlgorithmReduceAxis::CScalarAlgorithmReduceAxis(CScalar* scalarDestination, CAxis* axisSource, CReduceAxisToScalar* algo)
  : CScalarAlgorithmTransformation(scalarDestination, axisSource),
    reduction_(0)
 {
   if (algo->operation.isEmpty())
-    ERROR("CScalarAlgorithmReduceScalar::CScalarAlgorithmReduceScalar(CAxis* axisDestination, CAxis* axisSource, CReduceAxisToScalar* algo)",
+    ERROR("CScalarAlgorithmReduceAxis::CScalarAlgorithmReduceAxis(CAxis* axisDestination, CAxis* axisSource, CReduceAxisToScalar* algo)",
            << "Operation must be defined."
            << "Axis source " <<axisSource->getId() << std::endl
            << "Scalar destination " << scalarDestination->getId());
-  StdString op = algo->operation;
+  StdString op;
+  switch (algo->operation)
+  {
+    case CReduceAxisToScalar::operation_attr::sum:
+      op = "sum";
+      break;
+    case CReduceAxisToScalar::operation_attr::min:
+      op = "min";
+      break;
+    case CReduceAxisToScalar::operation_attr::max:
+      op = "max";
+      break;
+    case CReduceAxisToScalar::operation_attr::average:
+      op = "average";
+      break;
+    default:
+        ERROR("CScalarAlgorithmReduceAxis::CScalarAlgorithmReduceAxis(CScalar* scalarDestination, CAxis* axisSource, CReduceAxisToScalar* algo)",
+         << "Operation is wrongly defined. Supported operations: sum, min, max, average." << std::endl
+         << "Domain source " <<axisSource->getId() << std::endl
+         << "Scalar destination " << scalarDestination->getId());
+
+  }
+  
   if (CReductionAlgorithm::ReductionOperations.end() == CReductionAlgorithm::ReductionOperations.find(op))
-    ERROR("CScalarAlgorithmReduceScalar::CScalarAlgorithmReduceScalar(CAxis* axisDestination, CAxis* axisSource, CReduceAxisToScalar* algo)",
+    ERROR("CScalarAlgorithmReduceAxis::CScalarAlgorithmReduceAxis(CAxis* axisDestination, CAxis* axisSource, CReduceAxisToScalar* algo)",
        << "Operation '" << op << "' not found. Please make sure to use a supported one"
        << "Axis source " <<axisSource->getId() << std::endl
@@ -62,5 +84,5 @@
 }
 
-void CScalarAlgorithmReduceScalar::apply(const std::vector<std::pair<int,double> >& localIndex,
+void CScalarAlgorithmReduceAxis::apply(const std::vector<std::pair<int,double> >& localIndex,
                                          const double* dataInput,
                                          CArray<double,1>& dataOut,
@@ -71,15 +93,15 @@
 }
 
-void CScalarAlgorithmReduceScalar::updateData(CArray<double,1>& dataOut)
+void CScalarAlgorithmReduceAxis::updateData(CArray<double,1>& dataOut)
 {
   reduction_->updateData(dataOut);
 }
 
-CScalarAlgorithmReduceScalar::~CScalarAlgorithmReduceScalar()
+CScalarAlgorithmReduceAxis::~CScalarAlgorithmReduceAxis()
 {
   if (0 != reduction_) delete reduction_;
 }
 
-void CScalarAlgorithmReduceScalar::computeIndexSourceMapping_(const std::vector<CArray<double,1>* >& dataAuxInputs)
+void CScalarAlgorithmReduceAxis::computeIndexSourceMapping_(const std::vector<CArray<double,1>* >& dataAuxInputs)
 {
   this->transformationMapping_.resize(1);
Index: /XIOS/trunk/src/transformation/scalar_algorithm_reduce_axis.hpp
===================================================================
--- /XIOS/trunk/src/transformation/scalar_algorithm_reduce_axis.hpp	(revision 979)
+++ /XIOS/trunk/src/transformation/scalar_algorithm_reduce_axis.hpp	(revision 980)
@@ -21,11 +21,11 @@
 
 /*!
-  \class CScalarAlgorithmReduceScalar
+  \class CScalarAlgorithmReduceAxis
   Reducing an axis to a scalar
 */
-class CScalarAlgorithmReduceScalar : public CScalarAlgorithmTransformation
+class CScalarAlgorithmReduceAxis : public CScalarAlgorithmTransformation
 {
 public:
-  CScalarAlgorithmReduceScalar(CScalar* scalarDestination, CAxis* axisSource, CReduceAxisToScalar* algo);
+  CScalarAlgorithmReduceAxis(CScalar* scalarDestination, CAxis* axisSource, CReduceAxisToScalar* algo);
 
   virtual void apply(const std::vector<std::pair<int,double> >& localIndex,
@@ -37,5 +37,5 @@
   virtual void updateData(CArray<double,1>& dataOut);
   
-  virtual ~CScalarAlgorithmReduceScalar();
+  virtual ~CScalarAlgorithmReduceAxis();
 
   static bool registerTrans();
