src/MEDLoader/Test/MEDLoaderTest.cxx

   1 // Copyright (C) 2007-2015  CEA/DEN, EDF R&D
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Lesser General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2.1 of the License, or (at your option) any later version.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Lesser General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU Lesser General Public
  14 // License along with this library; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16 //
  17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 //
  19 // Author : Anthony Geay (CEA/DEN)
  20
  21 #include "MEDLoaderTest.hxx"
  22 #include "MEDLoader.hxx"
  23 #include "MEDLoaderBase.hxx"
  24 #include "MEDCouplingUMesh.hxx"
  25 #include "MEDCouplingFieldDouble.hxx"
  26 #include "MEDCouplingMemArray.hxx"
  27
  28 #include <cmath>
  29
  30 using namespace ParaMEDMEM;
  31
  32 void MEDLoaderTest::testMesh1DRW()
  33 {
  34   MEDCouplingUMesh *mesh=build1DMesh_1();
  35   mesh->checkCoherency();
  36   MEDLoader::WriteUMesh("file1.med",mesh,true);
  37   MEDCouplingUMesh *mesh_rw=MEDLoader::ReadUMeshFromFile("file1.med",mesh->getName().c_str(),0);
  38   CPPUNIT_ASSERT(mesh->isEqual(mesh_rw,1e-12));
  39   mesh_rw->decrRef();
  40   mesh->decrRef();
  41 }
  42
  43 void MEDLoaderTest::testMesh2DCurveRW()
  44 {
  45   MEDCouplingUMesh *mesh=build2DCurveMesh_1();
  46   mesh->checkCoherency();
  47   MEDLoader::WriteUMesh("file2.med",mesh,true);
  48   MEDCouplingUMesh *mesh_rw=MEDLoader::ReadUMeshFromFile("file2.med",mesh->getName().c_str(),0);
  49   CPPUNIT_ASSERT(mesh->isEqual(mesh_rw,1e-12));
  50   mesh_rw->decrRef();
  51   mesh->decrRef();
  52 }
  53
  54 void MEDLoaderTest::testMesh2DRW()
  55 {
  56   MEDCouplingUMesh *mesh=build2DMesh_1();
  57   mesh->checkCoherency();
  58   MEDLoader::WriteUMesh("file3.med",mesh,true);
  59   MEDCouplingUMesh *mesh_rw=MEDLoader::ReadUMeshFromFile("file3.med",mesh->getName().c_str(),0);
  60   CPPUNIT_ASSERT(mesh->isEqual(mesh_rw,1e-12));
  61   mesh_rw->decrRef();
  62   mesh->decrRef();
  63 }
  64
  65 void MEDLoaderTest::testMesh3DSurfRW()
  66 {
  67   MEDCouplingUMesh *mesh=build3DSurfMesh_1();
  68   mesh->checkCoherency();
  69   MEDLoader::WriteUMesh("file4.med",mesh,true);
  70   MEDCouplingUMesh *mesh_rw=MEDLoader::ReadUMeshFromFile("file4.med",mesh->getName().c_str(),0);
  71   CPPUNIT_ASSERT(mesh->isEqual(mesh_rw,1e-12));
  72   mesh_rw->decrRef();
  73   mesh->decrRef();
  74 }
  75
  76 void MEDLoaderTest::testMesh3DRW()
  77 {
  78   MEDCouplingUMesh *mesh=build3DMesh_1();
  79   mesh->checkCoherency();
  80   MEDLoader::WriteUMesh("file5.med",mesh,true);
  81   MEDCouplingUMesh *mesh_rw=MEDLoader::ReadUMeshFromFile("file5.med",mesh->getName().c_str(),0);
  82   CPPUNIT_ASSERT(mesh->isEqual(mesh_rw,1e-12));
  83   mesh_rw->decrRef();
  84   mesh->decrRef();
  85 }
  86
  87 /*!
  88  * Most basic test : one and only one MEDCoupling field in a new file.
  89  */
  90 void MEDLoaderTest::testFieldRW1()
  91 {
  92   MEDCouplingFieldDouble *f1=buildVecFieldOnCells_1();
  93   MEDLoader::WriteField("file6.med",f1,true);
  94   MEDCouplingFieldDouble *f2=MEDLoader::ReadFieldCell("file6.med",f1->getMesh()->getName().c_str(),0,f1->getName().c_str(),0,1);
  95   CPPUNIT_ASSERT(f1->isEqual(f2,1e-12,1e-12));
  96   f1->decrRef();
  97   f2->decrRef();
  98   //
  99   f1=buildVecFieldOnNodes_1();
 100   MEDLoader::WriteField("file7.med",f1,true);
 101   f2=MEDLoader::ReadFieldNode("file7.med",f1->getMesh()->getName().c_str(),0,f1->getName().c_str(),2,3);
 102   CPPUNIT_ASSERT(f1->isEqual(f2,1e-12,1e-12));
 103   // testing kind message on error of field type.
 104   CPPUNIT_ASSERT_THROW(MEDLoader::ReadFieldCell("file7.med",f1->getMesh()->getName().c_str(),0,f1->getName().c_str(),2,3),INTERP_KERNEL::Exception);
 105   //
 106   f1->decrRef();
 107   f2->decrRef();
 108 }
 109
 110 /*!
 111  * Multi field writing in a same file.
 112  */
 113 void MEDLoaderTest::testFieldRW2()
 114 {
 115   const char fileName[]="file8.med";
 116   static const double VAL1=12345.67890314;
 117   static const double VAL2=-1111111111111.;
 118   MEDCouplingFieldDouble *f1=buildVecFieldOnCells_1();
 119   MEDLoader::WriteField(fileName,f1,true);
 120   f1->setTime(10.,8,9);
 121   double *tmp=f1->getArray()->getPointer();
 122   tmp[0]=VAL1;
 123   MEDLoader::WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
 124   f1->setTime(10.14,18,19);
 125   tmp[0]=VAL2;
 126   MEDLoader::WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
 127   //retrieving time steps...
 128   MEDCouplingFieldDouble *f2=MEDLoader::ReadFieldCell(fileName,f1->getMesh()->getName().c_str(),0,f1->getName().c_str(),8,9);
 129   f1->setTime(10.,8,9);
 130   tmp[0]=VAL1;
 131   CPPUNIT_ASSERT(f1->isEqual(f2,1e-12,1e-12));
 132   f2->decrRef();
 133   f2=MEDLoader::ReadFieldCell(fileName,f1->getMesh()->getName().c_str(),0,f1->getName().c_str(),0,1);
 134   MEDCouplingFieldDouble *f3=buildVecFieldOnCells_1();
 135   CPPUNIT_ASSERT(f3->isEqual(f2,1e-12,1e-12));
 136   f3->decrRef();
 137   f2->decrRef();
 138   f2=MEDLoader::ReadFieldCell(fileName,f1->getMesh()->getName().c_str(),0,f1->getName().c_str(),18,19);
 139   f1->setTime(10.14,18,19);
 140   tmp[0]=VAL2;
 141   CPPUNIT_ASSERT(f1->isEqual(f2,1e-12,1e-12));
 142   //test of throw on invalid (dt,it)
 143   CPPUNIT_ASSERT_THROW(MEDLoader::ReadFieldCell(fileName,f1->getMesh()->getName().c_str(),0,f1->getName().c_str(),28,19),INTERP_KERNEL::Exception);
 144   f2->decrRef();
 145   f1->decrRef();
 146   //ON NODES
 147   f1=buildVecFieldOnNodes_1();
 148   const char fileName2[]="file9.med";
 149   MEDLoader::WriteField(fileName2,f1,true);
 150   f1->setTime(110.,108,109);
 151   tmp=f1->getArray()->getPointer();
 152   tmp[3]=VAL1;
 153   MEDLoader::WriteFieldUsingAlreadyWrittenMesh(fileName2,f1);
 154   f1->setTime(210.,208,209);
 155   tmp[3]=VAL2;
 156   MEDLoader::WriteFieldUsingAlreadyWrittenMesh(fileName2,f1);
 157   f2=MEDLoader::ReadFieldNode(fileName2,f1->getMesh()->getName().c_str(),0,f1->getName().c_str(),108,109);
 158   f1->setTime(110.,108,109);
 159   tmp[3]=VAL1;
 160   CPPUNIT_ASSERT(f1->isEqual(f2,1e-12,1e-12));
 161   f2->decrRef();
 162   f2=MEDLoader::ReadFieldNode(fileName2,f1->getMesh()->getName().c_str(),0,f1->getName().c_str(),2,3);
 163   f3=buildVecFieldOnNodes_1();
 164   CPPUNIT_ASSERT(f3->isEqual(f2,1e-12,1e-12));
 165   f3->decrRef();
 166   f2->decrRef();
 167   f2=MEDLoader::ReadFieldNode(fileName2,f1->getMesh()->getName().c_str(),0,f1->getName().c_str(),208,209);
 168   f1->setTime(210.,208,209);
 169   tmp[3]=VAL2;
 170   CPPUNIT_ASSERT(f1->isEqual(f2,1e-12,1e-12));
 171   f2->decrRef();
 172   f1->decrRef();
 173 }
 174
 175 /*!
 176  * Multi field in a same file, but this field has several
 177  */
 178 void MEDLoaderTest::testFieldRW3()
 179 {
 180   const char fileName[]="file11.med";
 181   static const double VAL1=12345.67890314;
 182   static const double VAL2=-1111111111111.;
 183   const char name1[]="AField";
 184   const char name3[]="AMesh1";
 185   MEDCouplingFieldDouble *f1=buildVecFieldOnCells_1();
 186   (const_cast<MEDCouplingMesh *>(f1->getMesh()))->setName(name3);
 187   f1->setName(name1);
 188   f1->setTime(10.,8,9);
 189   double *tmp=f1->getArray()->getPointer();
 190   tmp[0]=VAL1;
 191   MEDLoader::WriteField(fileName,f1,true);
 192   f1->setTime(10.14,18,19);
 193   tmp[0]=VAL2;
 194   MEDLoader::WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
 195   f1->setTime(10.55,28,29);
 196   tmp[0]=3*VAL1;
 197   MEDLoader::WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
 198   f1->setTime(10.66,38,39);
 199   tmp[0]=3*VAL2;
 200   MEDLoader::WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
 201   f1->setTime(10.77,48,49);
 202   tmp[0]=4*VAL2;
 203   MEDLoader::WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
 204   //ON NODES
 205   f1->decrRef();
 206   f1=buildVecFieldOnNodes_1();
 207   f1->setName(name1);
 208   (const_cast<MEDCouplingMesh *>(f1->getMesh()))->setName(name3);
 209   f1->setTime(110.,8,9);
 210   MEDLoader::WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
 211   f1->setTime(110.,108,109);
 212   tmp=f1->getArray()->getPointer();
 213   tmp[3]=VAL1;
 214   MEDLoader::WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
 215   f1->setTime(210.,208,209);
 216   tmp[3]=VAL2;
 217   MEDLoader::WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
 218   //
 219   std::vector< std::pair<int,int> > it1=MEDLoader::GetCellFieldIterations(fileName,name3,name1);
 220   CPPUNIT_ASSERT_EQUAL(5,(int)it1.size());
 221   CPPUNIT_ASSERT_EQUAL(8,it1[0].first); CPPUNIT_ASSERT_EQUAL(9,it1[0].second);
 222   CPPUNIT_ASSERT_EQUAL(18,it1[1].first); CPPUNIT_ASSERT_EQUAL(19,it1[1].second);
 223   CPPUNIT_ASSERT_EQUAL(28,it1[2].first); CPPUNIT_ASSERT_EQUAL(29,it1[2].second);
 224   CPPUNIT_ASSERT_EQUAL(38,it1[3].first); CPPUNIT_ASSERT_EQUAL(39,it1[3].second);
 225   CPPUNIT_ASSERT_EQUAL(48,it1[4].first); CPPUNIT_ASSERT_EQUAL(49,it1[4].second);
 226   std::vector< std::pair<int,int> > it3=MEDLoader::GetNodeFieldIterations(fileName,name3,name1);
 227   CPPUNIT_ASSERT_EQUAL(3,(int)it3.size());
 228   CPPUNIT_ASSERT_EQUAL(8,it3[0].first); CPPUNIT_ASSERT_EQUAL(9,it3[0].second);
 229   CPPUNIT_ASSERT_EQUAL(108,it3[1].first); CPPUNIT_ASSERT_EQUAL(109,it3[1].second);
 230   CPPUNIT_ASSERT_EQUAL(208,it3[2].first); CPPUNIT_ASSERT_EQUAL(209,it3[2].second);
 231   //
 232   f1->decrRef();
 233   //
 234   f1=MEDLoader::ReadFieldCell(fileName,name3,0,name1,8,9);
 235   CPPUNIT_ASSERT_DOUBLES_EQUAL(VAL1,f1->getArray()->getConstPointer()[0],1e-13);
 236   f1->decrRef();
 237   f1=MEDLoader::ReadFieldCell(fileName,name3,0,name1,18,19);
 238   CPPUNIT_ASSERT_DOUBLES_EQUAL(VAL2,f1->getArray()->getConstPointer()[0],1e-13);
 239   f1->decrRef();
 240   f1=MEDLoader::ReadFieldCell(fileName,name3,0,name1,28,29);
 241   CPPUNIT_ASSERT_DOUBLES_EQUAL(3*VAL1,f1->getArray()->getConstPointer()[0],1e-13);
 242   f1->decrRef();
 243   f1=MEDLoader::ReadFieldCell(fileName,name3,0,name1,38,39);
 244   CPPUNIT_ASSERT_DOUBLES_EQUAL(3*VAL2,f1->getArray()->getConstPointer()[0],1e-13);
 245   f1->decrRef();
 246   f1=MEDLoader::ReadFieldCell(fileName,name3,0,name1,48,49);
 247   CPPUNIT_ASSERT_DOUBLES_EQUAL(4*VAL2,f1->getArray()->getConstPointer()[0],1e-13);
 248   f1->decrRef();
 249   //
 250   f1=MEDLoader::ReadFieldNode(fileName,name3,0,name1,8,9);
 251   CPPUNIT_ASSERT_DOUBLES_EQUAL(71.,f1->getArray()->getConstPointer()[3],1e-13);
 252   f1->decrRef();
 253   f1=MEDLoader::ReadFieldNode(fileName,name3,0,name1,108,109);
 254   CPPUNIT_ASSERT_DOUBLES_EQUAL(VAL1,f1->getArray()->getConstPointer()[3],1e-13);
 255   f1->decrRef();
 256   f1=MEDLoader::ReadFieldNode(fileName,name3,0,name1,208,209);
 257   CPPUNIT_ASSERT_DOUBLES_EQUAL(VAL2,f1->getArray()->getConstPointer()[3],1e-13);
 258   f1->decrRef();
 259 }
 260
 261 void MEDLoaderTest::testMultiMeshRW1()
 262 {
 263   const char fileName[]="file10.med";
 264   MEDCouplingUMesh *mesh1=build3DMesh_1();
 265   const int part1[5]={1,2,4,13,15};
 266   MEDCouplingUMesh *mesh2=(MEDCouplingUMesh *)mesh1->buildPartOfMySelf(part1,part1+5,true);
 267   mesh2->setName("mesh2");
 268   const int part2[4]={3,4,13,14};
 269   MEDCouplingUMesh *mesh3=(MEDCouplingUMesh *)mesh1->buildPartOfMySelf(part2,part2+4,true);
 270   mesh3->setName("mesh3");
 271   MEDCouplingUMesh *mesh4=MEDCouplingUMesh::New();
 272   mesh4->setName("mesh4");
 273   mesh4->setMeshDimension(3);
 274   mesh4->allocateCells(1);
 275   int conn[4]={0,11,1,3};
 276   mesh4->insertNextCell(INTERP_KERNEL::NORM_TETRA4,4,conn);
 277   mesh4->finishInsertingCells();
 278   mesh4->setCoords(mesh1->getCoords());
 279   std::vector<const MEDCouplingUMesh *> meshes;
 280   meshes.push_back(mesh1);
 281   meshes.push_back(mesh2);
 282   meshes.push_back(mesh3);
 283   meshes.push_back(mesh4);
 284   const char mnane[]="3DToto";
 285   MEDLoader::WriteUMeshesPartition(fileName,mnane,meshes,true);
 286   //
 287   MEDCouplingUMesh *mesh5=MEDLoader::ReadUMeshFromFile(fileName,mnane);
 288   mesh1->setName(mnane);
 289   const int part3[18]={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17};
 290   MEDCouplingUMesh *mesh6=(MEDCouplingUMesh *)mesh5->buildPartOfMySelf(part3,part3+18,true);
 291   mesh6->setName(mnane);
 292   mesh5->decrRef();
 293   CPPUNIT_ASSERT(mesh6->isEqual(mesh1,1e-12));
 294   mesh6->decrRef();
 295   std::vector<std::string> grps=MEDLoader::GetMeshGroupsNames(fileName,mnane);
 296   CPPUNIT_ASSERT_EQUAL(4,(int)grps.size());
 297   CPPUNIT_ASSERT(std::find(grps.begin(),grps.end(),std::string("mesh2"))!=grps.end());
 298   CPPUNIT_ASSERT(std::find(grps.begin(),grps.end(),std::string("mesh3"))!=grps.end());
 299   CPPUNIT_ASSERT(std::find(grps.begin(),grps.end(),std::string("mesh4"))!=grps.end());
 300   CPPUNIT_ASSERT(std::find(grps.begin(),grps.end(),std::string("3DMesh_1"))!=grps.end());
 301   //
 302   std::vector<std::string> vec;
 303   vec.push_back(std::string("mesh2"));
 304   MEDCouplingUMesh *mesh2_2=MEDLoader::ReadUMeshFromGroups(fileName,mnane,0,vec);
 305   CPPUNIT_ASSERT(mesh2_2->isEqual(mesh2,1e-12));
 306   mesh2_2->decrRef();
 307   vec.clear(); vec.push_back(std::string("mesh3"));
 308   MEDCouplingUMesh *mesh3_2=MEDLoader::ReadUMeshFromGroups(fileName,mnane,0,vec);
 309   CPPUNIT_ASSERT(mesh3_2->isEqual(mesh3,1e-12));
 310   mesh3_2->decrRef();
 311   vec.clear(); vec.push_back(std::string("mesh4"));
 312   MEDCouplingUMesh *mesh4_2=MEDLoader::ReadUMeshFromGroups(fileName,mnane,0,vec);
 313   CPPUNIT_ASSERT(mesh4_2->isEqual(mesh4,1e-12));
 314   mesh4_2->decrRef();
 315   vec.clear(); vec.push_back(std::string("3DMesh_1"));
 316   MEDCouplingUMesh *mesh1_2=MEDLoader::ReadUMeshFromGroups(fileName,mnane,0,vec);
 317   mesh1->setName("3DMesh_1");
 318   CPPUNIT_ASSERT(mesh1_2->isEqual(mesh1,1e-12));
 319   mesh1_2->decrRef();
 320   //
 321   vec.clear(); vec.push_back(std::string("Family_-3")); vec.push_back(std::string("Family_-5"));
 322   mesh2_2=MEDLoader::ReadUMeshFromFamilies(fileName,mnane,0,vec);
 323   mesh2_2->setName("mesh2");
 324   CPPUNIT_ASSERT(mesh2_2->isEqual(mesh2,1e-12));
 325   mesh2_2->decrRef();
 326   //
 327   std::vector<std::string> ret=MEDLoader::GetMeshFamiliesNamesOnGroup(fileName,"3DToto","3DMesh_1");
 328   CPPUNIT_ASSERT_EQUAL(4,(int)ret.size());
 329   CPPUNIT_ASSERT(ret[0]=="Family_-2");
 330   CPPUNIT_ASSERT(ret[1]=="Family_-3");
 331   CPPUNIT_ASSERT(ret[2]=="Family_-4");
 332   CPPUNIT_ASSERT(ret[3]=="Family_-5");
 333   //
 334   std::vector<std::string> ret1=MEDLoader::GetMeshGroupsNamesOnFamily(fileName,"3DToto","Family_-3");
 335   CPPUNIT_ASSERT_EQUAL(2,(int)ret1.size());
 336   CPPUNIT_ASSERT(ret1[0]=="3DMesh_1");
 337   CPPUNIT_ASSERT(ret1[1]=="mesh2");
 338   //
 339   mesh4->decrRef();
 340   mesh3->decrRef();
 341   mesh2->decrRef();
 342   mesh1->decrRef();
 343 }
 344
 345 void MEDLoaderTest::testFieldProfilRW1()
 346 {
 347   const char fileName[]="file12.med";
 348   MEDCouplingUMesh *mesh1=build3DMesh_1();
 349   bool b;
 350   int newNbOfNodes;
 351   DataArrayInt *da=mesh1->mergeNodes(1e-12,b,newNbOfNodes);
 352   da->decrRef();
 353   MEDLoader::WriteUMesh(fileName,mesh1,true);
 354   const int part1[5]={1,2,4,13,15};
 355   MEDCouplingUMesh *mesh2=(MEDCouplingUMesh *)mesh1->buildPartOfMySelf(part1,part1+5,true);
 356   mesh2->setName(mesh1->getName().c_str());//<- important for the test
 357   //
 358   int nbOfCells=mesh2->getNumberOfCells();
 359   CPPUNIT_ASSERT_EQUAL(5,nbOfCells);
 360   MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
 361   f1->setName("VectorFieldOnCells");
 362   f1->setMesh(mesh2);
 363   DataArrayDouble *array=DataArrayDouble::New();
 364   array->alloc(nbOfCells,2);
 365   f1->setArray(array);
 366   array->decrRef();
 367   double *tmp=array->getPointer();
 368   const double arr1[10]={71.,171.,10.,110.,20.,120.,30.,130.,40.,140.};
 369   std::copy(arr1,arr1+10,tmp);
 370   f1->setTime(3.14,2,7);
 371   f1->checkCoherency();
 372   //
 373   MEDLoader::WriteField(fileName,f1,false);//<- false important for the test
 374   //
 375   MEDCouplingFieldDouble *f2=MEDLoader::ReadFieldCell(fileName,f1->getMesh()->getName().c_str(),0,f1->getName().c_str(),2,7);
 376   std::vector<ParaMEDMEM::TypeOfField> types=MEDLoader::GetTypesOfField(fileName,f1->getMesh()->getName().c_str(),f1->getName().c_str());
 377   CPPUNIT_ASSERT_EQUAL(1,(int)types.size());
 378   CPPUNIT_ASSERT(types[0]==ON_CELLS);
 379   f2->checkCoherency();
 380   CPPUNIT_ASSERT(f1->isEqual(f2,1e-12,1e-12));
 381   //
 382   f2->decrRef();
 383   f1->decrRef();
 384   mesh1->decrRef();
 385   mesh2->decrRef();
 386 }
 387
 388 /*!
 389  * Test MED file profiles.
 390  */
 391 void MEDLoaderTest::testFieldNodeProfilRW1()
 392 {
 393   const char fileName[]="file19.med";
 394   const char fileName2[]="file20.med";
 395   MEDCouplingUMesh *m=build2DMesh_1();
 396   int nbOfNodes=m->getNumberOfNodes();
 397   MEDLoader::WriteUMesh(fileName,m,true);
 398   MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_NODES,ONE_TIME);
 399   f1->setName("VFieldOnNodes");
 400   f1->setMesh(m);
 401   DataArrayDouble *array=DataArrayDouble::New();
 402   const double arr1[24]={1.,101.,2.,102.,3.,103.,4.,104.,5.,105.,6.,106.,7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.};
 403   array->alloc(nbOfNodes,2);
 404   std::copy(arr1,arr1+24,array->getPointer());
 405   f1->setArray(array);
 406   array->setInfoOnComponent(0,"tyty [mm]");
 407   array->setInfoOnComponent(1,"uiop [MW]");
 408   array->decrRef();
 409   f1->setTime(3.14,2,7);
 410   f1->checkCoherency();
 411   const int arr2[2]={1,4};//node ids are 2,4,5,3,6,7
 412   MEDCouplingFieldDouble *f2=f1->buildSubPart(arr2,arr2+2);
 413   (const_cast<MEDCouplingMesh *>(f2->getMesh()))->setName(f1->getMesh()->getName().c_str());
 414   MEDLoader::WriteField(fileName,f2,false);//<- false important for the test
 415   //
 416   MEDCouplingFieldDouble *f3=MEDLoader::ReadFieldNode(fileName,f2->getMesh()->getName().c_str(),0,f2->getName().c_str(),2,7);
 417   f3->checkCoherency();
 418   CPPUNIT_ASSERT(f3->isEqual(f2,1e-12,1e-12));
 419   f3->decrRef();
 420   //
 421   const int arr3[6]={1,3,0,5,2,4};
 422   f2->renumberNodes(arr3);
 423   MEDLoader::WriteUMesh(fileName2,m,true);
 424   MEDLoader::WriteField(fileName2,f2,false);//<- false important for the test
 425   f3=MEDLoader::ReadFieldNode(fileName2,f2->getMesh()->getName().c_str(),0,f2->getName().c_str(),2,7);
 426   f3->checkCoherency();
 427   CPPUNIT_ASSERT(f3->isEqual(f2,1e-12,1e-12));
 428   f3->decrRef();
 429   f2->decrRef();
 430   //
 431   f1->decrRef();
 432   m->decrRef();
 433 }
 434
 435 void MEDLoaderTest::testFieldNodeProfilRW2()
 436 {
 437   const char fileName[]="file23.med";
 438   MEDCouplingUMesh *mesh=build3DSurfMesh_1();
 439   MEDLoader::WriteUMesh(fileName,mesh,true);
 440   //
 441   MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_NODES,ONE_TIME);
 442   f1->setName("FieldMix");
 443   f1->setMesh(mesh);
 444   const double arr2[24]={
 445     1071.,1171.,1010.,1110.,1020.,1120.,1030.,1130.,1040.,1140.,1050.,1150.,
 446     1060.,1160.,1070.,1170.,1080.,1180.,1090.,1190.,1091.,1191.,1092.,1192.
 447   };
 448   DataArrayDouble *array=DataArrayDouble::New();
 449   array->alloc(12,2);
 450   f1->setArray(array);
 451   array->setInfoOnComponent(0,"plkj [mm]");
 452   array->setInfoOnComponent(1,"pqqqss [mm]");
 453   array->decrRef();
 454   double *tmp=array->getPointer();
 455   std::copy(arr2,arr2+24,tmp);
 456   f1->setTime(3.17,2,7);
 457   //
 458   const int renumArr[12]={3,7,2,1,5,11,10,0,9,6,8,4};
 459   f1->renumberNodes(renumArr);
 460   f1->checkCoherency();
 461   MEDLoader::WriteField(fileName,f1,false);//<- false important for the test
 462   MEDCouplingFieldDouble *f2=MEDLoader::ReadFieldNode(fileName,f1->getMesh()->getName().c_str(),0,f1->getName().c_str(),2,7);
 463   CPPUNIT_ASSERT(f2->isEqual(f1,1e-12,1e-12));
 464   //
 465   f2->decrRef();
 466   mesh->decrRef();
 467   f1->decrRef();
 468 }
 469
 470 void MEDLoaderTest::testFieldGaussRW1()
 471 {
 472   const char fileName[]="file13.med";
 473   MEDCouplingFieldDouble *f1=buildVecFieldOnGauss_1();
 474   MEDLoader::WriteField(fileName,f1,true);
 475   MEDCouplingFieldDouble *f2=MEDLoader::ReadField(ON_GAUSS_PT,fileName,f1->getMesh()->getName().c_str(),0,f1->getName().c_str(),1,5);
 476   CPPUNIT_ASSERT(f1->isEqual(f2,1e-12,1e-12));
 477   f2->decrRef();
 478   f1->decrRef();
 479 }
 480
 481 void MEDLoaderTest::testFieldGaussNERW1()
 482 {
 483   const char fileName[]="file14.med";
 484   MEDCouplingFieldDouble *f1=buildVecFieldOnGaussNE_1();
 485   MEDLoader::WriteField(fileName,f1,true);
 486   std::vector<ParaMEDMEM::TypeOfField> tof(MEDLoader::GetTypesOfField(fileName,"2DMesh_2","MyFieldOnGaussNE"));
 487   CPPUNIT_ASSERT_EQUAL(1,(int)tof.size());
 488   CPPUNIT_ASSERT(ON_GAUSS_NE==tof[0]);
 489   MEDCouplingFieldDouble *f2=MEDLoader::ReadField(ON_GAUSS_NE,fileName,f1->getMesh()->getName().c_str(),0,f1->getName().c_str(),1,5);
 490   CPPUNIT_ASSERT(f1->isEqual(f2,1e-12,1e-12));
 491   f2->decrRef();
 492   f1->decrRef();
 493 }
 494
 495 void MEDLoaderTest::testLittleStrings1()
 496 {
 497   std::string s("azeeeerrrtty");
 498   MEDLoaderBase::zipEqualConsChar(s,3);
 499   CPPUNIT_ASSERT(s=="azertty");
 500 }
 501
 502 void MEDLoaderTest::testSplitIntoNameAndUnit1()
 503 {
 504   std::string s(" []");
 505   std::string c,u;
 506   MEDLoaderBase::splitIntoNameAndUnit(s,c,u);
 507   CPPUNIT_ASSERT(c.empty());
 508   CPPUNIT_ASSERT(u.empty());
 509   s="   lmmm  kki jjj      ";
 510   MEDLoaderBase::strip(s);
 511   CPPUNIT_ASSERT(s=="lmmm  kki jjj");
 512   s=" ";
 513   MEDLoaderBase::strip(s);
 514   CPPUNIT_ASSERT(s.empty());
 515   s="";
 516   MEDLoaderBase::strip(s);
 517   CPPUNIT_ASSERT(s.empty());
 518   s="      ";
 519   MEDLoaderBase::strip(s);
 520   CPPUNIT_ASSERT(s.empty());
 521   s="     pp";
 522   MEDLoaderBase::strip(s);
 523   CPPUNIT_ASSERT(s=="pp");
 524 }
 525
 526 void MEDLoaderTest::testMesh3DSurfShuffleRW()
 527 {
 528   const char fileName[]="file15.med";
 529   MEDCouplingUMesh *mesh=build3DSurfMesh_1();
 530   const int renumber1[6]={2,5,1,0,3,4};
 531   mesh->renumberCells(renumber1,false);
 532   mesh->checkCoherency();
 533   MEDLoader::WriteUMesh(fileName,mesh,true);
 534   MEDCouplingUMesh *mesh_rw=MEDLoader::ReadUMeshFromFile(fileName,mesh->getName().c_str(),0);
 535   CPPUNIT_ASSERT(mesh->isEqual(mesh_rw,1e-12));
 536   mesh_rw->decrRef();
 537   mesh->decrRef();
 538 }
 539
 540 void MEDLoaderTest::testFieldShuffleRW1()
 541 {
 542   const char fileName[]="file16.med";
 543   MEDCouplingUMesh *mesh=build3DSurfMesh_1();
 544   MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
 545   f1->setName("FieldOnCellsShuffle");
 546   f1->setMesh(mesh);
 547   DataArrayDouble *array=DataArrayDouble::New();
 548   array->alloc(6,2);
 549   f1->setArray(array);
 550   array->decrRef();
 551   double *tmp=array->getPointer();
 552   const double arr1[12]={71.,171.,10.,110.,20.,120.,30.,130.,40.,140.,50.,150.};
 553   std::copy(arr1,arr1+12,tmp);
 554   f1->setTime(3.14,2,7);
 555   f1->checkCoherency();
 556   //
 557   const int renumber1[6]={2,1,5,0,3,4};
 558   f1->renumberCells(renumber1,false);
 559   MEDLoader::WriteField(fileName,f1,true);
 560   MEDCouplingFieldDouble *f2=MEDLoader::ReadFieldCell(fileName,mesh->getName().c_str(),0,f1->getName().c_str(),2,7);
 561   CPPUNIT_ASSERT(f2->isEqual(f1,1e-12,1e-12));
 562   f2->decrRef();
 563   //
 564   mesh->decrRef();
 565   f1->decrRef();
 566 }
 567
 568 /*!
 569  * Shuffle de cells but no profile. Like pointe.med
 570  */
 571 void MEDLoaderTest::testMultiFieldShuffleRW1()
 572 {
 573   const char fileName[]="file17.med";
 574   MEDCouplingUMesh *m=build3DMesh_2();
 575   CPPUNIT_ASSERT_EQUAL(20,m->getNumberOfCells());
 576   CPPUNIT_ASSERT_EQUAL(45,m->getNumberOfNodes());
 577   const int polys[3]={1,4,6};
 578   std::vector<int> poly2(polys,polys+3);
 579   m->convertToPolyTypes(&poly2[0],&poly2[0]+poly2.size());
 580   const int renum[20]={1,3,2,8,9,12,13,16,19,0,4,7,5,15,14,17,10,18,6,11};
 581   m->renumberCells(renum,false);
 582   m->orientCorrectlyPolyhedrons();
 583   // Writing
 584   MEDLoader::WriteUMesh(fileName,m,true);
 585   MEDCouplingFieldDouble *f1Tmp=m->getMeasureField(false);
 586   MEDCouplingFieldDouble *f1=f1Tmp->buildNewTimeReprFromThis(ONE_TIME,false);
 587   f1Tmp->decrRef();
 588   f1->setTime(0.,1,2);
 589   MEDCouplingFieldDouble *f_1=f1->cloneWithMesh(true);
 590   MEDLoader::WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
 591   f1->applyFunc("2*x");
 592   f1->setTime(0.01,3,4);
 593   MEDCouplingFieldDouble *f_2=f1->cloneWithMesh(true);
 594   MEDLoader::WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
 595   f1->applyFunc("2*x/3");
 596   f1->setTime(0.02,5,6);
 597   MEDCouplingFieldDouble *f_3=f1->cloneWithMesh(true);
 598   MEDLoader::WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
 599   f1->decrRef();
 600   // Reading
 601   std::vector<std::pair<int,int> > its;
 602   its.push_back(std::pair<int,int>(1,2));
 603   its.push_back(std::pair<int,int>(3,4));
 604   its.push_back(std::pair<int,int>(5,6));
 605   std::vector<MEDCouplingFieldDouble *> fs=MEDLoader::ReadFieldsOnSameMesh(ON_CELLS,fileName,f_1->getMesh()->getName().c_str(),0,f_1->getName().c_str(),its);
 606   CPPUNIT_ASSERT_EQUAL(3,(int)fs.size());
 607   const MEDCouplingMesh *mm=fs[0]->getMesh();
 608   CPPUNIT_ASSERT(fs[0]->isEqual(f_1,1e-12,1e-12));
 609   CPPUNIT_ASSERT(fs[1]->isEqual(f_2,1e-12,1e-12));
 610   CPPUNIT_ASSERT(fs[2]->isEqual(f_3,1e-12,1e-12));
 611   CPPUNIT_ASSERT(mm==fs[1]->getMesh());// <- important for the test
 612   CPPUNIT_ASSERT(mm==fs[2]->getMesh());// <- important for the test
 613   for(std::vector<MEDCouplingFieldDouble *>::iterator iter=fs.begin();iter!=fs.end();iter++)
 614     (*iter)->decrRef();
 615   //
 616   f_1->decrRef();
 617   f_2->decrRef();
 618   f_3->decrRef();
 619   //
 620   m->decrRef();
 621 }
 622
 623 void MEDLoaderTest::testWriteUMeshesRW1()
 624 {
 625   const char fileName[]="file18.med";
 626   MEDCouplingUMesh *m3d=build3DMesh_2();
 627   const double pt[3]={0.,0.,-0.3};
 628   const double vec[3]={0.,0.,1.};
 629   std::vector<int> nodes;
 630   m3d->findNodesOnPlane(pt,vec,1e-12,nodes);
 631   MEDCouplingUMesh *m2d=(MEDCouplingUMesh *)m3d->buildFacePartOfMySelfNode(&nodes[0],&nodes[0]+nodes.size(),true);
 632   const int renumber[5]={1,2,0,4,3};
 633   m2d->renumberCells(renumber,false);
 634   m2d->setName("ExampleOfMultiDimW");
 635   std::vector<const MEDCouplingUMesh *> meshes;
 636   meshes.push_back(m2d);
 637   meshes.push_back(m3d);
 638   MEDLoader::WriteUMeshes(fileName,meshes,true);
 639   MEDCouplingUMesh *m3d_bis=MEDLoader::ReadUMeshFromFile(fileName,m2d->getName().c_str(),0);
 640   CPPUNIT_ASSERT(!m3d_bis->isEqual(m3d,1e-12));
 641   m3d_bis->setName(m3d->getName().c_str());
 642   CPPUNIT_ASSERT(m3d_bis->isEqual(m3d,1e-12));
 643   MEDCouplingUMesh *m2d_bis=MEDLoader::ReadUMeshFromFile(fileName,m2d->getName().c_str(),-1);//-1 for faces
 644   CPPUNIT_ASSERT(m2d_bis->isEqual(m2d,1e-12));
 645   // Creation of a field on faces.
 646   MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
 647   f1->setName("FieldOnFacesShuffle");
 648   f1->setMesh(m2d);
 649   DataArrayDouble *array=DataArrayDouble::New();
 650   array->alloc(m2d->getNumberOfCells(),2);
 651   array->setInfoOnComponent(0,"plkj [mm]");
 652   array->setInfoOnComponent(1,"pqqqss [mm]");
 653   f1->setArray(array);
 654   array->decrRef();
 655   double *tmp=array->getPointer();
 656   const double arr1[10]={71.,171.,10.,110.,20.,120.,30.,130.,40.,140.};
 657   std::copy(arr1,arr1+10,tmp);
 658   f1->setTime(3.14,2,7);
 659   f1->checkCoherency();
 660   MEDLoader::WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
 661   MEDCouplingFieldDouble *f2=MEDLoader::ReadFieldCell(fileName,f1->getMesh()->getName().c_str(),-1,f1->getName().c_str(),2,7);
 662   CPPUNIT_ASSERT(f2->isEqual(f1,1e-12,1e-12));
 663   f1->decrRef();
 664   f2->decrRef();
 665   //
 666   m2d_bis->decrRef();
 667   m3d_bis->decrRef();
 668   m2d->decrRef();
 669   m3d->decrRef();
 670 }
 671
 672 void MEDLoaderTest::testMixCellAndNodesFieldRW1()
 673 {
 674   const char fileName[]="file21.med";
 675   MEDCouplingUMesh *mesh=build3DSurfMesh_1();
 676   MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
 677   f1->setName("FieldMix");
 678   f1->setMesh(mesh);
 679   DataArrayDouble *array=DataArrayDouble::New();
 680   array->alloc(6,2);
 681   f1->setArray(array);
 682   array->setInfoOnComponent(0,"plkj [mm]");
 683   array->setInfoOnComponent(1,"pqqqss [mm]");
 684   array->decrRef();
 685   double *tmp=array->getPointer();
 686   const double arr1[12]={71.,171.,10.,110.,20.,120.,30.,130.,40.,140.,50.,150.};
 687   std::copy(arr1,arr1+12,tmp);
 688   f1->setTime(3.14,2,7);
 689   f1->checkCoherency();
 690   //
 691   MEDCouplingFieldDouble *f2=MEDCouplingFieldDouble::New(ON_NODES,ONE_TIME);
 692   f2->setName("FieldMix");
 693   f2->setMesh(mesh);
 694   array=DataArrayDouble::New();
 695   array->alloc(12,2);
 696   f2->setArray(array);
 697   array->setInfoOnComponent(0,"plkj [mm]");
 698   array->setInfoOnComponent(1,"pqqqss [mm]");
 699   array->decrRef();
 700   tmp=array->getPointer();
 701   const double arr2[24]={
 702     1071.,1171.,1010.,1110.,1020.,1120.,1030.,1130.,1040.,1140.,1050.,1150.,
 703     1060.,1160.,1070.,1170.,1080.,1180.,1090.,1190.,1091.,1191.,1092.,1192.
 704   };
 705   std::copy(arr2,arr2+24,tmp);
 706   f2->setTime(3.14,2,7);
 707   f2->checkCoherency();
 708   //
 709   MEDLoader::WriteField(fileName,f1,true);
 710   std::vector<ParaMEDMEM::TypeOfField> ts=MEDLoader::GetTypesOfField(fileName,f1->getMesh()->getName().c_str(),f1->getName().c_str());
 711   CPPUNIT_ASSERT_EQUAL(1,(int)ts.size());
 712   CPPUNIT_ASSERT_EQUAL(ON_CELLS,ts[0]);
 713   std::vector<std::string> fs=MEDLoader::GetAllFieldNamesOnMesh(fileName,f1->getMesh()->getName().c_str());
 714   CPPUNIT_ASSERT_EQUAL(1,(int)fs.size());
 715   CPPUNIT_ASSERT(fs[0]=="FieldMix");
 716   MEDLoader::WriteFieldUsingAlreadyWrittenMesh(fileName,f2);
 717   fs=MEDLoader::GetAllFieldNamesOnMesh(fileName,f1->getMesh()->getName().c_str());
 718   CPPUNIT_ASSERT_EQUAL(1,(int)fs.size());
 719   CPPUNIT_ASSERT(fs[0]=="FieldMix");
 720   //
 721   ts=MEDLoader::GetTypesOfField(fileName,f1->getMesh()->getName().c_str(),f1->getName().c_str());
 722   CPPUNIT_ASSERT_EQUAL(2,(int)ts.size());
 723   CPPUNIT_ASSERT_EQUAL(ON_NODES,ts[0]);
 724   CPPUNIT_ASSERT_EQUAL(ON_CELLS,ts[1]);
 725   //
 726   MEDCouplingFieldDouble *f3=MEDLoader::ReadFieldNode(fileName,f1->getMesh()->getName().c_str(),0,f1->getName().c_str(),2,7);
 727   CPPUNIT_ASSERT(f3->isEqual(f2,1e-12,1e-12));
 728   f3->decrRef();
 729   f3=MEDLoader::ReadFieldCell(fileName,f1->getMesh()->getName().c_str(),0,f1->getName().c_str(),2,7);
 730   CPPUNIT_ASSERT(f3->isEqual(f1,1e-12,1e-12));
 731   f3->decrRef();
 732   //
 733   f1->decrRef();
 734   f2->decrRef();
 735   mesh->decrRef();
 736 }
 737
 738 void MEDLoaderTest::testGetAllFieldNamesRW1()
 739 {
 740   const char fileName[]="file22.med";
 741   MEDCouplingUMesh *mesh=build2DMesh_2();
 742   MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_NODES,ONE_TIME);
 743   f1->setName("Field1");
 744   f1->setTime(3.44,5,6);
 745   f1->setMesh(mesh);
 746   f1->fillFromAnalytic(2,"x+y");
 747   MEDLoader::WriteField(fileName,f1,true);
 748   f1->setTime(1002.3,7,8);
 749   f1->fillFromAnalytic(2,"x+77.*y");
 750   MEDLoader::WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
 751   f1->setName("Field2");
 752   MEDLoader::WriteField(fileName,f1,false);
 753   f1->setName("Field3");
 754   mesh->setName("2DMesh_2Bis");
 755   MEDLoader::WriteField(fileName,f1,false);
 756   f1->decrRef();
 757   f1=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
 758   f1->setName("Field8");
 759   f1->setTime(8.99,7,9);
 760   f1->setMesh(mesh);
 761   f1->fillFromAnalytic(3,"3*x+y");
 762   MEDLoader::WriteField(fileName,f1,false);
 763   f1->decrRef();
 764   std::vector<std::string> fs=MEDLoader::GetAllFieldNames(fileName);
 765   CPPUNIT_ASSERT_EQUAL(4,(int)fs.size());
 766   CPPUNIT_ASSERT(fs[0]=="Field1");
 767   CPPUNIT_ASSERT(fs[1]=="Field2");
 768   CPPUNIT_ASSERT(fs[2]=="Field3");
 769   CPPUNIT_ASSERT(fs[3]=="Field8");
 770   mesh->decrRef();
 771 }
 772
 773 MEDCouplingUMesh *MEDLoaderTest::build1DMesh_1()
 774 {
 775   double coords[6]={ 0.0, 0.3, 0.75, 1.0, 1.4, 1.3 };
 776   int conn[9]={ 0,1, 1,2, 2,3 , 3,4,5};
 777   MEDCouplingUMesh *mesh=MEDCouplingUMesh::New();
 778   mesh->setName("1DMesh_1");
 779   mesh->setMeshDimension(1);
 780   mesh->allocateCells(4);
 781   mesh->insertNextCell(INTERP_KERNEL::NORM_SEG2,2,conn);
 782   mesh->insertNextCell(INTERP_KERNEL::NORM_SEG2,2,conn+2);
 783   mesh->insertNextCell(INTERP_KERNEL::NORM_SEG2,2,conn+4);
 784   mesh->insertNextCell(INTERP_KERNEL::NORM_SEG3,3,conn+6);
 785   mesh->finishInsertingCells();
 786   DataArrayDouble *myCoords=DataArrayDouble::New();
 787   myCoords->alloc(6,1);
 788   myCoords->setInfoOnComponent(0,"tototototototot [m*m*m*m*m*m*m*m]");
 789   std::copy(coords,coords+6,myCoords->getPointer());
 790   mesh->setCoords(myCoords);
 791   myCoords->decrRef();
 792   return mesh;
 793 }
 794
 795 MEDCouplingUMesh *MEDLoaderTest::build2DCurveMesh_1()
 796 {
 797   double coords[12]={ 0.0,0.0, 0.3,0.3, 0.75,0.75, 1.0,1.0, 1.4,1.4, 1.3,1.3 };
 798   int conn[9]={ 0,1, 1,2, 2,3 , 3,4,5};
 799   MEDCouplingUMesh *mesh=MEDCouplingUMesh::New();
 800   mesh->setName("2DCurveMesh_1");
 801   mesh->setMeshDimension(1);
 802   mesh->allocateCells(4);
 803   mesh->insertNextCell(INTERP_KERNEL::NORM_SEG2,2,conn);
 804   mesh->insertNextCell(INTERP_KERNEL::NORM_SEG2,2,conn+2);
 805   mesh->insertNextCell(INTERP_KERNEL::NORM_SEG2,2,conn+4);
 806   mesh->insertNextCell(INTERP_KERNEL::NORM_SEG3,3,conn+6);
 807   mesh->finishInsertingCells();
 808   DataArrayDouble *myCoords=DataArrayDouble::New();
 809   myCoords->alloc(6,2);
 810   std::copy(coords,coords+12,myCoords->getPointer());
 811   mesh->setCoords(myCoords);
 812   myCoords->decrRef();
 813   return mesh;
 814 }
 815
 816 MEDCouplingUMesh *MEDLoaderTest::build2DMesh_1()
 817 {
 818   double targetCoords[24]={-0.3,-0.3, 0.2,-0.3, 0.7,-0.3, -0.3,0.2, 0.2,0.2, 0.7,0.2, -0.3,0.7, 0.2,0.7, 0.7,0.7, -0.05,0.95, 0.2,1.2, 0.45,0.95 };
 819   int targetConn[24]={1,4,2, 4,5,2, 6,10,8,9,11,7, 0,3,4,1, 6,7,4,3, 7,8,5,4};
 820   MEDCouplingUMesh *targetMesh=MEDCouplingUMesh::New();
 821   targetMesh->setMeshDimension(2);
 822   targetMesh->allocateCells(6);
 823   targetMesh->setName("2DMesh_1");
 824   targetMesh->insertNextCell(INTERP_KERNEL::NORM_TRI3,3,targetConn);
 825   targetMesh->insertNextCell(INTERP_KERNEL::NORM_TRI3,3,targetConn+3);
 826   targetMesh->insertNextCell(INTERP_KERNEL::NORM_TRI6,6,targetConn+6);
 827   targetMesh->insertNextCell(INTERP_KERNEL::NORM_QUAD4,4,targetConn+12);
 828   targetMesh->insertNextCell(INTERP_KERNEL::NORM_QUAD4,4,targetConn+16);
 829   targetMesh->insertNextCell(INTERP_KERNEL::NORM_POLYGON,4,targetConn+20);
 830   targetMesh->finishInsertingCells();
 831   DataArrayDouble *myCoords=DataArrayDouble::New();
 832   myCoords->alloc(12,2);
 833   myCoords->setInfoOnComponent(0,"tototototototot [m]");
 834   myCoords->setInfoOnComponent(1,"energie [kW]");
 835   std::copy(targetCoords,targetCoords+24,myCoords->getPointer());
 836   targetMesh->setCoords(myCoords);
 837   myCoords->decrRef();
 838   return targetMesh;
 839 }
 840
 841 MEDCouplingUMesh *MEDLoaderTest::build2DMesh_2()
 842 {
 843   double targetCoords[24]={
 844     -0.3,-0.3, 0.2,-0.3, 0.7,-0.3, -0.3,0.2, 0.2,0.2, 0.7,0.2, -0.3,0.7, 0.2,0.7, 0.7,0.7,
 845     -0.05,0.95, 0.2,1.2, 0.45,0.95
 846   };
 847   int targetConn[24]={1,4,2, 4,5,2, 6,10,8,9,11,7, 0,3,4,1, 6,7,4,3, 7,8,5,4};
 848   MEDCouplingUMesh *targetMesh=MEDCouplingUMesh::New();
 849   targetMesh->setMeshDimension(2);
 850   targetMesh->allocateCells(5);
 851   targetMesh->setName("2DMesh_2");
 852   targetMesh->insertNextCell(INTERP_KERNEL::NORM_TRI3,3,targetConn);
 853   targetMesh->insertNextCell(INTERP_KERNEL::NORM_TRI3,3,targetConn+3);
 854   targetMesh->insertNextCell(INTERP_KERNEL::NORM_QUAD4,4,targetConn+12);
 855   targetMesh->insertNextCell(INTERP_KERNEL::NORM_QUAD4,4,targetConn+16);
 856   targetMesh->insertNextCell(INTERP_KERNEL::NORM_TRI6,6,targetConn+6);
 857   targetMesh->finishInsertingCells();
 858   DataArrayDouble *myCoords=DataArrayDouble::New();
 859   myCoords->alloc(12,2);
 860   myCoords->setInfoOnComponent(0,"toto [m]");
 861   myCoords->setInfoOnComponent(1,"energie [kW]");
 862   std::copy(targetCoords,targetCoords+24,myCoords->getPointer());
 863   targetMesh->setCoords(myCoords);
 864   myCoords->decrRef();
 865   return targetMesh;
 866 }
 867
 868 MEDCouplingUMesh *MEDLoaderTest::build3DSurfMesh_1()
 869 {
 870   double targetCoords[36]={
 871     -0.3,-0.3,-0.3, 0.2,-0.3,-0.3, 0.7,-0.3,-0.3, -0.3,0.2,-0.3, 0.2,0.2,-0.3, 0.7,0.2,-0.3, -0.3,0.7,-0.3, 0.2,0.7,-0.3, 0.7,0.7,-0.3
 872     ,-0.05,0.95,-0.3, 0.2,1.2,-0.3, 0.45,0.95,-0.3
 873   };
 874   int targetConn[24]={1,4,2, 4,5,2, 6,10,8,9,11,7, 0,3,4,1, 6,7,4,3, 7,8,5,4};
 875   MEDCouplingUMesh *targetMesh=MEDCouplingUMesh::New();
 876   targetMesh->setMeshDimension(2);
 877   targetMesh->allocateCells(6);
 878   targetMesh->setName("3DSurfMesh_1");
 879   targetMesh->insertNextCell(INTERP_KERNEL::NORM_TRI3,3,targetConn);
 880   targetMesh->insertNextCell(INTERP_KERNEL::NORM_TRI3,3,targetConn+3);
 881   targetMesh->insertNextCell(INTERP_KERNEL::NORM_QUAD4,4,targetConn+12);
 882   targetMesh->insertNextCell(INTERP_KERNEL::NORM_QUAD4,4,targetConn+16);
 883   targetMesh->insertNextCell(INTERP_KERNEL::NORM_TRI6,6,targetConn+6);
 884   targetMesh->insertNextCell(INTERP_KERNEL::NORM_POLYGON,4,targetConn+20);
 885   targetMesh->finishInsertingCells();
 886   DataArrayDouble *myCoords=DataArrayDouble::New();
 887   myCoords->alloc(12,3);
 888   myCoords->setInfoOnComponent(0,"toto [m]");
 889   myCoords->setInfoOnComponent(2,"ff [km]");//component 1 is not set for test
 890   std::copy(targetCoords,targetCoords+36,myCoords->getPointer());
 891   targetMesh->setCoords(myCoords);
 892   myCoords->decrRef();
 893   return targetMesh;
 894 }
 895
 896 MEDCouplingUMesh *MEDLoaderTest::build3DMesh_1()
 897 {
 898   double coords[180]={
 899     0.,0.,0., 1.,1.,0., 1.,1.25,0., 0.,1.,0., 1.,1.5,0., 2.,0.,0., 2.,1.,0., 1.,2.,0., 0.,2.,0., 3.,1.,0.,
 900     3.,2.,0., 0.,1.,0., 1.,3.,0., 2.,2.,0., 2.,3.,0.,
 901     0.,0.,1., 1.,1.,1., 1.,1.25,1., 0.,1.,1., 1.,1.5,1., 2.,0.,1., 2.,1.,1., 1.,2.,1., 0.,2.,1., 3.,1.,1.,
 902     3.,2.,1., 0.,1.,1., 1.,3.,1., 2.,2.,1., 2.,3.,1.,
 903     0.,0.,2., 1.,1.,2., 1.,1.25,2., 0.,1.,2., 1.,1.5,2., 2.,0.,2., 2.,1.,2., 1.,2.,2., 0.,2.,2., 3.,1.,2.,
 904     3.,2.,2., 0.,1.,2., 1.,3.,2., 2.,2.,2., 2.,3.,2.,
 905     0.,0.,3., 1.,1.,3., 1.,1.25,3., 0.,1.,3., 1.,1.5,3., 2.,0.,3., 2.,1.,3., 1.,2.,3., 0.,2.,3., 3.,1.,3.,
 906     3.,2.,3., 0.,1.,3., 1.,3.,3., 2.,2.,3., 2.,3.,3.};
 907
 908   int conn[354]={
 909     // 0
 910     0,11,1,3,15,26,16,18,   1,2,4,7,13,6,-1,1,16,21,6,-1,6,21,28,13,-1,13,7,22,28,-1,7,4,19,22,-1,4,2,17,19,-1,2,1,16,17,-1,16,21,28,22,19,17,
 911     1,6,5,3,16,21,20,18,   13,10,9,6,28,25,24,21,
 912     11,8,7,4,2,1,-1,11,26,16,1,-1,1,16,17,2,-1,2,17,19,4,-1,4,19,22,7,-1,7,8,23,22,-1,8,11,26,23,-1,26,16,17,19,22,23,
 913     7,12,14,13,22,27,29,28,
 914     // 1
 915     15,26,16,18,30,41,31,33,   16,17,19,22,28,21,-1,16,31,36,21,-1,21,36,43,28,-1,28,22,37,43,-1,22,19,34,37,-1,19,17,32,34,-1,17,16,31,32,-1,31,36,43,37,34,32,
 916     16,21,20,18,31,36,35,33,   28,25,24,21,43,40,39,36,
 917     26,23,22,19,17,16,-1,26,41,31,16,-1,16,31,32,17,-1,17,32,34,19,-1,19,34,37,22,-1,22,23,38,37,-1,23,26,41,38,-1,41,31,32,34,37,38,
 918     22,27,29,28,37,42,44,43,
 919     // 2
 920     30,41,31,33,45,56,46,48,  31,32,34,37,43,36,-1,31,46,51,36,-1,36,51,58,43,-1,43,37,52,58,-1,37,34,49,52,-1,34,32,47,49,-1,32,31,46,47,-1,46,51,58,52,49,47,
 921     31,36,35,33,46,51,50,48,  43,40,39,36,58,55,54,51,
 922     41,38,37,34,32,31,-1,41,56,46,31,-1,31,46,47,32,-1,32,47,49,34,-1,34,49,52,37,-1,37,38,53,52,-1,38,41,56,53,-1,56,46,47,49,52,53,
 923     37,42,44,43,52,57,59,58
 924   };
 925   //
 926   MEDCouplingUMesh *ret=MEDCouplingUMesh::New();
 927   ret->setName("3DMesh_1");
 928   ret->setMeshDimension(3);
 929   ret->allocateCells(18);
 930   //
 931   ret->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn);
 932   ret->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn+51);
 933   ret->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn+59);
 934   ret->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn+110);
 935   //
 936   ret->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn+118);
 937   ret->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn+169);
 938   ret->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn+177);
 939   ret->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn+228);
 940   //
 941   ret->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn+236);
 942   ret->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn+287);
 943   ret->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn+295);
 944   ret->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn+346);
 945   //
 946   ret->insertNextCell(INTERP_KERNEL::NORM_POLYHED,43,conn+8);
 947   ret->insertNextCell(INTERP_KERNEL::NORM_POLYHED,43,conn+67);
 948   ret->insertNextCell(INTERP_KERNEL::NORM_POLYHED,43,conn+126);
 949   ret->insertNextCell(INTERP_KERNEL::NORM_POLYHED,43,conn+185);
 950   ret->insertNextCell(INTERP_KERNEL::NORM_POLYHED,43,conn+244);
 951   ret->insertNextCell(INTERP_KERNEL::NORM_POLYHED,43,conn+303);
 952   //
 953   ret->finishInsertingCells();
 954   DataArrayDouble *myCoords=DataArrayDouble::New();
 955   myCoords->alloc(60,3);
 956   myCoords->setInfoOnComponent(0,"titi [m]");
 957   myCoords->setInfoOnComponent(1,"density power [MW/m^3]");
 958   myCoords->setInfoOnComponent(2,"t [kW]");
 959   std::copy(coords,coords+180,myCoords->getPointer());
 960   ret->setCoords(myCoords);
 961   myCoords->decrRef();
 962   return ret;
 963 }
 964
 965 MEDCouplingUMesh *MEDLoaderTest::build3DMesh_2()
 966 {
 967   MEDCouplingUMesh *m3dsurfBase=build3DSurfMesh_1();
 968   int numbers[5]={0,1,2,3,5};
 969   MEDCouplingUMesh *m3dsurf=(MEDCouplingUMesh *)m3dsurfBase->buildPartOfMySelf(numbers,numbers+5,false);
 970   m3dsurfBase->decrRef();
 971   MEDCouplingUMesh *m1dBase=build1DMesh_1();
 972   int numbers2[4]={0,1,2,3};
 973   MEDCouplingUMesh *m1d=(MEDCouplingUMesh *)m1dBase->buildPartOfMySelf(numbers2,numbers2+4,false);
 974   m1dBase->decrRef();
 975   m1d->changeSpaceDimension(3);
 976   const double vec[3]={0.,1.,0.};
 977   const double pt[3]={0.,0.,0.};
 978   m1d->rotate(pt,vec,-M_PI/2.);
 979   MEDCouplingUMesh *ret=m3dsurf->buildExtrudedMesh(m1d,0);
 980   m1d->decrRef();
 981   m3dsurf->decrRef();
 982   return ret;
 983 }
 984
 985 MEDCouplingFieldDouble *MEDLoaderTest::buildVecFieldOnCells_1()
 986 {
 987   MEDCouplingUMesh *mesh=build3DSurfMesh_1();
 988   int nbOfCells=mesh->getNumberOfCells();
 989   MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
 990   f1->setName("VectorFieldOnCells");
 991   f1->setMesh(mesh);
 992   DataArrayDouble *array=DataArrayDouble::New();
 993   array->alloc(nbOfCells,3);
 994   array->setInfoOnComponent(0,"power [MW/m^3]");
 995   array->setInfoOnComponent(1,"density [g/cm^3]");
 996   array->setInfoOnComponent(2,"temperature [K]");
 997   f1->setArray(array);
 998   array->decrRef();
 999   double *tmp=array->getPointer();
1000   const double arr1[18]={0.,10.,20.,1.,11.,21.,2.,12.,22.,3.,13.,23.,4.,14.,24.,5.,15.,25.};
1001   std::copy(arr1,arr1+18,tmp);
1002   f1->setTime(2.,0,1);
1003   f1->checkCoherency();
1004   mesh->decrRef();
1005   return f1;
1006 }
1007
1008 MEDCouplingFieldDouble *MEDLoaderTest::buildVecFieldOnNodes_1()
1009 {
1010   MEDCouplingUMesh *mesh=build3DSurfMesh_1();
1011   int nbOfNodes=mesh->getNumberOfNodes();
1012   MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_NODES,ONE_TIME);
1013   f1->setName("VectorFieldOnNodes");
1014   f1->setMesh(mesh);
1015   DataArrayDouble *array=DataArrayDouble::New();
1016   array->alloc(nbOfNodes,3);
1017   f1->setArray(array);
1018   array->setInfoOnComponent(0,"power [MW/m^3]");
1019   array->setInfoOnComponent(1,"density [g/cm^3]");
1020   array->setInfoOnComponent(2,"temperature [K]");
1021   array->decrRef();
1022   double *tmp=array->getPointer();
1023   const double arr1[36]={
1024     70.,80.,90.,71.,81.,91.,72.,82.,92.,73.,83.,93.,74.,84.,94.,75.,85.,95.,
1025     1000.,10010.,10020.,1001.,10011.,10021.,1002.,10012.,10022.,1003.,10013.,10023.,1004.,10014.,10024.,1005.,10015.,10025.,
1026   };
1027   std::copy(arr1,arr1+36,tmp);
1028   f1->setTime(2.12,2,3);
1029   f1->checkCoherency();
1030   mesh->decrRef();
1031   return f1;
1032 }
1033
1034 MEDCouplingFieldDouble *MEDLoaderTest::buildVecFieldOnGauss_1()
1035 {
1036   const double _a=0.446948490915965;
1037   const double _b=0.091576213509771;
1038   const double _p1=0.11169079483905;
1039   const double _p2=0.0549758718227661;
1040   const double refCoo1[6]={ 0.,0., 1.,0., 0.,1. };
1041   const double gsCoo1[12]={ 2*_b-1, 1-4*_b, 2*_b-1, 2.07*_b-1, 1-4*_b,
1042                             2*_b-1, 1-4*_a, 2*_a-1, 2*_a-1, 1-4*_a, 2*_a-1, 2*_a-1 };
1043   const double wg1[6]={ 4*_p2, 4*_p2, 4*_p2, 4*_p1, 4*_p1, 4*_p1 };
1044   std::vector<double> _refCoo1(refCoo1,refCoo1+6);
1045   std::vector<double> _gsCoo1(gsCoo1,gsCoo1+12);
1046   std::vector<double> _wg1(wg1,wg1+6);
1047   MEDCouplingUMesh *m=build2DMesh_2();
1048   MEDCouplingFieldDouble *f=MEDCouplingFieldDouble::New(ON_GAUSS_PT,ONE_TIME);
1049   f->setTime(3.14,1,5);
1050   f->setMesh(m);
1051   f->setGaussLocalizationOnType(INTERP_KERNEL::NORM_TRI3,_refCoo1,_gsCoo1,_wg1);
1052   const double refCoo2[12]={-1.0,1.0, -1.0,-1.0, 1.0,-1.0, -1.0,0.0, 0.0,-1.0, 0.0,0.0 };
1053   std::vector<double> _refCoo2(refCoo2,refCoo2+12);
1054   std::vector<double> _gsCoo2(_gsCoo1);
1055   std::vector<double> _wg2(_wg1);
1056   _gsCoo2.resize(6); _wg2.resize(3);
1057   const double refCoo3[8]={ 0.,0., 1.,0., 1.,1., 0.,1. };
1058   std::vector<double> _refCoo3(refCoo3,refCoo3+8);
1059   _gsCoo1.resize(4); _wg1.resize(2);
1060   f->setGaussLocalizationOnType(INTERP_KERNEL::NORM_QUAD4,_refCoo3,_gsCoo1,_wg1);
1061   f->setGaussLocalizationOnType(INTERP_KERNEL::NORM_TRI6,_refCoo2,_gsCoo2,_wg2);
1062   DataArrayDouble *array=DataArrayDouble::New();
1063   array->alloc(19,2);
1064   double *ptr=array->getPointer();
1065   for(int i=0;i<19*2;i++)
1066     ptr[i]=(double)(i+7);
1067   f->setArray(array);
1068   f->setName("MyFirstFieldOnGaussPoint");
1069   array->setInfoOnComponent(0,"power [MW/m^3]");
1070   array->setInfoOnComponent(1,"density");
1071   array->decrRef();
1072   f->checkCoherency();
1073   m->decrRef();
1074   return f;
1075 }
1076
1077 MEDCouplingFieldDouble *MEDLoaderTest::buildVecFieldOnGaussNE_1()
1078 {
1079   MEDCouplingUMesh *m=build2DMesh_2();
1080   MEDCouplingFieldDouble *f=MEDCouplingFieldDouble::New(ON_GAUSS_NE,ONE_TIME);
1081   f->setTime(3.14,1,5);
1082   f->setMesh(m);
1083   DataArrayDouble *array=DataArrayDouble::New();
1084   array->alloc(20,2);
1085   double *ptr=array->getPointer();
1086   for(int i=0;i<20*2;i++)
1087     ptr[i]=(double)(i+8);
1088   f->setArray(array);
1089   array->setInfoOnComponent(0,"power [W]");
1090   array->setInfoOnComponent(1,"temperature");
1091   f->setName("MyFieldOnGaussNE");
1092   array->decrRef();
1093   f->checkCoherency();
1094   m->decrRef();
1095   return f;
1096 }
1097