Changeset 1653

Timestamp:

03/06/19 12:11:10 (5 years ago)

Author:

oabramkina

Message:

Developments for visualization of XIOS workflow.

Branch is spawned from trunk r1649.

Boost library is used for producing Graphviz DOT files. Current results: a DOT file representing a static workflow. For a complete proof of concept, DOT files for each timestamp should be generated. The necessary information has been collected by XIOS, it only requires rearranging the information for graphing (changes in classes CWorkflowGraph and CGraphviz).

Location:

XIOS/dev/dev_olga/src

Files:

• config/field_attribute.conf (modified) (1 diff)
• cxios.cpp (modified) (2 diffs)
• filter/file_server_writer_filter.cpp (modified) (2 diffs)
• filter/file_server_writer_filter.hpp (modified) (2 diffs)
• filter/file_writer_filter.cpp (modified) (3 diffs)
• filter/file_writer_filter.hpp (modified) (3 diffs)
• filter/filter.cpp (modified) (1 diff)
• filter/filter.hpp (modified) (1 diff)
• filter/garbage_collector.cpp (modified) (1 diff)
• filter/garbage_collector.hpp (modified) (1 diff)
• filter/input_pin.cpp (modified) (3 diffs)
• filter/input_pin.hpp (modified) (2 diffs)
• filter/output_pin.cpp (modified) (3 diffs)
• filter/output_pin.hpp (modified) (3 diffs)
• filter/pass_through_filter.cpp (modified) (1 diff)
• filter/pass_through_filter.hpp (modified) (1 diff)
• filter/source_filter.cpp (modified) (2 diffs)
• filter/source_filter.hpp (modified) (2 diffs)
• filter/spatial_transform_filter.cpp (modified) (11 diffs)
• filter/spatial_transform_filter.hpp (modified) (3 diffs)
• filter/store_filter.cpp (modified) (2 diffs)
• filter/store_filter.hpp (modified) (2 diffs)
• filter/temporal_filter.cpp (modified) (5 diffs)
• filter/temporal_filter.hpp (modified) (1 diff)
• graphviz.cpp (added)
• graphviz.hpp (added)
• io/nc4_data_output.cpp (modified) (1 diff)
• io/onetcdf4_impl.hpp (modified) (2 diffs)
• node/axis.hpp (modified) (1 diff)
• node/field.cpp (modified) (14 diffs)
• node/field.hpp (modified) (2 diffs)
• node/field_impl.hpp (modified) (3 diffs)
• node/grid.hpp (modified) (12 diffs)
• node/interpolate_domain.cpp (modified) (1 diff)
• transformation/domain_algorithm_zoom.cpp (modified) (1 diff)
• transformation/generic_algorithm_transformation.hpp (modified) (1 diff)
• transformation/grid_transformation.cpp (modified) (1 diff)
• transformation/grid_transformation_factory_impl.hpp (modified) (1 diff)
• workflow_graph.cpp (added)
• workflow_graph.hpp (added)

XIOS/dev/dev_olga/src/config/field_attribute.conf

@@ -19 +19 @@
 DECLARE_ATTRIBUTE(bool,      indexed_output)
 DECLARE_ATTRIBUTE(bool,      check_if_active)
+DECLARE_ATTRIBUTE(bool,      build_workflow_graph)
 
 DECLARE_ATTRIBUTE(StdString, domain_ref, false)

XIOS/dev/dev_olga/src/cxios.cpp

@@ -11 +11 @@
 #include "memtrack.hpp"
 #include "registry.hpp"
+#include "graphviz.hpp"
 
 namespace xios
@@ -135 +136 @@
        globalRegistry->toFile("xios_registry.bin") ;
        delete globalRegistry ;
+       
+       CGraphviz::buildStaticWorkflowGraph();
      }
 

XIOS/dev/dev_olga/src/filter/file_server_writer_filter.cpp

@@ -12 +12 @@
       ERROR("CFileServerWriterFilter::CFileServerWriterFilter(CField* field)",
             "The field cannot be null.");
+    filterId = InvalidableObject::count;
+    InvalidableObject::count++;
   }
 
@@ -28 +30 @@
     return true;
   }
+
+  int CFileServerWriterFilter::getFilterId(void)
+  {
+    return filterId;
+  }
+
 } // namespace xios

XIOS/dev/dev_olga/src/filter/file_server_writer_filter.hpp

@@ -37 +37 @@
       bool virtual isDataExpected(const CDate& date) const;
 
+      /*!
+       * Returns filter's id needed in case of building workflow graph
+       */
+      int getFilterId();
+
     protected:
       /*!
@@ -46 +51 @@
 
     private:
-      CField* field; //<! The associated field
+      CField* field;           //<! The associated field
       std::map<Time, CDataPacketPtr> packets; //<! The stored packets
+      int filterId;            //<! Filter's id needed in case of building a workflow
+
   }; // class CFileServerWriterFilter
 } // namespace xios

XIOS/dev/dev_olga/src/filter/file_writer_filter.cpp

@@ -3 +3 @@
 #include "field.hpp"
 #include "utils.hpp"
+#include "workflow_graph.hpp"
 
 namespace xios
@@ -13 +14 @@
       ERROR("CFileWriterFilter::CFileWriterFilter(CField* field)",
             "The field cannot be null.");
+    filterId = InvalidableObject::count;
+    InvalidableObject::count++;
   }
 
@@ -46 +49 @@
     return true;
   }
+
+  int CFileWriterFilter::getFilterId(void)
+  {
+    return filterId;
+  }
+
 } // namespace xios

XIOS/dev/dev_olga/src/filter/file_writer_filter.hpp

@@ -23 +23 @@
       CFileWriterFilter(CGarbageCollector& gc, CField* field);
 
+      inline StdString GetName(void) {return StdString("File writer filter");};
+
       /*!
        * Tests if the filter must auto-trigger.
@@ -37 +39 @@
       bool virtual isDataExpected(const CDate& date) const;
 
+      /*!
+       * Returns filter's id needed in case of building workflow graph
+       */
+      int getFilterId();
+
     protected:
       /*!
@@ -46 +53 @@
 
     private:
-      CField* field; //<! The associated field
+      CField* field;                          //<! The associated field
       std::map<Time, CDataPacketPtr> packets; //<! The stored packets
+      int filterId;                           //<! Filter's id needed in case of building a workflow
+
   }; // class CFileWriterFilter
 } // namespace xios

XIOS/dev/dev_olga/src/filter/filter.cpp

@@ -3 +3 @@
 namespace xios
 {
-  CFilter::CFilter(CGarbageCollector& gc, size_t inputSlotsCount, IFilterEngine* engine)
+  CFilter::CFilter(CGarbageCollector& gc, size_t inputSlotsCount, IFilterEngine* engine, bool buildWorkflowGraph /*= false*/)
     : CInputPin(gc, inputSlotsCount)
