Index: /XIOS/trunk/extern/remap/src/libmapper.cpp
===================================================================
--- /XIOS/trunk/extern/remap/src/libmapper.cpp	(revision 1638)
+++ /XIOS/trunk/extern/remap/src/libmapper.cpp	(revision 1639)
@@ -43,5 +43,5 @@
   double* src_area=NULL ;
   double* dst_area=NULL ;
-  mapper = new Mapper(EP_COMM_WORLD);
+  mapper = new Mapper(MPI_COMM_WORLD);
   mapper->setVerbosity(PROGRESS) ;
   mapper->setSourceMesh(src_bounds_lon, src_bounds_lat, src_area, n_vert_per_cell_src, n_cell_src, src_pole ) ;
Index: /XIOS/trunk/extern/remap/src/mapper.cpp
===================================================================
--- /XIOS/trunk/extern/remap/src/mapper.cpp	(revision 1638)
+++ /XIOS/trunk/extern/remap/src/mapper.cpp	(revision 1639)
@@ -32,6 +32,6 @@
 
   int mpiRank, mpiSize;
-  ep_lib::MPI_Comm_rank(communicator, &mpiRank);
-  ep_lib::MPI_Comm_size(communicator, &mpiSize);
+  MPI_Comm_rank(communicator, &mpiRank);
+  MPI_Comm_size(communicator, &mpiSize);
 
   sourceElements.reserve(nbCells);
@@ -43,5 +43,5 @@
     long int offset ;
     long int nb=nbCells ;
-    ep_lib::MPI_Scan(&nb,&offset,1,EP_LONG,EP_SUM,communicator) ;
+    MPI_Scan(&nb,&offset,1,MPI_LONG,MPI_SUM,communicator) ;
     offset=offset-nb ;
     for(int i=0;i<nbCells;i++) sourceGlobalId[i]=offset+i ;
@@ -70,6 +70,6 @@
 
   int mpiRank, mpiSize;
-  ep_lib::MPI_Comm_rank(communicator, &mpiRank);
-  ep_lib::MPI_Comm_size(communicator, &mpiSize);
+  MPI_Comm_rank(communicator, &mpiRank);
+  MPI_Comm_size(communicator, &mpiSize);
 
   targetElements.reserve(nbCells);
@@ -81,5 +81,5 @@
     long int offset ;
     long int nb=nbCells ;
-    ep_lib::MPI_Scan(&nb,&offset,1,EP_LONG,EP_SUM,communicator) ;
+    MPI_Scan(&nb,&offset,1,MPI_LONG,MPI_SUM,communicator) ;
     offset=offset-nb ;
     for(int i=0;i<nbCells;i++) targetGlobalId[i]=offset+i ;
@@ -117,6 +117,6 @@
   vector<double> timings;
   int mpiSize, mpiRank;
-  ep_lib::MPI_Comm_size(communicator, &mpiSize);
-  ep_lib::MPI_Comm_rank(communicator, &mpiRank);
+  MPI_Comm_size(communicator, &mpiSize);
+  MPI_Comm_rank(communicator, &mpiRank);
 
   this->buildSSTree(sourceMesh, targetMesh);
@@ -173,6 +173,6 @@
 {
   int mpiSize, mpiRank;
-  ep_lib::MPI_Comm_size(communicator, &mpiSize);
-  ep_lib::MPI_Comm_rank(communicator, &mpiRank);
+  MPI_Comm_size(communicator, &mpiSize);
+  MPI_Comm_rank(communicator, &mpiRank);
 
   /* create list of intersections (super mesh elements) for each rank */
@@ -235,5 +235,5 @@
   /* communicate sizes of source elements to be sent (index lists and later values and gradients) */
   int *nbRecvElement = new int[mpiSize];
-  ep_lib::MPI_Alltoall(nbSendElement, 1, EP_INT, nbRecvElement, 1, EP_INT, communicator);
+  MPI_Alltoall(nbSendElement, 1, MPI_INT, nbRecvElement, 1, MPI_INT, communicator);
 
   /* communicate indices of source elements on other ranks whoes value and gradient we need (since intersection) */
@@ -246,11 +246,11 @@
   Coord **sendGrad = new Coord*[mpiSize];
   GloId **sendNeighIds = new GloId*[mpiSize];
-  ep_lib::MPI_Request *sendRequest = new ep_lib::MPI_Request[5*mpiSize];
-  ep_lib::MPI_Request *recvRequest = new ep_lib::MPI_Request[5*mpiSize];
+  MPI_Request *sendRequest = new MPI_Request[5*mpiSize];
+  MPI_Request *recvRequest = new MPI_Request[5*mpiSize];
   for (int rank = 0; rank < mpiSize; rank++)
   {
     if (nbSendElement[rank] > 0)
     {
-      ep_lib::MPI_Issend(sendElement[rank], nbSendElement[rank], EP_INT, rank, 0, communicator, &sendRequest[nbSendRequest]);
+      MPI_Issend(sendElement[rank], nbSendElement[rank], MPI_INT, rank, 0, communicator, &sendRequest[nbSendRequest]);
       nbSendRequest++;
     }
@@ -271,12 +271,12 @@
         sendNeighIds[rank] = new GloId[nbRecvElement[rank]];
       }
-      ep_lib::MPI_Irecv(recvElement[rank], nbRecvElement[rank], EP_INT, rank, 0, communicator, &recvRequest[nbRecvRequest]);
+      MPI_Irecv(recvElement[rank], nbRecvElement[rank], MPI_INT, rank, 0, communicator, &recvRequest[nbRecvRequest]);
       nbRecvRequest++;
     }
   }
-  ep_lib::MPI_Status *status = new ep_lib::MPI_Status[5*mpiSize];
+  MPI_Status *status = new MPI_Status[5*mpiSize];
   
-  ep_lib::MPI_Waitall(nbSendRequest, sendRequest, status);
-        ep_lib::MPI_Waitall(nbRecvRequest, recvRequest, status);
+  MPI_Waitall(nbSendRequest, sendRequest, status);
+        MPI_Waitall(nbRecvRequest, recvRequest, status);
 
   /* for all indices that have been received from requesting ranks: pack values and gradients, then send */
@@ -310,15 +310,15 @@
           sendNeighIds[rank][j] = sstree.localElements[recvElement[rank][j]].src_id;
       }
-      ep_lib::MPI_Issend(sendValue[rank],  nbRecvElement[rank], EP_DOUBLE, rank, 0, communicator, &sendRequest[nbSendRequest]);
+      MPI_Issend(sendValue[rank],  nbRecvElement[rank], MPI_DOUBLE, rank, 0, communicator, &sendRequest[nbSendRequest]);
       nbSendRequest++;
-      ep_lib::MPI_Issend(sendArea[rank],  nbRecvElement[rank], EP_DOUBLE, rank, 0, communicator, &sendRequest[nbSendRequest]);
+      MPI_Issend(sendArea[rank],  nbRecvElement[rank], MPI_DOUBLE, rank, 0, communicator, &sendRequest[nbSendRequest]);
       nbSendRequest++;
-      ep_lib::MPI_Issend(sendGivenArea[rank],  nbRecvElement[rank], EP_DOUBLE, rank, 0, communicator, &sendRequest[nbSendRequest]);
+      MPI_Issend(sendGivenArea[rank],  nbRecvElement[rank], MPI_DOUBLE, rank, 0, communicator, &sendRequest[nbSendRequest]);
       nbSendRequest++;
       if (order == 2)
       {
-        ep_lib::MPI_Issend(sendGrad[rank], 3*nbRecvElement[rank]*(NMAX+1), EP_DOUBLE, rank, 0, communicator, &sendRequest[nbSendRequest]);
+        MPI_Issend(sendGrad[rank], 3*nbRecvElement[rank]*(NMAX+1), MPI_DOUBLE, rank, 0, communicator, &sendRequest[nbSendRequest]);
         nbSendRequest++;
-        ep_lib::MPI_Issend(sendNeighIds[rank], 4*nbRecvElement[rank]*(NMAX+1), EP_INT, rank, 0, communicator, &sendRequest[nbSendRequest]);
+        MPI_Issend(sendNeighIds[rank], 4*nbRecvElement[rank]*(NMAX+1), MPI_INT, rank, 0, communicator, &sendRequest[nbSendRequest]);
 //ym  --> attention taille GloId
         nbSendRequest++;
@@ -326,5 +326,5 @@
       else
       {
-        ep_lib::MPI_Issend(sendNeighIds[rank], 4*nbRecvElement[rank], EP_INT, rank, 0, communicator, &sendRequest[nbSendRequest]);
+        MPI_Issend(sendNeighIds[rank], 4*nbRecvElement[rank], MPI_INT, rank, 0, communicator, &sendRequest[nbSendRequest]);
 //ym  --> attention taille GloId
         nbSendRequest++;
@@ -333,16 +333,16 @@
     if (nbSendElement[rank] > 0)
     {
-      ep_lib::MPI_Irecv(recvValue[rank],  nbSendElement[rank], EP_DOUBLE, rank, 0, communicator, &recvRequest[nbRecvRequest]);
+      MPI_Irecv(recvValue[rank],  nbSendElement[rank], MPI_DOUBLE, rank, 0, communicator, &recvRequest[nbRecvRequest]);
       nbRecvRequest++;
-      ep_lib::MPI_Irecv(recvArea[rank],  nbSendElement[rank], EP_DOUBLE, rank, 0, communicator, &recvRequest[nbRecvRequest]);
+      MPI_Irecv(recvArea[rank],  nbSendElement[rank], MPI_DOUBLE, rank, 0, communicator, &recvRequest[nbRecvRequest]);
       nbRecvRequest++;
-      ep_lib::MPI_Irecv(recvGivenArea[rank],  nbSendElement[rank], EP_DOUBLE, rank, 0, communicator, &recvRequest[nbRecvRequest]);
+      MPI_Irecv(recvGivenArea[rank],  nbSendElement[rank], MPI_DOUBLE, rank, 0, communicator, &recvRequest[nbRecvRequest]);
       nbRecvRequest++;
       if (order == 2)
       {
-        ep_lib::MPI_Irecv(recvGrad[rank], 3*nbSendElement[rank]*(NMAX+1),
-            EP_DOUBLE, rank, 0, communicator, &recvRequest[nbRecvRequest]);
+        MPI_Irecv(recvGrad[rank], 3*nbSendElement[rank]*(NMAX+1),
+            MPI_DOUBLE, rank, 0, communicator, &recvRequest[nbRecvRequest]);
         nbRecvRequest++;
-        ep_lib::MPI_Irecv(recvNeighIds[rank], 4*nbSendElement[rank]*(NMAX+1), EP_INT, rank, 0, communicator, &recvRequest[nbRecvRequest]);
+        MPI_Irecv(recvNeighIds[rank], 4*nbSendElement[rank]*(NMAX+1), MPI_INT, rank, 0, communicator, &recvRequest[nbRecvRequest]);
 //ym  --> attention taille GloId
         nbRecvRequest++;
@@ -350,5 +350,5 @@
       else
       {
-        ep_lib::MPI_Irecv(recvNeighIds[rank], 4*nbSendElement[rank], EP_INT, rank, 0, communicator, &recvRequest[nbRecvRequest]);
+        MPI_Irecv(recvNeighIds[rank], 4*nbSendElement[rank], MPI_INT, rank, 0, communicator, &recvRequest[nbRecvRequest]);
 //ym  --> attention taille GloId
         nbRecvRequest++;
@@ -357,6 +357,6 @@
   }
         
-        ep_lib::MPI_Waitall(nbSendRequest, sendRequest, status);
-  ep_lib::MPI_Waitall(nbRecvRequest, recvRequest, status);
+        MPI_Waitall(nbSendRequest, sendRequest, status);
+  MPI_Waitall(nbRecvRequest, recvRequest, status);
   
 
@@ -487,6 +487,6 @@
 {
   int mpiSize, mpiRank;
-  ep_lib::MPI_Comm_size(communicator, &mpiSize);
-  ep_lib::MPI_Comm_rank(communicator, &mpiRank);
+  MPI_Comm_size(communicator, &mpiSize);
+  MPI_Comm_rank(communicator, &mpiRank);
 
   vector<Node> *routingList = new vector<Node>[mpiSize];
@@ -522,6 +522,6 @@
   }
 
-  ep_lib::MPI_Alltoall(nbSendNode, 1, EP_INT, nbRecvNode, 1, EP_INT, communicator);
-  ep_lib::MPI_Alltoall(sendMessageSize, 1, EP_INT, recvMessageSize, 1, EP_INT, communicator);
+  MPI_Alltoall(nbSendNode, 1, MPI_INT, nbRecvNode, 1, MPI_INT, communicator);
+  MPI_Alltoall(sendMessageSize, 1, MPI_INT, recvMessageSize, 1, MPI_INT, communicator);
 
   char **sendBuffer = new char*[mpiSize];
@@ -549,7 +549,7 @@
   int nbSendRequest = 0;
   int nbRecvRequest = 0;
-  ep_lib::MPI_Request *sendRequest = new ep_lib::MPI_Request[mpiSize];
-  ep_lib::MPI_Request *recvRequest = new ep_lib::MPI_Request[mpiSize];
-  ep_lib::MPI_Status  *status      = new ep_lib::MPI_Status[mpiSize];
+  MPI_Request *sendRequest = new MPI_Request[mpiSize];
+  MPI_Request *recvRequest = new MPI_Request[mpiSize];
+  MPI_Status  *status      = new MPI_Status[mpiSize];
 
   for (int rank = 0; rank < mpiSize; rank++)
@@ -557,16 +557,16 @@
     if (nbSendNode[rank] > 0)
     {
-      ep_lib::MPI_Issend(sendBuffer[rank], sendMessageSize[rank], EP_CHAR, rank, 0, communicator, &sendRequest[nbSendRequest]);
+      MPI_Issend(sendBuffer[rank], sendMessageSize[rank], MPI_CHAR, rank, 0, communicator, &sendRequest[nbSendRequest]);
       nbSendRequest++;
     }
     if (nbRecvNode[rank] > 0)
     {
-      ep_lib::MPI_Irecv(recvBuffer[rank], recvMessageSize[rank], EP_CHAR, rank, 0, communicator, &recvRequest[nbRecvRequest]);
+      MPI_Irecv(recvBuffer[rank], recvMessageSize[rank], MPI_CHAR, rank, 0, communicator, &recvRequest[nbRecvRequest]);
       nbRecvRequest++;
     }
   }
 
-  ep_lib::MPI_Waitall(nbRecvRequest, recvRequest, status);
-  ep_lib::MPI_Waitall(nbSendRequest, sendRequest, status);
+  MPI_Waitall(nbRecvRequest, recvRequest, status);
+  MPI_Waitall(nbSendRequest, sendRequest, status);
 
   for (int rank = 0; rank < mpiSize; rank++)
@@ -615,7 +615,7 @@
 
 
-  ep_lib::MPI_Barrier(communicator);
-  ep_lib::MPI_Alltoall(nbSendNode, 1, EP_INT, nbRecvNode, 1, EP_INT, communicator);
-  ep_lib::MPI_Alltoall(sendMessageSize, 1, EP_INT, recvMessageSize, 1, EP_INT, communicator);
+  MPI_Barrier(communicator);
+  MPI_Alltoall(nbSendNode, 1, MPI_INT, nbRecvNode, 1, MPI_INT, communicator);
+  MPI_Alltoall(sendMessageSize, 1, MPI_INT, recvMessageSize, 1, MPI_INT, communicator);
 
   for (int rank = 0; rank < mpiSize; rank++)
@@ -629,16 +629,16 @@
     if (nbSendNode[rank] > 0)
     {
-      ep_lib::MPI_Issend(sendBuffer2[rank], sendMessageSize[rank], EP_CHAR, rank, 0, communicator, &sendRequest[nbSendRequest]);
+      MPI_Issend(sendBuffer2[rank], sendMessageSize[rank], MPI_CHAR, rank, 0, communicator, &sendRequest[nbSendRequest]);
       nbSendRequest++;
     }
     if (nbRecvNode[rank] > 0)
     {
-      ep_lib::MPI_Irecv(recvBuffer2[rank], recvMessageSize[rank], EP_CHAR, rank, 0, communicator, &recvRequest[nbRecvRequest]);
+      MPI_Irecv(recvBuffer2[rank], recvMessageSize[rank], MPI_CHAR, rank, 0, communicator, &recvRequest[nbRecvRequest]);
       nbRecvRequest++;
     }
   }
 
-  ep_lib::MPI_Waitall(nbRecvRequest, recvRequest, status);
-  ep_lib::MPI_Waitall(nbSendRequest, sendRequest, status);
+  MPI_Waitall(nbRecvRequest, recvRequest, status);
+  MPI_Waitall(nbSendRequest, sendRequest, status);
 
   int nbNeighbourNodes = 0;
@@ -725,8 +725,8 @@
 {
   int mpiSize, mpiRank;
-  ep_lib::MPI_Comm_size(communicator, &mpiSize);
-  ep_lib::MPI_Comm_rank(communicator, &mpiRank);
-
-  ep_lib::MPI_Barrier(communicator);
+  MPI_Comm_size(communicator, &mpiSize);
+  MPI_Comm_rank(communicator, &mpiRank);
+
+  MPI_Barrier(communicator);
 
   vector<Node> *routingList = new vector<Node>[mpiSize];
@@ -753,5 +753,5 @@
     cout << endl;
   }
-  ep_lib::MPI_Barrier(communicator);
+  MPI_Barrier(communicator);
 
   int *nbSendNode = new int[mpiSize];
@@ -771,6 +771,6 @@
   }
 
-  ep_lib::MPI_Alltoall(nbSendNode, 1, EP_INT, nbRecvNode, 1, EP_INT, communicator);
-  ep_lib::MPI_Alltoall(sentMessageSize, 1, EP_INT, recvMessageSize, 1, EP_INT, communicator);
+  MPI_Alltoall(nbSendNode, 1, MPI_INT, nbRecvNode, 1, MPI_INT, communicator);
+  MPI_Alltoall(sentMessageSize, 1, MPI_INT, recvMessageSize, 1, MPI_INT, communicator);
 
   int total = 0;
@@ -805,7 +805,7 @@
   int nbSendRequest = 0;
   int nbRecvRequest = 0;
-  ep_lib::MPI_Request *sendRequest = new ep_lib::MPI_Request[mpiSize];
-  ep_lib::MPI_Request *recvRequest = new ep_lib::MPI_Request[mpiSize];
-  ep_lib::MPI_Status   *status = new ep_lib::MPI_Status[mpiSize];
+  MPI_Request *sendRequest = new MPI_Request[mpiSize];
+  MPI_Request *recvRequest = new MPI_Request[mpiSize];
+  MPI_Status   *status = new MPI_Status[mpiSize];
 
   for (int rank = 0; rank < mpiSize; rank++)
@@ -813,16 +813,16 @@
     if (nbSendNode[rank] > 0)
     {
-      ep_lib::MPI_Issend(sendBuffer[rank], sentMessageSize[rank], EP_CHAR, rank, 0, communicator, &sendRequest[nbSendRequest]);
+      MPI_Issend(sendBuffer[rank], sentMessageSize[rank], MPI_CHAR, rank, 0, communicator, &sendRequest[nbSendRequest]);
       nbSendRequest++;
     }
     if (nbRecvNode[rank] > 0)
     {
-      ep_lib::MPI_Irecv(recvBuffer[rank], recvMessageSize[rank], EP_CHAR, rank, 0, communicator, &recvRequest[nbRecvRequest]);
+      MPI_Irecv(recvBuffer[rank], recvMessageSize[rank], MPI_CHAR, rank, 0, communicator, &recvRequest[nbRecvRequest]);
       nbRecvRequest++;
     }
   }
 
-  ep_lib::MPI_Waitall(nbRecvRequest, recvRequest, status);
-  ep_lib::MPI_Waitall(nbSendRequest, sendRequest, status);
+  MPI_Waitall(nbRecvRequest, recvRequest, status);
+  MPI_Waitall(nbSendRequest, sendRequest, status);
   char **sendBuffer2 = new char*[mpiSize];
   char **recvBuffer2 = new char*[mpiSize];
@@ -883,5 +883,5 @@
 
   if (verbose >= 2) cout << "Rank " << mpiRank << "  Compute (internal) intersection " << cputime() - tic << " s" << endl;
-  ep_lib::MPI_Alltoall(sentMessageSize, 1, EP_INT, recvMessageSize, 1, EP_INT, communicator);
+  MPI_Alltoall(sentMessageSize, 1, MPI_INT, recvMessageSize, 1, MPI_INT, communicator);
 
   for (int rank = 0; rank < mpiSize; rank++)
@@ -896,16 +896,16 @@
     if (sentMessageSize[rank] > 0)
     {
-      ep_lib::MPI_Issend(sendBuffer2[rank], sentMessageSize[rank], EP_CHAR, rank, 0, communicator, &sendRequest[nbSendRequest]);
+      MPI_Issend(sendBuffer2[rank], sentMessageSize[rank], MPI_CHAR, rank, 0, communicator, &sendRequest[nbSendRequest]);
       nbSendRequest++;
     }
     if (recvMessageSize[rank] > 0)
     {
-      ep_lib::MPI_Irecv(recvBuffer2[rank], recvMessageSize[rank], EP_CHAR, rank, 0, communicator, &recvRequest[nbRecvRequest]);
+      MPI_Irecv(recvBuffer2[rank], recvMessageSize[rank], MPI_CHAR, rank, 0, communicator, &recvRequest[nbRecvRequest]);
       nbRecvRequest++;
     }
   }
 
-  ep_lib::MPI_Waitall(nbRecvRequest, recvRequest, status);
-  ep_lib::MPI_Waitall(nbSendRequest, sendRequest, status);
+  MPI_Waitall(nbRecvRequest, recvRequest, status);
+  MPI_Waitall(nbSendRequest, sendRequest, status);
 
   delete [] sendRequest;
