src/MEDLoader/Test/MEDLoaderTest.cxx

   1 // Copyright (C) 2007-2016  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 #include "TestInterpKernelUtils.hxx"  // getResourceFile()
  28
  29 #include <cmath>
  30 #include <numeric>
  31
  32 using namespace MEDCoupling;
  33
  34 void MEDLoaderTest::testMesh1DRW()
  35 {
  36   MEDCouplingUMesh *mesh=build1DMesh_1();
  37   mesh->checkConsistencyLight();
  38   WriteUMesh("file1.med",mesh,true);
  39   MEDCouplingUMesh *mesh_rw=ReadUMeshFromFile("file1.med",mesh->getName().c_str(),0);
  40   CPPUNIT_ASSERT(mesh->isEqual(mesh_rw,1e-12));
  41   mesh_rw->decrRef();
  42   mesh->decrRef();
  43 }
  44
  45 void MEDLoaderTest::testMesh2DCurveRW()
  46 {
  47   MEDCouplingUMesh *mesh=build2DCurveMesh_1();
  48   mesh->checkConsistencyLight();
  49   WriteUMesh("file2.med",mesh,true);
  50   MEDCouplingUMesh *mesh_rw=ReadUMeshFromFile("file2.med",mesh->getName().c_str(),0);
  51   CPPUNIT_ASSERT(mesh->isEqual(mesh_rw,1e-12));
  52   mesh_rw->decrRef();
  53   mesh->decrRef();
  54 }
  55
  56 void MEDLoaderTest::testMesh2DRW()
  57 {
  58   MEDCouplingUMesh *mesh=build2DMesh_1();
  59   mesh->checkConsistencyLight();
  60   WriteUMesh("file3.med",mesh,true);
  61   MEDCouplingUMesh *mesh_rw=ReadUMeshFromFile("file3.med",mesh->getName().c_str(),0);
  62   CPPUNIT_ASSERT(mesh->isEqual(mesh_rw,1e-12));
  63   mesh_rw->decrRef();
  64   mesh->decrRef();
  65 }
  66
  67 void MEDLoaderTest::testMesh3DSurfRW()
  68 {
  69   MEDCouplingUMesh *mesh=build3DSurfMesh_1();
  70   mesh->checkConsistencyLight();
  71   WriteUMesh("file4.med",mesh,true);
  72   MEDCouplingUMesh *mesh_rw=ReadUMeshFromFile("file4.med",mesh->getName().c_str(),0);
  73   CPPUNIT_ASSERT(mesh->isEqual(mesh_rw,1e-12));
  74   mesh_rw->decrRef();
  75   mesh->decrRef();
  76 }
  77
  78 void MEDLoaderTest::testMesh3DRW()
  79 {
  80   MEDCouplingUMesh *mesh=build3DMesh_1();
  81   mesh->checkConsistencyLight();
  82   WriteUMesh("file5.med",mesh,true);
  83   MEDCouplingUMesh *mesh_rw=ReadUMeshFromFile("file5.med",mesh->getName().c_str(),0);
  84   CPPUNIT_ASSERT(mesh->isEqual(mesh_rw,1e-12));
  85   mesh_rw->decrRef();
  86   mesh->decrRef();
  87 }
  88
  89 /*!
  90  * Most basic test : one and only one MEDCoupling field in a new file.
  91  */
  92 void MEDLoaderTest::testFieldRW1()
  93 {
  94   MEDCouplingFieldDouble *f1=buildVecFieldOnCells_1();
  95   WriteField("file6.med",f1,true);
  96   MEDCouplingFieldDouble *f2=ReadFieldCell("file6.med",f1->getMesh()->getName().c_str(),0,f1->getName().c_str(),0,1);
  97   CPPUNIT_ASSERT(f1->isEqual(f2,1e-12,1e-12));
  98   f1->decrRef();
  99   f2->decrRef();
 100   //
 101   f1=buildVecFieldOnNodes_1();
 102   WriteField("file7.med",f1,true);
 103   f2=ReadFieldNode("file7.med",f1->getMesh()->getName().c_str(),0,f1->getName().c_str(),2,3);
 104   CPPUNIT_ASSERT(f1->isEqual(f2,1e-12,1e-12));
 105   // testing kind message on error of field type.
 106   CPPUNIT_ASSERT_THROW(ReadFieldCell("file7.med",f1->getMesh()->getName().c_str(),0,f1->getName().c_str(),2,3),INTERP_KERNEL::Exception);
 107   //
 108   f1->decrRef();
 109   f2->decrRef();
 110 }
 111
 112 /*!
 113  * Multi field writing in a same file.
 114  */
 115 void MEDLoaderTest::testFieldRW2()
 116 {
 117   const char fileName[]="file8.med";
 118   static const double VAL1=12345.67890314;
 119   static const double VAL2=-1111111111111.;
 120   MEDCouplingFieldDouble *f1=buildVecFieldOnCells_1();
 121   WriteField(fileName,f1,true);
 122   f1->setTime(10.,8,9);
 123   double *tmp=f1->getArray()->getPointer();
 124   tmp[0]=VAL1;
 125   WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
 126   f1->setTime(10.14,18,19);
 127   tmp[0]=VAL2;
 128   WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
 129   //retrieving time steps...
 130   MEDCouplingFieldDouble *f2=ReadFieldCell(fileName,f1->getMesh()->getName().c_str(),0,f1->getName().c_str(),8,9);
 131   f1->setTime(10.,8,9);
 132   tmp[0]=VAL1;
 133   CPPUNIT_ASSERT(f1->isEqual(f2,1e-12,1e-12));
 134   f2->decrRef();
 135   f2=ReadFieldCell(fileName,f1->getMesh()->getName().c_str(),0,f1->getName().c_str(),0,1);
 136   MEDCouplingFieldDouble *f3=buildVecFieldOnCells_1();
 137   CPPUNIT_ASSERT(f3->isEqual(f2,1e-12,1e-12));
 138   f3->decrRef();
 139   f2->decrRef();
 140   f2=ReadFieldCell(fileName,f1->getMesh()->getName().c_str(),0,f1->getName().c_str(),18,19);
 141   f1->setTime(10.14,18,19);
 142   tmp[0]=VAL2;
 143   CPPUNIT_ASSERT(f1->isEqual(f2,1e-12,1e-12));
 144   //test of throw on invalid (dt,it)
 145   CPPUNIT_ASSERT_THROW(ReadFieldCell(fileName,f1->getMesh()->getName().c_str(),0,f1->getName().c_str(),28,19),INTERP_KERNEL::Exception);
 146   f2->decrRef();
 147   f1->decrRef();
 148   //ON NODES
 149   f1=buildVecFieldOnNodes_1();
 150   const char fileName2[]="file9.med";
 151   WriteField(fileName2,f1,true);
 152   f1->setTime(110.,108,109);
 153   tmp=f1->getArray()->getPointer();
 154   tmp[3]=VAL1;
 155   WriteFieldUsingAlreadyWrittenMesh(fileName2,f1);
 156   f1->setTime(210.,208,209);
 157   tmp[3]=VAL2;
 158   WriteFieldUsingAlreadyWrittenMesh(fileName2,f1);
 159   f2=ReadFieldNode(fileName2,f1->getMesh()->getName().c_str(),0,f1->getName().c_str(),108,109);
 160   f1->setTime(110.,108,109);
 161   tmp[3]=VAL1;
 162   CPPUNIT_ASSERT(f1->isEqual(f2,1e-12,1e-12));
 163   f2->decrRef();
 164   f2=ReadFieldNode(fileName2,f1->getMesh()->getName().c_str(),0,f1->getName().c_str(),2,3);
 165   f3=buildVecFieldOnNodes_1();
 166   CPPUNIT_ASSERT(f3->isEqual(f2,1e-12,1e-12));
 167   f3->decrRef();
 168   f2->decrRef();
 169   f2=ReadFieldNode(fileName2,f1->getMesh()->getName().c_str(),0,f1->getName().c_str(),208,209);
 170   f1->setTime(210.,208,209);
 171   tmp[3]=VAL2;
 172   CPPUNIT_ASSERT(f1->isEqual(f2,1e-12,1e-12));
 173   f2->decrRef();
 174   f1->decrRef();
 175 }
 176
 177 /*!
 178  * Multi field in a same file, but this field has several
 179  */
 180 void MEDLoaderTest::testFieldRW3()
 181 {
 182   const char fileName[]="file11.med";
 183   static const double VAL1=12345.67890314;
 184   static const double VAL2=-1111111111111.;
 185   const char name1[]="AField";
 186   const char name3[]="AMesh1";
 187   MEDCouplingFieldDouble *f1=buildVecFieldOnCells_1();
 188   (const_cast<MEDCouplingMesh *>(f1->getMesh()))->setName(name3);
 189   f1->setName(name1);
 190   f1->setTime(10.,8,9);
 191   double *tmp=f1->getArray()->getPointer();
 192   tmp[0]=VAL1;
 193   WriteField(fileName,f1,true);
 194   f1->setTime(10.14,18,19);
 195   tmp[0]=VAL2;
 196   WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
 197   f1->setTime(10.55,28,29);
 198   tmp[0]=3*VAL1;
 199   WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
 200   f1->setTime(10.66,38,39);
 201   tmp[0]=3*VAL2;
 202   WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
 203   f1->setTime(10.77,48,49);
 204   tmp[0]=4*VAL2;
 205   WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
 206   //ON NODES
 207   f1->decrRef();
 208   f1=buildVecFieldOnNodes_1();
 209   f1->setName(name1);
 210   (const_cast<MEDCouplingMesh *>(f1->getMesh()))->setName(name3);
 211   f1->setTime(110.,8,9);
 212   WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
 213   f1->setTime(110.,108,109);
 214   tmp=f1->getArray()->getPointer();
 215   tmp[3]=VAL1;
 216   WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
 217   f1->setTime(210.,208,209);
 218   tmp[3]=VAL2;
 219   WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
 220   //
 221   std::vector< std::pair<int,int> > it1=GetCellFieldIterations(fileName,name3,name1);
 222   CPPUNIT_ASSERT_EQUAL(5,(int)it1.size());
 223   CPPUNIT_ASSERT_EQUAL(8,it1[0].first); CPPUNIT_ASSERT_EQUAL(9,it1[0].second);
 224   CPPUNIT_ASSERT_EQUAL(18,it1[1].first); CPPUNIT_ASSERT_EQUAL(19,it1[1].second);
 225   CPPUNIT_ASSERT_EQUAL(28,it1[2].first); CPPUNIT_ASSERT_EQUAL(29,it1[2].second);
 226   CPPUNIT_ASSERT_EQUAL(38,it1[3].first); CPPUNIT_ASSERT_EQUAL(39,it1[3].second);
 227   CPPUNIT_ASSERT_EQUAL(48,it1[4].first); CPPUNIT_ASSERT_EQUAL(49,it1[4].second);
 228   std::vector< std::pair<int,int> > it3=GetNodeFieldIterations(fileName,name3,name1);
 229   CPPUNIT_ASSERT_EQUAL(3,(int)it3.size());
 230   CPPUNIT_ASSERT_EQUAL(8,it3[0].first); CPPUNIT_ASSERT_EQUAL(9,it3[0].second);
 231   CPPUNIT_ASSERT_EQUAL(108,it3[1].first); CPPUNIT_ASSERT_EQUAL(109,it3[1].second);
 232   CPPUNIT_ASSERT_EQUAL(208,it3[2].first); CPPUNIT_ASSERT_EQUAL(209,it3[2].second);
 233   //
 234   f1->decrRef();
 235   //
 236   f1=ReadFieldCell(fileName,name3,0,name1,8,9);
 237   CPPUNIT_ASSERT_DOUBLES_EQUAL(VAL1,f1->getArray()->getConstPointer()[0],1e-13);
 238   f1->decrRef();
 239   f1=ReadFieldCell(fileName,name3,0,name1,18,19);
 240   CPPUNIT_ASSERT_DOUBLES_EQUAL(VAL2,f1->getArray()->getConstPointer()[0],1e-13);
 241   f1->decrRef();
 242   f1=ReadFieldCell(fileName,name3,0,name1,28,29);
 243   CPPUNIT_ASSERT_DOUBLES_EQUAL(3*VAL1,f1->getArray()->getConstPointer()[0],1e-13);
 244   f1->decrRef();
 245   f1=ReadFieldCell(fileName,name3,0,name1,38,39);
 246   CPPUNIT_ASSERT_DOUBLES_EQUAL(3*VAL2,f1->getArray()->getConstPointer()[0],1e-13);
 247   f1->decrRef();
 248   f1=ReadFieldCell(fileName,name3,0,name1,48,49);
 249   CPPUNIT_ASSERT_DOUBLES_EQUAL(4*VAL2,f1->getArray()->getConstPointer()[0],1e-13);
 250   f1->decrRef();
 251   //
 252   f1=ReadFieldNode(fileName,name3,0,name1,8,9);
 253   CPPUNIT_ASSERT_DOUBLES_EQUAL(71.,f1->getArray()->getConstPointer()[3],1e-13);
 254   f1->decrRef();
 255   f1=ReadFieldNode(fileName,name3,0,name1,108,109);
 256   CPPUNIT_ASSERT_DOUBLES_EQUAL(VAL1,f1->getArray()->getConstPointer()[3],1e-13);
 257   f1->decrRef();
 258   f1=ReadFieldNode(fileName,name3,0,name1,208,209);
 259   CPPUNIT_ASSERT_DOUBLES_EQUAL(VAL2,f1->getArray()->getConstPointer()[3],1e-13);
 260   f1->decrRef();
 261 }
 262
 263 void MEDLoaderTest::testMultiMeshRW1()
 264 {
 265   const char fileName[]="file10.med";
 266   MEDCouplingUMesh *mesh1=build3DMesh_1();
 267   const int part1[5]={1,2,4,13,15};
 268   MEDCouplingUMesh *mesh2=(MEDCouplingUMesh *)mesh1->buildPartOfMySelf(part1,part1+5,true);
 269   mesh2->setName("mesh2");
 270   const int part2[4]={3,4,13,14};
 271   MEDCouplingUMesh *mesh3=(MEDCouplingUMesh *)mesh1->buildPartOfMySelf(part2,part2+4,true);
 272   mesh3->setName("mesh3");
 273   MEDCouplingUMesh *mesh4=MEDCouplingUMesh::New();
 274   mesh4->setName("mesh4");
 275   mesh4->setMeshDimension(3);
 276   mesh4->allocateCells(1);
 277   int conn[4]={0,11,1,3};
 278   mesh4->insertNextCell(INTERP_KERNEL::NORM_TETRA4,4,conn);
 279   mesh4->finishInsertingCells();
 280   mesh4->setCoords(mesh1->getCoords());
 281   std::vector<const MEDCouplingUMesh *> meshes;
 282   meshes.push_back(mesh1);
 283   meshes.push_back(mesh2);
 284   meshes.push_back(mesh3);
 285   meshes.push_back(mesh4);
 286   const char mnane[]="3DToto";
 287   WriteUMeshesPartition(fileName,mnane,meshes,true);
 288   //
 289   MEDCouplingUMesh *mesh5=ReadUMeshFromFile(fileName,mnane);
 290   mesh1->setName(mnane);
 291   const int part3[18]={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17};
 292   MEDCouplingUMesh *mesh6=(MEDCouplingUMesh *)mesh5->buildPartOfMySelf(part3,part3+18,true);
 293   mesh6->setName(mnane);
 294   mesh5->decrRef();
 295   CPPUNIT_ASSERT(mesh6->isEqual(mesh1,1e-12));
 296   mesh6->decrRef();
 297   std::vector<std::string> grps=GetMeshGroupsNames(fileName,mnane);
 298   CPPUNIT_ASSERT_EQUAL(4,(int)grps.size());
 299   CPPUNIT_ASSERT(std::find(grps.begin(),grps.end(),std::string("mesh2"))!=grps.end());
 300   CPPUNIT_ASSERT(std::find(grps.begin(),grps.end(),std::string("mesh3"))!=grps.end());
 301   CPPUNIT_ASSERT(std::find(grps.begin(),grps.end(),std::string("mesh4"))!=grps.end());
 302   CPPUNIT_ASSERT(std::find(grps.begin(),grps.end(),std::string("3DMesh_1"))!=grps.end());
 303   //
 304   std::vector<std::string> vec;
 305   vec.push_back(std::string("mesh2"));
 306   MEDCouplingUMesh *mesh2_2=ReadUMeshFromGroups(fileName,mnane,0,vec);
 307   CPPUNIT_ASSERT(mesh2_2->isEqual(mesh2,1e-12));
 308   mesh2_2->decrRef();
 309   vec.clear(); vec.push_back(std::string("mesh3"));
 310   MEDCouplingUMesh *mesh3_2=ReadUMeshFromGroups(fileName,mnane,0,vec);
 311   CPPUNIT_ASSERT(mesh3_2->isEqual(mesh3,1e-12));
 312   mesh3_2->decrRef();
 313   vec.clear(); vec.push_back(std::string("mesh4"));
 314   MEDCouplingUMesh *mesh4_2=ReadUMeshFromGroups(fileName,mnane,0,vec);
 315   CPPUNIT_ASSERT(mesh4_2->isEqual(mesh4,1e-12));
 316   mesh4_2->decrRef();
 317   vec.clear(); vec.push_back(std::string("3DMesh_1"));
 318   MEDCouplingUMesh *mesh1_2=ReadUMeshFromGroups(fileName,mnane,0,vec);
 319   mesh1->setName("3DMesh_1");
 320   CPPUNIT_ASSERT(mesh1_2->isEqual(mesh1,1e-12));
 321   mesh1_2->decrRef();
 322   //
 323   vec.clear(); vec.push_back(std::string("Family_-3")); vec.push_back(std::string("Family_-5"));
 324   mesh2_2=ReadUMeshFromFamilies(fileName,mnane,0,vec);
 325   mesh2_2->setName("mesh2");
 326   CPPUNIT_ASSERT(mesh2_2->isEqual(mesh2,1e-12));
 327   mesh2_2->decrRef();
 328   //
 329   std::vector<std::string> ret(GetMeshFamiliesNamesOnGroup(fileName,"3DToto","3DMesh_1"));
 330   std::set<std::string> s(ret.begin(),ret.end());
 331   std::set<std::string> ref_s;
 332   ref_s.insert("Family_-2");
 333   ref_s.insert("Family_-3");
 334   ref_s.insert("Family_-4");
 335   ref_s.insert("Family_-5");
 336   CPPUNIT_ASSERT_EQUAL(4,(int)ret.size());
 337   CPPUNIT_ASSERT(s==ref_s);
 338   //
 339   std::vector<std::string> ret1=GetMeshGroupsNamesOnFamily(fileName,"3DToto","Family_-3");
 340   CPPUNIT_ASSERT_EQUAL(2,(int)ret1.size());
 341   CPPUNIT_ASSERT(ret1[0]=="3DMesh_1");
 342   CPPUNIT_ASSERT(ret1[1]=="mesh2");
 343   //
 344   mesh4->decrRef();
 345   mesh3->decrRef();
 346   mesh2->decrRef();
 347   mesh1->decrRef();
 348 }
 349
 350 void MEDLoaderTest::testFieldProfilRW1()
 351 {
 352   const char fileName[]="file12.med";
 353   MEDCouplingUMesh *mesh1=build3DMesh_1();
 354   bool b;
 355   int newNbOfNodes;
 356   DataArrayInt *da=mesh1->mergeNodes(1e-12,b,newNbOfNodes);
 357   da->decrRef();
 358   WriteUMesh(fileName,mesh1,true);
 359   const int part1[5]={1,2,4,13,15};
 360   MEDCouplingUMesh *mesh2=(MEDCouplingUMesh *)mesh1->buildPartOfMySelf(part1,part1+5,true);
 361   mesh2->setName(mesh1->getName().c_str());//<- important for the test
 362   //
 363   int nbOfCells=mesh2->getNumberOfCells();
 364   CPPUNIT_ASSERT_EQUAL(5,nbOfCells);
 365   MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
 366   f1->setName("VectorFieldOnCells");
 367   f1->setMesh(mesh2);
 368   DataArrayDouble *array=DataArrayDouble::New();
 369   array->alloc(nbOfCells,2);
 370   f1->setArray(array);
 371   array->decrRef();
 372   double *tmp=array->getPointer();
 373   const double arr1[10]={71.,171.,10.,110.,20.,120.,30.,130.,40.,140.};
 374   std::copy(arr1,arr1+10,tmp);
 375   f1->setTime(3.14,2,7);
 376   f1->checkConsistencyLight();
 377   //
 378   WriteField(fileName,f1,false);//<- false important for the test
 379   //
 380   MEDCouplingFieldDouble *f2=ReadFieldCell(fileName,f1->getMesh()->getName().c_str(),0,f1->getName().c_str(),2,7);
 381   std::vector<MEDCoupling::TypeOfField> types=GetTypesOfField(fileName,f1->getMesh()->getName().c_str(),f1->getName().c_str());
 382   CPPUNIT_ASSERT_EQUAL(1,(int)types.size());
 383   CPPUNIT_ASSERT(types[0]==ON_CELLS);
 384   f2->checkConsistencyLight();
 385   CPPUNIT_ASSERT(f1->isEqual(f2,1e-12,1e-12));
 386   //
 387   f2->decrRef();
 388   f1->decrRef();
 389   mesh1->decrRef();
 390   mesh2->decrRef();
 391 }
 392
 393 /*!
 394  * Test MED file profiles.
 395  */
 396 void MEDLoaderTest::testFieldNodeProfilRW1()
 397 {
 398   const char fileName[]="file19.med";
 399   const char fileName2[]="file20.med";
 400   MEDCouplingUMesh *m=build2DMesh_1();
 401   int nbOfNodes=m->getNumberOfNodes();
 402   WriteUMesh(fileName,m,true);
 403   MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_NODES,ONE_TIME);
 404   f1->setName("VFieldOnNodes");
 405   f1->setMesh(m);
 406   DataArrayDouble *array=DataArrayDouble::New();
 407   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.};
 408   array->alloc(nbOfNodes,2);
 409   std::copy(arr1,arr1+24,array->getPointer());
 410   f1->setArray(array);
 411   array->setInfoOnComponent(0,"tyty [mm]");
 412   array->setInfoOnComponent(1,"uiop [MW]");
 413   array->decrRef();
 414   f1->setTime(3.14,2,7);
 415   f1->checkConsistencyLight();
 416   const int arr2[2]={1,4};//node ids are 2,4,5,3,6,7
 417   MEDCouplingFieldDouble *f2=f1->buildSubPart(arr2,arr2+2);
 418   (const_cast<MEDCouplingMesh *>(f2->getMesh()))->setName(f1->getMesh()->getName().c_str());
 419   WriteField(fileName,f2,false);//<- false important for the test
 420   //
 421   MEDCouplingFieldDouble *f3=ReadFieldNode(fileName,f2->getMesh()->getName().c_str(),0,f2->getName().c_str(),2,7);
 422   f3->checkConsistencyLight();
 423   CPPUNIT_ASSERT(f3->isEqual(f2,1e-12,1e-12));
 424   f3->decrRef();
 425   //
 426   const int arr3[6]={1,3,0,5,2,4};
 427   f2->renumberNodes(arr3);
 428   WriteUMesh(fileName2,m,true);
 429   WriteField(fileName2,f2,false);//<- false important for the test
 430   f3=ReadFieldNode(fileName2,f2->getMesh()->getName().c_str(),0,f2->getName().c_str(),2,7);
 431   f3->checkConsistencyLight();
 432   CPPUNIT_ASSERT(f3->isEqual(f2,1e-12,1e-12));
 433   f3->decrRef();
 434   f2->decrRef();
 435   //
 436   f1->decrRef();
 437   m->decrRef();
 438 }
 439
 440 void MEDLoaderTest::testFieldNodeProfilRW2()
 441 {
 442   const char fileName[]="file23.med";
 443   MEDCouplingUMesh *mesh=build3DSurfMesh_1();
 444   WriteUMesh(fileName,mesh,true);
 445   //
 446   MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_NODES,ONE_TIME);
 447   f1->setName("FieldMix");
 448   f1->setMesh(mesh);
 449   const double arr2[24]={
 450     1071.,1171.,1010.,1110.,1020.,1120.,1030.,1130.,1040.,1140.,1050.,1150.,
 451     1060.,1160.,1070.,1170.,1080.,1180.,1090.,1190.,1091.,1191.,1092.,1192.
 452   };
 453   DataArrayDouble *array=DataArrayDouble::New();
 454   array->alloc(12,2);
 455   f1->setArray(array);
 456   array->setInfoOnComponent(0,"plkj [mm]");
 457   array->setInfoOnComponent(1,"pqqqss [mm]");
 458   array->decrRef();
 459   double *tmp=array->getPointer();
 460   std::copy(arr2,arr2+24,tmp);
 461   f1->setTime(3.17,2,7);
 462   //
 463   const int renumArr[12]={3,7,2,1,5,11,10,0,9,6,8,4};
 464   f1->renumberNodes(renumArr);
 465   f1->checkConsistencyLight();
 466   WriteField(fileName,f1,false);//<- false important for the test
 467   MEDCouplingFieldDouble *f2=ReadFieldNode(fileName,f1->getMesh()->getName().c_str(),0,f1->getName().c_str(),2,7);
 468   CPPUNIT_ASSERT(f2->isEqual(f1,1e-12,1e-12));
 469   //
 470   f2->decrRef();
 471   mesh->decrRef();
 472   f1->decrRef();
 473 }
 474
 475 void MEDLoaderTest::testFieldGaussRW1()
 476 {
 477   const char fileName[]="file13.med";
 478   MEDCouplingFieldDouble *f1=buildVecFieldOnGauss_1();
 479   WriteField(fileName,f1,true);
 480   MEDCouplingFieldDouble *f2=ReadField(ON_GAUSS_PT,fileName,f1->getMesh()->getName().c_str(),0,f1->getName().c_str(),1,5);
 481   CPPUNIT_ASSERT(f1->isEqual(f2,1e-12,1e-12));
 482   f2->decrRef();
 483   f1->decrRef();
 484 }
 485
 486 void MEDLoaderTest::testFieldGaussNERW1()
 487 {
 488   const char fileName[]="file14.med";
 489   MEDCouplingFieldDouble *f1=buildVecFieldOnGaussNE_1();
 490   WriteField(fileName,f1,true);
 491   std::vector<MEDCoupling::TypeOfField> tof(GetTypesOfField(fileName,"2DMesh_2","MyFieldOnGaussNE"));
 492   CPPUNIT_ASSERT_EQUAL(1,(int)tof.size());
 493   CPPUNIT_ASSERT(ON_GAUSS_NE==tof[0]);
 494   MEDCouplingFieldDouble *f2=ReadField(ON_GAUSS_NE,fileName,f1->getMesh()->getName().c_str(),0,f1->getName().c_str(),1,5);
 495   CPPUNIT_ASSERT(f1->isEqual(f2,1e-12,1e-12));
 496   f2->decrRef();
 497   f1->decrRef();
 498 }
 499
 500 void MEDLoaderTest::testLittleStrings1()
 501 {
 502   std::string s("azeeeerrrtty");
 503   MEDLoaderBase::zipEqualConsChar(s,3);
 504   CPPUNIT_ASSERT(s=="azertty");
 505 }
 506
 507 void MEDLoaderTest::testSplitIntoNameAndUnit1()
 508 {
 509   std::string s(" []");
 510   std::string c,u;
 511   MEDLoaderBase::splitIntoNameAndUnit(s,c,u);
 512   CPPUNIT_ASSERT(c.empty());
 513   CPPUNIT_ASSERT(u.empty());
 514   s="   lmmm  kki jjj      ";
 515   MEDLoaderBase::strip(s);
 516   CPPUNIT_ASSERT(s=="lmmm  kki jjj");
 517   s=" ";
 518   MEDLoaderBase::strip(s);
 519   CPPUNIT_ASSERT(s.empty());
 520   s="";
 521   MEDLoaderBase::strip(s);
 522   CPPUNIT_ASSERT(s.empty());
 523   s="      ";
 524   MEDLoaderBase::strip(s);
 525   CPPUNIT_ASSERT(s.empty());
 526   s="     pp";
 527   MEDLoaderBase::strip(s);
 528   CPPUNIT_ASSERT(s=="pp");
 529 }
 530
 531 void MEDLoaderTest::testMesh3DSurfShuffleRW()
 532 {
 533   const char fileName[]="file15.med";
 534   MEDCouplingUMesh *mesh=build3DSurfMesh_1();
 535   const int renumber1[6]={2,5,1,0,3,4};
 536   mesh->renumberCells(renumber1,false);
 537   mesh->checkConsistencyLight();
 538   WriteUMesh(fileName,mesh,true);
 539   MEDCouplingUMesh *mesh_rw=ReadUMeshFromFile(fileName,mesh->getName().c_str(),0);
 540   CPPUNIT_ASSERT(mesh->isEqual(mesh_rw,1e-12));
 541   mesh_rw->decrRef();
 542   mesh->decrRef();
 543 }
 544
 545 void MEDLoaderTest::testFieldShuffleRW1()
 546 {
 547   const char fileName[]="file16.med";
 548   MEDCouplingUMesh *mesh=build3DSurfMesh_1();
 549   MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
 550   f1->setName("FieldOnCellsShuffle");
 551   f1->setMesh(mesh);
 552   DataArrayDouble *array=DataArrayDouble::New();
 553   array->alloc(6,2);
 554   f1->setArray(array);
 555   array->decrRef();
 556   double *tmp=array->getPointer();
 557   const double arr1[12]={71.,171.,10.,110.,20.,120.,30.,130.,40.,140.,50.,150.};
 558   std::copy(arr1,arr1+12,tmp);
 559   f1->setTime(3.14,2,7);
 560   f1->checkConsistencyLight();
 561   //
 562   const int renumber1[6]={2,1,5,0,3,4};
 563   f1->renumberCells(renumber1,false);
 564   WriteField(fileName,f1,true);
 565   MEDCouplingFieldDouble *f2=ReadFieldCell(fileName,mesh->getName().c_str(),0,f1->getName().c_str(),2,7);
 566   CPPUNIT_ASSERT(f2->isEqual(f1,1e-12,1e-12));
 567   f2->decrRef();
 568   //
 569   mesh->decrRef();
 570   f1->decrRef();
 571 }
 572
 573 /*!
 574  * Shuffle de cells but no profile. Like pointe.med
 575  */
 576 void MEDLoaderTest::testMultiFieldShuffleRW1()
 577 {
 578   const char fileName[]="file17.med";
 579   MEDCouplingUMesh *m=build3DMesh_2();
 580   CPPUNIT_ASSERT_EQUAL(20,m->getNumberOfCells());
 581   CPPUNIT_ASSERT_EQUAL(45,m->getNumberOfNodes());
 582   const int polys[3]={1,4,6};
 583   std::vector<int> poly2(polys,polys+3);
 584   m->convertToPolyTypes(&poly2[0],&poly2[0]+poly2.size());
 585   const int renum[20]={1,3,2,8,9,12,13,16,19,0,4,7,5,15,14,17,10,18,6,11};
 586   m->renumberCells(renum,false);
 587   m->orientCorrectlyPolyhedrons();
 588   // Writing
 589   WriteUMesh(fileName,m,true);
 590   MEDCouplingFieldDouble *f1Tmp=m->getMeasureField(false);
 591   MEDCouplingFieldDouble *f1=f1Tmp->buildNewTimeReprFromThis(ONE_TIME,false);
 592   f1Tmp->decrRef();
 593   f1->setTime(0.,1,2);
 594   MEDCouplingFieldDouble *f_1=f1->cloneWithMesh(true);
 595   WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
 596   f1->applyFunc("2*x");
 597   f1->setTime(0.01,3,4);
 598   MEDCouplingFieldDouble *f_2=f1->cloneWithMesh(true);
 599   WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
 600   f1->applyFunc("2*x/3");
 601   f1->setTime(0.02,5,6);
 602   MEDCouplingFieldDouble *f_3=f1->cloneWithMesh(true);
 603   WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
 604   f1->decrRef();
 605   // Reading
 606   std::vector<std::pair<int,int> > its;
 607   its.push_back(std::pair<int,int>(1,2));
 608   its.push_back(std::pair<int,int>(3,4));
 609   its.push_back(std::pair<int,int>(5,6));
 610   std::vector<MEDCouplingFieldDouble *> fs=ReadFieldsOnSameMesh(ON_CELLS,fileName,f_1->getMesh()->getName().c_str(),0,f_1->getName().c_str(),its);
 611   CPPUNIT_ASSERT_EQUAL(3,(int)fs.size());
 612   const MEDCouplingMesh *mm=fs[0]->getMesh();
 613   CPPUNIT_ASSERT(fs[0]->isEqual(f_1,1e-12,1e-12));
 614   CPPUNIT_ASSERT(fs[1]->isEqual(f_2,1e-12,1e-12));
 615   CPPUNIT_ASSERT(fs[2]->isEqual(f_3,1e-12,1e-12));
 616   CPPUNIT_ASSERT(mm==fs[1]->getMesh());// <- important for the test
 617   CPPUNIT_ASSERT(mm==fs[2]->getMesh());// <- important for the test
 618   for(std::vector<MEDCouplingFieldDouble *>::iterator iter=fs.begin();iter!=fs.end();iter++)
 619     (*iter)->decrRef();
 620   //
 621   f_1->decrRef();
 622   f_2->decrRef();
 623   f_3->decrRef();
 624   //
 625   m->decrRef();
 626 }
 627
 628 void MEDLoaderTest::testWriteUMeshesRW1()
 629 {
 630   const char fileName[]="file18.med";
 631   MEDCouplingUMesh *m3d=build3DMesh_2();
 632   const double pt[3]={0.,0.,-0.3};
 633   const double vec[3]={0.,0.,1.};
 634   std::vector<int> nodes;
 635   m3d->findNodesOnPlane(pt,vec,1e-12,nodes);
 636   MEDCouplingUMesh *m2d=(MEDCouplingUMesh *)m3d->buildFacePartOfMySelfNode(&nodes[0],&nodes[0]+nodes.size(),true);
 637   const int renumber[5]={1,2,0,4,3};
 638   m2d->renumberCells(renumber,false);
 639   m2d->setName("ExampleOfMultiDimW");
 640   std::vector<const MEDCouplingUMesh *> meshes;
 641   meshes.push_back(m2d);
 642   meshes.push_back(m3d);
 643   WriteUMeshes(fileName,meshes,true);
 644   MEDCouplingUMesh *m3d_bis=ReadUMeshFromFile(fileName,m2d->getName().c_str(),0);
 645   CPPUNIT_ASSERT(!m3d_bis->isEqual(m3d,1e-12));
 646   m3d_bis->setName(m3d->getName().c_str());
 647   CPPUNIT_ASSERT(m3d_bis->isEqual(m3d,1e-12));
 648   MEDCouplingUMesh *m2d_bis=ReadUMeshFromFile(fileName,m2d->getName().c_str(),-1);//-1 for faces
 649   CPPUNIT_ASSERT(m2d_bis->isEqual(m2d,1e-12));
 650   // Creation of a field on faces.
 651   MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
 652   f1->setName("FieldOnFacesShuffle");
 653   f1->setMesh(m2d);
 654   DataArrayDouble *array=DataArrayDouble::New();
 655   array->alloc(m2d->getNumberOfCells(),2);
 656   array->setInfoOnComponent(0,"plkj [mm]");
 657   array->setInfoOnComponent(1,"pqqqss [mm]");
 658   f1->setArray(array);
 659   array->decrRef();
 660   double *tmp=array->getPointer();
 661   const double arr1[10]={71.,171.,10.,110.,20.,120.,30.,130.,40.,140.};
 662   std::copy(arr1,arr1+10,tmp);
 663   f1->setTime(3.14,2,7);
 664   f1->checkConsistencyLight();
 665   WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
 666   MEDCouplingFieldDouble *f2=ReadFieldCell(fileName,f1->getMesh()->getName().c_str(),-1,f1->getName().c_str(),2,7);
 667   CPPUNIT_ASSERT(f2->isEqual(f1,1e-12,1e-12));
 668   f1->decrRef();
 669   f2->decrRef();
 670   //
 671   m2d_bis->decrRef();
 672   m3d_bis->decrRef();
 673   m2d->decrRef();
 674   m3d->decrRef();
 675 }
 676
 677 void MEDLoaderTest::testMixCellAndNodesFieldRW1()
 678 {
 679   const char fileName[]="file21.med";
 680   MEDCouplingUMesh *mesh=build3DSurfMesh_1();
 681   MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
 682   f1->setName("FieldMix");
 683   f1->setMesh(mesh);
 684   DataArrayDouble *array=DataArrayDouble::New();
 685   array->alloc(6,2);
 686   f1->setArray(array);
 687   array->setInfoOnComponent(0,"plkj [mm]");
 688   array->setInfoOnComponent(1,"pqqqss [mm]");
 689   array->decrRef();
 690   double *tmp=array->getPointer();
 691   const double arr1[12]={71.,171.,10.,110.,20.,120.,30.,130.,40.,140.,50.,150.};
 692   std::copy(arr1,arr1+12,tmp);
 693   f1->setTime(3.14,2,7);
 694   f1->checkConsistencyLight();
 695   //
 696   MEDCouplingFieldDouble *f2=MEDCouplingFieldDouble::New(ON_NODES,ONE_TIME);
 697   f2->setName("FieldMix");
 698   f2->setMesh(mesh);
 699   array=DataArrayDouble::New();
 700   array->alloc(12,2);
 701   f2->setArray(array);
 702   array->setInfoOnComponent(0,"plkj [mm]");
 703   array->setInfoOnComponent(1,"pqqqss [mm]");
 704   array->decrRef();
 705   tmp=array->getPointer();
 706   const double arr2[24]={
 707     1071.,1171.,1010.,1110.,1020.,1120.,1030.,1130.,1040.,1140.,1050.,1150.,
 708     1060.,1160.,1070.,1170.,1080.,1180.,1090.,1190.,1091.,1191.,1092.,1192.
 709   };
 710   std::copy(arr2,arr2+24,tmp);
 711   f2->setTime(3.14,2,7);
 712   f2->checkConsistencyLight();
 713   //
 714   WriteField(fileName,f1,true);
 715   std::vector<MEDCoupling::TypeOfField> ts=GetTypesOfField(fileName,f1->getMesh()->getName().c_str(),f1->getName().c_str());
 716   CPPUNIT_ASSERT_EQUAL(1,(int)ts.size());
 717   CPPUNIT_ASSERT_EQUAL(ON_CELLS,ts[0]);
 718   std::vector<std::string> fs=GetAllFieldNamesOnMesh(fileName,f1->getMesh()->getName().c_str());
 719   CPPUNIT_ASSERT_EQUAL(1,(int)fs.size());
 720   CPPUNIT_ASSERT(fs[0]=="FieldMix");
 721   WriteFieldUsingAlreadyWrittenMesh(fileName,f2);
 722   fs=GetAllFieldNamesOnMesh(fileName,f1->getMesh()->getName().c_str());
 723   CPPUNIT_ASSERT_EQUAL(1,(int)fs.size());
 724   CPPUNIT_ASSERT(fs[0]=="FieldMix");
 725   //
 726   ts=GetTypesOfField(fileName,f1->getMesh()->getName().c_str(),f1->getName().c_str());
 727   CPPUNIT_ASSERT_EQUAL(2,(int)ts.size());
 728   CPPUNIT_ASSERT_EQUAL(ON_NODES,ts[0]);
 729   CPPUNIT_ASSERT_EQUAL(ON_CELLS,ts[1]);
 730   //
 731   MEDCouplingFieldDouble *f3=ReadFieldNode(fileName,f1->getMesh()->getName().c_str(),0,f1->getName().c_str(),2,7);
 732   CPPUNIT_ASSERT(f3->isEqual(f2,1e-12,1e-12));
 733   f3->decrRef();
 734   f3=ReadFieldCell(fileName,f1->getMesh()->getName().c_str(),0,f1->getName().c_str(),2,7);
 735   CPPUNIT_ASSERT(f3->isEqual(f1,1e-12,1e-12));
 736   f3->decrRef();
 737   //
 738   f1->decrRef();
 739   f2->decrRef();
 740   mesh->decrRef();
 741 }
 742
 743 void MEDLoaderTest::testGetAllFieldNamesRW1()
 744 {
 745   const char fileName[]="file22.med";
 746   MEDCouplingUMesh *mesh=build2DMesh_2();
 747   MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_NODES,ONE_TIME);
 748   f1->setName("Field1");
 749   f1->setTime(3.44,5,6);
 750   f1->setMesh(mesh);
 751   f1->fillFromAnalytic(2,"x+y");
 752   WriteField(fileName,f1,true);
 753   f1->setTime(1002.3,7,8);
 754   f1->fillFromAnalytic(2,"x+77.*y");
 755   WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
 756   f1->setName("Field2");
 757   WriteField(fileName,f1,false);
 758   f1->setName("Field3");
 759   mesh->setName("2DMesh_2Bis");
 760   WriteField(fileName,f1,false);
 761   f1->decrRef();
 762   f1=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
 763   f1->setName("Field8");
 764   f1->setTime(8.99,7,9);
 765   f1->setMesh(mesh);
 766   f1->fillFromAnalytic(3,"3*x+y");
 767   WriteField(fileName,f1,false);
 768   f1->decrRef();
 769   std::vector<std::string> fs=GetAllFieldNames(fileName);
 770   CPPUNIT_ASSERT_EQUAL(4,(int)fs.size());
 771   CPPUNIT_ASSERT(fs[0]=="Field1");
 772   CPPUNIT_ASSERT(fs[1]=="Field2");
 773   CPPUNIT_ASSERT(fs[2]=="Field3");
 774   CPPUNIT_ASSERT(fs[3]=="Field8");
 775   mesh->decrRef();
 776 }
 777
 778
 779 void MEDLoaderTest::testMEDLoaderRead1()
 780 {
 781   using namespace std;
 782   using namespace INTERP_KERNEL;
 783
 784   string fileName= INTERP_TEST::getResourceFile("pointe.med", 3);
 785   vector<string> meshNames=GetMeshNames(fileName.c_str());
 786   CPPUNIT_ASSERT_EQUAL(1,(int)meshNames.size());
 787   MEDCouplingUMesh *mesh=ReadUMeshFromFile(fileName.c_str(),meshNames[0].c_str(),0);
 788   CPPUNIT_ASSERT_EQUAL(3,mesh->getSpaceDimension());
 789   CPPUNIT_ASSERT_EQUAL(3,mesh->getMeshDimension());
 790   CPPUNIT_ASSERT_EQUAL(16,mesh->getNumberOfCells());
 791   CPPUNIT_ASSERT_EQUAL(19,mesh->getNumberOfNodes());
 792   CPPUNIT_ASSERT_EQUAL(3,(int)mesh->getAllGeoTypes().size());
 793   for(int i=0;i<12;i++)
 794     CPPUNIT_ASSERT_EQUAL(NORM_TETRA4,mesh->getTypeOfCell(i));
 795   CPPUNIT_ASSERT_EQUAL(NORM_PYRA5,mesh->getTypeOfCell(12));
 796   CPPUNIT_ASSERT_EQUAL(NORM_HEXA8,mesh->getTypeOfCell(13));
 797   CPPUNIT_ASSERT_EQUAL(NORM_HEXA8,mesh->getTypeOfCell(14));
 798   CPPUNIT_ASSERT_EQUAL(NORM_PYRA5,mesh->getTypeOfCell(15));
 799   CPPUNIT_ASSERT_EQUAL((std::size_t)90,mesh->getNodalConnectivity()->getNbOfElems());
 800   CPPUNIT_ASSERT_EQUAL(701,std::accumulate(mesh->getNodalConnectivity()->getPointer(),mesh->getNodalConnectivity()->getPointer()+90,0));
 801   CPPUNIT_ASSERT_EQUAL(705,std::accumulate(mesh->getNodalConnectivityIndex()->getPointer(),mesh->getNodalConnectivityIndex()->getPointer()+17,0));
 802   CPPUNIT_ASSERT_DOUBLES_EQUAL(46.,std::accumulate(mesh->getCoords()->getPointer(),mesh->getCoords()->getPointer()+57,0),1e-12);
 803   mesh->decrRef();
 804   //
 805   vector<string> families=GetMeshFamiliesNames(fileName.c_str(),meshNames[0].c_str());
 806   CPPUNIT_ASSERT_EQUAL(8,(int)families.size());
 807   CPPUNIT_ASSERT(families[2]=="FAMILLE_ELEMENT_3");
 808   //
 809   vector<string> families2;
 810   families2.push_back(families[2]);
 811   mesh=ReadUMeshFromFamilies(fileName.c_str(),meshNames[0].c_str(),0,families2);
 812   CPPUNIT_ASSERT_EQUAL(3,mesh->getSpaceDimension());
 813   CPPUNIT_ASSERT_EQUAL(3,mesh->getMeshDimension());
 814   CPPUNIT_ASSERT_EQUAL(2,mesh->getNumberOfCells());
 815   CPPUNIT_ASSERT_EQUAL(19,mesh->getNumberOfNodes());
 816   CPPUNIT_ASSERT_EQUAL(2,(int)mesh->getAllGeoTypes().size());
 817   CPPUNIT_ASSERT_EQUAL(NORM_TETRA4,mesh->getTypeOfCell(0));
 818   CPPUNIT_ASSERT_EQUAL(NORM_PYRA5,mesh->getTypeOfCell(1));
 819   CPPUNIT_ASSERT_EQUAL((std::size_t)11,mesh->getNodalConnectivity()->getNbOfElems());
 820   CPPUNIT_ASSERT_EQUAL(132,std::accumulate(mesh->getNodalConnectivity()->getPointer(),mesh->getNodalConnectivity()->getPointer()+11,0));
 821   CPPUNIT_ASSERT_EQUAL(16,std::accumulate(mesh->getNodalConnectivityIndex()->getPointer(),mesh->getNodalConnectivityIndex()->getPointer()+3,0));
 822   CPPUNIT_ASSERT_DOUBLES_EQUAL(46.,std::accumulate(mesh->getCoords()->getPointer(),mesh->getCoords()->getPointer()+57,0),1e-12);
 823   mesh->decrRef();
 824   //
 825   vector<string> groups=GetMeshGroupsNames(fileName.c_str(),meshNames[0].c_str());
 826   CPPUNIT_ASSERT_EQUAL(5,(int)groups.size());
 827   CPPUNIT_ASSERT(groups[0]=="groupe1");
 828   CPPUNIT_ASSERT(groups[1]=="groupe2");
 829   CPPUNIT_ASSERT(groups[2]=="groupe3");
 830   CPPUNIT_ASSERT(groups[3]=="groupe4");
 831   CPPUNIT_ASSERT(groups[4]=="groupe5");
 832   vector<string> groups2;
 833   groups2.push_back(groups[0]);
 834   mesh=ReadUMeshFromGroups(fileName.c_str(),meshNames[0].c_str(),0,groups2);
 835   CPPUNIT_ASSERT_EQUAL(3,mesh->getSpaceDimension());
 836   CPPUNIT_ASSERT_EQUAL(3,mesh->getMeshDimension());
 837   CPPUNIT_ASSERT_EQUAL(7,mesh->getNumberOfCells());
 838   CPPUNIT_ASSERT_EQUAL(19,mesh->getNumberOfNodes());
 839   CPPUNIT_ASSERT_EQUAL(2,(int)mesh->getAllGeoTypes().size());
 840   for(int i=0;i<6;i++)
 841     CPPUNIT_ASSERT_EQUAL(NORM_TETRA4,mesh->getTypeOfCell(i));
 842   CPPUNIT_ASSERT_EQUAL(NORM_PYRA5,mesh->getTypeOfCell(6));
 843   CPPUNIT_ASSERT_EQUAL((std::size_t)36,mesh->getNodalConnectivity()->getNbOfElems());
 844   CPPUNIT_ASSERT_EQUAL(254,std::accumulate(mesh->getNodalConnectivity()->getPointer(),mesh->getNodalConnectivity()->getPointer()+36,0));
 845   CPPUNIT_ASSERT_EQUAL(141,std::accumulate(mesh->getNodalConnectivityIndex()->getPointer(),mesh->getNodalConnectivityIndex()->getPointer()+8,0));
 846   CPPUNIT_ASSERT_DOUBLES_EQUAL(46.,std::accumulate(mesh->getCoords()->getPointer(),mesh->getCoords()->getPointer()+57,0),1e-12);
 847   mesh->decrRef();
 848   //
 849   std::vector<std::string> fieldsName=GetCellFieldNamesOnMesh(fileName.c_str(),meshNames[0].c_str());
 850   CPPUNIT_ASSERT_EQUAL(2,(int)fieldsName.size());
 851   CPPUNIT_ASSERT(fieldsName[0]=="fieldcelldoublescalar");
 852   CPPUNIT_ASSERT(fieldsName[1]=="fieldcelldoublevector");
 853   std::vector<std::pair<int,int> > its0=GetCellFieldIterations(fileName.c_str(),meshNames[0].c_str(),fieldsName[0].c_str());
 854   CPPUNIT_ASSERT_EQUAL(1,(int)its0.size());
 855   CPPUNIT_ASSERT_EQUAL(-1,its0[0].first);
 856   CPPUNIT_ASSERT_EQUAL(-1,its0[0].second);
 857   std::vector<std::pair<int,int> > its1=GetCellFieldIterations(fileName.c_str(),meshNames[0].c_str(),fieldsName[1].c_str());
 858   CPPUNIT_ASSERT_EQUAL(1,(int)its1.size());
 859   CPPUNIT_ASSERT_EQUAL(-1,its1[0].first);
 860   CPPUNIT_ASSERT_EQUAL(-1,its1[0].second);
 861   //
 862   MEDCouplingFieldDouble *field0=ReadFieldCell(fileName.c_str(),meshNames[0].c_str(),0,fieldsName[0].c_str(),its0[0].first,its0[0].second);
 863   field0->checkConsistencyLight();
 864   CPPUNIT_ASSERT(field0->getName()==fieldsName[0]);
 865   CPPUNIT_ASSERT_EQUAL(1,field0->getNumberOfComponents());
 866   CPPUNIT_ASSERT_EQUAL(16,field0->getNumberOfTuples());
 867   const double expectedValues[16]={1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,2.,3.,3.,2.};
 868   double diffValue[16];
 869   std::transform(field0->getArray()->getPointer(),field0->getArray()->getPointer()+16,expectedValues,diffValue,std::minus<double>());
 870   CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,*std::max_element(diffValue,diffValue+16),1e-12);
 871   CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,*std::min_element(diffValue,diffValue+16),1e-12);
 872   const MEDCouplingUMesh *constMesh=dynamic_cast<const MEDCouplingUMesh *>(field0->getMesh());
 873   CPPUNIT_ASSERT(constMesh);
 874   CPPUNIT_ASSERT_EQUAL(3,constMesh->getSpaceDimension());
 875   CPPUNIT_ASSERT_EQUAL(3,constMesh->getMeshDimension());
 876   CPPUNIT_ASSERT_EQUAL(16,constMesh->getNumberOfCells());
 877   CPPUNIT_ASSERT_EQUAL(19,constMesh->getNumberOfNodes());
 878   CPPUNIT_ASSERT_EQUAL(3,(int)constMesh->getAllGeoTypes().size());
 879   for(int i=0;i<12;i++)
 880     CPPUNIT_ASSERT_EQUAL(NORM_TETRA4,constMesh->getTypeOfCell(i));
 881   CPPUNIT_ASSERT_EQUAL(NORM_PYRA5,constMesh->getTypeOfCell(12));
 882   CPPUNIT_ASSERT_EQUAL(NORM_HEXA8,constMesh->getTypeOfCell(13));
 883   CPPUNIT_ASSERT_EQUAL(NORM_HEXA8,constMesh->getTypeOfCell(14));
 884   CPPUNIT_ASSERT_EQUAL(NORM_PYRA5,constMesh->getTypeOfCell(15));
 885   CPPUNIT_ASSERT_EQUAL((std::size_t)90,constMesh->getNodalConnectivity()->getNbOfElems());
 886   CPPUNIT_ASSERT_EQUAL(701,std::accumulate(constMesh->getNodalConnectivity()->getConstPointer(),constMesh->getNodalConnectivity()->getConstPointer()+90,0));
 887   CPPUNIT_ASSERT_EQUAL(705,std::accumulate(constMesh->getNodalConnectivityIndex()->getConstPointer(),constMesh->getNodalConnectivityIndex()->getConstPointer()+17,0));
 888   CPPUNIT_ASSERT_DOUBLES_EQUAL(46.,std::accumulate(constMesh->getCoords()->getConstPointer(),constMesh->getCoords()->getConstPointer()+57,0),1e-12);
 889   field0->decrRef();
 890   //
 891   MEDCouplingFieldDouble *field1=ReadFieldCell(fileName.c_str(),meshNames[0].c_str(),0,fieldsName[1].c_str(),its1[0].first,its1[0].second);
 892   field1->checkConsistencyLight();
 893   CPPUNIT_ASSERT(field1->getName()==fieldsName[1]);
 894   CPPUNIT_ASSERT_EQUAL(3,field1->getNumberOfComponents());
 895   CPPUNIT_ASSERT_EQUAL(16,field1->getNumberOfTuples());
 896   const double expectedValues2[48]={1.,0.,1.,1.,0.,1.,1.,0.,1.,2.,1.,0.,2.,1.,0.,2.,1.,0.,3.,0.,1.,3.,0.,1.,3.,0.,1.,4.,1.,0.,4.,1.,0.,4.,1.,0.,5.,0.,0.,6.,1.,1.,6.,0.,0.,5.,1.,1.};
 897   double diffValue2[48];
 898   std::transform(field1->getArray()->getPointer(),field1->getArray()->getPointer()+48,expectedValues2,diffValue2,std::minus<double>());
 899   CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,*std::max_element(diffValue2,diffValue2+48),1e-12);
 900   CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,*std::min_element(diffValue2,diffValue2+48),1e-12);
 901   constMesh=dynamic_cast<const MEDCouplingUMesh *>(field1->getMesh());
 902   CPPUNIT_ASSERT(constMesh);
 903   CPPUNIT_ASSERT_EQUAL(3,constMesh->getSpaceDimension());
 904   CPPUNIT_ASSERT_EQUAL(3,constMesh->getMeshDimension());
 905   CPPUNIT_ASSERT_EQUAL(16,constMesh->getNumberOfCells());
 906   CPPUNIT_ASSERT_EQUAL(19,constMesh->getNumberOfNodes());
 907   CPPUNIT_ASSERT_EQUAL(3,(int)constMesh->getAllGeoTypes().size());
 908   for(int i=0;i<12;i++)
 909     CPPUNIT_ASSERT_EQUAL(NORM_TETRA4,constMesh->getTypeOfCell(i));
 910   CPPUNIT_ASSERT_EQUAL(NORM_PYRA5,constMesh->getTypeOfCell(12));
 911   CPPUNIT_ASSERT_EQUAL(NORM_HEXA8,constMesh->getTypeOfCell(13));
 912   CPPUNIT_ASSERT_EQUAL(NORM_HEXA8,constMesh->getTypeOfCell(14));
 913   CPPUNIT_ASSERT_EQUAL(NORM_PYRA5,constMesh->getTypeOfCell(15));
 914   CPPUNIT_ASSERT_EQUAL((std::size_t)90,constMesh->getNodalConnectivity()->getNbOfElems());
 915   CPPUNIT_ASSERT_EQUAL(701,std::accumulate(constMesh->getNodalConnectivity()->getConstPointer(),constMesh->getNodalConnectivity()->getConstPointer()+90,0));
 916   CPPUNIT_ASSERT_EQUAL(705,std::accumulate(constMesh->getNodalConnectivityIndex()->getConstPointer(),constMesh->getNodalConnectivityIndex()->getConstPointer()+17,0));
 917   CPPUNIT_ASSERT_DOUBLES_EQUAL(46.,std::accumulate(constMesh->getCoords()->getConstPointer(),constMesh->getCoords()->getConstPointer()+57,0),1e-12);
 918   field1->decrRef();
 919   //fields on nodes
 920   std::vector<std::string> fieldsNameNode=GetNodeFieldNamesOnMesh(fileName.c_str(),meshNames[0].c_str());
 921   CPPUNIT_ASSERT_EQUAL(2,(int)fieldsNameNode.size());
 922   CPPUNIT_ASSERT(fieldsNameNode[0]=="fieldnodedouble");
 923   CPPUNIT_ASSERT(fieldsNameNode[1]=="fieldnodeint");
 924   std::vector<std::pair<int,int> > its0Node=GetNodeFieldIterations(fileName.c_str(),meshNames[0].c_str(),fieldsNameNode[0].c_str());
 925   CPPUNIT_ASSERT_EQUAL(3,(int)its0Node.size());
 926   CPPUNIT_ASSERT_EQUAL(-1,its0Node[0].first);
 927   CPPUNIT_ASSERT_EQUAL(-1,its0Node[0].second);
 928   CPPUNIT_ASSERT_EQUAL(1,its0Node[1].first);
 929   CPPUNIT_ASSERT_EQUAL(-1,its0Node[1].second);
 930   CPPUNIT_ASSERT_EQUAL(2,its0Node[2].first);
 931   CPPUNIT_ASSERT_EQUAL(-1,its0Node[2].second);
 932   MEDCouplingFieldDouble *field0Nodes=ReadFieldNode(fileName.c_str(),meshNames[0].c_str(),0,fieldsNameNode[0].c_str(),its0Node[0].first,its0Node[0].second);
 933   field0Nodes->checkConsistencyLight();
 934   CPPUNIT_ASSERT(field0Nodes->getName()==fieldsNameNode[0]);
 935   CPPUNIT_ASSERT_EQUAL(1,field0Nodes->getNumberOfComponents());
 936   CPPUNIT_ASSERT_EQUAL(19,field0Nodes->getNumberOfTuples());
 937   const double expectedValues3[19]={1.,1.,1.,2.,2.,2.,3.,3.,3.,4.,4.,4.,5.,5.,5.,6.,6.,6.,7.};
 938   double diffValue3[19];
 939   std::transform(field0Nodes->getArray()->getPointer(),field0Nodes->getArray()->getPointer()+19,expectedValues3,diffValue3,std::minus<double>());
 940   CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,*std::max_element(diffValue3,diffValue3+19),1e-12);
 941   CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,*std::min_element(diffValue3,diffValue3+19),1e-12);
 942   constMesh=dynamic_cast<const MEDCouplingUMesh *>(field0Nodes->getMesh());
 943   CPPUNIT_ASSERT(constMesh);
 944   field0Nodes->decrRef();
 945   //
 946   field0Nodes=ReadFieldNode(fileName.c_str(),meshNames[0].c_str(),0,fieldsNameNode[0].c_str(),its0Node[2].first,its0Node[2].second);
 947   field0Nodes->checkConsistencyLight();
 948   CPPUNIT_ASSERT(field0Nodes->getName()==fieldsNameNode[0]);
 949   CPPUNIT_ASSERT_EQUAL(1,field0Nodes->getNumberOfComponents());
 950   CPPUNIT_ASSERT_EQUAL(19,field0Nodes->getNumberOfTuples());
 951   const double expectedValues4[19]={1.,2.,2.,2.,3.,3.,3.,4.,4.,4.,5.,5.,5.,6.,6.,6.,7.,7.,7.};
 952   std::transform(field0Nodes->getArray()->getPointer(),field0Nodes->getArray()->getPointer()+19,expectedValues4,diffValue3,std::minus<double>());
 953   CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,*std::max_element(diffValue3,diffValue3+19),1e-12);
 954   CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,*std::min_element(diffValue3,diffValue3+19),1e-12);
 955   constMesh=dynamic_cast<const MEDCouplingUMesh *>(field0Nodes->getMesh());
 956   CPPUNIT_ASSERT(constMesh);
 957   CPPUNIT_ASSERT_EQUAL(3,constMesh->getSpaceDimension());
 958   CPPUNIT_ASSERT_EQUAL(3,constMesh->getMeshDimension());
 959   CPPUNIT_ASSERT_EQUAL(16,constMesh->getNumberOfCells());
 960   CPPUNIT_ASSERT_EQUAL(19,constMesh->getNumberOfNodes());
 961   CPPUNIT_ASSERT_EQUAL(3,(int)constMesh->getAllGeoTypes().size());
 962   for(int i=0;i<12;i++)
 963     CPPUNIT_ASSERT_EQUAL(NORM_TETRA4,constMesh->getTypeOfCell(i));
 964   CPPUNIT_ASSERT_EQUAL(NORM_PYRA5,constMesh->getTypeOfCell(12));
 965   CPPUNIT_ASSERT_EQUAL(NORM_HEXA8,constMesh->getTypeOfCell(13));
 966   CPPUNIT_ASSERT_EQUAL(NORM_HEXA8,constMesh->getTypeOfCell(14));
 967   CPPUNIT_ASSERT_EQUAL(NORM_PYRA5,constMesh->getTypeOfCell(15));
 968   CPPUNIT_ASSERT_EQUAL((std::size_t)90,constMesh->getNodalConnectivity()->getNbOfElems());
 969   CPPUNIT_ASSERT_EQUAL(701,std::accumulate(constMesh->getNodalConnectivity()->getConstPointer(),constMesh->getNodalConnectivity()->getConstPointer()+90,0));
 970   CPPUNIT_ASSERT_EQUAL(705,std::accumulate(constMesh->getNodalConnectivityIndex()->getConstPointer(),constMesh->getNodalConnectivityIndex()->getConstPointer()+17,0));
 971   CPPUNIT_ASSERT_DOUBLES_EQUAL(46.,std::accumulate(constMesh->getCoords()->getConstPointer(),constMesh->getCoords()->getConstPointer()+57,0),1e-12);
 972   field0Nodes->decrRef();
 973   //
 974   field0Nodes=ReadFieldNode(fileName.c_str(),meshNames[0].c_str(),0,fieldsNameNode[0].c_str(),its0Node[0].first,its0Node[0].second);
 975   field0Nodes->checkConsistencyLight();
 976   CPPUNIT_ASSERT(field0Nodes->getName()==fieldsNameNode[0]);
 977   CPPUNIT_ASSERT_EQUAL(1,field0Nodes->getNumberOfComponents());
 978   CPPUNIT_ASSERT_EQUAL(19,field0Nodes->getNumberOfTuples());
 979   const double expectedValues5[19]={1.,1.,1.,2.,2.,2.,3.,3.,3.,4.,4.,4.,5.,5.,5.,6.,6.,6.,7.};
 980   std::transform(field0Nodes->getArray()->getPointer(),field0Nodes->getArray()->getPointer()+19,expectedValues5,diffValue3,std::minus<double>());
 981   CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,*std::max_element(diffValue3,diffValue3+19),1e-12);
 982   CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,*std::min_element(diffValue3,diffValue3+19),1e-12);
 983   constMesh=dynamic_cast<const MEDCouplingUMesh *>(field0Nodes->getMesh());
 984   CPPUNIT_ASSERT(constMesh);
 985   CPPUNIT_ASSERT_EQUAL(3,constMesh->getSpaceDimension());
 986   CPPUNIT_ASSERT_EQUAL(3,constMesh->getMeshDimension());
 987   CPPUNIT_ASSERT_EQUAL(16,constMesh->getNumberOfCells());
 988   CPPUNIT_ASSERT_EQUAL(19,constMesh->getNumberOfNodes());
 989   CPPUNIT_ASSERT_EQUAL(3,(int)constMesh->getAllGeoTypes().size());
 990   for(int i=0;i<12;i++)
 991     CPPUNIT_ASSERT_EQUAL(NORM_TETRA4,constMesh->getTypeOfCell(i));
 992   CPPUNIT_ASSERT_EQUAL(NORM_PYRA5,constMesh->getTypeOfCell(12));
 993   CPPUNIT_ASSERT_EQUAL(NORM_HEXA8,constMesh->getTypeOfCell(13));
 994   CPPUNIT_ASSERT_EQUAL(NORM_HEXA8,constMesh->getTypeOfCell(14));
 995   CPPUNIT_ASSERT_EQUAL(NORM_PYRA5,constMesh->getTypeOfCell(15));
 996   CPPUNIT_ASSERT_EQUAL((std::size_t)90,constMesh->getNodalConnectivity()->getNbOfElems());
 997   CPPUNIT_ASSERT_EQUAL(701,std::accumulate(constMesh->getNodalConnectivity()->getConstPointer(),constMesh->getNodalConnectivity()->getConstPointer()+90,0));
 998   CPPUNIT_ASSERT_EQUAL(705,std::accumulate(constMesh->getNodalConnectivityIndex()->getConstPointer(),constMesh->getNodalConnectivityIndex()->getConstPointer()+17,0));
 999   CPPUNIT_ASSERT_DOUBLES_EQUAL(46.,std::accumulate(constMesh->getCoords()->getConstPointer(),constMesh->getCoords()->getConstPointer()+57,0),1e-12);
