Changeset 2000 for XIOS

Timestamp:

01/04/21 11:13:46 (3 years ago)

Author:

ymipsl

Message:

Add reduce operation for transformation (sum was already fonctional)
min, max, average
YM

Location:

XIOS/dev/dev_ym/XIOS_COUPLING/src/distribution

Files:

• reduce_transform_connector.cpp (modified) (1 diff)
• reduce_transform_connector.hpp (modified) (2 diffs)

XIOS/dev/dev_ym/XIOS_COUPLING/src/distribution/reduce_transform_connector.cpp

@@ -15 +15 @@
         break ;
       case EReduction::min :
+        transfer_=&CReduceTransformConnector::transferMin ;
         break ;
       case EReduction::max :
+        transfer_=&CReduceTransformConnector::transferMax ;
         break ;
-      case EReduction::extract :
-        break ;
-      case EReduction::average :
+     case EReduction::average :
+        transfer_=&CReduceTransformConnector::transferAverage ;
         break ;
       default :

XIOS/dev/dev_ym/XIOS_COUPLING/src/distribution/reduce_transform_connector.hpp

@@ -6 +6 @@
 #include "local_view.hpp"
 #include "reduction_types.hpp"
+#include <algorithm>
 
 
@@ -128 +129 @@
     }
 