-    , COutputPin(gc)
+    , COutputPin(gc, false, buildWorkflowGraph)
     , engine(engine)
     , inputSlotCount(inputSlotCount)
   { /* Nothing to do */ }
+
+  StdString CFilter::GetName(void)    { return StdString("Filter"); }
 
   void CFilter::onInputReady(std::vector<CDataPacketPtr> data)

XIOS/dev/dev_olga/src/filter/filter.hpp

@@ -23 +23 @@
        * \param inputSlotsCount the number of input slots
        * \param engine the filter engine
+       * \param buildWorkflowGraph indicates whether data will be visualized
        */
-      CFilter(CGarbageCollector& gc, size_t inputSlotsCount, IFilterEngine* engine);
+      CFilter(CGarbageCollector& gc, size_t inputSlotsCount, IFilterEngine* engine, bool buildWorkflowGraph = false);
+
+      StdString virtual GetName(void);
 
       /*!

XIOS/dev/dev_olga/src/filter/garbage_collector.cpp

@@ -3 +3 @@
 namespace xios
 {
+
+  int InvalidableObject::count = 0;
+  
   void CGarbageCollector::registerObject(InvalidableObject* Object, Time timestamp)
   {

XIOS/dev/dev_olga/src/filter/garbage_collector.hpp

@@ -20 +20 @@
      */
     void virtual invalidate(Time timestamp) = 0;
+  
+    static int count; //!< Counter used to identify a filter in case building workflow graph
+    
   }; // struct InvalidableObject
 

XIOS/dev/dev_olga/src/filter/input_pin.cpp

@@ -3 +3 @@
 #include "garbage_collector.hpp"
 #include "exception.hpp"
+#include "workflow_graph.hpp"
 
 namespace xios
@@ -11 +12 @@
     , triggers(slotsCount)
     , hasTriggers(false)
-  { /* Nothing to do */ }
+  {   }
+
+  StdString CInputPin::GetName(void)
+  {
+    return StdString("Input pin");
+  }
 
   void CInputPin::setInput(size_t inputSlot, CDataPacketPtr packet)
@@ -77 +83 @@
     inputs.erase(inputs.begin(), inputs.lower_bound(timestamp));
   }
+
+  int CInputPin::getFilterId(void)
+  {
+    return -1;
+  }
+
 } // namespace xios

XIOS/dev/dev_olga/src/filter/input_pin.hpp

@@ -26 +26 @@
        */
       CInputPin(CGarbageCollector& gc, size_t slotsCount);
+      
+      StdString virtual GetName(void);
 
       /*!
@@ -79 +81 @@
        */
       void virtual invalidate(Time timestamp);
+      
+      /*!
+       * Returns filter's id needed in case of building workflow graph
+       * This function should never be called from this class, instead functions defined in derived classes or in class COutputPin should be used
+       */
+      int virtual getFilterId();
 
     protected:

XIOS/dev/dev_olga/src/filter/output_pin.cpp

@@ -1 +1 @@
 #include "output_pin.hpp"
 #include "exception.hpp"
+#include "workflow_graph.hpp"
 
 namespace xios
 {
-  COutputPin::COutputPin(CGarbageCollector& gc, bool manualTrigger /*= false*/)
+  COutputPin::COutputPin(CGarbageCollector& gc, bool manualTrigger /*= false*/, bool buildWorkflowGraph /* =false */)
     : gc(gc)
     , manualTrigger(manualTrigger)
-  { /* Nothing to do */ }
+    , buildWorkflowGraph(buildWorkflowGraph)
+  {
+    filterId = InvalidableObject::count;
+    InvalidableObject::count++;
+  }
+
+  StdString COutputPin::GetName(void)
+  {
+    return StdString("Output pin");
+  }
 
   void COutputPin::connectOutput(std::shared_ptr<CInputPin> inputPin, size_t inputSlot)
@@ -26 +36 @@
       ERROR("void COutputPin::onOutputReady(CDataPacketPtr packet)",
             "The packet cannot be null.");
+
+    if (buildWorkflowGraph)
+    {
+        CWorkflowGraph::mapFilterTimestamps[this->getFilterId()].push_back(packet->timestamp);
+        CWorkflowGraph::timestamps.insert(packet->timestamp);
+    }
 
     if (manualTrigger) // Don't use canBeTriggered here, this function is virtual and can be overriden
@@ -101 +117 @@
     outputPackets.erase(outputPackets.begin(), outputPackets.lower_bound(timestamp));
   }
+
+  int COutputPin::getFilterId(void)
+  {
+    return filterId;
+  }
+
 } // namespace xios

XIOS/dev/dev_olga/src/filter/output_pin.hpp

@@ -19 +19 @@
        * \param gc the garbage collector associated with this ouput pin
        * \param slotsCount the number of slots
+       * \param buildWorkflowGraph indicates whether data will be visualized
        */
-      COutputPin(CGarbageCollector& gc, bool manualTrigger = false);
+      COutputPin(CGarbageCollector& gc, bool manualTrigger = false, bool buildWorkflowGraph = false);
 
+      StdString virtual GetName(void);
+      
       /*!
        * Connects to a specific slot of the input pin of a downstream filter.
@@ -66 +69 @@
       void virtual invalidate(Time timestamp);
 
+      /*!
+       * Returns filter's id needed in case of building workflow graph
+       */
+      int getFilterId();
+
     protected:
       /*!
@@ -97 +105 @@
       //! Output buffer, store the packets until the output is triggered
       std::map<Time, CDataPacketPtr> outputPackets;
+
+      //! Indicates whether the workflow will be visualized
+      bool buildWorkflowGraph;
+
+      //! Filter's id needed in case of building a workflow graph
+      int filterId;
+
+
   }; // class COutputPin
 } // namespace xios

XIOS/dev/dev_olga/src/filter/pass_through_filter.cpp

@@ -3 +3 @@
 namespace xios
 {
-  CPassThroughFilter::CPassThroughFilter(CGarbageCollector& gc)
-    : CFilter(gc, 1, this)
+  CPassThroughFilter::CPassThroughFilter(CGarbageCollector& gc, bool buildWorkflowGraph /*= false*/)
+    : CFilter(gc, 1, this, buildWorkflowGraph)
   { /* Nothing to do */ }
 