Index: /XIOS/trunk/extern/remap/src/mapper.hpp
===================================================================
--- /XIOS/trunk/extern/remap/src/mapper.hpp	(revision 1638)
+++ /XIOS/trunk/extern/remap/src/mapper.hpp	(revision 1639)
@@ -18,5 +18,5 @@
 {
 public:
-       Mapper(ep_lib::MPI_Comm comm=EP_COMM_WORLD) : communicator(comm), verbose(SILENT), neighbourElements(NULL), sstree(comm) {}
+       Mapper(MPI_Comm comm=MPI_COMM_WORLD) : communicator(comm), verbose(SILENT), neighbourElements(NULL), sstree(comm) {}
        ~Mapper();
        void setVerbosity(verbosity v) {verbose=v ;}
@@ -67,5 +67,5 @@
 
        CParallelTree sstree;
-       ep_lib::MPI_Comm communicator ;
+       MPI_Comm communicator ;
        std::vector<Elt>  sourceElements ;
        std::vector<Node> sourceMesh ;
Index: /XIOS/trunk/extern/remap/src/mpi_cascade.cpp
===================================================================
--- /XIOS/trunk/extern/remap/src/mpi_cascade.cpp	(revision 1638)
+++ /XIOS/trunk/extern/remap/src/mpi_cascade.cpp	(revision 1639)
@@ -4,8 +4,8 @@
 namespace sphereRemap {
 
-CMPICascade::CMPICascade(int nodes_per_level, ep_lib::MPI_Comm comm)
+CMPICascade::CMPICascade(int nodes_per_level, MPI_Comm comm)
 {
 	int remaining_levels;
-	ep_lib::MPI_Comm intraComm;
+	MPI_Comm intraComm;
 	int l = 0; // current level
 	do {
@@ -15,6 +15,6 @@
 		level[l].p_grp_size = level[l].size/level[l].group_size;
 	
-		ep_lib::MPI_Comm_split(comm, level[l].colour(), level[l].key(), &intraComm);
-		ep_lib::MPI_Comm_split(comm, level[l].p_colour(), level[l].p_key(), &(level[l].pg_comm));
+		MPI_Comm_split(comm, level[l].colour(), level[l].key(), &intraComm);
+		MPI_Comm_split(comm, level[l].p_colour(), level[l].p_key(), &(level[l].pg_comm));
 		comm = intraComm;
 		l++;
Index: /XIOS/trunk/extern/remap/src/mpi_cascade.hpp
===================================================================
--- /XIOS/trunk/extern/remap/src/mpi_cascade.hpp	(revision 1638)
+++ /XIOS/trunk/extern/remap/src/mpi_cascade.hpp	(revision 1639)
@@ -12,8 +12,8 @@
 {
 public:
-	CCascadeLevel(ep_lib::MPI_Comm comm) : comm(comm)
+	CCascadeLevel(MPI_Comm comm) : comm(comm)
 	{
-		ep_lib::MPI_Comm_size(comm, &size);
-		ep_lib::MPI_Comm_rank(comm, &rank);
+		MPI_Comm_size(comm, &size);
+		MPI_Comm_rank(comm, &rank);
 	}
 	int colour() const { return rank % group_size; };
@@ -24,5 +24,5 @@
 	int p_key() const { return colour() + rank/(p_grp_size*group_size)*group_size; }
 
-	ep_lib::MPI_Comm comm, pg_comm;
+	MPI_Comm comm, pg_comm;
 	int rank;
 	int size;
@@ -35,5 +35,5 @@
 public:
 	// 
-	CMPICascade(int nodes_per_level, ep_lib::MPI_Comm comm);
+	CMPICascade(int nodes_per_level, MPI_Comm comm);
 
 	int num_levels;
Index: /XIOS/trunk/extern/remap/src/mpi_routing.cpp
===================================================================
--- /XIOS/trunk/extern/remap/src/mpi_routing.cpp	(revision 1638)
+++ /XIOS/trunk/extern/remap/src/mpi_routing.cpp	(revision 1639)
@@ -10,8 +10,8 @@
 const int verbose = 0;
 
-CMPIRouting::CMPIRouting(ep_lib::MPI_Comm comm) : communicator(comm)
-{
-	ep_lib::MPI_Comm_rank(comm, &mpiRank);
-	ep_lib::MPI_Comm_size(comm, &mpiSize);
+CMPIRouting::CMPIRouting(MPI_Comm comm) : communicator(comm)
+{
+	MPI_Comm_rank(comm, &mpiRank);
+	MPI_Comm_size(comm, &mpiSize);
 }
 
@@ -19,8 +19,8 @@
     but message lengths are *known* to receiver */
 template <typename T>
-void alltoalls_known(const vector<vector<T> >& send, vector<vector<T> >& recv, const vector<int>& ranks, ep_lib::MPI_Comm communicator)
-{
-	vector<ep_lib::MPI_Request> request(ranks.size() * 2);
-	vector<ep_lib::MPI_Status>  status(ranks.size() * 2);
+void alltoalls_known(const vector<vector<T> >& send, vector<vector<T> >& recv, const vector<int>& ranks, MPI_Comm communicator)
+{
+	vector<MPI_Request> request(ranks.size() * 2);
+	vector<MPI_Status>  status(ranks.size() * 2);
 
 	// communicate data
@@ -28,9 +28,9 @@
 	for (int i = 0; i < ranks.size(); i++)
 		if (recv[i].size())
-			ep_lib::MPI_Irecv(&recv[i][0], recv[i].size()*sizeof(T), EP_CHAR, ranks[i], 0, communicator, &request[nbRequest++]);
+			MPI_Irecv(&recv[i][0], recv[i].size()*sizeof(T), MPI_CHAR, ranks[i], 0, communicator, &request[nbRequest++]);
 	for (int i = 0; i < ranks.size(); i++)
 		if (send[i].size())
-			ep_lib::MPI_Isend((void *) &send[i][0], send[i].size()*sizeof(T), EP_CHAR, ranks[i], 0, communicator, &request[nbRequest++]);
-	ep_lib::MPI_Waitall(nbRequest, &request[0], &status[0]);
+			MPI_Isend((void *) &send[i][0], send[i].size()*sizeof(T), MPI_CHAR, ranks[i], 0, communicator, &request[nbRequest++]);
+	MPI_Waitall(nbRequest, &request[0], &status[0]);
 }
 
@@ -38,8 +38,8 @@
     but message lengths are *unknown* to receiver */
 template <typename T>
-void alltoalls_unknown(const vector<vector<T> >& send, vector<vector<T> >& recv, const vector<int>& ranks, ep_lib::MPI_Comm communicator)
-{
-	vector<ep_lib::MPI_Request> request(ranks.size() * 2);
-	vector<ep_lib::MPI_Status>  status(ranks.size() * 2);
+void alltoalls_unknown(const vector<vector<T> >& send, vector<vector<T> >& recv, const vector<int>& ranks, MPI_Comm communicator)
+{
+	vector<MPI_Request> request(ranks.size() * 2);
+	vector<MPI_Status>  status(ranks.size() * 2);
 
 	// communicate sizes
@@ -50,8 +50,8 @@
 		sendSizes[i] = send[i].size();
 	for (int i = 0; i < ranks.size(); i++)
-		ep_lib::MPI_Irecv(&recvSizes[i], 1, EP_INT, ranks[i], 0, communicator, &request[nbRequest++]);
+		MPI_Irecv(&recvSizes[i], 1, MPI_INT, ranks[i], 0, communicator, &request[nbRequest++]);
 	for (int i = 0; i < ranks.size(); i++)
-		ep_lib::MPI_Isend(&sendSizes[i], 1, EP_INT, ranks[i], 0, communicator, &request[nbRequest++]);
-	ep_lib::MPI_Waitall(nbRequest, &request[0], &status[0]);
+		MPI_Isend(&sendSizes[i], 1, MPI_INT, ranks[i], 0, communicator, &request[nbRequest++]);
+	MPI_Waitall(nbRequest, &request[0], &status[0]);
 
 	// allocate
@@ -118,10 +118,10 @@
 	CTimer::get("CMPIRouting::init(reduce_scatter)").reset();
 	CTimer::get("CMPIRouting::init(reduce_scatter)").resume();
-	ep_lib::MPI_Reduce_scatter(toSend, &nbSource, recvCount, EP_INT, EP_SUM, communicator);
+	MPI_Reduce_scatter(toSend, &nbSource, recvCount, MPI_INT, MPI_SUM, communicator);
 	CTimer::get("CMPIRouting::init(reduce_scatter)").suspend();
 	CTimer::get("CMPIRouting::init(reduce_scatter)").print();
 
-	ep_lib::MPI_Alloc_mem(nbTarget *sizeof(int), EP_INFO_NULL, &targetRank);
-	ep_lib::MPI_Alloc_mem(nbSource *sizeof(int), EP_INFO_NULL, &sourceRank);
+	MPI_Alloc_mem(nbTarget *sizeof(int), MPI_INFO_NULL, &targetRank);
+	MPI_Alloc_mem(nbSource *sizeof(int), MPI_INFO_NULL, &sourceRank);
 
 	targetRankToIndex = new int[mpiSize];
@@ -137,10 +137,10 @@
 	}
 
-	ep_lib::MPI_Barrier(communicator);
+	MPI_Barrier(communicator);
 	CTimer::get("CMPIRouting::init(get_source)").reset();
 	CTimer::get("CMPIRouting::init(get_source)").resume();
 
-	ep_lib::MPI_Request *request = new ep_lib::MPI_Request[nbSource + nbTarget];
-	ep_lib::MPI_Status  *status = new ep_lib::MPI_Status[nbSource + nbTarget];
+	MPI_Request *request = new MPI_Request[nbSource + nbTarget];
+	MPI_Status  *status = new MPI_Status[nbSource + nbTarget];
 
 	int indexRequest = 0;
@@ -150,15 +150,11 @@
 	for (int i = 0; i < nbSource; i++)
 	{
-		#ifdef _usingMPI
-                ep_lib::MPI_Irecv(&sourceRank[i], 1, EP_INT, MPI_ANY_SOURCE, 0, communicator, &request[indexRequest]);
-		#elif _usingEP
-                ep_lib::MPI_Irecv(&sourceRank[i], 1, EP_INT, -2, 0, communicator, &request[indexRequest]);
-		#endif
-                indexRequest++;
-	}
-	MPI_Barrier(communicator);
-	for (int i = 0; i < nbTarget; i++)
-	{
-		ep_lib::MPI_Isend(&mpiRank, 1, EP_INT, targetRank[i], 0, communicator, &request[indexRequest]);
+		MPI_Irecv(&sourceRank[i], 1, MPI_INT, MPI_ANY_SOURCE, 0, communicator, &request[indexRequest]);
+		indexRequest++;
+	}
+	MPI_Barrier(communicator);
+	for (int i = 0; i < nbTarget; i++)
+	{
+		MPI_Isend(&mpiRank, 1, MPI_INT, targetRank[i], 0, communicator, &request[indexRequest]);
 		indexRequest++;
 	}
@@ -174,15 +170,11 @@
 	for (int i = 0; i < nbSource; i++)
 	{
-		#ifdef _usingMPI
-                ep_lib::MPI_Irecv(&sourceRank[i], 1, EP_INT, MPI_ANY_SOURCE, 0, communicator, &request[indexRequest]);
-		#elif _usingEP
-                ep_lib::MPI_Irecv(&sourceRank[i], 1, EP_INT, -2, 0, communicator, &request[indexRequest]);
-		#endif
-                indexRequest++;
-	}
-
-	for (int i = 0; i < nbTarget; i++)
-	{
-		ep_lib::MPI_Isend(&mpiRank, 1, EP_INT, targetRank[i], 0, communicator, &request[indexRequest]);
+		MPI_Irecv(&sourceRank[i], 1, MPI_INT, MPI_ANY_SOURCE, 0, communicator, &request[indexRequest]);
+		indexRequest++;
+	}
+
+	for (int i = 0; i < nbTarget; i++)
+	{
+		MPI_Isend(&mpiRank, 1, MPI_INT, targetRank[i], 0, communicator, &request[indexRequest]);
 		indexRequest++;
 	}
@@ -209,5 +201,5 @@
 	for (int i = 0; i < nbSource; i++)
 	{
-		ep_lib::MPI_Irecv(&nbSourceElement[i], 1, EP_INT, sourceRank[i], 0, communicator, &request[indexRequest]);
+		MPI_Irecv(&nbSourceElement[i], 1, MPI_INT, sourceRank[i], 0, communicator, &request[indexRequest]);
 		indexRequest++;
 	}
@@ -216,5 +208,5 @@
 	{
 		totalTargetElement += nbTargetElement[i];
-		ep_lib::MPI_Isend(&nbTargetElement[i], 1, EP_INT, targetRank[i], 0, communicator, &request[indexRequest]);
+		MPI_Isend(&nbTargetElement[i], 1, MPI_INT, targetRank[i], 0, communicator, &request[indexRequest]);
 		indexRequest++;
 	}
@@ -284,9 +276,9 @@
 
 
-	ep_lib::MPI_Request* request=new ep_lib::MPI_Request[nbSource+nbTarget];
-	ep_lib::MPI_Status*  status=new ep_lib::MPI_Status[nbSource+nbTarget];
+	MPI_Request* request=new MPI_Request[nbSource+nbTarget];
+	MPI_Status*  status=new MPI_Status[nbSource+nbTarget];
 	int indexRequest=0;
 
-	ep_lib::MPI_Barrier(communicator);
+	MPI_Barrier(communicator);
 	CTimer::get("CMPIRouting::transferToTarget").reset();
 	CTimer::get("CMPIRouting::transferToTarget").resume();
@@ -294,5 +286,5 @@
 	for(int i=0; i<nbSource; i++)
 	{
-		ep_lib::MPI_Irecv(sourceBuffer[i],nbSourceElement[i]*sizeof(T),EP_CHAR, sourceRank[i], 0, communicator, &request[indexRequest]);
+		MPI_Irecv(sourceBuffer[i],nbSourceElement[i]*sizeof(T),MPI_CHAR, sourceRank[i], 0, communicator, &request[indexRequest]);
 		indexRequest++;
 	}
@@ -300,13 +292,13 @@
 	for(int i=0;i<nbTarget; i++)
 	{
-		ep_lib::MPI_Isend(targetBuffer[i],nbTargetElement[i]*sizeof(T), EP_CHAR, targetRank[i], 0, communicator, &request[indexRequest]);
-		indexRequest++;
-	}
-
-	ep_lib::MPI_Waitall(indexRequest,request,status);
+		MPI_Isend(targetBuffer[i],nbTargetElement[i]*sizeof(T), MPI_CHAR, targetRank[i], 0, communicator, &request[indexRequest]);
+		indexRequest++;
+	}
+
+	MPI_Waitall(indexRequest,request,status);
 
 	CTimer::get("CMPIRouting::transferToTarget").suspend();
 	CTimer::get("CMPIRouting::transferToTarget").print();
-	ep_lib::MPI_Barrier(communicator);
+	MPI_Barrier(communicator);
 
 	// unpack the data
@@ -348,9 +340,9 @@
 	}
 
-	ep_lib::MPI_Request *request = new ep_lib::MPI_Request[nbSource + nbTarget];
-	ep_lib::MPI_Status  *status = new ep_lib::MPI_Status[nbSource + nbTarget];
+	MPI_Request *request = new MPI_Request[nbSource + nbTarget];
+	MPI_Status  *status = new MPI_Status[nbSource + nbTarget];
 	int indexRequest = 0;
 
-	ep_lib::MPI_Barrier(communicator);
+	MPI_Barrier(communicator);
 	CTimer::get("CMPIRouting::transferToTarget(messageSize)").reset();
 	CTimer::get("CMPIRouting::transferToTarget(messageSize)").resume();
@@ -358,5 +350,5 @@
 	for(int i=0; i<nbSource; i++)
 	{
-		ep_lib::MPI_Irecv(&sourceMessageSize[i],1,EP_INT, sourceRank[i], 0, communicator, &request[indexRequest]);
+		MPI_Irecv(&sourceMessageSize[i],1,MPI_INT, sourceRank[i], 0, communicator, &request[indexRequest]);
 		indexRequest++;
 	}
@@ -364,11 +356,11 @@
 	for(int i=0; i<nbTarget; i++)
 	{
-		ep_lib::MPI_Isend(&targetMessageSize[i],1, EP_INT, targetRank[i], 0, communicator, &request[indexRequest]);
-		indexRequest++;
-	}
-
-	ep_lib::MPI_Waitall(indexRequest,request,status);
-
-	ep_lib::MPI_Barrier(communicator);
+		MPI_Isend(&targetMessageSize[i],1, MPI_INT, targetRank[i], 0, communicator, &request[indexRequest]);
+		indexRequest++;
+	}
+
+	MPI_Waitall(indexRequest,request,status);
+
+	MPI_Barrier(communicator);
 	CTimer::get("CMPIRouting::transferToTarget(messageSize)").suspend();
 	CTimer::get("CMPIRouting::transferToTarget(messageSize)").print();
@@ -403,5 +395,5 @@
 	for(int i=0; i<nbSource; i++)
 	{
-		ep_lib::MPI_Irecv(sourceBuffer[i],sourceMessageSize[i],EP_CHAR, sourceRank[i], 0, communicator, &request[indexRequest]);
+		MPI_Irecv(sourceBuffer[i],sourceMessageSize[i],MPI_CHAR, sourceRank[i], 0, communicator, &request[indexRequest]);
 		indexRequest++;
 	}
@@ -409,5 +401,5 @@
 	for(int i=0;i<nbTarget; i++)
 	{
-		ep_lib::MPI_Isend(targetBuffer[i],targetMessageSize[i], EP_CHAR, targetRank[i], 0, communicator, &request[indexRequest]);
+		MPI_Isend(targetBuffer[i],targetMessageSize[i], MPI_CHAR, targetRank[i], 0, communicator, &request[indexRequest]);
 		indexRequest++;
 	}
@@ -468,11 +460,11 @@
 	}
 
-	ep_lib::MPI_Request* request=new ep_lib::MPI_Request[nbSource+nbTarget];
-	ep_lib::MPI_Status*  status=new ep_lib::MPI_Status[nbSource+nbTarget];
+	MPI_Request* request=new MPI_Request[nbSource+nbTarget];
+	MPI_Status*  status=new MPI_Status[nbSource+nbTarget];
 	int indexRequest=0;
 
 	for(int i=0; i<nbSource; i++)
 	{
-		ep_lib::MPI_Isend(sourceBuffer[i],nbSourceElement[i]*sizeof(T),EP_CHAR, sourceRank[i], 0, communicator, &request[indexRequest]);
+		MPI_Isend(sourceBuffer[i],nbSourceElement[i]*sizeof(T),MPI_CHAR, sourceRank[i], 0, communicator, &request[indexRequest]);
 		indexRequest++;
 	}
@@ -480,9 +472,9 @@
 	for(int i=0;i<nbTarget; i++)
 	{
-		ep_lib::MPI_Irecv(targetBuffer[i],nbTargetElement[i]*sizeof(T), EP_CHAR, targetRank[i], 0, communicator, &request[indexRequest]);
-		indexRequest++;
-	}
-
-	ep_lib::MPI_Waitall(indexRequest,request,status);
+		MPI_Irecv(targetBuffer[i],nbTargetElement[i]*sizeof(T), MPI_CHAR, targetRank[i], 0, communicator, &request[indexRequest]);
+		indexRequest++;
+	}
+
+	MPI_Waitall(indexRequest,request,status);
 
 	// unpack the data
@@ -524,18 +516,18 @@
 	}
 
-	ep_lib::MPI_Request *request = new ep_lib::MPI_Request[nbSource + nbTarget];
-	ep_lib::MPI_Status  *status = new ep_lib::MPI_Status[nbSource + nbTarget];
+	MPI_Request *request = new MPI_Request[nbSource + nbTarget];
+	MPI_Status  *status = new MPI_Status[nbSource + nbTarget];
 	int indexRequest = 0;
 	for (int i = 0; i < nbSource; i++)
 	{
-		ep_lib::MPI_Isend(&sourceMessageSize[i], 1, EP_INT, sourceRank[i], 0, communicator, &request[indexRequest]);
-		indexRequest++;
-	}
-	for (int i = 0; i < nbTarget; i++)
-	{
-		ep_lib::MPI_Irecv(&targetMessageSize[i], 1, EP_INT, targetRank[i], 0, communicator, &request[indexRequest]);
-		indexRequest++;
-	}
-	ep_lib::MPI_Waitall(indexRequest, request, status);
+		MPI_Isend(&sourceMessageSize[i], 1, MPI_INT, sourceRank[i], 0, communicator, &request[indexRequest]);
+		indexRequest++;
+	}
+	for (int i = 0; i < nbTarget; i++)
+	{
+		MPI_Irecv(&targetMessageSize[i], 1, MPI_INT, targetRank[i], 0, communicator, &request[indexRequest]);
+		indexRequest++;
+	}
+	MPI_Waitall(indexRequest, request, status);
 
 	for (int i = 0; i < nbTarget; i++)
@@ -565,13 +557,13 @@
 	for (int i = 0; i < nbSource; i++)
 	{
-		ep_lib::MPI_Isend(sourceBuffer[i], sourceMessageSize[i], EP_CHAR, sourceRank[i], 0, communicator, &request[indexRequest]);
-		indexRequest++;
-	}
-	for (int i = 0; i < nbTarget; i++)
-	{
-		ep_lib::MPI_Irecv(targetBuffer[i], targetMessageSize[i], EP_CHAR, targetRank[i], 0, communicator, &request[indexRequest]);
-		indexRequest++;
-	}
-	ep_lib::MPI_Waitall(indexRequest, request, status);
+		MPI_Isend(sourceBuffer[i], sourceMessageSize[i], MPI_CHAR, sourceRank[i], 0, communicator, &request[indexRequest]);
+		indexRequest++;
+	}
+	for (int i = 0; i < nbTarget; i++)
+	{
+		MPI_Irecv(targetBuffer[i], targetMessageSize[i], MPI_CHAR, targetRank[i], 0, communicator, &request[indexRequest]);
+		indexRequest++;
+	}
+	MPI_Waitall(indexRequest, request, status);
 
 	// unpack the data
@@ -613,8 +605,8 @@
 
 template void alltoalls_unknown(const std::vector<std::vector<NES> >& send, std::vector<std::vector<NES> >& recv,
-                                const std::vector<int>& ranks, ep_lib::MPI_Comm communicator);
+                                const std::vector<int>& ranks, MPI_Comm communicator);
 
 template void alltoalls_known(const std::vector<std::vector<int> >& send, std::vector<std::vector<int> >& recv,
-                              const std::vector<int>& ranks, ep_lib::MPI_Comm communicator);
-
-}
+                              const std::vector<int>& ranks, MPI_Comm communicator);
+
+}
Index: /XIOS/trunk/extern/remap/src/mpi_routing.hpp
===================================================================
--- /XIOS/trunk/extern/remap/src/mpi_routing.hpp	(revision 1638)
+++ /XIOS/trunk/extern/remap/src/mpi_routing.hpp	(revision 1639)
@@ -11,5 +11,5 @@
 {
 
-	ep_lib::MPI_Comm communicator;
+	MPI_Comm communicator;
 	int mpiRank;
 	int mpiSize;
@@ -29,5 +29,5 @@
 
 public:
-	CMPIRouting(ep_lib::MPI_Comm comm);
+	CMPIRouting(MPI_Comm comm);
 	~CMPIRouting();
 	template<typename T> void init(const std::vector<T>& route, CMPICascade *cascade = NULL);
@@ -44,9 +44,9 @@
 template <typename T>
 void alltoalls_known(const std::vector<std::vector<T> >& send, std::vector<std::vector<T> >& recv,
-                     const std::vector<int>& ranks, ep_lib::MPI_Comm communicator);
+                     const std::vector<int>& ranks, MPI_Comm communicator);
 
 template <typename T>
 void alltoalls_unknown(const std::vector<std::vector<T> >& send, std::vector<std::vector<T> >& recv,
-                       const std::vector<int>& ranks, ep_lib::MPI_Comm communicator);
+                       const std::vector<int>& ranks, MPI_Comm communicator);
 }
 #endif
Index: /XIOS/trunk/extern/remap/src/parallel_tree.cpp
===================================================================
--- /XIOS/trunk/extern/remap/src/parallel_tree.cpp	(revision 1638)
+++ /XIOS/trunk/extern/remap/src/parallel_tree.cpp	(revision 1639)
@@ -115,5 +115,5 @@
 
 //CParallelTree::CParallelTree(MPI_Comm comm) : communicator(comm), cascade(MIN_NODE_SZ*MIN_NODE_SZ, comm)
-CParallelTree::CParallelTree(ep_lib::MPI_Comm comm) : communicator(comm), cascade(MAX_NODE_SZ*MAX_NODE_SZ*2, comm)
+CParallelTree::CParallelTree(MPI_Comm comm) : communicator(comm), cascade(MAX_NODE_SZ*MAX_NODE_SZ*2, comm)
 {
 	treeCascade.reserve(cascade.num_levels);
@@ -151,5 +151,5 @@
 
 	int nrecv; // global number of samples  THIS WILL BE THE NUMBER OF LEAFS IN THE SAMPLE TREE
-	ep_lib::MPI_Allreduce(&n, &nrecv, 1, EP_INT, EP_SUM, comm.comm); // => size of sample tree does not depend on keepNodes!
+	MPI_Allreduce(&n, &nrecv, 1, MPI_INT, MPI_SUM, comm.comm); // => size of sample tree does not depend on keepNodes!
 	double ratio = blocSize / (1.0 * nrecv);
 	int nsend = ratio * n + 1; // nsend = n_local_samples / n_global_samples * blocksize + 1 = blocksize/comm.size
@@ -157,5 +157,5 @@
 
 	int *counts = new int[comm.size];
-	ep_lib::MPI_Allgather(&nsend, 1, EP_INT, counts, 1, EP_INT, comm.comm);
+	MPI_Allgather(&nsend, 1, MPI_INT, counts, 1, MPI_INT, comm.comm);
 
 	nrecv = 0;
@@ -183,5 +183,5 @@
 	/* each process needs the sample elements from all processes */
 	double *recvBuffer = new double[nrecv*4];
-	ep_lib::MPI_Allgatherv(sendBuffer, 4 * nsend, EP_DOUBLE, recvBuffer, counts, displs, EP_DOUBLE, comm.comm);
+	MPI_Allgatherv(sendBuffer, 4 * nsend, MPI_DOUBLE, recvBuffer, counts, displs, MPI_DOUBLE, comm.comm);
 	delete[] sendBuffer;
 	delete[] counts;
@@ -241,5 +241,5 @@
          << "   node size : "<<node.size()<<"   bloc size : "<<blocSize<<"  total number of leaf : "<<tree.leafs.size()<<endl ;
 /*
-	MPI_Allreduce(&ok, &allok, 1, EP_INT, MPI_PROD, communicator);
+	MPI_Allreduce(&ok, &allok, 1, MPI_INT, MPI_PROD, communicator);
 	if (!allok) {
 		MPI_Finalize();
@@ -247,5 +247,5 @@
 	}
 */
-    ep_lib::MPI_Abort(EP_COMM_WORLD,-1) ;
+    MPI_Abort(MPI_COMM_WORLD,-1) ;
   }
 /*
@@ -265,5 +265,5 @@
 {
 	CMPIRouting MPIRoute(communicator);
-	ep_lib::MPI_Barrier(communicator);
+	MPI_Barrier(communicator);
 	CTimer::get("buildLocalTree(initRoute)").resume();
 	MPIRoute.init(route);
@@ -290,5 +290,5 @@
 
 	int mpiRank;
-	ep_lib::MPI_Comm_rank(communicator, &mpiRank);
+	MPI_Comm_rank(communicator, &mpiRank);
 	localTree.leafs.reserve(nbLocalElements);
 	for (int i = 0; i < nbLocalElements; i++)
@@ -316,7 +316,7 @@
   nb1=node.size() ; nb2=node2.size() ;
   nb=nb1+nb2 ;
-  ep_lib::MPI_Allreduce(&nb, &nbTot, 1, EP_LONG, EP_SUM, communicator) ;
+  MPI_Allreduce(&nb, &nbTot, 1, MPI_LONG, MPI_SUM, communicator) ;
   int commSize ;
-  ep_lib::MPI_Comm_size(communicator,&commSize) ;
+  MPI_Comm_size(communicator,&commSize) ;
   
 	// make multiple of two
@@ -501,9 +501,9 @@
 	// gather circles on this level of the cascade
 	int pg_size;
-	ep_lib::MPI_Comm_size(cascade.level[level].pg_comm, &pg_size);
+	MPI_Comm_size(cascade.level[level].pg_comm, &pg_size);
 	vector<Coord> allRootCentres(pg_size);
 	vector<double> allRootRadia(pg_size);
-	ep_lib::MPI_Allgather(&rootCentre, 3, EP_DOUBLE, &allRootCentres[0], 3, EP_DOUBLE, cascade.level[level].pg_comm);
-	ep_lib::MPI_Allgather(&rootRadius, 1, EP_DOUBLE, &allRootRadia[0],   1, EP_DOUBLE, cascade.level[level].pg_comm);
+	MPI_Allgather(&rootCentre, 3, MPI_DOUBLE, &allRootCentres[0], 3, MPI_DOUBLE, cascade.level[level].pg_comm);
+	MPI_Allgather(&rootRadius, 1, MPI_DOUBLE, &allRootRadia[0],   1, MPI_DOUBLE, cascade.level[level].pg_comm);
 
 	// now allRootsRadia and allRootCentres must be inserted into second levels of us and propagated to root
Index: /XIOS/trunk/extern/remap/src/parallel_tree.hpp
===================================================================
--- /XIOS/trunk/extern/remap/src/parallel_tree.hpp	(revision 1638)
+++ /XIOS/trunk/extern/remap/src/parallel_tree.hpp	(revision 1639)
@@ -12,5 +12,5 @@
 {
 public:
-	CParallelTree(ep_lib::MPI_Comm comm);
+	CParallelTree(MPI_Comm comm);
 	~CParallelTree();
 
@@ -34,5 +34,5 @@
 	vector<CSampleTree> treeCascade; // first for sample tree, then for routing tree
 	CMPICascade cascade;
-  ep_lib::MPI_Comm communicator ;
+  MPI_Comm communicator ;
 
 };
Index: /XIOS/trunk/src/buffer_client.cpp
===================================================================
--- /XIOS/trunk/src/buffer_client.cpp	(revision 1638)
+++ /XIOS/trunk/src/buffer_client.cpp	(revision 1639)
@@ -12,5 +12,5 @@
   size_t CClientBuffer::maxRequestSize = 0;
 
-  CClientBuffer::CClientBuffer(ep_lib::MPI_Comm interComm, int serverRank, StdSize bufferSize, StdSize estimatedMaxEventSize, StdSize maxBufferedEvents)
+  CClientBuffer::CClientBuffer(MPI_Comm interComm, int serverRank, StdSize bufferSize, StdSize estimatedMaxEventSize, StdSize maxBufferedEvents)
     : interComm(interComm)
     , serverRank(serverRank)
@@ -83,5 +83,5 @@
   bool CClientBuffer::checkBuffer(void)
   {
-    ep_lib::MPI_Status status;
+    MPI_Status status;
     int flag;
 
@@ -89,5 +89,5 @@
     {
       traceOff();
-      ep_lib::MPI_Test(&request, &flag, &status);
+      MPI_Test(&request, &flag, &status);
       traceOn();
       if (flag == true) pending = false;
@@ -98,5 +98,5 @@
       if (count > 0)
       {
-        ep_lib::MPI_Issend(buffer[current], count, EP_CHAR, serverRank, 20, interComm, &request);
+        MPI_Issend(buffer[current], count, MPI_CHAR, serverRank, 20, interComm, &request);
         pending = true;
         if (current == 1) current = 0;
Index: /XIOS/trunk/src/buffer_client.hpp
===================================================================
--- /XIOS/trunk/src/buffer_client.hpp	(revision 1638)
+++ /XIOS/trunk/src/buffer_client.hpp	(revision 1639)
@@ -14,5 +14,5 @@
       static size_t maxRequestSize;
 
-      CClientBuffer(ep_lib::MPI_Comm intercomm, int serverRank, StdSize bufferSize, StdSize estimatedMaxEventSize, StdSize maxBufferedEvents);
+      CClientBuffer(MPI_Comm intercomm, int serverRank, StdSize bufferSize, StdSize estimatedMaxEventSize, StdSize maxBufferedEvents);
       ~CClientBuffer();
 
@@ -39,8 +39,8 @@
       bool pending;
 
-      ep_lib::MPI_Request request;
+      MPI_Request request;
 
       CBufferOut* retBuffer;
-      const ep_lib::MPI_Comm interComm;
+      const MPI_Comm interComm;
   };
 }
Index: /XIOS/trunk/src/client.cpp
===================================================================
--- /XIOS/trunk/src/client.cpp	(revision 1638)
+++ /XIOS/trunk/src/client.cpp	(revision 1639)
@@ -9,5 +9,4 @@
 #include "oasis_cinterface.hpp"
 #include "mpi.hpp"
-//#include "mpi_wrapper.hpp"
 #include "timer.hpp"
 #include "buffer_client.hpp"
@@ -17,7 +16,7 @@
 {
 
-    ep_lib::MPI_Comm CClient::intraComm ;
-    ep_lib::MPI_Comm CClient::interComm ;
-    std::list<ep_lib::MPI_Comm> CClient::contextInterComms;
+    MPI_Comm CClient::intraComm ;
+    MPI_Comm CClient::interComm ;
+    std::list<MPI_Comm> CClient::contextInterComms;
     int CClient::serverLeader ;
     bool CClient::is_MPI_Initialized ;
@@ -25,5 +24,5 @@
     StdOFStream CClient::m_infoStream;
     StdOFStream CClient::m_errorStream;
-    ep_lib::MPI_Comm& CClient::getInterComm(void)   { return (interComm); }
+    MPI_Comm& CClient::getInterComm(void)   { return (interComm); }
      
 ///---------------------------------------------------------------
@@ -36,8 +35,8 @@
  */
 
-    void CClient::initialize(const string& codeId, ep_lib::MPI_Comm& localComm, ep_lib::MPI_Comm& returnComm)
+    void CClient::initialize(const string& codeId, MPI_Comm& localComm, MPI_Comm& returnComm)
     {
       int initialized ;
-      ep_lib::MPI_Initialized(&initialized) ;
+      MPI_Initialized(&initialized) ;
       if (initialized) is_MPI_Initialized=true ;
       else is_MPI_Initialized=false ;
@@ -48,9 +47,9 @@
       {
 // localComm isn't given
-        if (localComm == EP_COMM_NULL)
+        if (localComm == MPI_COMM_NULL)
         {
           if (!is_MPI_Initialized)
           {
-            ep_lib::MPI_Init(NULL, NULL);
+            MPI_Init(NULL, NULL);
           }
           CTimer::get("XIOS").resume() ;
@@ -64,13 +63,12 @@
           int myColor ;
           int i,c ;
-          ep_lib::MPI_Comm newComm ;
-
-          ep_lib::MPI_Comm_size(CXios::globalComm,&size) ;
-
-          ep_lib::MPI_Comm_rank(CXios::globalComm,&rank_);
+          MPI_Comm newComm ;
+
+          MPI_Comm_size(CXios::globalComm,&size) ;
+          MPI_Comm_rank(CXios::globalComm,&rank_);
 
           hashAll=new unsigned long[size] ;
 
-          ep_lib::MPI_Allgather(&hashClient,1,EP_LONG,hashAll,1,EP_LONG,CXios::globalComm) ;
+          MPI_Allgather(&hashClient,1,MPI_LONG,hashAll,1,MPI_LONG,CXios::globalComm) ;
 
           map<unsigned long, int> colors ;
@@ -99,5 +97,5 @@
 
           myColor=colors[hashClient];
-          ep_lib::MPI_Comm_split(CXios::globalComm,myColor,rank_,&intraComm) ;
+          MPI_Comm_split(CXios::globalComm,myColor,rank_,&intraComm) ;
 
           if (CXios::usingServer)
@@ -106,14 +104,14 @@
             serverLeader=leaders[hashServer] ;
             int intraCommSize, intraCommRank ;
-            ep_lib::MPI_Comm_size(intraComm,&intraCommSize) ;
-            ep_lib::MPI_Comm_rank(intraComm,&intraCommRank) ;
+            MPI_Comm_size(intraComm,&intraCommSize) ;
+            MPI_Comm_rank(intraComm,&intraCommRank) ;
             info(50)<<"intercommCreate::client "<<rank_<<" intraCommSize : "<<intraCommSize
                    <<" intraCommRank :"<<intraCommRank<<"  clientLeader "<< serverLeader<<endl ;
-             ep_lib::MPI_Intercomm_create(intraComm, 0, CXios::globalComm, serverLeader, 0, &interComm) ;
+             MPI_Intercomm_create(intraComm, 0, CXios::globalComm, serverLeader, 0, &interComm) ;
              //rank_ = intraCommRank;
           }
           else
           {
-            ep_lib::MPI_Comm_dup(intraComm,&interComm) ;
+            MPI_Comm_dup(intraComm,&interComm) ;
           }
           delete [] hashAll ;
@@ -128,6 +126,6 @@
           else
           {
-            ep_lib::MPI_Comm_dup(localComm,&intraComm) ;
-            ep_lib::MPI_Comm_dup(intraComm,&interComm) ;
+            MPI_Comm_dup(localComm,&intraComm) ;
+            MPI_Comm_dup(intraComm,&interComm) ;
           }
         }
@@ -137,10 +135,10 @@
       {
         // localComm isn't given
-        if (localComm == EP_COMM_NULL)
+        if (localComm == MPI_COMM_NULL)
         {
           if (!is_MPI_Initialized) oasis_init(codeId) ;
           oasis_get_localcomm(localComm) ;
         }
-        ep_lib::MPI_Comm_dup(localComm,&intraComm) ;
+        MPI_Comm_dup(localComm,&intraComm) ;
 
         CTimer::get("XIOS").resume() ;
@@ -149,15 +147,15 @@
         if (CXios::usingServer)
         {
-          ep_lib::MPI_Status status ;
-          ep_lib::MPI_Comm_rank(intraComm,&rank_) ;
+          MPI_Status status ;
+          MPI_Comm_rank(intraComm,&rank_) ;
 
           oasis_get_intercomm(interComm,CXios::xiosCodeId) ;
-          if (rank_==0) ep_lib::MPI_Recv(&serverLeader,1, EP_INT, 0, 0, interComm, &status) ;
-          ep_lib::MPI_Bcast(&serverLeader,1,EP_INT,0,intraComm) ;
-        }
-        else ep_lib::MPI_Comm_dup(intraComm,&interComm) ;
-      }
-
-      ep_lib::MPI_Comm_dup(intraComm,&returnComm) ;
+          if (rank_==0) MPI_Recv(&serverLeader,1, MPI_INT, 0, 0, interComm, &status) ;
+          MPI_Bcast(&serverLeader,1,MPI_INT,0,intraComm) ;
+        }
+        else MPI_Comm_dup(intraComm,&interComm) ;
+      }
+
+      MPI_Comm_dup(intraComm,&returnComm) ;
     }
 
@@ -170,5 +168,5 @@
  * Function is only called by client.
  */
-    void CClient::registerContext(const string& id, ep_lib::MPI_Comm contextComm)
+    void CClient::registerContext(const string& id, MPI_Comm contextComm)
     {
       CContext::setCurrent(id) ;
@@ -180,6 +178,6 @@
       // Attached mode
       {
-        ep_lib::MPI_Comm contextInterComm ;
-        ep_lib::MPI_Comm_dup(contextComm,&contextInterComm) ;
+        MPI_Comm contextInterComm ;
+        MPI_Comm_dup(contextComm,&contextInterComm) ;
         CContext* contextServer = CContext::create(idServer);
 
@@ -200,9 +198,9 @@
         size_t message_size ;
         int leaderRank ;
-        ep_lib::MPI_Comm contextInterComm ;
-
-        ep_lib::MPI_Comm_size(contextComm,&size) ;
-        ep_lib::MPI_Comm_rank(contextComm,&rank) ;
-        ep_lib::MPI_Comm_rank(CXios::globalComm,&globalRank) ;
+        MPI_Comm contextInterComm ;
+
+        MPI_Comm_size(contextComm,&size) ;
+        MPI_Comm_rank(contextComm,&rank) ;
+        MPI_Comm_rank(CXios::globalComm,&globalRank) ;
         if (rank!=0) globalRank=0 ;
 
@@ -216,16 +214,16 @@
         buffer<<msg ;
 
-        ep_lib::MPI_Send((void*)buff,buffer.count(),EP_CHAR,serverLeader,1,CXios::globalComm) ;
-
-        ep_lib::MPI_Intercomm_create(contextComm,0,CXios::globalComm,serverLeader,10+globalRank,&contextInterComm) ;
+        MPI_Send((void*)buff,buffer.count(),MPI_CHAR,serverLeader,1,CXios::globalComm) ;
+
+        MPI_Intercomm_create(contextComm,0,CXios::globalComm,serverLeader,10+globalRank,&contextInterComm) ;
         info(10)<<"Register new Context : "<<id<<endl ;
-        ep_lib::MPI_Comm inter ;
-        ep_lib::MPI_Intercomm_merge(contextInterComm,0,&inter) ;
-        ep_lib::MPI_Barrier(inter) ;
+        MPI_Comm inter ;
+        MPI_Intercomm_merge(contextInterComm,0,&inter) ;
+        MPI_Barrier(inter) ;
 
         context->initClient(contextComm,contextInterComm) ;
 
         contextInterComms.push_back(contextInterComm);
-        ep_lib::MPI_Comm_free(&inter);
+        MPI_Comm_free(&inter);
         delete [] buff ;
 
@@ -253,8 +251,8 @@
         int msg=0 ;
 
-        ep_lib::MPI_Comm_rank(intraComm,&rank) ;
+        MPI_Comm_rank(intraComm,&rank) ;
         if (rank==0) 
         {
-          ep_lib::MPI_Send(&msg,1,EP_INT,0,5,interComm) ; // tags oasis_endded = 5
+          MPI_Send(&msg,1,MPI_INT,0,5,interComm) ; // tags oasis_endded = 5
         }
 
@@ -268,19 +266,19 @@
       int msg=0 ;
 
-      ep_lib::MPI_Comm_rank(intraComm,&rank) ;
+      MPI_Comm_rank(intraComm,&rank) ;
  
       if (!CXios::isServer)
       {
-        ep_lib::MPI_Comm_rank(intraComm,&rank) ;
+        MPI_Comm_rank(intraComm,&rank) ;
         if (rank==0)
         {
-          ep_lib::MPI_Send(&msg,1,EP_INT,0,0,interComm) ;
-        }
-      }
-
-      for (std::list<ep_lib::MPI_Comm>::iterator it = contextInterComms.begin(); it != contextInterComms.end(); it++)
-        ep_lib::MPI_Comm_free(&(*it));
-      ep_lib::MPI_Comm_free(&interComm);
-      ep_lib::MPI_Comm_free(&intraComm);
+          MPI_Send(&msg,1,MPI_INT,0,0,interComm) ;
+        }
+      }
+
+      for (std::list<MPI_Comm>::iterator it = contextInterComms.begin(); it != contextInterComms.end(); it++)
+        MPI_Comm_free(&(*it));
+      MPI_Comm_free(&interComm);
+      MPI_Comm_free(&intraComm);
 
       CTimer::get("XIOS init/finalize").suspend() ;
