Changeset 1018 for XIOS/trunk/src


Ignore:
Timestamp:
01/10/17 13:52:53 (7 years ago)
Author:
mhnguyen
Message:

Improving missing-value processing
If detect_missing_value is activated, then all missing value will be converted to
NaN (Not-a-number) in input of data flow then they will be reconverted to missing value on output

+) Update SourceFilter?, TemporalFilter? and SpatialTransformFilter? with new processing
+) Update all transformations with new processing

Test
+) On Curie
+) Work

Location:
XIOS/trunk/src
Files:
30 edited

Legend:

Unmodified
Added
Removed

  • XIOS/trunk/src/filter/file_writer_filter.cpp

    r639 r1018  
    22#include "exception.hpp" 
    33#include "field.hpp" 
     4#include "utils.hpp" 
    45 
    56namespace xios 
    … …  
    1617  void CFileWriterFilter::onInputReady(std::vector<CDataPacketPtr> data) 
    1718  { 
     19    bool ignoreMissingValue = (!field->detect_missing_value.isEmpty() &&  
     20                               !field->default_value.isEmpty() &&  
     21                               field->detect_missing_value == true); 
     22    if (ignoreMissingValue) 
     23    { 
     24      double missingValue = field->default_value; 
     25      size_t nbData = data[0]->data.numElements(); 
     26      for (size_t idx = 0; idx < nbData; ++idx) 
     27      { 
     28        if (NumTraits<double>::isnan(data[0]->data(idx))) 
     29          data[0]->data(idx) = missingValue; 
     30      } 
     31    }     
     32 
    1833    field->sendUpdateData(data[0]->data); 
    1934  } 

  • XIOS/trunk/src/filter/source_filter.cpp

    r1006 r1018  
    33#include "exception.hpp" 
    44#include "calendar_util.hpp" 
     5#include <limits>  
    56 
    67namespace xios 
    78{ 
    89  CSourceFilter::CSourceFilter(CGarbageCollector& gc, CGrid* grid, 
    9                                const CDuration offset /*= NoneDu*/, bool manualTrigger /*= false*/) 
     10                               const CDuration offset /*= NoneDu*/, bool manualTrigger /*= false*/, 
     11                               bool hasMissingValue /*= false*/, 
     12                               double defaultValue /*= 0.0*/) 
    1013    : COutputPin(gc, manualTrigger) 
    1114    , grid(grid) 
    1215    , offset(offset) 
     16    , hasMissingValue(hasMissingValue), defaultValue(defaultValue) 
    1317  { 
    1418    if (!grid) 
    … …  
    2933    packet->data.resize(grid->storeIndex_client.numElements()); 
    3034    grid->inputField(data, packet->data); 
     35 
     36    // Convert missing values to NaN 
     37    if (hasMissingValue) 
     38    { 
     39      double nanValue = std::numeric_limits<double>::quiet_NaN(); 
     40      size_t nbData = packet->data.numElements(); 
     41      for (size_t idx = 0; idx < nbData; ++idx) 
     42      { 
     43        if (defaultValue == packet->data(idx)) 
     44          packet->data(idx) = nanValue; 
     45      } 
     46    } 
    3147 
    3248    onOutputReady(packet); 

  • XIOS/trunk/src/filter/source_filter.hpp

    r1006 r1018  
    2323       * \param offset the offset applied to the timestamp of all packets 
    2424       * \param manualTrigger whether the output should be triggered manually 
     25       * \param hasMissingValue whether data has missing value 
     26       * \param defaultValue missing value to detect 
    2527       */ 
    2628      CSourceFilter(CGarbageCollector& gc, CGrid* grid, 
    27                     const CDuration offset = NoneDu, bool manualTrigger = false); 
     29                    const CDuration offset = NoneDu, bool manualTrigger = false, 
     30                    bool hasMissingValue = false, 
     31                    double defaultValue = 0.0); 
    2832 
    2933      /*! 
    … …  
    5862      CGrid* grid; //!< The grid attached to the data the filter can accept 
    5963      const CDuration offset; //!< The offset applied to the timestamp of all packets 
     64      bool hasMissingValue; 
     65      double defaultValue; 
    6066  }; // class CSourceFilter 
    6167} // namespace xios 

  • XIOS/trunk/src/filter/spatial_transform_filter.cpp

    r1006 r1018  
    1111 
    1212  std::pair<boost::shared_ptr<CSpatialTransformFilter>, boost::shared_ptr<CSpatialTransformFilter> > 
    13   CSpatialTransformFilter::buildFilterGraph(CGarbageCollector& gc, CGrid* srcGrid, CGrid* destGrid, double defaultValue) 
     13  CSpatialTransformFilter::buildFilterGraph(CGarbageCollector& gc, CGrid* srcGrid, CGrid* destGrid, bool hasMissingValue, double missingValue) 
    1414  { 
    1515    if (!srcGrid || !destGrid) 
    … …  
    2626      const std::vector<StdString>& auxInputs = gridTransformation->getAuxInputs(); 
    2727      size_t inputCount = 1 + (auxInputs.empty() ? 0 : auxInputs.size()); 
     28      double defaultValue  = (hasMissingValue) ? std::numeric_limits<double>::quiet_NaN() : missingValue; 
    2829      boost::shared_ptr<CSpatialTransformFilter> filter(new CSpatialTransformFilter(gc, engine, defaultValue, inputCount)); 
    2930 
    … …  
    103104      } 
    104105      packet->data.resize(gridTransformation->getGridDestination()->storeIndex_client.numElements()); 
    105       packet->data = defaultValue; 
     106      if (0 != packet->data.numElements()) 
     107        (packet->data)(0) = defaultValue; 
    106108      apply(data[0]->data, packet->data); 
    107109    } 

  • XIOS/trunk/src/filter/spatial_transform_filter.hpp

    r873 r1018  
    3232       * \param srcGrid the source grid 
    3333       * \param destGrid the destination grid 
     34       * \param hasMissingValue whether field source has missing value 
     35       * \param defaultValue default value 
    3436       * \return the first and the last filters of the filter graph 
    3537       */ 
    3638      static std::pair<boost::shared_ptr<CSpatialTransformFilter>, boost::shared_ptr<CSpatialTransformFilter> > 
    37       buildFilterGraph(CGarbageCollector& gc, CGrid* srcGrid, CGrid* destGrid, double defaultValue); 
     39      buildFilterGraph(CGarbageCollector& gc, CGrid* srcGrid, CGrid* destGrid, bool hasMissingValue, double defaultValue); 
    3840 
    3941    protected: 

  • XIOS/trunk/src/filter/temporal_filter.cpp

    r854 r1018  
    1515    , isFirstOperation(true) 
    1616  { 
     17    double defaultValue = ignoreMissingValue ? std::numeric_limits<double>::quiet_NaN() : missingValue; 
     18     
    1719#define DECLARE_FUNCTOR(MType, mtype) \ 
    1820    if (opId.compare(#mtype) == 0) \ 
    … …  
    2022      if (ignoreMissingValue) \ 
    2123      { \ 
    22         functor.reset(new func::C##MType(tmpData, missingValue)); \ 
     24        functor.reset(new func::C##MType(tmpData, defaultValue)); \ 
    2325      } \ 
    2426      else \ 

  • XIOS/trunk/src/functor/accumulate.cpp

    r591 r1018  
    11#include "accumulate.hpp" 
    22#include "array_new.hpp" 
     3#include "utils.hpp" 
    34 
    45namespace xios 
    … …  
    3334            double* out=_doutput.dataFirst(); 
    3435            for (i=0; i<n; ++i,++in,++out)  
    35               if (*in!=missingValue) 
     36              if (!NumTraits<double>::isnan(*in)) 
    3637              { 
    37                 if(*out!=missingValue) *out  += *in; 
     38                if(!NumTraits<double>::isnan(*out)) *out  += *in; 
    3839                else *out=*in ; 
    3940              } 

  • XIOS/trunk/src/functor/average.cpp

    r591 r1018  
    11#include "average.hpp" 
    22#include "array_new.hpp" 
     3#include "utils.hpp" 
    34 
    45namespace xios 
    … …  
    4243            int* nc=nbcalls.dataFirst() ; 
    4344            for (i=0; i<n; ++i,++nc,++in)  
    44               if (*in!=missingValue) (*nc) ++; 
     45              if (!NumTraits<double>::isnan(*in)) (*nc) ++; 
    4546          } 
    4647        } 
    … …  
    5455            int* nc=nbcalls.dataFirst() ; 
    5556            for (i=0; i<n; ++i,++in,++out,++nc)  
    56               if (*in!=missingValue)  
     57              if (!NumTraits<double>::isnan(*in))  
    5758              { 
    5859                if (*nc != 0) (*out)  += *in; 

  • XIOS/trunk/src/functor/maximum.cpp

    r591 r1018  
    11#include "maximum.hpp" 
    22#include "array_new.hpp" 
    3  
    4  
     3#include "utils.hpp" 
    54 
    65namespace xios 
    … …  
    3534           {  
    3635             for (; it1 != end1; it1++, it++)  
    37                if (*it1 != missingValue) 
     36               if (!NumTraits<double>::isnan(*it1)) 
    3837               { 
    39                  if ( *it != missingValue) *it = std::max(*it1, *it); 
     38                 if (!NumTraits<double>::isnan(*it)) *it = std::max(*it1, *it); 
    4039                 else *it=*it1 ;   
    4140               } 

  • XIOS/trunk/src/functor/minimum.cpp

    r591 r1018  
    22#include "array_new.hpp" 
    33#include <algorithm> 
     4#include "utils.hpp" 
    45 
    56namespace xios 
    … …  
    2627      { 
    2728        const double * it1  = _dinput.dataFirst(), 
    28                       * end1 = _dinput.dataFirst() + _dinput.numElements(); 
     29                      *end1 = _dinput.dataFirst() + _dinput.numElements(); 
    2930        double * it   = _doutput.dataFirst(); 
    3031         
    … …  
    3536          {  
    3637            for (; it1 != end1; it1++, it++)  
    37               if (*it1!=missingValue) 
     38              if (!NumTraits<double>::isnan(*it1)) 
    3839              { 
    39                 if (*it != missingValue) *it = std::min(*it1, *it); 
     40                if (!NumTraits<double>::isnan(*it)) *it = std::min(*it1, *it); 
    4041                else *it=*it1 ; 
    4142              } 

  • XIOS/trunk/src/node/field.cpp

    r1017 r1018  
    795795           if (grid && grid != gridRef && grid->hasTransform()) 
    796796           { 
    797              double defaultValue = !default_value.isEmpty() ? default_value : 0.0; 
    798              std::pair<boost::shared_ptr<CFilter>, boost::shared_ptr<CFilter> > filters = CSpatialTransformFilter::buildFilterGraph(gc, gridRef, grid, defaultValue); 
     797             bool hasMissingValue = (!detect_missing_value.isEmpty() && !default_value.isEmpty() && detect_missing_value == true); 
     798             double defaultValue  = hasMissingValue ? default_value : (!default_value.isEmpty() ? default_value : 0.0); 
     799             std::pair<boost::shared_ptr<CFilter>, boost::shared_ptr<CFilter> > filters = CSpatialTransformFilter::buildFilterGraph(gc, gridRef, grid, hasMissingValue, defaultValue); 
    799800 
    800801             filter->connectOutput(filters.first, 0); 
    … …  
    814815                                                                                                     true)); 
    815816       else // The data might be passed from the model 
    816          instantDataFilter = clientSourceFilter = boost::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid)); 
     817       { 
     818          bool ignoreMissingValue = (!detect_missing_value.isEmpty() && !default_value.isEmpty() && detect_missing_value == true); 
     819          double defaultValue  = ignoreMissingValue ? default_value : (!default_value.isEmpty() ? default_value : 0.0); 
     820          instantDataFilter = clientSourceFilter = boost::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid, NoneDu, false, 
     821                                                                                                      ignoreMissingValue, defaultValue));       } 
    817822     } 
    818823 
    … …  
    853858     // Check if a spatial transformation is needed 
    854859     if (grid && grid != fieldRef->grid && grid->hasTransform()) 
    855      { 
    856        double defaultValue = !default_value.isEmpty() ? default_value : 0.0; 
    857        filters = CSpatialTransformFilter::buildFilterGraph(gc, fieldRef->grid, grid, defaultValue); 
     860     {        
     861       bool hasMissingValue = (!detect_missing_value.isEmpty() && !default_value.isEmpty() && detect_missing_value == true); 
     862       double defaultValue  = hasMissingValue ? default_value : (!default_value.isEmpty() ? default_value : 0.0);                                 
     863       filters = CSpatialTransformFilter::buildFilterGraph(gc, fieldRef->grid, grid, hasMissingValue, defaultValue); 
    858864     } 
    859865     else 
    … …  
    900906       { 
    901907         if (!clientSourceFilter) 
    902            clientSourceFilter = boost::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid)); 
     908         { 
     909           bool ignoreMissingValue = (!detect_missing_value.isEmpty() && !default_value.isEmpty() && detect_missing_value == true); 
     910           double defaultValue  = ignoreMissingValue ? default_value : (!default_value.isEmpty() ? default_value : 0.0);  
     911           clientSourceFilter = boost::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid, NoneDu, false, 
     912                                                                                   ignoreMissingValue, defaultValue)); 
     913         } 
    903914 
    904915         selfReferenceFilter = clientSourceFilter; 
    … …  
    934945 
    935946       const bool ignoreMissingValue = (!detect_missing_value.isEmpty() && !default_value.isEmpty() && detect_missing_value == true); 
    936  
     947        
    937948       boost::shared_ptr<CTemporalFilter> temporalFilter(new CTemporalFilter(gc, operation, 
    938949                                                                             CContext::getCurrent()->getCalendar()->getInitDate(), 

  • XIOS/trunk/src/test/test_remap.f90

    r978 r1018  
    9191    IF (MOD(i,10)==0) THEN 
    9292      src_mask_2D(i)=.FALSE. 
     93      src_field_2D(i) = 100000 
    9394    ELSE 
    94       src_mask_2D(i)=.TRUE. 
     95      src_mask_2D(i)=.TRUE.       
    9596    ENDIF 
    9697  ENDDO 
    … …  
    99100    lval(i) = i*100 
    100101    src_field_pression(:,i) = i * 100 
    101     src_field_3D(:,i) = src_field_3D(:,i) + i * 10     
     102    IF (MOD(i,3)==0) THEN 
     103      ! src_field_pression(:,i) = 100000 
     104      src_field_3D(:,i) = 100000 
     105    ELSE 
     106      ! src_field_pression(:,i) = i * 100 
     107      src_field_3D(:,i) = src_field_3D(:,i) + i * 10  
     108    ENDIF 
     109    ! src_field_3D(:,i) = src_field_3D(:,i) + i * 10     
    102110  ENDDO 
    103111 
    104112  DO i=1,llm2 
    105     src_field_4D(:,:,i) = src_field_3D(:,:) 
     113    src_field_4D(:,:,i) = src_field_3D(:,:) + i * 100 
    106114  ENDDO 
    107115 
    … …  
    184192    CALL xios_send_field("src_field_2D_clone",src_field_2D) 
    185193    CALL xios_send_field("src_field_3D",src_field_3D) 
     194    CALL xios_send_field("src_field_3D_clone",src_field_3D) 
    186195    CALL xios_send_field("src_field_4D",src_field_4D) 
    187196    CALL xios_send_field("src_field_3D_pression",src_field_pression) 

  • XIOS/trunk/src/transformation/Functions/average_reduction.cpp

    r979 r1018  
    33   \author Ha NGUYEN 
    44   \since 8 Sep 2016 
    5    \date 8 Sep 2016 
     5   \date 9 Jan 2017 
    66 
    77   \brief average reduction 
    88 */ 
    99#include "average_reduction.hpp" 
     10#include "utils.hpp" 
    1011 
    1112namespace xios { 
    … …  
    2930                                       const double* dataInput, 
    3031                                       CArray<double,1>& dataOut, 
    31                                        std::vector<bool>& flagInitial) 
     32                                       std::vector<bool>& flagInitial, 
     33                                       const double& defaultValue) 
    3234{ 
    3335  if (resetWeight_) { weights_.resize(flagInitial.size()); weights_ = 1.0; resetWeight_ = false; } 
     36  bool hasMissingValue = NumTraits<double>::isnan(defaultValue); 
    3437 
    35   int nbLocalIndex = localIndex.size(); 
    36   int currentlocalIndex = 0; 
    37   double currentWeight  = 0.0; 
    38   for (int idx = 0; idx < nbLocalIndex; ++idx) 
     38  if (hasMissingValue) 
    3939  { 
    40     currentlocalIndex = localIndex[idx].first; 
    41     currentWeight     = localIndex[idx].second; 
     40    int nbLocalIndex = localIndex.size(); 
     41    int currentlocalIndex = 0; 
     42    double currentWeight  = 0.0; 
     43    for (int idx = 0; idx < nbLocalIndex; ++idx) 
     44    { 
     45      currentlocalIndex = localIndex[idx].first; 
     46      currentWeight     = localIndex[idx].second; 
     47      if (!NumTraits<double>::isnan(*(dataInput + idx))) 
     48      { 
     49        if (flagInitial[currentlocalIndex]) 
     50        { 
     51          dataOut(currentlocalIndex) = *(dataInput + idx); 
     52          flagInitial[currentlocalIndex] = false; 
     53        } 
     54        else 
     55        { 
     56          dataOut(currentlocalIndex)  += *(dataInput + idx); 
     57          weights_(currentlocalIndex) += 1.0; 
     58        } 
     59      } 
     60    } 
     61  } 
     62  else 
     63  { 
     64    int nbLocalIndex = localIndex.size(); 
     65    int currentlocalIndex = 0; 
     66    double currentWeight  = 0.0; 
     67    for (int idx = 0; idx < nbLocalIndex; ++idx) 
     68    { 
     69      currentlocalIndex = localIndex[idx].first; 
     70      currentWeight     = localIndex[idx].second; 
    4271 
    43     if (flagInitial[currentlocalIndex]) 
    44     { 
    45       dataOut(currentlocalIndex) = *(dataInput + idx); 
    46       flagInitial[currentlocalIndex] = false; 
    47     } 
    48     else 
    49     { 
    50       dataOut(currentlocalIndex)  += *(dataInput + idx); 
    51       weights_(currentlocalIndex) += 1.0; 
     72      if (flagInitial[currentlocalIndex]) 
     73      { 
     74        dataOut(currentlocalIndex) = *(dataInput + idx); 
     75        flagInitial[currentlocalIndex] = false; 
     76      } 
     77      else 
     78      { 
     79        dataOut(currentlocalIndex)  += *(dataInput + idx); 
     80        weights_(currentlocalIndex) += 1.0; 
     81      } 
    5282    } 
    5383  } 

  • XIOS/trunk/src/transformation/Functions/average_reduction.hpp

    r979 r1018  
    2626                     const double* dataInput, 
    2727                     CArray<double,1>& dataOut, 
    28                      std::vector<bool>& flagInitial); 
     28                     std::vector<bool>& flagInitial, 
     29                     const double& defaultValue); 
    2930 
    3031  virtual void updateData(CArray<double,1>& dataOut); 

  • XIOS/trunk/src/transformation/Functions/extract.cpp

    r895 r1018  
    2929                                       const double* dataInput, 
    3030                                       CArray<double,1>& dataOut, 
    31                                        std::vector<bool>& flagInitial) 
     31                                       std::vector<bool>& flagInitial, 
     32                                       const double& defaultValue) 
    3233{ 
    3334  int nbLocalIndex = localIndex.size(); 

  • XIOS/trunk/src/transformation/Functions/extract.hpp

    r895 r1018  
    2626                     const double* dataInput, 
    2727                     CArray<double,1>& dataOut, 
    28                      std::vector<bool>& flagInitial); 
     28                     std::vector<bool>& flagInitial, 
     29                     const double& defaultValue); 
    2930 
    3031  virtual ~CExtractReductionAlgorithm() {} 

  • XIOS/trunk/src/transformation/Functions/max_reduction.cpp

    r979 r1018  
    88 */ 
    99#include "max_reduction.hpp" 
     10#include "utils.hpp" 
    1011 
    1112namespace xios { 
    … …  
    2930                                   const double* dataInput, 
    3031                                   CArray<double,1>& dataOut, 
    31                                    std::vector<bool>& flagInitial) 
     32                                   std::vector<bool>& flagInitial, 
     33                                   const double& defaultValue) 
    3234{ 
    33   int nbLocalIndex = localIndex.size(); 
    34   int currentlocalIndex = 0; 
    35   double currentWeight  = 0.0; 
    36   for (int idx = 0; idx < nbLocalIndex; ++idx) 
     35  bool hasMissingValue = NumTraits<double>::isnan(defaultValue); 
     36 
     37  if (hasMissingValue) 
    3738  { 
    38     currentlocalIndex = localIndex[idx].first; 
    39     currentWeight     = localIndex[idx].second; 
    40     if (flagInitial[currentlocalIndex]) 
     39    int nbLocalIndex = localIndex.size(); 
     40    int currentlocalIndex = 0;     
     41    for (int idx = 0; idx < nbLocalIndex; ++idx) 
    4142    { 
    42       dataOut(currentlocalIndex) = *(dataInput + idx); 
    43       flagInitial[currentlocalIndex] = false; 
     43      currentlocalIndex = localIndex[idx].first;       
     44      if (!NumTraits<double>::isnan(*(dataInput + idx))) 
     45      { 
     46        if (flagInitial[currentlocalIndex]) 
     47        { 
     48          dataOut(currentlocalIndex) = *(dataInput + idx); 
     49          flagInitial[currentlocalIndex] = false; 
     50        } 
     51        else 
     52        { 
     53          dataOut(currentlocalIndex) = std::max(*(dataInput + idx), dataOut(currentlocalIndex)); 
     54        } 
     55      } 
    4456    } 
    45     else 
     57  } 
     58  else 
     59  { 
     60    int nbLocalIndex = localIndex.size(); 
     61    int currentlocalIndex = 0;     
     62    for (int idx = 0; idx < nbLocalIndex; ++idx) 
    4663    { 
    47       dataOut(currentlocalIndex) = std::max(*(dataInput + idx), dataOut(currentlocalIndex)); 
     64      currentlocalIndex = localIndex[idx].first;       
     65      if (flagInitial[currentlocalIndex]) 
     66      { 
     67        dataOut(currentlocalIndex) = *(dataInput + idx); 
     68        flagInitial[currentlocalIndex] = false; 
     69      } 
     70      else 
     71      { 
     72        dataOut(currentlocalIndex) = std::max(*(dataInput + idx), dataOut(currentlocalIndex)); 
     73      } 
    4874    } 
    4975  } 

  • XIOS/trunk/src/transformation/Functions/max_reduction.hpp

    r979 r1018  
    2626                     const double* dataInput, 
    2727                     CArray<double,1>& dataOut, 
    28                      std::vector<bool>& flagInitial); 
     28                     std::vector<bool>& flagInitial, 
     29                     const double& defaultValue); 
    2930 
    3031  virtual ~CMaxReductionAlgorithm() {} 

  • XIOS/trunk/src/transformation/Functions/min_reduction.cpp

    r979 r1018  
    33   \author Ha NGUYEN 
    44   \since 27 June 2016 
    5    \date 27 June 2016 
     5   \date 9 Jan 2017 
    66 
    77   \brief min reduction 
    88 */ 
    99#include "min_reduction.hpp" 
     10#include "utils.hpp" 
    1011 
    1112namespace xios { 
    … …  
    2930                                   const double* dataInput, 
    3031                                   CArray<double,1>& dataOut, 
    31                                    std::vector<bool>& flagInitial) 
     32                                   std::vector<bool>& flagInitial, 
     33                                   const double& defaultValue) 
    3234{ 
    33   int nbLocalIndex = localIndex.size(); 
    34   int currentlocalIndex = 0; 
    35   for (int idx = 0; idx < nbLocalIndex; ++idx) 
     35  bool hasMissingValue = NumTraits<double>::isnan(defaultValue); 
     36 
     37  if (hasMissingValue) 
    3638  { 
    37     currentlocalIndex = localIndex[idx].first; 
    38     if (flagInitial[currentlocalIndex]) 
     39    int nbLocalIndex = localIndex.size(); 
     40    int currentlocalIndex = 0; 
     41    for (int idx = 0; idx < nbLocalIndex; ++idx) 
    3942    { 
    40       dataOut(currentlocalIndex) = *(dataInput + idx); 
    41       flagInitial[currentlocalIndex] = false; 
     43      currentlocalIndex = localIndex[idx].first; 
     44      if (!NumTraits<double>::isnan(*(dataInput + idx))) 
     45      { 
     46        if (flagInitial[currentlocalIndex]) 
     47        { 
     48          dataOut(currentlocalIndex) = *(dataInput + idx); 
     49          flagInitial[currentlocalIndex] = false; 
     50        } 
     51        else 
     52        { 
     53          dataOut(currentlocalIndex) = std::min(*(dataInput + idx), dataOut(currentlocalIndex)); 
     54        } 
     55      } 
    4256    } 
    43     else 
     57  } 
     58  else 
     59  { 
     60    int nbLocalIndex = localIndex.size(); 
     61    int currentlocalIndex = 0; 
     62    for (int idx = 0; idx < nbLocalIndex; ++idx) 
    4463    { 
    45       dataOut(currentlocalIndex) = std::min(*(dataInput + idx), dataOut(currentlocalIndex)); 
     64      currentlocalIndex = localIndex[idx].first; 
     65      if (flagInitial[currentlocalIndex]) 
     66      { 
     67        dataOut(currentlocalIndex) = *(dataInput + idx); 
     68        flagInitial[currentlocalIndex] = false; 
     69      } 
     70      else 
     71      { 
     72        dataOut(currentlocalIndex) = std::min(*(dataInput + idx), dataOut(currentlocalIndex)); 
     73      } 
    4674    } 
    4775  } 

  • XIOS/trunk/src/transformation/Functions/min_reduction.hpp

    r979 r1018  
    2626                     const double* dataInput, 
    2727                     CArray<double,1>& dataOut, 
    28                      std::vector<bool>& flagInitial); 
     28                     std::vector<bool>& flagInitial, 
     29                     const double& defaultValue); 
    2930 
    3031  virtual ~CMinReductionAlgorithm() {} 

  • XIOS/trunk/src/transformation/Functions/reduction.hpp

    r979 r1018  
    4545                     const double* dataInput, 
    4646                     CArray<double,1>& dataOut, 
    47                      std::vector<bool>& flagInitial) = 0; 
     47                     std::vector<bool>& flagInitial, 
     48                     const double& defaultValue) = 0; 
    4849  /*! 
    4950    Update local data  

  • XIOS/trunk/src/transformation/Functions/sum_reduction.cpp

    r979 r1018  
    33   \author Ha NGUYEN 
    44   \since 27 June 2016 
    5    \date 27 June 2016 
     5   \date 9 Jan 2017 
    66 
    77   \brief sum reduction 
    88 */ 
    99#include "sum_reduction.hpp" 
     10#include "utils.hpp" 
    1011 
    1112namespace xios { 
    … …  
    2930                                   const double* dataInput, 
    3031                                   CArray<double,1>& dataOut, 
    31                                    std::vector<bool>& flagInitial) 
     32                                   std::vector<bool>& flagInitial, 
     33                                   const double& defaultValue) 
    3234{ 
    33   int nbLocalIndex = localIndex.size(); 
    34   int currentlocalIndex = 0; 
    35   double currentWeight  = 0.0; 
    36   for (int idx = 0; idx < nbLocalIndex; ++idx) 
     35  bool hasMissingValue = NumTraits<double>::isnan(defaultValue); 
     36  if (hasMissingValue) 
    3737  { 
    38     currentlocalIndex = localIndex[idx].first; 
    39     currentWeight     = localIndex[idx].second; 
    40     if (flagInitial[currentlocalIndex]) 
     38    int nbLocalIndex = localIndex.size(); 
     39    int currentlocalIndex = 0;     
     40    for (int idx = 0; idx < nbLocalIndex; ++idx) 
    4141    { 
    42       dataOut(currentlocalIndex) = *(dataInput + idx); 
    43       flagInitial[currentlocalIndex] = false; 
    44     } 
    45     else 
     42      currentlocalIndex = localIndex[idx].first;    
     43      if (!NumTraits<double>::isnan(*(dataInput + idx))) 
     44      {    
     45        if (flagInitial[currentlocalIndex]) 
     46        { 
     47          dataOut(currentlocalIndex) = *(dataInput + idx); 
     48          flagInitial[currentlocalIndex] = false; 
     49        } 
     50        else 
     51        { 
     52          dataOut(currentlocalIndex) += *(dataInput + idx); 
     53        } 
     54      } 
     55    }     
     56  } 
     57  else 
     58  { 
     59    int nbLocalIndex = localIndex.size(); 
     60    int currentlocalIndex = 0;     
     61    for (int idx = 0; idx < nbLocalIndex; ++idx) 
    4662    { 
    47       dataOut(currentlocalIndex) += *(dataInput + idx); 
     63      currentlocalIndex = localIndex[idx].first;       
     64      if (flagInitial[currentlocalIndex]) 
     65      { 
     66        dataOut(currentlocalIndex) = *(dataInput + idx); 
     67        flagInitial[currentlocalIndex] = false; 
     68      } 
     69      else 
     70      { 
     71        dataOut(currentlocalIndex) += *(dataInput + idx); 
     72      } 
    4873    } 
    4974  } 

  • XIOS/trunk/src/transformation/Functions/sum_reduction.hpp

    r979 r1018  
    2626                     const double* dataInput, 
    2727                     CArray<double,1>& dataOut, 
    28                      std::vector<bool>& flagInitial); 
     28                     std::vector<bool>& flagInitial, 
     29                     const double& defaultValue); 
    2930 
    3031  virtual ~CSumReductionAlgorithm() {} 

  • XIOS/trunk/src/transformation/axis_algorithm_extract_domain.cpp

    r980 r1018  
    7171                                        const double& defaultValue) 
    7272{ 
    73   reduction_->apply(localIndex, dataInput, dataOut, flagInitial); 
     73  reduction_->apply(localIndex, dataInput, dataOut, flagInitial, defaultValue); 
    7474} 
    7575 

  • XIOS/trunk/src/transformation/axis_algorithm_reduce_domain.cpp

    r980 r1018  
    7979                                       const double& defaultValue) 
    8080{ 
    81   reduction_->apply(localIndex, dataInput, dataOut, flagInitial); 
     81  reduction_->apply(localIndex, dataInput, dataOut, flagInitial, defaultValue); 
    8282} 
    8383 

  • XIOS/trunk/src/transformation/generic_algorithm_transformation.cpp

    r979 r1018  
    1111#include "context_client.hpp" 
    1212#include "client_client_dht_template.hpp" 
     13#include "utils.hpp" 
    1314 
    1415namespace xios { 
    … …  
    3132                                            const double& defaultValue) 
    3233{ 
    33   int nbLocalIndex = localIndex.size(); 
    34   bool hasMissingValue = (0.0 != defaultValue) ? true : false; 
     34  int nbLocalIndex = localIndex.size();   
     35  bool hasMissingValue = NumTraits<double>::isnan(defaultValue);   
    3536  if (hasMissingValue) 
    3637  { 
    3738    for (int idx = 0; idx < nbLocalIndex; ++idx) 
    3839    { 
    39       if (defaultValue == *(dataInput + idx)) 
     40      if (NumTraits<double>::isnan(*(dataInput + idx))) 
    4041      { 
    4142        flagInitial[localIndex[idx].first] = false; 

  • XIOS/trunk/src/transformation/scalar_algorithm_extract_axis.cpp

    r980 r1018  
    5858                                         const double& defaultValue) 
    5959{ 
    60   reduction_->apply(localIndex, dataInput, dataOut, flagInitial); 
     60  reduction_->apply(localIndex, dataInput, dataOut, flagInitial, defaultValue); 
    6161} 
    6262 

  • XIOS/trunk/src/transformation/scalar_algorithm_reduce_axis.cpp

    r980 r1018  
    9090                                         const double& defaultValue) 
    9191{ 
    92   reduction_->apply(localIndex, dataInput, dataOut, flagInitial); 
     92  reduction_->apply(localIndex, dataInput, dataOut, flagInitial, defaultValue); 
    9393} 
    9494 

  • XIOS/trunk/src/transformation/scalar_algorithm_reduce_domain.cpp

    r979 r1018  
    8484                                         const double& defaultValue) 
    8585{ 
    86   reduction_->apply(localIndex, dataInput, dataOut, flagInitial); 
     86  reduction_->apply(localIndex, dataInput, dataOut, flagInitial, defaultValue); 
    8787} 
    8888 

  • XIOS/trunk/src/utils.hpp

    r814 r1018  
    257257    return 1e-12; 
    258258  } 
     259  static inline bool isnan(const Scalar& v) { 
     260    return (v != v); 
     261  } 
    259262}; 
    260263 
Note: See TracChangeset for help on using the changeset viewer.