XIOS/dev/dev_olga/src/filter/pass_through_filter.hpp

@@ -17 +17 @@
        *
        * \param gc the associated garbage collector
+       * \param buildWorkflowGraph indicates whether data will be visualized
        */
-      CPassThroughFilter(CGarbageCollector& gc);
+      CPassThroughFilter(CGarbageCollector& gc, bool buildWorkflowGraph = false);
+
+      inline StdString GetName(void) {return StdString("Pass through filter");};
 
     protected:

XIOS/dev/dev_olga/src/filter/source_filter.cpp

@@ -4 +4 @@
 #include "calendar_util.hpp"
 #include <limits> 
+#include "workflow_graph.hpp"
 
 namespace xios
@@ -11 +12 @@
                                const CDuration offset /*= NoneDu*/, bool manualTrigger /*= false*/,
                                bool hasMissingValue /*= false*/,
-                               double defaultValue /*= 0.0*/)
-    : COutputPin(gc, manualTrigger)
+                               double defaultValue /*= 0.0*/,
+                               bool buildWorkflowGraph /*= false*/)
+    : COutputPin(gc, manualTrigger, buildWorkflowGraph)
     , grid(grid)
     , compression(compression)

XIOS/dev/dev_olga/src/filter/source_filter.hpp

@@ -27 +27 @@
        * \param hasMissingValue whether data has missing value
        * \param defaultValue missing value to detect
+       * \param[in] buildWorkflowGraph indicates whether the workflow will be visualized
        */
       CSourceFilter(CGarbageCollector& gc, CGrid* grid,
@@ -33 +34 @@
                     const CDuration offset = NoneDu, bool manualTrigger = false,
                     bool hasMissingValue = false,
-                    double defaultValue = 0.0);
+                    double defaultValue = 0.0,
+                                        bool buildWorkflowGraph = false);
+
+      inline StdString GetName(void) {return StdString("Source filter");};
 
       /*!

XIOS/dev/dev_olga/src/filter/spatial_transform_filter.cpp

@@ -4 +4 @@
 #include "context_client.hpp"
 #include "timer.hpp"
+#include "workflow_graph.hpp"
 
 namespace xios
 {
-  CSpatialTransformFilter::CSpatialTransformFilter(CGarbageCollector& gc, CSpatialTransformFilterEngine* engine, double outputValue, size_t inputSlotsCount)
-    : CFilter(gc, inputSlotsCount, engine), outputDefaultValue(outputValue)
+  CSpatialTransformFilter::CSpatialTransformFilter(CGarbageCollector& gc, CSpatialTransformFilterEngine* engine,
+                                                   double outputValue, size_t inputSlotsCount, bool buildWorkflowGraph /*= false*/)
+    : CFilter(gc, inputSlotsCount, engine, buildWorkflowGraph), outputDefaultValue(outputValue)
   { /* Nothing to do */ }
 
   std::pair<std::shared_ptr<CSpatialTransformFilter>, std::shared_ptr<CSpatialTransformFilter> >
-  CSpatialTransformFilter::buildFilterGraph(CGarbageCollector& gc, CGrid* srcGrid, CGrid* destGrid, bool hasMissingValue, double missingValue)
+  CSpatialTransformFilter::buildFilterGraph(CGarbageCollector& gc, CGrid* srcGrid, CGrid* destGrid, bool hasMissingValue, double missingValue,
+                                            bool buildWorkflowGraph)
   {
     if (!srcGrid || !destGrid)
@@ -29 +32 @@
       double defaultValue  = (hasMissingValue) ? std::numeric_limits<double>::quiet_NaN() : 0.0;
 
-
       const CGridTransformationSelector::ListAlgoType& algoList = gridTransformation->getAlgoList() ;
       CGridTransformationSelector::ListAlgoType::const_iterator it  ;
@@ -37 +39 @@
 
       std::shared_ptr<CSpatialTransformFilter> filter ;
-      if( isSpatialTemporal) filter = std::shared_ptr<CSpatialTransformFilter>(new CSpatialTemporalFilter(gc, engine, gridTransformation, defaultValue, inputCount));
-      else filter = std::shared_ptr<CSpatialTransformFilter>(new CSpatialTransformFilter(gc, engine, defaultValue, inputCount));
-
-      
+      if( isSpatialTemporal)
+        filter = std::shared_ptr<CSpatialTransformFilter>(new CSpatialTemporalFilter(gc, engine, gridTransformation, defaultValue, inputCount, buildWorkflowGraph));
+      else
+        filter = std::shared_ptr<CSpatialTransformFilter>(new CSpatialTransformFilter(gc, engine, defaultValue, inputCount, buildWorkflowGraph));
+
       if (!lastFilter)
         lastFilter = filter;
       else
+      {
         filter->connectOutput(firstFilter, 0);
+        if (buildWorkflowGraph)
+        {
+          int filterOut = (std::static_pointer_cast<COutputPin>(filter))->getFilterId();
+          int filterIn = (std::static_pointer_cast<COutputPin>(firstFilter))->getFilterId();
+          // PASS field's id here
+          CWorkflowGraph::mapFieldToFilters["XXX"].push_back(filterOut);
+          CWorkflowGraph::mapFieldToFilters["XXX"].push_back(filterIn);
+          CWorkflowGraph::mapFilters[filterOut] = "Spatial transform filter";
+          CWorkflowGraph::mapFilters[filterIn] = "Spatial transform filter";
+        }
+      }
 
       firstFilter = filter;
@@ -69 +84 @@
   }
 