@@ -290,5 +288,5 @@
       {
         if (CXios::usingOasis) oasis_finalize();
-        else ep_lib::MPI_Finalize() ;
+        else MPI_Finalize() ;
       }
       
@@ -327,5 +325,5 @@
       int size = 0;
       int rank;
-      ep_lib::MPI_Comm_size(CXios::globalComm, &size);
+      MPI_Comm_size(CXios::globalComm, &size);
       while (size)
       {
@@ -336,5 +334,5 @@
       if (CXios::usingOasis)
       {
-        ep_lib::MPI_Comm_rank(CXios::globalComm,&rank);
+        MPI_Comm_rank(CXios::globalComm,&rank);
         fileNameClient << fileName << "_" << std::setfill('0') << std::setw(numDigit) << rank << ext;
       }
Index: /XIOS/trunk/src/client.hpp
===================================================================
--- /XIOS/trunk/src/client.hpp	(revision 1638)
+++ /XIOS/trunk/src/client.hpp	(revision 1639)
@@ -10,16 +10,16 @@
     {
       public:
-        static void initialize(const string& codeId, ep_lib::MPI_Comm& localComm, ep_lib::MPI_Comm& returnComm);
+        static void initialize(const string& codeId, MPI_Comm& localComm, MPI_Comm& returnComm);
         static void finalize(void);
-        static void registerContext(const string& id, ep_lib::MPI_Comm contextComm);
+        static void registerContext(const string& id, MPI_Comm contextComm);
         static void callOasisEnddef(void) ;
 
-        static ep_lib::MPI_Comm intraComm;
-        static ep_lib::MPI_Comm interComm;
-        static std::list<ep_lib::MPI_Comm> contextInterComms;
+        static MPI_Comm intraComm;
+        static MPI_Comm interComm;
+        static std::list<MPI_Comm> contextInterComms;
         static int serverLeader;
         static bool is_MPI_Initialized ;
 
-        static ep_lib::MPI_Comm& getInterComm();
+        static MPI_Comm& getInterComm();
 
         //! Get global rank without oasis and current rank in model intraComm in case of oasis
Index: /XIOS/trunk/src/client_client_dht_template.hpp
===================================================================
--- /XIOS/trunk/src/client_client_dht_template.hpp	(revision 1638)
+++ /XIOS/trunk/src/client_client_dht_template.hpp	(revision 1639)
@@ -40,8 +40,8 @@
   public:
     CClientClientDHTTemplate(const Index2InfoTypeMap& indexInfoInitMap,
-                             const ep_lib::MPI_Comm& clientIntraComm);
+                             const MPI_Comm& clientIntraComm);
 
     CClientClientDHTTemplate(const Index2VectorInfoTypeMap& indexInfoInitMap,
-                             const ep_lib::MPI_Comm& clientIntraComm);
+                             const MPI_Comm& clientIntraComm);
 
     void computeIndexInfoMapping(const CArray<size_t,1>& indices);
@@ -55,5 +55,5 @@
 
   protected:
-    CClientClientDHTTemplate(const ep_lib::MPI_Comm& clientIntraComm);
+    CClientClientDHTTemplate(const MPI_Comm& clientIntraComm);
 
   protected:
@@ -62,9 +62,9 @@
     // Redistribute index and info among clients
     void computeDistributedIndex(const Index2InfoTypeMap& indexInfoInitMap,
-                                 const ep_lib::MPI_Comm& intraCommLevel,
+                                 const MPI_Comm& intraCommLevel,
                                  int level);
 
     void computeDistributedIndex(const Index2VectorInfoTypeMap& indexInfoInitMap,
-                                 const ep_lib::MPI_Comm& intraCommLevel,
+                                 const MPI_Comm& intraCommLevel,
                                  int level);
 
@@ -73,5 +73,5 @@
 
     void computeIndexInfoMappingLevel(const CArray<size_t,1>& indices,
-                                      const ep_lib::MPI_Comm& intraCommLevel,
+                                      const MPI_Comm& intraCommLevel,
                                       int level);
 
@@ -85,32 +85,19 @@
     // Send information to clients
     void sendInfoToClients(int clientDestRank, unsigned char* info, int infoSize,
-                           const ep_lib::MPI_Comm& clientIntraComm,
-                           std::vector<ep_lib::MPI_Request>& requestSendInfo);
-    void sendInfoToClients(int clientDestRank, unsigned char* info, int infoSize,
-                           const ep_lib::MPI_Comm& clientIntraComm,
-                           ep_lib::MPI_Request* requestSendInfo);
+                           const MPI_Comm& clientIntraComm,
+                           std::vector<MPI_Request>& requestSendInfo);
 
     void recvInfoFromClients(int clientSrcRank, unsigned char* info, int infoSize,
-                            const ep_lib::MPI_Comm& clientIntraComm,
-                            std::vector<ep_lib::MPI_Request>& requestRecvInfo);
-    void recvInfoFromClients(int clientSrcRank, unsigned char* info, int infoSize,
-                             const ep_lib::MPI_Comm& clientIntraComm,
-                             ep_lib::MPI_Request* requestRecvInfo);
-                                                        
+                            const MPI_Comm& clientIntraComm,
+                            std::vector<MPI_Request>& requestRecvInfo);
 
     // Send global index to clients
     void sendIndexToClients(int clientDestRank, size_t* indices, size_t indiceSize,
-                            const ep_lib::MPI_Comm& clientIntraComm,
-                            std::vector<ep_lib::MPI_Request>& requestSendIndexGlobal);
-    void sendIndexToClients(int clientDestRank, size_t* indices, size_t indiceSize,
-                            const ep_lib::MPI_Comm& clientIntraComm,
-                            ep_lib::MPI_Request* requestSendIndexGlobal);
+                            const MPI_Comm& clientIntraComm,
+                            std::vector<MPI_Request>& requestSendIndexGlobal);
 
     void recvIndexFromClients(int clientSrcRank, size_t* indices, size_t indiceSize,
-                             const ep_lib::MPI_Comm& clientIntraComm,
-                             std::vector<ep_lib::MPI_Request>& requestRecvIndex);
-    void recvIndexFromClients(int clientSrcRank, size_t* indices, size_t indiceSize,
-                              const ep_lib::MPI_Comm& clientIntraComm,
-                              ep_lib::MPI_Request* requestRecvIndex);
+                             const MPI_Comm& clientIntraComm,
+                             std::vector<MPI_Request>& requestRecvIndex);
 
     void sendRecvOnReturn(const std::vector<int>& sendNbRank, std::vector<int>& sendNbElements,
Index: /XIOS/trunk/src/client_client_dht_template_impl.hpp
===================================================================
--- /XIOS/trunk/src/client_client_dht_template_impl.hpp	(revision 1638)
+++ /XIOS/trunk/src/client_client_dht_template_impl.hpp	(revision 1639)
@@ -14,8 +14,8 @@
 {
 template<typename T, typename H>
-CClientClientDHTTemplate<T,H>::CClientClientDHTTemplate(const ep_lib::MPI_Comm& clientIntraComm)
+CClientClientDHTTemplate<T,H>::CClientClientDHTTemplate(const MPI_Comm& clientIntraComm)
   : H(clientIntraComm), index2InfoMapping_(), indexToInfoMappingLevel_(), nbClient_(0)
 {
-  ep_lib::MPI_Comm_size(clientIntraComm, &nbClient_);
+  MPI_Comm_size(clientIntraComm, &nbClient_);
   this->computeMPICommLevel();
   int nbLvl = this->getNbLevel();
@@ -34,8 +34,8 @@
 template<typename T, typename H>
 CClientClientDHTTemplate<T,H>::CClientClientDHTTemplate(const Index2InfoTypeMap& indexInfoMap,
-                                                        const ep_lib::MPI_Comm& clientIntraComm)
+                                                        const MPI_Comm& clientIntraComm)
   : H(clientIntraComm), index2InfoMapping_(), indexToInfoMappingLevel_(), nbClient_(0)
 {
-  ep_lib::MPI_Comm_size(clientIntraComm, &nbClient_);
+  MPI_Comm_size(clientIntraComm, &nbClient_);
   this->computeMPICommLevel();
   int nbLvl = this->getNbLevel();
@@ -59,8 +59,8 @@
 template<typename T, typename H>
 CClientClientDHTTemplate<T,H>::CClientClientDHTTemplate(const Index2VectorInfoTypeMap& indexInfoMap,
-                                                        const ep_lib::MPI_Comm& clientIntraComm)
+                                                        const MPI_Comm& clientIntraComm)
   : H(clientIntraComm), index2InfoMapping_(), indexToInfoMappingLevel_(), nbClient_(0)
 {
-  ep_lib::MPI_Comm_size(clientIntraComm, &nbClient_);
+  MPI_Comm_size(clientIntraComm, &nbClient_);
   this->computeMPICommLevel();
   int nbLvl = this->getNbLevel();
@@ -95,9 +95,9 @@
 template<typename T, typename H>
 void CClientClientDHTTemplate<T,H>::computeIndexInfoMappingLevel(const CArray<size_t,1>& indices,
-                                                                 const ep_lib::MPI_Comm& commLevel,
+                                                                 const MPI_Comm& commLevel,
                                                                  int level)
 {
   int clientRank;
-  ep_lib::MPI_Comm_rank(commLevel,&clientRank);
+  MPI_Comm_rank(commLevel,&clientRank);
   int groupRankBegin = this->getGroupBegin()[level];
   int nbClient = this->getNbInGroup()[level];
@@ -169,14 +169,5 @@
     recvIndexBuff = new unsigned long[recvNbIndexCount];
 
-  int request_size = 0;
-  for (int idx = 0; idx < recvRankClient.size(); ++idx)
-  {
-    if (0 != recvNbIndexClientCount[idx])
-      request_size ++;
-  }
-
-  request_size += client2ClientIndex.size();
-
-  std::vector<ep_lib::MPI_Request> request(request_size);
+  std::vector<MPI_Request> request;
   std::vector<int>::iterator itbRecvIndex = recvRankClient.begin(), itRecvIndex,
                              iteRecvIndex = recvRankClient.end(),
@@ -185,9 +176,8 @@
   int currentIndex = 0;
   int nbRecvClient = recvRankClient.size();
-  int request_position = 0;
   for (int idx = 0; idx < nbRecvClient; ++idx)
   {
     if (0 != recvNbIndexClientCount[idx])
-      recvIndexFromClients(recvRankClient[idx], recvIndexBuff+currentIndex, recvNbIndexClientCount[idx], commLevel, &request[request_position++]);
+      recvIndexFromClients(recvRankClient[idx], recvIndexBuff+currentIndex, recvNbIndexClientCount[idx], commLevel, request);
     currentIndex += recvNbIndexClientCount[idx];
   }
@@ -196,8 +186,8 @@
                                                 iteIndex = client2ClientIndex.end();
   for (itIndex = itbIndex; itIndex != iteIndex; ++itIndex)
-    sendIndexToClients(itIndex->first, (itIndex->second), sendNbIndexBuff[itIndex->first-groupRankBegin], commLevel, &request[request_position++]);
-
-  std::vector<ep_lib::MPI_Status> status(request.size());
-  ep_lib::MPI_Waitall(request.size(), &request[0], &status[0]);
+    sendIndexToClients(itIndex->first, (itIndex->second), sendNbIndexBuff[itIndex->first-groupRankBegin], commLevel, request);
+
+  std::vector<MPI_Status> status(request.size());
+  MPI_Waitall(request.size(), &request[0], &status[0]);
 
   CArray<size_t,1>* tmpGlobalIndex;
@@ -252,24 +242,5 @@
   }
 
-  int requestOnReturn_size=0;
-  for (int idx = 0; idx < recvRankOnReturn.size(); ++idx)
-  {
-    if (0 != recvNbIndexOnReturn[idx])
-    {
-      requestOnReturn_size += 2;
-    }
-  }
-
-  for (int idx = 0; idx < nbRecvClient; ++idx)
-  {
-    if (0 != sendNbIndexOnReturn[idx])
-    {
-      requestOnReturn_size += 2;
-    }
-  }
-
-  int requestOnReturn_position=0;
-
-  std::vector<ep_lib::MPI_Request> requestOnReturn(requestOnReturn_size);
+  std::vector<MPI_Request> requestOnReturn;
   currentIndex = 0;
   for (int idx = 0; idx < recvRankOnReturn.size(); ++idx)
@@ -277,9 +248,9 @@
     if (0 != recvNbIndexOnReturn[idx])
     {
-      recvIndexFromClients(recvRankOnReturn[idx], recvIndexBuffOnReturn+currentIndex, recvNbIndexOnReturn[idx], commLevel, &requestOnReturn[requestOnReturn_position++]);
+      recvIndexFromClients(recvRankOnReturn[idx], recvIndexBuffOnReturn+currentIndex, recvNbIndexOnReturn[idx], commLevel, requestOnReturn);
       recvInfoFromClients(recvRankOnReturn[idx],
                           recvInfoBuffOnReturn+currentIndex*ProcessDHTElement<InfoType>::typeSize(),
                           recvNbIndexOnReturn[idx]*ProcessDHTElement<InfoType>::typeSize(),
-                          commLevel, &requestOnReturn[requestOnReturn_position++]);
+                          commLevel, requestOnReturn);
     }
     currentIndex += recvNbIndexOnReturn[idx];
@@ -315,13 +286,13 @@
 
       sendIndexToClients(rank, client2ClientIndexOnReturn[rank],
-                         sendNbIndexOnReturn[idx], commLevel, &requestOnReturn[requestOnReturn_position++]);
+                         sendNbIndexOnReturn[idx], commLevel, requestOnReturn);
       sendInfoToClients(rank, client2ClientInfoOnReturn[rank],
-                        sendNbIndexOnReturn[idx]*ProcessDHTElement<InfoType>::typeSize(), commLevel, &requestOnReturn[requestOnReturn_position++]);
+                        sendNbIndexOnReturn[idx]*ProcessDHTElement<InfoType>::typeSize(), commLevel, requestOnReturn);
     }
     currentIndex += recvNbIndexClientCount[idx];
   }
 
-  std::vector<ep_lib::MPI_Status> statusOnReturn(requestOnReturn.size());
-  ep_lib::MPI_Waitall(requestOnReturn.size(), &requestOnReturn[0], &statusOnReturn[0]);
+  std::vector<MPI_Status> statusOnReturn(requestOnReturn.size());
+  MPI_Waitall(requestOnReturn.size(), &requestOnReturn[0], &statusOnReturn[0]);
 
   Index2VectorInfoTypeMap indexToInfoMapping;
