Index: XIOS/dev/dev_ym/XIOS_COUPLING/src/config/interpolate_axis_attribute.conf
===================================================================
--- XIOS/dev/dev_ym/XIOS_COUPLING/src/config/interpolate_axis_attribute.conf	(revision 2121)
+++ XIOS/dev/dev_ym/XIOS_COUPLING/src/config/interpolate_axis_attribute.conf	(revision 2122)
@@ -3,2 +3,4 @@
 DECLARE_ATTRIBUTE(int, order)
 DECLARE_ATTRIBUTE(StdString, coordinate)
+DECLARE_ATTRIBUTE(StdString, coordinate_src)
+DECLARE_ATTRIBUTE(StdString, coordinate_dst)
Index: XIOS/dev/dev_ym/XIOS_COUPLING/src/node/interpolate_axis.cpp
===================================================================
--- XIOS/dev/dev_ym/XIOS_COUPLING/src/node/interpolate_axis.cpp	(revision 2121)
+++ XIOS/dev/dev_ym/XIOS_COUPLING/src/node/interpolate_axis.cpp	(revision 2122)
@@ -60,11 +60,32 @@
     }
 
+    if (!this->coordinate.isEmpty() && (!this->coordinate_src.isEmpty() || !this->coordinate_dst.isEmpty()))
+    {
+       ERROR("CInterpolateAxis::checkValid(CAxis* axisSrc)",
+               << "<coordinate> is incompatible with <coordinate_src> or <coordinate_dst> attributes. <coordinate> attribute is present only for backward"
+               << "compatibility and is now declared obsolete") ;
+    }
 
     if (!this->coordinate.isEmpty())
     {
-      StdString coordinate = this->coordinate.getValue();
       if (!CField::has(coordinate))
         ERROR("CInterpolateAxis::checkValid(CAxis* axisSrc)",
                << "Coordinate field whose id " << coordinate << "does not exist "
+               << "Please define one");
+    }
+
+    if (!this->coordinate_src.isEmpty())
+    {
+      if (!CField::has(coordinate_src))
+        ERROR("CInterpolateAxis::checkValid(CAxis* axisSrc)",
+               << "Coordinate field whose id " << coordinate_src << "does not exist "
+               << "Please define one");
+    }
+
+    if (!this->coordinate_dst.isEmpty())
+    {
+      if (!CField::has(coordinate_dst))
+        ERROR("CInterpolateAxis::checkValid(CAxis* axisSrc)",
+               << "Coordinate field whose id " << coordinate_dst << "does not exist "
                << "Please define one");
     }
