Changeset 470

Timestamp:

01/30/14 15:55:42 (10 years ago)

Author:

ymipsl

Message:

Enhancement : using new field attribute "detect_missing_value=true" adn defining a default value, the temporal operator (average, minimum, maximum, accumulate ...) detect missing value in the field and don't take them into account to perform the operation.

YM

Location:

XIOS/trunk/src

Files:

• config/field_attribute.conf (modified) (1 diff)
• functor/accumulate.cpp (modified) (2 diffs)
• functor/accumulate.hpp (modified) (1 diff)
• functor/average.cpp (modified) (3 diffs)
• functor/average.hpp (modified) (1 diff)
• functor/instant.cpp (modified) (1 diff)
• functor/instant.hpp (modified) (1 diff)
• functor/maximum.cpp (modified) (2 diffs)
• functor/maximum.hpp (modified) (1 diff)
• functor/minimum.cpp (modified) (2 diffs)
• functor/minimum.hpp (modified) (1 diff)
• functor/once.cpp (modified) (1 diff)
• functor/once.hpp (modified) (1 diff)
• node/field.cpp (modified) (1 diff)

XIOS/trunk/src/config/field_attribute.conf

@@ -5 +5 @@
 DECLARE_ATTRIBUTE(StdString, unit)
 DECLARE_ATTRIBUTE(StdString, operation)
+DECLARE_ATTRIBUTE(bool,      detect_missing_value)
 
 DECLARE_ATTRIBUTE(StdString, freq_op)

XIOS/trunk/src/functor/accumulate.cpp

@@ -9 +9 @@
 
       CAccumulate::CAccumulate(CArray<double,1>& doutput)
-         : SuperClass(StdString("average"), doutput)
+         : SuperClass(StdString("accumulate"), doutput)
+      { /* Ne rien faire de plus */ }
+
+      CAccumulate::CAccumulate(CArray<double,1>& doutput, double missingValue)
+         : SuperClass(StdString("accumulate"), doutput, missingValue)
       { /* Ne rien faire de plus */ }
 
@@ -20 +24 @@
                                  CArray<double,1>& _doutput)
       {
-/*
-         const double * it1  = _dinput->data(),
-                      * end1 = _dinput->data() + _dinput->num_elements(); 
-               double * it   = _doutput->data();
-         if (this->nbcall == 1)
-              for (; it1 != end1; it1++, it++) *it  = *it1;
-         else for (; it1 != end1; it1++, it++) *it += *it1;               
-*/
         if (this->nbcall == 1) _doutput=_dinput ;
-        else _doutput+=_dinput ;
+        else 
+        {
+          if (hasMissingValue)
+          {
+            int i, n =_dinput.numElements() ;
+            const double * in=_dinput.dataFirst() ;
+            double* out=_doutput.dataFirst();
+            for (i=0; i<n; ++i,++in,++out) 
+              if (*in!=missingValue)
+              {
+                if(*out!=missingValue) *out  += *in;
+                else *out=*in ;
+              }
+          }
+          else _doutput+=_dinput ;
+        }
+      }
       
-      }
       
       void CAccumulate::final(void)
       {
-/*          double * it1  = this->getDataOutput()->data(),
-                 * end1 = this->getDataOutput()->data() + this->getDataOutput()->num_elements();
-          for (; it1 != end1; it1++) *it1 /= this->nbcall;
-          this->nbcall = 0;                                                   
-*/
-//        doutput/=this->nbcall; 
         this->nbcall = 0; 
       }

XIOS/trunk/src/functor/accumulate.hpp

@@ -22 +22 @@
             //CAccumulate(const CFunData & data);
             CAccumulate(CArray<double,1>& doutput);
+            CAccumulate(CArray<double,1>& doutput, double missingValue);
             //CAccumulate(const CAccumulate & accumulate);         // Not implemented.
             //CAccumulate(const CAccumulate * const accumulate);   // Not implemented.

XIOS/trunk/src/functor/average.cpp

@@ -12 +12 @@
       { /* Ne rien faire de plus */ }
 
+      CAverage::CAverage(CArray<double,1>& doutput, double missingValue)
+         : SuperClass(StdString("average"), doutput, missingValue)
+      { /* Ne rien faire de plus */ }
+
       CAverage::~CAverage(void)
       { /* Ne rien faire de plus */ }