@@ -389,9 +360,9 @@
 template<typename T, typename H>
 void CClientClientDHTTemplate<T,H>::computeDistributedIndex(const Index2VectorInfoTypeMap& indexInfoMap,
-                                                            const ep_lib::MPI_Comm& commLevel,
+                                                            const MPI_Comm& commLevel,
                                                             int level)
 {
   int clientRank;
-  ep_lib::MPI_Comm_rank(commLevel,&clientRank);
+  MPI_Comm_rank(commLevel,&clientRank);
   computeSendRecvRank(level, clientRank);
 
@@ -468,32 +439,16 @@
   // it will send a message to the correct clients.
   // Contents of the message are index and its corresponding informatioin
-  int request_size = 0;
-   for (int idx = 0; idx < recvRankClient.size(); ++idx)
-   {
-     if (0 != recvNbIndexClientCount[idx])
-     {
-       request_size += 2;
-     }
-   }
- 
-   request_size += client2ClientIndex.size();
-   request_size += client2ClientInfo.size();
- 
-   std::vector<ep_lib::MPI_Request> request(request_size);
-
+  std::vector<MPI_Request> request;
   int currentIndex = 0;
   int nbRecvClient = recvRankClient.size();
-  int request_position=0;
   for (int idx = 0; idx < nbRecvClient; ++idx)
   {
     if (0 != recvNbIndexClientCount[idx])
     {
-      recvIndexFromClients(recvRankClient[idx], recvIndexBuff+currentIndex, recvNbIndexClientCount[idx], commLevel, &request[request_position++]);
-      //if(clientRank==0) printf("recv index request = %p, inserted = %p, request = %d\n", &request[0], request.back(), *static_cast< int*>(request.back()->mpi_request));
+      recvIndexFromClients(recvRankClient[idx], recvIndexBuff+currentIndex, recvNbIndexClientCount[idx], commLevel, request);
       recvInfoFromClients(recvRankClient[idx],
-                            recvInfoBuff+currentIndex*ProcessDHTElement<InfoType>::typeSize(),
-                            recvNbIndexClientCount[idx]*ProcessDHTElement<InfoType>::typeSize(),
-                            commLevel, &request[request_position++]);
-      //if(clientRank==0) printf("recv info request = %p, inserted = %p, request = %d\n", &request[0], request.back(), *static_cast< int*>(request.back()->mpi_request));
+                          recvInfoBuff+currentIndex*ProcessDHTElement<InfoType>::typeSize(),
+                          recvNbIndexClientCount[idx]*ProcessDHTElement<InfoType>::typeSize(),
+                          commLevel, request);
     }
     currentIndex += recvNbIndexClientCount[idx];
@@ -503,15 +458,12 @@
                                                 iteIndex = client2ClientIndex.end();
   for (itIndex = itbIndex; itIndex != iteIndex; ++itIndex)
-  {  sendIndexToClients(itIndex->first, itIndex->second, sendNbIndexBuff[itIndex->first-groupRankBegin], commLevel, &request[request_position++]);
-  }    //if(clientRank==0) printf("send index request = %p, inserted = %p, request = %d\n", &request[0], request.back(), *static_cast< int*>(request.back()->mpi_request));}
+    sendIndexToClients(itIndex->first, itIndex->second, sendNbIndexBuff[itIndex->first-groupRankBegin], commLevel, request);
   std::unordered_map<int, unsigned char*>::iterator itbInfo = client2ClientInfo.begin(), itInfo,
                                                       iteInfo = client2ClientInfo.end();
   for (itInfo = itbInfo; itInfo != iteInfo; ++itInfo)
-   { sendInfoToClients(itInfo->first, itInfo->second, sendNbInfo[itInfo->first-groupRankBegin], commLevel, &request[request_position++]);
-   }//   if(clientRank==0) printf("send info request = %p, inserted = %p, request = %d\n", &request[0], request.back(), *static_cast< int*>(request.back()->mpi_request));}
-
-  std::vector<ep_lib::MPI_Status> status(request.size());
-  
-  ep_lib::MPI_Waitall(request.size(), &request[0], &status[0]);
+    sendInfoToClients(itInfo->first, itInfo->second, sendNbInfo[itInfo->first-groupRankBegin], commLevel, request);
+
+  std::vector<MPI_Status> status(request.size());
+  MPI_Waitall(request.size(), &request[0], &status[0]);
 
   Index2VectorInfoTypeMap indexToInfoMapping;
@@ -566,28 +518,11 @@
 template<typename T, typename H>
 void CClientClientDHTTemplate<T,H>::sendIndexToClients(int clientDestRank, size_t* indices, size_t indiceSize,
-                                                       const ep_lib::MPI_Comm& clientIntraComm,
-                                                       std::vector<ep_lib::MPI_Request>& requestSendIndex)
-{
-  ep_lib::MPI_Request request;
+                                                       const MPI_Comm& clientIntraComm,
+                                                       std::vector<MPI_Request>& requestSendIndex)
+{
+  MPI_Request request;
   requestSendIndex.push_back(request);
-  ep_lib::MPI_Isend(indices, indiceSize, EP_UNSIGNED_LONG,
+  MPI_Isend(indices, indiceSize, MPI_UNSIGNED_LONG,
             clientDestRank, MPI_DHT_INDEX, clientIntraComm, &(requestSendIndex.back()));
-}
-
-/*!
-  Send message containing index to clients
-  \param [in] clientDestRank rank of destination client
-  \param [in] indices index to send
-  \param [in] indiceSize size of index array to send
-  \param [in] clientIntraComm communication group of client
-  \param [in] requestSendIndex sending request
-*/
-template<typename T, typename H>
-void CClientClientDHTTemplate<T,H>::sendIndexToClients(int clientDestRank, size_t* indices, size_t indiceSize,
-                                                       const ep_lib::MPI_Comm& clientIntraComm,
-                                                       ep_lib::MPI_Request* requestSendIndex)
-{
-  ep_lib::MPI_Isend(indices, indiceSize, EP_UNSIGNED_LONG,
-            clientDestRank, MPI_DHT_INDEX, clientIntraComm, requestSendIndex);
 }
 
@@ -601,27 +536,11 @@
 template<typename T, typename H>
 void CClientClientDHTTemplate<T,H>::recvIndexFromClients(int clientSrcRank, size_t* indices, size_t indiceSize,
-                                                         const ep_lib::MPI_Comm& clientIntraComm,
-                                                         std::vector<ep_lib::MPI_Request>& requestRecvIndex)
-{
-  ep_lib::MPI_Request request;
+                                                         const MPI_Comm& clientIntraComm,
+                                                         std::vector<MPI_Request>& requestRecvIndex)
+{
+  MPI_Request request;
   requestRecvIndex.push_back(request);
-  ep_lib::MPI_Irecv(indices, indiceSize, EP_UNSIGNED_LONG,
+  MPI_Irecv(indices, indiceSize, MPI_UNSIGNED_LONG,
             clientSrcRank, MPI_DHT_INDEX, clientIntraComm, &(requestRecvIndex.back()));
-}
-
-/*!
-  Receive message containing index to clients
-  \param [in] clientDestRank rank of destination client
-  \param [in] indices index to send
-  \param [in] clientIntraComm communication group of client
-  \param [in] requestRecvIndex receiving request
-*/
-template<typename T, typename H>
-void CClientClientDHTTemplate<T,H>::recvIndexFromClients(int clientSrcRank, size_t* indices, size_t indiceSize,
-                                                         const ep_lib::MPI_Comm& clientIntraComm,
-                                                         ep_lib::MPI_Request *requestRecvIndex)
-{
-  ep_lib::MPI_Irecv(indices, indiceSize, EP_UNSIGNED_LONG,
-            clientSrcRank, MPI_DHT_INDEX, clientIntraComm, requestRecvIndex);
 }
 
@@ -636,29 +555,12 @@
 template<typename T, typename H>
 void CClientClientDHTTemplate<T,H>::sendInfoToClients(int clientDestRank, unsigned char* info, int infoSize,
-                                                      const ep_lib::MPI_Comm& clientIntraComm,
-                                                      std::vector<ep_lib::MPI_Request>& requestSendInfo)
-{
-  ep_lib::MPI_Request request;
+                                                      const MPI_Comm& clientIntraComm,
+                                                      std::vector<MPI_Request>& requestSendInfo)
+{
+  MPI_Request request;
   requestSendInfo.push_back(request);
 
-  ep_lib::MPI_Isend(info, infoSize, EP_CHAR,
+  MPI_Isend(info, infoSize, MPI_CHAR,
             clientDestRank, MPI_DHT_INFO, clientIntraComm, &(requestSendInfo.back()));
-}
-
-/*!
-  Send message containing information to clients
-  \param [in] clientDestRank rank of destination client
-  \param [in] info info array to send
-  \param [in] infoSize info array size to send
-  \param [in] clientIntraComm communication group of client
-  \param [in] requestSendInfo sending request
-*/
-template<typename T, typename H>
-void CClientClientDHTTemplate<T,H>::sendInfoToClients(int clientDestRank, unsigned char* info, int infoSize,
-                                                      const ep_lib::MPI_Comm& clientIntraComm,
-                                                      ep_lib::MPI_Request *requestSendInfo)
-{
-  ep_lib::MPI_Isend(info, infoSize, EP_CHAR,
-            clientDestRank, MPI_DHT_INFO, clientIntraComm, requestSendInfo);
 }
 
@@ -673,29 +575,12 @@
 template<typename T, typename H>
 void CClientClientDHTTemplate<T,H>::recvInfoFromClients(int clientSrcRank, unsigned char* info, int infoSize,
-                                                        const ep_lib::MPI_Comm& clientIntraComm,
-                                                        std::vector<ep_lib::MPI_Request>& requestRecvInfo)
-{
-  ep_lib::MPI_Request request;
+                                                        const MPI_Comm& clientIntraComm,
+                                                        std::vector<MPI_Request>& requestRecvInfo)
+{
+  MPI_Request request;
   requestRecvInfo.push_back(request);
 
-  ep_lib::MPI_Irecv(info, infoSize, EP_CHAR,
+  MPI_Irecv(info, infoSize, MPI_CHAR,
             clientSrcRank, MPI_DHT_INFO, clientIntraComm, &(requestRecvInfo.back()));
-}
-
-/*!
-  Receive message containing information from other clients
-  \param [in] clientDestRank rank of destination client
-  \param [in] info info array to receive
-  \param [in] infoSize info array size to receive
-  \param [in] clientIntraComm communication group of client
-  \param [in] requestRecvInfo list of receiving request
-*/
-template<typename T, typename H>
-void CClientClientDHTTemplate<T,H>::recvInfoFromClients(int clientSrcRank, unsigned char* info, int infoSize,
-                                                        const ep_lib::MPI_Comm& clientIntraComm,
-                                                        ep_lib::MPI_Request* requestRecvInfo)
-{
-  ep_lib::MPI_Irecv(info, infoSize, EP_CHAR,
-            clientSrcRank, MPI_DHT_INFO, clientIntraComm, requestRecvInfo);
 }
 
@@ -766,11 +651,11 @@
 {
   recvNbElements.resize(recvNbRank.size());
-  std::vector<ep_lib::MPI_Request> request(sendNbRank.size()+recvNbRank.size());
-  std::vector<ep_lib::MPI_Status> requestStatus(sendNbRank.size()+recvNbRank.size());
+  std::vector<MPI_Request> request(sendNbRank.size()+recvNbRank.size());
+  std::vector<MPI_Status> requestStatus(sendNbRank.size()+recvNbRank.size());
 
   int nRequest = 0;
   for (int idx = 0; idx < recvNbRank.size(); ++idx)
   {
-    ep_lib::MPI_Irecv(&recvNbElements[0]+idx, 1, EP_INT,
+    MPI_Irecv(&recvNbElements[0]+idx, 1, MPI_INT,
               recvNbRank[idx], MPI_DHT_INDEX_1, this->internalComm_, &request[nRequest]);
     ++nRequest;
@@ -779,10 +664,10 @@
   for (int idx = 0; idx < sendNbRank.size(); ++idx)
   {
-    ep_lib::MPI_Isend(&sendNbElements[0]+idx, 1, EP_INT,
+    MPI_Isend(&sendNbElements[0]+idx, 1, MPI_INT,
               sendNbRank[idx], MPI_DHT_INDEX_1, this->internalComm_, &request[nRequest]);
     ++nRequest;
   }
 
-  ep_lib::MPI_Waitall(sendNbRank.size()+recvNbRank.size(), &request[0], &requestStatus[0]);
+  MPI_Waitall(sendNbRank.size()+recvNbRank.size(), &request[0], &requestStatus[0]);
 }
 
@@ -811,11 +696,11 @@
   std::vector<int> recvBuff(recvBuffSize*2,0);
 
-  std::vector<ep_lib::MPI_Request> request(sendBuffSize+recvBuffSize);
-  std::vector<ep_lib::MPI_Status> requestStatus(sendBuffSize+recvBuffSize);
+  std::vector<MPI_Request> request(sendBuffSize+recvBuffSize);
+  std::vector<MPI_Status> requestStatus(sendBuffSize+recvBuffSize);
 
   int nRequest = 0;
   for (int idx = 0; idx < recvBuffSize; ++idx)
   {
-    ep_lib::MPI_Irecv(&recvBuff[0]+2*idx, 2, EP_INT,
+    MPI_Irecv(&recvBuff[0]+2*idx, 2, MPI_INT,
               recvRank[idx], MPI_DHT_INDEX_0, this->internalComm_, &request[nRequest]);
     ++nRequest;
@@ -831,10 +716,10 @@
   for (int idx = 0; idx < sendBuffSize; ++idx)
   {
-    ep_lib::MPI_Isend(&sendBuff[idx*2], 2, EP_INT,
+    MPI_Isend(&sendBuff[idx*2], 2, MPI_INT,
               sendRank[idx], MPI_DHT_INDEX_0, this->internalComm_, &request[nRequest]);
     ++nRequest;
   }
 
-  ep_lib::MPI_Waitall(sendBuffSize+recvBuffSize, &request[0], &requestStatus[0]);
+  MPI_Waitall(sendBuffSize+recvBuffSize, &request[0], &requestStatus[0]);
   int nbRecvRank = 0, nbRecvElements = 0;
   recvNbRank.clear();
Index: /XIOS/trunk/src/client_server_mapping.cpp
===================================================================
--- /XIOS/trunk/src/client_server_mapping.cpp	(revision 1638)
+++ /XIOS/trunk/src/client_server_mapping.cpp	(revision 1639)
@@ -30,5 +30,5 @@
 */
 std::map<int,int> CClientServerMapping::computeConnectedClients(int nbServer, int nbClient,
-                                                                ep_lib::MPI_Comm& clientIntraComm,
+                                                                MPI_Comm& clientIntraComm,
                                                                 const std::vector<int>& connectedServerRank)
 {
@@ -62,5 +62,5 @@
 
   // get connected server for everybody
-  ep_lib::MPI_Allgather(&nbConnectedServer,1,EP_INT,recvCount,1,EP_INT,clientIntraComm) ;
+  MPI_Allgather(&nbConnectedServer,1,MPI_INT,recvCount,1,MPI_INT,clientIntraComm) ;
 
   displ[0]=0 ;
@@ -70,5 +70,5 @@
 
 
-  ep_lib::MPI_Allgatherv(sendBuff,nbConnectedServer,EP_INT,recvBuff,recvCount,displ,EP_INT,clientIntraComm) ;
+  MPI_Allgatherv(sendBuff,nbConnectedServer,MPI_INT,recvBuff,recvCount,displ,MPI_INT,clientIntraComm) ;
   for(int n=0;n<recvSize;n++) clientRes[recvBuff[n]]++ ;
 
Index: /XIOS/trunk/src/client_server_mapping.hpp
===================================================================
--- /XIOS/trunk/src/client_server_mapping.hpp	(revision 1638)
+++ /XIOS/trunk/src/client_server_mapping.hpp	(revision 1639)
@@ -37,5 +37,5 @@
 
     static std::map<int,int> computeConnectedClients(int nbServer, int nbClient,
-                                                     ep_lib::MPI_Comm& clientIntraComm,
+                                                     MPI_Comm& clientIntraComm,
                                                      const std::vector<int>& connectedServerRank);
 
Index: /XIOS/trunk/src/client_server_mapping_distributed.cpp
===================================================================
--- /XIOS/trunk/src/client_server_mapping_distributed.cpp	(revision 1638)
+++ /XIOS/trunk/src/client_server_mapping_distributed.cpp	(revision 1639)
@@ -20,5 +20,5 @@
 
 CClientServerMappingDistributed::CClientServerMappingDistributed(const std::unordered_map<size_t,int>& globalIndexOfServer,
-                                                                 const ep_lib::MPI_Comm& clientIntraComm, bool isDataDistributed)
+                                                                 const MPI_Comm& clientIntraComm, bool isDataDistributed)
   : CClientServerMapping(), ccDHT_(0)
 {
Index: /XIOS/trunk/src/client_server_mapping_distributed.hpp
===================================================================
--- /XIOS/trunk/src/client_server_mapping_distributed.hpp	(revision 1638)
+++ /XIOS/trunk/src/client_server_mapping_distributed.hpp	(revision 1639)
@@ -35,5 +35,5 @@
     /** Default constructor */
     CClientServerMappingDistributed(const std::unordered_map<size_t,int>& globalIndexOfServer,
-                                    const ep_lib::MPI_Comm& clientIntraComm,
+                                    const MPI_Comm& clientIntraComm,
                                     bool isDataDistributed = true);
 
Index: /XIOS/trunk/src/context_client.cpp
===================================================================
--- /XIOS/trunk/src/context_client.cpp	(revision 1638)
+++ /XIOS/trunk/src/context_client.cpp	(revision 1639)
@@ -21,5 +21,5 @@
     \cxtSer [in] cxtSer Pointer to context of server side. (It is only used in case of attached mode).
     */
-    CContextClient::CContextClient(CContext* parent, ep_lib::MPI_Comm intraComm_, ep_lib::MPI_Comm interComm_, CContext* cxtSer)
+    CContextClient::CContextClient(CContext* parent, MPI_Comm intraComm_, MPI_Comm interComm_, CContext* cxtSer)
      : mapBufferSize_(), parentServer(cxtSer), maxBufferedEvents(4)
     {
@@ -27,11 +27,11 @@
       intraComm = intraComm_;
       interComm = interComm_;
-      ep_lib::MPI_Comm_rank(intraComm, &clientRank);
-      ep_lib::MPI_Comm_size(intraComm, &clientSize);
+      MPI_Comm_rank(intraComm, &clientRank);
+      MPI_Comm_size(intraComm, &clientSize);
 
       int flag;
-      ep_lib::MPI_Comm_test_inter(interComm, &flag);
-      if (flag) ep_lib::MPI_Comm_remote_size(interComm, &serverSize);
-      else  ep_lib::MPI_Comm_size(interComm, &serverSize);
+      MPI_Comm_test_inter(interComm, &flag);
+      if (flag) MPI_Comm_remote_size(interComm, &serverSize);
+      else  MPI_Comm_size(interComm, &serverSize);
 
       computeLeader(clientRank, clientSize, serverSize, ranksServerLeader, ranksServerNotLeader);
@@ -102,7 +102,7 @@
         classId_in=event.getClassId() ;
 //        MPI_Allreduce(&timeLine,&timeLine_out, 1, MPI_UINT64_T, MPI_SUM, intraComm) ; // MPI_UINT64_T standardized by MPI 3
-        ep_lib::MPI_Allreduce(&timeLine,&timeLine_out, 1, EP_LONG_LONG_INT, EP_SUM, intraComm) ; 
-        ep_lib::MPI_Allreduce(&typeId_in,&typeId, 1, EP_INT, EP_SUM, intraComm) ;
-        ep_lib::MPI_Allreduce(&classId_in,&classId, 1, EP_INT, EP_SUM, intraComm) ;
+        MPI_Allreduce(&timeLine,&timeLine_out, 1, MPI_LONG_LONG_INT, MPI_SUM, intraComm) ; 
+        MPI_Allreduce(&typeId_in,&typeId, 1, MPI_INT, MPI_SUM, intraComm) ;
+        MPI_Allreduce(&classId_in,&classId, 1, MPI_INT, MPI_SUM, intraComm) ;
         if (typeId/clientSize!=event.getTypeId() || classId/clientSize!=event.getClassId() || timeLine_out/clientSize!=timeLine)
         {
@@ -343,9 +343,5 @@
        if (ratio < minBufferSizeEventSizeRatio) minBufferSizeEventSizeRatio = ratio;
      }
-     #ifdef _usingMPI
-     ep_lib::MPI_Allreduce(MPI_IN_PLACE, &minBufferSizeEventSizeRatio, 1, EP_DOUBLE, EP_MIN, intraComm);
-     #elif _usingEP
-     ep_lib::MPI_Allreduce(&minBufferSizeEventSizeRatio, &minBufferSizeEventSizeRatio, 1, EP_DOUBLE, EP_MIN, intraComm);
-     #endif
+     MPI_Allreduce(MPI_IN_PLACE, &minBufferSizeEventSizeRatio, 1, MPI_DOUBLE, MPI_MIN, intraComm);
 
      if (minBufferSizeEventSizeRatio < 1.0)
Index: /XIOS/trunk/src/context_client.hpp
===================================================================
--- /XIOS/trunk/src/context_client.hpp	(revision 1638)
+++ /XIOS/trunk/src/context_client.hpp	(revision 1639)
@@ -27,5 +27,5 @@
     public:
       // Contructor
-      CContextClient(CContext* parent, ep_lib::MPI_Comm intraComm, ep_lib::MPI_Comm interComm, CContext* parentServer = 0);
+      CContextClient(CContext* parent, MPI_Comm intraComm, MPI_Comm interComm, CContext* parentServer = 0);
 
       // Send event to server
@@ -71,7 +71,7 @@
       int serverSize; //!< Size of server group
 
-      ep_lib::MPI_Comm interComm; //!< Communicator of server group
+      MPI_Comm interComm; //!< Communicator of server group
 
-      ep_lib::MPI_Comm intraComm; //!< Communicator of client group
+      MPI_Comm intraComm; //!< Communicator of client group
 
       map<int,CClientBuffer*> buffers; //!< Buffers for connection to servers
Index: /XIOS/trunk/src/context_server.cpp
===================================================================
--- /XIOS/trunk/src/context_server.cpp	(revision 1638)
+++ /XIOS/trunk/src/context_server.cpp	(revision 1639)
@@ -23,16 +23,16 @@
 {
 
-  CContextServer::CContextServer(CContext* parent,ep_lib::MPI_Comm intraComm_,ep_lib::MPI_Comm interComm_)
+  CContextServer::CContextServer(CContext* parent,MPI_Comm intraComm_,MPI_Comm interComm_)
   {
     context=parent;
     intraComm=intraComm_;
-    ep_lib::MPI_Comm_size(intraComm,&intraCommSize);
-    ep_lib::MPI_Comm_rank(intraComm,&intraCommRank);
+    MPI_Comm_size(intraComm,&intraCommSize);
+    MPI_Comm_rank(intraComm,&intraCommRank);
 
     interComm=interComm_;
     int flag;
-    ep_lib::MPI_Comm_test_inter(interComm,&flag);
-    if (flag) ep_lib::MPI_Comm_remote_size(interComm,&commSize);
-    else  ep_lib::MPI_Comm_size(interComm,&commSize);
+    MPI_Comm_test_inter(interComm,&flag);
+    if (flag) MPI_Comm_remote_size(interComm,&commSize);
+    else  MPI_Comm_size(interComm,&commSize);
 
     currentTimeLine=0;
@@ -76,23 +76,15 @@
     int count;
     char * addr;
-    ep_lib::MPI_Status status;
+    MPI_Status status;
     map<int,CServerBuffer*>::iterator it;
     bool okLoop;
 
     traceOff();
-    #ifdef _usingMPI
     MPI_Iprobe(MPI_ANY_SOURCE, 20,interComm,&flag,&status);
-    #elif _usingEP
-    ep_lib::MPI_Iprobe(-2, 20,interComm,&flag,&status);
-    #endif
     traceOn();
 
     if (flag==true)
     {
-      #ifdef _usingMPI
       rank=status.MPI_SOURCE ;
-      #elif _usingEP
-      rank=status.ep_src ;
-      #endif
       okLoop = true;
       if (pendingRequest.find(rank)==pendingRequest.end())
@@ -106,5 +98,5 @@
 
             traceOff();
-            ep_lib::MPI_Iprobe(rank, 20,interComm,&flag,&status);
+            MPI_Iprobe(rank, 20,interComm,&flag,&status);
             traceOn();
             if (flag==true) listenPendingRequest(status) ;
@@ -115,14 +107,10 @@
   }
 
-  bool CContextServer::listenPendingRequest(ep_lib::MPI_Status& status)
+  bool CContextServer::listenPendingRequest(MPI_Status& status)
   {
     int count;
     char * addr;
     map<int,CServerBuffer*>::iterator it;
-    #ifdef _usingMPI
     int rank=status.MPI_SOURCE ;
-    #elif _usingEP
-    int rank=status.ep_src ;
-    #endif
 
     it=buffers.find(rank);
@@ -130,5 +118,5 @@
     {
        StdSize buffSize = 0;
-       ep_lib::MPI_Recv(&buffSize, 1, EP_LONG, rank, 20, interComm, &status);
+       MPI_Recv(&buffSize, 1, MPI_LONG, rank, 20, interComm, &status);
        mapBufferSize_.insert(std::make_pair(rank, buffSize));
        it=(buffers.insert(pair<int,CServerBuffer*>(rank,new CServerBuffer(buffSize)))).first;
@@ -137,9 +125,9 @@
     else
     {
-      ep_lib::MPI_Get_count(&status,EP_CHAR,&count);
+      MPI_Get_count(&status,MPI_CHAR,&count);
       if (it->second->isBufferFree(count))
       {
          addr=(char*)it->second->getBuffer(count);
-         ep_lib::MPI_Irecv(addr,count,EP_CHAR,rank,20,interComm,&pendingRequest[rank]);
+         MPI_Irecv(addr,count,MPI_CHAR,rank,20,interComm,&pendingRequest[rank]);
          bufferRequest[rank]=addr;
          return true;
@@ -153,5 +141,5 @@
   void CContextServer::checkPendingRequest(void)
   {
-    map<int,ep_lib::MPI_Request>::iterator it;
+    map<int,MPI_Request>::iterator it;
     list<int> recvRequest;
     list<int>::iterator itRecv;
@@ -159,5 +147,5 @@
     int flag;
     int count;
-    ep_lib::MPI_Status status;
+    MPI_Status status;
 
     for(it=pendingRequest.begin();it!=pendingRequest.end();it++)
@@ -165,10 +153,10 @@
       rank=it->first;
       traceOff();
-      ep_lib::MPI_Test(& it->second, &flag, &status);
+      MPI_Test(& it->second, &flag, &status);
       traceOn();
       if (flag==true)
       {
         recvRequest.push_back(rank);
-        ep_lib::MPI_Get_count(&status,EP_CHAR,&count);
+        MPI_Get_count(&status,MPI_CHAR,&count);
         processRequest(rank,bufferRequest[rank],count);
       }
@@ -230,5 +218,5 @@
          // The best way to properly solve this problem will be to use the event scheduler also in attached mode
          // for now just set up a MPI barrier
-         if (!CServer::eventScheduler && CXios::isServer) ep_lib::MPI_Barrier(intraComm) ;
+         if (!CServer::eventScheduler && CXios::isServer) MPI_Barrier(intraComm) ;
 
          CTimer::get("Process events").resume();
Index: /XIOS/trunk/src/context_server.hpp
===================================================================
--- /XIOS/trunk/src/context_server.hpp	(revision 1638)
+++ /XIOS/trunk/src/context_server.hpp	(revision 1639)
@@ -14,8 +14,8 @@
     public:
 
-    CContextServer(CContext* parent,ep_lib::MPI_Comm intraComm,ep_lib::MPI_Comm interComm) ;
+    CContextServer(CContext* parent,MPI_Comm intraComm,MPI_Comm interComm) ;
     bool eventLoop(bool enableEventsProcessing = true);
     void listen(void) ;
-    bool listenPendingRequest(ep_lib::MPI_Status& status) ;
+    bool listenPendingRequest(MPI_Status& status) ;
     void checkPendingRequest(void) ;
     void processRequest(int rank, char* buff,int count) ;
@@ -26,13 +26,13 @@
     bool hasPendingEvent(void) ;
 
-    ep_lib::MPI_Comm intraComm ;
+    MPI_Comm intraComm ;
     int intraCommSize ;
     int intraCommRank ;
 
-    ep_lib::MPI_Comm interComm ;
+    MPI_Comm interComm ;
     int commSize ;
 
     map<int,CServerBuffer*> buffers ;
-    map<int,ep_lib::MPI_Request> pendingRequest ;
+    map<int,MPI_Request> pendingRequest ;
     map<int,char*> bufferRequest ;
 
Index: /XIOS/trunk/src/cxios.cpp
===================================================================
--- /XIOS/trunk/src/cxios.cpp	(revision 1638)
+++ /XIOS/trunk/src/cxios.cpp	(revision 1639)
@@ -26,5 +26,5 @@
   bool CXios::isClient ;
   bool CXios::isServer ;
-  ep_lib::MPI_Comm CXios::globalComm ;
+  MPI_Comm CXios::globalComm ;
   bool CXios::usingOasis ;
   bool CXios::usingServer = false;
@@ -90,13 +90,6 @@
 
     checkEventSync = getin<bool>("check_event_sync", checkEventSync);
-    #ifdef _usingMPI
+
     globalComm=MPI_COMM_WORLD ;
-    #elif _usingEP
-    ep_lib::MPI_Comm *ep_comm;
-    ep_lib::MPI_Info info;
-    ep_lib::MPI_Comm_create_endpoints(EP_COMM_WORLD->mpi_comm, 1, info, ep_comm);
-    ep_lib::passage = ep_comm;
-    globalComm=ep_lib::passage[0] ;
-    #endif
   }
 
@@ -107,16 +100,13 @@
   \param [in/out] returnComm communicator corresponding to group of client with same codeId
   */
-  void CXios::initClientSide(const string& codeId, ep_lib::MPI_Comm& localComm, ep_lib::MPI_Comm& returnComm)
+  void CXios::initClientSide(const string& codeId, MPI_Comm& localComm, MPI_Comm& returnComm)
   TRY
   {
+    initialize() ;
+
     isClient = true;
-    isServer = false;
-
-    initialize() ;
-
 
     CClient::initialize(codeId,localComm,returnComm) ;
     if (CClient::getRank()==0) globalRegistry = new CRegistry(returnComm) ;
-
 
     // If there are no server processes then we are in attached mode
@@ -177,10 +167,8 @@
   void CXios::initServerSide(void)
   {
-    isClient = false;
-    isServer = true;
-
     initServer();
     isClient = false;
     isServer = true;
+
     // Initialize all aspects MPI
     CServer::initialize();
@@ -235,5 +223,5 @@
         int firstPoolGlobalRank = secondaryServerGlobalRanks[0];
         int rankGlobal;
-        ep_lib::MPI_Comm_rank(globalComm, &rankGlobal);
+        MPI_Comm_rank(globalComm, &rankGlobal);
 
         // Merge registries defined on each pools
@@ -247,8 +235,8 @@
             globalRegistrySndServers.mergeRegistry(*globalRegistry) ;
             int registrySize = globalRegistrySndServers.size();
-            ep_lib::MPI_Send(&registrySize,1,EP_LONG,firstPoolGlobalRank,15,CXios::globalComm) ;
+            MPI_Send(&registrySize,1,MPI_LONG,firstPoolGlobalRank,15,CXios::globalComm) ;
             CBufferOut buffer(registrySize) ;
             globalRegistrySndServers.toBuffer(buffer) ;
-            ep_lib::MPI_Send(buffer.start(),registrySize,EP_CHAR,firstPoolGlobalRank,15,CXios::globalComm) ;
+            MPI_Send(buffer.start(),registrySize,MPI_CHAR,firstPoolGlobalRank,15,CXios::globalComm) ;
           }
         }
@@ -257,5 +245,5 @@
         if (rankGlobal == firstPoolGlobalRank)
         {
-          ep_lib::MPI_Status status;
+          MPI_Status status;
           char* recvBuff;
 
@@ -266,7 +254,7 @@
             int rank = secondaryServerGlobalRanks[i];
             int registrySize = 0;
-            ep_lib::MPI_Recv(&registrySize, 1, EP_LONG, rank, 15, CXios::globalComm, &status);
+            MPI_Recv(&registrySize, 1, MPI_LONG, rank, 15, CXios::globalComm, &status);
             recvBuff = new char[registrySize];
-            ep_lib::MPI_Recv(recvBuff, registrySize, EP_CHAR, rank, 15, CXios::globalComm, &status);
+            MPI_Recv(recvBuff, registrySize, MPI_CHAR, rank, 15, CXios::globalComm, &status);
             CBufferIn buffer(recvBuff, registrySize) ;
             CRegistry recvRegistry;
Index: /XIOS/trunk/src/cxios.hpp
===================================================================
--- /XIOS/trunk/src/cxios.hpp	(revision 1638)
+++ /XIOS/trunk/src/cxios.hpp	(revision 1639)
@@ -15,5 +15,5 @@
     public:
      static void initialize(void) ;
-     static void initClientSide(const string & codeId, ep_lib::MPI_Comm& localComm, ep_lib::MPI_Comm& returnComm) ;
+     static void initClientSide(const string & codeId, MPI_Comm& localComm, MPI_Comm& returnComm) ;
      static void initServerSide(void) ;
      static void clientFinalize(void) ;
@@ -40,5 +40,5 @@
      static bool isServer ; //!< Check if xios is server
 
-     static ep_lib::MPI_Comm globalComm ; //!< Global communicator
+     static MPI_Comm globalComm ; //!< Global communicator
 
      static bool printLogs2Files; //!< Printing out logs into files
Index: /XIOS/trunk/src/dht_auto_indexing.cpp
===================================================================
--- /XIOS/trunk/src/dht_auto_indexing.cpp	(revision 1638)
+++ /XIOS/trunk/src/dht_auto_indexing.cpp	(revision 1639)
@@ -22,5 +22,5 @@
 
   CDHTAutoIndexing::CDHTAutoIndexing(const CArray<size_t,1>& hashValue,
-                                     const ep_lib::MPI_Comm& clientIntraComm)
+                                     const MPI_Comm& clientIntraComm)
     : CClientClientDHTTemplate<size_t>(clientIntraComm)
   {
@@ -28,12 +28,12 @@
     nbIndexOnProc_ = hashValue.size();
     size_t nbIndexAccum;
-    ep_lib::MPI_Scan(&nbIndexOnProc_, &nbIndexAccum, 1, EP_UNSIGNED_LONG, EP_SUM, clientIntraComm);
+    MPI_Scan(&nbIndexOnProc_, &nbIndexAccum, 1, MPI_UNSIGNED_LONG, MPI_SUM, clientIntraComm);
 
     // Broadcasting the total number of indexes
     int rank, size;
-    ep_lib::MPI_Comm_rank(clientIntraComm, &rank);
-    ep_lib::MPI_Comm_size(clientIntraComm, &size);
+    MPI_Comm_rank(clientIntraComm, &rank);
+    MPI_Comm_size(clientIntraComm, &size);
     if (rank == (size-1)) nbIndexesGlobal_ = nbIndexAccum;
-    ep_lib::MPI_Bcast(&nbIndexesGlobal_, 1, EP_UNSIGNED_LONG, size-1, clientIntraComm);
+    MPI_Bcast(&nbIndexesGlobal_, 1, MPI_UNSIGNED_LONG, size-1, clientIntraComm);
 
     CArray<size_t,1>::const_iterator itbIdx = hashValue.begin(), itIdx,
@@ -58,5 +58,5 @@
   */
   CDHTAutoIndexing::CDHTAutoIndexing(Index2VectorInfoTypeMap& hashInitMap,
-                                     const ep_lib::MPI_Comm& clientIntraComm)
+                                     const MPI_Comm& clientIntraComm)
     : CClientClientDHTTemplate<size_t>(clientIntraComm)
   {
@@ -64,11 +64,11 @@
     nbIndexOnProc_ = hashInitMap.size();
     size_t nbIndexAccum;
-    ep_lib::MPI_Scan(&nbIndexOnProc_, &nbIndexAccum, 1, EP_UNSIGNED_LONG, EP_SUM, clientIntraComm);
+    MPI_Scan(&nbIndexOnProc_, &nbIndexAccum, 1, MPI_UNSIGNED_LONG, MPI_SUM, clientIntraComm);
 
     int rank, size;
-    ep_lib::MPI_Comm_rank(clientIntraComm, &rank);
-    ep_lib::MPI_Comm_size(clientIntraComm, &size);
+    MPI_Comm_rank(clientIntraComm, &rank);
+    MPI_Comm_size(clientIntraComm, &size);
     if (rank == (size-1)) nbIndexesGlobal_ = nbIndexAccum;
-    ep_lib::MPI_Bcast(&nbIndexesGlobal_, 1, EP_UNSIGNED_LONG, size-1, clientIntraComm);
+    MPI_Bcast(&nbIndexesGlobal_, 1, MPI_UNSIGNED_LONG, size-1, clientIntraComm);
 
     Index2VectorInfoTypeMap::iterator itbIdx = hashInitMap.begin(), itIdx,
Index: /XIOS/trunk/src/dht_auto_indexing.hpp
===================================================================
--- /XIOS/trunk/src/dht_auto_indexing.hpp	(revision 1638)
+++ /XIOS/trunk/src/dht_auto_indexing.hpp	(revision 1639)
@@ -25,8 +25,8 @@
 
     CDHTAutoIndexing(const CArray<size_t,1>& hashValue,
-                     const ep_lib::MPI_Comm& clientIntraComm);
+                     const MPI_Comm& clientIntraComm);
 
     CDHTAutoIndexing(Index2VectorInfoTypeMap& hashInitMap,
-                     const ep_lib::MPI_Comm& clientIntraComm);
+                     const MPI_Comm& clientIntraComm);
 
     size_t getNbIndexesGlobal() const;
Index: /XIOS/trunk/src/event_scheduler.cpp
===================================================================
--- /XIOS/trunk/src/event_scheduler.cpp	(revision 1638)
+++ /XIOS/trunk/src/event_scheduler.cpp	(revision 1639)
@@ -8,9 +8,9 @@
  
  
-  CEventScheduler::CEventScheduler(const ep_lib::MPI_Comm& comm) 
-  {
-    ep_lib::MPI_Comm_dup(comm, &communicator) ;
-    ep_lib::MPI_Comm_size(communicator,&mpiSize) ;
-    ep_lib::MPI_Comm_rank(communicator,&mpiRank);
+  CEventScheduler::CEventScheduler(const MPI_Comm& comm) 
+  {
+    MPI_Comm_dup(comm, &communicator) ;
+    MPI_Comm_size(communicator,&mpiSize) ;
+    MPI_Comm_rank(communicator,&mpiRank);
 
 
@@ -88,5 +88,5 @@
 
     pendingSentParentRequest.push(sentRequest) ;
-    ep_lib::MPI_Isend(sentRequest->buffer,3, EP_UNSIGNED_LONG, parent[lev], 0, communicator, &sentRequest->request) ;
+    MPI_Isend(sentRequest->buffer,3, MPI_UNSIGNED_LONG, parent[lev], 0, communicator, &sentRequest->request) ;
     traceOn() ;
   } 
@@ -115,5 +115,5 @@
   {
     int completed ;
-    ep_lib::MPI_Status status ;
+    MPI_Status status ;
     int received ;
     SPendingRequest* recvRequest ;
@@ -135,17 +135,9 @@
     while(received)
     {
-      #ifdef _usingMPI
       MPI_Iprobe(MPI_ANY_SOURCE,1,communicator,&received, &status) ;
-      #elif _usingEP
-      ep_lib::MPI_Iprobe(-2,1,communicator,&received, &status) ;
-      #endif
       if (received)
       {
         recvRequest=new SPendingRequest ;
-        #ifdef _usingMPI
         MPI_Irecv(recvRequest->buffer, 3, MPI_UNSIGNED_LONG, MPI_ANY_SOURCE, 1, communicator, &(recvRequest->request)) ;
-        #elif _usingEP
-        ep_lib::MPI_Irecv(recvRequest->buffer, 3, EP_UNSIGNED_LONG, -2, 1, communicator, &(recvRequest->request)) ;
-        #endif
         pendingRecvParentRequest.push(recvRequest) ;
       }
@@ -157,5 +149,5 @@
     {
       recvRequest=pendingRecvParentRequest.front() ;
-      ep_lib::MPI_Test( &(recvRequest->request), &completed, &status) ;
+      MPI_Test( &(recvRequest->request), &completed, &status) ;
       if (completed) 
       {
@@ -177,5 +169,5 @@
 // function call only by parent mpi process
 
-    ep_lib::MPI_Status status ; 
+    MPI_Status status ; 
     int received ;
     received=true ;
@@ -185,17 +177,9 @@
     while(received)
     {
-      #ifdef _usingMPI
       MPI_Iprobe(MPI_ANY_SOURCE,0,communicator,&received, &status) ;
-      #elif _usingEP
-      ep_lib::MPI_Iprobe(-2,0,communicator,&received, &status) ;
-      #endif
       if (received)
       {
         recvRequest=new SPendingRequest ;
-        #ifdef _usingMPI
         MPI_Irecv(recvRequest->buffer, 3, MPI_UNSIGNED_LONG, MPI_ANY_SOURCE, 0, communicator, &recvRequest->request) ;
-        #elif _usingEP
-        ep_lib::MPI_Irecv(recvRequest->buffer, 3, EP_UNSIGNED_LONG, -2, 0, communicator, &recvRequest->request) ;
-        #endif
         pendingRecvChildRequest.push_back(recvRequest) ;
       }
@@ -206,5 +190,5 @@
     for(list<SPendingRequest*>::iterator it=pendingRecvChildRequest.begin(); it!=pendingRecvChildRequest.end() ; )
     {
-      ep_lib::MPI_Test(&((*it)->request),&received,&status) ;
+      MPI_Test(&((*it)->request),&received,&status) ;
       if (received)
       {
@@ -244,5 +228,5 @@
     for(list<SPendingRequest*>::iterator it=pendingSentChildRequest.begin(); it!=pendingSentChildRequest.end() ; )
     {
-      ep_lib::MPI_Test(&(*it)->request,&received,&status) ;
+      MPI_Test(&(*it)->request,&received,&status) ;
       if (received)
       {
@@ -267,5 +251,5 @@
       sentRequest->buffer[1]=contextHashId ;
       sentRequest->buffer[2]=lev+1 ;
-      ep_lib::MPI_Isend(sentRequest->buffer,3, EP_UNSIGNED_LONG, child[lev][i], 1, communicator, & sentRequest->request) ;
+      MPI_Isend(sentRequest->buffer,3, MPI_UNSIGNED_LONG, child[lev][i], 1, communicator, & sentRequest->request) ;
       pendingSentChildRequest.push_back(sentRequest) ;
     }
Index: /XIOS/trunk/src/event_scheduler.hpp
===================================================================
--- /XIOS/trunk/src/event_scheduler.hpp	(revision 1638)
+++ /XIOS/trunk/src/event_scheduler.hpp	(revision 1639)
@@ -26,5 +26,5 @@
         *  @param[in] comm : MPI communicator du duplicate for internal use
         */
-       CEventScheduler(const ep_lib::MPI_Comm& comm) ;
+       CEventScheduler(const MPI_Comm& comm) ;
 
 
@@ -151,8 +151,8 @@
        {
          size_t buffer[3] ;      /*!< communication buffer : timeLine, hashId, level */
-         ep_lib::MPI_Request request ;   /*!< pending MPI request */ 
+         MPI_Request request ;   /*!< pending MPI request */ 
        } ;
        
-       ep_lib::MPI_Comm communicator ;  /*!< Internal MPI communicator */ 
+       MPI_Comm communicator ;  /*!< Internal MPI communicator */ 
        int mpiRank ;            /*!< Rank in the communicator */
        int mpiSize ;            /*!< Size of the communicator */
Index: /XIOS/trunk/src/filter/spatial_transform_filter.cpp
===================================================================
--- /XIOS/trunk/src/filter/spatial_transform_filter.cpp	(revision 1638)
+++ /XIOS/trunk/src/filter/spatial_transform_filter.cpp	(revision 1639)
@@ -224,5 +224,5 @@
 
       idxSendBuff = 0;
-      std::vector<ep_lib::MPI_Request> sendRecvRequest;
+      std::vector<MPI_Request> sendRecvRequest;
       for (itSend = itbSend; itSend != iteSend; ++itSend, ++idxSendBuff)
       {
@@ -234,6 +234,6 @@
           sendBuff[idxSendBuff][idx] = dataCurrentSrc(localIndex_p(idx));
         }
-        sendRecvRequest.push_back(ep_lib::MPI_Request());
-        ep_lib::MPI_Isend(sendBuff[idxSendBuff], countSize, EP_DOUBLE, destRank, 12, client->intraComm, &sendRecvRequest.back());
+        sendRecvRequest.push_back(MPI_Request());
+        MPI_Isend(sendBuff[idxSendBuff], countSize, MPI_DOUBLE, destRank, 12, client->intraComm, &sendRecvRequest.back());
       }
 
@@ -252,10 +252,10 @@
         int srcRank = itRecv->first;
         int countSize = itRecv->second.size();
-        sendRecvRequest.push_back(ep_lib::MPI_Request());
-        ep_lib::MPI_Irecv(recvBuff + currentBuff, countSize, EP_DOUBLE, srcRank, 12, client->intraComm, &sendRecvRequest.back());
+        sendRecvRequest.push_back(MPI_Request());
+        MPI_Irecv(recvBuff + currentBuff, countSize, MPI_DOUBLE, srcRank, 12, client->intraComm, &sendRecvRequest.back());
         currentBuff += countSize;
       }
-      std::vector<ep_lib::MPI_Status> status(sendRecvRequest.size());
-      ep_lib::MPI_Waitall(sendRecvRequest.size(), &sendRecvRequest[0], &status[0]);
+      std::vector<MPI_Status> status(sendRecvRequest.size());
+      MPI_Waitall(sendRecvRequest.size(), &sendRecvRequest[0], &status[0]);
 
       dataCurrentDest.resize(*itNbListRecv);
Index: /XIOS/trunk/src/interface/c/icdata.cpp
===================================================================
--- /XIOS/trunk/src/interface/c/icdata.cpp	(revision 1638)
+++ /XIOS/trunk/src/interface/c/icdata.cpp	(revision 1639)
@@ -60,24 +60,15 @@
    {
       std::string str;
-      ep_lib::MPI_Comm local_comm;
-      ep_lib::MPI_Comm return_comm;
+      MPI_Comm local_comm;
+      MPI_Comm return_comm;
 
       if (!cstr2string(client_id, len_client_id, str)) return;
 
       int initialized;
-      ep_lib::MPI_Initialized(&initialized);
-      #ifdef _usingMPI
+      MPI_Initialized(&initialized);
       if (initialized) local_comm=MPI_Comm_f2c(*f_local_comm);
       else local_comm=MPI_COMM_NULL;
-      #elif _usingEP
-      if (initialized) local_comm=EP_Comm_f2c(f_local_comm);
-      else local_comm=EP_COMM_NULL;
-      #endif
       CXios::initClientSide(str, local_comm, return_comm);
-      #ifdef _usingMPI
       *f_return_comm=MPI_Comm_c2f(return_comm);
-      #elif _usingEP
-      *f_return_comm=*static_cast<MPI_Fint* >(EP_Comm_c2f(return_comm));
-      #endif
       CTimer::get("XIOS init").suspend();
       CTimer::get("XIOS").suspend();
@@ -89,14 +80,10 @@
    {
      std::string str;
-     ep_lib::MPI_Comm comm;
+     MPI_Comm comm;
 
      if (!cstr2string(context_id, len_context_id, str)) return;
      CTimer::get("XIOS").resume();
      CTimer::get("XIOS init context").resume();
-     #ifdef _usingMPI
      comm=MPI_Comm_f2c(*f_comm);
-     #elif _usingEP
-     comm=EP_Comm_f2c(f_comm);
-     #endif
      CClient::registerContext(str, comm);
      CTimer::get("XIOS init context").suspend();
Index: /XIOS/trunk/src/interface/c/oasis_cinterface.cpp
===================================================================
--- /XIOS/trunk/src/interface/c/oasis_cinterface.cpp	(revision 1638)
+++ /XIOS/trunk/src/interface/c/oasis_cinterface.cpp	(revision 1639)
@@ -21,26 +21,26 @@
   }
 
-  void oasis_get_localcomm(ep_lib::MPI_Comm& comm)
+  void oasis_get_localcomm(MPI_Comm& comm)
   {
-    ep_lib::MPI_Fint f_comm ;
+    MPI_Fint f_comm ;
     
     fxios_oasis_get_localcomm(&f_comm) ;
-    //comm=MPI_Comm_f2c(f_comm) ;
+    comm=MPI_Comm_f2c(f_comm) ;
   }
  
-  void oasis_get_intracomm(ep_lib::MPI_Comm& comm_client_server,const std::string& server_id)
+  void oasis_get_intracomm(MPI_Comm& comm_client_server,const std::string& server_id)
   {
-    ep_lib::MPI_Fint f_comm ;
+    MPI_Fint f_comm ;
     
     fxios_oasis_get_intracomm(&f_comm,server_id.data(),server_id.size()) ;
-    //comm_client_server=MPI_Comm_f2c(f_comm) ;
+    comm_client_server=MPI_Comm_f2c(f_comm) ;
   }
  
-  void oasis_get_intercomm(ep_lib::MPI_Comm& comm_client_server,const std::string& server_id)
+  void oasis_get_intercomm(MPI_Comm& comm_client_server,const std::string& server_id)
   {
-    ep_lib::MPI_Fint f_comm ;
+    MPI_Fint f_comm ;
     
     fxios_oasis_get_intercomm(&f_comm,server_id.data(),server_id.size()) ;
-    //comm_client_server=MPI_Comm_f2c(f_comm) ;
+    comm_client_server=MPI_Comm_f2c(f_comm) ;
   }
 }
Index: /XIOS/trunk/src/interface/c/oasis_cinterface.hpp
===================================================================
--- /XIOS/trunk/src/interface/c/oasis_cinterface.hpp	(revision 1638)
+++ /XIOS/trunk/src/interface/c/oasis_cinterface.hpp	(revision 1639)
@@ -10,7 +10,7 @@
   void fxios_oasis_enddef(void) ;
   void fxios_oasis_finalize(void) ;
-  void fxios_oasis_get_localcomm(ep_lib::MPI_Fint* f_comm) ;
-  void fxios_oasis_get_intracomm(ep_lib::MPI_Fint* f_comm_client_server,const char* client_id,int str_len) ;
-  void fxios_oasis_get_intercomm(ep_lib::MPI_Fint* f_comm_client_server,const char* client_id,int str_len) ;
+  void fxios_oasis_get_localcomm(MPI_Fint* f_comm) ;
+  void fxios_oasis_get_intracomm(MPI_Fint* f_comm_client_server,const char* client_id,int str_len) ;
+  void fxios_oasis_get_intercomm(MPI_Fint* f_comm_client_server,const char* client_id,int str_len) ;
 }
  
@@ -20,7 +20,7 @@
   void oasis_enddef(void) ;
   void oasis_finalize(void) ;
-  void oasis_get_localcomm(ep_lib::MPI_Comm& comm) ;
-  void oasis_get_intracomm(ep_lib::MPI_Comm& comm_client_server,const std::string& server_id) ;
-  void oasis_get_intercomm(ep_lib::MPI_Comm& comm_client_server,const std::string& server_id) ;
+  void oasis_get_localcomm(MPI_Comm& comm) ;
+  void oasis_get_intracomm(MPI_Comm& comm_client_server,const std::string& server_id) ;
+  void oasis_get_intercomm(MPI_Comm& comm_client_server,const std::string& server_id) ;
 }
 #endif
Index: /XIOS/trunk/src/io/inetcdf4.cpp
===================================================================
--- /XIOS/trunk/src/io/inetcdf4.cpp	(revision 1638)
+++ /XIOS/trunk/src/io/inetcdf4.cpp	(revision 1639)
@@ -7,5 +7,5 @@
 namespace xios
 {
-  CINetCDF4::CINetCDF4(const StdString& filename, const ep_lib::MPI_Comm* comm /*= NULL*/, bool multifile /*= true*/,
+  CINetCDF4::CINetCDF4(const StdString& filename, const MPI_Comm* comm /*= NULL*/, bool multifile /*= true*/,
                        bool readMetaDataPar /*= false*/, const StdString& timeCounterName /*= "time_counter"*/)
   {
@@ -14,5 +14,5 @@
     {
       int commSize = 0;
-      ep_lib::MPI_Comm_size(*comm, &commSize);
+      MPI_Comm_size(*comm, &commSize);
       if (commSize <= 1)
         comm = NULL;
@@ -23,5 +23,5 @@
     // even if Parallel NetCDF ends up being used.
     if (mpi)
-      CNetCdfInterface::openPar(filename, NC_NOWRITE | NC_MPIIO, *comm, EP_INFO_NULL, this->ncidp);
+      CNetCdfInterface::openPar(filename, NC_NOWRITE | NC_MPIIO, *comm, MPI_INFO_NULL, this->ncidp);
     else
       CNetCdfInterface::open(filename, NC_NOWRITE, this->ncidp);
Index: /XIOS/trunk/src/io/inetcdf4.hpp
===================================================================
--- /XIOS/trunk/src/io/inetcdf4.hpp	(revision 1638)
+++ /XIOS/trunk/src/io/inetcdf4.hpp	(revision 1639)
@@ -22,5 +22,5 @@
     public:
       /// Constructors ///
-      CINetCDF4(const StdString& filename, const ep_lib::MPI_Comm* comm = NULL, bool multifile = true,
+      CINetCDF4(const StdString& filename, const MPI_Comm* comm = NULL, bool multifile = true,
                 bool readMetaDataPar = false, const StdString& timeCounterName = "time_counter");
 
Index: /XIOS/trunk/src/io/nc4_data_input.cpp
===================================================================
--- /XIOS/trunk/src/io/nc4_data_input.cpp	(revision 1638)
+++ /XIOS/trunk/src/io/nc4_data_input.cpp	(revision 1639)
@@ -10,5 +10,5 @@
 namespace xios
 {
-  CNc4DataInput::CNc4DataInput(const StdString& filename, ep_lib::MPI_Comm comm_file, bool multifile, bool isCollective /*= true*/,
+  CNc4DataInput::CNc4DataInput(const StdString& filename, MPI_Comm comm_file, bool multifile, bool isCollective /*= true*/,
                                bool readMetaDataPar /*= false*/, bool ugridConvention /*= false*/, const StdString& timeCounterName /*= "time_counter"*/)
     : SuperClass()
Index: /XIOS/trunk/src/io/nc4_data_input.hpp
===================================================================
--- /XIOS/trunk/src/io/nc4_data_input.hpp	(revision 1638)
+++ /XIOS/trunk/src/io/nc4_data_input.hpp	(revision 1639)
@@ -23,5 +23,5 @@
 
     /// Constructors ///
-    CNc4DataInput(const StdString& filename, ep_lib::MPI_Comm comm_file, bool multifile, bool isCollective = true,
+    CNc4DataInput(const StdString& filename, MPI_Comm comm_file, bool multifile, bool isCollective = true,
                   bool readMetaDataPar = false, bool ugridConvention = false, const StdString& timeCounterName = "time_counter");
     CNc4DataInput(const CNc4DataInput& dataInput);       // Not implemented.
@@ -70,5 +70,5 @@
   private:
     /// Private attributes ///
-    ep_lib::MPI_Comm comm_file;
+    MPI_Comm comm_file;
     const StdString filename;
     bool isCollective;
Index: /XIOS/trunk/src/io/nc4_data_output.cpp
===================================================================
--- /XIOS/trunk/src/io/nc4_data_output.cpp	(revision 1638)
+++ /XIOS/trunk/src/io/nc4_data_output.cpp	(revision 1639)
@@ -28,5 +28,5 @@
       CNc4DataOutput::CNc4DataOutput
          (CFile* file, const StdString & filename, bool exist, bool useClassicFormat, bool useCFConvention,
-          ep_lib::MPI_Comm comm_file, bool multifile, bool isCollective, const StdString& timeCounterName)
+          MPI_Comm comm_file, bool multifile, bool isCollective, const StdString& timeCounterName)
             : SuperClass()
             , SuperClassWriter(filename, exist, useClassicFormat, useCFConvention, &comm_file, multifile, timeCounterName)
Index: /XIOS/trunk/src/io/nc4_data_output.hpp
===================================================================
--- /XIOS/trunk/src/io/nc4_data_output.hpp	(revision 1638)
+++ /XIOS/trunk/src/io/nc4_data_output.hpp	(revision 1639)
@@ -27,5 +27,5 @@
                (CFile* file, const StdString & filename, bool exist, bool useClassicFormat,
                 bool useCFConvention,
-                ep_lib::MPI_Comm comm_file, bool multifile, bool isCollective = true,
+                MPI_Comm comm_file, bool multifile, bool isCollective = true,
                 const StdString& timeCounterName = "time_counter");
 
@@ -117,5 +117,5 @@
 
             /// PropriÃ©tÃ©s privÃ©es ///
-            ep_lib::MPI_Comm comm_file;
+            MPI_Comm comm_file;
             const StdString filename;
             std::map<Time, StdSize> timeToRecordCache;
Index: /XIOS/trunk/src/io/netCdfInterface.cpp
===================================================================
--- /XIOS/trunk/src/io/netCdfInterface.cpp	(revision 1638)
+++ /XIOS/trunk/src/io/netCdfInterface.cpp	(revision 1639)
@@ -10,5 +10,5 @@
 #include "netCdfInterface.hpp"
 #include "netCdfException.hpp"
-#include "ep_mpi.hpp"
+
 namespace xios
 {
@@ -47,11 +47,7 @@
 \return Status code
 */
-int CNetCdfInterface::createPar(const StdString& fileName, int cMode, ep_lib::MPI_Comm comm, ep_lib::MPI_Info info, int& ncId)
-{
-  #ifdef _usingMPI
+int CNetCdfInterface::createPar(const StdString& fileName, int cMode, MPI_Comm comm, MPI_Info info, int& ncId)
+{
   int status = xios::nc_create_par(fileName.c_str(), cMode, comm, info, &ncId);
-  #elif _usingEP
-  int status = xios::nc_create_par(fileName.c_str(), cMode, to_mpi_comm(comm->mpi_comm), to_mpi_info(info), &ncId);
-  #endif
   if (NC_NOERR != status)
   {
@@ -104,11 +100,7 @@
 \return Status code
 */
-int CNetCdfInterface::openPar(const StdString& fileName, int oMode, ep_lib::MPI_Comm comm, ep_lib::MPI_Info info, int& ncId)
-{
-  #ifdef _usingMPI
+int CNetCdfInterface::openPar(const StdString& fileName, int oMode, MPI_Comm comm, MPI_Info info, int& ncId)
+{
   int status = xios::nc_open_par(fileName.c_str(), oMode, comm, info, &ncId);
-  #elif _usingEP
-  int status = xios::nc_open_par(fileName.c_str(), oMode, to_mpi_comm(comm->mpi_comm), to_mpi_info(info), &ncId);
-  #endif
   if (NC_NOERR != status)
   {
Index: /XIOS/trunk/src/io/netCdfInterface.hpp
===================================================================
--- /XIOS/trunk/src/io/netCdfInterface.hpp	(revision 1638)
+++ /XIOS/trunk/src/io/netCdfInterface.hpp	(revision 1639)
@@ -32,5 +32,5 @@
 
     //! Create a netcdf file on a parallel file system
-    static int createPar(const StdString& path, int cmode, ep_lib::MPI_Comm comm, ep_lib::MPI_Info info, int& ncId);
+    static int createPar(const StdString& path, int cmode, MPI_Comm comm, MPI_Info info, int& ncId);
 
     //! Open a netcdf file
@@ -38,5 +38,5 @@
 
     //! Open a netcdf file
-    static int openPar(const StdString& path, int cmode, ep_lib::MPI_Comm comm, ep_lib::MPI_Info info, int& ncId);
+    static int openPar(const StdString& path, int cmode, MPI_Comm comm, MPI_Info info, int& ncId);
 
     //! Close a netcdf file
Index: /XIOS/trunk/src/io/onetcdf4.cpp
===================================================================
--- /XIOS/trunk/src/io/onetcdf4.cpp	(revision 1638)
+++ /XIOS/trunk/src/io/onetcdf4.cpp	(revision 1639)
@@ -15,5 +15,5 @@
       CONetCDF4::CONetCDF4(const StdString& filename, bool append, bool useClassicFormat,
 							bool useCFConvention,
-                           const ep_lib::MPI_Comm* comm, bool multifile, const StdString& timeCounterName)
+                           const MPI_Comm* comm, bool multifile, const StdString& timeCounterName)
         : path()
         , wmpi(false)
@@ -33,5 +33,5 @@
 
       void CONetCDF4::initialize(const StdString& filename, bool append, bool useClassicFormat, bool useCFConvention, 
-                                 const ep_lib::MPI_Comm* comm, bool multifile, const StdString& timeCounterName)
+                                 const MPI_Comm* comm, bool multifile, const StdString& timeCounterName)
       {
          this->useClassicFormat = useClassicFormat;
@@ -44,5 +44,5 @@
          {
             int commSize = 0;
-            ep_lib::MPI_Comm_size(*comm, &commSize);
+            MPI_Comm_size(*comm, &commSize);
             if (commSize <= 1)
                comm = NULL;
@@ -58,5 +58,5 @@
             CTimer::get("Files : create").resume();
             if (wmpi)
-               CNetCdfInterface::createPar(filename, mode, *comm, EP_INFO_NULL, this->ncidp);
+               CNetCdfInterface::createPar(filename, mode, *comm, MPI_INFO_NULL, this->ncidp);
             else
                CNetCdfInterface::create(filename, mode, this->ncidp);
@@ -70,5 +70,5 @@
             CTimer::get("Files : open").resume();
             if (wmpi)
-               CNetCdfInterface::openPar(filename, mode, *comm, EP_INFO_NULL, this->ncidp);
+               CNetCdfInterface::openPar(filename, mode, *comm, MPI_INFO_NULL, this->ncidp);
             else
                CNetCdfInterface::open(filename, mode, this->ncidp);
Index: /XIOS/trunk/src/io/onetcdf4.hpp
===================================================================
--- /XIOS/trunk/src/io/onetcdf4.hpp	(revision 1638)
+++ /XIOS/trunk/src/io/onetcdf4.hpp	(revision 1639)
@@ -28,5 +28,5 @@
             CONetCDF4(const StdString& filename, bool append, bool useClassicFormat = false,
             		  bool useCFConvention = true,
-                      const ep_lib::MPI_Comm* comm = NULL, bool multifile = true,
+                      const MPI_Comm* comm = NULL, bool multifile = true,
                       const StdString& timeCounterName = "time_counter");
 
@@ -37,5 +37,5 @@
             /// Initialisation ///
             void initialize(const StdString& filename, bool append, bool useClassicFormat, bool useCFConvention,
-                            const ep_lib::MPI_Comm* comm, bool multifile, const StdString& timeCounterName);
+                            const MPI_Comm* comm, bool multifile, const StdString& timeCounterName);
             void close(void);
             void sync(void);
Index: /XIOS/trunk/src/mpi.hpp
===================================================================
--- /XIOS/trunk/src/mpi.hpp	(revision 1638)
+++ /XIOS/trunk/src/mpi.hpp	(revision 1639)
@@ -11,35 +11,5 @@
 #define OMPI_SKIP_MPICXX
 
-#ifdef _usingEP
-#include "ep_lib.hpp"
-#include "ep_declaration.hpp"
-#endif
-
 #include <mpi.h>
 
-#ifdef _usingMPI
-
-#define ep_lib  
-
-#define EP_INT MPI_INT
-#define EP_FLOAT MPI_FLOAT
-#define EP_DOUBLE MPI_DOUBLE
-#define EP_CHAR MPI_CHAR
-#define EP_LONG MPI_LONG
-#define EP_LONG_LONG_INT MPI_LONG_LONG_INT
-#define EP_UNSIGNED_LONG  MPI_UNSIGNED_LONG
-#define EP_UNSIGNED_CHAR  MPI_UNSIGNED_CHAR
-
-
-#define EP_COMM_WORLD MPI_COMM_WORLD
-#define EP_COMM_NULL MPI_COMM_NULL
-#define EP_INFO_NULL MPI_INFO_NULL
-
-#define EP_MAX MPI_MAX
-#define EP_MIN MPI_MIN
-#define EP_SUM MPI_SUM
-#define EP_LOR MPI_LOR
-
 #endif
-
-#endif
Index: OS/trunk/src/mpi_std.hpp
===================================================================
--- /XIOS/trunk/src/mpi_std.hpp	(revision 1638)
+++ 	(revision )
@@ -1,22 +1,0 @@
-#ifndef __XIOS_MPI_HPP__
-#define __XIOS_MPI_HPP__
-
-/* skip C++ Binding for mpich , intel MPI */
-#define MPICH_SKIP_MPICXX
-
-/* skip C++ Binding for SGI MPI library */
-#define MPI_NO_CPPBIND
-
-/* skip C++ Binding for OpenMPI */
-#define OMPI_SKIP_MPICXX
-
-
-//#include "mpi_wrapper.hpp"
-#ifdef _usingEP
-#include "ep_lib.hpp"
-#include "ep_declaration.hpp"
-#endif
-
-#include <mpi.h>
-
-#endif
Index: /XIOS/trunk/src/node/axis.cpp
===================================================================
--- /XIOS/trunk/src/node/axis.cpp	(revision 1638)
+++ /XIOS/trunk/src/node/axis.cpp	(revision 1639)
@@ -130,9 +130,9 @@
      \return the number of indexes written by each server
    */
-   int CAxis::getNumberWrittenIndexes(ep_lib::MPI_Comm writtenCom)
+   int CAxis::getNumberWrittenIndexes(MPI_Comm writtenCom)
    TRY
    {
      int writtenSize;
-     ep_lib::MPI_Comm_size(writtenCom, &writtenSize);
+     MPI_Comm_size(writtenCom, &writtenSize);
      return numberWrittenIndexes_[writtenSize];
    }
@@ -143,9 +143,9 @@
      \return the total number of indexes written by the servers
    */
-   int CAxis::getTotalNumberWrittenIndexes(ep_lib::MPI_Comm writtenCom)
+   int CAxis::getTotalNumberWrittenIndexes(MPI_Comm writtenCom)
    TRY
    {
      int writtenSize;
-     ep_lib::MPI_Comm_size(writtenCom, &writtenSize);
+     MPI_Comm_size(writtenCom, &writtenSize);
      return totalNumberWrittenIndexes_[writtenSize];
    }
@@ -156,18 +156,18 @@
      \return the offset of indexes written by each server
    */
-   int CAxis::getOffsetWrittenIndexes(ep_lib::MPI_Comm writtenCom)
+   int CAxis::getOffsetWrittenIndexes(MPI_Comm writtenCom)
    TRY
    {
      int writtenSize;
-     ep_lib::MPI_Comm_size(writtenCom, &writtenSize);
+     MPI_Comm_size(writtenCom, &writtenSize);
      return offsetWrittenIndexes_[writtenSize];
    }
    CATCH_DUMP_ATTR
 
-   CArray<int, 1>& CAxis::getCompressedIndexToWriteOnServer(ep_lib::MPI_Comm writtenCom)
+   CArray<int, 1>& CAxis::getCompressedIndexToWriteOnServer(MPI_Comm writtenCom)
    TRY
    {
      int writtenSize;
-     ep_lib::MPI_Comm_size(writtenCom, &writtenSize);
+     MPI_Comm_size(writtenCom, &writtenSize);
      return compressedIndexToWriteOnServer[writtenSize];
    }
@@ -768,9 +768,9 @@
   CATCH_DUMP_ATTR
 
-  void CAxis::computeWrittenCompressedIndex(ep_lib::MPI_Comm writtenComm)
+  void CAxis::computeWrittenCompressedIndex(MPI_Comm writtenComm)
   TRY
   {
     int writtenCommSize;
-    ep_lib::MPI_Comm_size(writtenComm, &writtenCommSize);
+    MPI_Comm_size(writtenComm, &writtenCommSize);
     if (compressedIndexToWriteOnServer.find(writtenCommSize) != compressedIndexToWriteOnServer.end())
       return;
@@ -850,6 +850,6 @@
       {
              
-        ep_lib::MPI_Allreduce(&numberWrittenIndexes_[writtenCommSize], &totalNumberWrittenIndexes_[writtenCommSize], 1, EP_INT, EP_SUM, writtenComm);
-        ep_lib::MPI_Scan(&numberWrittenIndexes_[writtenCommSize], &offsetWrittenIndexes_[writtenCommSize], 1, EP_INT, EP_SUM, writtenComm);
+        MPI_Allreduce(&numberWrittenIndexes_[writtenCommSize], &totalNumberWrittenIndexes_[writtenCommSize], 1, MPI_INT, MPI_SUM, writtenComm);
+        MPI_Scan(&numberWrittenIndexes_[writtenCommSize], &offsetWrittenIndexes_[writtenCommSize], 1, MPI_INT, MPI_SUM, writtenComm);
         offsetWrittenIndexes_[writtenCommSize] -= numberWrittenIndexes_[writtenCommSize];
       }
Index: /XIOS/trunk/src/node/axis.hpp
===================================================================
--- /XIOS/trunk/src/node/axis.hpp	(revision 1638)
+++ /XIOS/trunk/src/node/axis.hpp	(revision 1639)
@@ -68,8 +68,8 @@
          const std::set<StdString> & getRelFiles(void) const;
 
-         int getNumberWrittenIndexes(ep_lib::MPI_Comm writtenCom);
-         int getTotalNumberWrittenIndexes(ep_lib::MPI_Comm writtenCom);
-         int getOffsetWrittenIndexes(ep_lib::MPI_Comm writtenCom);
-         CArray<int, 1>& getCompressedIndexToWriteOnServer(ep_lib::MPI_Comm writtenCom);
+         int getNumberWrittenIndexes(MPI_Comm writtenCom);
+         int getTotalNumberWrittenIndexes(MPI_Comm writtenCom);
+         int getOffsetWrittenIndexes(MPI_Comm writtenCom);
+         CArray<int, 1>& getCompressedIndexToWriteOnServer(MPI_Comm writtenCom);
 
          std::map<int, StdSize> getAttributesBufferSize(CContextClient* client, const std::vector<int>& globalDim, int orderPositionInGrid,
@@ -113,5 +113,5 @@
 
          void computeWrittenIndex();
-         void computeWrittenCompressedIndex(ep_lib::MPI_Comm);
+         void computeWrittenCompressedIndex(MPI_Comm);
          bool hasTransformation();
          void solveInheritanceTransformation();
Index: /XIOS/trunk/src/node/context.cpp
===================================================================
--- /XIOS/trunk/src/node/context.cpp	(revision 1638)
+++ /XIOS/trunk/src/node/context.cpp	(revision 1639)
@@ -265,10 +265,10 @@
 
    //! Initialize client side
-   void CContext::initClient(ep_lib::MPI_Comm intraComm, ep_lib::MPI_Comm interComm, CContext* cxtServer /*= 0*/)
+   void CContext::initClient(MPI_Comm intraComm, MPI_Comm interComm, CContext* cxtServer /*= 0*/)
    TRY
    {
 
      hasClient = true;
-     ep_lib::MPI_Comm intraCommServer, interCommServer;
+     MPI_Comm intraCommServer, interCommServer;
      
 
@@ -284,7 +284,7 @@
        else
        {
-         ep_lib::MPI_Comm_dup(intraComm, &intraCommServer);
+         MPI_Comm_dup(intraComm, &intraCommServer);
          comms.push_back(intraCommServer);
-         ep_lib::MPI_Comm_dup(interComm, &interCommServer);
+         MPI_Comm_dup(interComm, &interCommServer);
          comms.push_back(interCommServer);
        }
@@ -309,7 +309,7 @@
      {
        clientPrimServer.push_back(new CContextClient(this, intraComm, interComm));
-       ep_lib::MPI_Comm_dup(intraComm, &intraCommServer);
+       MPI_Comm_dup(intraComm, &intraCommServer);
        comms.push_back(intraCommServer);
-       ep_lib::MPI_Comm_dup(interComm, &interCommServer);
+       MPI_Comm_dup(interComm, &interCommServer);
        comms.push_back(interCommServer);
        serverPrimServer.push_back(new CContextServer(this, intraCommServer, interCommServer));
@@ -383,5 +383,5 @@
    CATCH_DUMP_ATTR
 
-   void CContext::initServer(ep_lib::MPI_Comm intraComm, ep_lib::MPI_Comm interComm, CContext* cxtClient /*= 0*/)
+   void CContext::initServer(MPI_Comm intraComm, MPI_Comm interComm, CContext* cxtClient /*= 0*/)
    TRY
    {
@@ -402,5 +402,5 @@
      registryOut->setPath(contextRegistryId) ;
 
-     ep_lib::MPI_Comm intraCommClient, interCommClient;
+     MPI_Comm intraCommClient, interCommClient;
      if (cxtClient) // Attached mode
      {
@@ -410,7 +410,7 @@
      else
      {
-       ep_lib::MPI_Comm_dup(intraComm, &intraCommClient);
+       MPI_Comm_dup(intraComm, &intraCommClient);
        comms.push_back(intraCommClient);
-       ep_lib::MPI_Comm_dup(interComm, &interCommClient);
+       MPI_Comm_dup(interComm, &interCommClient);
        comms.push_back(interCommClient);
      }
@@ -502,6 +502,6 @@
 
          //! Free internally allocated communicators
-         for (std::list<ep_lib::MPI_Comm>::iterator it = comms.begin(); it != comms.end(); ++it)
-           ep_lib::MPI_Comm_free(&(*it));
+         for (std::list<MPI_Comm>::iterator it = comms.begin(); it != comms.end(); ++it)
+           MPI_Comm_free(&(*it));
          comms.clear();
 
@@ -544,6 +544,6 @@
 
          //! Free internally allocated communicators
-         for (std::list<ep_lib::MPI_Comm>::iterator it = comms.begin(); it != comms.end(); ++it)
-           ep_lib::MPI_Comm_free(&(*it));
+         for (std::list<MPI_Comm>::iterator it = comms.begin(); it != comms.end(); ++it)
+           MPI_Comm_free(&(*it));
          comms.clear();
 
@@ -560,6 +560,6 @@
    TRY
    {
-     for (std::list<ep_lib::MPI_Comm>::iterator it = comms.begin(); it != comms.end(); ++it)
-       ep_lib::MPI_Comm_free(&(*it));
+     for (std::list<MPI_Comm>::iterator it = comms.begin(); it != comms.end(); ++it)
+       MPI_Comm_free(&(*it));
      comms.clear();
    }
Index: /XIOS/trunk/src/node/context.hpp
===================================================================
--- /XIOS/trunk/src/node/context.hpp	(revision 1638)
+++ /XIOS/trunk/src/node/context.hpp	(revision 1639)
@@ -88,6 +88,6 @@
       public :
          // Initialize server or client
-         void initClient(ep_lib::MPI_Comm intraComm, ep_lib::MPI_Comm interComm, CContext* cxtServer = 0);
-         void initServer(ep_lib::MPI_Comm intraComm, ep_lib::MPI_Comm interComm, CContext* cxtClient = 0);
+         void initClient(MPI_Comm intraComm, MPI_Comm interComm, CContext* cxtServer = 0);
+         void initServer(MPI_Comm intraComm, MPI_Comm interComm, CContext* cxtClient = 0);
          bool isInitialized(void);
 
@@ -263,5 +263,5 @@
          StdString idServer_;
          CGarbageCollector garbageCollector;
-         std::list<ep_lib::MPI_Comm> comms; //!< Communicators allocated internally
+         std::list<MPI_Comm> comms; //!< Communicators allocated internally
 
       public: // Some function maybe removed in the near future
Index: /XIOS/trunk/src/node/domain.cpp
===================================================================
--- /XIOS/trunk/src/node/domain.cpp	(revision 1638)
+++ /XIOS/trunk/src/node/domain.cpp	(revision 1639)
@@ -99,9 +99,9 @@
      \return the number of indexes written by each server
    */
-   int CDomain::getNumberWrittenIndexes(ep_lib::MPI_Comm writtenCom)
+   int CDomain::getNumberWrittenIndexes(MPI_Comm writtenCom)
    TRY
    {
      int writtenSize;
-     ep_lib::MPI_Comm_size(writtenCom, &writtenSize);
+     MPI_Comm_size(writtenCom, &writtenSize);
      return numberWrittenIndexes_[writtenSize];
    }
@@ -112,9 +112,9 @@
      \return the total number of indexes written by the servers
    */
-   int CDomain::getTotalNumberWrittenIndexes(ep_lib::MPI_Comm writtenCom)
+   int CDomain::getTotalNumberWrittenIndexes(MPI_Comm writtenCom)
    TRY
    {
      int writtenSize;
-     ep_lib::MPI_Comm_size(writtenCom, &writtenSize);
+     MPI_Comm_size(writtenCom, &writtenSize);
      return totalNumberWrittenIndexes_[writtenSize];
    }
@@ -125,18 +125,18 @@
      \return the offset of indexes written by each server
    */
-   int CDomain::getOffsetWrittenIndexes(ep_lib::MPI_Comm writtenCom)
+   int CDomain::getOffsetWrittenIndexes(MPI_Comm writtenCom)
    TRY
    {
      int writtenSize;
-     ep_lib::MPI_Comm_size(writtenCom, &writtenSize);
+     MPI_Comm_size(writtenCom, &writtenSize);
      return offsetWrittenIndexes_[writtenSize];
    }
    CATCH_DUMP_ATTR
 
-   CArray<int, 1>& CDomain::getCompressedIndexToWriteOnServer(ep_lib::MPI_Comm writtenCom)
+   CArray<int, 1>& CDomain::getCompressedIndexToWriteOnServer(MPI_Comm writtenCom)
    TRY
    {
      int writtenSize;
-     ep_lib::MPI_Comm_size(writtenCom, &writtenSize);
+     MPI_Comm_size(writtenCom, &writtenSize);
      return compressedIndexToWriteOnServer[writtenSize];
    }
@@ -690,14 +690,14 @@
      int v ;
      v=ibegin ;
-     ep_lib::MPI_Allgather(&v,1,EP_INT,ibegin_g,1,EP_INT,client->intraComm) ;
+     MPI_Allgather(&v,1,MPI_INT,ibegin_g,1,MPI_INT,client->intraComm) ;
      v=jbegin ;
-     ep_lib::MPI_Allgather(&v,1,EP_INT,jbegin_g,1,EP_INT,client->intraComm) ;
+     MPI_Allgather(&v,1,MPI_INT,jbegin_g,1,MPI_INT,client->intraComm) ;
      v=ni ;
-     ep_lib::MPI_Allgather(&v,1,EP_INT,ni_g,1,EP_INT,client->intraComm) ;
+     MPI_Allgather(&v,1,MPI_INT,ni_g,1,MPI_INT,client->intraComm) ;
      v=nj ;
-     ep_lib::MPI_Allgather(&v,1,EP_INT,nj_g,1,EP_INT,client->intraComm) ;
-
-     ep_lib::MPI_Allgatherv(lon.dataFirst(),ni,EP_DOUBLE,lon_g.dataFirst(),ni_g, ibegin_g,EP_DOUBLE,client->intraComm) ;
-     ep_lib::MPI_Allgatherv(lat.dataFirst(),nj,EP_DOUBLE,lat_g.dataFirst(),nj_g, jbegin_g,EP_DOUBLE,client->intraComm) ;
+     MPI_Allgather(&v,1,MPI_INT,nj_g,1,MPI_INT,client->intraComm) ;
+
+     MPI_Allgatherv(lon.dataFirst(),ni,MPI_DOUBLE,lon_g.dataFirst(),ni_g, ibegin_g,MPI_DOUBLE,client->intraComm) ;
+     MPI_Allgatherv(lat.dataFirst(),nj,MPI_DOUBLE,lat_g.dataFirst(),nj_g, jbegin_g,MPI_DOUBLE,client->intraComm) ;
 
       delete[] ibegin_g ;
@@ -1932,5 +1932,5 @@
           displs[0] = 0;
           int localCount = connectedServerRank_[nbServer].size() ;
-          ep_lib::MPI_Gather(&localCount, 1, EP_INT, &counts[0], 1, EP_INT, 0, client->intraComm) ;
+          MPI_Gather(&localCount, 1, MPI_INT, &counts[0], 1, MPI_INT, 0, client->intraComm) ;
           for (int i = 0; i < clientSize-1; ++i)
           {
@@ -1938,5 +1938,5 @@
           }
           std::vector<int> allConnectedServers(displs[clientSize-1]+counts[clientSize-1]);
-          ep_lib::MPI_Gatherv(&(connectedServerRank_[nbServer])[0], localCount, EP_INT, &allConnectedServers[0], &counts[0], &displs[0], EP_INT, 0, client->intraComm);
+          MPI_Gatherv(&(connectedServerRank_[nbServer])[0], localCount, MPI_INT, &allConnectedServers[0], &counts[0], &displs[0], MPI_INT, 0, client->intraComm);
 
           if ((allConnectedServers.size() != nbServer) && (rank == 0))
@@ -2003,9 +2003,9 @@
    CATCH_DUMP_ATTR
 
-  void CDomain::computeWrittenCompressedIndex(ep_lib::MPI_Comm writtenComm)
+  void CDomain::computeWrittenCompressedIndex(MPI_Comm writtenComm)
   TRY
   {
     int writtenCommSize;
-    ep_lib::MPI_Comm_size(writtenComm, &writtenCommSize);
+    MPI_Comm_size(writtenComm, &writtenCommSize);
     if (compressedIndexToWriteOnServer.find(writtenCommSize) != compressedIndexToWriteOnServer.end())
       return;
@@ -2064,6 +2064,6 @@
       {
              
-        ep_lib::MPI_Allreduce(&numberWrittenIndexes_[writtenCommSize], &totalNumberWrittenIndexes_[writtenCommSize], 1, EP_INT, EP_SUM, writtenComm);
-        ep_lib::MPI_Scan(&numberWrittenIndexes_[writtenCommSize], &offsetWrittenIndexes_[writtenCommSize], 1, EP_INT, EP_SUM, writtenComm);
+        MPI_Allreduce(&numberWrittenIndexes_[writtenCommSize], &totalNumberWrittenIndexes_[writtenCommSize], 1, MPI_INT, MPI_SUM, writtenComm);
+        MPI_Scan(&numberWrittenIndexes_[writtenCommSize], &offsetWrittenIndexes_[writtenCommSize], 1, MPI_INT, MPI_SUM, writtenComm);
         offsetWrittenIndexes_[writtenCommSize] -= numberWrittenIndexes_[writtenCommSize];
       }
Index: /XIOS/trunk/src/node/domain.hpp
===================================================================
--- /XIOS/trunk/src/node/domain.hpp	(revision 1638)
+++ /XIOS/trunk/src/node/domain.hpp	(revision 1639)
@@ -94,8 +94,8 @@
          bool isWrittenCompressed(const StdString& filename) const;
          
-         int getNumberWrittenIndexes(ep_lib::MPI_Comm writtenCom);
-         int getTotalNumberWrittenIndexes(ep_lib::MPI_Comm writtenCom);
-         int getOffsetWrittenIndexes(ep_lib::MPI_Comm writtenCom);
-         CArray<int,1>& getCompressedIndexToWriteOnServer(ep_lib::MPI_Comm writtenCom);
+         int getNumberWrittenIndexes(MPI_Comm writtenCom);
+         int getTotalNumberWrittenIndexes(MPI_Comm writtenCom);
+         int getOffsetWrittenIndexes(MPI_Comm writtenCom);
+         CArray<int,1>& getCompressedIndexToWriteOnServer(MPI_Comm writtenCom);
 
          std::map<int, StdSize> getAttributesBufferSize(CContextClient* client, bool bufferForWriting = false);
@@ -116,5 +116,5 @@
          
          void computeWrittenIndex();
-         void computeWrittenCompressedIndex(ep_lib::MPI_Comm);
+         void computeWrittenCompressedIndex(MPI_Comm);
 
          void AllgatherRectilinearLonLat(CArray<double,1>& lon, CArray<double,1>& lat,
Index: /XIOS/trunk/src/node/field.cpp
===================================================================
--- /XIOS/trunk/src/node/field.cpp	(revision 1638)
+++ /XIOS/trunk/src/node/field.cpp	(revision 1639)
@@ -531,9 +531,5 @@
     if (!nstepMaxRead)
     {
-       #ifdef _usingMPI
        MPI_Allreduce(MPI_IN_PLACE, &nstepMax, 1, MPI_INT, MPI_MAX, context->server->intraComm);
-       #elif _usingEP
-       ep_lib::MPI_Allreduce(&nstepMax, &nstepMax, 1, EP_INT, EP_MAX, context->server->intraComm);
-       #endif
        nstepMaxRead = true;
     }
Index: /XIOS/trunk/src/node/file.cpp
===================================================================
--- /XIOS/trunk/src/node/file.cpp	(revision 1638)
+++ /XIOS/trunk/src/node/file.cpp	(revision 1639)
@@ -25,5 +25,5 @@
    CFile::CFile(void)
       : CObjectTemplate<CFile>(), CFileAttributes()
-      , vFieldGroup(), data_out(), enabledFields(), fileComm(EP_COMM_NULL)
+      , vFieldGroup(), data_out(), enabledFields(), fileComm(MPI_COMM_NULL)
       , isOpen(false), read_client(0), checkRead(false), allZoneEmpty(false)
    {
@@ -34,5 +34,5 @@
    CFile::CFile(const StdString & id)
       : CObjectTemplate<CFile>(id), CFileAttributes()
-      , vFieldGroup(), data_out(), enabledFields(), fileComm(EP_COMM_NULL)
+      , vFieldGroup(), data_out(), enabledFields(), fileComm(MPI_COMM_NULL)
       , isOpen(false), read_client(0), checkRead(false), allZoneEmpty(false)
     {
@@ -307,6 +307,6 @@
 
       int color = allZoneEmpty ? 0 : 1;
-      ep_lib::MPI_Comm_split(server->intraComm, color, server->intraCommRank, &fileComm);
-      if (allZoneEmpty) ep_lib::MPI_Comm_free(&fileComm);
+      MPI_Comm_split(server->intraComm, color, server->intraCommRank, &fileComm);
+      if (allZoneEmpty) MPI_Comm_free(&fileComm);
     }
     CATCH_DUMP_ATTR
@@ -554,6 +554,6 @@
          {
             int commSize, commRank;
-            ep_lib::MPI_Comm_size(fileComm, &commSize);
-            ep_lib::MPI_Comm_rank(fileComm, &commRank);
+            MPI_Comm_size(fileComm, &commSize);
+            MPI_Comm_rank(fileComm, &commRank);
 
             if (server->intraCommSize > 1)
@@ -634,5 +634,5 @@
     CContext* context = CContext::getCurrent();
     CContextServer* server = context->server;
-    ep_lib::MPI_Comm readComm = this->fileComm;
+    MPI_Comm readComm = this->fileComm;
 
     if (!allZoneEmpty)
@@ -677,6 +677,6 @@
       {
         int commSize, commRank;
-        ep_lib::MPI_Comm_size(readComm, &commSize);
-        ep_lib::MPI_Comm_rank(readComm, &commRank);
+        MPI_Comm_size(readComm, &commSize);
+        MPI_Comm_rank(readComm, &commRank);
 
         if (server->intraCommSize > 1)
@@ -722,5 +722,5 @@
         isOpen = false;
        }
-      if (fileComm != EP_COMM_NULL) ep_lib::MPI_Comm_free(&fileComm);
+      if (fileComm != MPI_COMM_NULL) MPI_Comm_free(&fileComm);
    }
    CATCH_DUMP_ATTR
Index: /XIOS/trunk/src/node/file.hpp
===================================================================
--- /XIOS/trunk/src/node/file.hpp	(revision 1638)
+++ /XIOS/trunk/src/node/file.hpp	(revision 1639)
@@ -175,5 +175,5 @@
          int nbAxis, nbDomains;
          bool isOpen;         
-         ep_lib::MPI_Comm fileComm;
+         MPI_Comm fileComm;
 
       private:
Index: /XIOS/trunk/src/node/grid.cpp
===================================================================
--- /XIOS/trunk/src/node/grid.cpp	(revision 1638)
+++ /XIOS/trunk/src/node/grid.cpp	(revision 1639)
@@ -661,6 +661,6 @@
         {
           CContextServer* server = CContext::getCurrent()->server;      
-          ep_lib::MPI_Allreduce(&numberWrittenIndexes_, &totalNumberWrittenIndexes_, 1, EP_INT, EP_SUM, server->intraComm);
-          ep_lib::MPI_Scan(&numberWrittenIndexes_, &offsetWrittenIndexes_, 1, EP_INT, EP_SUM, server->intraComm);
+          MPI_Allreduce(&numberWrittenIndexes_, &totalNumberWrittenIndexes_, 1, MPI_INT, MPI_SUM, server->intraComm);
+          MPI_Scan(&numberWrittenIndexes_, &offsetWrittenIndexes_, 1, MPI_INT, MPI_SUM, server->intraComm);
           offsetWrittenIndexes_ -= numberWrittenIndexes_;
         }
@@ -856,5 +856,5 @@
          displs[0] = 0;
          int localCount = connectedServerRank_[receiverSize].size() ;
-         ep_lib::MPI_Gather(&localCount, 1, EP_INT, &counts[0], 1, EP_INT, 0, client->intraComm) ;
+         MPI_Gather(&localCount, 1, MPI_INT, &counts[0], 1, MPI_INT, 0, client->intraComm) ;
          for (int i = 0; i < client->clientSize-1; ++i)
          {
@@ -862,5 +862,5 @@
          }
          std::vector<int> allConnectedServers(displs[client->clientSize-1]+counts[client->clientSize-1]);
-         ep_lib::MPI_Gatherv(&(connectedServerRank_[receiverSize])[0], localCount, EP_INT, &allConnectedServers[0], &counts[0], &displs[0], EP_INT, 0, client->intraComm);
+         MPI_Gatherv(&(connectedServerRank_[receiverSize])[0], localCount, MPI_INT, &allConnectedServers[0], &counts[0], &displs[0], MPI_INT, 0, client->intraComm);
 
          if ((allConnectedServers.size() != receiverSize) && (client->clientRank == 0))
Index: /XIOS/trunk/src/node/mesh.cpp
===================================================================
--- /XIOS/trunk/src/node/mesh.cpp	(revision 1638)
+++ /XIOS/trunk/src/node/mesh.cpp	(revision 1639)
@@ -414,5 +414,5 @@
  * \param [in] bounds_lat Array of boundary latitudes. Its size depends on the element type.
  */
-  void CMesh::createMeshEpsilon(const ep_lib::MPI_Comm& comm,
+  void CMesh::createMeshEpsilon(const MPI_Comm& comm,
                                 const CArray<double, 1>& lonvalue, const CArray<double, 1>& latvalue,
                                 const CArray<double, 2>& bounds_lon, const CArray<double, 2>& bounds_lat)
@@ -421,6 +421,6 @@
     int nvertex = (bounds_lon.numElements() == 0) ? 1 : bounds_lon.rows();
     int mpiRank, mpiSize;
-    ep_lib::MPI_Comm_rank(comm, &mpiRank);
-    ep_lib::MPI_Comm_size(comm, &mpiSize);
+    MPI_Comm_rank(comm, &mpiRank);
+    MPI_Comm_size(comm, &mpiSize);
     double prec = 1e-11;  // used in calculations of edge_lon/lat
 
@@ -460,5 +460,5 @@
       unsigned long nbEdgesOnProc = nbEdges_;
       unsigned long nbEdgesAccum;
-      ep_lib::MPI_Scan(&nbEdgesOnProc, &nbEdgesAccum, 1, EP_UNSIGNED_LONG, EP_SUM, comm);
+      MPI_Scan(&nbEdgesOnProc, &nbEdgesAccum, 1, MPI_UNSIGNED_LONG, MPI_SUM, comm);
       nbEdgesAccum -= nbEdges_;
 
@@ -590,7 +590,7 @@
          unsigned long nodeCount = nodeIdx2Idx.size();
          unsigned long nodeStart, nbNodes;
-         ep_lib::MPI_Scan(&nodeCount, &nodeStart, 1, EP_UNSIGNED_LONG, EP_SUM, comm);
+         MPI_Scan(&nodeCount, &nodeStart, 1, MPI_UNSIGNED_LONG, MPI_SUM, comm);
          int nNodes = nodeStart;
-         ep_lib::MPI_Bcast(&nNodes, 1, EP_UNSIGNED_LONG, mpiSize-1, comm);
+         MPI_Bcast(&nNodes, 1, MPI_UNSIGNED_LONG, mpiSize-1, comm);
          nbNodesGlo = nNodes;
 
@@ -683,5 +683,5 @@
       unsigned long nbFacesOnProc = nbFaces_;
       unsigned long nbFacesAccum;
-      ep_lib::MPI_Scan(&nbFacesOnProc, &nbFacesAccum, 1, EP_UNSIGNED_LONG, EP_SUM, comm);
+      MPI_Scan(&nbFacesOnProc, &nbFacesAccum, 1, MPI_UNSIGNED_LONG, MPI_SUM, comm);
       nbFacesAccum -= nbFaces_;
 
@@ -807,7 +807,7 @@
 
         unsigned long edgeStart, nbEdges;
-        ep_lib::MPI_Scan(&edgeCount, &edgeStart, 1, EP_UNSIGNED_LONG, EP_SUM, comm);
+        MPI_Scan(&edgeCount, &edgeStart, 1, MPI_UNSIGNED_LONG, MPI_SUM, comm);
         int nEdges = edgeStart;
-        ep_lib::MPI_Bcast(&nEdges, 1, EP_UNSIGNED_LONG, mpiSize-1, comm);
+        MPI_Bcast(&nEdges, 1, MPI_UNSIGNED_LONG, mpiSize-1, comm);
         nbEdgesGlo = nEdges;
 
@@ -1028,7 +1028,7 @@
         unsigned long edgeCount = edgeIdx2Idx.size();
         unsigned long edgeStart, nbEdges;
-        ep_lib::MPI_Scan(&edgeCount, &edgeStart, 1, EP_UNSIGNED_LONG, EP_SUM, comm);
+        MPI_Scan(&edgeCount, &edgeStart, 1, MPI_UNSIGNED_LONG, MPI_SUM, comm);
         int nEdges = edgeStart;
-        ep_lib::MPI_Bcast(&nEdges, 1, EP_UNSIGNED_LONG, mpiSize-1, comm);
+        MPI_Bcast(&nEdges, 1, MPI_UNSIGNED_LONG, mpiSize-1, comm);
         nbEdgesGlo = nEdges;
 
@@ -1298,7 +1298,7 @@
         unsigned long nodeCount = nodeIdx2Idx.size();
         unsigned long nodeStart, nbNodes;
-        ep_lib::MPI_Scan(&nodeCount, &nodeStart, 1, EP_UNSIGNED_LONG, EP_SUM, comm);
+        MPI_Scan(&nodeCount, &nodeStart, 1, MPI_UNSIGNED_LONG, MPI_SUM, comm);
         int nNodes = nodeStart;
-        ep_lib::MPI_Bcast(&nNodes, 1, EP_UNSIGNED_LONG, mpiSize-1, comm);
+        MPI_Bcast(&nNodes, 1, MPI_UNSIGNED_LONG, mpiSize-1, comm);
         nbNodesGlo = nNodes;
 
@@ -1418,7 +1418,7 @@
         unsigned long edgeCount = edgeIdx2Idx.size();
         unsigned long edgeStart, nbEdges;
-        ep_lib::MPI_Scan(&edgeCount, &edgeStart, 1, EP_UNSIGNED_LONG, EP_SUM, comm);
+        MPI_Scan(&edgeCount, &edgeStart, 1, MPI_UNSIGNED_LONG, MPI_SUM, comm);
         int nEdges = edgeStart;
-        ep_lib::MPI_Bcast(&nEdges, 1, EP_UNSIGNED_LONG, mpiSize-1, comm);
+        MPI_Bcast(&nEdges, 1, MPI_UNSIGNED_LONG, mpiSize-1, comm);
         nbEdgesGlo = nEdges;
 
@@ -1614,5 +1614,5 @@
    */
 
-  void CMesh::getGloNghbFacesNodeType(const ep_lib::MPI_Comm& comm, const CArray<int, 1>& face_idx,
+  void CMesh::getGloNghbFacesNodeType(const MPI_Comm& comm, const CArray<int, 1>& face_idx,
                                const CArray<double, 2>& bounds_lon, const CArray<double, 2>& bounds_lat,
                                CArray<int, 2>& nghbFaces)
@@ -1623,6 +1623,6 @@
 
     int mpiRank, mpiSize;
-    ep_lib::MPI_Comm_rank(comm, &mpiRank);
-    ep_lib::MPI_Comm_size(comm, &mpiSize);
+    MPI_Comm_rank(comm, &mpiRank);
+    MPI_Comm_size(comm, &mpiSize);
 
     // (1) Generating unique node indexes
@@ -1770,5 +1770,5 @@
    */
 
-  void CMesh::getGloNghbFacesEdgeType(const ep_lib::MPI_Comm& comm, const CArray<int, 1>& face_idx,
+  void CMesh::getGloNghbFacesEdgeType(const MPI_Comm& comm, const CArray<int, 1>& face_idx,
                                const CArray<double, 2>& bounds_lon, const CArray<double, 2>& bounds_lat,
                                CArray<int, 2>& nghbFaces)
@@ -1779,6 +1779,6 @@
 
     int mpiRank, mpiSize;
-    ep_lib::MPI_Comm_rank(comm, &mpiRank);
-    ep_lib::MPI_Comm_size(comm, &mpiSize);
+    MPI_Comm_rank(comm, &mpiRank);
+    MPI_Comm_size(comm, &mpiSize);
 
     // (1) Generating unique node indexes
@@ -1951,5 +1951,5 @@
    */
 
-  void CMesh::getGlobalNghbFaces(const int nghbType, const ep_lib::MPI_Comm& comm,
+  void CMesh::getGlobalNghbFaces(const int nghbType, const MPI_Comm& comm,
                                  const CArray<int, 1>& face_idx,
                                  const CArray<double, 2>& bounds_lon, const CArray<double, 2>& bounds_lat,
Index: /XIOS/trunk/src/node/mesh.hpp
===================================================================
--- /XIOS/trunk/src/node/mesh.hpp	(revision 1638)
+++ /XIOS/trunk/src/node/mesh.hpp	(revision 1639)
@@ -60,9 +60,9 @@
                       const CArray<double, 2>&, const CArray<double, 2>& );
                         
-      void createMeshEpsilon(const ep_lib::MPI_Comm&,
+      void createMeshEpsilon(const MPI_Comm&,
                              const CArray<double, 1>&, const CArray<double, 1>&,
                              const CArray<double, 2>&, const CArray<double, 2>& );
 
-      void getGlobalNghbFaces(const int, const ep_lib::MPI_Comm&, const CArray<int, 1>&,
+      void getGlobalNghbFaces(const int, const MPI_Comm&, const CArray<int, 1>&,
                               const CArray<double, 2>&, const CArray<double, 2>&,
                               CArray<int, 2>&);
@@ -87,6 +87,6 @@
       CClientClientDHTSizet* pNodeGlobalIndex;                    // pointer to a map <nodeHash, nodeIdxGlo>
       CClientClientDHTSizet* pEdgeGlobalIndex;                    // pointer to a map <edgeHash, edgeIdxGlo>
-      void getGloNghbFacesNodeType(const ep_lib::MPI_Comm&, const CArray<int, 1>&, const CArray<double, 2>&, const CArray<double, 2>&, CArray<int, 2>&);
-      void getGloNghbFacesEdgeType(const ep_lib::MPI_Comm&, const CArray<int, 1>&, const CArray<double, 2>&, const CArray<double, 2>&, CArray<int, 2>&);
+      void getGloNghbFacesNodeType(const MPI_Comm&, const CArray<int, 1>&, const CArray<double, 2>&, const CArray<double, 2>&, CArray<int, 2>&);
+      void getGloNghbFacesEdgeType(const MPI_Comm&, const CArray<int, 1>&, const CArray<double, 2>&, const CArray<double, 2>&, CArray<int, 2>&);
       void getLocNghbFacesNodeType(const CArray<int, 1>&, const CArray<double, 2>&, const CArray<double, 2>&, CArray<int, 2>&, CArray<int, 1>&);
       void getLocNghbFacesEdgeType(const CArray<int, 1>&, const CArray<double, 2>&, const CArray<double, 2>&, CArray<int, 2>&, CArray<int, 1>&);
Index: /XIOS/trunk/src/policy.cpp
===================================================================
--- /XIOS/trunk/src/policy.cpp	(revision 1638)
+++ /XIOS/trunk/src/policy.cpp	(revision 1639)
@@ -49,5 +49,5 @@
 //}
 
-DivideAdaptiveComm::DivideAdaptiveComm(const ep_lib::MPI_Comm& mpiComm)
+DivideAdaptiveComm::DivideAdaptiveComm(const MPI_Comm& mpiComm)
   : internalComm_(mpiComm), level_(0), groupBegin_(), nbInGroup_(), computed_(false)
 {
@@ -61,6 +61,6 @@
 
   int mpiSize, mpiRank;
-  ep_lib::MPI_Comm_size(internalComm_,&mpiSize);
-  ep_lib::MPI_Comm_rank(internalComm_,&mpiRank);
+  MPI_Comm_size(internalComm_,&mpiSize);
+  MPI_Comm_rank(internalComm_,&mpiRank);
 
   int maxChild=1;
Index: /XIOS/trunk/src/policy.hpp
===================================================================
--- /XIOS/trunk/src/policy.hpp	(revision 1638)
+++ /XIOS/trunk/src/policy.hpp	(revision 1639)
@@ -31,5 +31,5 @@
 {
 protected:
-  DivideAdaptiveComm(const ep_lib::MPI_Comm& mpiComm);
+  DivideAdaptiveComm(const MPI_Comm& mpiComm);
 
   void computeMPICommLevel();
@@ -41,5 +41,5 @@
 
 protected:
-  const ep_lib::MPI_Comm& internalComm_;
+  const MPI_Comm& internalComm_;
   std::vector<std::vector<int> > groupParentsBegin_;
   std::vector<std::vector<int> > nbInGroupParents_;
Index: /XIOS/trunk/src/registry.cpp
===================================================================
--- /XIOS/trunk/src/registry.cpp	(revision 1638)
+++ /XIOS/trunk/src/registry.cpp	(revision 1639)
@@ -191,5 +191,5 @@
   {
     int rank ;
-    ep_lib::MPI_Comm_rank(communicator,&rank);
+    MPI_Comm_rank(communicator,&rank);
     if (rank==0)
     {
@@ -197,13 +197,13 @@
       this->toBuffer(buffer) ;
       int size=buffer.count() ;
-      ep_lib::MPI_Bcast(&size,1,EP_INT,0,communicator) ;
-      ep_lib::MPI_Bcast(buffer.start(),size,EP_CHAR,0,communicator) ;
+      MPI_Bcast(&size,1,MPI_INT,0,communicator) ;
+      MPI_Bcast(buffer.start(),size,MPI_CHAR,0,communicator) ;
     }
     else
     {
       int size ;
-      ep_lib::MPI_Bcast(&size,1,EP_INT,0,communicator) ;
+      MPI_Bcast(&size,1,MPI_INT,0,communicator) ;
       CBufferIn buffer(size) ;
-      ep_lib::MPI_Bcast(buffer.start(),size,EP_CHAR,0,communicator) ;
+      MPI_Bcast(buffer.start(),size,MPI_CHAR,0,communicator) ;
       this->fromBuffer(buffer) ;
     }
@@ -214,9 +214,9 @@
   }
 
-  void CRegistry::gatherRegistry(const ep_lib::MPI_Comm& comm)
+  void CRegistry::gatherRegistry(const MPI_Comm& comm)
   {
     int rank,mpiSize ;
-    ep_lib::MPI_Comm_rank(comm,&rank);
-    ep_lib::MPI_Comm_size(comm,&mpiSize);
+    MPI_Comm_rank(comm,&rank);
+    MPI_Comm_size(comm,&mpiSize);
 
     int* sizes=new int[mpiSize] ;
@@ -224,5 +224,5 @@
     this->toBuffer(localBuffer) ;
     int localSize=localBuffer.count() ;
-    ep_lib::MPI_Gather(&localSize,1,EP_INT,sizes,1,EP_INT,0,comm) ;
+    MPI_Gather(&localSize,1,MPI_INT,sizes,1,MPI_INT,0,comm) ;
 
     char* globalBuffer ;
@@ -240,5 +240,5 @@
 
       globalBuffer=new char[globalBufferSize] ;
-      ep_lib::MPI_Gatherv(localBuffer.start(),localSize,EP_CHAR,globalBuffer,sizes,displs,EP_CHAR,0,comm) ;
+      MPI_Gatherv(localBuffer.start(),localSize,MPI_CHAR,globalBuffer,sizes,displs,MPI_CHAR,0,comm) ;
       for(int i=1;i<mpiSize;++i)
       {
@@ -251,5 +251,5 @@
       delete[] globalBuffer ;
     }
-    else  ep_lib::MPI_Gatherv(localBuffer.start(),localSize,EP_CHAR,globalBuffer,sizes,displs,EP_CHAR,0,comm) ;   
+    else  MPI_Gatherv(localBuffer.start(),localSize,MPI_CHAR,globalBuffer,sizes,displs,MPI_CHAR,0,comm) ;   
     delete[] sizes ;
     
@@ -261,9 +261,9 @@
   }
 
-  void CRegistry::hierarchicalGatherRegistry(const ep_lib::MPI_Comm& comm)
+  void CRegistry::hierarchicalGatherRegistry(const MPI_Comm& comm)
   {
     int mpiRank,mpiSize ;
-    ep_lib::MPI_Comm_rank(comm,&mpiRank);
-    ep_lib::MPI_Comm_size(comm,&mpiSize);    
+    MPI_Comm_rank(comm,&mpiRank);
+    MPI_Comm_size(comm,&mpiSize);    
 
     if (mpiSize>2)
@@ -272,20 +272,20 @@
       if (mpiRank<mpiSize/2+mpiSize%2) color=0 ;
       else color=1 ;
-      ep_lib::MPI_Comm commUp ;
-      ep_lib::MPI_Comm_split(comm,color,mpiRank,&commUp) ,
+      MPI_Comm commUp ;
+      MPI_Comm_split(comm,color,mpiRank,&commUp) ,
       hierarchicalGatherRegistry(commUp) ;
-      ep_lib::MPI_Comm_free(&commUp) ;
+      MPI_Comm_free(&commUp) ;
     }
 
     if (mpiSize>1)
     {
-      ep_lib::MPI_Comm commDown ;
+      MPI_Comm commDown ;
       int color ;
       
       if (mpiRank==0 || mpiRank==mpiSize/2+mpiSize%2) color=0 ;
       else color=1 ;
-      ep_lib::MPI_Comm_split(comm,color,mpiRank,&commDown) ;
+      MPI_Comm_split(comm,color,mpiRank,&commDown) ;
       if (color==0) gatherRegistry(commDown) ;
-      ep_lib::MPI_Comm_free(&commDown) ;    
+      MPI_Comm_free(&commDown) ;    
     }
   }
Index: /XIOS/trunk/src/registry.hpp
===================================================================
--- /XIOS/trunk/src/registry.hpp	(revision 1638)
+++ /XIOS/trunk/src/registry.hpp	(revision 1639)
@@ -23,5 +23,5 @@
 
 /** Constructor, the communicator is used for bcast or gather operation between MPI processes */
-      CRegistry(const ep_lib::MPI_Comm& comm=EP_COMM_WORLD) : communicator(comm) {}
+      CRegistry(const MPI_Comm& comm=MPI_COMM_WORLD) : communicator(comm) {}
 
 /** Copy constructor */
@@ -106,8 +106,8 @@
 
 /** use internally for recursivity */
-      void gatherRegistry(const ep_lib::MPI_Comm& comm) ;
+      void gatherRegistry(const MPI_Comm& comm) ;
 
 /** use internally for recursivity */
-      void hierarchicalGatherRegistry(const ep_lib::MPI_Comm& comm) ;
+      void hierarchicalGatherRegistry(const MPI_Comm& comm) ;
 
 
@@ -120,5 +120,5 @@
 
 /** MPI communicator used for broadcast and gather operation */
-      ep_lib::MPI_Comm communicator ;
+      MPI_Comm communicator ;
   } ;
 
Index: /XIOS/trunk/src/server.cpp
===================================================================
--- /XIOS/trunk/src/server.cpp	(revision 1638)
+++ /XIOS/trunk/src/server.cpp	(revision 1639)
@@ -18,9 +18,9 @@
 namespace xios
 {
-    ep_lib::MPI_Comm CServer::intraComm ;
-    std::list<ep_lib::MPI_Comm> CServer::interCommLeft ;
-    std::list<ep_lib::MPI_Comm> CServer::interCommRight ;
-    std::list<ep_lib::MPI_Comm> CServer::contextInterComms;
-    std::list<ep_lib::MPI_Comm> CServer::contextIntraComms;
+    MPI_Comm CServer::intraComm ;
+    std::list<MPI_Comm> CServer::interCommLeft ;
+    std::list<MPI_Comm> CServer::interCommRight ;
+    std::list<MPI_Comm> CServer::contextInterComms;
+    std::list<MPI_Comm> CServer::contextIntraComms;
     int CServer::serverLevel = 0 ;
     int CServer::nbContexts = 0;
@@ -48,5 +48,5 @@
     {
       int initialized ;
-      ep_lib::MPI_Initialized(&initialized) ;
+      MPI_Initialized(&initialized) ;
       if (initialized) is_MPI_Initialized=true ;
       else is_MPI_Initialized=false ;
@@ -59,5 +59,5 @@
         if (!is_MPI_Initialized)
         {
-          ep_lib::MPI_Init(NULL, NULL);
+          MPI_Init(NULL, NULL);
         }
         CTimer::get("XIOS").resume() ;
@@ -72,11 +72,11 @@
         int myColor ;
         int i,c ;
-        ep_lib::MPI_Comm newComm;
-
-        ep_lib::MPI_Comm_size(CXios::globalComm, &size) ;
-        ep_lib::MPI_Comm_rank(CXios::globalComm, &rank_);
+        MPI_Comm newComm;
+
+        MPI_Comm_size(CXios::globalComm, &size) ;
+        MPI_Comm_rank(CXios::globalComm, &rank_);
 
         hashAll=new unsigned long[size] ;
-        ep_lib::MPI_Allgather(&hashServer, 1, EP_LONG, hashAll, 1, EP_LONG, CXios::globalComm) ;
+        MPI_Allgather(&hashServer, 1, MPI_LONG, hashAll, 1, MPI_LONG, CXios::globalComm) ;
 
         map<unsigned long, int> colors ;
@@ -174,5 +174,5 @@
         // (2) Create intraComm
         if (serverLevel != 2) myColor=colors[hashServer];
-        ep_lib::MPI_Comm_split(CXios::globalComm, myColor, rank_, &intraComm) ;
+        MPI_Comm_split(CXios::globalComm, myColor, rank_, &intraComm) ;
 
         // (3) Create interComm
@@ -186,10 +186,10 @@
               clientLeader=it->second ;
               int intraCommSize, intraCommRank ;
-              ep_lib::MPI_Comm_size(intraComm,&intraCommSize) ;
-              ep_lib::MPI_Comm_rank(intraComm,&intraCommRank) ;
+              MPI_Comm_size(intraComm,&intraCommSize) ;
+              MPI_Comm_rank(intraComm,&intraCommRank) ;
               info(50)<<"intercommCreate::server (classical mode) "<<rank_<<" intraCommSize : "<<intraCommSize
                        <<" intraCommRank :"<<intraCommRank<<"  clientLeader "<< clientLeader<<endl ;
 
-              ep_lib::MPI_Intercomm_create(intraComm, 0, CXios::globalComm, clientLeader, 0, &newComm) ;
+              MPI_Intercomm_create(intraComm, 0, CXios::globalComm, clientLeader, 0, &newComm) ;
               interCommLeft.push_back(newComm) ;
             }
@@ -207,9 +207,9 @@
               clientLeader=it->second ;
               int intraCommSize, intraCommRank ;
-              ep_lib::MPI_Comm_size(intraComm, &intraCommSize) ;
-              ep_lib::MPI_Comm_rank(intraComm, &intraCommRank) ;
+              MPI_Comm_size(intraComm, &intraCommSize) ;
+              MPI_Comm_rank(intraComm, &intraCommRank) ;
               info(50)<<"intercommCreate::server (server level 1) "<<rank_<<" intraCommSize : "<<intraCommSize
                        <<" intraCommRank :"<<intraCommRank<<"  clientLeader "<< clientLeader<<endl ;
-              ep_lib::MPI_Intercomm_create(intraComm, 0, CXios::globalComm, clientLeader, 0, &newComm) ;
+              MPI_Intercomm_create(intraComm, 0, CXios::globalComm, clientLeader, 0, &newComm) ;
               interCommLeft.push_back(newComm) ;
             }
@@ -219,9 +219,9 @@
           {
             int intraCommSize, intraCommRank ;
-            ep_lib::MPI_Comm_size(intraComm, &intraCommSize) ;
-            ep_lib::MPI_Comm_rank(intraComm, &intraCommRank) ;
+            MPI_Comm_size(intraComm, &intraCommSize) ;
+            MPI_Comm_rank(intraComm, &intraCommRank) ;
             info(50)<<"intercommCreate::client (server level 1) "<<rank_<<" intraCommSize : "<<intraCommSize
                 <<" intraCommRank :"<<intraCommRank<<"  clientLeader "<< sndServerGlobalRanks[i]<<endl ;
-            ep_lib::MPI_Intercomm_create(intraComm, 0, CXios::globalComm, sndServerGlobalRanks[i], 1, &newComm) ;
+            MPI_Intercomm_create(intraComm, 0, CXios::globalComm, sndServerGlobalRanks[i], 1, &newComm) ;
             interCommRight.push_back(newComm) ;
           }
@@ -232,10 +232,10 @@
           clientLeader = leaders[hashString(CXios::xiosCodeId)];
           int intraCommSize, intraCommRank ;
-          ep_lib::MPI_Comm_size(intraComm, &intraCommSize) ;
-          ep_lib::MPI_Comm_rank(intraComm, &intraCommRank) ;
+          MPI_Comm_size(intraComm, &intraCommSize) ;
+          MPI_Comm_rank(intraComm, &intraCommRank) ;
           info(50)<<"intercommCreate::server (server level 2) "<<rank_<<" intraCommSize : "<<intraCommSize
                    <<" intraCommRank :"<<intraCommRank<<"  clientLeader "<< clientLeader<<endl ;
 
-          ep_lib::MPI_Intercomm_create(intraComm, 0, CXios::globalComm, clientLeader, 1, &newComm) ;
+          MPI_Intercomm_create(intraComm, 0, CXios::globalComm, clientLeader, 1, &newComm) ;
           interCommLeft.push_back(newComm) ;
         }
@@ -253,20 +253,20 @@
 
         CTimer::get("XIOS").resume() ;
-        ep_lib::MPI_Comm localComm;
+        MPI_Comm localComm;
         oasis_get_localcomm(localComm);
-        ep_lib::MPI_Comm_rank(localComm,&rank_) ;
+        MPI_Comm_rank(localComm,&rank_) ;
 
 //      (1) Create server intraComm
         if (!CXios::usingServer2)
         {
-          ep_lib::MPI_Comm_dup(localComm, &intraComm);
+          MPI_Comm_dup(localComm, &intraComm);
         }
         else
         {
           int globalRank;
-          ep_lib::MPI_Comm_size(localComm,&size) ;
-          ep_lib::MPI_Comm_rank(CXios::globalComm,&globalRank) ;
+          MPI_Comm_size(localComm,&size) ;
+          MPI_Comm_rank(CXios::globalComm,&globalRank) ;
           srvGlobalRanks = new int[size] ;
-          ep_lib::MPI_Allgather(&globalRank, 1, EP_INT, srvGlobalRanks, 1, EP_INT, localComm) ;
+          MPI_Allgather(&globalRank, 1, MPI_INT, srvGlobalRanks, 1, MPI_INT, localComm) ;
 
           int reqNbProc = size*CXios::ratioServer2/100.;
@@ -276,5 +276,5 @@
                 << "It is impossible to dedicate the requested number of processes = "<<reqNbProc
                 <<" to secondary server. XIOS will run in the classical server mode."<<endl;
-            ep_lib::MPI_Comm_dup(localComm, &intraComm);
+            MPI_Comm_dup(localComm, &intraComm);
           }
           else
@@ -339,5 +339,5 @@
             }
             if (serverLevel != 2) myColor=0;
-            ep_lib::MPI_Comm_split(localComm, myColor, rank_, &intraComm) ;
+            MPI_Comm_split(localComm, myColor, rank_, &intraComm) ;
           }
         }
@@ -348,7 +348,7 @@
         vector<string>::iterator it ;
 
-        ep_lib::MPI_Comm newComm ;
+        MPI_Comm newComm ;
         int globalRank ;
-        ep_lib::MPI_Comm_rank(CXios::globalComm,&globalRank);
+        MPI_Comm_rank(CXios::globalComm,&globalRank);
 
 //      (2) Create interComms with models
@@ -359,5 +359,5 @@
           {
             interCommLeft.push_back(newComm) ;
-            if (rank_==0) ep_lib::MPI_Send(&globalRank,1,EP_INT,0,0,newComm) ;
+            if (rank_==0) MPI_Send(&globalRank,1,MPI_INT,0,0,newComm) ;
           }
         }
@@ -365,6 +365,6 @@
 //      (3) Create interComms between primary and secondary servers
         int intraCommSize, intraCommRank ;
-        ep_lib::MPI_Comm_size(intraComm,&intraCommSize) ;
-        ep_lib::MPI_Comm_rank(intraComm, &intraCommRank) ;
+        MPI_Comm_size(intraComm,&intraCommSize) ;
+        MPI_Comm_rank(intraComm, &intraCommRank) ;
 
         if (serverLevel == 1)
@@ -375,5 +375,5 @@
             info(50)<<"intercommCreate::client (server level 1) "<<globalRank<<" intraCommSize : "<<intraCommSize
                 <<" intraCommRank :"<<intraCommRank<<"  clientLeader "<< srvSndLeader<<endl ;
-            ep_lib::MPI_Intercomm_create(intraComm, 0, CXios::globalComm, srvSndLeader, 0, &newComm) ;
+            MPI_Intercomm_create(intraComm, 0, CXios::globalComm, srvSndLeader, 0, &newComm) ;
             interCommRight.push_back(newComm) ;
           }
@@ -383,5 +383,5 @@
           info(50)<<"intercommCreate::server (server level 2)"<<globalRank<<" intraCommSize : "<<intraCommSize
                    <<" intraCommRank :"<<intraCommRank<<"  clientLeader "<< srvGlobalRanks[0] <<endl ;
-          ep_lib::MPI_Intercomm_create(intraComm, 0, CXios::globalComm, srvGlobalRanks[0], 0, &newComm) ;
+          MPI_Intercomm_create(intraComm, 0, CXios::globalComm, srvGlobalRanks[0], 0, &newComm) ;
           interCommLeft.push_back(newComm) ;
         }
@@ -393,5 +393,5 @@
 
 
-      ep_lib::MPI_Comm_rank(intraComm, &rank) ;
+      MPI_Comm_rank(intraComm, &rank) ;
       if (rank==0) isRoot=true;
       else isRoot=false;
@@ -406,9 +406,9 @@
       delete eventScheduler ;
 
-      for (std::list<ep_lib::MPI_Comm>::iterator it = contextInterComms.begin(); it != contextInterComms.end(); it++)
-        ep_lib::MPI_Comm_free(&(*it));
-
-      for (std::list<ep_lib::MPI_Comm>::iterator it = contextIntraComms.begin(); it != contextIntraComms.end(); it++)
-        ep_lib::MPI_Comm_free(&(*it));
+      for (std::list<MPI_Comm>::iterator it = contextInterComms.begin(); it != contextInterComms.end(); it++)
+        MPI_Comm_free(&(*it));
+
+      for (std::list<MPI_Comm>::iterator it = contextIntraComms.begin(); it != contextIntraComms.end(); it++)
+        MPI_Comm_free(&(*it));
 
 //      for (std::list<MPI_Comm>::iterator it = interComm.begin(); it != interComm.end(); it++)
@@ -418,13 +418,13 @@
 //          MPI_Comm_free(&(*it));
 
-        for (std::list<ep_lib::MPI_Comm>::iterator it = interCommRight.begin(); it != interCommRight.end(); it++)
-          ep_lib::MPI_Comm_free(&(*it));
-
-      ep_lib::MPI_Comm_free(&intraComm);
+        for (std::list<MPI_Comm>::iterator it = interCommRight.begin(); it != interCommRight.end(); it++)
+          MPI_Comm_free(&(*it));
+
+      MPI_Comm_free(&intraComm);
 
       if (!is_MPI_Initialized)
       {
         if (CXios::usingOasis) oasis_finalize();
-        else ep_lib::MPI_Finalize() ;
+        else MPI_Finalize() ;
       }
       report(0)<<"Performance report : Time spent for XIOS : "<<CTimer::get("XIOS server").getCumulatedTime()<<endl  ;
@@ -465,5 +465,5 @@
      void CServer::listenFinalize(void)
      {
-        list<ep_lib::MPI_Comm>::iterator it, itr;
+        list<MPI_Comm>::iterator it, itr;
         int msg ;
         int flag ;
@@ -471,18 +471,18 @@
         for(it=interCommLeft.begin();it!=interCommLeft.end();it++)
         {
-           ep_lib::MPI_Status status ;
+           MPI_Status status ;
            traceOff() ;
-           ep_lib::MPI_Iprobe(0,0,*it,&flag,&status) ;
+           MPI_Iprobe(0,0,*it,&flag,&status) ;
            traceOn() ;
            if (flag==true)
            {
-              ep_lib::MPI_Recv(&msg,1,EP_INT,0,0,*it,&status) ;
+              MPI_Recv(&msg,1,MPI_INT,0,0,*it,&status) ;
               info(20)<<" CServer : Receive client finalize"<<endl ;
               // Sending server finalize message to secondary servers (if any)
               for(itr=interCommRight.begin();itr!=interCommRight.end();itr++)
               {
-                ep_lib::MPI_Send(&msg,1,EP_INT,0,0,*itr) ;
+                MPI_Send(&msg,1,MPI_INT,0,0,*itr) ;
               }
-              ep_lib::MPI_Comm_free(&(*it));
+              MPI_Comm_free(&(*it));
               interCommLeft.erase(it) ;
               break ;
@@ -493,10 +493,10 @@
          {
            int i,size ;
-           ep_lib::MPI_Comm_size(intraComm,&size) ;
-           ep_lib::MPI_Request* requests= new ep_lib::MPI_Request[size-1] ;
-           ep_lib::MPI_Status* status= new ep_lib::MPI_Status[size-1] ;
-
-           for(int i=1;i<size;i++) ep_lib::MPI_Isend(&msg,1,EP_INT,i,4,intraComm,&requests[i-1]) ;
-           ep_lib::MPI_Waitall(size-1,requests,status) ;
+           MPI_Comm_size(intraComm,&size) ;
+           MPI_Request* requests= new MPI_Request[size-1] ;
+           MPI_Status* status= new MPI_Status[size-1] ;
+
+           for(int i=1;i<size;i++) MPI_Isend(&msg,1,MPI_INT,i,4,intraComm,&requests[i-1]) ;
+           MPI_Waitall(size-1,requests,status) ;
 
            finished=true ;
@@ -510,13 +510,13 @@
      {
         int flag ;
-        ep_lib::MPI_Status status ;
+        MPI_Status status ;
         int msg ;
 
         traceOff() ;
-        ep_lib::MPI_Iprobe(0,4,intraComm, &flag, &status) ;
+        MPI_Iprobe(0,4,intraComm, &flag, &status) ;
         traceOn() ;
         if (flag==true)
         {
-           ep_lib::MPI_Recv(&msg,1,EP_INT,0,4,intraComm,&status) ;
+           MPI_Recv(&msg,1,MPI_INT,0,4,intraComm,&status) ;
            finished=true ;
         }
@@ -534,18 +534,18 @@
      {
         int flag ;
-        ep_lib::MPI_Status status ;
-        list<ep_lib::MPI_Comm>::iterator it;
+        MPI_Status status ;
+        list<MPI_Comm>::iterator it;
         int msg ;
         static int nbCompound=0 ;
         int size ;
         static bool sent=false ;
-        static ep_lib::MPI_Request* allRequests ;
-        static ep_lib::MPI_Status* allStatus ;
+        static MPI_Request* allRequests ;
+        static MPI_Status* allStatus ;
 
 
         if (sent)
         {
-          ep_lib::MPI_Comm_size(intraComm,&size) ;
-          ep_lib::MPI_Testall(size,allRequests, &flag, allStatus) ;
+          MPI_Comm_size(intraComm,&size) ;
+          MPI_Testall(size,allRequests, &flag, allStatus) ;
           if (flag==true)
           {
@@ -559,22 +559,22 @@
         for(it=interCommLeft.begin();it!=interCommLeft.end();it++)
         {
-           ep_lib::MPI_Status status ;
+           MPI_Status status ;
            traceOff() ;
-           ep_lib::MPI_Iprobe(0,5,*it,&flag,&status) ;  // tags oasis_endded = 5
+           MPI_Iprobe(0,5,*it,&flag,&status) ;  // tags oasis_endded = 5
            traceOn() ;
            if (flag==true)
            {
-              ep_lib::MPI_Recv(&msg,1,EP_INT,0,5,*it,&status) ; // tags oasis_endded = 5
+              MPI_Recv(&msg,1,MPI_INT,0,5,*it,&status) ; // tags oasis_endded = 5
               nbCompound++ ;
               if (nbCompound==interCommLeft.size())
               {
-                for (std::list<ep_lib::MPI_Comm>::iterator it = interCommRight.begin(); it != interCommRight.end(); it++)
+                for (std::list<MPI_Comm>::iterator it = interCommRight.begin(); it != interCommRight.end(); it++)
                 {
-                   ep_lib::MPI_Send(&msg,1,EP_INT,0,5,*it) ; // tags oasis_endded = 5
+                   MPI_Send(&msg,1,MPI_INT,0,5,*it) ; // tags oasis_endded = 5
                 }
-                ep_lib::MPI_Comm_size(intraComm,&size) ;
-                allRequests= new ep_lib::MPI_Request[size] ;
-                allStatus= new ep_lib::MPI_Status[size] ;
-                for(int i=0;i<size;i++) ep_lib::MPI_Isend(&msg,1,EP_INT,i,5,intraComm,&allRequests[i]) ; // tags oasis_endded = 5
+                MPI_Comm_size(intraComm,&size) ;
+                allRequests= new MPI_Request[size] ;
+                allStatus= new MPI_Status[size] ;
+                for(int i=0;i<size;i++) MPI_Isend(&msg,1,MPI_INT,i,5,intraComm,&allRequests[i]) ; // tags oasis_endded = 5
                 sent=true ;
               }
@@ -590,5 +590,5 @@
      {
        int flag ;
-       ep_lib::MPI_Status status ;
+       MPI_Status status ;
        const int root=0 ;
        int msg ;
@@ -607,9 +607,9 @@
          
        traceOff() ;
-       ep_lib::MPI_Iprobe(root,5,intraComm, &flag, &status) ;
+       MPI_Iprobe(root,5,intraComm, &flag, &status) ;
        traceOn() ;
        if (flag==true)
        {
-         ep_lib::MPI_Recv(&msg,1,EP_INT,root,5,intraComm,&status) ; // tags oasis_endded = 5
+         MPI_Recv(&msg,1,MPI_INT,root,5,intraComm,&status) ; // tags oasis_endded = 5
          boost::hash<string> hashString;
          size_t hashId = hashString("oasis_enddef");
@@ -626,8 +626,8 @@
      {
 
-       ep_lib::MPI_Status status ;
+       MPI_Status status ;
        int flag ;
        static char* buffer ;
-       static ep_lib::MPI_Request request ;
+       static MPI_Request request ;
        static bool recept=false ;
        int rank ;
@@ -637,20 +637,12 @@
        {
          traceOff() ;
-         #ifdef _usingMPI
-         ep_lib::MPI_Iprobe(MPI_ANY_SOURCE,1,CXios::globalComm, &flag, &status) ;
-         #elif _usingEP
-         ep_lib::MPI_Iprobe(-2,1,CXios::globalComm, &flag, &status) ;
-         #endif
+         MPI_Iprobe(MPI_ANY_SOURCE,1,CXios::globalComm, &flag, &status) ;
          traceOn() ;
          if (flag==true)
          {
-           #ifdef _usingMPI
            rank=status.MPI_SOURCE ;
-           #elif _usingEP
-           rank=status.ep_src ;
-           #endif
-           ep_lib::MPI_Get_count(&status,EP_CHAR,&count) ;
+           MPI_Get_count(&status,MPI_CHAR,&count) ;
            buffer=new char[count] ;
-           ep_lib::MPI_Irecv((void*)buffer,count,EP_CHAR,rank,1,CXios::globalComm,&request) ;
+           MPI_Irecv((void*)buffer,count,MPI_CHAR,rank,1,CXios::globalComm,&request) ;
            recept=true ;
          }
@@ -659,14 +651,10 @@
        {
          traceOff() ;
-         ep_lib::MPI_Test(&request,&flag,&status) ;
+         MPI_Test(&request,&flag,&status) ;
          traceOn() ;
          if (flag==true)
          {
-           #ifdef _usingMPI
            rank=status.MPI_SOURCE ;
-           #elif _usingEP
-           rank=status.ep_src ;
-           #endif
-           ep_lib::MPI_Get_count(&status,EP_CHAR,&count) ;
+           MPI_Get_count(&status,MPI_CHAR,&count) ;
            recvContextMessage((void*)buffer,count) ;
            delete [] buffer ;
@@ -701,9 +689,9 @@
        {
          int size ;
-         ep_lib::MPI_Comm_size(intraComm,&size) ;
+         MPI_Comm_size(intraComm,&size) ;
 //         MPI_Request* requests= new MPI_Request[size-1] ;
 //         MPI_Status* status= new MPI_Status[size-1] ;
-         ep_lib::MPI_Request* requests= new ep_lib::MPI_Request[size] ;
-         ep_lib::MPI_Status* status= new ep_lib::MPI_Status[size] ;
+         MPI_Request* requests= new MPI_Request[size] ;
+         MPI_Status* status= new MPI_Status[size] ;
 
          CMessage msg ;
@@ -717,5 +705,5 @@
          for(int i=0; i<size; i++)
          {
-           ep_lib::MPI_Isend(sendBuff,sendBuffer.count(),EP_CHAR,i,2,intraComm,&requests[i]) ;
+           MPI_Isend(sendBuff,sendBuffer.count(),MPI_CHAR,i,2,intraComm,&requests[i]) ;
          }
 
@@ -729,12 +717,12 @@
      void CServer::listenRootContext(void)
      {
-       ep_lib::MPI_Status status ;
+       MPI_Status status ;
        int flag ;
        static std::vector<void*> buffers;
-       static std::vector<ep_lib::MPI_Request> requests ;
+       static std::vector<MPI_Request> requests ;
        static std::vector<int> counts ;
        static std::vector<bool> isEventRegistered ;
        static std::vector<bool> isEventQueued ;
-       ep_lib::MPI_Request request;
+       MPI_Request request;
 
        int rank ;
@@ -745,13 +733,13 @@
        // (1) Receive context id from the root, save it into a buffer
        traceOff() ;
-       ep_lib::MPI_Iprobe(root,2,intraComm, &flag, &status) ;
+       MPI_Iprobe(root,2,intraComm, &flag, &status) ;
        traceOn() ;
        if (flag==true)
        {
          counts.push_back(0);
-         ep_lib::MPI_Get_count(&status,EP_CHAR,&(counts.back())) ;
+         MPI_Get_count(&status,MPI_CHAR,&(counts.back())) ;
          buffers.push_back(new char[counts.back()]) ;
          requests.push_back(request);
-         ep_lib::MPI_Irecv((void*)(buffers.back()),counts.back(),EP_CHAR,root,2,intraComm,&(requests.back())) ;
+         MPI_Irecv((void*)(buffers.back()),counts.back(),MPI_CHAR,root,2,intraComm,&(requests.back())) ;
          isEventRegistered.push_back(false);
          isEventQueued.push_back(false);
@@ -762,5 +750,5 @@
        {
          // (2) If context id is received, register an event
-         ep_lib::MPI_Test(&requests[ctxNb],&flag,&status) ;
+         MPI_Test(&requests[ctxNb],&flag,&status) ;
          if (flag==true && !isEventRegistered[ctxNb])
          {
@@ -799,12 +787,12 @@
        // (1) create interComm (with a client)
        // (2) initialize client and server (contextClient and contextServer)
-       ep_lib::MPI_Comm inter;
+       MPI_Comm inter;
        if (serverLevel < 2)
        {
-         ep_lib::MPI_Comm contextInterComm;
-         ep_lib::MPI_Intercomm_create(intraComm, 0, CXios::globalComm, leaderRank, 10+leaderRank, &contextInterComm);
-         ep_lib::MPI_Intercomm_merge(contextInterComm,1,&inter);
-         ep_lib::MPI_Barrier(inter);
-         ep_lib::MPI_Comm_free(&inter);
+         MPI_Comm contextInterComm;
+         MPI_Intercomm_create(intraComm, 0, CXios::globalComm, leaderRank, 10+leaderRank, &contextInterComm);
+         MPI_Intercomm_merge(contextInterComm,1,&inter);
+         MPI_Barrier(inter);
+         MPI_Comm_free(&inter);
          context->initServer(intraComm,contextInterComm);
          contextInterComms.push_back(contextInterComm);
@@ -819,5 +807,5 @@
        else if (serverLevel == 2)
        {
-         ep_lib::MPI_Comm_dup(interCommLeft.front(), &inter);
+         MPI_Comm_dup(interCommLeft.front(), &inter);
          contextInterComms.push_back(inter);
          context->initServer(intraComm, contextInterComms.back());
@@ -830,6 +818,6 @@
        {
          int i = 0, size;
-         ep_lib::MPI_Comm_size(intraComm, &size) ;
-         for (std::list<ep_lib::MPI_Comm>::iterator it = interCommRight.begin(); it != interCommRight.end(); it++, ++i)
+         MPI_Comm_size(intraComm, &size) ;
+         for (std::list<MPI_Comm>::iterator it = interCommRight.begin(); it != interCommRight.end(); it++, ++i)
          {
            StdString str = contextId +"_server_" + boost::lexical_cast<string>(i);
@@ -841,8 +829,8 @@
            CBufferOut buffer(buff,messageSize) ;
            buffer<<msg ;
-           ep_lib::MPI_Send(buff, buffer.count(), EP_CHAR, sndServerGlobalRanks[i], 1, CXios::globalComm) ;
-           ep_lib::MPI_Comm_dup(*it, &inter);
+           MPI_Send(buff, buffer.count(), MPI_CHAR, sndServerGlobalRanks[i], 1, CXios::globalComm) ;
+           MPI_Comm_dup(*it, &inter);
            contextInterComms.push_back(inter);
-           ep_lib::MPI_Comm_dup(intraComm, &inter);
+           MPI_Comm_dup(intraComm, &inter);
            contextIntraComms.push_back(inter);
            context->initClient(contextIntraComms.back(), contextInterComms.back()) ;
@@ -874,5 +862,5 @@
      {
        int rank;
-       ep_lib::MPI_Comm_rank(intraComm,&rank);
+       MPI_Comm_rank(intraComm,&rank);
        return rank;
      }
@@ -897,5 +885,5 @@
       int size = 0;
       int id;
-      ep_lib::MPI_Comm_size(CXios::globalComm, &size);
+      MPI_Comm_size(CXios::globalComm, &size);
       while (size)
       {
Index: /XIOS/trunk/src/server.hpp
===================================================================
--- /XIOS/trunk/src/server.hpp	(revision 1638)
+++ /XIOS/trunk/src/server.hpp	(revision 1639)
@@ -26,9 +26,9 @@
         static void registerContext(void* buff,int count, int leaderRank=0);
 
-        static ep_lib::MPI_Comm intraComm;
-        static std::list<ep_lib::MPI_Comm> interCommLeft;           // interComm between server (primary, classical or secondary) and its client (client or primary server)
-        static std::list<ep_lib::MPI_Comm> interCommRight;          // interComm between primary server and secondary server (non-empty only for primary server pool)
-        static std::list<ep_lib::MPI_Comm> contextInterComms;  // list of context intercomms
-        static std::list<ep_lib::MPI_Comm> contextIntraComms;  // list of context intercomms (needed only in case of secondary servers)
+        static MPI_Comm intraComm;
+        static std::list<MPI_Comm> interCommLeft;           // interComm between server (primary, classical or secondary) and its client (client or primary server)
+        static std::list<MPI_Comm> interCommRight;          // interComm between primary server and secondary server (non-empty only for primary server pool)
+        static std::list<MPI_Comm> contextInterComms;  // list of context intercomms
+        static std::list<MPI_Comm> contextIntraComms;  // list of context intercomms (needed only in case of secondary servers)
         static CEventScheduler* eventScheduler;
 
Index: OS/trunk/src/test/test_omp.f90
===================================================================
--- /XIOS/trunk/src/test/test_omp.f90	(revision 1638)
+++ 	(revision )
@@ -1,196 +1,0 @@
-PROGRAM test_omp
-
-  USE xios
-  USE mod_wait
-  USE omp_lib
-  IMPLICIT NONE
-  INCLUDE "mpif.h"
-  INTEGER :: rank
-  INTEGER :: size
-  INTEGER :: ierr
-
-  CHARACTER(len=*),PARAMETER :: id="client"
-  INTEGER :: comm
-  TYPE(xios_duration) :: dtime
-  CHARACTER(len=20) :: dtime_str
-  TYPE(xios_date) :: date
-  CHARACTER(len=20) :: date_str
-  CHARACTER(len=15) :: calendar_type
-  TYPE(xios_context) :: ctx_hdl
-  INTEGER,PARAMETER :: ni_glo=100
-  INTEGER,PARAMETER :: nj_glo=100
-  INTEGER,PARAMETER :: llm=5
-  DOUBLE PRECISION  :: lval(llm)=1, scalar = 5
-  TYPE(xios_field) :: field_hdl
-  TYPE(xios_fieldgroup) :: fieldgroup_hdl
-  TYPE(xios_file) :: file_hdl
-  LOGICAL :: ok
-
-  DOUBLE PRECISION,DIMENSION(ni_glo,nj_glo) :: lon_glo,lat_glo
-  DOUBLE PRECISION :: field_A_glo(ni_glo,nj_glo,llm)
-  DOUBLE PRECISION,ALLOCATABLE :: lon(:,:),lat(:,:),field_A(:,:,:), lonvalue(:,:), axisValue(:), field_domain(:,:)
-  INTEGER :: ni,ibegin,iend,nj,jbegin,jend
-  INTEGER :: i,j,l,ts,n, provided
-
-!!! MPI Initialization   
-    CALL MPI_INIT_THREAD(3, provided, ierr)
-    if(provided .LT. 3) then
-      print*, "provided thread level = ", provided
-      call MPI_Abort()
-    endif
-    !CALL VTINIT(ierr)
-    CALL init_wait
-
-    CALL MPI_COMM_RANK(MPI_COMM_WORLD,rank,ierr)
-    CALL MPI_COMM_SIZE(MPI_COMM_WORLD,size,ierr)
-    if(rank < size-4) then
-
-  
-    CALL xios_initialize(id,return_comm=comm)
-    print*, "comm = ", comm
-    CALL MPI_COMM_RANK(comm,rank,ierr)
-    CALL MPI_COMM_SIZE(comm,size,ierr)
-
-
-    DO j=1,nj_glo
-      DO i=1,ni_glo
-        lon_glo(i,j)=(i-1)+(j-1)*ni_glo
-        lat_glo(i,j)=1000+(i-1)+(j-1)*ni_glo
-        DO l=1,llm
-          field_A_glo(i,j,l)=(i-1)+(j-1)*ni_glo*100+10000*l
-        ENDDO
-      ENDDO
-    ENDDO
-    ni=ni_glo ; ibegin=0
-
-    jbegin=0
-    DO n=0,size-1
-      nj=nj_glo/size
-      IF (n<MOD(nj_glo,size)) nj=nj+1
-      IF (n==rank) exit
-      jbegin=jbegin+nj
-    ENDDO
-
-    iend=ibegin+ni-1 ; jend=jbegin+nj-1
-
-    !ALLOCATE(lon(ni,nj),lat(ni,nj),field_A(0:ni+1,-1:nj+2,llm),lonvalue(ni,nj))
-    !lon(:,:)=lon_glo(ibegin+1:iend+1,jbegin+1:jend+1)
-    !lat(:,:)=lat_glo(ibegin+1:iend+1,jbegin+1:jend+1)
-    !field_A(1:ni,1:nj,:)=field_A_glo(ibegin+1:iend+1,jbegin+1:jend+1,:)
-    
-    ALLOCATE(lon(ni,nj),lat(ni,nj),field_A(0:ni+1,-1:nj+2,llm),lonvalue(ni,nj), axisValue(nj_glo), field_domain(0:ni+1,-1:nj+2))
-    lon(:,:)=lon_glo(ibegin+1:iend+1,jbegin+1:jend+1)
-    lat(:,:)=lat_glo(ibegin+1:iend+1,jbegin+1:jend+1)
-    field_A(1:ni,1:nj,:)=field_A_glo(ibegin+1:iend+1,jbegin+1:jend+1,:)
-    field_domain(1:ni,1:nj) = field_A_glo(ibegin+1:iend+1,jbegin+1:jend+1,1)
-    axisValue(1:nj_glo)=field_A_glo(1,1:nj_glo,1);
-  
-
-
-    CALL xios_context_initialize("test",comm)
-    CALL xios_get_handle("test",ctx_hdl)
-    CALL xios_set_current_context(ctx_hdl)
-  
-    CALL xios_get_calendar_type(calendar_type)
-    PRINT *, "calendar_type = ", calendar_type
-
-    CALL xios_set_axis_attr("axis_A",n_glo=llm ,value=lval) ;
-    CALL xios_set_domain_attr("domain_A",ni_glo=ni_glo, nj_glo=nj_glo, ibegin=ibegin, ni=ni,jbegin=jbegin,nj=nj,type='curvilinear')
-    CALL xios_set_domain_attr("domain_A",data_dim=2, data_ibegin=-1, data_ni=ni+2, data_jbegin=-2, data_nj=nj+4)
-    CALL xios_set_domain_attr("domain_A",lonvalue_2D=lon,latvalue_2D=lat)
-    CALL xios_set_fieldgroup_attr("field_definition",enabled=.TRUE.)
-    !print*, "test block OK", rank, size
-
-    !CALL xios_get_handle("field_definition",fieldgroup_hdl)
-    !CALL xios_add_child(fieldgroup_hdl,field_hdl,"field_B")
-    !CALL xios_set_attr(field_hdl,field_ref="field_A",name="field_B")
-
-    !CALL xios_get_handle("output",file_hdl)
-    !CALL xios_add_child(file_hdl,field_hdl)
-    !CALL xios_set_attr(field_hdl,field_ref="field_A_zoom",name="field_C")
-
-    dtime%second = 3600
-    CALL xios_set_timestep(dtime)
-    !print*, "xios_set_timestep OK", rank, size    
-
-   ! The calendar is created as soon as the calendar type is defined. This way
-   ! calendar operations can be used before the context definition is closed
-   CALL xios_get_time_origin(date)
-   PRINT *, "--> year length = ", xios_get_year_length_in_seconds(date%year)
-   PRINT *, "--> day length = ", xios_get_day_length_in_seconds()
-   CALL xios_date_convert_to_string(date, date_str)
-   PRINT *, "time_origin = ", date_str
-   PRINT *, "xios_date_get_second_of_year(time_origin) = ", xios_date_get_second_of_year(date)
-   PRINT *, "xios_date_get_day_of_year(time_origin) = ", xios_date_get_day_of_year(date)
-   PRINT *, "xios_date_get_fraction_of_year(time_origin) = ", xios_date_get_fraction_of_year(date)
-   PRINT *, "xios_date_get_second_of_day(time_origin) = ", xios_date_get_second_of_day(date)
-   PRINT *, "xios_date_get_fraction_of_day(time_origin) = ", xios_date_get_fraction_of_day(date)
-   dtime%timestep = 1
-   dtime = 0.5 * dtime
-   CALL xios_duration_convert_to_string(dtime, dtime_str)
-   PRINT *, "duration = ", dtime_str
-   date = date + 3 * (dtime + dtime)
-   CALL xios_date_convert_to_string(date, date_str)
-   PRINT *, "date = time_origin + 3 * (duration + duration) = ", date_str
-   PRINT *, "xios_date_convert_to_seconds(date) = ", xios_date_convert_to_seconds(date)
-   PRINT *, "xios_date_convert_to_seconds(date - 2.5h) = ", xios_date_convert_to_seconds(date - 2.5 * xios_hour)
-
-   ni=0 ; lonvalue(:,:)=0;
-   CALL xios_get_domain_attr("domain_A",ni=ni,lonvalue_2D=lonvalue)
-   !print *,"ni",ni
-   !print *,"lonvalue",lonvalue;
-
-   CALL xios_is_defined_field_attr("field_A",enabled=ok)
-   PRINT *,"field_A : attribute enabled is defined ? ",ok 
-   CALL xios_close_context_definition()
-
-   PRINT*,"field field_A is active ? ",xios_field_is_active("field_A")
-
-   DO ts=1,4
-    CALL xios_update_calendar(ts)
-    CALL xios_send_field("field_A",field_A)
-    !CALL xios_send_field("field_Axis",axisValue)
-    ! CALL xios_send_field("field_Axis",lval)
-    !CALL xios_send_field("field_Domain",field_domain)
-    !CALL xios_send_field("field_Scalar",scalar)
-    CALL wait_us(5000)
-   ENDDO
-
-    CALL xios_context_finalize()
-    !print*, "xios_context_finalize OK", rank, size
-
-    CALL xios_finalize()
-    print*, "xios_finalize OK", rank, size
-
-    DEALLOCATE(lon, lat, field_A, lonvalue, axisValue, field_domain)
-    print*, "deallocate OK", rank, size
-    CALL MPI_COMM_FREE(comm, ierr)
-
-
-
-
-
-
-    else
-
-    CALL xios_init_server
-    
-    print*, "server ready to end ", rank, size
-  
-    endif
-    
-  CALL MPI_BARRIER(MPI_COMM_WORLD, ierr)
-  CALL MPI_BARRIER(MPI_COMM_WORLD, ierr)
-  CALL MPI_COMM_RANK(MPI_COMM_WORLD, rank, ierr)
-  CALL MPI_COMM_SIZE(MPI_COMM_WORLD, size, ierr)
-  print*, "before MPI_Finalize : rank = ", rank, size
-  CALL MPI_FINALIZE(ierr)
-  !CALL VTFINI(ierr)
-  print*, "after MPI_Finalize : rank = ", rank, size
-
-END PROGRAM test_omp
-
-
-
-
-
Index: /XIOS/trunk/src/timer.cpp
===================================================================
--- /XIOS/trunk/src/timer.cpp	(revision 1638)
+++ /XIOS/trunk/src/timer.cpp	(revision 1639)
@@ -1,4 +1,3 @@
 #include "timer.hpp"
-//#include "mpi_std.hpp"
 #include "mpi.hpp"
 #include <string>
@@ -7,5 +6,4 @@
 #include <sstream>
 #include "tracer.hpp"
-//extern ::MPI_Comm MPI_COMM_WORLD;
 
 namespace xios
@@ -20,5 +18,4 @@
   double CTimer::getTime(void)
   {
-    MPI_COMM_WORLD;
     return MPI_Wtime();
   }
Index: /XIOS/trunk/src/tracer.cpp
===================================================================
--- /XIOS/trunk/src/tracer.cpp	(revision 1638)
+++ /XIOS/trunk/src/tracer.cpp	(revision 1639)
@@ -1,6 +1,5 @@
 #include "tracer.hpp"
 #ifdef VTRACE
-//#include <vt_user.h>
-#include <VT.h>
+#include <vt_user.h>
 #endif
 #include <string>
@@ -13,6 +12,5 @@
   {
 #ifdef VTRACE
-    //VT_ON() ;
-    VT_traceon() ;
+    VT_ON() ;
 #endif
   }
@@ -21,6 +19,5 @@
   {
 #ifdef VTRACE
-    //VT_OFF() ;
-    VT_traceoff() ;
+    VT_OFF() ;
 #endif
   }
@@ -29,5 +26,5 @@
   {
 #ifdef VTRACE
-    //VT_USER_START(name.c_str()) ;
+    VT_USER_START(name.c_str()) ;
 #endif
   }
@@ -36,5 +33,5 @@
   {
 #ifdef VTRACE
-    //VT_USER_END(name.c_str()) ;
+    VT_USER_END(name.c_str()) ;
 #endif
   }
Index: /XIOS/trunk/src/transformation/axis_algorithm_interpolate.cpp
===================================================================
--- /XIOS/trunk/src/transformation/axis_algorithm_interpolate.cpp	(revision 1638)
+++ /XIOS/trunk/src/transformation/axis_algorithm_interpolate.cpp	(revision 1639)
@@ -272,5 +272,5 @@
 
     int* recvCount=new int[nbClient];
-    ep_lib::MPI_Allgather(&numValue,1,EP_INT,recvCount,1,EP_INT,client->intraComm);
+    MPI_Allgather(&numValue,1,MPI_INT,recvCount,1,MPI_INT,client->intraComm);
 
     int* displ=new int[nbClient];
@@ -279,6 +279,6 @@
 
     // Each client have enough global info of axis
-    ep_lib::MPI_Allgatherv(sendIndexBuff,numValue,EP_INT,recvIndexBuff,recvCount,displ,EP_INT,client->intraComm);
-    ep_lib::MPI_Allgatherv(sendValueBuff,numValue,EP_DOUBLE,&(recvBuff[0]),recvCount,displ,EP_DOUBLE,client->intraComm);
+    MPI_Allgatherv(sendIndexBuff,numValue,MPI_INT,recvIndexBuff,recvCount,displ,MPI_INT,client->intraComm);
+    MPI_Allgatherv(sendValueBuff,numValue,MPI_DOUBLE,&(recvBuff[0]),recvCount,displ,MPI_DOUBLE,client->intraComm);
 
     for (int idx = 0; idx < srcSize; ++idx)
Index: /XIOS/trunk/src/transformation/axis_algorithm_inverse.cpp
===================================================================
--- /XIOS/trunk/src/transformation/axis_algorithm_inverse.cpp	(revision 1638)
+++ /XIOS/trunk/src/transformation/axis_algorithm_inverse.cpp	(revision 1639)
@@ -161,5 +161,5 @@
     sendRankSizeMap[itIndex->first] = sendSize;
   }
-  ep_lib::MPI_Allgather(&connectedClient,1,EP_INT,recvCount,1,EP_INT,client->intraComm);
+  MPI_Allgather(&connectedClient,1,MPI_INT,recvCount,1,MPI_INT,client->intraComm);
 
   displ[0]=0 ;
@@ -168,6 +168,6 @@
   int* recvRankBuff=new int[recvSize];
   int* recvSizeBuff=new int[recvSize];
-  ep_lib::MPI_Allgatherv(sendRankBuff,connectedClient,EP_INT,recvRankBuff,recvCount,displ,EP_INT,client->intraComm);
-  ep_lib::MPI_Allgatherv(sendSizeBuff,connectedClient,EP_INT,recvSizeBuff,recvCount,displ,EP_INT,client->intraComm);
+  MPI_Allgatherv(sendRankBuff,connectedClient,MPI_INT,recvRankBuff,recvCount,displ,MPI_INT,client->intraComm);
+  MPI_Allgatherv(sendSizeBuff,connectedClient,MPI_INT,recvSizeBuff,recvCount,displ,MPI_INT,client->intraComm);
   for (int i = 0; i < nbClient; ++i)
   {
@@ -181,6 +181,6 @@
 
   // Sending global index of grid source to corresponding process as well as the corresponding mask
-  std::vector<ep_lib::MPI_Request> requests;
-  std::vector<ep_lib::MPI_Status> status;
+  std::vector<MPI_Request> requests;
+  std::vector<MPI_Status> status;
   std::unordered_map<int, unsigned long* > recvGlobalIndexSrc;
   std::unordered_map<int, double* > sendValueToDest;
@@ -192,6 +192,6 @@
     sendValueToDest[recvRank] = new double [recvSize];
 
-    requests.push_back(ep_lib::MPI_Request());
-    ep_lib::MPI_Irecv(recvGlobalIndexSrc[recvRank], recvSize, EP_UNSIGNED_LONG, recvRank, 46, client->intraComm, &requests.back());
+    requests.push_back(MPI_Request());
+    MPI_Irecv(recvGlobalIndexSrc[recvRank], recvSize, MPI_UNSIGNED_LONG, recvRank, 46, client->intraComm, &requests.back());
   }
 
@@ -214,14 +214,14 @@
 
     // Send global index source and mask
-    requests.push_back(ep_lib::MPI_Request());
-    ep_lib::MPI_Isend(sendGlobalIndexSrc[sendRank], sendSize, EP_UNSIGNED_LONG, sendRank, 46, client->intraComm, &requests.back());
+    requests.push_back(MPI_Request());
+    MPI_Isend(sendGlobalIndexSrc[sendRank], sendSize, MPI_UNSIGNED_LONG, sendRank, 46, client->intraComm, &requests.back());
   }
 
   status.resize(requests.size());
-  ep_lib::MPI_Waitall(requests.size(), &requests[0], &status[0]);
-
-
-  std::vector<ep_lib::MPI_Request>().swap(requests);
-  std::vector<ep_lib::MPI_Status>().swap(status);
+  MPI_Waitall(requests.size(), &requests[0], &status[0]);
+
+
+  std::vector<MPI_Request>().swap(requests);
+  std::vector<MPI_Status>().swap(status);
 
   // Okie, on destination side, we will wait for information of masked index of source
@@ -231,6 +231,6 @@
     int recvSize = itSend->second;
 
-    requests.push_back(ep_lib::MPI_Request());
-    ep_lib::MPI_Irecv(recvValueFromSrc[recvRank], recvSize, EP_DOUBLE, recvRank, 48, client->intraComm, &requests.back());
+    requests.push_back(MPI_Request());
+    MPI_Irecv(recvValueFromSrc[recvRank], recvSize, MPI_DOUBLE, recvRank, 48, client->intraComm, &requests.back());
   }
 
@@ -249,9 +249,9 @@
     }
     // Okie, now inform the destination which source index are masked
-    requests.push_back(ep_lib::MPI_Request());
-    ep_lib::MPI_Isend(sendValueToDest[recvRank], recvSize, EP_DOUBLE, recvRank, 48, client->intraComm, &requests.back());
+    requests.push_back(MPI_Request());
+    MPI_Isend(sendValueToDest[recvRank], recvSize, MPI_DOUBLE, recvRank, 48, client->intraComm, &requests.back());
   }
   status.resize(requests.size());
-  ep_lib::MPI_Waitall(requests.size(), &requests[0], &status[0]);
+  MPI_Waitall(requests.size(), &requests[0], &status[0]);
 
 
Index: /XIOS/trunk/src/transformation/domain_algorithm_generate_rectilinear.cpp
===================================================================
--- /XIOS/trunk/src/transformation/domain_algorithm_generate_rectilinear.cpp	(revision 1638)
+++ /XIOS/trunk/src/transformation/domain_algorithm_generate_rectilinear.cpp	(revision 1639)
@@ -70,6 +70,6 @@
         StdSize hashValue = hashFunc.hashVec(globalAxisIndex);
         std::vector<StdSize> recvBuff(client->clientSize);
-        ep_lib::MPI_Gather(&hashValue, 1, EP_UNSIGNED_LONG,
-                   &recvBuff[0], 1, EP_UNSIGNED_LONG,
+        MPI_Gather(&hashValue, 1, MPI_UNSIGNED_LONG,
+                   &recvBuff[0], 1, MPI_UNSIGNED_LONG,
                    0,
                    client->intraComm);
@@ -87,5 +87,5 @@
         }
 
-        ep_lib::MPI_Bcast(&nbLocalAxis[0], nbAxis, EP_INT,
+        MPI_Bcast(&nbLocalAxis[0], nbAxis, MPI_INT,
                   0, client->intraComm);
       }
Index: /XIOS/trunk/src/transformation/domain_algorithm_interpolate.cpp
===================================================================
--- /XIOS/trunk/src/transformation/domain_algorithm_interpolate.cpp	(revision 1638)
+++ /XIOS/trunk/src/transformation/domain_algorithm_interpolate.cpp	(revision 1639)
@@ -434,14 +434,10 @@
   CContextClient* client=context->client;
 
-  ep_lib::MPI_Comm poleComme(EP_COMM_NULL);
-  #ifdef _usingMPI
+  MPI_Comm poleComme(MPI_COMM_NULL);
   MPI_Comm_split(client->intraComm, interMapValuePole.empty() ? MPI_UNDEFINED : 1, 0, &poleComme);
-  #elif _usingEP
-  ep_lib::MPI_Comm_split(client->intraComm, interMapValuePole.empty() ? 0 : 1, 0, &poleComme);
-  #endif
-  if (EP_COMM_NULL != poleComme)
+  if (MPI_COMM_NULL != poleComme)
   {
     int nbClientPole;
-    ep_lib::MPI_Comm_size(poleComme, &nbClientPole);
+    MPI_Comm_size(poleComme, &nbClientPole);
 
     std::map<int,std::vector<std::pair<int,double> > >::iterator itePole = interMapValuePole.end(), itPole,
@@ -454,5 +450,5 @@
     std::vector<int> recvCount(nbClientPole,0);
     std::vector<int> displ(nbClientPole,0);
-    ep_lib::MPI_Allgather(&nbWeight,1,EP_INT,&recvCount[0],1,EP_INT,poleComme) ;
+    MPI_Allgather(&nbWeight,1,MPI_INT,&recvCount[0],1,MPI_INT,poleComme) ;
 
     displ[0]=0;
@@ -477,6 +473,6 @@
 
     // Gather all index and weight for pole
-    ep_lib::MPI_Allgatherv(&sendSourceIndexBuff[0],nbWeight,EP_INT,&recvSourceIndexBuff[0],&recvCount[0],&displ[0],EP_INT,poleComme);
-    ep_lib::MPI_Allgatherv(&sendSourceWeightBuff[0],nbWeight,EP_DOUBLE,&recvSourceWeightBuff[0],&recvCount[0],&displ[0],EP_DOUBLE,poleComme);
+    MPI_Allgatherv(&sendSourceIndexBuff[0],nbWeight,MPI_INT,&recvSourceIndexBuff[0],&recvCount[0],&displ[0],MPI_INT,poleComme);
+    MPI_Allgatherv(&sendSourceWeightBuff[0],nbWeight,MPI_DOUBLE,&recvSourceWeightBuff[0],&recvCount[0],&displ[0],MPI_DOUBLE,poleComme);
 
     std::map<int,double> recvTemp;
@@ -635,5 +631,5 @@
 
 
-  ep_lib::MPI_Allreduce(sendBuff, recvBuff, nbClient, EP_INT, EP_SUM, client->intraComm);
+  MPI_Allreduce(sendBuff, recvBuff, nbClient, MPI_INT, MPI_SUM, client->intraComm);
 
   int* sendIndexDestBuff = new int [sendBuffSize];
@@ -641,5 +637,5 @@
   double* sendWeightBuff = new double [sendBuffSize];
 
-  std::vector<ep_lib::MPI_Request> sendRequest;
+  std::vector<MPI_Request> sendRequest;
 
   int sendOffSet = 0, l = 0;
@@ -662,24 +658,24 @@
     }
 
-    sendRequest.push_back(ep_lib::MPI_Request());
-    ep_lib::MPI_Isend(sendIndexDestBuff + sendOffSet,
+    sendRequest.push_back(MPI_Request());
+    MPI_Isend(sendIndexDestBuff + sendOffSet,
              k,
-             EP_INT,
+             MPI_INT,
              itMap->first,
              MPI_DOMAIN_INTERPOLATION_DEST_INDEX,
              client->intraComm,
              &sendRequest.back());
-    sendRequest.push_back(ep_lib::MPI_Request());
-    ep_lib::MPI_Isend(sendIndexSrcBuff + sendOffSet,
+    sendRequest.push_back(MPI_Request());
+    MPI_Isend(sendIndexSrcBuff + sendOffSet,
              k,
-             EP_INT,
+             MPI_INT,
              itMap->first,
              MPI_DOMAIN_INTERPOLATION_SRC_INDEX,
              client->intraComm,
              &sendRequest.back());
-    sendRequest.push_back(ep_lib::MPI_Request());
-    ep_lib::MPI_Isend(sendWeightBuff + sendOffSet,
+    sendRequest.push_back(MPI_Request());
+    MPI_Isend(sendWeightBuff + sendOffSet,
              k,
-             EP_DOUBLE,
+             MPI_DOUBLE,
              itMap->first,
              MPI_DOMAIN_INTERPOLATION_WEIGHT,
@@ -697,34 +693,20 @@
   while (receivedSize < recvBuffSize)
   {
-    ep_lib::MPI_Status recvStatus;
-    #ifdef _usingMPI
+    MPI_Status recvStatus;
     MPI_Recv((recvIndexDestBuff + receivedSize),
              recvBuffSize,
-             EP_INT,
+             MPI_INT,
              MPI_ANY_SOURCE,
              MPI_DOMAIN_INTERPOLATION_DEST_INDEX,
              client->intraComm,
              &recvStatus);
-    #elif _usingEP
-    ep_lib::MPI_Recv((recvIndexDestBuff + receivedSize),
+
+    int countBuff = 0;
+    MPI_Get_count(&recvStatus, MPI_INT, &countBuff);
+    clientSrcRank = recvStatus.MPI_SOURCE;
+
+    MPI_Recv((recvIndexSrcBuff + receivedSize),
              recvBuffSize,
-             EP_INT,
-             -2,
-             MPI_DOMAIN_INTERPOLATION_DEST_INDEX,
-             client->intraComm,
-             &recvStatus);
-    #endif
-
-    int countBuff = 0;
-    ep_lib::MPI_Get_count(&recvStatus, EP_INT, &countBuff);
-    #ifdef _usingMPI
-    clientSrcRank = recvStatus.MPI_SOURCE;
-    #elif _usingEP
-    clientSrcRank = recvStatus.ep_src;
-    #endif
-
-    ep_lib::MPI_Recv((recvIndexSrcBuff + receivedSize),
-             recvBuffSize,
-             EP_INT,
+             MPI_INT,
              clientSrcRank,
              MPI_DOMAIN_INTERPOLATION_SRC_INDEX,
@@ -732,7 +714,7 @@
              &recvStatus);
 
-    ep_lib::MPI_Recv((recvWeightBuff + receivedSize),
+    MPI_Recv((recvWeightBuff + receivedSize),
              recvBuffSize,
-             EP_DOUBLE,
+             MPI_DOUBLE,
              clientSrcRank,
              MPI_DOMAIN_INTERPOLATION_WEIGHT,
@@ -748,11 +730,6 @@
   }
 
-  std::vector<ep_lib::MPI_Status> requestStatus(sendRequest.size());
-  #ifdef _usingMPI
+  std::vector<MPI_Status> requestStatus(sendRequest.size());
   MPI_Waitall(sendRequest.size(), &sendRequest[0], MPI_STATUS_IGNORE);
-  #elif _usingEP
-  std::vector<ep_lib::MPI_Status> waitstat(sendRequest.size());
-  ep_lib::MPI_Waitall(sendRequest.size(), &sendRequest[0], &waitstat[0]);
-  #endif
 
   delete [] sendIndexDestBuff;
@@ -768,5 +745,5 @@
  
 /*! Redefined some functions of CONetCDF4 to make use of them */
-CDomainAlgorithmInterpolate::WriteNetCdf::WriteNetCdf(const StdString& filename, const ep_lib::MPI_Comm comm)
+CDomainAlgorithmInterpolate::WriteNetCdf::WriteNetCdf(const StdString& filename, const MPI_Comm comm)
   : CNc4DataOutput(NULL, filename, false, false, true, comm, false, true) {}
 int CDomainAlgorithmInterpolate::WriteNetCdf::addDimensionWrite(const StdString& name, 
@@ -858,6 +835,6 @@
   }
 
-  ep_lib::MPI_Allreduce(&localNbWeight, &globalNbWeight, 1, EP_LONG, EP_SUM, client->intraComm);
-  ep_lib::MPI_Scan(&localNbWeight, &startIndex, 1, EP_LONG, EP_SUM, client->intraComm);
+  MPI_Allreduce(&localNbWeight, &globalNbWeight, 1, MPI_LONG, MPI_SUM, client->intraComm);
+  MPI_Scan(&localNbWeight, &startIndex, 1, MPI_LONG, MPI_SUM, client->intraComm);
   
   if (0 == globalNbWeight)
Index: /XIOS/trunk/src/transformation/generic_algorithm_transformation.cpp
===================================================================
--- /XIOS/trunk/src/transformation/generic_algorithm_transformation.cpp	(revision 1638)
+++ /XIOS/trunk/src/transformation/generic_algorithm_transformation.cpp	(revision 1639)
@@ -136,5 +136,5 @@
       {
         distributed=domainListSrcP[elementPositionInGridSrc2DomainPosition_[elementPositionInGrid]]->isDistributed() ;
-        ep_lib::MPI_Allreduce(&distributed,&distributed_glo, 1, EP_INT, EP_LOR, client->intraComm) ;
+        MPI_Allreduce(&distributed,&distributed_glo, 1, MPI_INT, MPI_LOR, client->intraComm) ;
     
       }
@@ -142,5 +142,5 @@
       {
         distributed=axisListSrcP[elementPositionInGridSrc2AxisPosition_[elementPositionInGrid]]->isDistributed() ;
-        ep_lib::MPI_Allreduce(&distributed,&distributed_glo, 1, EP_INT, EP_LOR, client->intraComm) ;
+        MPI_Allreduce(&distributed,&distributed_glo, 1, MPI_INT, MPI_LOR, client->intraComm) ;
       }
       else //it's a scalar
@@ -238,5 +238,5 @@
   int sendValue = (computeGlobalIndexOnProc) ? 1 : 0;
   int recvValue = 0;
-  ep_lib::MPI_Allreduce(&sendValue, &recvValue, 1, EP_INT, EP_SUM, client->intraComm);
+  MPI_Allreduce(&sendValue, &recvValue, 1, MPI_INT, MPI_SUM, client->intraComm);
   computeGlobalIndexOnProc = (0 < recvValue);
 
Index: /XIOS/trunk/src/transformation/grid_transformation.cpp
===================================================================
--- /XIOS/trunk/src/transformation/grid_transformation.cpp	(revision 1638)
+++ /XIOS/trunk/src/transformation/grid_transformation.cpp	(revision 1639)
@@ -514,5 +514,5 @@
     sendRankSizeMap[itIndex->first] = sendSize;
   }
-  ep_lib::MPI_Allgather(&connectedClient,1,EP_INT,recvCount,1,EP_INT,client->intraComm);
+  MPI_Allgather(&connectedClient,1,MPI_INT,recvCount,1,MPI_INT,client->intraComm);
 
   displ[0]=0 ;
@@ -521,6 +521,6 @@
   int* recvRankBuff=new int[recvSize];
   int* recvSizeBuff=new int[recvSize];
-  ep_lib::MPI_Allgatherv(sendRankBuff,connectedClient,EP_INT,recvRankBuff,recvCount,displ,EP_INT,client->intraComm);
-  ep_lib::MPI_Allgatherv(sendSizeBuff,connectedClient,EP_INT,recvSizeBuff,recvCount,displ,EP_INT,client->intraComm);
+  MPI_Allgatherv(sendRankBuff,connectedClient,MPI_INT,recvRankBuff,recvCount,displ,MPI_INT,client->intraComm);
+  MPI_Allgatherv(sendSizeBuff,connectedClient,MPI_INT,recvSizeBuff,recvCount,displ,MPI_INT,client->intraComm);
   for (int i = 0; i < nbClient; ++i)
   {
@@ -534,9 +534,8 @@
 
   // Sending global index of grid source to corresponding process as well as the corresponding mask
-  std::vector<ep_lib::MPI_Request> requests(recvRankSizeMap.size()*2 + globaIndexWeightFromSrcToDst.size()*2);
-  std::vector<ep_lib::MPI_Status> status;
+  std::vector<MPI_Request> requests;
+  std::vector<MPI_Status> status;
   std::unordered_map<int, unsigned char* > recvMaskDst;
   std::unordered_map<int, unsigned long* > recvGlobalIndexSrc;
-  int requests_position = 0;
   for (std::map<int,int>::const_iterator itRecv = recvRankSizeMap.begin(); itRecv != recvRankSizeMap.end(); ++itRecv)
   {
@@ -546,11 +545,8 @@
     recvGlobalIndexSrc[recvRank] = new unsigned long [recvSize];
 
-    ep_lib::MPI_Irecv(recvGlobalIndexSrc[recvRank], recvSize, EP_UNSIGNED_LONG, recvRank, 46, client->intraComm, &requests[requests_position++]);
-    ep_lib::MPI_Irecv(recvMaskDst[recvRank], recvSize, EP_UNSIGNED_CHAR, recvRank, 47, client->intraComm, &requests[requests_position++]);
-
-    //requests.push_back(ep_lib::MPI_Request());
-    //ep_lib::MPI_Irecv(recvGlobalIndexSrc[recvRank], recvSize, EP_UNSIGNED_LONG, recvRank, 46, client->intraComm, &requests.back());
-    //requests.push_back(ep_lib::MPI_Request());
-    //ep_lib::MPI_Irecv(recvMaskDst[recvRank], recvSize, EP_UNSIGNED_CHAR, recvRank, 47, client->intraComm, &requests.back());
+    requests.push_back(MPI_Request());
+    MPI_Irecv(recvGlobalIndexSrc[recvRank], recvSize, MPI_UNSIGNED_LONG, recvRank, 46, client->intraComm, &requests.back());
+    requests.push_back(MPI_Request());
+    MPI_Irecv(recvMaskDst[recvRank], recvSize, MPI_UNSIGNED_CHAR, recvRank, 47, client->intraComm, &requests.back());
   }
 
@@ -587,19 +583,16 @@
 
     // Send global index source and mask
-    ep_lib::MPI_Isend(sendGlobalIndexSrc[sendRank], sendSize, EP_UNSIGNED_LONG, sendRank, 46, client->intraComm, &requests[requests_position++]);
-    ep_lib::MPI_Isend(sendMaskDst[sendRank], sendSize, EP_UNSIGNED_CHAR, sendRank, 47, client->intraComm, &requests[requests_position++]);
-    //requests.push_back(ep_lib::MPI_Request());
-    //ep_lib::MPI_Isend(sendGlobalIndexSrc[sendRank], sendSize, EP_UNSIGNED_LONG, sendRank, 46, client->intraComm, &requests.back());
-    //requests.push_back(ep_lib::MPI_Request());
-    //ep_lib::MPI_Isend(sendMaskDst[sendRank], sendSize, EP_UNSIGNED_CHAR, sendRank, 47, client->intraComm, &requests.back());
+    requests.push_back(MPI_Request());
+    MPI_Isend(sendGlobalIndexSrc[sendRank], sendSize, MPI_UNSIGNED_LONG, sendRank, 46, client->intraComm, &requests.back());
+    requests.push_back(MPI_Request());
+    MPI_Isend(sendMaskDst[sendRank], sendSize, MPI_UNSIGNED_CHAR, sendRank, 47, client->intraComm, &requests.back());
   }
 
   status.resize(requests.size());
-  ep_lib::MPI_Waitall(requests.size(), &requests[0], &status[0]);
+  MPI_Waitall(requests.size(), &requests[0], &status[0]);
 
   // Okie, now use the mask to identify which index source we need to send, then also signal the destination which masked index we will return
-  requests.resize(sendRankSizeMap.size() + recvRankSizeMap.size());
-  requests_position = 0;
-  std::vector<ep_lib::MPI_Status>().swap(status);
+  std::vector<MPI_Request>().swap(requests);
+  std::vector<MPI_Status>().swap(status);
   // Okie, on destination side, we will wait for information of masked index of source
   for (std::map<int,int>::const_iterator itSend = sendRankSizeMap.begin(); itSend != sendRankSizeMap.end(); ++itSend)
@@ -608,7 +601,6 @@
     int recvSize = itSend->second;
 
-    ep_lib::MPI_Irecv(sendMaskDst[recvRank], recvSize, EP_UNSIGNED_CHAR, recvRank, 48, client->intraComm, &requests[requests_position++]);
-    //requests.push_back(ep_lib::MPI_Request());
-    //ep_lib::MPI_Irecv(sendMaskDst[recvRank], recvSize, EP_UNSIGNED_CHAR, recvRank, 48, client->intraComm, &requests.back());
+    requests.push_back(MPI_Request());
+    MPI_Irecv(sendMaskDst[recvRank], recvSize, MPI_UNSIGNED_CHAR, recvRank, 48, client->intraComm, &requests.back());
   }
 
@@ -646,10 +638,9 @@
 
     // Okie, now inform the destination which source index are masked
-    ep_lib::MPI_Isend(recvMaskDst[recvRank], recvSize, EP_UNSIGNED_CHAR, recvRank, 48, client->intraComm, &requests[requests_position++]);
-    //requests.push_back(ep_lib::MPI_Request());
-    //ep_lib::MPI_Isend(recvMaskDst[recvRank], recvSize, EP_UNSIGNED_CHAR, recvRank, 48, client->intraComm, &requests.back());
+    requests.push_back(MPI_Request());
+    MPI_Isend(recvMaskDst[recvRank], recvSize, MPI_UNSIGNED_CHAR, recvRank, 48, client->intraComm, &requests.back());
   }
   status.resize(requests.size());
-  ep_lib::MPI_Waitall(requests.size(), &requests[0], &status[0]);
+  MPI_Waitall(requests.size(), &requests[0], &status[0]);
 
   // Cool, now we can fill in local index of grid destination (counted for masked index)