-  CSpatialTemporalFilter::CSpatialTemporalFilter(CGarbageCollector& gc, CSpatialTransformFilterEngine* engine, CGridTransformation* gridTransformation, double outputValue, size_t inputSlotsCount)
-    : CSpatialTransformFilter(gc, engine, outputValue, inputSlotsCount), record(0)
+  CSpatialTemporalFilter::CSpatialTemporalFilter(CGarbageCollector& gc, CSpatialTransformFilterEngine* engine,
+                                                  CGridTransformation* gridTransformation, double outputValue,
+                                                  size_t inputSlotsCount, bool buildWorkflowGraph)
+    : CSpatialTransformFilter(gc, engine, outputValue, inputSlotsCount, buildWorkflowGraph), record(0)
   {
       const CGridTransformationSelector::ListAlgoType& algoList = gridTransformation->getAlgoList() ;
@@ -188 +205 @@
     
     CContextClient* client = CContext::getCurrent()->client;
+    int rank;
+    MPI_Comm_rank (client->intraComm, &rank);
 
     // Get default value for output data
@@ -217 +236 @@
       int idxSendBuff = 0;
       std::vector<double*> sendBuff(localIndexToSend.size());
+      double* sendBuffRank;
       for (itSend = itbSend; itSend != iteSend; ++itSend, ++idxSendBuff)
       {
+        int destRank = itSend->first;
         if (0 != itSend->second.numElements())
-          sendBuff[idxSendBuff] = new double[itSend->second.numElements()];
+        {
+          if (rank != itSend->first)
+            sendBuff[idxSendBuff] = new double[itSend->second.numElements()];
+          else
+            sendBuffRank = new double[itSend->second.numElements()];
+        }
       }
 
@@ -230 +256 @@
         const CArray<int,1>& localIndex_p = itSend->second;
         int countSize = localIndex_p.numElements();
-        for (int idx = 0; idx < countSize; ++idx)
-        {
-          sendBuff[idxSendBuff][idx] = dataCurrentSrc(localIndex_p(idx));
-        }
-        sendRecvRequest.push_back(MPI_Request());
-        MPI_Isend(sendBuff[idxSendBuff], countSize, MPI_DOUBLE, destRank, 12, client->intraComm, &sendRecvRequest.back());
+        if (destRank != rank)
+        {
+          for (int idx = 0; idx < countSize; ++idx)
+          {
+            sendBuff[idxSendBuff][idx] = dataCurrentSrc(localIndex_p(idx));
+          }
+          sendRecvRequest.push_back(MPI_Request());
+          MPI_Isend(sendBuff[idxSendBuff], countSize, MPI_DOUBLE, destRank, 12, client->intraComm, &sendRecvRequest.back());
+        }
+        else
+        {
+          for (int idx = 0; idx < countSize; ++idx)
+          {
+            sendBuffRank[idx] = dataCurrentSrc(localIndex_p(idx));
+          }
+        }
       }
 
@@ -243 +279 @@
                                                                        iteRecv = localIndexToReceive.end();
       int recvBuffSize = 0;
-      for (itRecv = itbRecv; itRecv != iteRecv; ++itRecv) recvBuffSize += itRecv->second.size(); //(recvBuffSize < itRecv->second.size())
-                                                                       //? itRecv->second.size() : recvBuffSize;
+      for (itRecv = itbRecv; itRecv != iteRecv; ++itRecv)
+      {
+        if (itRecv->first != rank )
+          recvBuffSize += itRecv->second.size();
+      }
+      //(recvBuffSize < itRecv->second.size()) ? itRecv->second.size() : recvBuffSize;
       double* recvBuff;
+
       if (0 != recvBuffSize) recvBuff = new double[recvBuffSize];
       int currentBuff = 0;
@@ -251 +292 @@
       {
         int srcRank = itRecv->first;
-        int countSize = itRecv->second.size();
-        sendRecvRequest.push_back(MPI_Request());
-        MPI_Irecv(recvBuff + currentBuff, countSize, MPI_DOUBLE, srcRank, 12, client->intraComm, &sendRecvRequest.back());
-        currentBuff += countSize;
+        if (srcRank != rank)
+        {
+          int countSize = itRecv->second.size();
+          sendRecvRequest.push_back(MPI_Request());
+          MPI_Irecv(recvBuff + currentBuff, countSize, MPI_DOUBLE, srcRank, 12, client->intraComm, &sendRecvRequest.back());
+          currentBuff += countSize;
+        }
       }
       std::vector<MPI_Status> status(sendRecvRequest.size());
@@ -267 +311 @@
       for (itRecv = itbRecv; itRecv != iteRecv; ++itRecv)
       {
-        int countSize = itRecv->second.size();
         const std::vector<std::pair<int,double> >& localIndex_p = itRecv->second;
-        (*itAlgo)->apply(localIndex_p,
-                         recvBuff+currentBuff,
-                         dataCurrentDest,
-                         localInitFlag,
-                         ignoreMissingValue,firstPass);
-
-        currentBuff += countSize;
+        int srcRank = itRecv->first;
+        if (srcRank != rank)
+        {
+          int countSize = itRecv->second.size();
+          (*itAlgo)->apply(localIndex_p,
+                           recvBuff+currentBuff,
+                           dataCurrentDest,
+                           localInitFlag,
+                           ignoreMissingValue,firstPass);
+          currentBuff += countSize;
+        }
+        else
+        {
+          (*itAlgo)->apply(localIndex_p,
+                           sendBuffRank,
+                           dataCurrentDest,
+                           localInitFlag,
+                           ignoreMissingValue,firstPass);
+        }
+
         firstPass=false ;
       }
@@ -285 +341 @@
       {
         if (0 != itSend->second.numElements())
-          delete [] sendBuff[idxSendBuff];
+        {
+          if (rank != itSend->first)
+            delete [] sendBuff[idxSendBuff];
+          else
+            delete [] sendBuffRank;
+        }
       }
       if (0 != recvBuffSize) delete [] recvBuff;

XIOS/dev/dev_olga/src/filter/spatial_transform_filter.hpp

@@ -23 +23 @@
        * \param outputValue default value of output pin
        * \param [in] inputSlotsCount number of input, by default there is only one for field src
+       * \param buildWorkflowGraph indicates whether data will be visualized
        */
-      CSpatialTransformFilter(CGarbageCollector& gc, CSpatialTransformFilterEngine* engine, double outputValue, size_t inputSlotsCount = 1);
+      CSpatialTransformFilter(CGarbageCollector& gc, CSpatialTransformFilterEngine* engine,
+                              double outputValue, size_t inputSlotsCount = 1, bool buildWorkflowGraph = false);
+
+      inline StdString GetName(void) {return StdString("Spatial transform filter");};
 
       /*!
@@ -34 +38 @@
        * \param hasMissingValue whether field source has missing value
        * \param defaultValue default value
+       * \param buildWorkflowGraph indicates whether data will be visualized
        * \return the first and the last filters of the filter graph
        */
       static std::pair<std::shared_ptr<CSpatialTransformFilter>, std::shared_ptr<CSpatialTransformFilter> >
-      buildFilterGraph(CGarbageCollector& gc, CGrid* srcGrid, CGrid* destGrid, bool hasMissingValue, double defaultValue);
+      buildFilterGraph(CGarbageCollector& gc, CGrid* srcGrid, CGrid* destGrid, bool hasMissingValue, double defaultValue, bool buildWorkflowGraph = false);
 
     protected:
@@ -67 +72 @@
        * \param outputValue default value of output pin
        * \param [in] inputSlotsCount number of input, by default there is only one for field src
+       * \param buildWorkflowGraph indicates whether data will be visualized
+       *
        */
-      CSpatialTemporalFilter(CGarbageCollector& gc, CSpatialTransformFilterEngine* engine, CGridTransformation* gridTransformation, double outputValue, size_t inputSlotsCount = 1);
+      CSpatialTemporalFilter(CGarbageCollector& gc, CSpatialTransformFilterEngine* engine, CGridTransformation* gridTransformation,
+                            double outputValue, size_t inputSlotsCount = 1, bool buildWorkflowGraph = false);
 
 

XIOS/dev/dev_olga/src/filter/store_filter.cpp

@@ -21 +21 @@
       ERROR("CStoreFilter::CStoreFilter(CContext* context, CGrid* grid)",
             "Impossible to construct a store filter without providing a grid.");
+    filterId = InvalidableObject::count;
+    InvalidableObject::count++;
   }
 
@@ -126 +128 @@
     packets.erase(packets.begin(), packets.lower_bound(timestamp));
   }
+
+  int CStoreFilter::getFilterId(void)
+  {
+    return filterId;
+  }
+
 } // namespace xios

XIOS/dev/dev_olga/src/filter/store_filter.hpp

@@ -73 +73 @@
       void virtual invalidate(Time timestamp);
 
+      /*!
+       * Returns filter's id needed in case of building workflow graph
+       */
+      int getFilterId();
+
     protected:
       /*!
@@ -82 +87 @@
 
     private:
-      CGarbageCollector& gc; //!< The garbage collector associated to the filter
-      CContext* context; //!< The context to which the data belongs
-      CGrid* grid; //!< The grid attached to the data the filter can accept
-      const bool detectMissingValues; //!< Whether missing values should be detected
-      const double missingValue; //!< The value to use to replace missing values
+      CGarbageCollector& gc;            //!< The garbage collector associated to the filter
+      CContext* context;                //!< The context to which the data belongs
+      CGrid* grid;                      //!< The grid attached to the data the filter can accept
+      const bool detectMissingValues;   //!< Whether missing values should be detected
+      const double missingValue;        //!< The value to use to replace missing values
       std::map<Time, CDataPacketPtr> packets; //<! The stored packets
+      int filterId;                     //!< Filter's id needed in case of building a workflow
+
   }; // class CStoreFilter
 } // namespace xios

XIOS/dev/dev_olga/src/filter/temporal_filter.cpp

@@ -9 +9 @@
   CTemporalFilter::CTemporalFilter(CGarbageCollector& gc, const std::string& opId,
                                    const CDate& initDate, const CDuration samplingFreq, const CDuration samplingOffset, const CDuration opFreq,
-                                   bool ignoreMissingValue /*= false*/)
-    : CFilter(gc, 1, this)
+                                   bool ignoreMissingValue /*= false*/, bool buildWorkflowGraph /*= false*/)
+    : CFilter(gc, 1, this, buildWorkflowGraph)
     , functor(createFunctor(opId, ignoreMissingValue, tmpData))
     , isOnceOperation(functor->timeType() == func::CFunctor::once)
@@ -22 +22 @@
                         this->samplingOffset.second, this->samplingOffset.timestep)
     , initDate(initDate)
-//    , nextSamplingDate(initDate + (this->samplingOffset + initDate.getRelCalendar().getTimeStep()))
     , nextSamplingDate(initDate + offsetMonth + ( offsetAllButMonth + initDate.getRelCalendar().getTimeStep()))
     , nbOperationDates(1)
     , nbSamplingDates(0)
-//    , nextOperationDate(initDate + opFreq + this->samplingOffset)
     , isFirstOperation(true)
   {
@@ -43 +41 @@
       {
         usePacket = (data[0]->date >= nextSamplingDate);
-//        outputResult = (data[0]->date + samplingFreq > nextOperationDate);
         outputResult = (data[0]->date  > initDate + nbOperationDates*opFreq - samplingFreq + offsetMonth + offsetAllButMonth);
         copyLess = (isInstantOperation && usePacket && outputResult);
@@ -80 +77 @@
 
         isFirstOperation = false;
-//        nextOperationDate = initDate + samplingFreq + nbOperationDates*opFreq - samplingFreq + offsetMonth + offsetAllButMonth;
       }
     }
@@ -94 +90 @@
   bool CTemporalFilter::isDataExpected(const CDate& date) const
   {
-//    return isOnceOperation ? isFirstOperation : (date >= nextSamplingDate || date + samplingFreq > nextOperationDate);
     return isOnceOperation ? isFirstOperation : (date >= nextSamplingDate || date > initDate + nbOperationDates*opFreq - samplingFreq + offsetMonth + offsetAllButMonth);
   }

XIOS/dev/dev_olga/src/filter/temporal_filter.hpp