@@ -74,9 +95,37 @@
   {
     std::vector<StdString> auxInputs;
+    
+    if (!this->coordinate.isEmpty() && (!this->coordinate_src.isEmpty() || !this->coordinate_dst.isEmpty()))
+    {
+       ERROR("std::vector<StdString> CInterpolateAxis::checkAuxInputs_()",
+               << "<coordinate> is incompatible with <coordinate_src> or <coordinate_dst> attributes. <coordinate> attribute is present only for backward"
+               << "compatibility and is now declared obsolete") ;
+    }
+
     if (!this->coordinate.isEmpty())
     {
       StdString coordinate = this->coordinate.getValue();
       if (!CField::has(coordinate))
-        ERROR("CInterpolateAxis::checkValid(CAxis* axisSrc)",
+        ERROR("std::vector<StdString> CInterpolateAxis::checkAuxInputs_()",
+               << "Coordinate field whose id " << coordinate << "does not exist "
+               << "Please define one");
+      auxInputs.push_back(coordinate);
+    }
+
+    if (!this->coordinate_src.isEmpty())
+    {
+      StdString coordinate = this->coordinate_src.getValue();
+      if (!CField::has(coordinate))
+        ERROR("std::vector<StdString> CInterpolateAxis::checkAuxInputs_()",
+               << "Coordinate field whose id " << coordinate << "does not exist "
+               << "Please define one");
+      auxInputs.push_back(coordinate);
+    }
+
+    if (!this->coordinate_dst.isEmpty())
+    {
+      StdString coordinate = this->coordinate_dst.getValue();
+      if (!CField::has(coordinate))
+        ERROR("std::vector<StdString> CInterpolateAxis::checkAuxInputs_()",
                << "Coordinate field whose id " << coordinate << "does not exist "
                << "Please define one");
@@ -97,7 +146,9 @@
                                                         std::map<int, int>& elementPositionInGridDst2DomainPosition)
   {
-    if (!coordinate.isEmpty())  return CAxisAlgorithmInterpolateCoordinate::create(isSource, gridDst,  gridSrc, this, elementPositionInGrid, 
-                                      elementPositionInGridSrc2ScalarPosition, elementPositionInGridSrc2AxisPosition, elementPositionInGridSrc2DomainPosition,
-                                      elementPositionInGridDst2ScalarPosition, elementPositionInGridDst2AxisPosition, elementPositionInGridDst2DomainPosition);
+    if (!coordinate.isEmpty() || !coordinate_src.isEmpty() || !coordinate_dst.isEmpty()) 
+       return CAxisAlgorithmInterpolateCoordinate::create(isSource, gridDst,  gridSrc, this, elementPositionInGrid, 
+              elementPositionInGridSrc2ScalarPosition, elementPositionInGridSrc2AxisPosition, elementPositionInGridSrc2DomainPosition,
+              elementPositionInGridDst2ScalarPosition, elementPositionInGridDst2AxisPosition, elementPositionInGridDst2DomainPosition);
+    
     else return CAxisAlgorithmInterpolate::create(isSource, gridDst,  gridSrc, this, elementPositionInGrid, 
                 elementPositionInGridSrc2ScalarPosition, elementPositionInGridSrc2AxisPosition, elementPositionInGridSrc2DomainPosition,
Index: XIOS/dev/dev_ym/XIOS_COUPLING/src/transformation/axis_algorithm/axis_algorithm_interpolate_coordinate.cpp
===================================================================
--- XIOS/dev/dev_ym/XIOS_COUPLING/src/transformation/axis_algorithm/axis_algorithm_interpolate_coordinate.cpp	(revision 2121)
+++ XIOS/dev/dev_ym/XIOS_COUPLING/src/transformation/axis_algorithm/axis_algorithm_interpolate_coordinate.cpp	(revision 2122)
@@ -55,6 +55,18 @@
   vector<string> CAxisAlgorithmInterpolateCoordinate::getAuxFieldId(void)
   {
-    if (hasCoordinate_) return vector<string>(1,coordinate_) ;
+    if (hasCoordinateSrc_ && hasCoordinateDest_) return {coordinateSrc_,coordinateDest_} ;
+    else if (hasCoordinateSrc_) return {coordinateSrc_} ;
+    else if (hasCoordinateDest_) return {coordinateDest_} ;
     else return vector<string>() ;
+  }
+  
+  bool CAxisAlgorithmInterpolateCoordinate::transformAuxField(int pos)
+  {
+    if (pos==0)
+    {
+      if (hasCoordinateSrc_) return true ;
+      else if(hasCoordinateDest_) return false ;
+    }
+    if (pos==1) return false ;
   }
 
@@ -69,16 +81,35 @@
     if (!interpAxis->coordinate.isEmpty())
     {
-      coordinate_ = interpAxis->coordinate.getValue();
+      coordinateSrc_ = interpAxis->coordinate.getValue();
       hasCoordinate_=true ;
-    }
-  
-    ngloSrc_=axisSource->n_glo ;
+      hasCoordinateSrc_=true ;
+    }
+
+    if (!interpAxis->coordinate_src.isEmpty())
+    {
+      coordinateSrc_ = interpAxis->coordinate_src.getValue();
+      hasCoordinate_=true ;
+      hasCoordinateSrc_=true ;
+    }
+
+    if (!interpAxis->coordinate_dst.isEmpty())
+    {
+      coordinateDest_ = interpAxis->coordinate_dst.getValue();
+      hasCoordinate_=true ;
+      hasCoordinateDest_=true ;
+    }
+
+    ngloSrc_=axisSource->n_glo ; 
     nDest_ =  axisDest_-> getLocalView(CElementView::WORKFLOW)->getSize() ;
-    CArray<double,1> coord ;
-    CLocalConnector destConnector(axisDest_->getLocalView(CElementView::FULL), axisDest_->getLocalView(CElementView::WORKFLOW)) ;
-    destConnector.computeConnector() ;
-    destConnector.transfer(axisDest_->value, coord) ;
-    destCoordinate_ = vector<double>(coord.dataFirst(), coord.dataFirst()+nDest_) ;
     
+    if (!hasCoordinateDest_)
+    {
+      CArray<double,1> coord ;
+      CLocalConnector destConnector(axisDest_->getLocalView(CElementView::FULL), axisDest_->getLocalView(CElementView::WORKFLOW)) ;
+      destConnector.computeConnector() ;
+      destConnector.transfer(axisDest_->value, coord) ;
+      destCoordinate_ = vector<double>(coord.dataFirst(), coord.dataFirst()+nDest_) ;
+    }
+
     CArray<size_t,1> globalIndex(ngloSrc_) ;
     for(int i=0;i<ngloSrc_;i++) 
@@ -93,4 +124,15 @@
 
     this->computeAlgorithm(axisSource->getLocalView(CElementView::WORKFLOW), axisSourceGlo.getView(CElementView::FULL)) ;
+
+    if (!hasCoordinateSrc_)
+    {
+      CArray<double,1> coord ;
+      CArray<double,1> coordGlo ;
+      CLocalConnector srcConnector(axisSrc_->getLocalView(CElementView::FULL), axisSrc_->getLocalView(CElementView::WORKFLOW)) ;
+      srcConnector.computeConnector() ;
+      srcConnector.transfer(axisSrc_->value, coord) ; // full view value -> workflow value
+      transferTransformConnector_ -> transfer(coord, coordGlo) ; // workflow view -> full global view
+      srcCoordinate_ = vector<double>(coordGlo.dataFirst(), coordGlo.dataFirst()+ngloSrc_) ;
+    }
   }
   CATCH
@@ -98,5 +140,6 @@
   CTransformFilter* CAxisAlgorithmInterpolateCoordinate::createTransformFilter(CGarbageCollector& gc, CGridAlgorithm* algo, bool detectMissingValues, double defaultValue)
   {
-    return new CTransformFilter(gc, 2, algo, detectMissingValues, defaultValue) ;  
+    if (hasCoordinateSrc_ && hasCoordinateDest_) return new CTransformFilter(gc, 3, algo, detectMissingValues, defaultValue) ;
+    else return new CTransformFilter(gc, 2, algo, detectMissingValues, defaultValue) ;  
   }
 
@@ -105,14 +148,20 @@
   {
     CArray<double,1> dataInTmp;
-    CArray<double,1> auxDataInTmp ;
+    CArray<double,1> auxDataInSrc ;
     transferTransformConnector_ -> transfer(dimBefore, dimAfter, dataIn, dataInTmp) ;
-    transferTransformConnector_ -> transfer(dimBefore, dimAfter, auxDataIn[0], auxDataInTmp) ;
-  
+    if (hasCoordinateSrc_)  transferTransformConnector_ -> transfer(dimBefore, dimAfter, auxDataIn[0], auxDataInSrc) ;
+
+   
     dataOut.resize(dimBefore*dimAfter*nDest_) ;
-    const double* pressure = auxDataInTmp.dataFirst() ;
+    const double* pressureSrc ;
+    const double* pressureDest ;
+    if (hasCoordinateSrc_)  pressureSrc = auxDataInSrc.dataFirst() ;
+    if (hasCoordinateDest_ && hasCoordinateSrc_) pressureDest = auxDataIn[1].dataFirst() ;
+    else if (hasCoordinateDest_ && !hasCoordinateSrc_ ) pressureDest = auxDataIn[0].dataFirst() ;
+    
     const double* in = dataInTmp.dataFirst() ;
     double* out = dataOut.dataFirst() ;
 
-    size_t sliceSrc = dimAfter*ngloSrc_ ;
+    size_t sliceSrc  = dimAfter*ngloSrc_ ;
     size_t sliceDest = dimAfter*nDest_ ;
     vector<double> srcCoordinate(ngloSrc_) ;
@@ -123,24 +172,90 @@
     std::vector<int> destIndex(nDest_);
 
-    size_t nsrc ;
+    size_t nsrc, nDest ;
+
     for(size_t j=0, posJsrc=0, posJdest=0 ;  j<dimBefore ; j++, posJsrc+=sliceSrc, posJdest+=sliceDest )
       for(size_t k=0, posKsrc=posJsrc, posKdest=posJdest ; k<dimAfter ; k++, posKsrc++,posKdest++)
       {
-        nsrc=0 ;
-        for(size_t i=0, posIsrc=posKsrc, posIdest=posKdest ; i<ngloSrc_ ; i++, posIsrc+=dimAfter, posIdest+=dimAfter)
-        {
-          if ( !( std::isnan(pressure[posIsrc]) || std::isnan(in[posIsrc]) ) )
-          {
-            srcCoordinate[nsrc]=pressure[posIsrc] ;
-            srcValue[nsrc] = in[posIsrc] ;
-            nsrc++ ;
-          }
-        }
-        destCoordinate = destCoordinate_ ;    
-        computeInterp(nsrc, srcCoordinate, srcValue, srcIndex, nDest_, destCoordinate, destValue, destIndex) ;
-
-        for(size_t i=0, posIdest=posKdest ; i<nDest_ ; i++, posIdest+=dimAfter)  out[posIdest] = destValue[i] ;
+        if (hasCoordinateSrc_)
+        {
+          nsrc=0 ;
+          for(size_t i=0, posIsrc=posKsrc, posIdest=posKdest ; i<ngloSrc_ ; i++, posIsrc+=dimAfter, posIdest+=dimAfter)
+          {
+            if ( !( std::isnan(pressureSrc[posIsrc]) || std::isnan(in[posIsrc]) ) )
+            {
+              srcCoordinate[nsrc]=pressureSrc[posIsrc] ;
+              srcValue[nsrc] = in[posIsrc] ;
+              nsrc++ ;
+            }
+          }
+        }
+        else
+        {
+          nsrc=0 ;
+          for(size_t i=0, posIsrc=posKsrc ; i<ngloSrc_ ; i++, posIsrc+=dimAfter)
+          {
+            if ( !( std::isnan(srcCoordinate_[i]) || std::isnan(in[posIsrc]) ) )
+            {
+              srcCoordinate[nsrc]=srcCoordinate_[i] ;
+              srcValue[nsrc] = in[posIsrc] ;
+              nsrc++ ;
+            }
+          }
+        }  
+
+        if (hasCoordinateDest_)
+        {
+          nDest=0 ;
+          for(size_t i=0, posIdest=posKdest ; i<nDest_ ; i++, posIdest+=dimAfter)
+          {
+            if ( !( std::isnan(pressureDest[posIdest]) ) )
+            {
+              destCoordinate[nDest]=pressureDest[posIdest] ;
+              nDest++ ;
+            }
+          }
+        }
+        else
+        {
+          nDest=0 ;
+          for(size_t i=0, posIdest=posKdest ; i<nDest_ ; i++, posIdest+=dimAfter)
+          {
+            if ( !( std::isnan(destCoordinate[i]) ) )
+            {
+              destCoordinate[nDest]=destCoordinate_[i] ;
+              nDest++ ;
+            }
+          }
+        }
+  
+        computeInterp(nsrc, srcCoordinate, srcValue, srcIndex, nDest, destCoordinate, destValue, destIndex) ;
+        
+        if (hasCoordinateDest_)
+        {
+          nDest=0 ;
+          for(size_t i=0, posIdest=posKdest ; i<nDest_ ; i++, posIdest+=dimAfter)  
+          {
+            if ( !( std::isnan(pressureDest[posIdest]) ) )  
+            {
+              out[posIdest] = destValue[nDest] ;
+              nDest++ ;
+            }
+            else out[posIdest] = std::numeric_limits<double>::quiet_NaN() ;
+          }
+        }
+        else
+        {
+          nDest=0 ;
+          for(size_t i=0, posIdest=posKdest ; i<nDest_ ; i++, posIdest+=dimAfter)  
+          {
+            if ( !( std::isnan(destCoordinate[i]) ) )  
+            {
+              out[posIdest] = destValue[nDest] ;
+              nDest++ ;
+            }
+            else out[posIdest] = std::numeric_limits<double>::quiet_NaN() ;
+          }
+        }
       }
-
   }
 
Index: XIOS/dev/dev_ym/XIOS_COUPLING/src/transformation/axis_algorithm/axis_algorithm_interpolate_coordinate.hpp
===================================================================
--- XIOS/dev/dev_ym/XIOS_COUPLING/src/transformation/axis_algorithm/axis_algorithm_interpolate_coordinate.hpp	(revision 2121)
+++ XIOS/dev/dev_ym/XIOS_COUPLING/src/transformation/axis_algorithm/axis_algorithm_interpolate_coordinate.hpp	(revision 2122)
@@ -32,4 +32,5 @@
   virtual ~CAxisAlgorithmInterpolateCoordinate() {}
   virtual vector<string> getAuxFieldId(void)  ;
+  virtual bool transformAuxField(int pos) ;
   virtual void apply(int dimBefore, int dimAfter, const CArray<double,1>& dataIn, 
                      const vector<CArray<double,1>>& auxDataIn, CArray<double,1>& dataOut) ;
@@ -43,6 +44,9 @@
   // Interpolation order
   int order_;
-  StdString coordinate_;
+  StdString coordinateSrc_; // pressure src
+  StdString coordinateDest_; // pressure dst
   bool hasCoordinate_=false ;
+  bool hasCoordinateSrc_=false ;
+  bool hasCoordinateDest_=false ;
 
   CAxis* axisSrc_=nullptr ;
@@ -50,5 +54,6 @@
   size_t ngloSrc_ ;
   size_t nDest_ ;
-  vector<double> destCoordinate_ ;
+  vector<double> srcCoordinate_  ; // src axis value
+  vector<double> destCoordinate_ ; // dst axis value
 
 public:
Index: XIOS/dev/dev_ym/XIOS_COUPLING/src/transformation/generic_algorithm_transformation.hpp
===================================================================
--- XIOS/dev/dev_ym/XIOS_COUPLING/src/transformation/generic_algorithm_transformation.hpp	(revision 2121)
+++ XIOS/dev/dev_ym/XIOS_COUPLING/src/transformation/generic_algorithm_transformation.hpp	(revision 2122)
@@ -41,5 +41,5 @@
     virtual void apply(int dimBefore, int dimAfter, const CArray<double,1>& dataIn, const vector<CArray<double,1>>& auxData, CArray<double,1>& dataOut) { abort() ;} //=0
     virtual bool isGenerateTransformation(void) { return false ;}
-
+    virtual bool transformAuxField(int pos) { return true ;}
     virtual vector<string> getAuxFieldId(void) ;
   protected :
Index: XIOS/dev/dev_ym/XIOS_COUPLING/src/transformation/grid_algorithm_generic.cpp
===================================================================
--- XIOS/dev/dev_ym/XIOS_COUPLING/src/transformation/grid_algorithm_generic.cpp	(revision 2121)
+++ XIOS/dev/dev_ym/XIOS_COUPLING/src/transformation/grid_algorithm_generic.cpp	(revision 2122)
@@ -64,5 +64,9 @@
 
     gridTransformConnector_->transfer(dataIn, dataOutTmp) ;
-    for (int i=0; i<auxData.size();i++)  gridTransformConnector_->transfer(auxData[i], auxDataOutTmp[i]) ;
+    for (int i=0; i<auxData.size();i++)  
+    {
+      if (algorithm_->transformAuxField(i)) gridTransformConnector_->transfer(auxData[i], auxDataOutTmp[i]) ;
+      else auxDataOutTmp[i].reference(auxData[i]) ;
+    }
 
     algorithm_->apply(dimBefore_, dimAfter_, dataOutTmp, auxDataOutTmp, dataOut) ;
