1 // Copyright (C) 2007-2016 CEA/DEN, EDF R&D
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.
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.
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
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
19 // Author : Anthony Geay (CEA/DEN)
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()
32 using namespace MEDCoupling;
34 void MEDLoaderTest::testMesh1DRW()
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));
45 void MEDLoaderTest::testMesh2DCurveRW()
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));
56 void MEDLoaderTest::testMesh2DRW()
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));
67 void MEDLoaderTest::testMesh3DSurfRW()
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));
78 void MEDLoaderTest::testMesh3DRW()
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));
90 * Most basic test : one and only one MEDCoupling field in a new file.
92 void MEDLoaderTest::testFieldRW1()
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));
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);
113 * Multi field writing in a same file.
115 void MEDLoaderTest::testFieldRW2()
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();
125 WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
126 f1->setTime(10.14,18,19);
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);
133 CPPUNIT_ASSERT(f1->isEqual(f2,1e-12,1e-12));
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));
140 f2=ReadFieldCell(fileName,f1->getMesh()->getName().c_str(),0,f1->getName().c_str(),18,19);
141 f1->setTime(10.14,18,19);
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);
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();
155 WriteFieldUsingAlreadyWrittenMesh(fileName2,f1);
156 f1->setTime(210.,208,209);
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);
162 CPPUNIT_ASSERT(f1->isEqual(f2,1e-12,1e-12));
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));
169 f2=ReadFieldNode(fileName2,f1->getMesh()->getName().c_str(),0,f1->getName().c_str(),208,209);
170 f1->setTime(210.,208,209);
172 CPPUNIT_ASSERT(f1->isEqual(f2,1e-12,1e-12));
178 * Multi field in a same file, but this field has several
180 void MEDLoaderTest::testFieldRW3()
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);
190 f1->setTime(10.,8,9);
191 double *tmp=f1->getArray()->getPointer();
193 WriteField(fileName,f1,true);
194 f1->setTime(10.14,18,19);
196 WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
197 f1->setTime(10.55,28,29);
199 WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
200 f1->setTime(10.66,38,39);
202 WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
203 f1->setTime(10.77,48,49);
205 WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
208 f1=buildVecFieldOnNodes_1();
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();
216 WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
217 f1->setTime(210.,208,209);
219 WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
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);
236 f1=ReadFieldCell(fileName,name3,0,name1,8,9);
237 CPPUNIT_ASSERT_DOUBLES_EQUAL(VAL1,f1->getArray()->getConstPointer()[0],1e-13);
239 f1=ReadFieldCell(fileName,name3,0,name1,18,19);
240 CPPUNIT_ASSERT_DOUBLES_EQUAL(VAL2,f1->getArray()->getConstPointer()[0],1e-13);
242 f1=ReadFieldCell(fileName,name3,0,name1,28,29);
243 CPPUNIT_ASSERT_DOUBLES_EQUAL(3*VAL1,f1->getArray()->getConstPointer()[0],1e-13);
245 f1=ReadFieldCell(fileName,name3,0,name1,38,39);
246 CPPUNIT_ASSERT_DOUBLES_EQUAL(3*VAL2,f1->getArray()->getConstPointer()[0],1e-13);
248 f1=ReadFieldCell(fileName,name3,0,name1,48,49);
249 CPPUNIT_ASSERT_DOUBLES_EQUAL(4*VAL2,f1->getArray()->getConstPointer()[0],1e-13);
252 f1=ReadFieldNode(fileName,name3,0,name1,8,9);
253 CPPUNIT_ASSERT_DOUBLES_EQUAL(71.,f1->getArray()->getConstPointer()[3],1e-13);
255 f1=ReadFieldNode(fileName,name3,0,name1,108,109);
256 CPPUNIT_ASSERT_DOUBLES_EQUAL(VAL1,f1->getArray()->getConstPointer()[3],1e-13);
258 f1=ReadFieldNode(fileName,name3,0,name1,208,209);
259 CPPUNIT_ASSERT_DOUBLES_EQUAL(VAL2,f1->getArray()->getConstPointer()[3],1e-13);
263 void MEDLoaderTest::testMultiMeshRW1()
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);
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);
295 CPPUNIT_ASSERT(mesh6->isEqual(mesh1,1e-12));
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());
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));
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));
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));
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));
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));
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);
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");
350 void MEDLoaderTest::testFieldProfilRW1()
352 const char fileName[]="file12.med";
353 MEDCouplingUMesh *mesh1=build3DMesh_1();
356 DataArrayInt *da=mesh1->mergeNodes(1e-12,b,newNbOfNodes);
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
363 int nbOfCells=mesh2->getNumberOfCells();
364 CPPUNIT_ASSERT_EQUAL(5,nbOfCells);
365 MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
366 f1->setName("VectorFieldOnCells");
368 DataArrayDouble *array=DataArrayDouble::New();
369 array->alloc(nbOfCells,2);
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();
378 WriteField(fileName,f1,false);//<- false important for the test
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));
394 * Test MED file profiles.
396 void MEDLoaderTest::testFieldNodeProfilRW1()
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");
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());
411 array->setInfoOnComponent(0,"tyty [mm]");
412 array->setInfoOnComponent(1,"uiop [MW]");
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
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));
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));
440 void MEDLoaderTest::testFieldNodeProfilRW2()
442 const char fileName[]="file23.med";
443 MEDCouplingUMesh *mesh=build3DSurfMesh_1();
444 WriteUMesh(fileName,mesh,true);
446 MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_NODES,ONE_TIME);
447 f1->setName("FieldMix");
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.
453 DataArrayDouble *array=DataArrayDouble::New();
456 array->setInfoOnComponent(0,"plkj [mm]");
457 array->setInfoOnComponent(1,"pqqqss [mm]");
459 double *tmp=array->getPointer();
460 std::copy(arr2,arr2+24,tmp);
461 f1->setTime(3.17,2,7);
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));
475 void MEDLoaderTest::testFieldGaussRW1()
477 const char fileName[]="file13.med";
478 MEDCouplingFieldDouble *f1=buildVecFieldOnGauss_1();
479 WriteField(fileName,f1,true);
480 MCAuto<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));
485 void MEDLoaderTest::testFieldGaussNERW1()
487 const char fileName[]="file14.med";
488 MEDCouplingFieldDouble *f1=buildVecFieldOnGaussNE_1();
489 WriteField(fileName,f1,true);
490 std::vector<MEDCoupling::TypeOfField> tof(GetTypesOfField(fileName,"2DMesh_2","MyFieldOnGaussNE"));
491 CPPUNIT_ASSERT_EQUAL(1,(int)tof.size());
492 CPPUNIT_ASSERT(ON_GAUSS_NE==tof[0]);
493 MCAuto<MEDCouplingFieldDouble> f2(ReadField(ON_GAUSS_NE,fileName,f1->getMesh()->getName().c_str(),0,f1->getName().c_str(),1,5));
494 CPPUNIT_ASSERT(f1->isEqual(f2,1e-12,1e-12));
498 void MEDLoaderTest::testLittleStrings1()
500 std::string s("azeeeerrrtty");
501 MEDLoaderBase::zipEqualConsChar(s,3);
502 CPPUNIT_ASSERT(s=="azertty");
505 void MEDLoaderTest::testSplitIntoNameAndUnit1()
507 std::string s(" []");
509 MEDLoaderBase::splitIntoNameAndUnit(s,c,u);
510 CPPUNIT_ASSERT(c.empty());
511 CPPUNIT_ASSERT(u.empty());
513 MEDLoaderBase::strip(s);
514 CPPUNIT_ASSERT(s=="lmmm kki jjj");
516 MEDLoaderBase::strip(s);
517 CPPUNIT_ASSERT(s.empty());
519 MEDLoaderBase::strip(s);
520 CPPUNIT_ASSERT(s.empty());
522 MEDLoaderBase::strip(s);
523 CPPUNIT_ASSERT(s.empty());
525 MEDLoaderBase::strip(s);
526 CPPUNIT_ASSERT(s=="pp");
529 void MEDLoaderTest::testMesh3DSurfShuffleRW()
531 const char fileName[]="file15.med";
532 MEDCouplingUMesh *mesh=build3DSurfMesh_1();
533 const int renumber1[6]={2,5,1,0,3,4};
534 mesh->renumberCells(renumber1,false);
535 mesh->checkConsistencyLight();
536 WriteUMesh(fileName,mesh,true);
537 MEDCouplingUMesh *mesh_rw=ReadUMeshFromFile(fileName,mesh->getName().c_str(),0);
538 CPPUNIT_ASSERT(mesh->isEqual(mesh_rw,1e-12));
543 void MEDLoaderTest::testFieldShuffleRW1()
545 const char fileName[]="file16.med";
546 MEDCouplingUMesh *mesh=build3DSurfMesh_1();
547 MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
548 f1->setName("FieldOnCellsShuffle");
550 DataArrayDouble *array=DataArrayDouble::New();
554 double *tmp=array->getPointer();
555 const double arr1[12]={71.,171.,10.,110.,20.,120.,30.,130.,40.,140.,50.,150.};
556 std::copy(arr1,arr1+12,tmp);
557 f1->setTime(3.14,2,7);
558 f1->checkConsistencyLight();
560 const int renumber1[6]={2,1,5,0,3,4};
561 f1->renumberCells(renumber1,false);
562 WriteField(fileName,f1,true);
563 MEDCouplingFieldDouble *f2=ReadFieldCell(fileName,mesh->getName().c_str(),0,f1->getName().c_str(),2,7);
564 CPPUNIT_ASSERT(f2->isEqual(f1,1e-12,1e-12));
572 * Shuffle de cells but no profile. Like pointe.med
574 void MEDLoaderTest::testMultiFieldShuffleRW1()
576 const char fileName[]="file17.med";
577 MEDCouplingUMesh *m=build3DMesh_2();
578 CPPUNIT_ASSERT_EQUAL(20,m->getNumberOfCells());
579 CPPUNIT_ASSERT_EQUAL(45,m->getNumberOfNodes());
580 const int polys[3]={1,4,6};
581 std::vector<int> poly2(polys,polys+3);
582 m->convertToPolyTypes(&poly2[0],&poly2[0]+poly2.size());
583 const int renum[20]={1,3,2,8,9,12,13,16,19,0,4,7,5,15,14,17,10,18,6,11};
584 m->renumberCells(renum,false);
585 m->orientCorrectlyPolyhedrons();
587 WriteUMesh(fileName,m,true);
588 MEDCouplingFieldDouble *f1Tmp=m->getMeasureField(false);
589 MEDCouplingFieldDouble *f1=f1Tmp->buildNewTimeReprFromThis(ONE_TIME,false);
592 MEDCouplingFieldDouble *f_1=f1->cloneWithMesh(true);
593 WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
594 f1->applyFunc("2*x");
595 f1->setTime(0.01,3,4);
596 MEDCouplingFieldDouble *f_2=f1->cloneWithMesh(true);
597 WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
598 f1->applyFunc("2*x/3");
599 f1->setTime(0.02,5,6);
600 MEDCouplingFieldDouble *f_3=f1->cloneWithMesh(true);
601 WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
604 std::vector<std::pair<int,int> > its;
605 its.push_back(std::pair<int,int>(1,2));
606 its.push_back(std::pair<int,int>(3,4));
607 its.push_back(std::pair<int,int>(5,6));
608 std::vector<MEDCouplingFieldDouble *> fs=ReadFieldsOnSameMesh(ON_CELLS,fileName,f_1->getMesh()->getName().c_str(),0,f_1->getName().c_str(),its);
609 CPPUNIT_ASSERT_EQUAL(3,(int)fs.size());
610 const MEDCouplingMesh *mm=fs[0]->getMesh();
611 CPPUNIT_ASSERT(fs[0]->isEqual(f_1,1e-12,1e-12));
612 CPPUNIT_ASSERT(fs[1]->isEqual(f_2,1e-12,1e-12));
613 CPPUNIT_ASSERT(fs[2]->isEqual(f_3,1e-12,1e-12));
614 CPPUNIT_ASSERT(mm==fs[1]->getMesh());// <- important for the test
615 CPPUNIT_ASSERT(mm==fs[2]->getMesh());// <- important for the test
616 for(std::vector<MEDCouplingFieldDouble *>::iterator iter=fs.begin();iter!=fs.end();iter++)
626 void MEDLoaderTest::testWriteUMeshesRW1()
628 const char fileName[]="file18.med";
629 MEDCouplingUMesh *m3d=build3DMesh_2();
630 const double pt[3]={0.,0.,-0.3};
631 const double vec[3]={0.,0.,1.};
632 std::vector<int> nodes;
633 m3d->findNodesOnPlane(pt,vec,1e-12,nodes);
634 MEDCouplingUMesh *m2d=(MEDCouplingUMesh *)m3d->buildFacePartOfMySelfNode(&nodes[0],&nodes[0]+nodes.size(),true);
635 const int renumber[5]={1,2,0,4,3};
636 m2d->renumberCells(renumber,false);
637 m2d->setName("ExampleOfMultiDimW");
638 std::vector<const MEDCouplingUMesh *> meshes;
639 meshes.push_back(m2d);
640 meshes.push_back(m3d);
641 WriteUMeshes(fileName,meshes,true);
642 MEDCouplingUMesh *m3d_bis=ReadUMeshFromFile(fileName,m2d->getName().c_str(),0);
643 CPPUNIT_ASSERT(!m3d_bis->isEqual(m3d,1e-12));
644 m3d_bis->setName(m3d->getName().c_str());
645 CPPUNIT_ASSERT(m3d_bis->isEqual(m3d,1e-12));
646 MEDCouplingUMesh *m2d_bis=ReadUMeshFromFile(fileName,m2d->getName().c_str(),-1);//-1 for faces
647 CPPUNIT_ASSERT(m2d_bis->isEqual(m2d,1e-12));
648 // Creation of a field on faces.
649 MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
650 f1->setName("FieldOnFacesShuffle");
652 DataArrayDouble *array=DataArrayDouble::New();
653 array->alloc(m2d->getNumberOfCells(),2);
654 array->setInfoOnComponent(0,"plkj [mm]");
655 array->setInfoOnComponent(1,"pqqqss [mm]");
658 double *tmp=array->getPointer();
659 const double arr1[10]={71.,171.,10.,110.,20.,120.,30.,130.,40.,140.};
660 std::copy(arr1,arr1+10,tmp);
661 f1->setTime(3.14,2,7);
662 f1->checkConsistencyLight();
663 WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
664 MEDCouplingFieldDouble *f2=ReadFieldCell(fileName,f1->getMesh()->getName().c_str(),-1,f1->getName().c_str(),2,7);
665 CPPUNIT_ASSERT(f2->isEqual(f1,1e-12,1e-12));
675 void MEDLoaderTest::testMixCellAndNodesFieldRW1()
677 const char fileName[]="file21.med";
678 MEDCouplingUMesh *mesh=build3DSurfMesh_1();
679 MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
680 f1->setName("FieldMix");
682 DataArrayDouble *array=DataArrayDouble::New();
685 array->setInfoOnComponent(0,"plkj [mm]");
686 array->setInfoOnComponent(1,"pqqqss [mm]");
688 double *tmp=array->getPointer();
689 const double arr1[12]={71.,171.,10.,110.,20.,120.,30.,130.,40.,140.,50.,150.};
690 std::copy(arr1,arr1+12,tmp);
691 f1->setTime(3.14,2,7);
692 f1->checkConsistencyLight();
694 MEDCouplingFieldDouble *f2=MEDCouplingFieldDouble::New(ON_NODES,ONE_TIME);
695 f2->setName("FieldMix");
697 array=DataArrayDouble::New();
700 array->setInfoOnComponent(0,"plkj [mm]");
701 array->setInfoOnComponent(1,"pqqqss [mm]");
703 tmp=array->getPointer();
704 const double arr2[24]={
705 1071.,1171.,1010.,1110.,1020.,1120.,1030.,1130.,1040.,1140.,1050.,1150.,
706 1060.,1160.,1070.,1170.,1080.,1180.,1090.,1190.,1091.,1191.,1092.,1192.
708 std::copy(arr2,arr2+24,tmp);
709 f2->setTime(3.14,2,7);
710 f2->checkConsistencyLight();
712 WriteField(fileName,f1,true);
713 std::vector<MEDCoupling::TypeOfField> ts=GetTypesOfField(fileName,f1->getMesh()->getName().c_str(),f1->getName().c_str());
714 CPPUNIT_ASSERT_EQUAL(1,(int)ts.size());
715 CPPUNIT_ASSERT_EQUAL(ON_CELLS,ts[0]);
716 std::vector<std::string> fs=GetAllFieldNamesOnMesh(fileName,f1->getMesh()->getName().c_str());
717 CPPUNIT_ASSERT_EQUAL(1,(int)fs.size());
718 CPPUNIT_ASSERT(fs[0]=="FieldMix");
719 WriteFieldUsingAlreadyWrittenMesh(fileName,f2);
720 fs=GetAllFieldNamesOnMesh(fileName,f1->getMesh()->getName().c_str());
721 CPPUNIT_ASSERT_EQUAL(1,(int)fs.size());
722 CPPUNIT_ASSERT(fs[0]=="FieldMix");
724 ts=GetTypesOfField(fileName,f1->getMesh()->getName().c_str(),f1->getName().c_str());
725 CPPUNIT_ASSERT_EQUAL(2,(int)ts.size());
726 CPPUNIT_ASSERT_EQUAL(ON_NODES,ts[0]);
727 CPPUNIT_ASSERT_EQUAL(ON_CELLS,ts[1]);
729 MEDCouplingFieldDouble *f3=ReadFieldNode(fileName,f1->getMesh()->getName().c_str(),0,f1->getName().c_str(),2,7);
730 CPPUNIT_ASSERT(f3->isEqual(f2,1e-12,1e-12));
732 f3=ReadFieldCell(fileName,f1->getMesh()->getName().c_str(),0,f1->getName().c_str(),2,7);
733 CPPUNIT_ASSERT(f3->isEqual(f1,1e-12,1e-12));
741 void MEDLoaderTest::testGetAllFieldNamesRW1()
743 const char fileName[]="file22.med";
744 MEDCouplingUMesh *mesh=build2DMesh_2();
745 MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_NODES,ONE_TIME);
746 f1->setName("Field1");
747 f1->setTime(3.44,5,6);
749 f1->fillFromAnalytic(2,"x+y");
750 WriteField(fileName,f1,true);
751 f1->setTime(1002.3,7,8);
752 f1->fillFromAnalytic(2,"x+77.*y");
753 WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
754 f1->setName("Field2");
755 WriteField(fileName,f1,false);
756 f1->setName("Field3");
757 mesh->setName("2DMesh_2Bis");
758 WriteField(fileName,f1,false);
760 f1=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
761 f1->setName("Field8");
762 f1->setTime(8.99,7,9);
764 f1->fillFromAnalytic(3,"3*x+y");
765 WriteField(fileName,f1,false);
767 std::vector<std::string> fs=GetAllFieldNames(fileName);
768 CPPUNIT_ASSERT_EQUAL(4,(int)fs.size());
769 CPPUNIT_ASSERT(fs[0]=="Field1");
770 CPPUNIT_ASSERT(fs[1]=="Field2");
771 CPPUNIT_ASSERT(fs[2]=="Field3");
772 CPPUNIT_ASSERT(fs[3]=="Field8");
777 void MEDLoaderTest::testMEDLoaderRead1()
780 using namespace INTERP_KERNEL;
782 string fileName= INTERP_TEST::getResourceFile("pointe.med", 3);
783 vector<string> meshNames=GetMeshNames(fileName.c_str());
784 CPPUNIT_ASSERT_EQUAL(1,(int)meshNames.size());
785 MEDCouplingUMesh *mesh=ReadUMeshFromFile(fileName.c_str(),meshNames[0].c_str(),0);
786 CPPUNIT_ASSERT_EQUAL(3,mesh->getSpaceDimension());
787 CPPUNIT_ASSERT_EQUAL(3,mesh->getMeshDimension());
788 CPPUNIT_ASSERT_EQUAL(16,mesh->getNumberOfCells());
789 CPPUNIT_ASSERT_EQUAL(19,mesh->getNumberOfNodes());
790 CPPUNIT_ASSERT_EQUAL(3,(int)mesh->getAllGeoTypes().size());
791 for(int i=0;i<12;i++)
792 CPPUNIT_ASSERT_EQUAL(NORM_TETRA4,mesh->getTypeOfCell(i));
793 CPPUNIT_ASSERT_EQUAL(NORM_PYRA5,mesh->getTypeOfCell(12));
794 CPPUNIT_ASSERT_EQUAL(NORM_HEXA8,mesh->getTypeOfCell(13));
795 CPPUNIT_ASSERT_EQUAL(NORM_HEXA8,mesh->getTypeOfCell(14));
796 CPPUNIT_ASSERT_EQUAL(NORM_PYRA5,mesh->getTypeOfCell(15));
797 CPPUNIT_ASSERT_EQUAL((std::size_t)90,mesh->getNodalConnectivity()->getNbOfElems());
798 CPPUNIT_ASSERT_EQUAL(701,std::accumulate(mesh->getNodalConnectivity()->getPointer(),mesh->getNodalConnectivity()->getPointer()+90,0));
799 CPPUNIT_ASSERT_EQUAL(705,std::accumulate(mesh->getNodalConnectivityIndex()->getPointer(),mesh->getNodalConnectivityIndex()->getPointer()+17,0));
800 CPPUNIT_ASSERT_DOUBLES_EQUAL(46.,std::accumulate(mesh->getCoords()->getPointer(),mesh->getCoords()->getPointer()+57,0),1e-12);
803 vector<string> families=GetMeshFamiliesNames(fileName.c_str(),meshNames[0].c_str());
804 CPPUNIT_ASSERT_EQUAL(8,(int)families.size());
805 CPPUNIT_ASSERT(families[2]=="FAMILLE_ELEMENT_3");
807 vector<string> families2;
808 families2.push_back(families[2]);
809 mesh=ReadUMeshFromFamilies(fileName.c_str(),meshNames[0].c_str(),0,families2);
810 CPPUNIT_ASSERT_EQUAL(3,mesh->getSpaceDimension());
811 CPPUNIT_ASSERT_EQUAL(3,mesh->getMeshDimension());
812 CPPUNIT_ASSERT_EQUAL(2,mesh->getNumberOfCells());
813 CPPUNIT_ASSERT_EQUAL(19,mesh->getNumberOfNodes());
814 CPPUNIT_ASSERT_EQUAL(2,(int)mesh->getAllGeoTypes().size());
815 CPPUNIT_ASSERT_EQUAL(NORM_TETRA4,mesh->getTypeOfCell(0));
816 CPPUNIT_ASSERT_EQUAL(NORM_PYRA5,mesh->getTypeOfCell(1));
817 CPPUNIT_ASSERT_EQUAL((std::size_t)11,mesh->getNodalConnectivity()->getNbOfElems());
818 CPPUNIT_ASSERT_EQUAL(132,std::accumulate(mesh->getNodalConnectivity()->getPointer(),mesh->getNodalConnectivity()->getPointer()+11,0));
819 CPPUNIT_ASSERT_EQUAL(16,std::accumulate(mesh->getNodalConnectivityIndex()->getPointer(),mesh->getNodalConnectivityIndex()->getPointer()+3,0));
820 CPPUNIT_ASSERT_DOUBLES_EQUAL(46.,std::accumulate(mesh->getCoords()->getPointer(),mesh->getCoords()->getPointer()+57,0),1e-12);
823 vector<string> groups=GetMeshGroupsNames(fileName.c_str(),meshNames[0].c_str());
824 CPPUNIT_ASSERT_EQUAL(5,(int)groups.size());
825 CPPUNIT_ASSERT(groups[0]=="groupe1");
826 CPPUNIT_ASSERT(groups[1]=="groupe2");
827 CPPUNIT_ASSERT(groups[2]=="groupe3");
828 CPPUNIT_ASSERT(groups[3]=="groupe4");
829 CPPUNIT_ASSERT(groups[4]=="groupe5");
830 vector<string> groups2;
831 groups2.push_back(groups[0]);
832 mesh=ReadUMeshFromGroups(fileName.c_str(),meshNames[0].c_str(),0,groups2);
833 CPPUNIT_ASSERT_EQUAL(3,mesh->getSpaceDimension());
834 CPPUNIT_ASSERT_EQUAL(3,mesh->getMeshDimension());
835 CPPUNIT_ASSERT_EQUAL(7,mesh->getNumberOfCells());
836 CPPUNIT_ASSERT_EQUAL(19,mesh->getNumberOfNodes());
837 CPPUNIT_ASSERT_EQUAL(2,(int)mesh->getAllGeoTypes().size());
839 CPPUNIT_ASSERT_EQUAL(NORM_TETRA4,mesh->getTypeOfCell(i));
840 CPPUNIT_ASSERT_EQUAL(NORM_PYRA5,mesh->getTypeOfCell(6));
841 CPPUNIT_ASSERT_EQUAL((std::size_t)36,mesh->getNodalConnectivity()->getNbOfElems());
842 CPPUNIT_ASSERT_EQUAL(254,std::accumulate(mesh->getNodalConnectivity()->getPointer(),mesh->getNodalConnectivity()->getPointer()+36,0));
843 CPPUNIT_ASSERT_EQUAL(141,std::accumulate(mesh->getNodalConnectivityIndex()->getPointer(),mesh->getNodalConnectivityIndex()->getPointer()+8,0));
844 CPPUNIT_ASSERT_DOUBLES_EQUAL(46.,std::accumulate(mesh->getCoords()->getPointer(),mesh->getCoords()->getPointer()+57,0),1e-12);
847 std::vector<std::string> fieldsName=GetCellFieldNamesOnMesh(fileName.c_str(),meshNames[0].c_str());
848 CPPUNIT_ASSERT_EQUAL(2,(int)fieldsName.size());
849 CPPUNIT_ASSERT(fieldsName[0]=="fieldcelldoublescalar");
850 CPPUNIT_ASSERT(fieldsName[1]=="fieldcelldoublevector");
851 std::vector<std::pair<int,int> > its0=GetCellFieldIterations(fileName.c_str(),meshNames[0].c_str(),fieldsName[0].c_str());
852 CPPUNIT_ASSERT_EQUAL(1,(int)its0.size());
853 CPPUNIT_ASSERT_EQUAL(-1,its0[0].first);
854 CPPUNIT_ASSERT_EQUAL(-1,its0[0].second);
855 std::vector<std::pair<int,int> > its1=GetCellFieldIterations(fileName.c_str(),meshNames[0].c_str(),fieldsName[1].c_str());
856 CPPUNIT_ASSERT_EQUAL(1,(int)its1.size());
857 CPPUNIT_ASSERT_EQUAL(-1,its1[0].first);
858 CPPUNIT_ASSERT_EQUAL(-1,its1[0].second);
860 MEDCouplingFieldDouble *field0=ReadFieldCell(fileName.c_str(),meshNames[0].c_str(),0,fieldsName[0].c_str(),its0[0].first,its0[0].second);
861 field0->checkConsistencyLight();
862 CPPUNIT_ASSERT(field0->getName()==fieldsName[0]);
863 CPPUNIT_ASSERT_EQUAL(1,(int)field0->getNumberOfComponents());
864 CPPUNIT_ASSERT_EQUAL(16,(int)field0->getNumberOfTuples());
865 const double expectedValues[16]={1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,2.,3.,3.,2.};
866 double diffValue[16];
867 std::transform(field0->getArray()->getPointer(),field0->getArray()->getPointer()+16,expectedValues,diffValue,std::minus<double>());
868 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,*std::max_element(diffValue,diffValue+16),1e-12);
869 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,*std::min_element(diffValue,diffValue+16),1e-12);
870 const MEDCouplingUMesh *constMesh=dynamic_cast<const MEDCouplingUMesh *>(field0->getMesh());
871 CPPUNIT_ASSERT(constMesh);
872 CPPUNIT_ASSERT_EQUAL(3,constMesh->getSpaceDimension());
873 CPPUNIT_ASSERT_EQUAL(3,constMesh->getMeshDimension());
874 CPPUNIT_ASSERT_EQUAL(16,constMesh->getNumberOfCells());
875 CPPUNIT_ASSERT_EQUAL(19,constMesh->getNumberOfNodes());
876 CPPUNIT_ASSERT_EQUAL(3,(int)constMesh->getAllGeoTypes().size());
877 for(int i=0;i<12;i++)
878 CPPUNIT_ASSERT_EQUAL(NORM_TETRA4,constMesh->getTypeOfCell(i));
879 CPPUNIT_ASSERT_EQUAL(NORM_PYRA5,constMesh->getTypeOfCell(12));
880 CPPUNIT_ASSERT_EQUAL(NORM_HEXA8,constMesh->getTypeOfCell(13));
881 CPPUNIT_ASSERT_EQUAL(NORM_HEXA8,constMesh->getTypeOfCell(14));
882 CPPUNIT_ASSERT_EQUAL(NORM_PYRA5,constMesh->getTypeOfCell(15));
883 CPPUNIT_ASSERT_EQUAL((std::size_t)90,constMesh->getNodalConnectivity()->getNbOfElems());
884 CPPUNIT_ASSERT_EQUAL(701,std::accumulate(constMesh->getNodalConnectivity()->getConstPointer(),constMesh->getNodalConnectivity()->getConstPointer()+90,0));
885 CPPUNIT_ASSERT_EQUAL(705,std::accumulate(constMesh->getNodalConnectivityIndex()->getConstPointer(),constMesh->getNodalConnectivityIndex()->getConstPointer()+17,0));
886 CPPUNIT_ASSERT_DOUBLES_EQUAL(46.,std::accumulate(constMesh->getCoords()->getConstPointer(),constMesh->getCoords()->getConstPointer()+57,0),1e-12);
889 MEDCouplingFieldDouble *field1=ReadFieldCell(fileName.c_str(),meshNames[0].c_str(),0,fieldsName[1].c_str(),its1[0].first,its1[0].second);
890 field1->checkConsistencyLight();
891 CPPUNIT_ASSERT(field1->getName()==fieldsName[1]);
892 CPPUNIT_ASSERT_EQUAL(3,(int)field1->getNumberOfComponents());
893 CPPUNIT_ASSERT_EQUAL(16,(int)field1->getNumberOfTuples());
894 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.};
895 double diffValue2[48];
896 std::transform(field1->getArray()->getPointer(),field1->getArray()->getPointer()+48,expectedValues2,diffValue2,std::minus<double>());
897 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,*std::max_element(diffValue2,diffValue2+48),1e-12);
898 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,*std::min_element(diffValue2,diffValue2+48),1e-12);
899 constMesh=dynamic_cast<const MEDCouplingUMesh *>(field1->getMesh());
900 CPPUNIT_ASSERT(constMesh);
901 CPPUNIT_ASSERT_EQUAL(3,constMesh->getSpaceDimension());
902 CPPUNIT_ASSERT_EQUAL(3,constMesh->getMeshDimension());
903 CPPUNIT_ASSERT_EQUAL(16,constMesh->getNumberOfCells());
904 CPPUNIT_ASSERT_EQUAL(19,constMesh->getNumberOfNodes());
905 CPPUNIT_ASSERT_EQUAL(3,(int)constMesh->getAllGeoTypes().size());
906 for(int i=0;i<12;i++)
907 CPPUNIT_ASSERT_EQUAL(NORM_TETRA4,constMesh->getTypeOfCell(i));
908 CPPUNIT_ASSERT_EQUAL(NORM_PYRA5,constMesh->getTypeOfCell(12));
909 CPPUNIT_ASSERT_EQUAL(NORM_HEXA8,constMesh->getTypeOfCell(13));
910 CPPUNIT_ASSERT_EQUAL(NORM_HEXA8,constMesh->getTypeOfCell(14));
911 CPPUNIT_ASSERT_EQUAL(NORM_PYRA5,constMesh->getTypeOfCell(15));
912 CPPUNIT_ASSERT_EQUAL((std::size_t)90,constMesh->getNodalConnectivity()->getNbOfElems());
913 CPPUNIT_ASSERT_EQUAL(701,std::accumulate(constMesh->getNodalConnectivity()->getConstPointer(),constMesh->getNodalConnectivity()->getConstPointer()+90,0));
914 CPPUNIT_ASSERT_EQUAL(705,std::accumulate(constMesh->getNodalConnectivityIndex()->getConstPointer(),constMesh->getNodalConnectivityIndex()->getConstPointer()+17,0));
915 CPPUNIT_ASSERT_DOUBLES_EQUAL(46.,std::accumulate(constMesh->getCoords()->getConstPointer(),constMesh->getCoords()->getConstPointer()+57,0),1e-12);
918 std::vector<std::string> fieldsNameNode=GetNodeFieldNamesOnMesh(fileName.c_str(),meshNames[0].c_str());
919 CPPUNIT_ASSERT_EQUAL(2,(int)fieldsNameNode.size());
920 CPPUNIT_ASSERT(fieldsNameNode[0]=="fieldnodedouble");
921 CPPUNIT_ASSERT(fieldsNameNode[1]=="fieldnodeint");
922 std::vector<std::pair<int,int> > its0Node=GetNodeFieldIterations(fileName.c_str(),meshNames[0].c_str(),fieldsNameNode[0].c_str());
923 CPPUNIT_ASSERT_EQUAL(3,(int)its0Node.size());
924 CPPUNIT_ASSERT_EQUAL(-1,its0Node[0].first);
925 CPPUNIT_ASSERT_EQUAL(-1,its0Node[0].second);
926 CPPUNIT_ASSERT_EQUAL(1,its0Node[1].first);
927 CPPUNIT_ASSERT_EQUAL(-1,its0Node[1].second);
928 CPPUNIT_ASSERT_EQUAL(2,its0Node[2].first);
929 CPPUNIT_ASSERT_EQUAL(-1,its0Node[2].second);
930 MEDCouplingFieldDouble *field0Nodes=ReadFieldNode(fileName.c_str(),meshNames[0].c_str(),0,fieldsNameNode[0].c_str(),its0Node[0].first,its0Node[0].second);
931 field0Nodes->checkConsistencyLight();
932 CPPUNIT_ASSERT(field0Nodes->getName()==fieldsNameNode[0]);
933 CPPUNIT_ASSERT_EQUAL(1,(int)field0Nodes->getNumberOfComponents());
934 CPPUNIT_ASSERT_EQUAL(19,(int)field0Nodes->getNumberOfTuples());
935 const double expectedValues3[19]={1.,1.,1.,2.,2.,2.,3.,3.,3.,4.,4.,4.,5.,5.,5.,6.,6.,6.,7.};
936 double diffValue3[19];
937 std::transform(field0Nodes->getArray()->getPointer(),field0Nodes->getArray()->getPointer()+19,expectedValues3,diffValue3,std::minus<double>());
938 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,*std::max_element(diffValue3,diffValue3+19),1e-12);
939 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,*std::min_element(diffValue3,diffValue3+19),1e-12);
940 constMesh=dynamic_cast<const MEDCouplingUMesh *>(field0Nodes->getMesh());
941 CPPUNIT_ASSERT(constMesh);
942 field0Nodes->decrRef();
944 field0Nodes=ReadFieldNode(fileName.c_str(),meshNames[0].c_str(),0,fieldsNameNode[0].c_str(),its0Node[2].first,its0Node[2].second);
945 field0Nodes->checkConsistencyLight();
946 CPPUNIT_ASSERT(field0Nodes->getName()==fieldsNameNode[0]);
947 CPPUNIT_ASSERT_EQUAL(1,(int)field0Nodes->getNumberOfComponents());
948 CPPUNIT_ASSERT_EQUAL(19,(int)field0Nodes->getNumberOfTuples());
949 const double expectedValues4[19]={1.,2.,2.,2.,3.,3.,3.,4.,4.,4.,5.,5.,5.,6.,6.,6.,7.,7.,7.};
950 std::transform(field0Nodes->getArray()->getPointer(),field0Nodes->getArray()->getPointer()+19,expectedValues4,diffValue3,std::minus<double>());
951 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,*std::max_element(diffValue3,diffValue3+19),1e-12);
952 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,*std::min_element(diffValue3,diffValue3+19),1e-12);
953 constMesh=dynamic_cast<const MEDCouplingUMesh *>(field0Nodes->getMesh());
954 CPPUNIT_ASSERT(constMesh);
955 CPPUNIT_ASSERT_EQUAL(3,constMesh->getSpaceDimension());
956 CPPUNIT_ASSERT_EQUAL(3,constMesh->getMeshDimension());
957 CPPUNIT_ASSERT_EQUAL(16,constMesh->getNumberOfCells());
958 CPPUNIT_ASSERT_EQUAL(19,constMesh->getNumberOfNodes());
959 CPPUNIT_ASSERT_EQUAL(3,(int)constMesh->getAllGeoTypes().size());
960 for(int i=0;i<12;i++)
961 CPPUNIT_ASSERT_EQUAL(NORM_TETRA4,constMesh->getTypeOfCell(i));
962 CPPUNIT_ASSERT_EQUAL(NORM_PYRA5,constMesh->getTypeOfCell(12));
963 CPPUNIT_ASSERT_EQUAL(NORM_HEXA8,constMesh->getTypeOfCell(13));
964 CPPUNIT_ASSERT_EQUAL(NORM_HEXA8,constMesh->getTypeOfCell(14));
965 CPPUNIT_ASSERT_EQUAL(NORM_PYRA5,constMesh->getTypeOfCell(15));
966 CPPUNIT_ASSERT_EQUAL((std::size_t)90,constMesh->getNodalConnectivity()->getNbOfElems());
967 CPPUNIT_ASSERT_EQUAL(701,std::accumulate(constMesh->getNodalConnectivity()->getConstPointer(),constMesh->getNodalConnectivity()->getConstPointer()+90,0));
968 CPPUNIT_ASSERT_EQUAL(705,std::accumulate(constMesh->getNodalConnectivityIndex()->getConstPointer(),constMesh->getNodalConnectivityIndex()->getConstPointer()+17,0));
969 CPPUNIT_ASSERT_DOUBLES_EQUAL(46.,std::accumulate(constMesh->getCoords()->getConstPointer(),constMesh->getCoords()->getConstPointer()+57,0),1e-12);
970 field0Nodes->decrRef();
972 field0Nodes=ReadFieldNode(fileName.c_str(),meshNames[0].c_str(),0,fieldsNameNode[0].c_str(),its0Node[0].first,its0Node[0].second);
973 field0Nodes->checkConsistencyLight();
974 CPPUNIT_ASSERT(field0Nodes->getName()==fieldsNameNode[0]);
975 CPPUNIT_ASSERT_EQUAL(1,(int)field0Nodes->getNumberOfComponents());
976 CPPUNIT_ASSERT_EQUAL(19,(int)field0Nodes->getNumberOfTuples());
977 const double expectedValues5[19]={1.,1.,1.,2.,2.,2.,3.,3.,3.,4.,4.,4.,5.,5.,5.,6.,6.,6.,7.};
978 std::transform(field0Nodes->getArray()->getPointer(),field0Nodes->getArray()->getPointer()+19,expectedValues5,diffValue3,std::minus<double>());
979 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,*std::max_element(diffValue3,diffValue3+19),1e-12);
980 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,*std::min_element(diffValue3,diffValue3+19),1e-12);
981 constMesh=dynamic_cast<const MEDCouplingUMesh *>(field0Nodes->getMesh());
982 CPPUNIT_ASSERT(constMesh);
983 CPPUNIT_ASSERT_EQUAL(3,constMesh->getSpaceDimension());
984 CPPUNIT_ASSERT_EQUAL(3,constMesh->getMeshDimension());
985 CPPUNIT_ASSERT_EQUAL(16,constMesh->getNumberOfCells());
986 CPPUNIT_ASSERT_EQUAL(19,constMesh->getNumberOfNodes());
987 CPPUNIT_ASSERT_EQUAL(3,(int)constMesh->getAllGeoTypes().size());
988 for(int i=0;i<12;i++)
989 CPPUNIT_ASSERT_EQUAL(NORM_TETRA4,constMesh->getTypeOfCell(i));
990 CPPUNIT_ASSERT_EQUAL(NORM_PYRA5,constMesh->getTypeOfCell(12));
991 CPPUNIT_ASSERT_EQUAL(NORM_HEXA8,constMesh->getTypeOfCell(13));
992 CPPUNIT_ASSERT_EQUAL(NORM_HEXA8,constMesh->getTypeOfCell(14));
993 CPPUNIT_ASSERT_EQUAL(NORM_PYRA5,constMesh->getTypeOfCell(15));
994 CPPUNIT_ASSERT_EQUAL((std::size_t)90,constMesh->getNodalConnectivity()->getNbOfElems());
995 CPPUNIT_ASSERT_EQUAL(701,std::accumulate(constMesh->getNodalConnectivity()->getConstPointer(),constMesh->getNodalConnectivity()->getConstPointer()+90,0));
996 CPPUNIT_ASSERT_EQUAL(705,std::accumulate(constMesh->getNodalConnectivityIndex()->getConstPointer(),constMesh->getNodalConnectivityIndex()->getConstPointer()+17,0));
997 CPPUNIT_ASSERT_DOUBLES_EQUAL(46.,std::accumulate(constMesh->getCoords()->getConstPointer(),constMesh->getCoords()->getConstPointer()+57,0),1e-12);
998 field0Nodes->decrRef();
1001 void MEDLoaderTest::testMEDLoaderPolygonRead()
1003 using namespace std;
1004 using namespace INTERP_KERNEL;
1006 string fileName=INTERP_TEST::getResourceFile("polygones.med", 3);
1007 vector<string> meshNames=GetMeshNames(fileName.c_str());
1008 CPPUNIT_ASSERT_EQUAL(1,(int)meshNames.size());
1009 CPPUNIT_ASSERT(meshNames[0]=="Bord");
1010 MEDCouplingUMesh *mesh=ReadUMeshFromFile(fileName.c_str(),meshNames[0].c_str(),0);
1011 mesh->checkConsistencyLight();
1012 CPPUNIT_ASSERT_EQUAL(3,mesh->getSpaceDimension());
1013 CPPUNIT_ASSERT_EQUAL(2,mesh->getMeshDimension());
1014 CPPUNIT_ASSERT_EQUAL(538,mesh->getNumberOfCells());
1015 CPPUNIT_ASSERT_EQUAL(579,mesh->getNumberOfNodes());
1016 CPPUNIT_ASSERT_EQUAL(2,(int)mesh->getAllGeoTypes().size());
1017 for(int i=0;i<514;i++)
1018 CPPUNIT_ASSERT_EQUAL(NORM_QUAD4,mesh->getTypeOfCell(i));
1019 for(int i=514;i<538;i++)
1020 CPPUNIT_ASSERT_EQUAL(NORM_POLYGON,mesh->getTypeOfCell(i));
1021 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,std::accumulate(mesh->getCoords()->getPointer(),mesh->getCoords()->getPointer()+1737,0),1e-12);
1022 const double expectedVals1[12]={1.4851585216522212,-0.5,0.,1.4851585216522212,-0.4,0.,1.4851585216522212,-0.3,0., 1.5741585216522211, -0.5, 0. };
1023 double diffValue1[12];
1024 std::transform(mesh->getCoords()->getPointer(),mesh->getCoords()->getPointer()+12,expectedVals1,diffValue1,std::minus<double>());
1025 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,*std::max_element(diffValue1,diffValue1+12),1e-12);
1026 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,*std::min_element(diffValue1,diffValue1+12),1e-12);
1027 CPPUNIT_ASSERT_EQUAL((std::size_t)2768,mesh->getNodalConnectivity()->getNbOfElems());
1028 CPPUNIT_ASSERT_EQUAL(651050,std::accumulate(mesh->getNodalConnectivity()->getPointer(),mesh->getNodalConnectivity()->getPointer()+2768,0));
1029 CPPUNIT_ASSERT_EQUAL(725943,std::accumulate(mesh->getNodalConnectivityIndex()->getPointer(),mesh->getNodalConnectivityIndex()->getPointer()+539,0));
1032 std::vector<std::string> fieldsName=GetCellFieldNamesOnMesh(fileName.c_str(),meshNames[0].c_str());
1033 CPPUNIT_ASSERT_EQUAL(3,(int)fieldsName.size());
1034 CPPUNIT_ASSERT(fieldsName[0]=="bord_:_distorsion");
1035 CPPUNIT_ASSERT(fieldsName[1]=="bord_:_familles");
1036 CPPUNIT_ASSERT(fieldsName[2]=="bord_:_non-ortho");
1037 std::vector<std::pair<int,int> > its0=GetCellFieldIterations(fileName.c_str(),meshNames[0].c_str(),fieldsName[0].c_str());
1038 CPPUNIT_ASSERT_EQUAL(1,(int)its0.size());
1039 MEDCouplingFieldDouble *field=ReadFieldCell(fileName.c_str(),meshNames[0].c_str(),0,fieldsName[0].c_str(),its0[0].first,its0[0].second);
1040 field->checkConsistencyLight();
1041 CPPUNIT_ASSERT(field->getName()==fieldsName[0]);
1042 CPPUNIT_ASSERT_EQUAL(1,(int)field->getNumberOfComponents());
1043 CPPUNIT_ASSERT_EQUAL(538,(int)field->getNumberOfTuples());
1044 const MEDCouplingUMesh *constMesh=dynamic_cast<const MEDCouplingUMesh *>(field->getMesh());
1045 CPPUNIT_ASSERT(constMesh);
1046 CPPUNIT_ASSERT_EQUAL(3,constMesh->getSpaceDimension());
1047 CPPUNIT_ASSERT_EQUAL(2,constMesh->getMeshDimension());
1048 CPPUNIT_ASSERT_EQUAL(538,constMesh->getNumberOfCells());
1049 CPPUNIT_ASSERT_EQUAL(579,constMesh->getNumberOfNodes());
1050 CPPUNIT_ASSERT_EQUAL(2,(int)constMesh->getAllGeoTypes().size());
1051 for(int i=0;i<514;i++)
1052 CPPUNIT_ASSERT_EQUAL(NORM_QUAD4,constMesh->getTypeOfCell(i));
1053 for(int i=514;i<538;i++)
1054 CPPUNIT_ASSERT_EQUAL(NORM_POLYGON,constMesh->getTypeOfCell(i));
1055 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,std::accumulate(constMesh->getCoords()->getConstPointer(),constMesh->getCoords()->getConstPointer()+1737,0),1e-12);
1056 std::transform(constMesh->getCoords()->getConstPointer(),constMesh->getCoords()->getConstPointer()+12,expectedVals1,diffValue1,std::minus<double>());
1057 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,*std::max_element(diffValue1,diffValue1+12),1e-12);
1058 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,*std::min_element(diffValue1,diffValue1+12),1e-12);
1059 CPPUNIT_ASSERT_EQUAL((std::size_t)2768,constMesh->getNodalConnectivity()->getNbOfElems());
1060 CPPUNIT_ASSERT_EQUAL(651050,std::accumulate(constMesh->getNodalConnectivity()->getConstPointer(),constMesh->getNodalConnectivity()->getConstPointer()+2768,0));
1061 CPPUNIT_ASSERT_EQUAL(725943,std::accumulate(constMesh->getNodalConnectivityIndex()->getConstPointer(),constMesh->getNodalConnectivityIndex()->getConstPointer()+539,0));
1062 const double *values=field->getArray()->getPointer();
1063 CPPUNIT_ASSERT_DOUBLES_EQUAL(2.87214203182918,std::accumulate(values,values+538,0.),1e-12);
1067 void MEDLoaderTest::testMEDLoaderPolyhedronRead()
1069 using namespace std;
1070 using namespace INTERP_KERNEL;
1072 string fileName=INTERP_TEST::getResourceFile("poly3D.med", 3);
1073 vector<string> meshNames=GetMeshNames(fileName.c_str());
1074 CPPUNIT_ASSERT_EQUAL(1,(int)meshNames.size());
1075 CPPUNIT_ASSERT(meshNames[0]=="poly3D");
1076 MEDCouplingUMesh *mesh=ReadUMeshFromFile(fileName.c_str(),meshNames[0].c_str(),0);
1077 mesh->checkConsistencyLight();
1078 CPPUNIT_ASSERT_EQUAL(3,mesh->getSpaceDimension());
1079 CPPUNIT_ASSERT_EQUAL(3,mesh->getMeshDimension());
1080 CPPUNIT_ASSERT_EQUAL(3,mesh->getNumberOfCells());
1081 CPPUNIT_ASSERT_EQUAL(19,mesh->getNumberOfNodes());
1082 CPPUNIT_ASSERT_EQUAL(2,(int)mesh->getAllGeoTypes().size());
1083 CPPUNIT_ASSERT_EQUAL(NORM_TETRA4,mesh->getTypeOfCell(0));
1084 CPPUNIT_ASSERT_EQUAL(NORM_POLYHED,mesh->getTypeOfCell(1));
1085 CPPUNIT_ASSERT_EQUAL(NORM_POLYHED,mesh->getTypeOfCell(2));
1086 CPPUNIT_ASSERT_EQUAL((std::size_t)98,mesh->getNodalConnectivity()->getNbOfElems());
1087 CPPUNIT_ASSERT_EQUAL(725,std::accumulate(mesh->getNodalConnectivity()->getPointer(),mesh->getNodalConnectivity()->getPointer()+98,0));
1088 CPPUNIT_ASSERT_DOUBLES_EQUAL(110.,std::accumulate(mesh->getCoords()->getPointer(),mesh->getCoords()->getPointer()+57,0),1e-12);
1089 CPPUNIT_ASSERT_EQUAL(155,std::accumulate(mesh->getNodalConnectivityIndex()->getPointer(),mesh->getNodalConnectivityIndex()->getPointer()+4,0));
1092 mesh=ReadUMeshFromFile(fileName.c_str(),meshNames[0].c_str(),-1);
1093 mesh->checkConsistencyLight();
1094 CPPUNIT_ASSERT_EQUAL(3,mesh->getSpaceDimension());
1095 CPPUNIT_ASSERT_EQUAL(2,mesh->getMeshDimension());
1096 CPPUNIT_ASSERT_EQUAL(17,mesh->getNumberOfCells());
1097 CPPUNIT_ASSERT_EQUAL(19,mesh->getNumberOfNodes());
1098 CPPUNIT_ASSERT_EQUAL(3,(int)mesh->getAllGeoTypes().size());
1099 CPPUNIT_ASSERT_EQUAL(NORM_POLYGON,mesh->getTypeOfCell(0));
1100 CPPUNIT_ASSERT_EQUAL(NORM_QUAD4,mesh->getTypeOfCell(1));
1101 CPPUNIT_ASSERT_EQUAL(NORM_QUAD4,mesh->getTypeOfCell(2));
1102 CPPUNIT_ASSERT_EQUAL(NORM_QUAD4,mesh->getTypeOfCell(3));
1103 CPPUNIT_ASSERT_EQUAL(NORM_QUAD4,mesh->getTypeOfCell(4));
1104 CPPUNIT_ASSERT_EQUAL(NORM_QUAD4,mesh->getTypeOfCell(5));
1105 CPPUNIT_ASSERT_EQUAL(NORM_QUAD4,mesh->getTypeOfCell(6));
1106 CPPUNIT_ASSERT_EQUAL(NORM_TRI3,mesh->getTypeOfCell(7));
1107 CPPUNIT_ASSERT_EQUAL(NORM_POLYGON,mesh->getTypeOfCell(8));
1108 CPPUNIT_ASSERT_EQUAL(NORM_POLYGON,mesh->getTypeOfCell(9));
1109 CPPUNIT_ASSERT_EQUAL(NORM_QUAD4,mesh->getTypeOfCell(10));
1110 CPPUNIT_ASSERT_EQUAL(NORM_TRI3,mesh->getTypeOfCell(11));
1111 CPPUNIT_ASSERT_EQUAL(NORM_TRI3,mesh->getTypeOfCell(12));
1112 CPPUNIT_ASSERT_EQUAL(NORM_TRI3,mesh->getTypeOfCell(13));
1113 CPPUNIT_ASSERT_EQUAL(NORM_TRI3,mesh->getTypeOfCell(14));
1114 CPPUNIT_ASSERT_EQUAL(NORM_QUAD4,mesh->getTypeOfCell(15));
1115 CPPUNIT_ASSERT_EQUAL(NORM_TRI3,mesh->getTypeOfCell(16));
1116 CPPUNIT_ASSERT_DOUBLES_EQUAL(110.,std::accumulate(mesh->getCoords()->getPointer(),mesh->getCoords()->getPointer()+57,0),1e-12);
1117 CPPUNIT_ASSERT_EQUAL((std::size_t)83,mesh->getNodalConnectivity()->getNbOfElems());
1118 CPPUNIT_ASSERT_EQUAL(619,std::accumulate(mesh->getNodalConnectivity()->getPointer(),mesh->getNodalConnectivity()->getPointer()+83,0));
1121 vector<string> families=GetMeshFamiliesNames(fileName.c_str(),meshNames[0].c_str());
1122 CPPUNIT_ASSERT_EQUAL(4,(int)families.size());
1123 CPPUNIT_ASSERT(families[0]=="FAMILLE_FACE_POLYGONS3");
1124 CPPUNIT_ASSERT(families[1]=="FAMILLE_FACE_QUAD41");
1125 CPPUNIT_ASSERT(families[2]=="FAMILLE_FACE_TRIA32");
1126 CPPUNIT_ASSERT(families[3]=="FAMILLE_ZERO");
1127 vector<string> families2;
1128 families2.push_back(families[0]);
1129 mesh=ReadUMeshFromFamilies(fileName.c_str(),meshNames[0].c_str(),-1,families2);
1130 mesh->checkConsistencyLight();
1131 CPPUNIT_ASSERT_EQUAL(3,mesh->getSpaceDimension());
1132 CPPUNIT_ASSERT_EQUAL(2,mesh->getMeshDimension());
1133 CPPUNIT_ASSERT_EQUAL(3,mesh->getNumberOfCells());
1134 CPPUNIT_ASSERT_EQUAL(19,mesh->getNumberOfNodes());
1135 CPPUNIT_ASSERT_EQUAL(1,(int)mesh->getAllGeoTypes().size());
1136 for(int i=0;i<3;i++)
1137 CPPUNIT_ASSERT_EQUAL(NORM_POLYGON,mesh->getTypeOfCell(i));
1138 CPPUNIT_ASSERT_EQUAL((std::size_t)19,mesh->getNodalConnectivity()->getNbOfElems());
1139 CPPUNIT_ASSERT_EQUAL(117,std::accumulate(mesh->getNodalConnectivity()->getPointer(),mesh->getNodalConnectivity()->getPointer()+19,0));
1142 mesh=ReadUMeshFromFamilies(fileName.c_str(),meshNames[0].c_str(),0,families2);
1143 CPPUNIT_ASSERT_EQUAL(3,mesh->getSpaceDimension());
1144 CPPUNIT_ASSERT_EQUAL(0,mesh->getNumberOfCells());
1145 CPPUNIT_ASSERT_EQUAL(19,mesh->getNumberOfNodes());
1146 CPPUNIT_ASSERT_EQUAL(3,mesh->getMeshDimension());
1147 CPPUNIT_ASSERT_EQUAL(0,(int)mesh->getAllGeoTypes().size());
1151 MEDCouplingUMesh *MEDLoaderTest::build1DMesh_1()
1153 double coords[6]={ 0.0, 0.3, 0.75, 1.0, 1.4, 1.3 };
1154 int conn[9]={ 0,1, 1,2, 2,3 , 3,4,5};
1155 MEDCouplingUMesh *mesh=MEDCouplingUMesh::New();
1156 mesh->setName("1DMesh_1");
1157 mesh->setMeshDimension(1);
1158 mesh->allocateCells(4);
1159 mesh->insertNextCell(INTERP_KERNEL::NORM_SEG2,2,conn);
1160 mesh->insertNextCell(INTERP_KERNEL::NORM_SEG2,2,conn+2);
1161 mesh->insertNextCell(INTERP_KERNEL::NORM_SEG2,2,conn+4);
1162 mesh->insertNextCell(INTERP_KERNEL::NORM_SEG3,3,conn+6);
1163 mesh->finishInsertingCells();
1164 DataArrayDouble *myCoords=DataArrayDouble::New();
1165 myCoords->alloc(6,1);
1166 myCoords->setInfoOnComponent(0,"tototototototot [m*m*m*m*m*m*m*m]");
1167 std::copy(coords,coords+6,myCoords->getPointer());
1168 mesh->setCoords(myCoords);
1169 myCoords->decrRef();
1173 MEDCouplingUMesh *MEDLoaderTest::build2DCurveMesh_1()
1175 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 };
1176 int conn[9]={ 0,1, 1,2, 2,3 , 3,4,5};
1177 MEDCouplingUMesh *mesh=MEDCouplingUMesh::New();
1178 mesh->setName("2DCurveMesh_1");
1179 mesh->setMeshDimension(1);
1180 mesh->allocateCells(4);
1181 mesh->insertNextCell(INTERP_KERNEL::NORM_SEG2,2,conn);
1182 mesh->insertNextCell(INTERP_KERNEL::NORM_SEG2,2,conn+2);
1183 mesh->insertNextCell(INTERP_KERNEL::NORM_SEG2,2,conn+4);
1184 mesh->insertNextCell(INTERP_KERNEL::NORM_SEG3,3,conn+6);
1185 mesh->finishInsertingCells();
1186 DataArrayDouble *myCoords=DataArrayDouble::New();
1187 myCoords->alloc(6,2);
1188 std::copy(coords,coords+12,myCoords->getPointer());
1189 mesh->setCoords(myCoords);
1190 myCoords->decrRef();
1194 MEDCouplingUMesh *MEDLoaderTest::build2DMesh_1()
1196 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 };
1197 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};
1198 MEDCouplingUMesh *targetMesh=MEDCouplingUMesh::New();
1199 targetMesh->setMeshDimension(2);
1200 targetMesh->allocateCells(6);
1201 targetMesh->setName("2DMesh_1");
1202 targetMesh->insertNextCell(INTERP_KERNEL::NORM_TRI3,3,targetConn);
1203 targetMesh->insertNextCell(INTERP_KERNEL::NORM_TRI3,3,targetConn+3);
1204 targetMesh->insertNextCell(INTERP_KERNEL::NORM_TRI6,6,targetConn+6);
1205 targetMesh->insertNextCell(INTERP_KERNEL::NORM_QUAD4,4,targetConn+12);
1206 targetMesh->insertNextCell(INTERP_KERNEL::NORM_QUAD4,4,targetConn+16);
1207 targetMesh->insertNextCell(INTERP_KERNEL::NORM_POLYGON,4,targetConn+20);
1208 targetMesh->finishInsertingCells();
1209 DataArrayDouble *myCoords=DataArrayDouble::New();
1210 myCoords->alloc(12,2);
1211 myCoords->setInfoOnComponent(0,"tototototototot [m]");
1212 myCoords->setInfoOnComponent(1,"energie [kW]");
1213 std::copy(targetCoords,targetCoords+24,myCoords->getPointer());
1214 targetMesh->setCoords(myCoords);
1215 myCoords->decrRef();
1219 MEDCouplingUMesh *MEDLoaderTest::build2DMesh_2()
1221 double targetCoords[24]={
1222 -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,
1223 -0.05,0.95, 0.2,1.2, 0.45,0.95
1225 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};
1226 MEDCouplingUMesh *targetMesh=MEDCouplingUMesh::New();
1227 targetMesh->setMeshDimension(2);
1228 targetMesh->allocateCells(5);
1229 targetMesh->setName("2DMesh_2");
1230 targetMesh->insertNextCell(INTERP_KERNEL::NORM_TRI3,3,targetConn);
1231 targetMesh->insertNextCell(INTERP_KERNEL::NORM_TRI3,3,targetConn+3);
1232 targetMesh->insertNextCell(INTERP_KERNEL::NORM_QUAD4,4,targetConn+12);
1233 targetMesh->insertNextCell(INTERP_KERNEL::NORM_QUAD4,4,targetConn+16);
1234 targetMesh->insertNextCell(INTERP_KERNEL::NORM_TRI6,6,targetConn+6);
1235 targetMesh->finishInsertingCells();
1236 DataArrayDouble *myCoords=DataArrayDouble::New();
1237 myCoords->alloc(12,2);
1238 myCoords->setInfoOnComponent(0,"toto [m]");
1239 myCoords->setInfoOnComponent(1,"energie [kW]");
1240 std::copy(targetCoords,targetCoords+24,myCoords->getPointer());
1241 targetMesh->setCoords(myCoords);
1242 myCoords->decrRef();
1246 MEDCouplingUMesh *MEDLoaderTest::build3DSurfMesh_1()
1248 double targetCoords[36]={
1249 -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
1250 ,-0.05,0.95,-0.3, 0.2,1.2,-0.3, 0.45,0.95,-0.3
1252 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};
1253 MEDCouplingUMesh *targetMesh=MEDCouplingUMesh::New();
1254 targetMesh->setMeshDimension(2);
1255 targetMesh->allocateCells(6);
1256 targetMesh->setName("3DSurfMesh_1");
1257 targetMesh->insertNextCell(INTERP_KERNEL::NORM_TRI3,3,targetConn);
1258 targetMesh->insertNextCell(INTERP_KERNEL::NORM_TRI3,3,targetConn+3);
1259 targetMesh->insertNextCell(INTERP_KERNEL::NORM_QUAD4,4,targetConn+12);
1260 targetMesh->insertNextCell(INTERP_KERNEL::NORM_QUAD4,4,targetConn+16);
1261 targetMesh->insertNextCell(INTERP_KERNEL::NORM_TRI6,6,targetConn+6);
1262 targetMesh->insertNextCell(INTERP_KERNEL::NORM_POLYGON,4,targetConn+20);
1263 targetMesh->finishInsertingCells();
1264 DataArrayDouble *myCoords=DataArrayDouble::New();
1265 myCoords->alloc(12,3);
1266 myCoords->setInfoOnComponent(0,"toto [m]");
1267 myCoords->setInfoOnComponent(2,"ff [km]");//component 1 is not set for test
1268 std::copy(targetCoords,targetCoords+36,myCoords->getPointer());
1269 targetMesh->setCoords(myCoords);
1270 myCoords->decrRef();
1274 MEDCouplingUMesh *MEDLoaderTest::build3DMesh_1()
1276 double coords[180]={
1277 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.,
1278 3.,2.,0., 0.,1.,0., 1.,3.,0., 2.,2.,0., 2.,3.,0.,
1279 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.,
1280 3.,2.,1., 0.,1.,1., 1.,3.,1., 2.,2.,1., 2.,3.,1.,
1281 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.,
1282 3.,2.,2., 0.,1.,2., 1.,3.,2., 2.,2.,2., 2.,3.,2.,
1283 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.,
1284 3.,2.,3., 0.,1.,3., 1.,3.,3., 2.,2.,3., 2.,3.,3.};
1288 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,
1289 1,6,5,3,16,21,20,18, 13,10,9,6,28,25,24,21,
1290 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,
1291 7,12,14,13,22,27,29,28,
1293 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,
1294 16,21,20,18,31,36,35,33, 28,25,24,21,43,40,39,36,
1295 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,
1296 22,27,29,28,37,42,44,43,
1298 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,
1299 31,36,35,33,46,51,50,48, 43,40,39,36,58,55,54,51,
1300 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,
1301 37,42,44,43,52,57,59,58
1304 MEDCouplingUMesh *ret=MEDCouplingUMesh::New();
1305 ret->setName("3DMesh_1");
1306 ret->setMeshDimension(3);
1307 ret->allocateCells(18);
1309 ret->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn);
1310 ret->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn+51);
1311 ret->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn+59);
1312 ret->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn+110);
1314 ret->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn+118);
1315 ret->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn+169);
1316 ret->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn+177);
1317 ret->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn+228);
1319 ret->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn+236);
1320 ret->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn+287);
1321 ret->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn+295);
1322 ret->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn+346);
1324 ret->insertNextCell(INTERP_KERNEL::NORM_POLYHED,43,conn+8);
1325 ret->insertNextCell(INTERP_KERNEL::NORM_POLYHED,43,conn+67);
1326 ret->insertNextCell(INTERP_KERNEL::NORM_POLYHED,43,conn+126);
1327 ret->insertNextCell(INTERP_KERNEL::NORM_POLYHED,43,conn+185);
1328 ret->insertNextCell(INTERP_KERNEL::NORM_POLYHED,43,conn+244);
1329 ret->insertNextCell(INTERP_KERNEL::NORM_POLYHED,43,conn+303);
1331 ret->finishInsertingCells();
1332 DataArrayDouble *myCoords=DataArrayDouble::New();
1333 myCoords->alloc(60,3);
1334 myCoords->setInfoOnComponent(0,"titi [m]");
1335 myCoords->setInfoOnComponent(1,"density power [MW/m^3]");
1336 myCoords->setInfoOnComponent(2,"t [kW]");
1337 std::copy(coords,coords+180,myCoords->getPointer());
1338 ret->setCoords(myCoords);
1339 myCoords->decrRef();
1343 MEDCouplingUMesh *MEDLoaderTest::build3DMesh_2()
1345 MEDCouplingUMesh *m3dsurfBase=build3DSurfMesh_1();
1346 int numbers[5]={0,1,2,3,5};
1347 MEDCouplingUMesh *m3dsurf=(MEDCouplingUMesh *)m3dsurfBase->buildPartOfMySelf(numbers,numbers+5,false);
1348 m3dsurfBase->decrRef();
1349 MEDCouplingUMesh *m1dBase=build1DMesh_1();
1350 int numbers2[4]={0,1,2,3};
1351 MEDCouplingUMesh *m1d=(MEDCouplingUMesh *)m1dBase->buildPartOfMySelf(numbers2,numbers2+4,false);
1353 m1d->changeSpaceDimension(3);
1354 const double vec[3]={0.,1.,0.};
1355 const double pt[3]={0.,0.,0.};
1356 m1d->rotate(pt,vec,-M_PI/2.);
1357 MEDCouplingUMesh *ret=m3dsurf->buildExtrudedMesh(m1d,0);
1363 MEDCouplingFieldDouble *MEDLoaderTest::buildVecFieldOnCells_1()
1365 MEDCouplingUMesh *mesh=build3DSurfMesh_1();
1366 int nbOfCells=mesh->getNumberOfCells();
1367 MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
1368 f1->setName("VectorFieldOnCells");
1370 DataArrayDouble *array=DataArrayDouble::New();
1371 array->alloc(nbOfCells,3);
1372 array->setInfoOnComponent(0,"power [MW/m^3]");
1373 array->setInfoOnComponent(1,"density [g/cm^3]");
1374 array->setInfoOnComponent(2,"temperature [K]");
1375 f1->setArray(array);
1377 double *tmp=array->getPointer();
1378 const double arr1[18]={0.,10.,20.,1.,11.,21.,2.,12.,22.,3.,13.,23.,4.,14.,24.,5.,15.,25.};
1379 std::copy(arr1,arr1+18,tmp);
1380 f1->setTime(2.,0,1);
1381 f1->checkConsistencyLight();
1386 MEDCouplingFieldDouble *MEDLoaderTest::buildVecFieldOnNodes_1()
1388 MEDCouplingUMesh *mesh=build3DSurfMesh_1();
1389 int nbOfNodes=mesh->getNumberOfNodes();
1390 MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_NODES,ONE_TIME);
1391 f1->setName("VectorFieldOnNodes");
1393 DataArrayDouble *array=DataArrayDouble::New();
1394 array->alloc(nbOfNodes,3);
1395 f1->setArray(array);
1396 array->setInfoOnComponent(0,"power [MW/m^3]");
1397 array->setInfoOnComponent(1,"density [g/cm^3]");
1398 array->setInfoOnComponent(2,"temperature [K]");
1400 double *tmp=array->getPointer();
1401 const double arr1[36]={
1402 70.,80.,90.,71.,81.,91.,72.,82.,92.,73.,83.,93.,74.,84.,94.,75.,85.,95.,
1403 1000.,10010.,10020.,1001.,10011.,10021.,1002.,10012.,10022.,1003.,10013.,10023.,1004.,10014.,10024.,1005.,10015.,10025.,
1405 std::copy(arr1,arr1+36,tmp);
1406 f1->setTime(2.12,2,3);
1407 f1->checkConsistencyLight();
1412 MEDCouplingFieldDouble *MEDLoaderTest::buildVecFieldOnGauss_1()
1414 const double _a=0.446948490915965;
1415 const double _b=0.091576213509771;
1416 const double _p1=0.11169079483905;
1417 const double _p2=0.0549758718227661;
1418 const double refCoo1[6]={ 0.,0., 1.,0., 0.,1. };
1419 const double gsCoo1[12]={ 2*_b-1, 1-4*_b, 2*_b-1, 2.07*_b-1, 1-4*_b,
1420 2*_b-1, 1-4*_a, 2*_a-1, 2*_a-1, 1-4*_a, 2*_a-1, 2*_a-1 };
1421 const double wg1[6]={ 4*_p2, 4*_p2, 4*_p2, 4*_p1, 4*_p1, 4*_p1 };
1422 std::vector<double> _refCoo1(refCoo1,refCoo1+6);
1423 std::vector<double> _gsCoo1(gsCoo1,gsCoo1+12);
1424 std::vector<double> _wg1(wg1,wg1+6);
1425 MEDCouplingUMesh *m=build2DMesh_2();
1426 MEDCouplingFieldDouble *f=MEDCouplingFieldDouble::New(ON_GAUSS_PT,ONE_TIME);
1427 f->setTime(3.14,1,5);
1429 f->setGaussLocalizationOnType(INTERP_KERNEL::NORM_TRI3,_refCoo1,_gsCoo1,_wg1);
1430 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 };
1431 std::vector<double> _refCoo2(refCoo2,refCoo2+12);
1432 std::vector<double> _gsCoo2(_gsCoo1);
1433 std::vector<double> _wg2(_wg1);
1434 _gsCoo2.resize(6); _wg2.resize(3);
1435 const double refCoo3[8]={ 0.,0., 1.,0., 1.,1., 0.,1. };
1436 std::vector<double> _refCoo3(refCoo3,refCoo3+8);
1437 _gsCoo1.resize(4); _wg1.resize(2);
1438 f->setGaussLocalizationOnType(INTERP_KERNEL::NORM_QUAD4,_refCoo3,_gsCoo1,_wg1);
1439 f->setGaussLocalizationOnType(INTERP_KERNEL::NORM_TRI6,_refCoo2,_gsCoo2,_wg2);
1440 DataArrayDouble *array=DataArrayDouble::New();
1442 double *ptr=array->getPointer();
1443 for(int i=0;i<19*2;i++)
1444 ptr[i]=(double)(i+7);
1446 f->setName("MyFirstFieldOnGaussPoint");
1447 array->setInfoOnComponent(0,"power [MW/m^3]");
1448 array->setInfoOnComponent(1,"density");
1450 f->checkConsistencyLight();
1455 MEDCouplingFieldDouble *MEDLoaderTest::buildVecFieldOnGaussNE_1()
1457 MEDCouplingUMesh *m=build2DMesh_2();
1458 MEDCouplingFieldDouble *f=MEDCouplingFieldDouble::New(ON_GAUSS_NE,ONE_TIME);
1459 f->setTime(3.14,1,5);
1461 DataArrayDouble *array=DataArrayDouble::New();
1463 double *ptr=array->getPointer();
1464 for(int i=0;i<20*2;i++)
1465 ptr[i]=(double)(i+8);
1467 array->setInfoOnComponent(0,"power [W]");
1468 array->setInfoOnComponent(1,"temperature");
1469 f->setName("MyFieldOnGaussNE");
1471 f->checkConsistencyLight();