@@ -29 +29 @@
       CTemporalFilter(CGarbageCollector& gc, const std::string& opId,
                       const CDate& initDate, const CDuration samplingFreq, const CDuration samplingOffset, const CDuration opFreq,
-                      bool ignoreMissingValue = false);
+                      bool ignoreMissingValue = false, bool buildWorkflowGraph = false);
+
+      inline StdString GetName(void) {return StdString("Temporal filter");};
 
       /*!

XIOS/dev/dev_olga/src/io/nc4_data_output.cpp

@@ -426 +426 @@
                      std::vector<StdSize> start(2) ;
                      std::vector<StdSize> count(2) ;
-// Comment out for a moment because it is not working for a hole
+// Comment out: it is not working for a hole
 //                     if (domain->isEmpty())
 //                     {

XIOS/dev/dev_olga/src/io/onetcdf4_impl.hpp

@@ -60 +60 @@
     CTimer::get("CONetCDF4::writeData getWriteDataInfos").suspend();
  
-    int dimArrayLen = 0;
+    int dimArrayLen;
     for (int i=0; i<scount.size(); i++)
       if (scount[i] == stringArrayLen)
@@ -73 +73 @@
     }
     char *PtrArrayStr ;
-    PtrArrayStr=new char[stringArrayLen] ;
+    PtrArrayStr=new char[stringArrayLen*data.numElements()] ;
+    memset (PtrArrayStr,' ',stringArrayLen*data.numElements());
+    size_t offset=0 ;
     Array<StdString,1>::const_iterator it, itb=data.begin(), ite=data.end() ;
-    int lineNb = 0;
-    for(it=itb;it!=ite;it++)
+    for(it=itb;it!=ite;++it, offset+=stringArrayLen)
     {
-      it->copy(PtrArrayStr,it->size()) ;
-      PtrArrayStr[it->size()]='\0' ;
-      sstart[0] = lineNb;
-      sstart[dimArrayLen] = 0;
-      scount[0] = 1;
-      scount[dimArrayLen] = it->size()+1;
-      CTimer::get("CONetCDF4::writeData writeData_").resume();
-      this->writeData_(grpid, varid, sstart, scount, PtrArrayStr);
-      CTimer::get("CONetCDF4::writeData writeData_").suspend();
-      ++lineNb;
+      it->copy(PtrArrayStr+offset,it->size()) ;
+      PtrArrayStr[offset+it->size()]='\0' ;
     }
+
+     CTimer::get("CONetCDF4::writeData writeData_").resume();
+     this->writeData_(grpid, varid, sstart, scount, PtrArrayStr);
+     CTimer::get("CONetCDF4::writeData writeData_").suspend();
+
     delete []  PtrArrayStr;
   }

XIOS/dev/dev_olga/src/node/axis.hpp

@@ -183 +183 @@
    }; // class CAxis
 
+   ///--------------------------------------------------------------
+
    // Declare/Define CAxisGroup and CAxisDefinition
    DECLARE_GROUP(CAxis);

XIOS/dev/dev_olga/src/node/field.cpp

@@ -24 +24 @@
 #include "spatial_transform_filter.hpp"
 #include "file_server_writer_filter.hpp"
+#include "workflow_graph.hpp"
 
 namespace xios{
@@ -1109 +1110 @@
    TRY
    {     
-    if (!isReferenceSolvedAndTransformed) solveAllEnabledFieldsAndTransform();
-    if (!isGridChecked) checkGridOfEnabledFields();
+     if (!isReferenceSolvedAndTransformed) solveAllEnabledFieldsAndTransform();
+     if (!isGridChecked) checkGridOfEnabledFields();
 
      const bool detectMissingValues = (!detect_missing_value.isEmpty() && !default_value.isEmpty() && detect_missing_value == true);
+     const bool buildWorkflowGraph = (!build_workflow_graph.isEmpty() && build_workflow_graph == true);
      const double defaultValue  = detectMissingValues ? default_value : (!default_value.isEmpty() ? default_value : 0.0);
 
@@ -1122 +1124 @@
      {
         if (!instantDataFilter)
+        {
           instantDataFilter = clientSourceFilter = std::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid, true, false));
-
+        }
 
        // If the field data is to be read by the client or/and written to a file
@@ -1138 +1141 @@
      {
        if (!instantDataFilter)
+       {
          instantDataFilter = clientSourceFilter = std::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid, false, false));
-
+       }
              // If the field data is to be read by the client or/and written to a file
        if (enableOutput && !storeFilter && !fileWriterFilter)
@@ -1164 +1168 @@
            if (!field_ref.isEmpty())
            {
-             CGrid* gridRef = CField::get(field_ref)->grid;
+             CField* fieldRef = CField::get(field_ref);
+             fieldRef->build_workflow_graph.setValue(buildWorkflowGraph);
+             CGrid* gridRef = fieldRef->grid;
 
              if (grid && grid != gridRef && grid->hasTransform())
              {
-                 std::pair<std::shared_ptr<CFilter>, std::shared_ptr<CFilter> > filters = CSpatialTransformFilter::buildFilterGraph(gc, gridRef, grid, detectMissingValues, defaultValue); 
+               std::pair<std::shared_ptr<CFilter>, std::shared_ptr<CFilter> > filters = CSpatialTransformFilter::buildFilterGraph(gc, gridRef, grid,
+                                                                                         detectMissingValues, defaultValue, buildWorkflowGraph);
 
                filter->connectOutput(filters.first, 0);
+
+               if (buildWorkflowGraph)
+               {
+                 int filterOut = filter->getFilterId();
+                 int filterIn = (std::static_pointer_cast<COutputPin>(filters.second))->getFilterId();
+                 CWorkflowGraph::mapFieldToFilters[this->getId()].push_back(filterOut);
+                 CWorkflowGraph::mapFieldToFilters[this->getId()].push_back(filterIn);
+                 CWorkflowGraph::mapFilters[filterOut] = filter->GetName();
+                 CWorkflowGraph::mapFilters[filterIn] = filters.second->GetName();
+               }
                filter = filters.second;
              }
@@ -1179 +1196 @@
          // Check if we have a reference on another field
          else if (!field_ref.isEmpty())
+         {
+           CField::get(field_ref)->build_workflow_graph.setValue(buildWorkflowGraph);
            instantDataFilter = getFieldReference(gc);
+         }
          // Check if the data is to be read from a file
          else if (file && !file->mode.isEmpty() && file->mode == CFile::mode_attr::read)
@@ -1185 +1205 @@
            checkTimeAttributes();
            instantDataFilter = serverSourceFilter = std::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid, true, false, freq_offset, true,
-                                                                                                       detectMissingValues, defaultValue));
+                                                                                                       detectMissingValues, defaultValue, buildWorkflowGraph));
          }
          else // The data might be passed from the model
@@ -1191 +1211 @@
             if (check_if_active.isEmpty()) check_if_active = false; 
             instantDataFilter = clientSourceFilter = std::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid, false, true, NoneDu, false,
-                                                                                                        detectMissingValues, defaultValue));
+                                                                                                      detectMissingValues, defaultValue, buildWorkflowGraph));
          }
        }
@@ -1209 +1229 @@
            fileWriterFilter = std::shared_ptr<CFileWriterFilter>(new CFileWriterFilter(gc, this));
            getTemporalDataFilter(gc, file->output_freq)->connectOutput(fileWriterFilter, 0);
+           if (buildWorkflowGraph)
+           {
+             int filterOut = getTemporalDataFilter(gc, file->output_freq)->getFilterId();
+             int filterIn = fileWriterFilter->getFilterId();
+             CWorkflowGraph::mapFieldToFilters[this->getId()].push_back(filterOut);
+             CWorkflowGraph::mapFieldToFilters[this->getId()].push_back(filterIn);
+             CWorkflowGraph::mapFilters[filterOut] = "Temporal filter";
+             CWorkflowGraph::mapFilters[filterIn] = fileWriterFilter->GetName();
+           }
          }
        }
@@ -1231 +1260 @@
      CField* fieldRef = CField::get(field_ref);
      fieldRef->buildFilterGraph(gc, false);
+     bool buildWorkflowGraph = (!build_workflow_graph.isEmpty() && build_workflow_graph == true);
 
      std::pair<std::shared_ptr<CFilter>, std::shared_ptr<CFilter> > filters;
@@ -1238 +1268 @@
        bool hasMissingValue = (!detect_missing_value.isEmpty() && !default_value.isEmpty() && detect_missing_value == true);
        double defaultValue  = hasMissingValue ? default_value : (!default_value.isEmpty() ? default_value : 0.0);                                
-       filters = CSpatialTransformFilter::buildFilterGraph(gc, fieldRef->grid, grid, hasMissingValue, defaultValue);
+       filters = CSpatialTransformFilter::buildFilterGraph(gc, fieldRef->grid, grid, hasMissingValue, defaultValue, buildWorkflowGraph);
      }
      else
-       filters.first = filters.second = std::shared_ptr<CFilter>(new CPassThroughFilter(gc));
+     {
+       filters.first = filters.second = std::shared_ptr<CFilter>(new CPassThroughFilter(gc, buildWorkflowGraph));
+     }
 
      fieldRef->getInstantDataFilter()->connectOutput(filters.first, 0);
 
+     if (buildWorkflowGraph)
+     {
+       int filterOut = fieldRef->instantDataFilter->getFilterId();
+       int filterIn = (std::static_pointer_cast<COutputPin>(filters.first))->getFilterId();
+       CWorkflowGraph::mapFieldToFilters[fieldRef->getId()].push_back(filterOut);
+       CWorkflowGraph::mapFieldToFilters[fieldRef->getId()].push_back(filterIn);
+       CWorkflowGraph::mapFilters[filterOut] = fieldRef->getInstantDataFilter()->GetName();
+       CWorkflowGraph::mapFilters[filterIn] = filters.first->GetName();
+     }
      return filters.second;
    }
@@ -1317 +1358 @@
    {
      std::map<CDuration, std::shared_ptr<COutputPin> >::iterator it = temporalDataFilters.find(outFreq);
+     const bool buildWorkflowGraph = (!build_workflow_graph.isEmpty() && build_workflow_graph == true);
 
      if (it == temporalDataFilters.end())
@@ -1327 +1369 @@
 
        const bool detectMissingValues = (!detect_missing_value.isEmpty()  && detect_missing_value == true);
-       std::shared_ptr<CTemporalFilter> temporalFilter(new CTemporalFilter(gc, operation,
-                                                                             CContext::getCurrent()->getCalendar()->getInitDate(),
-                                                                             freq_op, freq_offset, outFreq, detectMissingValues));
+       std::shared_ptr<CTemporalFilter> temporalFilter(new CTemporalFilter(gc, operation, CContext::getCurrent()->getCalendar()->getInitDate(),
+                                                                             freq_op, freq_offset, outFreq,
+                                                                             detectMissingValues, buildWorkflowGraph));
 
        instantDataFilter->connectOutput(temporalFilter, 0);
 
+       if (buildWorkflowGraph)
+       {
+         int filterOut = instantDataFilter->getFilterId();
+         int filterIn = (std::static_pointer_cast<COutputPin>(temporalFilter))->getFilterId();
+         CWorkflowGraph::mapFieldToFilters[this->getId()].push_back(filterOut);
+         CWorkflowGraph::mapFieldToFilters[this->getId()].push_back(filterIn);
+         CWorkflowGraph::mapFilters[filterOut] = getInstantDataFilter()->GetName();
+         CWorkflowGraph::mapFilters[filterIn] = temporalFilter->GetName();
+       }
+
        it = temporalDataFilters.insert(std::make_pair(outFreq, temporalFilter)).first;
      }
-
      return it->second;
    }
@@ -1367 +1418 @@
 
        const bool detectMissingValues = (!detect_missing_value.isEmpty() && detect_missing_value == true);
+       const bool buildWorkflowGraph = (!build_workflow_graph.isEmpty() && build_workflow_graph == true);
        std::shared_ptr<CTemporalFilter> temporalFilter(new CTemporalFilter(gc, operation,
-                                                                             CContext::getCurrent()->getCalendar()->getInitDate(),
-                                                                             freq_op, freq_offset, outFreq, detectMissingValues));
+                                                                           CContext::getCurrent()->getCalendar()->getInitDate(),
+                                                                           freq_op, freq_offset, outFreq,
+                                                                           detectMissingValues, buildWorkflowGraph));
 
        selfReferenceFilter->connectOutput(temporalFilter, 0);
+       if (buildWorkflowGraph)
+
+       {
+         int filterOut = selfReferenceFilter->getFilterId();
+         int filterIn = (std::static_pointer_cast<COutputPin>(temporalFilter))->getFilterId();
+         CWorkflowGraph::mapFieldToFilters[this->getId()].push_back(filterOut);
+         CWorkflowGraph::mapFieldToFilters[this->getId()].push_back(filterIn);
+         CWorkflowGraph::mapFilters[filterOut] = selfReferenceFilter->GetName();
+         CWorkflowGraph::mapFilters[filterIn] = temporalFilter->GetName();
+       }
+
        return temporalFilter ;
      }

XIOS/dev/dev_olga/src/node/field.hpp

@@ -7 +7 @@
 #include "functor.hpp"
 #include "functor_type.hpp"
+#include "filter.hpp"
 #include "duration.hpp"
 #include "date.hpp"
@@ -243 +244 @@
          bool hasTimeCentered;
 
-
          DECLARE_REF_FUNC(Field,field)
 

XIOS/dev/dev_olga/src/node/field_impl.hpp

@@ -17 +17 @@
   template <int N>
   void CField::setData(const CArray<double, N>& _data)
+  TRY
   {
     if (clientSourceFilter)
@@ -27 +28 @@
             << "Impossible to receive data from the model for a field [ id = " << getId() << " ] with a reference or an arithmetic operation.");
   }
+  CATCH_DUMP_ATTR
 
   template <int N>
   void CField::getData(CArray<double, N>& _data) const
+  TRY
   {
     if (storeFilter)
@@ -45 +48 @@
     }
   }
+  CATCH
 } // namespace xios
 

XIOS/dev/dev_olga/src/node/grid.hpp

@@ -205 +205 @@
          bool hasTransform();
          size_t getGlobalWrittenSize(void) ;
-//         void getLocalMask(CArray<bool,1>& localMask) ;
-//         template<int N>
-//         void getLocalMask(const CArray<bool,N>& gridMask, CArray<bool,1>& localMask) ;
       public:
          CArray<int, 1> storeIndex_client;
@@ -377 +374 @@
    template <int n>
    void CGrid::inputField(const CArray<double,n>& field, CArray<double,1>& stored) const
+   TRY
    {
 //#ifdef __XIOS_DEBUG
@@ -388 +386 @@
       this->storeField_arr(field.dataFirst(), stored);
    }
+   CATCH
 
    template <int n>
@@ -405 +404 @@
    template <int n>
    void CGrid::outputField(const CArray<double,1>& stored, CArray<double,n>& field) const
+   TRY
    {
 //#ifdef __XIOS_DEBUG
@@ -416 +416 @@
       this->restoreField_arr(stored, field.dataFirst());
    }
+   CATCH
 
    /*!
@@ -425 +426 @@
    template <int N>
    void CGrid::uncompressField(const CArray<double,N>& data, CArray<double,1>& outData) const
+   TRY
    {      
      uncompressField_arr(data.dataFirst(), outData);
    }
+   CATCH
 
    template<int N>
@@ -435 +438 @@
                              const CArray<int,1>& axisDomainOrder,
                              bool createMask)
+   TRY
    {
      int idx = 0;
@@ -530 +534 @@
     }
    }
+   CATCH_DUMP_ATTR
 
    template<int N>
@@ -535 +540 @@
                                   const std::vector<int>& eachDimSize,
                                   bool newValue)
+   TRY
    {
       if (N != eachDimSize.size())
@@ -549 +555 @@
       gridMask = newValue;
    }
+   CATCH_DUMP_ATTR
                                  
 
@@ -558 +565 @@
    template<int N>
    void CGrid::modifyGridMask(CArray<bool,N>& gridMask, const CArray<int,1>& indexToModify, bool valueToModify)
+   TRY
    {     
      int num = indexToModify.numElements();
@@ -565 +573 @@
      }
    }
+   CATCH_DUMP_ATTR
+
    ///--------------------------------------------------------------
 
 
-/*!
-  A grid can have multiple dimension, so can its mask in the form of multi-dimension array.
-It's not a good idea to store all multi-dimension arrays corresponding to each mask.
-One of the ways is to convert this array into 1-dimension one and every process is taken place on it.
-  \param [in] multi-dimension array grid mask
-*/
-//template<int N>
-//void CGrid::getLocalMask(const CArray<bool,N>& gridMask, CArray<bool,1>& localMask)
-//{
-//  if (gridMask.isEmpty()) return ;
-//  int dim = gridMask.dimensions();
-//  std::vector<int> dimensionSizes(dim);
-//  for (int i = 0; i < dim; ++i) dimensionSizes[i] = gridMask.extent(i);
-//
-//  std::vector<int> idxLoop(dim,0);
-//  int ssize = gridMask.numElements(), idx = 0;
-//  localMask.resize(ssize);
-//  while (idx < ssize)
-//  {
-//    for (int i = 0; i < dim-1; ++i)
-//    {
-//      if (idxLoop[i] == dimensionSizes[i])
-//      {
-//        idxLoop[i] = 0;
-//        ++idxLoop[i+1];
-//      }
-//    }
-//
-//    int maskIndex = idxLoop[0];
-//    int mulDim = 1;
-//    for (int k = 1; k < dim; ++k)
-//    {
-//      mulDim *= dimensionSizes[k-1];
-//      maskIndex += idxLoop[k]*mulDim;
-//    }
-//    localMask(maskIndex) = *(gridMask.dataFirst()+maskIndex);
-//
-//    ++idxLoop[0];
-//    ++idx;
-//  }
-//}
 
    // Declare/Define CGridGroup and CGridDefinition