@@ -20 +24 @@
                                  CArray<double,1>& _doutput)
       {
-/*
-         const double * it1  = _dinput->data(),
-                      * end1 = _dinput->data() + _dinput->num_elements(); 
-               double * it   = _doutput->data();
-         if (this->nbcall == 1)
-              for (; it1 != end1; it1++, it++) *it  = *it1;
-         else for (; it1 != end1; it1++, it++) *it += *it1;               
-*/
-        if (this->nbcall == 1) _doutput=_dinput ;
-        else _doutput+=_dinput ;
+        if (hasMissingValue)
+        {
+          if (nbcalls.numElements()==0) 
+          {
+             nbcalls.resize(_dinput.numElements()) ;
+             nbcalls=0 ;
+          }
+        }
+        
+        if (this->nbcall == 1) 
+        {
+          _doutput=_dinput ;
+          if (hasMissingValue) 
+          {
+            int i, n =_dinput.numElements() ;
+            const double * in=_dinput.dataFirst() ;
+            int* nc=nbcalls.dataFirst() ;
+            for (i=0; i<n; ++i,++nc) 
+              if (*in!=missingValue) (*nc) ++;
+          }
+        }
+        else
+        {
+          if (hasMissingValue)
+          {
+            int i, n =_dinput.numElements() ;
+            const double * in=_dinput.dataFirst() ;
+            double* out=_doutput.dataFirst();
+            int* nc=nbcalls.dataFirst() ;
+            for (i=0; i<n; ++i,++in,++out,++nc) 
+              if (*in!=missingValue) 
+              {
+                if (*nc != 0) (*out)  += *in;
+                else *out = *in ;
+                (*nc) ++;
+              } 
+          }
+          else _doutput+=_dinput ;
+        }
       
       }
@@ -35 +68 @@
       void CAverage::final(void)
       {
-/*          double * it1  = this->getDataOutput()->data(),
-                 * end1 = this->getDataOutput()->data() + this->getDataOutput()->num_elements();
-          for (; it1 != end1; it1++) *it1 /= this->nbcall;
-          this->nbcall = 0;                                                   
-*/
-        doutput/=this->nbcall; 
+        if (hasMissingValue)
+        {
+          int i, n = nbcalls.numElements() ;
+          double* out= doutput.dataFirst();
+          int* nc=nbcalls.dataFirst() ;
+          for (i=0; i<n; ++i, ++out,++nc) 
+            if (*nc!=0) 
+            {
+              *out  /= *nc;
+              *nc = 0 ;
+            }
+        
+        }  
+        else doutput/=this->nbcall; 
         this->nbcall = 0; 
+
       }
    } // namespace func

XIOS/trunk/src/functor/average.hpp

@@ -22 +22 @@
             //CAverage(const CFunData & data);
             CAverage(CArray<double,1>& doutput);
+            CAverage(CArray<double,1>& doutput, double missingValue);
             //CAverage(const CAverage & average);         // Not implemented.
             //CAverage(const CAverage * const average);   // Not implemented.

XIOS/trunk/src/functor/instant.cpp

@@ -10 +10 @@
       CInstant::CInstant(CArray<double,1>& doutput)
          : SuperClass(StdString("instant"), doutput)
+      { /* Ne rien faire de plus */ }
+ 
+      CInstant::CInstant(CArray<double,1>& doutput, double missingValue)
+         : SuperClass(StdString("instant"), doutput, missingValue)
       { /* Ne rien faire de plus */ }
 

XIOS/trunk/src/functor/instant.hpp

@@ -22 +22 @@
             //CInstant(const CFunData & data);
             CInstant(CArray<double,1>& doutput);
-            //CInstant(const CInstant & instant);         // Not implemented.
+            CInstant(CArray<double,1>& doutput, double missingValue);
+           //CInstant(const CInstant & instant);         // Not implemented.
             //CInstant(const CInstant * const instant);   // Not implemented.
 

XIOS/trunk/src/functor/maximum.cpp

@@ -14 +14 @@
       { /* Ne rien faire de plus */ }
 
+      CMaximum::CMaximum(CArray<double,1>& doutput, double missingValue)
+         : SuperClass(StdString("maximum"), doutput, missingValue)
+      { /* Ne rien faire de plus */ }
+
       CMaximum::~CMaximum(void)
       { /* Ne rien faire de plus */ }