1000   field0Nodes->decrRef();
1001 }
1002
1003 void MEDLoaderTest::testMEDLoaderPolygonRead()
1004 {
1005   using namespace std;
1006   using namespace INTERP_KERNEL;
1007
1008   string fileName=INTERP_TEST::getResourceFile("polygones.med", 3);
1009   vector<string> meshNames=GetMeshNames(fileName.c_str());
1010   CPPUNIT_ASSERT_EQUAL(1,(int)meshNames.size());
1011   CPPUNIT_ASSERT(meshNames[0]=="Bord");
1012   MEDCouplingUMesh *mesh=ReadUMeshFromFile(fileName.c_str(),meshNames[0].c_str(),0);
1013   mesh->checkConsistencyLight();
1014   CPPUNIT_ASSERT_EQUAL(3,mesh->getSpaceDimension());
1015   CPPUNIT_ASSERT_EQUAL(2,mesh->getMeshDimension());
1016   CPPUNIT_ASSERT_EQUAL(538,mesh->getNumberOfCells());
1017   CPPUNIT_ASSERT_EQUAL(579,mesh->getNumberOfNodes());
1018   CPPUNIT_ASSERT_EQUAL(2,(int)mesh->getAllGeoTypes().size());
1019   for(int i=0;i<514;i++)
1020     CPPUNIT_ASSERT_EQUAL(NORM_QUAD4,mesh->getTypeOfCell(i));
1021   for(int i=514;i<538;i++)
1022     CPPUNIT_ASSERT_EQUAL(NORM_POLYGON,mesh->getTypeOfCell(i));
1023   CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,std::accumulate(mesh->getCoords()->getPointer(),mesh->getCoords()->getPointer()+1737,0),1e-12);
1024   const double expectedVals1[12]={1.4851585216522212,-0.5,0.,1.4851585216522212,-0.4,0.,1.4851585216522212,-0.3,0., 1.5741585216522211, -0.5, 0. };
1025   double diffValue1[12];
1026   std::transform(mesh->getCoords()->getPointer(),mesh->getCoords()->getPointer()+12,expectedVals1,diffValue1,std::minus<double>());
1027   CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,*std::max_element(diffValue1,diffValue1+12),1e-12);
1028   CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,*std::min_element(diffValue1,diffValue1+12),1e-12);
1029   CPPUNIT_ASSERT_EQUAL((std::size_t)2768,mesh->getNodalConnectivity()->getNbOfElems());
1030   CPPUNIT_ASSERT_EQUAL(651050,std::accumulate(mesh->getNodalConnectivity()->getPointer(),mesh->getNodalConnectivity()->getPointer()+2768,0));
1031   CPPUNIT_ASSERT_EQUAL(725943,std::accumulate(mesh->getNodalConnectivityIndex()->getPointer(),mesh->getNodalConnectivityIndex()->getPointer()+539,0));
1032   mesh->decrRef();
1033   //
1034   std::vector<std::string> fieldsName=GetCellFieldNamesOnMesh(fileName.c_str(),meshNames[0].c_str());
1035   CPPUNIT_ASSERT_EQUAL(3,(int)fieldsName.size());
1036   CPPUNIT_ASSERT(fieldsName[0]=="bord_:_distorsion");
1037   CPPUNIT_ASSERT(fieldsName[1]=="bord_:_familles");
1038   CPPUNIT_ASSERT(fieldsName[2]=="bord_:_non-ortho");
1039   std::vector<std::pair<int,int> > its0=GetCellFieldIterations(fileName.c_str(),meshNames[0].c_str(),fieldsName[0].c_str());
1040   CPPUNIT_ASSERT_EQUAL(1,(int)its0.size());
1041   MEDCouplingFieldDouble *field=ReadFieldCell(fileName.c_str(),meshNames[0].c_str(),0,fieldsName[0].c_str(),its0[0].first,its0[0].second);
1042   field->checkConsistencyLight();
1043   CPPUNIT_ASSERT(field->getName()==fieldsName[0]);
1044   CPPUNIT_ASSERT_EQUAL(1,field->getNumberOfComponents());
1045   CPPUNIT_ASSERT_EQUAL(538,field->getNumberOfTuples());
1046   const MEDCouplingUMesh *constMesh=dynamic_cast<const MEDCouplingUMesh *>(field->getMesh());
1047   CPPUNIT_ASSERT(constMesh);
1048   CPPUNIT_ASSERT_EQUAL(3,constMesh->getSpaceDimension());
1049   CPPUNIT_ASSERT_EQUAL(2,constMesh->getMeshDimension());
1050   CPPUNIT_ASSERT_EQUAL(538,constMesh->getNumberOfCells());
1051   CPPUNIT_ASSERT_EQUAL(579,constMesh->getNumberOfNodes());
1052   CPPUNIT_ASSERT_EQUAL(2,(int)constMesh->getAllGeoTypes().size());
1053   for(int i=0;i<514;i++)
1054     CPPUNIT_ASSERT_EQUAL(NORM_QUAD4,constMesh->getTypeOfCell(i));
1055   for(int i=514;i<538;i++)
1056     CPPUNIT_ASSERT_EQUAL(NORM_POLYGON,constMesh->getTypeOfCell(i));
1057   CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,std::accumulate(constMesh->getCoords()->getConstPointer(),constMesh->getCoords()->getConstPointer()+1737,0),1e-12);
1058   std::transform(constMesh->getCoords()->getConstPointer(),constMesh->getCoords()->getConstPointer()+12,expectedVals1,diffValue1,std::minus<double>());
1059   CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,*std::max_element(diffValue1,diffValue1+12),1e-12);
1060   CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,*std::min_element(diffValue1,diffValue1+12),1e-12);
1061   CPPUNIT_ASSERT_EQUAL((std::size_t)2768,constMesh->getNodalConnectivity()->getNbOfElems());
1062   CPPUNIT_ASSERT_EQUAL(651050,std::accumulate(constMesh->getNodalConnectivity()->getConstPointer(),constMesh->getNodalConnectivity()->getConstPointer()+2768,0));
1063   CPPUNIT_ASSERT_EQUAL(725943,std::accumulate(constMesh->getNodalConnectivityIndex()->getConstPointer(),constMesh->getNodalConnectivityIndex()->getConstPointer()+539,0));
1064   const double *values=field->getArray()->getPointer();
1065   CPPUNIT_ASSERT_DOUBLES_EQUAL(2.87214203182918,std::accumulate(values,values+538,0.),1e-12);
1066   field->decrRef();
1067 }
1068
1069 void MEDLoaderTest::testMEDLoaderPolyhedronRead()
1070 {
1071   using namespace std;
1072   using namespace INTERP_KERNEL;
1073
1074   string fileName=INTERP_TEST::getResourceFile("poly3D.med", 3);
1075   vector<string> meshNames=GetMeshNames(fileName.c_str());
1076   CPPUNIT_ASSERT_EQUAL(1,(int)meshNames.size());
1077   CPPUNIT_ASSERT(meshNames[0]=="poly3D");
1078   MEDCouplingUMesh *mesh=ReadUMeshFromFile(fileName.c_str(),meshNames[0].c_str(),0);
1079   mesh->checkConsistencyLight();
1080   CPPUNIT_ASSERT_EQUAL(3,mesh->getSpaceDimension());
1081   CPPUNIT_ASSERT_EQUAL(3,mesh->getMeshDimension());
1082   CPPUNIT_ASSERT_EQUAL(3,mesh->getNumberOfCells());
1083   CPPUNIT_ASSERT_EQUAL(19,mesh->getNumberOfNodes());
1084   CPPUNIT_ASSERT_EQUAL(2,(int)mesh->getAllGeoTypes().size());
1085   CPPUNIT_ASSERT_EQUAL(NORM_TETRA4,mesh->getTypeOfCell(0));
1086   CPPUNIT_ASSERT_EQUAL(NORM_POLYHED,mesh->getTypeOfCell(1));
1087   CPPUNIT_ASSERT_EQUAL(NORM_POLYHED,mesh->getTypeOfCell(2));
1088   CPPUNIT_ASSERT_EQUAL((std::size_t)98,mesh->getNodalConnectivity()->getNbOfElems());
1089   CPPUNIT_ASSERT_EQUAL(725,std::accumulate(mesh->getNodalConnectivity()->getPointer(),mesh->getNodalConnectivity()->getPointer()+98,0));
1090   CPPUNIT_ASSERT_DOUBLES_EQUAL(110.,std::accumulate(mesh->getCoords()->getPointer(),mesh->getCoords()->getPointer()+57,0),1e-12);
1091   CPPUNIT_ASSERT_EQUAL(155,std::accumulate(mesh->getNodalConnectivityIndex()->getPointer(),mesh->getNodalConnectivityIndex()->getPointer()+4,0));
1092   mesh->decrRef();
1093   //
1094   mesh=ReadUMeshFromFile(fileName.c_str(),meshNames[0].c_str(),-1);
1095   mesh->checkConsistencyLight();
1096   CPPUNIT_ASSERT_EQUAL(3,mesh->getSpaceDimension());
1097   CPPUNIT_ASSERT_EQUAL(2,mesh->getMeshDimension());
1098   CPPUNIT_ASSERT_EQUAL(17,mesh->getNumberOfCells());
1099   CPPUNIT_ASSERT_EQUAL(19,mesh->getNumberOfNodes());
1100   CPPUNIT_ASSERT_EQUAL(3,(int)mesh->getAllGeoTypes().size());
1101   CPPUNIT_ASSERT_EQUAL(NORM_POLYGON,mesh->getTypeOfCell(0));
1102   CPPUNIT_ASSERT_EQUAL(NORM_QUAD4,mesh->getTypeOfCell(1));
1103   CPPUNIT_ASSERT_EQUAL(NORM_QUAD4,mesh->getTypeOfCell(2));
1104   CPPUNIT_ASSERT_EQUAL(NORM_QUAD4,mesh->getTypeOfCell(3));
1105   CPPUNIT_ASSERT_EQUAL(NORM_QUAD4,mesh->getTypeOfCell(4));
1106   CPPUNIT_ASSERT_EQUAL(NORM_QUAD4,mesh->getTypeOfCell(5));
1107   CPPUNIT_ASSERT_EQUAL(NORM_QUAD4,mesh->getTypeOfCell(6));
1108   CPPUNIT_ASSERT_EQUAL(NORM_TRI3,mesh->getTypeOfCell(7));
1109   CPPUNIT_ASSERT_EQUAL(NORM_POLYGON,mesh->getTypeOfCell(8));
1110   CPPUNIT_ASSERT_EQUAL(NORM_POLYGON,mesh->getTypeOfCell(9));
1111   CPPUNIT_ASSERT_EQUAL(NORM_QUAD4,mesh->getTypeOfCell(10));
1112   CPPUNIT_ASSERT_EQUAL(NORM_TRI3,mesh->getTypeOfCell(11));
1113   CPPUNIT_ASSERT_EQUAL(NORM_TRI3,mesh->getTypeOfCell(12));
1114   CPPUNIT_ASSERT_EQUAL(NORM_TRI3,mesh->getTypeOfCell(13));
1115   CPPUNIT_ASSERT_EQUAL(NORM_TRI3,mesh->getTypeOfCell(14));
1116   CPPUNIT_ASSERT_EQUAL(NORM_QUAD4,mesh->getTypeOfCell(15));
1117   CPPUNIT_ASSERT_EQUAL(NORM_TRI3,mesh->getTypeOfCell(16));
1118   CPPUNIT_ASSERT_DOUBLES_EQUAL(110.,std::accumulate(mesh->getCoords()->getPointer(),mesh->getCoords()->getPointer()+57,0),1e-12);
1119   CPPUNIT_ASSERT_EQUAL((std::size_t)83,mesh->getNodalConnectivity()->getNbOfElems());
1120   CPPUNIT_ASSERT_EQUAL(619,std::accumulate(mesh->getNodalConnectivity()->getPointer(),mesh->getNodalConnectivity()->getPointer()+83,0));
1121   mesh->decrRef();
1122   //
1123   vector<string> families=GetMeshFamiliesNames(fileName.c_str(),meshNames[0].c_str());
1124   CPPUNIT_ASSERT_EQUAL(4,(int)families.size());
1125   CPPUNIT_ASSERT(families[0]=="FAMILLE_FACE_POLYGONS3");
1126   CPPUNIT_ASSERT(families[1]=="FAMILLE_FACE_QUAD41");
1127   CPPUNIT_ASSERT(families[2]=="FAMILLE_FACE_TRIA32");
1128   CPPUNIT_ASSERT(families[3]=="FAMILLE_ZERO");
1129   vector<string> families2;
1130   families2.push_back(families[0]);
1131   mesh=ReadUMeshFromFamilies(fileName.c_str(),meshNames[0].c_str(),-1,families2);
1132   mesh->checkConsistencyLight();
1133   CPPUNIT_ASSERT_EQUAL(3,mesh->getSpaceDimension());
1134   CPPUNIT_ASSERT_EQUAL(2,mesh->getMeshDimension());
1135   CPPUNIT_ASSERT_EQUAL(3,mesh->getNumberOfCells());
1136   CPPUNIT_ASSERT_EQUAL(19,mesh->getNumberOfNodes());
1137   CPPUNIT_ASSERT_EQUAL(1,(int)mesh->getAllGeoTypes().size());
1138   for(int i=0;i<3;i++)
1139     CPPUNIT_ASSERT_EQUAL(NORM_POLYGON,mesh->getTypeOfCell(i));
1140   CPPUNIT_ASSERT_EQUAL((std::size_t)19,mesh->getNodalConnectivity()->getNbOfElems());
1141   CPPUNIT_ASSERT_EQUAL(117,std::accumulate(mesh->getNodalConnectivity()->getPointer(),mesh->getNodalConnectivity()->getPointer()+19,0));
1142   mesh->decrRef();
1143   //
1144   mesh=ReadUMeshFromFamilies(fileName.c_str(),meshNames[0].c_str(),0,families2);
1145   CPPUNIT_ASSERT_EQUAL(3,mesh->getSpaceDimension());
1146   CPPUNIT_ASSERT_EQUAL(0,mesh->getNumberOfCells());
1147   CPPUNIT_ASSERT_EQUAL(19,mesh->getNumberOfNodes());
1148   CPPUNIT_ASSERT_EQUAL(3,mesh->getMeshDimension());
1149   CPPUNIT_ASSERT_EQUAL(0,(int)mesh->getAllGeoTypes().size());
1150   mesh->decrRef();
1151 }
1152
1153 MEDCouplingUMesh *MEDLoaderTest::build1DMesh_1()
1154 {
1155   double coords[6]={ 0.0, 0.3, 0.75, 1.0, 1.4, 1.3 };
1156   int conn[9]={ 0,1, 1,2, 2,3 , 3,4,5};
1157   MEDCouplingUMesh *mesh=MEDCouplingUMesh::New();
1158   mesh->setName("1DMesh_1");
1159   mesh->setMeshDimension(1);
1160   mesh->allocateCells(4);
1161   mesh->insertNextCell(INTERP_KERNEL::NORM_SEG2,2,conn);
1162   mesh->insertNextCell(INTERP_KERNEL::NORM_SEG2,2,conn+2);
1163   mesh->insertNextCell(INTERP_KERNEL::NORM_SEG2,2,conn+4);
1164   mesh->insertNextCell(INTERP_KERNEL::NORM_SEG3,3,conn+6);
1165   mesh->finishInsertingCells();
1166   DataArrayDouble *myCoords=DataArrayDouble::New();
1167   myCoords->alloc(6,1);
1168   myCoords->setInfoOnComponent(0,"tototototototot [m*m*m*m*m*m*m*m]");
1169   std::copy(coords,coords+6,myCoords->getPointer());
1170   mesh->setCoords(myCoords);
1171   myCoords->decrRef();
1172   return mesh;
1173 }
1174
1175 MEDCouplingUMesh *MEDLoaderTest::build2DCurveMesh_1()
1176 {
1177   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 };
1178   int conn[9]={ 0,1, 1,2, 2,3 , 3,4,5};
1179   MEDCouplingUMesh *mesh=MEDCouplingUMesh::New();
1180   mesh->setName("2DCurveMesh_1");
1181   mesh->setMeshDimension(1);
1182   mesh->allocateCells(4);
1183   mesh->insertNextCell(INTERP_KERNEL::NORM_SEG2,2,conn);
1184   mesh->insertNextCell(INTERP_KERNEL::NORM_SEG2,2,conn+2);
1185   mesh->insertNextCell(INTERP_KERNEL::NORM_SEG2,2,conn+4);
1186   mesh->insertNextCell(INTERP_KERNEL::NORM_SEG3,3,conn+6);
1187   mesh->finishInsertingCells();
1188   DataArrayDouble *myCoords=DataArrayDouble::New();
1189   myCoords->alloc(6,2);
1190   std::copy(coords,coords+12,myCoords->getPointer());
1191   mesh->setCoords(myCoords);
1192   myCoords->decrRef();
1193   return mesh;
1194 }
1195
1196 MEDCouplingUMesh *MEDLoaderTest::build2DMesh_1()
1197 {
1198   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 };
1199   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};
1200   MEDCouplingUMesh *targetMesh=MEDCouplingUMesh::New();
1201   targetMesh->setMeshDimension(2);
1202   targetMesh->allocateCells(6);
1203   targetMesh->setName("2DMesh_1");
1204   targetMesh->insertNextCell(INTERP_KERNEL::NORM_TRI3,3,targetConn);
1205   targetMesh->insertNextCell(INTERP_KERNEL::NORM_TRI3,3,targetConn+3);
1206   targetMesh->insertNextCell(INTERP_KERNEL::NORM_TRI6,6,targetConn+6);
1207   targetMesh->insertNextCell(INTERP_KERNEL::NORM_QUAD4,4,targetConn+12);
1208   targetMesh->insertNextCell(INTERP_KERNEL::NORM_QUAD4,4,targetConn+16);
1209   targetMesh->insertNextCell(INTERP_KERNEL::NORM_POLYGON,4,targetConn+20);
1210   targetMesh->finishInsertingCells();
1211   DataArrayDouble *myCoords=DataArrayDouble::New();
1212   myCoords->alloc(12,2);
1213   myCoords->setInfoOnComponent(0,"tototototototot [m]");
1214   myCoords->setInfoOnComponent(1,"energie [kW]");
1215   std::copy(targetCoords,targetCoords+24,myCoords->getPointer());
1216   targetMesh->setCoords(myCoords);
1217   myCoords->decrRef();
1218   return targetMesh;
1219 }
1220
1221 MEDCouplingUMesh *MEDLoaderTest::build2DMesh_2()
1222 {
1223   double targetCoords[24]={
1224     -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,
1225     -0.05,0.95, 0.2,1.2, 0.45,0.95
1226   };
1227   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};
1228   MEDCouplingUMesh *targetMesh=MEDCouplingUMesh::New();
1229   targetMesh->setMeshDimension(2);
1230   targetMesh->allocateCells(5);
1231   targetMesh->setName("2DMesh_2");
1232   targetMesh->insertNextCell(INTERP_KERNEL::NORM_TRI3,3,targetConn);
1233   targetMesh->insertNextCell(INTERP_KERNEL::NORM_TRI3,3,targetConn+3);
1234   targetMesh->insertNextCell(INTERP_KERNEL::NORM_QUAD4,4,targetConn+12);
1235   targetMesh->insertNextCell(INTERP_KERNEL::NORM_QUAD4,4,targetConn+16);
1236   targetMesh->insertNextCell(INTERP_KERNEL::NORM_TRI6,6,targetConn+6);
1237   targetMesh->finishInsertingCells();
1238   DataArrayDouble *myCoords=DataArrayDouble::New();
1239   myCoords->alloc(12,2);
1240   myCoords->setInfoOnComponent(0,"toto [m]");
1241   myCoords->setInfoOnComponent(1,"energie [kW]");
1242   std::copy(targetCoords,targetCoords+24,myCoords->getPointer());
1243   targetMesh->setCoords(myCoords);
1244   myCoords->decrRef();
1245   return targetMesh;
1246 }
1247
1248 MEDCouplingUMesh *MEDLoaderTest::build3DSurfMesh_1()
1249 {
1250   double targetCoords[36]={
1251     -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
1252     ,-0.05,0.95,-0.3, 0.2,1.2,-0.3, 0.45,0.95,-0.3
1253   };
1254   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};
1255   MEDCouplingUMesh *targetMesh=MEDCouplingUMesh::New();
1256   targetMesh->setMeshDimension(2);
1257   targetMesh->allocateCells(6);
1258   targetMesh->setName("3DSurfMesh_1");
1259   targetMesh->insertNextCell(INTERP_KERNEL::NORM_TRI3,3,targetConn);
1260   targetMesh->insertNextCell(INTERP_KERNEL::NORM_TRI3,3,targetConn+3);
1261   targetMesh->insertNextCell(INTERP_KERNEL::NORM_QUAD4,4,targetConn+12);
1262   targetMesh->insertNextCell(INTERP_KERNEL::NORM_QUAD4,4,targetConn+16);
1263   targetMesh->insertNextCell(INTERP_KERNEL::NORM_TRI6,6,targetConn+6);
1264   targetMesh->insertNextCell(INTERP_KERNEL::NORM_POLYGON,4,targetConn+20);
1265   targetMesh->finishInsertingCells();
1266   DataArrayDouble *myCoords=DataArrayDouble::New();
1267   myCoords->alloc(12,3);
1268   myCoords->setInfoOnComponent(0,"toto [m]");
1269   myCoords->setInfoOnComponent(2,"ff [km]");//component 1 is not set for test
1270   std::copy(targetCoords,targetCoords+36,myCoords->getPointer());
1271   targetMesh->setCoords(myCoords);
1272   myCoords->decrRef();
1273   return targetMesh;
1274 }
1275
1276 MEDCouplingUMesh *MEDLoaderTest::build3DMesh_1()
1277 {
1278   double coords[180]={
1279     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.,
1280     3.,2.,0., 0.,1.,0., 1.,3.,0., 2.,2.,0., 2.,3.,0.,
1281     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.,
1282     3.,2.,1., 0.,1.,1., 1.,3.,1., 2.,2.,1., 2.,3.,1.,
1283     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.,
1284     3.,2.,2., 0.,1.,2., 1.,3.,2., 2.,2.,2., 2.,3.,2.,
1285     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.,
1286     3.,2.,3., 0.,1.,3., 1.,3.,3., 2.,2.,3., 2.,3.,3.};
1287
1288   int conn[354]={
1289     // 0
1290     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,
1291     1,6,5,3,16,21,20,18,   13,10,9,6,28,25,24,21,
1292     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,
1293     7,12,14,13,22,27,29,28,
1294     // 1
1295     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,
1296     16,21,20,18,31,36,35,33,   28,25,24,21,43,40,39,36,
1297     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,
1298     22,27,29,28,37,42,44,43,
1299     // 2
1300     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,
1301     31,36,35,33,46,51,50,48,  43,40,39,36,58,55,54,51,
1302     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,
1303     37,42,44,43,52,57,59,58
1304   };
1305   //
1306   MEDCouplingUMesh *ret=MEDCouplingUMesh::New();
1307   ret->setName("3DMesh_1");
1308   ret->setMeshDimension(3);
1309   ret->allocateCells(18);
1310   //
1311   ret->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn);
1312   ret->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn+51);
1313   ret->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn+59);
1314   ret->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn+110);
1315   //
1316   ret->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn+118);
1317   ret->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn+169);
1318   ret->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn+177);
1319   ret->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn+228);
1320   //
1321   ret->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn+236);
1322   ret->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn+287);
1323   ret->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn+295);
1324   ret->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn+346);
1325   //
1326   ret->insertNextCell(INTERP_KERNEL::NORM_POLYHED,43,conn+8);
1327   ret->insertNextCell(INTERP_KERNEL::NORM_POLYHED,43,conn+67);
1328   ret->insertNextCell(INTERP_KERNEL::NORM_POLYHED,43,conn+126);
1329   ret->insertNextCell(INTERP_KERNEL::NORM_POLYHED,43,conn+185);
1330   ret->insertNextCell(INTERP_KERNEL::NORM_POLYHED,43,conn+244);
1331   ret->insertNextCell(INTERP_KERNEL::NORM_POLYHED,43,conn+303);
1332   //
1333   ret->finishInsertingCells();
1334   DataArrayDouble *myCoords=DataArrayDouble::New();
1335   myCoords->alloc(60,3);
1336   myCoords->setInfoOnComponent(0,"titi [m]");
1337   myCoords->setInfoOnComponent(1,"density power [MW/m^3]");
1338   myCoords->setInfoOnComponent(2,"t [kW]");
1339   std::copy(coords,coords+180,myCoords->getPointer());
1340   ret->setCoords(myCoords);
1341   myCoords->decrRef();
1342   return ret;
1343 }
1344
1345 MEDCouplingUMesh *MEDLoaderTest::build3DMesh_2()
1346 {
1347   MEDCouplingUMesh *m3dsurfBase=build3DSurfMesh_1();
1348   int numbers[5]={0,1,2,3,5};
1349   MEDCouplingUMesh *m3dsurf=(MEDCouplingUMesh *)m3dsurfBase->buildPartOfMySelf(numbers,numbers+5,false);
1350   m3dsurfBase->decrRef();
1351   MEDCouplingUMesh *m1dBase=build1DMesh_1();
1352   int numbers2[4]={0,1,2,3};
1353   MEDCouplingUMesh *m1d=(MEDCouplingUMesh *)m1dBase->buildPartOfMySelf(numbers2,numbers2+4,false);
1354   m1dBase->decrRef();
1355   m1d->changeSpaceDimension(3);
1356   const double vec[3]={0.,1.,0.};
1357   const double pt[3]={0.,0.,0.};
1358   m1d->rotate(pt,vec,-M_PI/2.);
1359   MEDCouplingUMesh *ret=m3dsurf->buildExtrudedMesh(m1d,0);
1360   m1d->decrRef();
1361   m3dsurf->decrRef();
1362   return ret;
1363 }
1364
1365 MEDCouplingFieldDouble *MEDLoaderTest::buildVecFieldOnCells_1()
1366 {
1367   MEDCouplingUMesh *mesh=build3DSurfMesh_1();
1368   int nbOfCells=mesh->getNumberOfCells();
1369   MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
1370   f1->setName("VectorFieldOnCells");
1371   f1->setMesh(mesh);
1372   DataArrayDouble *array=DataArrayDouble::New();
1373   array->alloc(nbOfCells,3);
1374   array->setInfoOnComponent(0,"power [MW/m^3]");
1375   array->setInfoOnComponent(1,"density [g/cm^3]");
1376   array->setInfoOnComponent(2,"temperature [K]");
1377   f1->setArray(array);
1378   array->decrRef();
1379   double *tmp=array->getPointer();
1380   const double arr1[18]={0.,10.,20.,1.,11.,21.,2.,12.,22.,3.,13.,23.,4.,14.,24.,5.,15.,25.};
1381   std::copy(arr1,arr1+18,tmp);
1382   f1->setTime(2.,0,1);
1383   f1->checkConsistencyLight();
1384   mesh->decrRef();
1385   return f1;
1386 }
1387
1388 MEDCouplingFieldDouble *MEDLoaderTest::buildVecFieldOnNodes_1()
1389 {
1390   MEDCouplingUMesh *mesh=build3DSurfMesh_1();
1391   int nbOfNodes=mesh->getNumberOfNodes();
1392   MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_NODES,ONE_TIME);
1393   f1->setName("VectorFieldOnNodes");
1394   f1->setMesh(mesh);
1395   DataArrayDouble *array=DataArrayDouble::New();
1396   array->alloc(nbOfNodes,3);
1397   f1->setArray(array);
1398   array->setInfoOnComponent(0,"power [MW/m^3]");
1399   array->setInfoOnComponent(1,"density [g/cm^3]");
1400   array->setInfoOnComponent(2,"temperature [K]");
1401   array->decrRef();
1402   double *tmp=array->getPointer();
1403   const double arr1[36]={
1404     70.,80.,90.,71.,81.,91.,72.,82.,92.,73.,83.,93.,74.,84.,94.,75.,85.,95.,
1405     1000.,10010.,10020.,1001.,10011.,10021.,1002.,10012.,10022.,1003.,10013.,10023.,1004.,10014.,10024.,1005.,10015.,10025.,
1406   };
1407   std::copy(arr1,arr1+36,tmp);
1408   f1->setTime(2.12,2,3);
1409   f1->checkConsistencyLight();
1410   mesh->decrRef();
1411   return f1;
1412 }
1413
1414 MEDCouplingFieldDouble *MEDLoaderTest::buildVecFieldOnGauss_1()
1415 {
1416   const double _a=0.446948490915965;
1417   const double _b=0.091576213509771;
1418   const double _p1=0.11169079483905;
1419   const double _p2=0.0549758718227661;
1420   const double refCoo1[6]={ 0.,0., 1.,0., 0.,1. };
1421   const double gsCoo1[12]={ 2*_b-1, 1-4*_b, 2*_b-1, 2.07*_b-1, 1-4*_b,
1422                             2*_b-1, 1-4*_a, 2*_a-1, 2*_a-1, 1-4*_a, 2*_a-1, 2*_a-1 };
1423   const double wg1[6]={ 4*_p2, 4*_p2, 4*_p2, 4*_p1, 4*_p1, 4*_p1 };
1424   std::vector<double> _refCoo1(refCoo1,refCoo1+6);
1425   std::vector<double> _gsCoo1(gsCoo1,gsCoo1+12);
1426   std::vector<double> _wg1(wg1,wg1+6);
1427   MEDCouplingUMesh *m=build2DMesh_2();
1428   MEDCouplingFieldDouble *f=MEDCouplingFieldDouble::New(ON_GAUSS_PT,ONE_TIME);
1429   f->setTime(3.14,1,5);
1430   f->setMesh(m);
1431   f->setGaussLocalizationOnType(INTERP_KERNEL::NORM_TRI3,_refCoo1,_gsCoo1,_wg1);
1432   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 };
1433   std::vector<double> _refCoo2(refCoo2,refCoo2+12);
1434   std::vector<double> _gsCoo2(_gsCoo1);
1435   std::vector<double> _wg2(_wg1);
1436   _gsCoo2.resize(6); _wg2.resize(3);
1437   const double refCoo3[8]={ 0.,0., 1.,0., 1.,1., 0.,1. };
1438   std::vector<double> _refCoo3(refCoo3,refCoo3+8);
1439   _gsCoo1.resize(4); _wg1.resize(2);
1440   f->setGaussLocalizationOnType(INTERP_KERNEL::NORM_QUAD4,_refCoo3,_gsCoo1,_wg1);
1441   f->setGaussLocalizationOnType(INTERP_KERNEL::NORM_TRI6,_refCoo2,_gsCoo2,_wg2);
1442   DataArrayDouble *array=DataArrayDouble::New();
1443   array->alloc(19,2);
1444   double *ptr=array->getPointer();
1445   for(int i=0;i<19*2;i++)
1446     ptr[i]=(double)(i+7);
1447   f->setArray(array);
1448   f->setName("MyFirstFieldOnGaussPoint");
1449   array->setInfoOnComponent(0,"power [MW/m^3]");
1450   array->setInfoOnComponent(1,"density");
1451   array->decrRef();
1452   f->checkConsistencyLight();
1453   m->decrRef();
1454   return f;
1455 }
1456
1457 MEDCouplingFieldDouble *MEDLoaderTest::buildVecFieldOnGaussNE_1()
1458 {
1459   MEDCouplingUMesh *m=build2DMesh_2();
1460   MEDCouplingFieldDouble *f=MEDCouplingFieldDouble::New(ON_GAUSS_NE,ONE_TIME);
1461   f->setTime(3.14,1,5);
1462   f->setMesh(m);
1463   DataArrayDouble *array=DataArrayDouble::New();
1464   array->alloc(20,2);
1465   double *ptr=array->getPointer();
1466   for(int i=0;i<20*2;i++)
1467     ptr[i]=(double)(i+8);
1468   f->setArray(array);
1469   array->setInfoOnComponent(0,"power [W]");
1470   array->setInfoOnComponent(1,"temperature");
1471   f->setName("MyFieldOnGaussNE");
1472   array->decrRef();
1473   f->checkConsistencyLight();
1474   m->decrRef();
1475   return f;
1476 }
1477
1478
1479