From: cvw <cvw>
Date: Tue, 3 Jan 2012 15:09:04 +0000 (+0000)
Subject: partition of meshes MEDCoupling with MEDCouplingFieldDouble
X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=a298fa6d8db8e479fdad375aecc29f88dcf7944c;p=tools%2Fmedcoupling.git

partition of meshes MEDCoupling with MEDCouplingFieldDouble
---

diff --git a/src/MEDPartitioner/Test/MEDPARTITIONERTest.cxx b/src/MEDPartitioner/Test/MEDPARTITIONERTest.cxx
new file mode 100644
index 000000000..7b8bde6cc
--- /dev/null
+++ b/src/MEDPartitioner/Test/MEDPARTITIONERTest.cxx
@@ -0,0 +1,1109 @@
+// Copyright (C) 2007-2011  CEA/DEN, EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+
+#include <sstream>
+#include <cmath>
+#include <list>
+#include <stdexcept>
+#include <cstdlib>
+#include <vector>
+
+//#include "MEDPARTITIONERTest.hxx"
+#include <cppunit/TestAssert.h>
+
+//#include "MEDMEM_STRING.hxx"
+
+#include "MEDPARTITIONERTest.hxx"
+
+#include "CellModel.hxx"
+#include "MEDFileMesh.hxx"
+#include "MEDLoader.hxx"
+#include "MEDLoaderBase.hxx"
+#include "MEDCouplingUMesh.hxx"
+#include "MEDCouplingExtrudedMesh.hxx"
+#include "MEDCouplingFieldDouble.hxx"
+#include "MEDCouplingMemArray.hxx"
+#include "MEDCouplingMultiFields.hxx"
+
+#include "MEDPARTITIONER_MESHCollection.hxx"
+//#include "MEDPARTITIONER_Topology.hxx"
+#include "MEDPARTITIONER_ParallelTopology.hxx"
+#include "MEDPARTITIONER_ParaDomainSelector.hxx"
+
+#include "MEDPARTITIONER_utils.hxx"
+
+#ifdef HAVE_MPI2
+#include <mpi.h>
+#endif
+
+using namespace std;
+//using namespace MEDPARTITIONER;
+using namespace ParaMEDMEM;
+using namespace MEDPARTITIONER;
+
+/*string intToStr(int i)
+{
+  ostringstream oss;
+  oss<<i;
+  return oss.str();
+}*/
+
+void MEDPARTITIONERTest::setSize(int ni, int nj, int nk)
+{
+  this->_ni=ni;  //nb of hexa9
+  this->_nj=nj;
+  this->_nk=nk;
+  this->_ntot=_ni*_nj*_nk;
+  string ijk=intToStr(ni)+"x"+intToStr(nj)+"x"+intToStr(nk);
+  this->_fileName="tmp_testMesh_"+ijk+".med";
+  this->_fileNameWithFaces="tmp_testMeshWithFaces_"+ijk+".med";
+  string ij=intToStr(ni)+"x"+intToStr(nj);
+  this->_fileName2="tmp_testMesh_"+ij+".med";
+  this->_meshName="testMesh";
+}
+
+void MEDPARTITIONERTest::setSmallSize()
+{
+  setSize(2,3,5); //nb of hexa9
+}
+
+void MEDPARTITIONERTest::setMedianSize()
+{
+  setSize(20,30,50); //nb of hexa9
+}
+
+void MEDPARTITIONERTest::setbigSize()
+{
+  setSize(200,300,500); //nb of hexa9
+}
+
+
+// ============================================================================
+/*!
+ *  Set up the environment called at every CPPUNIT_TEST ()
+ */
+// ============================================================================
+void MEDPARTITIONERTest::setUp()
+{
+  this->_verbose=0;
+}
+
+// ============================================================================
+/*!
+ *  - delete
+ */
+// ============================================================================
+void MEDPARTITIONERTest::tearDown()
+{
+}
+
+ParaMEDMEM::MEDCouplingUMesh * MEDPARTITIONERTest::buildCUBE3DMesh()
+//only hexa8
+{
+  vector<int> conn;
+  vector<double> coor;
+  for (int k=0; k<=_nk; k++)
+  for (int j=0; j<=_nj; j++)
+  for (int i=0; i<=_ni; i++)
+  {
+    coor.push_back(i+.1);
+    coor.push_back(j+.2);
+    coor.push_back(k+.3);
+  }
+  int ii;
+  for (int k=0; k<_nk; k++)
+  for (int j=0; j<_nj; j++)
+  for (int i=0; i<_ni; i++)
+  {
+    ii=i + j*(_ni+1) + k*(_ni+1)*(_nj+1);
+    conn.push_back(ii);
+    conn.push_back(ii+1);
+    ii=ii + _ni + 2 ;
+    conn.push_back(ii);
+    conn.push_back(ii-1);
+    
+    ii=i + j*(_ni+1) + (k+1)*(_ni+1)*(_nj+1);
+    conn.push_back(ii);
+    conn.push_back(ii+1);
+    ii=ii + _ni + 2 ;
+    conn.push_back(ii);
+    conn.push_back(ii-1);
+  }
+
+  if (false) //(_verbose)
+  {
+    cout<<"\nnb coor "<<(_ni+1)*(_nj+1)*(_nk+1)*3<<" "<<coor.size()<<endl;
+    for (int i=0; i<coor.size(); i++) cout<<coor[i]<<" ";
+    cout<<endl;
+    cout<<"\nnb conn "<<(_ni)*(_nj)*(_nk)*8<<" "<<conn.size()<<endl;
+    for (int i=0; i<conn.size(); i=i+8)
+    { 
+      for (int j=0; j<8; j++) cout<<conn[i+j]<<" ";
+      cout<<endl;
+    }
+    cout<<endl;
+  }
+  
+  MEDCouplingUMesh *mesh=MEDCouplingUMesh::New();
+  mesh->setMeshDimension(3);
+  int nbc=conn.size()/8; //nb of cells
+  int nbv=coor.size()/3; //nb of vertices
+  mesh->allocateCells(nbc);
+  for(int i=0; i<nbc; i++)
+  {
+    int onehexa[8];
+    std::copy(conn.begin()+i*8,conn.begin()+(i+1)*8,onehexa);
+    if (false) //(_verbose)
+    {
+      for (int j=0; j<8; j++) cout<<onehexa[j]<<" ";
+      cout<<endl;
+    }
+    mesh->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,onehexa);
+  }
+  mesh->finishInsertingCells();
+  DataArrayDouble *myCoords=DataArrayDouble::New();
+  myCoords->alloc(nbv,3);
+  std::copy(coor.begin(),coor.end(),myCoords->getPointer());
+  mesh->setCoords(myCoords);
+  mesh->setName(_meshName.c_str());
+  myCoords->decrRef();
+  mesh->checkCoherency();
+  return mesh;
+}
+
+ParaMEDMEM::MEDCouplingUMesh * MEDPARTITIONERTest::buildCARRE3DMesh()
+//only quad4 in oblique (k=j)
+{
+  vector<int> conn;
+  vector<double> coor;
+  for (int j=0; j<=_nj; j++)
+  for (int i=0; i<=_ni; i++)
+  {
+    int k=j;
+    coor.push_back(i+.1);
+    coor.push_back(j+.2);
+    coor.push_back(k+.3);
+  }
+  int ii;
+  int k=0;
+  for (int j=0; j<_nj; j++)
+  for (int i=0; i<_ni; i++)
+  {
+    ii=i + j*(_ni+1) + k*(_ni+1)*(_nj+1);
+    conn.push_back(ii);
+    conn.push_back(ii+1);
+    ii=ii + _ni + 2 ;
+    conn.push_back(ii);
+    conn.push_back(ii-1);
+   }
+
+  if (false) //(_verbose)
+  {
+    cout<<"\nnb coor "<<(_ni+1)*(_nj+1)*3<<" "<<coor.size()<<endl;
+    for (int i=0; i<coor.size(); i++) cout<<coor[i]<<" ";
+    cout<<endl;
+    cout<<"\nnb conn "<<(_ni)*(_nj)*4<<" "<<conn.size()<<endl;
+    for (int i=0; i<conn.size(); i=i+4)
+    { 
+      for (int j=0; j<4; j++) cout<<conn[i+j]<<" ";
+      cout<<endl;
+    }
+    cout<<endl;
+  }
+  
+  MEDCouplingUMesh *mesh=MEDCouplingUMesh::New();
+  mesh->setMeshDimension(2);
+  int nbc=conn.size()/4; //nb of cells
+  int nbv=coor.size()/3; //nb of vertices
+  mesh->allocateCells(nbc);
+  for(int i=0; i<nbc; i++)
+  {
+    int onequa[4];
+    std::copy(conn.begin()+i*4,conn.begin()+(i+1)*4,onequa);
+    if (false) //(_verbose)
+    {
+      for (int j=0; j<4; j++) cout<<onequa[j]<<" ";
+      cout<<endl;
+    }
+    mesh->insertNextCell(INTERP_KERNEL::NORM_QUAD4,4,onequa);
+  }
+  mesh->finishInsertingCells();
+  DataArrayDouble *myCoords=DataArrayDouble::New();
+  myCoords->alloc(nbv,3);
+  std::copy(coor.begin(),coor.end(),myCoords->getPointer());
+  mesh->setCoords(myCoords);
+  mesh->setName(_meshName.c_str());
+  myCoords->decrRef();
+  mesh->checkCoherency();
+  return mesh;
+}
+
+ParaMEDMEM::MEDCouplingUMesh * MEDPARTITIONERTest::buildFACE3DMesh()
+//only quad4 on a global face of the CUBE3D (k=0)
+{
+  vector<int> conn;
+  vector<double> coor;
+  for (int j=0; j<=_nj; j++)
+  for (int i=0; i<=_ni; i++)
+  {
+    int k=0;
+    coor.push_back(i+.1);
+    coor.push_back(j+.2);
+    coor.push_back(k+.3);
+  }
+  int ii;
+  int k=0;
+  for (int j=0; j<_nj; j++)
+  for (int i=0; i<_ni; i++)
+  {
+    ii=i + j*(_ni+1) + k*(_ni+1)*(_nj+1);
+    conn.push_back(ii);
+    conn.push_back(ii+1);
+    ii=ii + _ni + 2 ;
+    conn.push_back(ii);
+    conn.push_back(ii-1);
+   }
+
+  if (false) //(_verbose)
+  {
+    cout<<"\nnb coor "<<(_ni+1)*(_nj+1)*3<<" "<<coor.size()<<endl;
+    for (int i=0; i<coor.size(); i++) cout<<coor[i]<<" ";
+    cout<<endl;
+    cout<<"\nnb conn "<<(_ni)*(_nj)*4<<" "<<conn.size()<<endl;
+    for (int i=0; i<conn.size(); i=i+4)
+    { 
+      for (int j=0; j<4; j++) cout<<conn[i+j]<<" ";
+      cout<<endl;
+    }
+    cout<<endl;
+  }
+  
+  MEDCouplingUMesh *mesh=MEDCouplingUMesh::New();
+  mesh->setMeshDimension(2);
+  int nbc=conn.size()/4; //nb of cells
+  int nbv=coor.size()/3; //nb of vertices
+  mesh->allocateCells(nbc);
+  for(int i=0; i<nbc; i++)
+  {
+    int onequa[4];
+    std::copy(conn.begin()+i*4,conn.begin()+(i+1)*4,onequa);
+    if (false) //(_verbose)
+    {
+      for (int j=0; j<4; j++) cout<<onequa[j]<<" ";
+      cout<<endl;
+    }
+    mesh->insertNextCell(INTERP_KERNEL::NORM_QUAD4,4,onequa);
+  }
+  mesh->finishInsertingCells();
+  DataArrayDouble *myCoords=DataArrayDouble::New();
+  myCoords->alloc(nbv,3);
+  std::copy(coor.begin(),coor.end(),myCoords->getPointer());
+  mesh->setCoords(myCoords);
+  mesh->setName(_meshName.c_str());
+  myCoords->decrRef();
+  mesh->checkCoherency();
+  return mesh;
+}
+
+MEDCouplingFieldDouble * MEDPARTITIONERTest::buildVecFieldOnCells(string myfileName)
+{
+  //int ni=2,nj=3,nk=5; //nb of hexa9
+  vector<double> field;
+  for (int k=0; k<_nk; k++)
+  for (int j=0; j<_nj; j++)
+  for (int i=0; i<_ni; i++)
+  {
+    field.push_back(i+.1);
+    field.push_back(j+.2);
+    field.push_back(k+.3);
+  }
+  //cvwat
+  MEDCouplingUMesh *mesh=MEDLoader::ReadUMeshFromFile(myfileName.c_str(),_meshName.c_str(),0);
+  int nbOfCells=mesh->getNumberOfCells();
+  MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
+  f1->setName("VectorFieldOnCells");
+  f1->setDescription("DescriptionOfFieldOnCells"); //not saved in file?
+  f1->setMesh(mesh);
+  DataArrayDouble *myField=DataArrayDouble::New();
+  myField->alloc(nbOfCells,3);
+  std::copy(field.begin(),field.end(),myField->getPointer());
+  f1->setArray(myField);
+  myField->setInfoOnComponent(0,"vx");
+  myField->setInfoOnComponent(1,"vy");
+  myField->setInfoOnComponent(2,"vz");
+  myField->decrRef();
+  f1->setTime(2.,0,1);
+  f1->checkCoherency();
+  mesh->decrRef();
+  return f1;
+}
+
+MEDCouplingFieldDouble * MEDPARTITIONERTest::buildVecFieldOnNodes()
+{
+  //int ni=2,nj=3,nk=5; //nb of hexa9
+  vector<double> field;
+  for (int k=0; k<=_nk; k++)
+  for (int j=0; j<=_nj; j++)
+  for (int i=0; i<=_ni; i++)
+  {
+    field.push_back(i+.1);
+    field.push_back(j+.2);
+    field.push_back(k+.3);
+  }
+  
+  MEDCouplingUMesh *mesh=MEDLoader::ReadUMeshFromFile(_fileName.c_str(),_meshName.c_str(),0);
+  int nbOfNodes=mesh->getNumberOfNodes();
+  MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_NODES,ONE_TIME);
+  f1->setName("VectorFieldOnNodes");
+  f1->setDescription("DescriptionOfFieldOnNodes"); //not saved in file?
+  f1->setMesh(mesh);
+  DataArrayDouble *myField=DataArrayDouble::New();
+  myField->alloc(nbOfNodes,3);
+  std::copy(field.begin(),field.end(),myField->getPointer());
+  f1->setArray(myField);
+  myField->setInfoOnComponent(0,"vx");
+  myField->setInfoOnComponent(1,"vy");
+  myField->setInfoOnComponent(2,"vz");
+  myField->decrRef();
+  f1->setTime(2.,0,1);
+  f1->checkCoherency();
+  mesh->decrRef();
+  return f1;
+}
+
+
+void MEDPARTITIONERTest::createTestMeshWithoutField()
+{
+  {
+  MEDCouplingUMesh * mesh = buildCUBE3DMesh();
+  MEDLoader::WriteUMesh(_fileName.c_str(),mesh,true);
+  if (_verbose) cout<<endl<<_fileName<<" created"<<endl;
+  if (_ntot<1000000) //too long
+  {
+    MEDCouplingUMesh *mesh_rw=MEDLoader::ReadUMeshFromFile(_fileName.c_str(),mesh->getName(),0);
+    if (_verbose) cout<<_fileName<<" reread"<<endl;
+    CPPUNIT_ASSERT(mesh->isEqual(mesh_rw,1e-12));
+    mesh_rw->decrRef();
+  }
+  mesh->decrRef();
+  }
+  
+  {
+  vector<const ParaMEDMEM::MEDCouplingUMesh*> meshes;
+  MEDCouplingUMesh * mesh1 = buildCUBE3DMesh();
+  MEDCouplingUMesh * mesh2 = buildFACE3DMesh();
+  mesh1->setName("testMesh");
+  mesh2->setName("theFaces");
+  mesh2->tryToShareSameCoordsPermute(*mesh1, 1e-9);
+  mesh2->checkCoherency();
+  mesh1->checkCoherency();
+  meshes.push_back(mesh1);
+  meshes.push_back(mesh2);
+  MEDLoader::WriteUMeshes(_fileNameWithFaces.c_str(), meshes, true);
+  
+  ParaMEDMEM::MEDFileUMesh* mfm=ParaMEDMEM::MEDFileUMesh::New(_fileNameWithFaces.c_str(), mesh1->getName());
+  DataArrayInt* FacesFam=DataArrayInt::New();
+  FacesFam->alloc(mfm->getSizeAtLevel(-1),1);
+  FacesFam->fillWithValue(-1);
+  DataArrayInt* CellsFam=DataArrayInt::New();
+  CellsFam->alloc(mfm->getSizeAtLevel(0),1);
+  CellsFam->fillWithValue(1);
+  mfm->setFamilyFieldArr(-1,FacesFam);
+  mfm->setFamilyFieldArr(0,CellsFam);
+  map<string,int> theFamilies;
+  theFamilies["FAMILLE_ZERO"]=0;
+  theFamilies["FamilyFaces"]=-1;
+  theFamilies["FamilyCells"]=1;
+  map<string, vector<string> > theGroups;
+  theGroups["GroupFaces"].push_back("FamilyFaces");
+  theGroups["GroupCells"].push_back("FamilyCells");
+  mfm->setFamilyInfo(theFamilies);
+  mfm->setGroupInfo(theGroups);
+  mfm->write(_fileNameWithFaces.c_str(),0);
+  FacesFam->decrRef();
+  CellsFam->decrRef();
+  
+  /*ce truc marche pas!
+  ParaMEDMEM::MEDFileUMesh* mfm=ParaMEDMEM::MEDFileUMesh::New(_fileNameWithFaces.c_str(), mesh1->getName());
+  vector<const ParaMEDMEM::MEDCouplingUMesh*> ms;
+  ms.push_back(mesh2);
+  mfm->setGroupsFromScratch(-1, ms);
+  mfm->write(_fileNameWithFaces.c_str(),0);
+  */
+  
+  if (_verbose) cout<<endl<<_fileNameWithFaces<<" created"<<endl;
+  if (_ntot<1000000) //too long
+  {
+    MEDCouplingUMesh *mesh_rw=MEDLoader::ReadUMeshFromFile(_fileNameWithFaces.c_str(),mesh1->getName(),0);
+    if (_verbose) cout<<_fileNameWithFaces<<" reread"<<endl;
+    CPPUNIT_ASSERT(mesh1->isEqual(mesh_rw,1e-12));
+    mesh_rw->decrRef();
+  }
+  mesh1->decrRef();
+  mesh2->decrRef();
+  }
+   
+  {
+  MEDCouplingUMesh * mesh = buildCARRE3DMesh();
+  MEDLoader::WriteUMesh(_fileName2.c_str(),mesh,true);
+  if (_verbose) cout<<endl<<_fileName2<<" created"<<endl;
+  MEDCouplingUMesh *mesh_rw=MEDLoader::ReadUMeshFromFile(_fileName2.c_str(),mesh->getName(),0);
+  if (_verbose) cout<<_fileName2<<" reread"<<endl;
+  CPPUNIT_ASSERT(mesh->isEqual(mesh_rw,1e-12));
+  mesh_rw->decrRef();
+  mesh->decrRef();
+  }
+}
+
+void MEDPARTITIONERTest::createHugeTestMesh(int ni, int nj, int nk, int nbx, int nby, int nbz, int nbTarget)
+{
+  setSize(ni,nj,nk);
+  _nbTargetHuge=nbTarget;
+  MEDCouplingUMesh * mesh = buildCUBE3DMesh();
+  //int nbx=1, nby=1, nbz=2;
+  std::vector< double > cooDep,cooFin;
+  mesh->getCoordinatesOfNode(0, cooDep);
+  mesh->getCoordinatesOfNode(mesh->getNumberOfNodes()-1, cooFin);
+  //cout<<endl<<cooDep[0]<<" "<<cooDep[1]<<" "<<cooDep[2]<<endl;
+  //cout<<cooFin[0]<<" "<<cooFin[1]<<" "<<cooFin[2]<<endl;
+
+  string tagXml="\
+<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n \
+<root>\n \
+  <version maj=\"2\" min=\"3\" ver=\"1\"/>\n \
+  <description what=\"\" when=\"YYMMDDHHmm\"/>\n \
+  <content>\n \
+    <mesh name=\"testMesh\"/>\n \
+  </content>\n \
+  <splitting>\n \
+    <subdomain number=\"$subdomainNumber\"/>\n \
+    <global_numbering present=\"no\"/>\n \
+  </splitting>\n \
+  <files>\n$tagSubfile \
+  </files>\n \
+  <mapping>\n$tagMesh \
+  </mapping>\n \
+</root>\n";
+  
+  string tagSubfiles, tagSubfile="\
+    <subfile id=\"$xyz\">\n \
+      <name>$fileName</name>\n \
+      <machine>localhost</machine>\n \
+    </subfile>\n";
+  string tagMeshes, tagMesh="\
+    <mesh name=\"testMesh\">\n \
+      <chunk subdomain=\"$xyz\">\n \
+        <name>testMesh</name>\n \
+      </chunk>\n \
+    </mesh>\n";
+  
+  int xyz=1;
+  string sxyz;
+  DataArrayDouble* coordsInit=mesh->getCoords()->deepCpy();
+  double* ptrInit=coordsInit->getPointer();
+  double deltax=cooFin[0]-cooDep[0];
+  double deltay=cooFin[1]-cooDep[1];
+  double deltaz=cooFin[2]-cooDep[2];
+  
+  double dz=0.;
+  for (int z=0; z<nbz; z++)
+  {
+    double dy=0.;
+    for (int y=0; y<nby; y++)
+    {
+      double dx=0.;
+      for (int x=0; x<nbx; x++)
+      {
+        string fileName;
+        sxyz=intToStr(xyz);
+        fileName="tmp_testMeshHuge_"+intToStr(_ni)+"x"+intToStr(_nj)+"x"+intToStr(_nk)+"_"+sxyz+".med";
+        
+        DataArrayDouble* coords=mesh->getCoords();
+        //int nbOfComp=coords->getNumberOfComponents();  //be 3D
+        int nbOfTuple=coords->getNumberOfTuples();
+        double* ptr=coords->getPointer();
+        double* ptrini=ptrInit;
+        for (int i=0; i<nbOfTuple; i++)
+        {
+          *ptr=(*ptrini)+dx; ptr++; ptrini++; //be 3D
+          *ptr=(*ptrini)+dy; ptr++; ptrini++;
+          *ptr=(*ptrini)+dz; ptr++; ptrini++;
+        }
+
+        MEDLoader::WriteUMesh(fileName.c_str(),mesh,true);
+        
+        tagSubfiles+=tagSubfile;
+        tagSubfiles.replace(tagSubfiles.find("$xyz"),4,sxyz);
+        tagSubfiles.replace(tagSubfiles.find("$fileName"),9,fileName);
+        
+        tagMeshes+=tagMesh;
+        tagMeshes.replace(tagMeshes.find("$xyz"),4,sxyz);
+        xyz++;
+        dx+=deltax;
+      }
+      dy+=deltay;
+    }
+    dz+=deltaz;
+  }
+  coordsInit->decrRef();
+  
+  tagXml.replace(tagXml.find("$subdomainNumber"),16,sxyz);
+  tagXml.replace(tagXml.find("$tagSubfile"),11,tagSubfiles);
+  tagXml.replace(tagXml.find("$tagMesh"),8,tagMeshes);
+
+  string nameFileXml;
+  _fileNameHugeXml="tmp_testMeshHuge_"+intToStr(_ni)+"x"+intToStr(_nj)+"x"+intToStr(_nk)+"_"+sxyz+".xml";
+  std::ofstream f(_fileNameHugeXml.c_str());
+  f<<tagXml;
+  f.close();
+  //cout<<"\n"<<tagXml<<endl;
+  if (_verbose) 
+    cout<<endl<<nameFileXml<<" created"<<endl;
+}
+
+void MEDPARTITIONERTest::createTestMeshWithVecFieldOnCells()
+{
+  {
+  string name=_fileName;
+  MEDCouplingFieldDouble *f1=buildVecFieldOnCells(name);
+  name.replace(name.find(".med"),4,"_WithVecFieldOnCells.med");
+  MEDLoader::WriteField(name.c_str(),f1,true);
+  f1->setTime(3.,1,1);  //time,it,order
+  f1->applyFunc("x/2.");
+  MEDLoader::WriteField(name.c_str(),f1,false);
+  if (_verbose) cout<<endl<<name<<" created"<<endl;
+  if (_ntot<1000000) //too long
+  {
+     MEDCouplingFieldDouble *f2=MEDLoader::ReadFieldCell(name.c_str(),f1->getMesh()->getName(),0,f1->getName(),0,1);
+    //DataArrayDouble *res=f2->getArray();
+    if (_verbose) cout<<name<<" reread"<<endl;
+    //CPPUNIT_ASSERT(f1->isEqual(f2,1e-12,1e-12));
+    f2->decrRef();
+  }
+  f1->decrRef();
+  }
+  {
+  string name=_fileName;
+  MEDCouplingFieldDouble *f1=buildVecFieldOnCells(name);
+  name.replace(name.find(".med"),4,"_WithVecFieldOnGaussNe.med");
+  MEDCouplingFieldDouble *f3=MEDCouplingFieldDouble::New(ON_GAUSS_NE,ONE_TIME);
+  f3->setMesh(f1->getMesh());
+  //cout<<"\nNumberOfMeshPlacesExpected "<<f3->getNumberOfMeshPlacesExpected()<<" "
+  //                                     /*<<getNumberOfTuples(f1->getMesh())<<" "*/
+  //                                     <<f3->getMesh()->getNumberOfNodes()<<" "
+  //                                     <<f3->getMesh()->getNumberOfCells()<<endl;
+  f3->setName("MyFieldOnGaussNE");
+  f3->setDescription("MyDescriptionNE");
+  DataArrayDouble *array=DataArrayDouble::New();
+  //int nb=f1->getMesh()->getNumberOfNodes();
+  
+  /*8 pt de gauss by cell
+  int nb=f3->getMesh()->getNumberOfCells()*8;
+  array->alloc(nb,2);
+  double *ptr=array->getPointer();
+  for (int i=0; i<nb*2; i=i+2) {ptr[i]=(double)(i/8) ; ptr[i]=2.*(double)(i/8);}
+  */
+  
+  //more nbptgauss=8 by default needs set MEDCouplingFieldDiscretizationPerCell
+  //theory: (may be) http://www.code-aster.org/V2/doc/v9/fr/man_r/r3/r3.06.03.pdf
+  int nbptgauss=8; //nb pt de gauss by cell 
+  int nbcell=f3->getMesh()->getNumberOfCells();
+  int nb=nbcell*nbptgauss;
+  int nbcomp=2;
+  array->alloc(nb,nbcomp);
+  double *ptr=array->getPointer();
+  int ii=0;
+  for (int i=0; i<nbcell; i++)
+    for (int j=0; j<nbptgauss; j++)
+      for (int k=0; k<nbcomp; k++)
+      {
+        //123.4 for 12th cell,3rd component, 4th gausspoint
+        ptr[ii]=(double)((i+1)*10+(k+1))+((double)(j+1))/10.;
+        ii++;
+      }
+  array->setInfoOnComponent(0,"vGx");
+  array->setInfoOnComponent(1,"vGy");
+  f3->setTime(4.,5,6);
+  f3->setArray(array);
+  array->decrRef();
+  MEDLoader::WriteField(name.c_str(),f3,true);
+  if (_verbose) cout<<endl<<name<<" created"<<endl;
+  f3->checkCoherency();
+  f1->decrRef();
+  if (_ntot<1000000) //too long
+  {
+    MEDCouplingFieldDouble* f4=MEDLoader::ReadField(ON_GAUSS_NE,
+           name.c_str(), f3->getMesh()->getName(), 0, "MyFieldOnGaussNE", 5, 6);
+    if (_verbose) cout<<"MyFieldOnGaussNE reread"<<endl;
+    f4->decrRef();
+  }
+  f3->decrRef();
+  }
+  {
+  string name=_fileNameWithFaces;
+  MEDCouplingFieldDouble *f1=buildVecFieldOnCells(name);
+  name.replace(name.find(".med"),4,"_WithVecFieldOnCells.med");
+  MEDLoader::WriteField(name.c_str(),f1,true);
+  if (_verbose) cout<<endl<<name<<" created"<<endl;
+  if (_ntot<1000000) //too long
+  {
+    MEDCouplingFieldDouble *f2=MEDLoader::ReadFieldCell(name.c_str(),f1->getMesh()->getName(),0,f1->getName(),0,1);
+    if (_verbose) cout<<name<<" reread"<<endl;
+    //CPPUNIT_ASSERT(f1->isEqual(f2,1e-12,1e-12)); assertion failed!!
+    f2->decrRef();
+  }
+  f1->decrRef();
+  }
+}
+
+void MEDPARTITIONERTest::createTestMeshWithVecFieldOnNodes()
+{
+  MEDCouplingFieldDouble *f1=buildVecFieldOnNodes();
+  string name=_fileName;
+  name.replace(name.find(".med"),4,"_WithVecFieldOnNodes.med");
+  MEDLoader::WriteField(name.c_str(),f1,true);
+  if (_verbose) cout<<endl<<name<<" created"<<endl;
+  if (_ntot<1000000) //too long
+  {
+    MEDCouplingFieldDouble *f2=MEDLoader::ReadFieldNode(name.c_str(),f1->getMesh()->getName(),0,f1->getName(),0,1);
+    if (_verbose) cout<<name<<" reread"<<endl;
+    //CPPUNIT_ASSERT(f1->isEqual(f2,1e-12,1e-12)); assertion failed!!
+    f2->decrRef();
+  }
+  f1->decrRef();
+}
+
+void MEDPARTITIONERTest::verifyTestMeshWithVecFieldOnNodes()
+{
+  string name=_fileName;
+  name.replace(name.find(".med"),4,"_WithVecFieldOnNodes.med");
+  MEDCouplingUMesh * m=MEDLoader::ReadUMeshFromFile(name.c_str(),_meshName.c_str(),0);
+  const std::set<INTERP_KERNEL::NormalizedCellType>& types=m->getAllTypes();
+  if (_verbose)
+  {
+    cout<<"\n types in "<<name<<" : ";
+    //for (std::set<INTERP_KERNEL::NormalizedCellType>::iterator t=types.begin(); t!=types.end(); ++t) cout<<" "<<*t;
+    for (std::set<INTERP_KERNEL::NormalizedCellType>::iterator t=types.begin(); t!=types.end(); ++t) 
+    {
+      //INTERP_KERNEL::CellModel essai=INTERP_KERNEL::CellModel::GetCellModel(*t);
+      cout<<" "<<(INTERP_KERNEL::CellModel::GetCellModel(*t)).getRepr();
+    }
+    cout<<endl;
+  }
+  m->decrRef();
+  
+  MEDFileUMesh * mf;
+  mf->New(_fileName.c_str(),_meshName.c_str(),-1,-1);
+  vector<int> lev;
+  lev=mf->getNonEmptyLevels();
+  if (_verbose)
+  {
+    cout<<" levels in "<<name<<" : ";
+    for (vector<int>::iterator l=lev.begin(); l!=lev.end(); ++l) cout<<" "<<*l;
+    cout<<endl;
+  }
+  mf->decrRef();
+}
+
+void MEDPARTITIONERTest::verifyMedpartitionerOnSmallSizeForMesh()
+{
+  int res;
+  string fileName,cmd,execName,sourceName,targetName,input;
+  execName=getenv("MED_ROOT_DIR");  //.../INSTALL/MED
+  execName+="/bin/salome/medpartitioner_para";
+  fileName=_fileNameWithFaces;
+  
+  ParaMEDMEM::MEDFileUMesh* initialMesh=ParaMEDMEM::MEDFileUMesh::New(fileName.c_str(),_meshName.c_str());
+  ParaMEDMEM::MEDCouplingUMesh* cellMesh=initialMesh->getLevel0Mesh(false);
+  ParaMEDMEM::MEDCouplingUMesh* faceMesh=initialMesh->getLevelM1Mesh(false);
+  
+  cmd="mpirun -np 5 "+execName+" --ndomains=5 --split-method=metis";  //on same proc
+  sourceName=fileName;
+  targetName=fileName;
+  targetName.replace(targetName.find(".med"),4,"_partitionedTo5_");
+  cmd+=" --input-file="+sourceName+" --output-file="+targetName+" --verbose="+intToStr(_verbose);
+  if (_verbose) cout<<endl<<cmd<<endl;
+  res=system(cmd.c_str());
+  CPPUNIT_ASSERT_EQUAL(0, res);
+  input=targetName+".xml";
+  
+  MPI_Init(0,0);
+  MPI_Comm_size(MPI_COMM_WORLD, &MyGlobals::_world_size);
+  MPI_Comm_rank(MPI_COMM_WORLD, &MyGlobals::_rank);
+
+  MEDPARTITIONER::ParaDomainSelector parallelizer(false);
+  MEDPARTITIONER::MESHCollection collection(input,parallelizer); //cvwat01
+  CPPUNIT_ASSERT_EQUAL(3, collection.getMeshDimension());
+  std::vector<ParaMEDMEM::MEDCouplingUMesh*>cellMeshes=collection.getMesh();
+  CPPUNIT_ASSERT_EQUAL(5, (int) cellMeshes.size());
+  int nbcells=0;
+  for (int i = 0; i < cellMeshes.size(); i++) nbcells+=cellMeshes[i]->getNumberOfCells();
+  CPPUNIT_ASSERT_EQUAL(cellMesh->getNumberOfCells(), nbcells);
+  
+  std::vector<ParaMEDMEM::MEDCouplingUMesh*>faceMeshes=collection.getFaceMesh();
+  CPPUNIT_ASSERT_EQUAL(5, (int) faceMeshes.size());
+  int nbfaces=0;
+  for (int i = 0; i < faceMeshes.size(); i++) nbfaces+=faceMeshes[i]->getNumberOfCells();
+  CPPUNIT_ASSERT_EQUAL(faceMesh->getNumberOfCells(), nbfaces);
+  
+  //merge split meshes and test equality
+  cmd="mpirun -np 1 "+execName+" --ndomains=1 --split-method=metis";  //on same proc
+  sourceName=targetName+".xml";
+  targetName=fileName;
+  targetName.replace(targetName.find(".med"),4,"_remergedFrom5_");
+  cmd+=" --input-file="+sourceName+" --output-file="+targetName+" --verbose="+intToStr(_verbose);
+  if (_verbose) cout<<endl<<cmd<<endl;
+  res=system(cmd.c_str());
+  CPPUNIT_ASSERT_EQUAL(0, res);
+  
+  string refusedName=targetName+"1.med";
+  ParaMEDMEM::MEDFileUMesh* refusedMesh=ParaMEDMEM::MEDFileUMesh::New(refusedName.c_str(),_meshName.c_str());
+  ParaMEDMEM::MEDCouplingUMesh* refusedCellMesh=refusedMesh->getLevel0Mesh(false);
+  ParaMEDMEM::MEDCouplingUMesh* refusedFaceMesh=refusedMesh->getLevelM1Mesh(false);
+  
+  CPPUNIT_ASSERT_EQUAL(cellMesh->getNumberOfCells(), refusedCellMesh->getNumberOfCells());
+  CPPUNIT_ASSERT_EQUAL(faceMesh->getNumberOfCells(), refusedFaceMesh->getNumberOfCells());
+  
+  /*not the good job
+  ParaMEDMEM::MEDCouplingMesh* mergeCell=cellMesh->mergeMyselfWith(refusedCellMesh);
+  CPPUNIT_ASSERT_EQUAL(cellMesh->getNumberOfCells(), mergeCell->getNumberOfCells());
+  
+  ParaMEDMEM::MEDCouplingMesh* mergeFace=faceMesh->mergeMyselfWith(refusedFaceMesh);
+  CPPUNIT_ASSERT_EQUAL(faceMesh->getNumberOfCells(), mergeFace->getNumberOfCells());
+  
+  CPPUNIT_ASSERT(faceMesh->isEqual(refusedFaceMesh,1e-12));
+  */
+  
+  std::vector<const MEDCouplingUMesh *> meshes;
+  std::vector<DataArrayInt *> corr;
+  meshes.push_back(cellMesh);
+  refusedCellMesh->tryToShareSameCoordsPermute(*cellMesh, 1e-9);
+  meshes.push_back(refusedCellMesh);
+  MEDCouplingUMesh* fusedCell=MEDCouplingUMesh::FuseUMeshesOnSameCoords(meshes,0,corr);
+  CPPUNIT_ASSERT_EQUAL(cellMesh->getNumberOfCells(), fusedCell->getNumberOfCells());
+  
+  meshes.resize(0);
+  for (int i = 0; i < corr.size(); i++) corr[i]->decrRef();
+  corr.resize(0);
+  meshes.push_back(faceMesh);
+  refusedFaceMesh->tryToShareSameCoordsPermute(*faceMesh, 1e-9);
+  meshes.push_back(refusedFaceMesh);
+  MEDCouplingUMesh* fusedFace=MEDCouplingUMesh::FuseUMeshesOnSameCoords(meshes,0,corr);
+  CPPUNIT_ASSERT_EQUAL(faceMesh->getNumberOfCells(), fusedFace->getNumberOfCells());
+  
+  for (int i = 0; i < corr.size(); i++) corr[i]->decrRef();
+  fusedFace->decrRef();
+  refusedFaceMesh->decrRef();
+  faceMesh->decrRef();
+  fusedCell->decrRef();
+  refusedCellMesh->decrRef();
+  cellMesh->decrRef();
+  //done in ~collection
+  //for (int i = 0; i < faceMeshes.size(); i++) faceMeshes[i]->decrRef();
+  //for (int i = 0; i < cellMeshes.size(); i++) cellMeshes[i]->decrRef();
+}
+
+void MEDPARTITIONERTest::verifyMedpartitionerOnSmallSizeForFieldOnCells()
+{
+  int res;
+  string fileName,cmd,execName,sourceName,targetName,input;
+  execName=getenv("MED_ROOT_DIR");  //.../INSTALL/MED
+  execName+="/bin/salome/medpartitioner_para";
+  fileName=_fileName;
+  fileName.replace(fileName.find(".med"),4,"_WithVecFieldOnCells.med");
+  
+  ParaMEDMEM::MEDFileUMesh* initialMesh=ParaMEDMEM::MEDFileUMesh::New(fileName.c_str(),_meshName.c_str());
+  ParaMEDMEM::MEDCouplingUMesh* cellMesh=initialMesh->getLevel0Mesh(false);
+  
+  cmd="mpirun -np 5 "+execName+" --ndomains=5 --split-method=metis";  //on same proc
+  sourceName=fileName;
+  targetName=fileName;
+  targetName.replace(targetName.find(".med"),4,"_partitionedTo5_");
+  cmd+=" --input-file="+sourceName+" --output-file="+targetName+" --verbose="+intToStr(_verbose);
+  if (_verbose) cout<<endl<<cmd<<endl;
+  res=system(cmd.c_str());
+  CPPUNIT_ASSERT_EQUAL(0, res);
+  input=targetName+".xml";
+  
+  //merge split meshes and test equality
+  cmd="mpirun -np 1 "+execName+" --ndomains=1 --split-method=metis";  //on same proc
+  sourceName=targetName+".xml";
+  targetName=fileName;
+  targetName.replace(targetName.find(".med"),4,"_remergedFrom5_");
+  cmd+=" --input-file="+sourceName+" --output-file="+targetName+" --verbose="+intToStr(_verbose);
+  if (_verbose) cout<<endl<<cmd<<endl;
+  res=system(cmd.c_str());
+  CPPUNIT_ASSERT_EQUAL(0, res);
+  
+  string refusedName=targetName+"1.med";
+  ParaMEDMEM::MEDFileUMesh* refusedMesh=ParaMEDMEM::MEDFileUMesh::New(refusedName.c_str(),_meshName.c_str());
+  ParaMEDMEM::MEDCouplingUMesh* refusedCellMesh=refusedMesh->getLevel0Mesh(false);
+  
+  CPPUNIT_ASSERT_EQUAL(cellMesh->getNumberOfCells(), refusedCellMesh->getNumberOfCells());
+  
+  std::vector<const MEDCouplingUMesh *> meshes;
+  std::vector<DataArrayInt *> corr;
+  meshes.push_back(cellMesh);
+  refusedCellMesh->tryToShareSameCoordsPermute(*cellMesh, 1e-9);
+  meshes.push_back(refusedCellMesh);
+  MEDCouplingUMesh* fusedCell=MEDCouplingUMesh::FuseUMeshesOnSameCoords(meshes,0,corr);
+  CPPUNIT_ASSERT_EQUAL(cellMesh->getNumberOfCells(), fusedCell->getNumberOfCells());
+  
+  MEDCouplingFieldDouble* field1=MEDLoader::ReadFieldCell(fileName.c_str(),initialMesh->getName(),0,"VectorFieldOnCells",0,1);
+  MEDCouplingFieldDouble* field2=MEDLoader::ReadFieldCell(refusedName.c_str(),refusedCellMesh->getName(),0,"VectorFieldOnCells",0,1);
+  
+  int nbcells=corr[1]->getNumberOfTuples();
+  CPPUNIT_ASSERT_EQUAL(cellMesh->getNumberOfCells(), nbcells);
+  //use corr to test equality of field
+  DataArrayDouble* f1=field1->getArray();
+  DataArrayDouble* f2=field2->getArray();
+  if (_verbose) 
+  {
+    cout<<"\nf1 : "<<f1->reprZip();
+    cout<<"\nf2 : "<<f2->reprZip(); //field2->advancedRepradvancedRepr();
+    for (int i = 0; i < corr.size(); i++) cout<<"\ncorr "<<i<<" : "<<corr[i]->reprZip();
+    
+  }
+  int nbequal=0;
+  int nbcomp=field1->getNumberOfComponents();
+  double* p1=f1->getPointer();
+  double* p2=f2->getPointer();
+  int* pc=corr[1]->getPointer();
+  for (int i = 0; i < nbcells; i++)
+  {
+    int i1=pc[i]*nbcomp;
+    int i2=i*nbcomp;
+    for (int j = 0; j < nbcomp; j++)
+    {
+      if (p1[i1+j]==p2[i2+j]) nbequal++;
+      //cout<<" "<<p1[i1+j]<<"="<<p2[i2+j];
+    }
+  }
+  CPPUNIT_ASSERT_EQUAL(nbcells*nbcomp, nbequal);
+  
+  for (int i = 0; i < corr.size(); i++) corr[i]->decrRef();
+  field1->decrRef();
+  field2->decrRef();
+  fusedCell->decrRef();
+  refusedCellMesh->decrRef();
+  cellMesh->decrRef();
+}
+
+void MEDPARTITIONERTest::verifyMedpartitionerOnSmallSizeForFieldOnGaussNe()
+{
+  int res;
+  string fileName,cmd,execName,sourceName,targetName,input;
+  execName=getenv("MED_ROOT_DIR");  //.../INSTALL/MED
+  execName+="/bin/salome/medpartitioner_para";
+  fileName=_fileName;
+  fileName.replace(fileName.find(".med"),4,"_WithVecFieldOnGaussNe.med");
+  
+  ParaMEDMEM::MEDFileUMesh* initialMesh=ParaMEDMEM::MEDFileUMesh::New(fileName.c_str(),_meshName.c_str());
+  ParaMEDMEM::MEDCouplingUMesh* cellMesh=initialMesh->getLevel0Mesh(false);
+  
+  cmd="mpirun -np 5 "+execName+" --ndomains=5 --split-method=metis";  //on same proc
+  sourceName=fileName;
+  targetName=fileName;
+  targetName.replace(targetName.find(".med"),4,"_partitionedTo5_");
+  cmd+=" --input-file="+sourceName+" --output-file="+targetName+" --verbose="+intToStr(_verbose);
+  if (_verbose) cout<<endl<<cmd<<endl;
+  res=system(cmd.c_str());
+  CPPUNIT_ASSERT_EQUAL(0, res);
+  input=targetName+".xml";
+  
+  //merge split meshes and test equality
+  cmd="mpirun -np 1 "+execName+" --ndomains=1 --split-method=metis";  //on same proc
+  sourceName=targetName+".xml";
+  targetName=fileName;
+  targetName.replace(targetName.find(".med"),4,"_remergedFrom5_");
+  cmd+=" --input-file="+sourceName+" --output-file="+targetName+" --verbose="+intToStr(_verbose);
+  if (_verbose) cout<<endl<<cmd<<endl;
+  res=system(cmd.c_str());
+  CPPUNIT_ASSERT_EQUAL(0, res);
+  
+  string refusedName=targetName+"1.med";
+  ParaMEDMEM::MEDFileUMesh* refusedMesh=ParaMEDMEM::MEDFileUMesh::New(refusedName.c_str(),_meshName.c_str());
+  ParaMEDMEM::MEDCouplingUMesh* refusedCellMesh=refusedMesh->getLevel0Mesh(false);
+  
+  CPPUNIT_ASSERT_EQUAL(cellMesh->getNumberOfCells(), refusedCellMesh->getNumberOfCells());
+  
+  std::vector<const MEDCouplingUMesh *> meshes;
+  std::vector<DataArrayInt *> corr;
+  meshes.push_back(cellMesh);
+  refusedCellMesh->tryToShareSameCoordsPermute(*cellMesh, 1e-9);
+  meshes.push_back(refusedCellMesh);
+  MEDCouplingUMesh* fusedCell=MEDCouplingUMesh::FuseUMeshesOnSameCoords(meshes,0,corr);
+  CPPUNIT_ASSERT_EQUAL(cellMesh->getNumberOfCells(), fusedCell->getNumberOfCells());
+  
+  MEDCouplingFieldDouble* field1=MEDLoader::ReadField(ON_GAUSS_NE,fileName.c_str(),initialMesh->getName(),0,"MyFieldOnGaussNE",5,6);
+  MEDCouplingFieldDouble* field2=MEDLoader::ReadField(ON_GAUSS_NE,refusedName.c_str(),refusedCellMesh->getName(),0,"MyFieldOnGaussNE",5,6);
+  
+  int nbcells=corr[1]->getNumberOfTuples();
+  CPPUNIT_ASSERT_EQUAL(cellMesh->getNumberOfCells(), nbcells);
+  //use corr to test equality of field
+  DataArrayDouble* f1=field1->getArray();
+  DataArrayDouble* f2=field2->getArray();
+  if (_verbose) 
+  {
+    cout<<"\nf1 : "<<f1->reprZip(); //123.4 for 12th cell,3rd component, 4th gausspoint
+    cout<<"\nf2 : "<<f2->reprZip(); //field2->advancedRepradvancedRepr();
+    for (int i = 0; i < corr.size(); i++) cout<<"\ncorr "<<i<<" : "<<corr[i]->reprZip();
+    
+  }
+  int nbequal=0;
+  int nbptgauss=8;
+  int nbcomp=field1->getNumberOfComponents();
+  double* p1=f1->getPointer();
+  double* p2=f2->getPointer();
+  int* pc=corr[1]->getPointer();
+  for (int i = 0; i < nbcells; i++)
+  {
+    int i1=pc[i]*nbcomp*nbptgauss;
+    int i2=i*nbcomp*nbptgauss;
+    for (int j = 0; j < nbcomp*nbptgauss; j++)
+    {
+      if (p1[i1+j]==p2[i2+j]) nbequal++;
+      //cout<<" "<<p1[i1+j]<<"="<<p2[i2+j];
+    }
+  }
+  CPPUNIT_ASSERT_EQUAL(nbcells*nbcomp*nbptgauss, nbequal);
+  
+  for (int i = 0; i < corr.size(); i++) corr[i]->decrRef();
+  field1->decrRef();
+  field2->decrRef();
+  fusedCell->decrRef();
+  refusedCellMesh->decrRef();
+  cellMesh->decrRef();
+}
+
+void MEDPARTITIONERTest::createTestMeshes()
+{
+  createTestMeshWithoutField();
+  createTestMeshWithVecFieldOnCells();
+  createTestMeshWithVecFieldOnNodes();
+}
+
+
+void MEDPARTITIONERTest::deleteTestMeshes()
+{
+  string cmd="rm *tmp_testMesh*";
+  if (_verbose) cout<<endl<<cmd<<endl;
+  system(cmd.c_str());  //may be not if debug
+}  
+
+void MEDPARTITIONERTest::launchMedpartitionerOnTestMeshes()
+{
+  
+  /* examples 
+  export INFI=/home/vb144235/resources/blade.med
+  //no need export MESH=Fuse_1
+  export INFI=tmp_testMeshxxx.med
+  //no need export MESH=testMesh
+  mpirun -np 2 medpartitioner_para --input-file=$INFI --output-file=ttmp1_ --ndomains=4
+  mpirun -np 5 medpartitioner_para --input-file=ttmp1_.xml --output-file=ttmp2_ --ndomains=5
+  mpirun -np 2 valgrind  medpartitioner_para --input-file=tmp_testMesh_20x30x50.med  --output-file=ttmp1petit_ --ndomains=4  --dump-cpu-memory --verbose=111
+  */
+  int res;
+  string cmd,execName,sourceName,targetName;
+  
+  res=system("which mpirun 2>/dev/null 1>/dev/null"); //no trace
+  CPPUNIT_ASSERT_EQUAL(0, res);
+  
+  execName=getenv("MED_ROOT_DIR");  //.../INSTALL/MED
+  execName+="/bin/salome/medpartitioner_para";
+  
+  cmd="which "+execName+" 2>/dev/null 1>/dev/null";  //no trace
+  res=system(cmd.c_str());
+  CPPUNIT_ASSERT_EQUAL(0, res);
+  
+  cmd="mpirun -np 2 "+execName+" --ndomains=2 --split-method=metis";  //on same proc
+  sourceName=_fileName;
+  targetName=_fileName;
+  targetName.replace(targetName.find(".med"),4,"_partitionedTo2_");
+  cmd+=" --input-file="+sourceName+" --output-file="+targetName+" --verbose="+intToStr(_verbose);
+  if (_verbose) cout<<endl<<cmd<<endl;
+  res=system(cmd.c_str());
+  CPPUNIT_ASSERT_EQUAL(0, res);
+  
+  cmd="mpirun -np 3 "+execName+" --ndomains=5 --split-method=metis"; //on less proc
+  sourceName=_fileName;
+  targetName=_fileName;
+  targetName.replace(targetName.find(".med"),4,"_partitionedTo5_");
+  cmd+=" --input-file="+sourceName+" --output-file="+targetName+" --verbose="+intToStr(_verbose);
+  if (_verbose) cout<<endl<<cmd<<endl;
+  res=system(cmd.c_str());
+  CPPUNIT_ASSERT_EQUAL(0, res);
+  
+  cmd="mpirun -np 1 "+execName+" --ndomains=1 --split-method=metis";  //on 1 proc
+  sourceName=targetName+".xml";
+  targetName=_fileName;
+  targetName.replace(targetName.find(".med"),4,"_remergedFrom5_");
+  cmd+=" --input-file="+sourceName+" --output-file="+targetName+" --verbose="+intToStr(_verbose);
+  if (_verbose) cout<<endl<<cmd<<endl;
+  res=system(cmd.c_str());
+  CPPUNIT_ASSERT_EQUAL(0, res);
+
+  cmd="mpirun -np 8 "+execName+" --ndomains=1 --split-method=metis";  //on more proc
+  //sourceName=targetName+".xml";
+  targetName=_fileName;
+  targetName.replace(targetName.find(".med"),4,"_remergedFrom5_");
+  cmd+=" --input-file="+sourceName+" --output-file="+targetName+" --verbose="+intToStr(_verbose);
+  if (_verbose) cout<<endl<<cmd<<endl;
+  res=system(cmd.c_str());
+  CPPUNIT_ASSERT_EQUAL(0, res);
+}  
+
+void MEDPARTITIONERTest::launchMedpartitionerOnHugeTestMeshes()
+{
+  int res=0;
+  string cmd,execName,sourceName,targetName;
+  execName=getenv("MED_ROOT_DIR");  //.../INSTALL/MED
+  execName+="/bin/salome/medpartitioner_para";
+
+  string snbTarget=intToStr(_nbTargetHuge);
+  cmd="mpirun -np "+snbTarget+" "+execName+" --ndomains="+snbTarget+" --split-method=metis";  //on same proc
+  sourceName=_fileNameHugeXml;
+  targetName=_fileNameHugeXml;
+  string tmp="_partitionedTo"+snbTarget+"_";
+  targetName.replace(targetName.find(".xml"),4,tmp);
+  cmd+=" --input-file="+sourceName+" --output-file="+targetName+" --verbose="+intToStr(_verbose);
+  if (_verbose) cout<<endl<<cmd<<endl;
+  res=system(cmd.c_str());
+  CPPUNIT_ASSERT_EQUAL(0, res);
+}  
+
+void MEDPARTITIONERTest::testSmallSize()
+{
+  setSmallSize();
+  createTestMeshes();
+  launchMedpartitionerOnTestMeshes();
+  verifyMedpartitionerOnSmallSizeForMesh();
+  verifyMedpartitionerOnSmallSizeForFieldOnCells();
+  verifyMedpartitionerOnSmallSizeForFieldOnGaussNe();
+}
+
+void MEDPARTITIONERTest::testMedianSize()
+{
+  setMedianSize();
+  createTestMeshes();
+  launchMedpartitionerOnTestMeshes();
+  createHugeTestMesh(_ni, _nj, _nk, 2, 2, 2, 20); //it is now to know how far we are going to test
+  launchMedpartitionerOnHugeTestMeshes();
+}
diff --git a/src/MEDPartitioner/Test/MEDPARTITIONERTest.hxx b/src/MEDPartitioner/Test/MEDPARTITIONERTest.hxx
new file mode 100644
index 000000000..aebe95e6e
--- /dev/null
+++ b/src/MEDPartitioner/Test/MEDPARTITIONERTest.hxx
@@ -0,0 +1,94 @@
+// Copyright (C) 2007-2011  CEA/DEN, EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+#ifndef _MEDPARTITIONERTEST_HXX_
+#define _MEDPARTITIONERTEST_HXX_
+
+#include <cppunit/extensions/HelperMacros.h>
+
+#include <set>
+#include <string>
+#include <iostream>
+
+#include "MEDCouplingUMesh.hxx"
+#include "MEDCouplingExtrudedMesh.hxx"
+#include "MEDCouplingFieldDouble.hxx"
+
+namespace MEDPARTITIONER {
+  class MESH;
+  /*class DataArrayDouble;
+  class MEDCouplingUMesh;
+  class MEDCouplingFieldDouble;
+  class MEDCouplingMultiFields;*/
+};
+
+class MEDPARTITIONERTest : public CppUnit::TestFixture
+{
+  CPPUNIT_TEST_SUITE( MEDPARTITIONERTest );
+  CPPUNIT_TEST( testSmallSize );
+  CPPUNIT_TEST( testMedianSize );
+  //CPPUNIT_TEST( deleteTestMeshes );
+  CPPUNIT_TEST_SUITE_END();
+
+public:
+
+  //global use
+  int _ni;  //nb of hexa9
+  int _nj;
+  int _nk;
+  int _ntot;
+  std::string _fileName; //initial test mesh file med CUBE3D
+  std::string _fileNameWithFaces; //initial test mesh file med CUBE3D plus a set of faces
+  std::string _fileName2; //initial test mesh file med CARRE3D
+  std::string _fileNameHugeXml;
+  int _nbTargetHuge;
+  std::string _meshName; //initial test mesh file med
+  int _verbose;
+  
+  //for utils
+  void setSize(int ni, int nj, int nk);
+  void setSmallSize();
+  void setMedianSize();
+  void setbigSize();
+  ParaMEDMEM::MEDCouplingUMesh * buildCUBE3DMesh();
+  ParaMEDMEM::MEDCouplingUMesh * buildFACE3DMesh();
+  ParaMEDMEM::MEDCouplingUMesh * buildCARRE3DMesh();
+  ParaMEDMEM::MEDCouplingFieldDouble * buildVecFieldOnCells(std::string myfileName);
+  ParaMEDMEM::MEDCouplingFieldDouble * buildVecFieldOnNodes();
+  void createTestMeshWithoutField();
+  void createTestMeshWithVecFieldOnCells();
+  void createTestMeshWithVecFieldOnNodes();
+  void verifyTestMeshWithVecFieldOnNodes();
+  void verifyMedpartitionerOnSmallSizeForMesh();
+  void verifyMedpartitionerOnSmallSizeForFieldOnCells();
+  void verifyMedpartitionerOnSmallSizeForFieldOnGaussNe();
+  void createTestMeshes();
+  void createHugeTestMesh(int ni, int nj, int nk, int nbx, int nby, int nbz, int nbTarget);
+  void launchMedpartitionerOnTestMeshes();
+  void launchMedpartitionerOnHugeTestMeshes();
+  void deleteTestMeshes();
+  
+  //for CPPUNIT_TEST
+  void setUp();
+  void tearDown();
+  void testSmallSize();
+  void testMedianSize();
+};
+
+#endif
diff --git a/src/MEDPartitioner/Test/Makefile.am b/src/MEDPartitioner/Test/Makefile.am
new file mode 100644
index 000000000..f4bcdd412
--- /dev/null
+++ b/src/MEDPartitioner/Test/Makefile.am
@@ -0,0 +1,114 @@
+# Copyright (C) 2007-2011  CEA/DEN, EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+#  SALOMELocalTrace : log on local machine
+#
+include $(top_srcdir)/adm_local/unix/make_common_starter.am
+
+lib_LTLIBRARIES = libMEDPARTITIONERTest.la
+
+dist_libMEDPARTITIONERTest_la_SOURCES= \
+	MEDPARTITIONERTest.cxx
+#	MEDPARTITIONERTest_Utils.cxx
+
+#if MED_ENABLE_PARMETIS
+#  dist_libMEDPARTITIONERTest_la_SOURCES+= \
+#	ParaMEDPARTITIONERTest.hxx
+#endif
+
+salomeinclude_HEADERS = \
+	MEDPARTITIONERTest.hxx
+#	MEDPARTITIONERTest_Utils.hxx
+
+libMEDPARTITIONERTest_la_CPPFLAGS= \
+	@CPPUNIT_INCLUDES@ \
+	$(MED2_INCLUDES) \
+	$(HDF5_INCLUDES) \
+	@CXXTMPDPTHFLAGS@ \
+	$(BOOST_CPPFLAGS) \
+	$(LIBXML_CXXFLAGS) \
+	-I$(srcdir)/.. \
+	-I$(srcdir)/../../MEDWrapper/V2_1/Core \
+	-I$(srcdir)/../../MEDMEM \
+	-I$(srcdir)/../../MEDMEMCppTest \
+	-I$(srcdir)/../../MEDCoupling \
+	-I$(srcdir)/../../MEDLoader \
+	-I$(srcdir)/../../INTERP_KERNEL/Bases \
+	-I$(srcdir)/../../INTERP_KERNEL/GaussPoints \
+	-I$(srcdir)/../../INTERP_KERNEL
+
+libMEDPARTITIONERTest_la_LDFLAGS= $(MED2_LIBS) @CPPUNIT_LIBS@
+
+if MED_ENABLE_KERNEL
+    libMEDPARTITIONERTest_la_CPPFLAGS+= ${KERNEL_CXXFLAGS}
+    libMEDPARTITIONERTest_la_LDFLAGS+= ${KERNEL_LDFLAGS} -lSALOMELocalTrace 
+endif
+
+if MED_ENABLE_PARMETIS
+  libMEDPARTITIONERTest_la_CPPFLAGS+= $(PARMETIS_CPPFLAGS)
+  libMEDPARTITIONERTest_la_LDFLAGS+= $(PARMETIS_LIBS)
+endif
+if MED_ENABLE_METIS
+  libMEDPARTITIONERTest_la_CPPFLAGS+= $(METIS_CPPFLAGS)
+  libMEDPARTITIONERTest_la_LDFLAGS+= $(METIS_LIBS)
+endif
+if MED_ENABLE_SCOTCH
+  libMEDPARTITIONERTest_la_CPPFLAGS+= $(SCOTCH_CPPFLAGS)
+  libMEDPARTITIONERTest_la_LDFLAGS+= $(SCOTCH_LIBS)
+endif
+
+# Executables targets
+bin_PROGRAMS= TestMEDPARTITIONER
+
+TestMEDPARTITIONER_SOURCES= TestMEDPARTITIONER.cxx
+
+TestMEDPARTITIONER_CPPFLAGS= $(libMEDPARTITIONERTest_la_CPPFLAGS) 
+TestMEDPARTITIONER_LDADD= \
+	$(MED2_LIBS) \
+	$(libMEDPARTITIONERTest_la_LDFLAGS) -lm \
+	libMEDPARTITIONERTest.la \
+	../../MEDWrapper/V2_1/Core/libmed_V2_1.la \
+	../../MEDMEM/libmedmem.la \
+	../../INTERP_KERNEL/libinterpkernel.la \
+	../libmedpartitioner.la
+
+if MED_ENABLE_KERNEL
+     TestMEDPARTITIONER_LDADD+= -lSALOMEBasics
+endif
+
+dist_salomescript_DATA = 
+#testMEDPARTITIONER.py
+
+UNIT_TEST_PROG = TestMEDPARTITIONER
+
+# parallel exe
+
+if MED_ENABLE_PARMETIS
+#  bin_PROGRAMS+= TestParaMEDPARTITIONER
+#  TestParaMEDPARTITIONER_SOURCES= TestParaMEDPARTITIONER.cxx
+#  TestParaMEDPARTITIONER_CPPFLAGS = $(TestMEDPARTITIONER_CPPFLAGS)
+#  TestParaMEDPARTITIONER_LDADD = $(TestMEDPARTITIONER_LDADD) $(HDF5_LIBS)
+#  dist_salomescript_DATA += testParaMEDPARTITIONER.py
+#  TESTS = TestParaMEDPARTITIONER
+endif
+
+check: tests
+
+CLEANFILES =            \
+        UnitTestsResult
diff --git a/src/MEDPartitioner/Test/TestMEDPARTITIONER.cxx b/src/MEDPartitioner/Test/TestMEDPARTITIONER.cxx
new file mode 100644
index 000000000..5598e1730
--- /dev/null
+++ b/src/MEDPartitioner/Test/TestMEDPARTITIONER.cxx
@@ -0,0 +1,30 @@
+// Copyright (C) 2007-2011  CEA/DEN, EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+// --- include all MEDMEM Test
+//
+#include "MEDPARTITIONERTest.hxx"
+
+// --- Registers the fixture into the 'registry'
+
+CPPUNIT_TEST_SUITE_REGISTRATION( MEDPARTITIONERTest );
+
+// --- generic Main program from KERNEL_SRC/src/Basics/Test
+
+#include "BasicMainTest.hxx"