Index: /XMLIO_V2/dev/dev_rv/Makefile.wk
===================================================================
--- /XMLIO_V2/dev/dev_rv/Makefile.wk	(revision 266)
+++ /XMLIO_V2/dev/dev_rv/Makefile.wk	(revision 267)
@@ -345,8 +345,8 @@
 
 # Sources pour le traitement des noeuds xml (contenues dans le dossier node)
-NSOURCE  = axis domain field file grid context
+NSOURCE  = axis domain field file grid variable context
 
 # Sources pour les opÃ©rations Ã Â effectuer sur les champs (contenues dans le dossier functor)
-FSOURCE  = once instant average
+FSOURCE  = once instant average maximum minimum
 
 # Sources contenant les diffÃ©rents type de calendriers (contenues dans le dossier date)
@@ -417,5 +417,5 @@
 ELEMS_ALL = $(ELEMS_CPP) $(ELEMS_FOR)
               
-OBJECTS = $(addprefix $(OBJ_PATH)/, $(addsuffix .o, $(ELEMS_ALL))) $(OBJ_PATH)/impi_interface.o
+OBJECTS = $(addprefix $(OBJ_PATH)/, $(addsuffix .o, $(ELEMS_ALL)))
 ifeq ($(VERSION), 4)
 	OBJECTS = $(addprefix $(OBJ_PATH)/, $(addsuffix .o, $(ELEMS_ALL)))
Index: /XMLIO_V2/dev/dev_rv/src/xmlio/buffer_pair.cpp
===================================================================
--- /XMLIO_V2/dev/dev_rv/src/xmlio/buffer_pair.cpp	(revision 266)
+++ /XMLIO_V2/dev/dev_rv/src/xmlio/buffer_pair.cpp	(revision 267)
@@ -1,5 +1,5 @@
 #include "buffer_pair.hpp"
 
-#include "impi_interface.hpp"
+#include "mpi_manager.hpp"
 
 namespace xmlioserver
@@ -11,5 +11,5 @@
          : com_client_server(com_client_server) 
          , first(BUFFER_CLIENT_SIZE), second(BUFFER_CLIENT_SIZE)
-         , first_request(mpi_request_null), second_request(mpi_request_null)
+         , first_request(MPI_REQUEST_NULL), second_request(MPI_REQUEST_NULL)
          , currentBuffer(0)
       { /* Ne rien faire de plus */ }
@@ -23,9 +23,9 @@
       {
          if ((currentBuffer  ==  0) && (first.getUsedSize()  != 0) &&
-            ((second_request == mpi_request_null) || CMPIManager::Test (second_request)))
+            ((second_request == MPI_REQUEST_NULL) || CMPIManager::Test (second_request)))
              return (true);
              
          if ((currentBuffer  ==  1) && (second.getUsedSize() != 0) &&
-            ((first_request  == mpi_request_null) || CMPIManager::Test (first_request)))
+            ((first_request  == MPI_REQUEST_NULL) || CMPIManager::Test (first_request)))
             return (true);
             
@@ -35,10 +35,10 @@
       //---------------------------------------------------------------
       
-      int CBufferPair::wait(void)
+      MPI_Request CBufferPair::wait(void)
       {
          if (this->currentBuffer == 0)
          {
             CMPIManager::Wait(this->second_request);
-            this->second_request = mpi_request_null;
+            this->second_request = MPI_REQUEST_NULL;
             return (this->second_request);
          }
@@ -46,5 +46,5 @@
          {
             CMPIManager::Wait(this->first_request);
-            this->first_request = mpi_request_null;
+            this->first_request = MPI_REQUEST_NULL;
             return (this->first_request);
          }
@@ -60,5 +60,5 @@
                (this->com_client_server, 0, this->first, this->first_request);
             this->currentBuffer  =  1;
-            this->second_request = mpi_request_null;
+            this->second_request = MPI_REQUEST_NULL;
             this->second.clear();
          }
@@ -68,5 +68,5 @@
                (this->com_client_server, 0, this->second, this->second_request);
             this->currentBuffer =  0;
-            this->first_request = mpi_request_null;
+            this->first_request = MPI_REQUEST_NULL;
             this->first.clear();
          }
Index: /XMLIO_V2/dev/dev_rv/src/xmlio/buffer_pair.hpp
===================================================================
--- /XMLIO_V2/dev/dev_rv/src/xmlio/buffer_pair.hpp	(revision 266)
+++ /XMLIO_V2/dev/dev_rv/src/xmlio/buffer_pair.hpp	(revision 267)
@@ -38,5 +38,5 @@
             
             /// Traitements divers ///
-            int wait(void);
+            MPI_Request wait(void);
             void sendCurrentBuffer(void); 
                         
@@ -54,5 +54,5 @@
             MPIComm com_client_server;
             CLinearBuffer first, second;
-            MPIRequest first_request, second_request;
+            MPI_Request first_request, second_request;
             int currentBuffer;
 
Index: LIO_V2/dev/dev_rv/src/xmlio/config/method_attribute.conf
===================================================================
--- /XMLIO_V2/dev/dev_rv/src/xmlio/config/method_attribute.conf	(revision 266)
+++ 	(revision )
@@ -1,1 +1,0 @@
-
Index: /XMLIO_V2/dev/dev_rv/src/xmlio/config/node_type.conf
===================================================================
--- /XMLIO_V2/dev/dev_rv/src/xmlio/config/node_type.conf	(revision 266)
+++ /XMLIO_V2/dev/dev_rv/src/xmlio/config/node_type.conf	(revision 267)
@@ -19,11 +19,11 @@
 #endif //__XMLIO_CGrid__
 
-#ifdef __XMLIO_CMethod__
-   DECLARE_NODE(Method, method)
-#endif //__XMLIO_CMethod__
+//#ifdef __XMLIO_CMethod__
+//   DECLARE_NODE(Method, method)
+//#endif //__XMLIO_CMethod__
 
-#ifdef __XMLIO_CVar__
-   DECLARE_NODE(Var   , var   )
-#endif //__XMLIO_CVar__
+#ifdef __XMLIO_CVariable__
+   DECLARE_NODE(Variable, variable)
+#endif //__XMLIO_CVariable__
 
 #ifdef __XMLIO_CContext__
Index: /XMLIO_V2/dev/dev_rv/src/xmlio/data_treatment.hpp
===================================================================
--- /XMLIO_V2/dev/dev_rv/src/xmlio/data_treatment.hpp	(revision 266)
+++ /XMLIO_V2/dev/dev_rv/src/xmlio/data_treatment.hpp	(revision 267)
@@ -130,5 +130,5 @@
             boost::shared_ptr<CField> field = *it;
             boost::shared_ptr<CFile>  file  = field->getRelFile();