@@ -26 +30 @@
               double * it   = _doutput.dataFirst();
          if (this->nbcall == 1) for (; it1 != end1; it1++, it++) *it = *it1;
-         else for (; it1 != end1; it1++, it++) *it = std::max(*it1, *it);
+         else 
+         {
+           if (hasMissingValue) 
+           { 
+             for (; it1 != end1; it1++, it++) 
+               if (*it1 != missingValue)
+               {
+                 if ( *it != missingValue) *it = std::max(*it1, *it);
+                 else *it=*it1 ;  
+               }
+           }
+           else for (; it1 != end1; it1++, it++) *it = std::max(*it1, *it);
+         }
 
 

XIOS/trunk/src/functor/maximum.hpp

@@ -22 +22 @@
             //CMaximum(const CFunData & data);
             CMaximum(CArray<double,1>& doutput);
+            CMaximum(CArray<double,1>& doutput, double missingValue);
             //CMaximum(const CMaximum & Maximum);         // Not implemented.
             //CMaximum(const CMaximum * const Maximum);   // Not implemented.

XIOS/trunk/src/functor/minimum.cpp

@@ -11 +11 @@
       CMinimum::CMinimum(CArray<double,1>& doutput)
          : SuperClass(StdString("minimum"), doutput)
+      { /* Ne rien faire de plus */ }
+
+      CMinimum::CMinimum(CArray<double,1>& doutput, double missingValue)
+         : SuperClass(StdString("minimum"), doutput, missingValue)
       { /* Ne rien faire de plus */ }
 
@@ -26 +30 @@
         
         if (this->nbcall == 1)  for (; it1 != end1; it1++, it++) *it = *it1;
-        else for (; it1 != end1; it1++, it++) *it = std::min(*it1, *it);
+        else 
+        {
+          if (hasMissingValue) 
+          { 
+            for (; it1 != end1; it1++, it++) 
+              if (*it1!=missingValue)
+              {
+                if (*it != missingValue) *it = std::min(*it1, *it);
+                else *it=*it1 ;
+              }
+          }
+          else for (; it1 != end1; it1++, it++) *it = std::min(*it1, *it);
+        }
 
       }

XIOS/trunk/src/functor/minimum.hpp

@@ -22 +22 @@
             //CMinimum(const CFunData & data);
             CMinimum(CArray<double,1>& doutput);
+            CMinimum(CArray<double,1>& doutput, double missingValue);
             //CMinimum(const CMinimum & Minimum);         // Not implemented.
             //CMinimum(const CMinimum * const Minimum);   // Not implemented.

XIOS/trunk/src/functor/once.cpp

@@ -10 +10 @@
       COnce::COnce(CArray<double,1>& doutput)
          : SuperClass(StdString("once"), doutput)
+      { /* Ne rien faire de plus */ }
+
+      COnce::COnce(CArray<double,1>& doutput, double missingValue)
+         : SuperClass(StdString("once"), doutput, missingValue)
       { /* Ne rien faire de plus */ }
 

XIOS/trunk/src/functor/once.hpp

@@ -21 +21 @@
             //COnce(void);                       // Not implemented.
             COnce(CArray<double,1>& doutput);
+            COnce(CArray<double,1>& doutput, double missingValue);
             //COnce(const COnce & once);         // Not implemented.
             //COnce(const COnce * const once);   // Not implemented.

XIOS/trunk/src/node/field.cpp

@@ -458 +458 @@
         else isOnceOperation=false;
         isFirstOperation=true;
-
+        
+          
 #define DECLARE_FUNCTOR(MType, mtype)              \
    if  (operation.getValue().compare(#mtype) == 0) \
    {                                               \
-      boost::shared_ptr<func::CFunctor>            \
-            foperation_(new C##MType(this->data)); \
-      this->foperation = foperation_;              \
+      if (!detect_missing_value.isEmpty() && !default_value.isEmpty() && detect_missing_value==true) \
+      { \
+        boost::shared_ptr<func::CFunctor> foperation_(new C##MType(this->data,default_value)); \
+        this->foperation = foperation_; \ 
+      } \
+      else \
+      { \
+        boost::shared_ptr<func::CFunctor> foperation_(new C##MType(this->data)); \
+        this->foperation = foperation_;  \
+      } \
       return;                                      \
    }