-
+    void transferMin(int repeat, int sizeT, const CArray<double,1>& dataIn, CArray<double,1>& dataOut)
+    {
+      double defaultValue = std::numeric_limits<double>::quiet_NaN();
+
+      int dstSlice = dstSize_*sizeT ;
+      int srcSlice = srcSize_*sizeT ;
+      dataOut.resize(repeat* dstSlice) ;
+      dataOut=0 ;
+           
+      const double* input = dataIn.dataFirst()  ;
+      double* output = dataOut.dataFirst()  ;
+
+      if (detectMissingValue_)
+      {
+        vector<bool> touched(repeat* dstSlice, false) ;
+        int pos=0 ;
+        for(int r=0;r<repeat;r++, input+=srcSlice, output+=dstSlice, pos+=dstSlice)
+        {
+          const double* in = input;
+          double* out = output ;
+          int k=0 ;
+          for(int i=0; i<dstSize_; i++, out+=sizeT, pos+=sizeT)
+          {
+            if (nSrc_[i]==0) for(int l=0; l<sizeT; l++) out[l] = defaultValue ;
+            else 
+            {
+              for(int j=0 ; j<nSrc_[i] ; j++,k++)
+                for(int l=0; l<sizeT; l++) 
+                {
+                  if (! std::isnan(in[connector_[k]*sizeT+l]) ) 
+                  {
+                    if (touched[pos+l]) out[l]=min(out[l],in[connector_[k]*sizeT+l]) ;
+                    else 
+                    {
+                      touched[pos+l] = true ;
+                      out[l] = in[connector_[k]*sizeT+l] ;
+                    }
+                  }
+                }
+            }
+          }
+        }
+
+        output = dataOut.dataFirst()  ;
+        pos=0 ;
+        for(int r=0;r<repeat;r++, input+=srcSlice, output+=dstSlice, pos+=dstSlice)
+        {
+          const double* in = input;
+          double* out = output ;
+          int k=0 ;
+          int pos=0 ;
+          for(int i=0; i<dstSize_; i++, out+=sizeT, pos+=sizeT)
+              for(int j=0 ; j<nSrc_[i] ; j++,k++)
+                for(int l=0; l<sizeT; l++) if (!touched[pos+l]) out[l] = defaultValue ;
+        }
+
+      }
+      else
+      {
+        for(int r=0;r<repeat;r++, input+=srcSlice, output+=dstSlice)
+        {
+          const double* in = input;
+          double* out = output ;
+          int k=0 ;
+          for(int i=0; i<dstSize_; i++, out+=sizeT)
+            if (nSrc_[i]==0)
+              for(int l=0; l<sizeT; l++) out[l] = defaultValue ;
+            else 
+            {
+              for(int j=0 ; j<nSrc_[i] ; j++,k++)
+                for(int l=0; l<sizeT; l++) out[l]=min(out[l],in[connector_[k]*sizeT+l]) ;
+            }
+        }
+      }
+    }
+
+    void transferMax(int repeat, int sizeT, const CArray<double,1>& dataIn, CArray<double,1>& dataOut)
+    {
+      double defaultValue = std::numeric_limits<double>::quiet_NaN();
+
+      int dstSlice = dstSize_*sizeT ;
+      int srcSlice = srcSize_*sizeT ;
+      dataOut.resize(repeat* dstSlice) ;
+      dataOut=0 ;
+           
+      const double* input = dataIn.dataFirst()  ;
+      double* output = dataOut.dataFirst()  ;
+
+      if (detectMissingValue_)
+      {
+        vector<bool> touched(repeat* dstSlice, false) ;
+        int pos=0 ;
+        for(int r=0;r<repeat;r++, input+=srcSlice, output+=dstSlice, pos+=dstSlice)
+        {
+          const double* in = input;
+          double* out = output ;
+          int k=0 ;
+          for(int i=0; i<dstSize_; i++, out+=sizeT, pos+=sizeT)
+          {
+            if (nSrc_[i]==0) for(int l=0; l<sizeT; l++) out[l] = defaultValue ;
+            else 
+            {
+              for(int j=0 ; j<nSrc_[i] ; j++,k++)
+                for(int l=0; l<sizeT; l++) 
+                {
+                  if (! std::isnan(in[connector_[k]*sizeT+l]) ) 
+                  {
+                    if (touched[pos+l]) out[l]=max(out[l],in[connector_[k]*sizeT+l]) ;
+                    else 
+                    {
+                      touched[pos+l] = true ;
+                      out[l] = in[connector_[k]*sizeT+l] ;
+                    }
+                  }
+                }
+            }
+          }
+        }
+
+        output = dataOut.dataFirst()  ;
+        pos=0 ;
+        for(int r=0;r<repeat;r++, input+=srcSlice, output+=dstSlice, pos+=dstSlice)
+        {
+          const double* in = input;
+          double* out = output ;
+          int k=0 ;
+          int pos=0 ;
+          for(int i=0; i<dstSize_; i++, out+=sizeT, pos+=sizeT)
+              for(int j=0 ; j<nSrc_[i] ; j++,k++)
+                for(int l=0; l<sizeT; l++) if (!touched[pos+l]) out[l] = defaultValue ;
+        }
+
+      }
+      else
+      {
+        for(int r=0;r<repeat;r++, input+=srcSlice, output+=dstSlice)
+        {
+          const double* in = input;
+          double* out = output ;
+          int k=0 ;
+          for(int i=0; i<dstSize_; i++, out+=sizeT)
+            if (nSrc_[i]==0)
+              for(int l=0; l<sizeT; l++) out[l] = defaultValue ;
+            else 
+            {
+              for(int j=0 ; j<nSrc_[i] ; j++,k++)
+                for(int l=0; l<sizeT; l++) out[l]=max(out[l],in[connector_[k]*sizeT+l]) ;
+            }
+        }
+      }
+    }
+
+    void transferAverage(int repeat, int sizeT, const CArray<double,1>& dataIn, CArray<double,1>& dataOut)
+    {
+      double defaultValue = std::numeric_limits<double>::quiet_NaN();
+
+      int dstSlice = dstSize_*sizeT ;
+      int srcSlice = srcSize_*sizeT ;
+      dataOut.resize(repeat* dstSlice) ;
+      dataOut=0 ;
+           
+      const double* input = dataIn.dataFirst()  ;
+      double* output = dataOut.dataFirst()  ;
+
+      if (detectMissingValue_)
+      {
+        vector<int> touched(repeat* dstSlice, 0) ;
+        int pos=0 ;
+        for(int r=0;r<repeat;r++, input+=srcSlice, output+=dstSlice, pos+=dstSlice)
+        {
+          const double* in = input;
+          double* out = output ;
+          int k=0 ;
+          for(int i=0; i<dstSize_; i++, out+=sizeT, pos+=sizeT)
+          {
+            if (nSrc_[i]==0) for(int l=0; l<sizeT; l++) out[l] = defaultValue ;
+            else 
+            {
+              for(int j=0 ; j<nSrc_[i] ; j++,k++)
+                for(int l=0; l<sizeT; l++) 
+                {
+                  if (! std::isnan(in[connector_[k]*sizeT+l]) ) 
+                  {
+                    if (touched[pos+l]) out[l] += in[connector_[k]*sizeT+l] ;
+                    else 
+                    {
+                      touched[pos+l]++ ;
+                      out[l] = in[connector_[k]*sizeT+l] ;
+                    }
+                  }
+                }
+            }
+          }
+        }
+
+        output = dataOut.dataFirst()  ;
+        pos=0 ;
+        for(int r=0;r<repeat;r++, input+=srcSlice, output+=dstSlice, pos+=dstSlice)
+        {
+          const double* in = input;
+          double* out = output ;
+          int k=0 ;
+          int pos=0 ;
+          for(int i=0; i<dstSize_; i++, out+=sizeT, pos+=sizeT)
+              for(int j=0 ; j<nSrc_[i] ; j++,k++)
+                for(int l=0; l<sizeT; l++) 
+                  if (touched[pos+l]==0) out[l] = defaultValue ;
+                  else out[l]/=touched[pos+l] ;
+        }
+
+      }
+      else
+      {
+        for(int r=0;r<repeat;r++, input+=srcSlice, output+=dstSlice)
+        {
+          const double* in = input;
+          double* out = output ;
+          int k=0 ;
+          for(int i=0; i<dstSize_; i++, out+=sizeT)
+            if (nSrc_[i]==0)
+              for(int l=0; l<sizeT; l++) out[l] = defaultValue ;
+            else 
+            {
+              for(int j=0 ; j<nSrc_[i] ; j++,k++)
+                for(int l=0; l<sizeT; l++) out[l] += in[connector_[k]*sizeT+l] ;
+            }
+          
+          out = output ;
+          for(int i=0; i<dstSize_; i++, out+=sizeT)
+            if (nSrc_[i]!=0)
+              for(int l=0; l<sizeT; l++) out[l]/=nSrc_[i];
+        }
+      }
+    }
   
   };