-//            std::cout << ">> " << fieldId << ", " << file->getId() << std::endl;
+//  std::cout << ">> " << fieldId << ", " << file->getId() << std::endl;
             if (field->updateData(currDate, timestep, data))
             {
Index: /XMLIO_V2/dev/dev_rv/src/xmlio/exception.hpp
===================================================================
--- /XMLIO_V2/dev/dev_rv/src/xmlio/exception.hpp	(revision 266)
+++ /XMLIO_V2/dev/dev_rv/src/xmlio/exception.hpp	(revision 267)
@@ -46,5 +46,5 @@
    "In file \'" __FILE__ "\', line " << __LINE__ << " -> " x << std::endl;
 
-#ifdef XIOS_DEBUG
+#ifdef __XIOS_DEBUG
 #  define DEBUG(x) std::clog << "> Debug " << INFO(x)
 #else
Index: LIO_V2/dev/dev_rv/src/xmlio/fortran/impi_interface.f90
===================================================================
--- /XMLIO_V2/dev/dev_rv/src/xmlio/fortran/impi_interface.f90	(revision 266)
+++ 	(revision )
@@ -1,185 +1,0 @@
-MODULE IMPI_INTERFACE
-   USE ISO_C_BINDING
-
-include "mpif.h"
-
-   INTEGER (kind = C_INT ), BIND(C, NAME = "mpi_success" )      :: xios_mpi_success      = MPI_SUCCESS
-   INTEGER (kind = C_INT ), BIND(C, NAME = "mpi_comm_world" )   :: xios_mpi_comm_world   = MPI_COMM_WORLD
-   INTEGER (kind = C_INT ), BIND(C, NAME = "mpi_char" )         :: xios_mpi_char         = MPI_CHARACTER
-   INTEGER (kind = C_INT ), BIND(C, NAME = "mpi_status_size" )  :: xios_mpi_status_size  = MPI_STATUS_SIZE
-   INTEGER (kind = C_INT ), BIND(C, NAME = "mpi_any_tag" )      :: xios_mpi_any_tag      = MPI_ANY_TAG
-   INTEGER (kind = C_INT ), BIND(C, NAME = "mpi_request_null" ) :: xios_mpi_request_null = MPI_REQUEST_NULL
-
-   CONTAINS
-
-   ! Initialiser MPI
-   SUBROUTINE xios_mpi_init(err) BIND(C, NAME ="mpi_init")
-      INTEGER  (kind = C_INT) :: err
-      CALL MPI_INIT(err)
-   END SUBROUTINE xios_mpi_init
-
-   ! Quitter MPI
-   SUBROUTINE xios_mpi_finalize(err) BIND(C, NAME ="mpi_finalize")
-      INTEGER  (kind = C_INT) :: err
-      CALL MPI_FINALIZE(err)
-   END SUBROUTINE xios_mpi_finalize
-
-   ! Quitter brutalement MPI
-   SUBROUTINE xios_mpi_abort(comm, errcode, err) BIND(C, NAME ="mpi_abort")
-      INTEGER  (kind = C_INT) :: comm, errcode, err
-      CALL MPI_ABORT(comm, errcode, err)
-   END SUBROUTINE xios_mpi_abort
-
-   ! Savoir si un processus Ã  fait un MPI_INIT
-   SUBROUTINE xios_mpi_initialized(flag, err) BIND(C, NAME ="mpi_initialized")
-      LOGICAL (kind = C_BOOL) :: flag
-      INTEGER (kind = C_INT)  :: err
-      LOGICAL                 :: cflag
-      cflag = flag
-      CALL MPI_INITIALIZED(cflag, err)
-   END SUBROUTINE xios_mpi_initialized
-
-   ! RÃ©cupÃ©rer la chaine de caractÃšres associÃ©e au code d'erreur err
-   SUBROUTINE xios_mpi_error_string(errcode, chaine, taille_chaine, err) &
-                                    BIND(C, NAME ="mpi_error_string")
-      INTEGER (kind = C_INT)                 :: errcode, taille_chaine, err
-      CHARACTER(kind = C_CHAR), DIMENSION(*) :: chaine
-      CHARACTER(len = taille_chaine)         :: cchaine
-      CALL MPI_ERROR_STRING(errcode, cchaine, taille_chaine, err)
-      chaine(taille_chaine) = cchaine
-   END SUBROUTINE xios_mpi_error_string
-
-   ! Envoyer un message Ã  un processus
-   SUBROUTINE xios_mpi_send(buf, count, datatype, dest, tag, comm, err) &
-                            BIND(C, NAME ="mpi_send")
-      CHARACTER(kind = C_CHAR), DIMENSION(*) :: buf
-      INTEGER (kind = C_INT)                 :: dest, count, datatype, tag, comm, err
-      CALL MPI_SEND(buf, count, datatype, dest, tag, comm, err)
-   END SUBROUTINE xios_mpi_send
-
-   ! Recevoir un message d'un processus
-   SUBROUTINE xios_mpi_recv(buf, count, datatype, source, &
-                            tag, comm, status, err)       &
-                            BIND(C, NAME ="mpi_recv")
-      CHARACTER(kind = C_CHAR), DIMENSION(*)              :: buf
-      INTEGER (kind = C_INT)                              :: count, datatype, source, tag, comm, err
-      INTEGER (kind = C_INT) , DIMENSION(mpi_status_size) :: status
-      CALL MPI_RECV(buf, count, datatype, source, tag, comm, status, err)
-   END SUBROUTINE xios_mpi_recv
-
-   ! Envoyer et recevoir un message
-   SUBROUTINE xios_mpi_sendrecv(sendbuf, sendcount, sendtype, dest, sendtag, recvbuf, recvcount, &
-                                recvtype, source, recvtag, comm, status, err) &
-                                BIND(C, NAME ="mpi_sendrecv")
-      CHARACTER(kind = C_CHAR), DIMENSION(*) :: sendbuf, recvbuf
-      INTEGER (kind = C_INT)                 :: sendcount, sendtype, dest, sendtag, recvcount, &
-                                                recvtype, source, recvtag, comm, err
-      INTEGER (kind = C_INT) , DIMENSION(mpi_status_size) :: status
-      CALL MPI_SENDRECV(sendbuf, sendcount, sendtype, dest, sendtag, recvbuf, &
-                        recvcount, recvtype, source, recvtag, comm, status, err)
-   END SUBROUTINE xios_mpi_sendrecv
-
-   ! Compter le nombre d'Ã©lÃ©ments reÃ§us
-   SUBROUTINE xios_mpi_get_count(status, datatype, count, err) BIND(C, NAME ="mpi_get_count")
-      INTEGER (kind = C_INT)                 :: datatype, count, err
-      INTEGER (kind = C_INT) , DIMENSION(mpi_status_size) :: status
-      
-      ! ATTTENTION GROS BUG ICI  SOUS GNU MAIS PAS INTEL ???????? voir datatype
-      ! PRINT *, datatype, MPI_CHARACTER, xios_mpi_char
-      CALL MPI_GET_COUNT(status, MPI_CHARACTER, count, err)
-   END SUBROUTINE xios_mpi_get_count
-
-   ! Tester l'arrivÃ©e d'un message
-   SUBROUTINE xios_mpi_iprobe(source, tag, comm, flag, status, err) BIND(C, NAME ="mpi_iprobe")
-      INTEGER (kind = C_INT) :: source, tag, comm, err
-      INTEGER (kind = C_INT) , DIMENSION(mpi_status_size) :: status
-      LOGICAL (kind = C_BOOL) :: flag
-      CALL MPI_IPROBE(source, tag, comm, flag, status, err)
-   END SUBROUTINE xios_mpi_iprobe
-
-   ! Nombre de processus dans un intracommunicateur
-   SUBROUTINE xios_mpi_comm_size(comm, nbre, err) BIND(C, NAME ="mpi_comm_size")
-      INTEGER (kind = C_INT)  :: comm, nbre, err
-      CALL MPI_COMM_SIZE(comm, nbre, err)
-   END SUBROUTINE xios_mpi_comm_size
-
-   ! Rang d'un processus dans un intracommunicateur
-   SUBROUTINE xios_mpi_comm_rank(comm, rang, err) BIND(C, NAME ="mpi_comm_rank")
-      INTEGER (kind = C_INT)  :: comm, rang, err
-      CALL MPI_COMM_RANK(comm, rang, err )
-   END SUBROUTINE xios_mpi_comm_rank
-
-   ! Partage d'un communicateur
-   SUBROUTINE xios_mpi_comm_split(comm, couleur, cle, newcomm, err) BIND(C, NAME ="mpi_comm_split")
-      INTEGER (kind = C_INT)  :: comm, couleur, cle, newcomm, err
-      CALL MPI_COMM_SPLIT(comm, couleur, cle, newcomm, err)
-   END SUBROUTINE xios_mpi_comm_split
-
-   ! Commencer Ã  envoyer un message
-   SUBROUTINE xios_mpi_issend(buf, count, datatype, dest, tag, comm, request, err) &
-                            BIND(C, NAME ="mpi_issend")
-      CHARACTER(kind = C_CHAR), DIMENSION(*) :: buf
-      INTEGER (kind = C_INT)                 :: count, datatype, tag, comm, request, err, dest
-      CALL MPI_ISSEND(buf, count, datatype, dest, tag, comm, request, err)
-   END SUBROUTINE xios_mpi_issend
-
-   ! Commencer Ã  recevoir un message
-   SUBROUTINE xios_mpi_irecv(buf, count, datatype, source, &
-                            tag, comm, request, err)       &
-                            BIND(C, NAME ="mpi_irecv")
-      CHARACTER(kind = C_CHAR), DIMENSION(*)              :: buf
-      INTEGER (kind = C_INT)                              :: count, datatype, source, tag, &
-                                                             comm, request, err
-      CALL MPI_IRECV(buf, count, datatype, source, tag, comm, request, err)
-   END SUBROUTINE xios_mpi_irecv
-
-   ! ComplÃ©ter une opÃ©ration non bloquante
-   SUBROUTINE xios_mpi_wait(request, status, err) BIND(C, NAME ="mpi_wait")
-      INTEGER (kind = C_INT)                              :: request, err
-      INTEGER (kind = C_INT) , DIMENSION(mpi_status_size) :: status
-      CALL MPI_WAIT(request, status, err)
-   END SUBROUTINE xios_mpi_wait
-
-   ! Tester une opÃ©ration non bloquante
-   SUBROUTINE xios_mpi_test(request, flag, status, err) BIND(C, NAME ="mpi_test")
-      INTEGER (kind = C_INT)                              :: request, err
-      INTEGER (kind = C_INT) , DIMENSION(mpi_status_size) :: status
-      LOGICAL (kind = C_BOOL)                             :: flag
-      LOGICAL                                             :: cflag
-      cflag = flag
-      CALL MPI_TEST(request, cflag, status, err)
-   END SUBROUTINE xios_mpi_test
-
-   ! CrÃ©ation d'un communicateur Ã  partir d'un groupe
-   SUBROUTINE xios_mpi_comm_create(comm, group, newcomm, err) BIND(C, NAME ="mpi_comm_create")
-      INTEGER (kind = C_INT) :: comm, group, newcomm, err
-      CALL MPI_COMM_CREATE(comm, group, newcomm, err)
-   END SUBROUTINE xios_mpi_comm_create
-
-   ! Obtention d'une groupe Ã  partir d'un communicateur
-   SUBROUTINE xios_mpi_comm_group(comm, group, err) BIND(C, NAME ="mpi_comm_group")
-      INTEGER (kind = C_INT) :: comm, group, err
-      CALL MPI_COMM_GROUP(comm, group, err)
-   END SUBROUTINE xios_mpi_comm_group
-
-   ! CrÃ©ation de sous-groupe
-   SUBROUTINE xios_mpi_group_incl(group, n, rank, newgroup, err) BIND(C, NAME ="mpi_group_incl")
-      INTEGER (kind = C_INT) :: group, n,  newgroup, err
-      INTEGER (kind = C_INT) , DIMENSION(*) :: rank
-      CALL MPI_GROUP_INCL(group, n, rank, newgroup, err)
-   END SUBROUTINE xios_mpi_group_incl
-
-   ! BarriÃšre
-   SUBROUTINE xios_mpi_barrier (comm, err) BIND (C, NAME ="mpi_barrier")
-      INTEGER (kind = C_INT) :: comm, err
-      CALL MPI_BARRIER(comm, err)
-   END SUBROUTINE xios_mpi_barrier
-
-   ! Collecte de donnÃ©es et rediffusion
-   SUBROUTINE xios_mpi_allgather(sendbuf, sendcount, recvbuf, recvcount, comm, ierror) BIND (C, NAME ="mpi_allgather")
-      INTEGER (kind = C_INT), DIMENSION(*) :: sendbuf, recvbuf
-      INTEGER (kind = C_INT)               :: sendcount, recvcount, comm, ierror
-       CALL MPI_ALLGATHER(sendbuf, sendcount, MPI_INTEGER, recvbuf, recvcount, MPI_INTEGER, comm, ierror)
-   END SUBROUTINE xios_mpi_allgather
-
-END MODULE IMPI_INTERFACE
Index: LIO_V2/dev/dev_rv/src/xmlio/fortran/impi_interface.hpp
===================================================================
--- /XMLIO_V2/dev/dev_rv/src/xmlio/fortran/impi_interface.hpp	(revision 266)
+++ 	(revision )
@@ -1,89 +1,0 @@
-#ifndef __MPI_INTERFACE__
-#define __MPI_INTERFACE
-
-#ifdef __cplusplus
-extern"C"
-{
-#endif //__cplusplus
-
-/// Groupe ///
-extern int mpi_comm_world;
-extern int mpi_success;
-extern int mpi_char;
-extern int mpi_status_size;
-extern int mpi_any_tag;
-extern int mpi_request_null;
-
-
-/// Initialisation / Finalisation ///
-void mpi_init(int * err);
-void mpi_finalize(int * err);
-
-/// Quitter brutalement MPI ///
-void mpi_abort(int * comm, int * errcode, int * err);
-
-/// Savoir si un processus Ã  fait un MPI_INIT ///
-void mpi_initialized(bool * flag, int * err);
-
-/// RÃ©cupÃ©rer la chaine de caractÃšres associÃ©e au code d'erreur err(non fonctionnelle) ///
-void mpi_error_string(int * errcode, char chaine[], int * taille_chaine, int * err);
-
-/// Envoyer un message Ã  un processus ///
-void mpi_send(char buf[], int * count, int * datatype, int * dest, int * tag, int * comm, int * err);
-
-/// Recevoir un message d'un processus ///
-void mpi_recv(char buf[], int * count, int * datatype, int * source,  int * tag, int * comm, int status[], int * err);
-
-/// Envoyer et recevoir un message ///
-void mpi_sendrecv(char sendbuf[], int * sendcount, int * sendtype, int * dest, int * sendtag, int recvbuf[], int * recvcount,
-                  int * recvtype, char source[], int * recvtag, int * comm, int status[], int * err) ;
-
-/// Compter le nombre d'Ã©lÃ©ments reÃ§us ///
-void mpi_get_count(int status[], int * datatype, int * count, int * err);
-
-/// Tester l'arrivÃ©e d'un message ///
-void mpi_iprobe(int * source, int * tag, int * comm, bool * flag, int status[], int * err);
-
-/// Nombre de processus dans un intracommunicateur ///
-void mpi_comm_size(int * comm, int * nbre, int * err);
-
-/// Rang d'un processus dans un intracommunicateur ///
-void mpi_comm_rank(int * comm, int * rang, int * err);
-
-/// Partage d'un communicateur ///
-void mpi_comm_split(int * comm, int * couleur, int * cle, int * newcomm, int * err);
-
-/// Commencer Ã  envoyer un message ///
-void mpi_issend(char * buf, int * count, int * datatype, int * dest,
-                int * tag, int * comm, int * request, int * err);
-
-/// Commencer Ã  recevoir un message ///
-void mpi_irecv(char buf[], int * count, int * datatype, int * source,
-                            int * tag, int * comm, int * request, int * err);
-
-/// ComplÃ©ter une opÃ©ration non bloquante ///
-void mpi_wait(int * request, int status[], int * err);
-
-/// Tester une opÃ©ration non bloquante ///
-void mpi_test(int * request, bool * flag, int status[], int * err);
-
-/// CrÃ©ation d'un communicateur Ã  partir d'un groupe ///
-void mpi_comm_create(int * comm, int * group, int * newcomm, int * err);
-
-/// Obtention d'un groupe Ã  partir d'un communicateur ///
-void mpi_comm_group(int * comm, int * group, int * err);
-
-/// CrÃ©ation de sous-groupe ///
-void mpi_group_incl(int * group, int * n, const int rank[], int * newgroup, int * err);
-
-/// BarriÃšre ///
-void mpi_barrier(int * comm, int * err);
-
-/// Collecte de donnÃ©es et rediffusion ///
-void mpi_allgather(int sendbuf[], int * sendcount, int recvbuf[], int * recvcount, int * comm, int * ierror);
-
-#ifdef __cplusplus
-}
-#endif //__cplusplus
-
-#endif //__MPI_INTERFACE__
Index: /XMLIO_V2/dev/dev_rv/src/xmlio/iface/interface.cpp.in
===================================================================
--- /XMLIO_V2/dev/dev_rv/src/xmlio/iface/interface.cpp.in	(revision 266)
+++ /XMLIO_V2/dev/dev_rv/src/xmlio/iface/interface.cpp.in	(revision 267)
@@ -369,5 +369,5 @@
       if ((comm_client_server != -1))
       {
-         MPIRequest request = 0;
+         MPI_Request request = 0;
          StdOStringStream ostrs;
          if (CMPIManager::GetCommRank(comm_client_server) == 1)
Index: /XMLIO_V2/dev/dev_rv/src/xmlio/main_server.cpp
===================================================================
--- /XMLIO_V2/dev/dev_rv/src/xmlio/main_server.cpp	(revision 266)
+++ /XMLIO_V2/dev/dev_rv/src/xmlio/main_server.cpp	(revision 267)
@@ -18,13 +18,20 @@
       MPIComm comm_client, comm_client_server, comm_server;
       //comm::CMPIManager::Initialise(&argc, &argv); // < seulement en mode connectÃ©
+      
+      //CTreeManager::ParseFile  ("test/iodef_simple_test.xml");
+      //CTreeManager::PrintTreeToFile("wk/def/test.xml");
+     
       //comm::CMPIManager::Finalize();               // < seulement en mode connectÃ©
 
       CXIOSManager::Initialise (CXIOSManager::CLIENT_SERVER, &argc, &argv);
-      //CXIOSManager::AddClient ("nemo"    , 4, 2, &nemo_fake_entry);
+      
+      //----------------------------------------------------------------------
+      //CXIOSManager::AddClient("nemo"    , 4, 2, &nemo_fake_entry);
       //CXIOSManager::AddClient("orchidee", 1, 1, &orchidee_fake_entry);
       //CXIOSManager::AddClient("lmdz"    , 4, 2, &lmdz_fake_entry);
+      
       CMPIManager::DispatchClient(true, comm_client, comm_client_server,  comm_server);
       CXIOSManager::RunServer("Nemo", comm_client_server, comm_server);
-      //CXIOSManager::RunClientServer (comm::CMPIManager::GetCommWorld ());
+      //CXIOSManager::RunClientServer (comm::CMPIManager::GetCommWorld ());     
       CXIOSManager::Finalize ();
    }
Index: /XMLIO_V2/dev/dev_rv/src/xmlio/manager/mpi_manager.cpp
===================================================================
--- /XMLIO_V2/dev/dev_rv/src/xmlio/manager/mpi_manager.cpp	(revision 266)
+++ /XMLIO_V2/dev/dev_rv/src/xmlio/manager/mpi_manager.cpp	(revision 267)
@@ -1,321 +1,302 @@
+/* ************************************************************************** *
+ *      Copyright Â© IPSL/LSCE, XMLIOServer, Avril 2010 - Octobre 2011         *
+ * ************************************************************************** */
+ 
+ /**
+ * \file    mpi_interface.cpp
+ * \brief   Gestion des communications MPI via une surcouche interne (implÃ©mentation).
+ * \author  HervÃ© Ozdoba
+ * \version 0.4
+ * \date    28 Juin 2011
+ */
+ 
+// XMLIOServer headers
 #include "mpi_manager.hpp"
 
-#include "impi_interface.hpp"
-
-namespace xmlioserver
-{
-   namespace comm
-   {
-      /// ////////////////////// DÃ©finitions ////////////////////// ///
-
-      void CMPIManager::Initialise(int * UNUSED(argc), char *** UNUSED(argv))
+
+// /////////////////////////////// DÃ©finitions ////////////////////////////// //
+
+namespace xmlioserver {
+namespace comm {
+
+   // ---------------------- Initialisation & Finalisation ---------------------
+
+   void CMPIManager::Initialise(int * _argc, char *** _argv)
+   {
+      int flag = 0;
+      if (MPI_Initialized(&flag) != MPI_SUCCESS)
+         ERROR("CMPIManager::Initialise(arc, argv)", << " MPI Error !");
+      if (!flag)
       {
-         int error = 0;
-         bool flag = false;
-
-         mpi_initialized(&flag, &error);
-         if (error != mpi_success)
-            ERROR("CMPIManager::Initialise(arc, argv)", << " MPI Error !");
-         if (!flag)
-         {
-            mpi_init(&error);
-            if (error != mpi_success)
-               ERROR("CMPIManager::Initialise(arc, argv)", << " MPI Error !");
-         }
-      }
-
-      void CMPIManager::Finalize(void)
-      {
-         int error = 0;
-         mpi_finalize(&error);
-         if (error != mpi_success)
+         if (MPI_Init(_argc, _argv) != MPI_SUCCESS)
             ERROR("CMPIManager::Initialise(arc, argv)", << " MPI Error !");
       }
 
-      ///--------------------------------------------------------------
-
-      int CMPIManager::GetCommRank(MPIComm comm)
+   }
+   
+   void CMPIManager::Finalize(void)
+   {
+      if (MPI_Finalize() != MPI_SUCCESS)
+         ERROR("CMPIManager::Finalize(void)", << " MPI Error !");
+   }
+   
+   // ------------------------------ Communicateurs ----------------------------
+   
+   int CMPIManager::GetCommRank(MPI_Comm _comm)
+   {
+      int rank = 0;
+      if (MPI_Comm_rank(_comm, &rank) != MPI_SUCCESS)
+         ERROR("CMPIManager::GetCommRank(comm)", << " MPI Error !");
+      return (rank);
+   }
+   
+   int CMPIManager::GetCommSize(MPI_Comm _comm)
+   {
+      int size = 0;
+      if (MPI_Comm_size(_comm, &size) != MPI_SUCCESS)
+         ERROR("CMPIManager::GetCommSize(comm)", << " MPI Error !");
+      return (size);
+   }
+   
+   MPI_Comm CMPIManager::CreateComm(MPI_Group _group, MPI_Comm _pcomm)
+   {
+      MPI_Comm commu;      
+      if (MPI_Comm_create(_pcomm, _group, &commu) != MPI_SUCCESS)
+         ERROR("CMPIManager::CreateComm(group, pcomm)", << " MPI Error !");
+      return (commu);
+   }
+   
+   //MPI_Comm CMPIManager::GetCommWorld(void)
+   //{
+   //   return (MPI_COMM_WORLD); 
+   //}
+   
+   // ---------------------------------- Autre ---------------------------------
+         
+   void CMPIManager::Barrier(MPI_Comm _comm)
+   {
+      if (MPI_Barrier(_comm) != MPI_SUCCESS)
+         ERROR("CMPIManager::Barrier(comm)", << " MPI Error !");
+   }
+   
+   bool CMPIManager::DispatchClient(bool       _is_server,
+                                    MPI_Comm & _comm_client,
+                                    MPI_Comm & _comm_client_server,
+                                    MPI_Comm & _comm_server,
+                                    MPI_Comm   _comm_parent)
+   {
+      int value = (_is_server) ? 1 : 2;
+      std::size_t nbClient = 0, nbServer = 0, nbClientByServer = 0;
+      std::vector<int> info, rank_client, rank_server;
+      CMPIManager::AllGather(value, info, _comm_parent);
+
+      for (std::size_t s = 0;  s < info.size(); s++)
       {
-         int rank = 0, error = 0;
-         mpi_comm_rank(&comm, &rank, &error);
-         if (error != mpi_success)
-            ERROR("CMPIManager::GetCommRank(comm)", << " MPI Error !");
-         return (rank);
+         if (info[s] == 1) rank_server.push_back(s);
+         else rank_client.push_back(s);
       }
-
-      int CMPIManager::GetCommSize(MPIComm comm)
+      nbClient = rank_client.size();
+      nbServer = rank_server.size();
+      
+      if (nbClient == 0)
+         ERROR("CMPIManager::DispatchClient()", << " Aucun client disponible !");
+         
+
+      _comm_client = CMPIManager::CreateComm(CMPIManager::CreateSubGroup(
+                     CMPIManager::GetGroupWorld(), rank_client), _comm_parent);
+
+      if (nbServer != 0)
       {
-         int size = 0, error = 0;
-         mpi_comm_size(&comm, &size, &error);
-         if (error != mpi_success)
-            ERROR("CMPIManager::GetCommSize(comm)", << " MPI Error !");
-         return (size);
+         std::size_t currentServer = 0;
+         nbClientByServer = nbClient/nbServer;
+         _comm_server = CMPIManager::CreateComm(CMPIManager::CreateSubGroup(
+                        CMPIManager::GetGroupWorld(), rank_server), _comm_parent);
+
+         //std::cout << nbClient << "," << nbServer  << "," << nbClientByServer << std::endl;
+
+         for (std::size_t mm = 0; mm < nbClient; mm += nbClientByServer)
+         {
+            std::vector<int> group_rank;
+            group_rank.push_back(rank_server[currentServer++]);
+            for (std::size_t nn = 0; nn < nbClientByServer; nn++)
+               group_rank.push_back(rank_client[nn+mm]);
+            MPI_Comm comm_client_server_ = CMPIManager::CreateComm(CMPIManager::CreateSubGroup(
+                                           CMPIManager::GetGroupWorld(), group_rank), _comm_parent);
+
+            if (std::find(group_rank.begin(), group_rank.end(),
+                         CMPIManager::GetCommRank(_comm_parent)) != group_rank.end())
+            {
+               _comm_client_server = comm_client_server_;
+            }
+               
+            group_rank.clear();
+         }
+         return (true);
       }
-
-      MPIComm CMPIManager::GetCommWorld(void)
-      { 
-         return (mpi_comm_world); 
+      else
+      {
+         _comm_server = _comm_client;
+         return (false);
       }
-
-      bool CMPIManager::IsMaster(MPIComm comm)
-      { 
-         return (CMPIManager::GetCommRank(comm) == 0); 
-      }
-
-      bool CMPIManager::IsRank(MPIComm comm, int rank)
-      { 
-         return (CMPIManager::GetCommRank(comm) == rank); 
-      }
-
-      MPIComm CMPIManager::CreateComm(MPIGroup group, MPIComm pcomm)
-      {
-         MPIComm  commu = 0;
-         int error = 0;
-         mpi_comm_create(&pcomm, &group, &commu, &error);
-         if (error != mpi_success)
-            ERROR("CMPIManager::CreateComm(group, pcomm)", << " MPI Error !");
-         return (commu);
-      }
-
-      //---------------------------------------------------------------
-
-      void CMPIManager::Barrier(MPIComm comm)
-      {
-         int error = 0;
-         mpi_barrier(&comm, &error);
-         if (error != mpi_success)
-            ERROR("CMPIManager::Barrier(comm)", << " MPI Error !");
-      }
-
-      bool CMPIManager::DispatchClient(bool      is_server,
-                                       MPIComm & comm_client,
-                                       MPIComm & comm_client_server,
-                                       MPIComm & comm_server,
-                                       MPIComm   comm_parent)
-      {
-         int value = (is_server) ? 1 : 2;
-         StdSize nbClient = 0, nbServer = 0, nbClientByServer = 0;
-         std::vector<int> info, rank_client, rank_server;
-         CMPIManager::AllGather(value, info, comm_parent);
-
-         for (StdSize s = 0;  s < info.size(); s++)
-         {
-            if (info[s] == 1) rank_server.push_back(s);
-            else rank_client.push_back(s);
-         }
-         nbClient = rank_client.size();
-         nbServer = rank_server.size();
-         
-
-         comm_client = CMPIManager::CreateComm(CMPIManager::CreateSubGroup(
-                       CMPIManager::GetGroupWorld(), rank_client), comm_parent);
-
-         if (nbServer != 0)
-         {
-            StdSize currentServer = 0;
-            nbClientByServer = nbClient/nbServer;
-            comm_server = CMPIManager::CreateComm(CMPIManager::CreateSubGroup(
-                          CMPIManager::GetGroupWorld(), rank_server), comm_parent);
-
-            //std::cout << nbClient << "," << nbServer  << "," << nbClientByServer << std::endl;
-
-            for (StdSize mm = 0; mm < nbClient; mm += nbClientByServer)
-            {
-               std::vector<int> group_rank;
-               group_rank.push_back(rank_server[currentServer++]);
-               for (StdSize nn = 0; nn < nbClientByServer; nn++)
-                  group_rank.push_back(rank_client[nn+mm]);
-               MPIComm comm_client_server_ = CMPIManager::CreateComm(CMPIManager::CreateSubGroup(
-                                             CMPIManager::GetGroupWorld(), group_rank), comm_parent);
-
-               if (std::find(group_rank.begin(), group_rank.end(), CMPIManager::GetCommRank()) != group_rank.end())
-               {
-                  comm_client_server = comm_client_server_;
-               }
-               
-               group_rank.clear();
-            }
-            return (true);
-         }
-         else
-         {
-            comm_server = comm_client;
-            return (false);
-         }
-      }
-
-      //---------------------------------------------------------------
-
-      MPIGroup CMPIManager::GetGroupWorld(void)
-      {
-         MPIGroup group = 0;
-         int error = 0;
-         MPIComm  commu = CMPIManager::GetCommWorld();
-         mpi_comm_group(&commu, &group, &error);
-         if (error != mpi_success)
-            ERROR("CMPIManager::GetGroupWorld()", << " MPI Error !");
-         return (group);
-      }
-
-      MPIGroup CMPIManager::CreateSubGroup(MPIGroup pgroup, const std::vector<int> & ranks)
-      {
-         MPIGroup group = 0;
-         int size = ranks.size();
-         int error = 0;
-         mpi_group_incl(&pgroup, &size, &(ranks[0]), &group, &error);
-         if (error != mpi_success)
-            ERROR("CMPIManager::CreateSubGroup(pgroup, ranks)", << " MPI Error !");
-         return (group);
-      }
-
-      MPIGroup CMPIManager::CreateSubGroup(MPIGroup pgroup, int min_rank, int max_rank, int intval)
-      {
-         std::vector<int> ranks;
-         for (int i = min_rank; i <= max_rank; i += intval)
-            ranks.push_back(i);
-         return (CMPIManager::CreateSubGroup(pgroup, ranks));
-      }
-
-      //---------------------------------------------------------------
-
-      void CMPIManager::AllocMem(void * data, StdSize size)
-      {
-         if (MPI_Alloc_mem(sizeof(char) * size, MPI_INFO_NULL, data) != MPI_SUCCESS)
-            ERROR("CMPIManager::AllocMem(data, size)", << " MPI Error !");
-      }
-
-      void CMPIManager::FreeMem(void * data)
-      { 
-         MPI_Free_mem(data);
-      }
-
-      //--------------------------------------------------------------
-
-      void CMPIManager::Send (MPIComm comm, int dest_rank, char * data,
-                              StdSize size, MPIRequest & request)
-      {
-         MPIDataType type = mpi_char;
-         int nsize = size;
-         int tag = 0, error = 0;
-         mpi_issend(data, &nsize, &type, &dest_rank, &tag, &comm, &request, &error);
-         if (error != mpi_success)
-            ERROR("CMPIManager::Send (comm, dest_rank, data, size, request)", << " MPI Error !");
-      }
-
-      void CMPIManager::Wait (MPIRequest & request)
-      {
-         MPIStatus status = new int[mpi_status_size]();
-         int error = 0;
-         mpi_wait(&request, status, &error);
-         if (error != mpi_success)
-            ERROR("CMPIManager::Wait (request)", << " MPI Error !");
-         delete [] status;
-      }
-
-      bool CMPIManager::Test (MPIRequest & request)
-      {
-         MPIStatus status = new int[mpi_status_size]();
-         bool flag = false;
-         int error = 0;
-         mpi_test(&request, &flag, status, &error);
-         if (error != mpi_success)
-            ERROR("CMPIManager::Test (request)", << " MPI Error !");
-         delete [] status;
-         return (flag);
-      }
-
-      bool CMPIManager::HasReceivedData(MPIComm comm, int src_rank)
-      {
-         MPIStatus status = new int[mpi_status_size]();
-         bool flag = false;
-         int error = 0, tag = mpi_any_tag;
-         mpi_iprobe(&src_rank, &tag, &comm, &flag, status, &error);
-         if (error != mpi_success)
-            ERROR("CMPIManager::hasReceivedData (comm, rank)", << " MPI Error !");
-         delete [] status;
-         return (flag);
-      }
-
-      StdSize CMPIManager::GetReceivedDataSize(MPIComm comm, int src_rank)
-      {
-         MPIDataType type = mpi_char;
-         MPIStatus status = new int[mpi_status_size]();
-         bool flag = false;
-         int error = 0, size = 0, tag = mpi_any_tag;
-
-         mpi_iprobe(&src_rank, &tag, &comm, &flag, status, &error);
-         if (error != mpi_success)
-            ERROR("CMPIManager::getReceivedDataSize (comm, rank)", << " MPI Error !");
-         if (flag == false) return (0);        
-         mpi_get_count(status, &type, &size, &error);
-         if (error != mpi_success)
-            ERROR("CMPIManager::getReceivedDataSize (comm, rank)", << " MPI Error !");
-         delete [] status;
-         return (size);
-      }
-
-      void CMPIManager::Receive(MPIComm comm, int src_rank, char * data)
-      {
-         MPIRequest req = 0;
-         MPIDataType type = mpi_char;
-         int error = 0, tag = mpi_any_tag;
-         int size = CMPIManager::GetReceivedDataSize(comm, src_rank);
-
-         mpi_irecv(data, &size, &type, &src_rank, &tag, &comm, &req, &error);
-         if (error != mpi_success)
-            ERROR("CMPIManager::Receive (comm, src_rank, data)", << " MPI Error !");
-         CMPIManager::Wait (req); // Temporaire
-      }
-
-      void CMPIManager::AllGather(int indata, std::vector<int> & outdata, MPIComm comm)
-      {
-         std::vector<int> data; data.push_back(indata);
-         CMPIManager::AllGather(data, outdata, comm);
-      }
-
-      void  CMPIManager::AllGather(std::vector<int> & indata,
-                                   std::vector<int> & outdata, MPIComm comm)
-      {
-         int error = 0;
-         int sendcount = indata.size(), recvcount = indata.size() * CMPIManager::GetCommSize(comm);
-         outdata.resize(recvcount);
-         mpi_allgather(&(indata[0]), &sendcount, &(outdata[0]), &sendcount, &comm, &error);
-         if (error != mpi_success)
-            ERROR("CMPIManager::AllGather (indata, outdata, comm)", << " MPI Error !");
-      }
-
-      //--------------------------------------------------------------
-
-      void CMPIManager::SendLinearBuffer
-         (MPIComm comm, int dest_rank, CLinearBuffer & buff, MPIRequest & request)
-      {
-         CMPIManager::Send(comm, dest_rank, buff, buff.getUsedSize(), request);
-         buff.clear();
-      }
-
-      void CMPIManager::ReceiveLinearBuffer(MPIComm comm, int src_rank, CLinearBuffer & buff)
-      {
-         CMPIManager::Receive(comm, src_rank, buff);
-         buff.computeBufferData();
-      }
-
-      boost::shared_ptr<CLinearBuffer> CMPIManager::ReceiveLinearBuffer(MPIComm comm, int src_rank)
-      {
-         boost::shared_ptr<CLinearBuffer> buff_ptr
-            (new CLinearBuffer(CMPIManager::GetReceivedDataSize(comm, src_rank)));
-         CMPIManager::ReceiveLinearBuffer(comm, src_rank, *buff_ptr);
-         return (buff_ptr);
-      }
-
-      void CMPIManager::ReceiveCircularBuffer(MPIComm comm, int src_rank, CCircularBuffer & buff)
-      {
-         StdSize data_size  = CMPIManager::GetReceivedDataSize(comm, src_rank);
-         StdSize data_begin = buff.prepareNextDataPosition(data_size);
-         CMPIManager::Receive(comm, src_rank, buff.getData(data_begin));
-         buff.updateNbRequests(data_begin, data_begin + data_size);
-      }
-
-      ///--------------------------------------------------------------
-
-   } // namespace comm
+   }
+   
+
+   // --------------------------------- Groupes --------------------------------
+         
+   MPI_Group CMPIManager::GetGroupWorld(void)
+   {
+      MPI_Group group = 0;
+      if (MPI_Comm_group(MPI_COMM_WORLD, &group) != MPI_SUCCESS)
+         ERROR("CMPIManager::GetGroupWorld()", << " MPI Error !");
+      return (group);
+   }
+   
+   MPI_Group CMPIManager::CreateSubGroup(MPI_Group _pgroup, const std::vector<int> & _ranks)
+   {
+      MPI_Group group = 0;
+      if (MPI_Group_incl(_pgroup, _ranks.size(), const_cast<int*>(&(_ranks[0])), &group) != MPI_SUCCESS)
+         ERROR("CMPIManager::CreateSubGroup(pgroup, ranks)", << " MPI Error !");
+      return (group);
+   }
+   
+   MPI_Group CMPIManager::CreateSubGroup
+      (MPI_Group _pgroup, int _min_rank, int _max_rank, int _intval)
+   {
+      std::vector<int> ranks;
+      for (int i = _min_rank; i <= _max_rank; i += _intval)
+         ranks.push_back(i);
+      return (CMPIManager::CreateSubGroup(_pgroup, ranks));
+   }
+
+   // ----------------------------------- Tests --------------------------------
+         
+   bool CMPIManager::IsMaster(MPI_Comm _comm)
+   {
+      return (CMPIManager::GetCommRank(_comm) == 0); 
+   }
+   
+   bool CMPIManager::IsRank(int _rank, MPI_Comm _comm)
+   {
+      return (CMPIManager::GetCommRank(_comm) == _rank); 
+   }
+
+   // --------------------------- Communication simple -------------------------
+         
+   void CMPIManager::Send (MPI_Comm _comm, int _dest_rank, char * _data,
+                           std::size_t _size, MPI_Request & _request)
+   {
+      int nsize = _size;    
+      if (MPI_Issend(_data, nsize, MPI_CHAR, _dest_rank, 0, _comm, &_request) != MPI_SUCCESS)
+         ERROR("CMPIManager::Send (comm, dest_rank, data, size, request)", << " MPI Error !");
+   }
+   
+   void CMPIManager::Wait (MPI_Request & _request)
+   {
+      MPI_Status status;
+      if (MPI_Wait(&_request, &status) != MPI_SUCCESS)
+         ERROR("CMPIManager::Wait (request)", << " MPI Error !");
+   }
+   
+   bool CMPIManager::Test (MPI_Request & _request)
+   {
+      MPI_Status status;
+      int flag = 0;
+      if (MPI_Test(&_request, &flag, &status) != MPI_SUCCESS)
+         ERROR("CMPIManager::Test (request)", << " MPI Error !");
+      return (flag);
+   }
+
+   bool CMPIManager::HasReceivedData(MPI_Comm _comm, int _src_rank)
+   {
+      MPI_Status status;
+      int flag = 0;
+      if (MPI_Iprobe(_src_rank, MPI_ANY_TAG, _comm, &flag, &status) != MPI_SUCCESS)
+         ERROR("CMPIManager::HasReceivedData (comm, rank)", << " MPI Error !");
+      return (flag);
+   }
+   
+   std::size_t CMPIManager::GetReceivedDataSize(MPI_Comm _comm, int _src_rank)
+   {
+      MPI_Status status;
+      int flag = 0, size = 0;
+      if (MPI_Iprobe(_src_rank, MPI_ANY_TAG, _comm, &flag, &status) != MPI_SUCCESS)
+         ERROR("CMPIManager::getReceivedDataSize (comm, rank)", << " MPI Error !");
+      if (!flag) return (0);  
+      if (MPI_Get_count(&status, MPI_CHAR, &size) != MPI_SUCCESS)
+         ERROR("CMPIManager::getReceivedDataSize (comm, rank)", << " MPI Error !");
+
+      return (size);
+   }
+   
+   void CMPIManager::Receive(MPI_Comm _comm, int _src_rank, char * _data)
+   {
+      MPI_Request request = 0;
+      int size = CMPIManager::GetReceivedDataSize(_comm, _src_rank);
+      if (MPI_Irecv(_data, size, MPI_CHAR, _src_rank, MPI_ANY_TAG, _comm, &request) != MPI_SUCCESS)
+         ERROR("CMPIManager::Receive (comm, src_rank, data)", << " MPI Error !");
+      CMPIManager::Wait (request); // Temporaire
+   }
+   
+   void CMPIManager::AllGather(int _indata, std::vector<int> & _outdata, MPI_Comm _comm)
+   {
+      std::vector<int> data; data.push_back(_indata);
+      CMPIManager::AllGather(data, _outdata, _comm);
+   }
+
+   void  CMPIManager::AllGather(const std::vector<int> & _indata,
+                                      std::vector<int> & _outdata, MPI_Comm _comm)
+   {
+      int sendcount = _indata.size(),
+          recvcount = _indata.size() * CMPIManager::GetCommSize(_comm);
+      _outdata.resize(recvcount);     
+      if (MPI_Allgather ( const_cast<int*>(&(_indata[0])), sendcount, MPI_INTEGER,
+                                          &(_outdata[0]) , recvcount, MPI_INTEGER, _comm) != MPI_SUCCESS)
+         ERROR("CMPIManager::AllGather (indata, outdata, comm)", << " MPI Error !");
+   }
+         
+   // ------------------------- Communication 'complexe' -----------------------
+         
+   void CMPIManager::SendLinearBuffer(MPI_Comm _comm, int _dest_rank, CLinearBuffer & _lbuffer, MPI_Request & _request)
+   {
+      CMPIManager::Send(_comm, _dest_rank, _lbuffer, _lbuffer.getUsedSize(), _request);
+      _lbuffer.clear();
+   }
+   
+   void CMPIManager::ReceiveLinearBuffer(MPI_Comm _comm, int _src_rank, CLinearBuffer & _lbuffer)
+   {
+      CMPIManager::Receive(_comm, _src_rank, _lbuffer);
+      _lbuffer.computeBufferData();
+   }
+   
+   boost::shared_ptr<CLinearBuffer> CMPIManager::ReceiveLinearBuffer(MPI_Comm _comm, int _src_rank)
+   {
+      boost::shared_ptr<CLinearBuffer> buff_ptr
+         (new CLinearBuffer(CMPIManager::GetReceivedDataSize(_comm, _src_rank)));
+      CMPIManager::ReceiveLinearBuffer(_comm, _src_rank, *buff_ptr);
+      return (buff_ptr);
+   }
+   
+   void CMPIManager::ReceiveCircularBuffer(MPI_Comm _comm, int _src_rank, CCircularBuffer & _cbuffer)
+   {
+      std::size_t data_size  = CMPIManager::GetReceivedDataSize(_comm, _src_rank);
+      std::size_t data_begin = _cbuffer.prepareNextDataPosition(data_size);
+      CMPIManager::Receive(_comm, _src_rank, _cbuffer.getData(data_begin));
+      _cbuffer.updateNbRequests(data_begin, data_begin + data_size);
+   }
+
+   // ---------------------- MÃ©moire (non fonctionnel ....) --------------------
+         
+   void CMPIManager::AllocMemory(void * _data, std::size_t _size)
+   {
+      if (MPI_Alloc_mem(sizeof(char) * _size, MPI_INFO_NULL, _data) != MPI_SUCCESS)
+         ERROR("CMPIManager::AllocMem(data, size)", << " MPI Error !");
+   }
+   
+   void CMPIManager::FreeMemory (void * _data)
+   {
+      MPI_Free_mem(_data);
+   }
+
+} // namespace comm
 } // namespace xmlioserver
+
Index: /XMLIO_V2/dev/dev_rv/src/xmlio/manager/mpi_manager.hpp
===================================================================
--- /XMLIO_V2/dev/dev_rv/src/xmlio/manager/mpi_manager.hpp	(revision 266)
+++ /XMLIO_V2/dev/dev_rv/src/xmlio/manager/mpi_manager.hpp	(revision 267)
@@ -1,89 +1,184 @@
-#ifndef __XMLIO_CMPIManager__
-#define __XMLIO_CMPIManager__
+/* ************************************************************************** *
+ *      Copyright Â© IPSL/LSCE, XMLIOServer, Avril 2010 - Octobre 2011         *
+ * ************************************************************************** */
 
-/// MPI headers ///
+#ifndef __MPI_INTERFACE_HPP__
+#define __MPI_INTERFACE_HPP__
+
+/**
+ * \file    mpi_interface.hpp
+ * \brief   Gestion des communications MPI via une surcouche interne (entÃªte).
+ * \author  HervÃ© Ozdoba
+ * \version 0.4
+ * \date    28 Juin 2011
+ */
+
+#ifndef __XIOS_NO_EXTERN
+
+// M(essage) P(assing) I(nterface) headers
 #include <mpi.h>
 
-/// xmlioserver headers ///
+// C++ standard headers
+#include <vector>
+
+#endif //__XIOS_NO_EXTERN
+
+// XMLIOServer headers
 #include "xmlioserver_spl.hpp"
-#include "exception.hpp"
 #include "buffer.hpp"
 #include "circular_buffer.hpp"
 #include "linear_buffer.hpp"
 
+// ////////////////////////////// DÃ©clarations ///////////////////////////// //
+
 namespace xmlioserver
 {
+   /// \brief Espace de nommage pour les communications via la bibliothÃšque MPI.
    namespace comm
    {
-      /// ////////////////////// DÃ©clarations ////////////////////// ///
-      typedef MPI_Fint     MPIComm;
-      typedef MPI_Fint    MPIGroup;
-      typedef MPI_Fint  MPIRequest;
-      typedef MPI_Fint  *MPIStatus;
-      typedef MPI_Fint MPIDataType;
-
+      typedef MPI_Fint     MPIComm; /*!< \brief Identifiant de communicateur MPI (Fortran).   */
+      typedef MPI_Fint    MPIGroup; /*!< \brief Identifiant de groupe MPI (Fortran).          */
+      typedef MPI_Fint  MPIRequest; /*!< \brief Identifiant de requÃªte MPI (Fortran).         */
+      typedef MPI_Fint  *MPIStatus; /*!< \brief Identifiant de statut MPI (Fortran).          */
+      typedef MPI_Fint MPIDataType; /*!< \brief Identifiant de type de donnÃ©es MPI (Fortran). */
+      
+      /**
+       * \class CMPIManager
+       * \brief Surcouche interne de la bibliÃ othÃšque M(essage) P(assing) I(nterface).
+       */
       class CMPIManager
       {
-         public :
-
-            /// Initialisation & Finalisation ///
+         public : // Initialisation & Finalisation
+         
             static void Initialise(int * argc, char *** argv);
             static void Finalize(void);
 
-            /// Communicateurs ///
-            static int GetCommRank(MPIComm comm = CMPIManager::GetCommWorld());
-            static int GetCommSize(MPIComm comm = CMPIManager::GetCommWorld());
-            static MPIComm CreateComm(MPIGroup group, MPIComm pcomm = CMPIManager::GetCommWorld());
-            static MPIComm GetCommWorld(void);
+         public : // Communicateurs
+         
+         
+            static inline int GetCommRank(MPIComm _comm)            
+            { return (CMPIManager::GetCommRank(MPI_Comm_f2c(_comm))); }   
+                    
+            static inline int GetCommSize(MPIComm _comm)            
+            { return (CMPIManager::GetCommSize(MPI_Comm_f2c(_comm))); }
+            
+            static inline MPIComm GetCommWorld(void)            
+            { return (MPI_Comm_c2f(MPI_COMM_WORLD)); }
+            
+            static inline MPIComm CreateComm(MPI_Group _group, MPIComm _pcomm = CMPIManager::GetCommWorld())
+            { return (MPI_Comm_c2f(CMPIManager::CreateComm( _group, MPI_Comm_f2c(_pcomm)))); }     
+            
+            static int GetCommRank(MPI_Comm _comm = MPI_COMM_WORLD);
+            static int GetCommSize(MPI_Comm _comm = MPI_COMM_WORLD);       
+            
+            static MPI_Comm CreateComm(MPI_Group _group, MPI_Comm _pcomm);
 
-            /// Autre ///
-            static void Barrier(MPIComm comm = CMPIManager::GetCommWorld());
+         public : // Autre
+         
+            static void Barrier(MPI_Comm _comm = MPI_COMM_WORLD);
+            
+            static inline bool DispatchClient(bool       _is_server,
+                                              MPIComm & _comm_client,
+                                              MPIComm & _comm_client_server,
+                                              MPIComm & _comm_server,
+                                              MPIComm   _comm_parent =  CMPIManager::GetCommWorld())
+            {
+               MPI_Comm comm_client        = MPI_Comm_f2c(_comm_client);
+               MPI_Comm comm_client_server = MPI_Comm_f2c(_comm_client_server);
+               MPI_Comm comm_server        = MPI_Comm_f2c(_comm_server);
+               MPI_Comm comm_parent        = MPI_Comm_f2c(_comm_parent);
+               bool ret = CMPIManager::DispatchClient(_is_server, comm_client, comm_client_server, comm_server, comm_parent);
+               _comm_client        = MPI_Comm_c2f(comm_client);
+               _comm_client_server = MPI_Comm_c2f(comm_client_server);
+               _comm_server        = MPI_Comm_c2f(comm_server); 
+               return (ret);                          
+            }
+                                      
+            
+            static bool DispatchClient(bool       _is_server,
+                                       MPI_Comm & _comm_client,
+                                       MPI_Comm & _comm_client_server,
+                                       MPI_Comm & _comm_server,
+                                       MPI_Comm   _comm_parent = MPI_COMM_WORLD);
 
-            static bool DispatchClient(bool      is_server,
-                                       MPIComm & comm_client,
-                                       MPIComm & comm_client_server,
-                                       MPIComm & comm_server,
-                                       MPIComm   comm_parent = CMPIManager::GetCommWorld());
+         public : // Groupes
+         
+            static MPI_Group GetGroupWorld(void);
+            static MPI_Group CreateSubGroup(MPI_Group _pgroup, const std::vector<int> & _ranks);
+            static MPI_Group CreateSubGroup(MPI_Group _pgroup, int _min_rank, int _max_rank, int _intval = 1);
 
-            /// Groupes ///
-            static MPIGroup GetGroupWorld(void);
-            static MPIGroup CreateSubGroup(MPIGroup pgroup, const std::vector<int> & ranks);
-            static MPIGroup CreateSubGroup(MPIGroup pgroup, int min_rank, int max_rank, int intval = 1);
+         public : // Tests 
+         
+            static inline bool IsMaster(MPIComm _comm)
+            { return (CMPIManager::IsMaster(MPI_Comm_f2c(_comm))); }
+            
+            static inline bool IsRank(int _rank, MPIComm _comm)
+            { return (CMPIManager::IsRank(_rank, MPI_Comm_f2c(_comm))); }
+         
+            static bool IsMaster(MPI_Comm _comm = MPI_COMM_WORLD);
+            static bool IsRank(int _rank, MPI_Comm _comm = MPI_COMM_WORLD);
 
-            /// Tests ///
-            static bool IsMaster(MPIComm comm = CMPIManager::GetCommWorld());
-            static bool IsRank(MPIComm comm, int rank);
+         public : // Communication simple
+         
+            static void Send (MPI_Comm _comm, int _dest_rank, char * _data,
+                              std::size_t _size, MPI_Request & _request);
+            static void Wait (MPI_Request & _request);
+            static bool Test (MPI_Request & _request);
 
-            /// Communication simple///
-            static void Send (MPIComm comm, int dest_rank, char * data, StdSize size, MPIRequest & request);
-            static void Wait (MPIRequest & request);
-            static bool Test (MPIRequest & request);
 
-            static void AllGather(int indata, std::vector<int> & outdata,
-                                  MPIComm comm = CMPIManager::GetCommWorld());
+            static inline bool HasReceivedData(MPIComm _comm, int _src_rank)
+            { return (CMPIManager::HasReceivedData(MPI_Comm_f2c(_comm), _src_rank));  }
+            
+            static inline std::size_t GetReceivedDataSize(MPIComm _comm, int _src_rank)
+            { return (CMPIManager::GetReceivedDataSize(MPI_Comm_f2c(_comm), _src_rank)); }
+            
+            
+            
+            static bool HasReceivedData(MPI_Comm _comm, int _src_rank);
+            
+            static std::size_t GetReceivedDataSize(MPI_Comm _comm, int _src_rank);
+            static void Receive(MPI_Comm _comm, int _src_rank, char * _data);
+            
+            static void AllGather(int _indata, std::vector<int> & _outdata,
+                                  MPI_Comm _comm = MPI_COMM_WORLD);
 
-            static void AllGather(std::vector<int> & indata,
-                                  std::vector<int> & outdata,
-                                  MPIComm comm = CMPIManager::GetCommWorld());
+            static void AllGather(const std::vector<int> & _indata,
+                                        std::vector<int> & _outdata,
+                                  MPI_Comm _comm = MPI_COMM_WORLD);
 
-            static bool HasReceivedData(MPIComm comm, int src_rank);
-            static StdSize GetReceivedDataSize(MPIComm comm, int src_rank);
-            static void Receive(MPIComm comm, int src_rank, char * data);
 
-            /// Communication 'complexe' ///
-            static void SendLinearBuffer(MPIComm comm, int dest_rank, CLinearBuffer & buff, MPIRequest & request);
-            static void ReceiveLinearBuffer(MPIComm comm, int src_rank, CLinearBuffer & buff);
-            static boost::shared_ptr<CLinearBuffer> ReceiveLinearBuffer(MPIComm comm, int src_rank);
-            static void ReceiveCircularBuffer(MPIComm comm, int src_rank, CCircularBuffer & buff);
+         public : // Communication 'complexe'
+         
+            static inline void SendLinearBuffer(MPIComm _comm, int _dest_rank, CLinearBuffer & _lbuffer, MPI_Request & _request)
+            { CMPIManager::SendLinearBuffer(MPI_Comm_f2c(_comm), _dest_rank, _lbuffer, _request); }
+            
+            static inline void ReceiveLinearBuffer(MPIComm _comm, int _src_rank, CLinearBuffer & _lbuffer)
+            { CMPIManager::ReceiveLinearBuffer(MPI_Comm_f2c(_comm), _src_rank, _lbuffer); }
+            
+            static inline boost::shared_ptr<CLinearBuffer> ReceiveLinearBuffer(MPIComm _comm, int _src_rank)
+            { return (CMPIManager::ReceiveLinearBuffer(MPI_Comm_f2c(_comm), _src_rank)); }
+            
+            static inline void ReceiveCircularBuffer(MPIComm _comm, int _src_rank, CCircularBuffer & _cbuffer)
+            { CMPIManager::ReceiveCircularBuffer(MPI_Comm_f2c(_comm), _src_rank, _cbuffer); }
+            
+         
+            static void SendLinearBuffer(MPI_Comm _comm, int _dest_rank, CLinearBuffer & _lbuffer, MPI_Request & _request);
+            static void ReceiveLinearBuffer(MPI_Comm _comm, int _src_rank, CLinearBuffer & _lbuffer);
+            static boost::shared_ptr<CLinearBuffer> ReceiveLinearBuffer(MPI_Comm _comm, int _src_rank);
+            static void ReceiveCircularBuffer(MPI_Comm _comm, int _src_rank, CCircularBuffer & _cbuffer);
+            
+            
 
-            /// MÃ©moire (non fonctionnel ....)///
-            static void AllocMem(void * data, StdSize size);
-            static void FreeMem(void * data);
+         public : // MÃ©moire (non fonctionnel ....)
+         
+            static void AllocMemory(void * _data, std::size_t _size);
+            static void FreeMemory (void * _data);
+         
+      }; // class CMPIManager
+      
 
-      }; // class CMPIManager
-
+      
    } // namespace comm
 } // namespace xmlioserver
 
-#endif // __XMLIO_CMPIManager__
-
+#endif //__MPI_INTERFACE_HPP__
Index: /XMLIO_V2/dev/dev_rv/src/xmlio/node/context.cpp
===================================================================
--- /XMLIO_V2/dev/dev_rv/src/xmlio/node/context.cpp	(revision 266)
+++ /XMLIO_V2/dev/dev_rv/src/xmlio/node/context.cpp	(revision 267)
@@ -130,5 +130,5 @@
 #define DECLARE_NODE_PAR(Name_, name_)
 #include "node_type.conf"
-
+            std::cout << name << std::endl;
             DEBUG(<< "L'Ã©lÃ©ment nommÃ© \'"     << name
                   << "\' dans le contexte \'" << CObjectFactory::GetCurrentContextId()
Index: /XMLIO_V2/dev/dev_rv/src/xmlio/node/field.hpp
===================================================================
--- /XMLIO_V2/dev/dev_rv/src/xmlio/node/field.hpp	(revision 266)
+++ /XMLIO_V2/dev/dev_rv/src/xmlio/node/field.hpp	(revision 267)
@@ -84,8 +84,11 @@
          template <StdSize N>
             inline bool updateData
-               (const date::CDate & currDate, const date::CDuration & timestep, const ARRAY(double, N) data);
+               (const date::CDate      & currDate,
+                const date::CDuration  & timestep,
+                const ARRAY(double, N)   data);
 
          bool updateDataServer
-               (const date::CDate & currDate, const std::deque<ARRAY(double, 1)> storedClient);
+               (const date::CDate & currDate,
+                const std::deque<ARRAY(double, 1)> storedClient);
 
       public :
Index: /XMLIO_V2/dev/dev_rv/src/xmlio/node/node_type.hpp
===================================================================
--- /XMLIO_V2/dev/dev_rv/src/xmlio/node/node_type.hpp	(revision 266)
+++ /XMLIO_V2/dev/dev_rv/src/xmlio/node/node_type.hpp	(revision 267)
@@ -7,6 +7,5 @@
 #include "file.hpp"
 #include "grid.hpp"
-//#include "method.hpp"
-//#include "var.hpp"
+#include "variable.hpp"
 #include "context.hpp"
 
Index: LIO_V2/dev/dev_rv/src/xmlio/node/var.hpp
===================================================================
--- /XMLIO_V2/dev/dev_rv/src/xmlio/node/var.hpp	(revision 266)
+++ 	(revision )
@@ -1,102 +1,0 @@
-#ifndef __XMLIO_CVar__
-#define __XMLIO_CVar__
-
-namespace xmlioserver
-{
-   namespace tree
-   {
-      /// ////////////////////// DÃ©clarations ////////////////////// ///
-
-      class CVarGroup;
-      class CVarAttributes;
-      class CBaseVar;
-      class CVar;
-
-      ///--------------------------------------------------------------
-
-      // Declare/Define CVarAttribute
-      BEGIN_DECLARE_ATTRIBUTE_MAP(CVar)
-#include "var_attribute.conf"
-      END_DECLARE_ATTRIBUTE_MAP(CVar)
-
-      ///--------------------------------------------------------------
-
-      class CBaseVar
-      { // Declare CVar functionalities
-         public :
-
-            /// Constructeur et Destructeur ///
-            CBaseVar(void);
-            ~CBaseVar(void);
-
-      }; // class CBaseVar
-
-      ///--------------------------------------------------------------
-
-      class CVar
-         : public CObjectTemplate<CVar>
-         , public CVarAttributes
-         , public CBaseVar
-      {
-            /// typedef ///
-            typedef CObjectTemplate<CVar>   SuperClass;
-            typedef CVarAttributes SuperClassAttribute;
-            typedef CBaseVar       SuperClassBase;
-
-         public :
-
-            typedef CVarAttributes RelAttributes;
-            typedef CVarGroup      RelGroup;
-
-            /// Constructeurs ///
-            CVar(void);
-            explicit CVar(const StdString & id);
-            CVar(const CVar & var);       // Not implemented yet.
-            CVar(const CVar * const var); // Not implemented yet.
-
-            /// Destructeur ///
-            virtual ~CVar(void);
-
-            /// Accesseurs statiques ///
-            static inline StdString GetName(void);
-            static inline StdString GetDefName(void);
-
-      }; // class CVar
-
-      ///--------------------------------------------------------------
-
-      // Declare/Define CVarGroup and CVarDefinition
-      DECLARE_GROUP(CVar);
-
-      /// ////////////////////// DÃ©finitions ////////////////////// ///
-
-      CBaseVar::CBaseVar(void)
-      { /* Ne rien faire de plus */ }
-
-      CBaseVar::~CBaseVar(void)
-      { /* Ne rien faire de plus */ }
-
-      ///--------------------------------------------------------------
-
-      CVar::CVar(void)
-         : CObjectTemplate<CVar>()
-         , CVarAttributes()
-         , CBaseVar()
-      { /* Ne rien faire de plus */ }
-
-      CVar::CVar(const StdString & id)
-         : CObjectTemplate<CVar>(id)
-         , CVarAttributes()
-         , CBaseVar()
-      { /* Ne rien faire de plus */ }
-
-      CVar::~CVar(void)
-      { /* Ne rien faire de plus */ }
-
-      StdString CVar::GetName(void)   { return (StdString("var")); }
-      StdString CVar::GetDefName(void){ return (CVar::GetName()); }
-
-   } // namespace tree
-} // namespace xmlioserver
-
-#endif // __XMLIO_CVar__
Index: /XMLIO_V2/dev/dev_rv/src/xmlio/node/variable.cpp
===================================================================
--- /XMLIO_V2/dev/dev_rv/src/xmlio/node/variable.cpp	(revision 267)
+++ /XMLIO_V2/dev/dev_rv/src/xmlio/node/variable.cpp	(revision 267)
@@ -0,0 +1,33 @@
+#include "variable.hpp"
+
+#include "attribute_template_impl.hpp"
+#include "object_template_impl.hpp"
+#include "group_template_impl.hpp"
+
+#include "object_factory.hpp"
+#include "object_factory_impl.hpp"
+
+namespace xmlioserver {
+namespace tree {
+
+   /// ////////////////////// DÃ©finitions ////////////////////// ///
+
+   CVariable::CVariable(void)
+      : CObjectTemplate<CVariable>()
+      , CVariableAttributes()
+   { /* Ne rien faire de plus */ }
+
+   CVariable::CVariable(const StdString & id)
+      : CObjectTemplate<CVariable>(id)
+      , CVariableAttributes()
+   { /* Ne rien faire de plus */ }
+
+   CVariable::~CVariable(void)
+   { /* Ne rien faire de plus */ }
+
+   StdString CVariable::GetName(void)   { return (StdString("variable")); }
+   StdString CVariable::GetDefName(void){ return (CVariable::GetName()); }
+   ENodeType CVariable::GetType(void)   { return (eVariable); }
+
+} // namespace tree
+} // namespace xmlioserver
Index: /XMLIO_V2/dev/dev_rv/src/xmlio/node/variable.hpp
===================================================================
--- /XMLIO_V2/dev/dev_rv/src/xmlio/node/variable.hpp	(revision 267)
+++ /XMLIO_V2/dev/dev_rv/src/xmlio/node/variable.hpp	(revision 267)
@@ -0,0 +1,68 @@
+#ifndef __XMLIO_CVariable__
+#define __XMLIO_CVariable__
+
+/// xmlioserver headers ///
+#include "xmlioserver_spl.hpp"
+#include "declare_group.hpp"
+
+#include "data_output.hpp"
+
+namespace xmlioserver
+{
+   namespace tree
+   {
+      /// ////////////////////// DÃ©clarations ////////////////////// ///
+
+      class CVariableGroup;
+      class CVariableAttributes;
+      class CVariable;
+
+      ///--------------------------------------------------------------
+
+      // Declare/Define CVarAttribute
+      BEGIN_DECLARE_ATTRIBUTE_MAP(CVariable)
+#include "var_attribute.conf"
+      END_DECLARE_ATTRIBUTE_MAP(CVariable)
+
+      ///--------------------------------------------------------------
+
+      class CVariable
+         : public CObjectTemplate<CVariable>
+         , public CVariableAttributes
+      {
+            /// typedef ///
+            typedef CObjectTemplate<CVariable>   SuperClass;
+            typedef CVariableAttributes SuperClassAttribute;
+
+         public :
+
+            typedef CVariableAttributes RelAttributes;
+            typedef CVariableGroup      RelGroup;
+
+            /// Constructeurs ///
+            CVariable(void);
+            explicit CVariable(const StdString & id);
+            CVariable(const CVariable & var);       // Not implemented yet.
+            CVariable(const CVariable * const var); // Not implemented yet.
+
+            /// Destructeur ///
+            virtual ~CVariable(void);
+
+            /// Accesseurs statiques ///
+            static StdString GetName(void);
+            static StdString GetDefName(void);
+            static ENodeType GetType(void);
+
+      }; // class CVar
+
+      ///--------------------------------------------------------------
+
+      // Declare/Define CVarGroup and CVarDefinition
+      DECLARE_GROUP(CVariable);
+
+
+
+   } // namespace tree
+} // namespace xmlioserver
+
+#endif // __XMLIO_CVariable__
Index: /XMLIO_V2/dev/dev_rv/src/xmlio/output/nc4_data_output.cpp
===================================================================
--- /XMLIO_V2/dev/dev_rv/src/xmlio/output/nc4_data_output.cpp	(revision 266)
+++ /XMLIO_V2/dev/dev_rv/src/xmlio/output/nc4_data_output.cpp	(revision 267)
@@ -68,6 +68,4 @@
          
          if (domain->isEmpty()) return;
-
-         int dvm = 1;
 
          std::vector<StdString> dim0, dim1;
Index: /XMLIO_V2/dev/dev_rv/src4/xmlio/mpi/mpi_interface.cpp
===================================================================
--- /XMLIO_V2/dev/dev_rv/src4/xmlio/mpi/mpi_interface.cpp	(revision 266)
+++ /XMLIO_V2/dev/dev_rv/src4/xmlio/mpi/mpi_interface.cpp	(revision 267)
@@ -253,8 +253,31 @@
    // ------------------------- Communication 'complexe' -----------------------
          
-   //void SendLinearBuffer(MPIComm comm, int dest_rank, CLinearBuffer & buff, MPIRequest & request);
-   //void ReceiveLinearBuffer(MPIComm comm, int src_rank, CLinearBuffer & buff);
-   //boost::shared_ptr<CLinearBuffer> ReceiveLinearBuffer(MPIComm comm, int src_rank);
-   //void ReceiveCircularBuffer(MPIComm comm, int src_rank, CCircularBuffer & buff);
+   void CMPIManager::SendLinearBuffer(MPI_Comm _comm, int _dest_rank, CLinearBuffer & _lbuffer, MPI_Request & _request)
+   {
+      CMPIManager::Send(_comm, _dest_rank, _lbuffer, _lbuffer.getUsedSize(), _request);
+      buff.clear();
+   }
+   
+   void CMPIManager::ReceiveLinearBuffer(MPI_Comm _comm, int _src_rank, CLinearBuffer & _lbuffer)
+   {
+      CMPIManager::Receive(_comm, _src_rank, _lbuffer);
+      _lbuffer.computeBufferData();
+   }
+   
+   boost::shared_ptr<CLinearBuffer> CMPIManager::ReceiveLinearBuffer(MPI_Comm _comm, int _src_rank)
+   {
+      boost::shared_ptr<CLinearBuffer> buff_ptr
+         (new CLinearBuffer(CMPIManager::GetReceivedDataSize(_comm, _src_rank)));
+      CMPIManager::ReceiveLinearBuffer(_comm, _src_rank, *buff_ptr);
+      return (buff_ptr);
+   }
+   
+   void CMPIManager::ReceiveCircularBuffer(MPI_Comm _comm, int _src_rank, CCircularBuffer & _cbuffer)
+   {
+      std::size_t data_size  = CMPIManager::GetReceivedDataSize(_comm, _src_rank);
+      std::size_t data_begin = buff.prepareNextDataPosition(data_size);
+      CMPIManager::Receive(comm, src_rank, buff.getData(data_begin));
+      _cbuffer.updateNbRequests(data_begin, data_begin + data_size);
+   }
 
    // ---------------------- MÃ©moire (non fonctionnel ....) --------------------
Index: /XMLIO_V2/dev/dev_rv/src4/xmlio/mpi/mpi_interface.hpp
===================================================================
--- /XMLIO_V2/dev/dev_rv/src4/xmlio/mpi/mpi_interface.hpp	(revision 266)
+++ /XMLIO_V2/dev/dev_rv/src4/xmlio/mpi/mpi_interface.hpp	(revision 267)
@@ -100,8 +100,8 @@
          public : // Communication 'complexe'
          
-            // static void SendLinearBuffer(MPIComm comm, int dest_rank, CLinearBuffer & buff, MPIRequest & request);
-            // static void ReceiveLinearBuffer(MPIComm comm, int src_rank, CLinearBuffer & buff);
-            // static boost::shared_ptr<CLinearBuffer> ReceiveLinearBuffer(MPIComm comm, int src_rank);
-            // static void ReceiveCircularBuffer(MPIComm comm, int src_rank, CCircularBuffer & buff);
+            static void SendLinearBuffer(MPI_Comm _comm, int _dest_rank, CLinearBuffer & _lbuffer, MPI_Request & _request);
+            static void ReceiveLinearBuffer(MPI_Comm _comm, int _src_rank, CLinearBuffer & _lbuffer);
+            static boost::shared_ptr<CLinearBuffer> ReceiveLinearBuffer(MPI_Comm _comm, int _src_rank);
+            static void ReceiveCircularBuffer(MPI_Comm _comm, int _src_rank, CCircularBuffer & _cbuffer);
 
          public : // MÃ©moire (non fonctionnel ....)