XIOS/dev/dev_olga/src/node/interpolate_domain.cpp

@@ -65 +65 @@
     if (this->read_write_convention.isEmpty()) this->read_write_convention.setValue(read_write_convention_attr::fortran);
 
+
   }
 

XIOS/dev/dev_olga/src/transformation/domain_algorithm_zoom.cpp

@@ -113 +113 @@
   domainDest_->data_ni.setValue(niDest);
   domainDest_->data_nj.setValue(njDest);
-  domainDest_->data_ibegin.setValue(0);  // local position
-  domainDest_->data_jbegin.setValue(0);  // local position
-  domainDest_->data_i_index.resize(niDest*njDest); // local position
-  domainDest_->data_j_index.resize(niDest*njDest); // local position
+  domainDest_->data_ibegin.setValue(0);
+  domainDest_->data_jbegin.setValue(0);
+  domainDest_->data_i_index.resize(niDest*njDest);
+  domainDest_->data_j_index.resize(niDest*njDest);
 
   domainDest_->domainMask.resize(niDest*njDest);

XIOS/dev/dev_olga/src/transformation/generic_algorithm_transformation.hpp

@@ -87 +87 @@
   */
   void computeIndexSourceMapping(const std::vector<CArray<double,1>* >& dataAuxInputs = std::vector<CArray<double,1>* >());
