1 // Copyright (C) 2007-2015 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->checkCoherency();
38 MEDLoader::WriteUMesh("file1.med",mesh,true);
39 MEDCouplingUMesh *mesh_rw=MEDLoader::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->checkCoherency();
49 MEDLoader::WriteUMesh("file2.med",mesh,true);
50 MEDCouplingUMesh *mesh_rw=MEDLoader::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->checkCoherency();
60 MEDLoader::WriteUMesh("file3.med",mesh,true);
61 MEDCouplingUMesh *mesh_rw=MEDLoader::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->checkCoherency();
71 MEDLoader::WriteUMesh("file4.med",mesh,true);
72 MEDCouplingUMesh *mesh_rw=MEDLoader::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->checkCoherency();
82 MEDLoader::WriteUMesh("file5.med",mesh,true);
83 MEDCouplingUMesh *mesh_rw=MEDLoader::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 MEDLoader::WriteField("file6.med",f1,true);
96 MEDCouplingFieldDouble *f2=MEDLoader::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 MEDLoader::WriteField("file7.med",f1,true);
103 f2=MEDLoader::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(MEDLoader::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 MEDLoader::WriteField(fileName,f1,true);
122 f1->setTime(10.,8,9);
123 double *tmp=f1->getArray()->getPointer();
125 MEDLoader::WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
126 f1->setTime(10.14,18,19);
128 MEDLoader::WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
129 //retrieving time steps...
130 MEDCouplingFieldDouble *f2=MEDLoader::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=MEDLoader::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=MEDLoader::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(MEDLoader::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 MEDLoader::WriteField(fileName2,f1,true);
152 f1->setTime(110.,108,109);
153 tmp=f1->getArray()->getPointer();
155 MEDLoader::WriteFieldUsingAlreadyWrittenMesh(fileName2,f1);
156 f1->setTime(210.,208,209);
158 MEDLoader::WriteFieldUsingAlreadyWrittenMesh(fileName2,f1);
159 f2=MEDLoader::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=MEDLoader::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=MEDLoader::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 MEDLoader::WriteField(fileName,f1,true);
194 f1->setTime(10.14,18,19);
196 MEDLoader::WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
197 f1->setTime(10.55,28,29);
199 MEDLoader::WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
200 f1->setTime(10.66,38,39);
202 MEDLoader::WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
203 f1->setTime(10.77,48,49);
205 MEDLoader::WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
208 f1=buildVecFieldOnNodes_1();
210 (const_cast<MEDCouplingMesh *>(f1->getMesh()))->setName(name3);
211 f1->setTime(110.,8,9);
212 MEDLoader::WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
213 f1->setTime(110.,108,109);
214 tmp=f1->getArray()->getPointer();
216 MEDLoader::WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
217 f1->setTime(210.,208,209);
219 MEDLoader::WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
221 std::vector< std::pair<int,int> > it1=MEDLoader::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=MEDLoader::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=MEDLoader::ReadFieldCell(fileName,name3,0,name1,8,9);
237 CPPUNIT_ASSERT_DOUBLES_EQUAL(VAL1,f1->getArray()->getConstPointer()[0],1e-13);
239 f1=MEDLoader::ReadFieldCell(fileName,name3,0,name1,18,19);
240 CPPUNIT_ASSERT_DOUBLES_EQUAL(VAL2,f1->getArray()->getConstPointer()[0],1e-13);
242 f1=MEDLoader::ReadFieldCell(fileName,name3,0,name1,28,29);
243 CPPUNIT_ASSERT_DOUBLES_EQUAL(3*VAL1,f1->getArray()->getConstPointer()[0],1e-13);
245 f1=MEDLoader::ReadFieldCell(fileName,name3,0,name1,38,39);
246 CPPUNIT_ASSERT_DOUBLES_EQUAL(3*VAL2,f1->getArray()->getConstPointer()[0],1e-13);
248 f1=MEDLoader::ReadFieldCell(fileName,name3,0,name1,48,49);
249 CPPUNIT_ASSERT_DOUBLES_EQUAL(4*VAL2,f1->getArray()->getConstPointer()[0],1e-13);
252 f1=MEDLoader::ReadFieldNode(fileName,name3,0,name1,8,9);
253 CPPUNIT_ASSERT_DOUBLES_EQUAL(71.,f1->getArray()->getConstPointer()[3],1e-13);
255 f1=MEDLoader::ReadFieldNode(fileName,name3,0,name1,108,109);
256 CPPUNIT_ASSERT_DOUBLES_EQUAL(VAL1,f1->getArray()->getConstPointer()[3],1e-13);
258 f1=MEDLoader::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 MEDLoader::WriteUMeshesPartition(fileName,mnane,meshes,true);
289 MEDCouplingUMesh *mesh5=MEDLoader::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=MEDLoader::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=MEDLoader::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=MEDLoader::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=MEDLoader::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=MEDLoader::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=MEDLoader::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(MEDLoader::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=MEDLoader::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 MEDLoader::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->checkCoherency();
378 MEDLoader::WriteField(fileName,f1,false);//<- false important for the test
380 MEDCouplingFieldDouble *f2=MEDLoader::ReadFieldCell(fileName,f1->getMesh()->getName().c_str(),0,f1->getName().c_str(),2,7);
381 std::vector<MEDCoupling::TypeOfField> types=MEDLoader::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->checkCoherency();
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 MEDLoader::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->checkCoherency();
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 MEDLoader::WriteField(fileName,f2,false);//<- false important for the test
421 MEDCouplingFieldDouble *f3=MEDLoader::ReadFieldNode(fileName,f2->getMesh()->getName().c_str(),0,f2->getName().c_str(),2,7);
422 f3->checkCoherency();
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 MEDLoader::WriteUMesh(fileName2,m,true);
429 MEDLoader::WriteField(fileName2,f2,false);//<- false important for the test
430 f3=MEDLoader::ReadFieldNode(fileName2,f2->getMesh()->getName().c_str(),0,f2->getName().c_str(),2,7);
431 f3->checkCoherency();
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 MEDLoader::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->checkCoherency();
466 MEDLoader::WriteField(fileName,f1,false);//<- false important for the test
467 MEDCouplingFieldDouble *f2=MEDLoader::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 MEDLoader::WriteField(fileName,f1,true);
480 MEDCouplingFieldDouble *f2=MEDLoader::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));
486 void MEDLoaderTest::testFieldGaussNERW1()
488 const char fileName[]="file14.med";
489 MEDCouplingFieldDouble *f1=buildVecFieldOnGaussNE_1();
490 MEDLoader::WriteField(fileName,f1,true);
491 std::vector<MEDCoupling::TypeOfField> tof(MEDLoader::GetTypesOfField(fileName,"2DMesh_2","MyFieldOnGaussNE"));
492 CPPUNIT_ASSERT_EQUAL(1,(int)tof.size());
493 CPPUNIT_ASSERT(ON_GAUSS_NE==tof[0]);
494 MEDCouplingFieldDouble *f2=MEDLoader::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));
500 void MEDLoaderTest::testLittleStrings1()
502 std::string s("azeeeerrrtty");
503 MEDLoaderBase::zipEqualConsChar(s,3);
504 CPPUNIT_ASSERT(s=="azertty");
507 void MEDLoaderTest::testSplitIntoNameAndUnit1()
509 std::string s(" []");
511 MEDLoaderBase::splitIntoNameAndUnit(s,c,u);
512 CPPUNIT_ASSERT(c.empty());
513 CPPUNIT_ASSERT(u.empty());
515 MEDLoaderBase::strip(s);
516 CPPUNIT_ASSERT(s=="lmmm kki jjj");
518 MEDLoaderBase::strip(s);
519 CPPUNIT_ASSERT(s.empty());
521 MEDLoaderBase::strip(s);
522 CPPUNIT_ASSERT(s.empty());
524 MEDLoaderBase::strip(s);
525 CPPUNIT_ASSERT(s.empty());
527 MEDLoaderBase::strip(s);
528 CPPUNIT_ASSERT(s=="pp");
531 void MEDLoaderTest::testMesh3DSurfShuffleRW()
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->checkCoherency();
538 MEDLoader::WriteUMesh(fileName,mesh,true);
539 MEDCouplingUMesh *mesh_rw=MEDLoader::ReadUMeshFromFile(fileName,mesh->getName().c_str(),0);
540 CPPUNIT_ASSERT(mesh->isEqual(mesh_rw,1e-12));
545 void MEDLoaderTest::testFieldShuffleRW1()
547 const char fileName[]="file16.med";
548 MEDCouplingUMesh *mesh=build3DSurfMesh_1();
549 MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
550 f1->setName("FieldOnCellsShuffle");
552 DataArrayDouble *array=DataArrayDouble::New();
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->checkCoherency();
562 const int renumber1[6]={2,1,5,0,3,4};
563 f1->renumberCells(renumber1,false);
564 MEDLoader::WriteField(fileName,f1,true);
565 MEDCouplingFieldDouble *f2=MEDLoader::ReadFieldCell(fileName,mesh->getName().c_str(),0,f1->getName().c_str(),2,7);
566 CPPUNIT_ASSERT(f2->isEqual(f1,1e-12,1e-12));
574 * Shuffle de cells but no profile. Like pointe.med
576 void MEDLoaderTest::testMultiFieldShuffleRW1()
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();
589 MEDLoader::WriteUMesh(fileName,m,true);
590 MEDCouplingFieldDouble *f1Tmp=m->getMeasureField(false);
591 MEDCouplingFieldDouble *f1=f1Tmp->buildNewTimeReprFromThis(ONE_TIME,false);
594 MEDCouplingFieldDouble *f_1=f1->cloneWithMesh(true);
595 MEDLoader::WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
596 f1->applyFunc("2*x");
597 f1->setTime(0.01,3,4);
598 MEDCouplingFieldDouble *f_2=f1->cloneWithMesh(true);
599 MEDLoader::WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
600 f1->applyFunc("2*x/3");
601 f1->setTime(0.02,5,6);
602 MEDCouplingFieldDouble *f_3=f1->cloneWithMesh(true);
603 MEDLoader::WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
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=MEDLoader::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++)
628 void MEDLoaderTest::testWriteUMeshesRW1()
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 MEDLoader::WriteUMeshes(fileName,meshes,true);
644 MEDCouplingUMesh *m3d_bis=MEDLoader::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=MEDLoader::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");
654 DataArrayDouble *array=DataArrayDouble::New();
655 array->alloc(m2d->getNumberOfCells(),2);
656 array->setInfoOnComponent(0,"plkj [mm]");
657 array->setInfoOnComponent(1,"pqqqss [mm]");
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->checkCoherency();
665 MEDLoader::WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
666 MEDCouplingFieldDouble *f2=MEDLoader::ReadFieldCell(fileName,f1->getMesh()->getName().c_str(),-1,f1->getName().c_str(),2,7);
667 CPPUNIT_ASSERT(f2->isEqual(f1,1e-12,1e-12));
677 void MEDLoaderTest::testMixCellAndNodesFieldRW1()
679 const char fileName[]="file21.med";
680 MEDCouplingUMesh *mesh=build3DSurfMesh_1();
681 MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
682 f1->setName("FieldMix");
684 DataArrayDouble *array=DataArrayDouble::New();
687 array->setInfoOnComponent(0,"plkj [mm]");
688 array->setInfoOnComponent(1,"pqqqss [mm]");
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->checkCoherency();
696 MEDCouplingFieldDouble *f2=MEDCouplingFieldDouble::New(ON_NODES,ONE_TIME);
697 f2->setName("FieldMix");
699 array=DataArrayDouble::New();
702 array->setInfoOnComponent(0,"plkj [mm]");
703 array->setInfoOnComponent(1,"pqqqss [mm]");
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.
710 std::copy(arr2,arr2+24,tmp);
711 f2->setTime(3.14,2,7);
712 f2->checkCoherency();
714 MEDLoader::WriteField(fileName,f1,true);
715 std::vector<MEDCoupling::TypeOfField> ts=MEDLoader::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=MEDLoader::GetAllFieldNamesOnMesh(fileName,f1->getMesh()->getName().c_str());
719 CPPUNIT_ASSERT_EQUAL(1,(int)fs.size());
720 CPPUNIT_ASSERT(fs[0]=="FieldMix");
721 MEDLoader::WriteFieldUsingAlreadyWrittenMesh(fileName,f2);
722 fs=MEDLoader::GetAllFieldNamesOnMesh(fileName,f1->getMesh()->getName().c_str());
723 CPPUNIT_ASSERT_EQUAL(1,(int)fs.size());
724 CPPUNIT_ASSERT(fs[0]=="FieldMix");
726 ts=MEDLoader::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]);
731 MEDCouplingFieldDouble *f3=MEDLoader::ReadFieldNode(fileName,f1->getMesh()->getName().c_str(),0,f1->getName().c_str(),2,7);
732 CPPUNIT_ASSERT(f3->isEqual(f2,1e-12,1e-12));
734 f3=MEDLoader::ReadFieldCell(fileName,f1->getMesh()->getName().c_str(),0,f1->getName().c_str(),2,7);
735 CPPUNIT_ASSERT(f3->isEqual(f1,1e-12,1e-12));
743 void MEDLoaderTest::testGetAllFieldNamesRW1()
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);
751 f1->fillFromAnalytic(2,"x+y");
752 MEDLoader::WriteField(fileName,f1,true);
753 f1->setTime(1002.3,7,8);
754 f1->fillFromAnalytic(2,"x+77.*y");
755 MEDLoader::WriteFieldUsingAlreadyWrittenMesh(fileName,f1);
756 f1->setName("Field2");
757 MEDLoader::WriteField(fileName,f1,false);
758 f1->setName("Field3");
759 mesh->setName("2DMesh_2Bis");
760 MEDLoader::WriteField(fileName,f1,false);
762 f1=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
763 f1->setName("Field8");
764 f1->setTime(8.99,7,9);
766 f1->fillFromAnalytic(3,"3*x+y");
767 MEDLoader::WriteField(fileName,f1,false);
769 std::vector<std::string> fs=MEDLoader::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");
779 void MEDLoaderTest::testMEDLoaderRead1()
782 using namespace INTERP_KERNEL;
784 string fileName= INTERP_TEST::getResourceFile("pointe.med", 3);
785 vector<string> meshNames=MEDLoader::GetMeshNames(fileName.c_str());
786 CPPUNIT_ASSERT_EQUAL(1,(int)meshNames.size());
787 MEDCouplingUMesh *mesh=MEDLoader::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);
805 vector<string> families=MEDLoader::GetMeshFamiliesNames(fileName.c_str(),meshNames[0].c_str());
806 CPPUNIT_ASSERT_EQUAL(8,(int)families.size());
807 CPPUNIT_ASSERT(families[2]=="FAMILLE_ELEMENT_3");
809 vector<string> families2;
810 families2.push_back(families[2]);
811 mesh=MEDLoader::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);
825 vector<string> groups=MEDLoader::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=MEDLoader::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());
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);
849 std::vector<std::string> fieldsName=MEDLoader::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=MEDLoader::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=MEDLoader::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);
862 MEDCouplingFieldDouble *field0=MEDLoader::ReadFieldCell(fileName.c_str(),meshNames[0].c_str(),0,fieldsName[0].c_str(),its0[0].first,its0[0].second);
863 field0->checkCoherency();
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);
891 MEDCouplingFieldDouble *field1=MEDLoader::ReadFieldCell(fileName.c_str(),meshNames[0].c_str(),0,fieldsName[1].c_str(),its1[0].first,its1[0].second);
892 field1->checkCoherency();
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);
920 std::vector<std::string> fieldsNameNode=MEDLoader::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=MEDLoader::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=MEDLoader::ReadFieldNode(fileName.c_str(),meshNames[0].c_str(),0,fieldsNameNode[0].c_str(),its0Node[0].first,its0Node[0].second);
933 field0Nodes->checkCoherency();
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();
946 field0Nodes=MEDLoader::ReadFieldNode(fileName.c_str(),meshNames[0].c_str(),0,fieldsNameNode[0].c_str(),its0Node[2].first,its0Node[2].second);
947 field0Nodes->checkCoherency();
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();
974 field0Nodes=MEDLoader::ReadFieldNode(fileName.c_str(),meshNames[0].c_str(),0,fieldsNameNode[0].c_str(),its0Node[0].first,its0Node[0].second);
975 field0Nodes->checkCoherency();
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();
1003 void MEDLoaderTest::testMEDLoaderPolygonRead()
1005 using namespace std;
1006 using namespace INTERP_KERNEL;
1008 string fileName=INTERP_TEST::getResourceFile("polygones.med", 3);
1009 vector<string> meshNames=MEDLoader::GetMeshNames(fileName.c_str());
1010 CPPUNIT_ASSERT_EQUAL(1,(int)meshNames.size());
1011 CPPUNIT_ASSERT(meshNames[0]=="Bord");
1012 MEDCouplingUMesh *mesh=MEDLoader::ReadUMeshFromFile(fileName.c_str(),meshNames[0].c_str(),0);
1013 mesh->checkCoherency();
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));
1034 std::vector<std::string> fieldsName=MEDLoader::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=MEDLoader::GetCellFieldIterations(fileName.c_str(),meshNames[0].c_str(),fieldsName[0].c_str());
1040 CPPUNIT_ASSERT_EQUAL(1,(int)its0.size());
1041 MEDCouplingFieldDouble *field=MEDLoader::ReadFieldCell(fileName.c_str(),meshNames[0].c_str(),0,fieldsName[0].c_str(),its0[0].first,its0[0].second);
1042 field->checkCoherency();
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);
1069 void MEDLoaderTest::testMEDLoaderPolyhedronRead()
1071 using namespace std;
1072 using namespace INTERP_KERNEL;
1074 string fileName=INTERP_TEST::getResourceFile("poly3D.med", 3);
1075 vector<string> meshNames=MEDLoader::GetMeshNames(fileName.c_str());
1076 CPPUNIT_ASSERT_EQUAL(1,(int)meshNames.size());
1077 CPPUNIT_ASSERT(meshNames[0]=="poly3D");
1078 MEDCouplingUMesh *mesh=MEDLoader::ReadUMeshFromFile(fileName.c_str(),meshNames[0].c_str(),0);
1079 mesh->checkCoherency();
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));
1094 mesh=MEDLoader::ReadUMeshFromFile(fileName.c_str(),meshNames[0].c_str(),-1);
1095 mesh->checkCoherency();
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));
1123 vector<string> families=MEDLoader::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=MEDLoader::ReadUMeshFromFamilies(fileName.c_str(),meshNames[0].c_str(),-1,families2);
1132 mesh->checkCoherency();
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));
1144 mesh=MEDLoader::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());
1153 MEDCouplingUMesh *MEDLoaderTest::build1DMesh_1()
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();
1175 MEDCouplingUMesh *MEDLoaderTest::build2DCurveMesh_1()
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();
1196 MEDCouplingUMesh *MEDLoaderTest::build2DMesh_1()
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();
1221 MEDCouplingUMesh *MEDLoaderTest::build2DMesh_2()
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
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();
1248 MEDCouplingUMesh *MEDLoaderTest::build3DSurfMesh_1()
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
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();
1276 MEDCouplingUMesh *MEDLoaderTest::build3DMesh_1()
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.};
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,
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,
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
1306 MEDCouplingUMesh *ret=MEDCouplingUMesh::New();
1307 ret->setName("3DMesh_1");
1308 ret->setMeshDimension(3);
1309 ret->allocateCells(18);
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);
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);
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);
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);
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();
1345 MEDCouplingUMesh *MEDLoaderTest::build3DMesh_2()
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);
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);
1365 MEDCouplingFieldDouble *MEDLoaderTest::buildVecFieldOnCells_1()
1367 MEDCouplingUMesh *mesh=build3DSurfMesh_1();
1368 int nbOfCells=mesh->getNumberOfCells();
1369 MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
1370 f1->setName("VectorFieldOnCells");
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);
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->checkCoherency();
1388 MEDCouplingFieldDouble *MEDLoaderTest::buildVecFieldOnNodes_1()
1390 MEDCouplingUMesh *mesh=build3DSurfMesh_1();
1391 int nbOfNodes=mesh->getNumberOfNodes();
1392 MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_NODES,ONE_TIME);
1393 f1->setName("VectorFieldOnNodes");
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]");
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.,
1407 std::copy(arr1,arr1+36,tmp);
1408 f1->setTime(2.12,2,3);
1409 f1->checkCoherency();
1414 MEDCouplingFieldDouble *MEDLoaderTest::buildVecFieldOnGauss_1()
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);
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();
1444 double *ptr=array->getPointer();
1445 for(int i=0;i<19*2;i++)
1446 ptr[i]=(double)(i+7);
1448 f->setName("MyFirstFieldOnGaussPoint");
1449 array->setInfoOnComponent(0,"power [MW/m^3]");
1450 array->setInfoOnComponent(1,"density");
1452 f->checkCoherency();
1457 MEDCouplingFieldDouble *MEDLoaderTest::buildVecFieldOnGaussNE_1()
1459 MEDCouplingUMesh *m=build2DMesh_2();
1460 MEDCouplingFieldDouble *f=MEDCouplingFieldDouble::New(ON_GAUSS_NE,ONE_TIME);
1461 f->setTime(3.14,1,5);
1463 DataArrayDouble *array=DataArrayDouble::New();
1465 double *ptr=array->getPointer();
1466 for(int i=0;i<20*2;i++)
1467 ptr[i]=(double)(i+8);
1469 array->setInfoOnComponent(0,"power [W]");
1470 array->setInfoOnComponent(1,"temperature");
1471 f->setName("MyFieldOnGaussNE");
1473 f->checkCoherency();