-//  void computeTransformationMappingNonDistributed(int elementPositionInGrid, CGrid* gridSrc, CGrid* gridDst,
-//                                                  vector<int>& localSrc, vector<int>& localDst, vector<double>& weight, vector<bool>& localMaskOnGridDest);
   void computeTransformationMappingNonDistributed(int elementPositionInGrid, CGrid* gridSrc, CGrid* gridDst,
                                                   vector<int>& localSrc, vector<int>& localDst, vector<double>& weight, int& nbLocalIndexOnGridDest);

XIOS/dev/dev_olga/src/transformation/grid_transformation.cpp

@@ -413 +413 @@
         int nbLocalIndexOnGridDest;
         CTimer::get("computeTransformationMappingNonDistributed").resume();  
-//        algo->computeTransformationMappingNonDistributed(elementPosition, gridSource_, tmpGridDestination_,
-//                                                         localSrc, localDst, weight, localMaskOnGridDest_.back()) ;
         algo->computeTransformationMappingNonDistributed(elementPosition, gridSource_, tmpGridDestination_, 
                                                          localSrc, localDst, weight, nbLocalIndexOnGridDest) ;

XIOS/dev/dev_olga/src/transformation/grid_transformation_factory_impl.hpp

@@ -110 +110 @@
 }
 
+
 }
 #endif // __XIOS_GRID_TRANSFORMATION_FACTORY_HPP__