1 // Copyright (C) 2007-2012 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.
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 "MEDCouplingBasicsTest1.hxx"
22 #include "MEDCouplingUMesh.hxx"
23 #include "MEDCouplingCMesh.hxx"
24 #include "MEDCouplingExtrudedMesh.hxx"
25 #include "MEDCouplingFieldDouble.hxx"
26 #include "MEDCouplingMemArray.hxx"
33 using namespace ParaMEDMEM;
35 void MEDCouplingBasicsTest1::testArray()
37 int tmp1[6]={7,6,5,4,3,2};
38 const int tmp2[3]={8,9,10};
41 mem.useArray(tmp1,false,CPP_DEALLOC,6);
42 CPPUNIT_ASSERT(tmp1==mem.getConstPointer());
43 CPPUNIT_ASSERT_THROW(mem.getPointer(),INTERP_KERNEL::Exception);
44 CPPUNIT_ASSERT_THROW(mem[2]=7,INTERP_KERNEL::Exception);
45 CPPUNIT_ASSERT_THROW(mem.writeOnPlace(0,12,tmp2,3),INTERP_KERNEL::Exception);
46 mem.writeOnPlace(4,12,tmp2,3);
50 std::copy(tmp1,tmp1+6,tmp3);
52 mem2.useArray(tmp3,true,CPP_DEALLOC,6);
53 CPPUNIT_ASSERT(tmp3==mem2.getConstPointer());
54 CPPUNIT_ASSERT(tmp3==mem2.getPointer());
55 CPPUNIT_ASSERT_EQUAL(5,mem2[2]);
57 CPPUNIT_ASSERT_EQUAL(7,mem2[2]);
58 mem2.writeOnPlace(0,12,tmp2,3);
59 CPPUNIT_ASSERT_EQUAL(9,mem2[2]);
60 CPPUNIT_ASSERT_EQUAL(12,mem2[0]);
61 mem2.writeOnPlace(4,12,tmp2,3);
65 void MEDCouplingBasicsTest1::testArray2()
67 DataArrayDouble *arr=DataArrayDouble::New();
69 double *tmp=arr->getPointer();
70 const double arrRef[12]={12.,11.,10.,9.,8.,7.,6.,5.,4.,3.,2.,1.};
71 std::copy(arrRef,arrRef+12,tmp);
72 arr->setInfoOnComponent(0,"ggg");
73 arr->setInfoOnComponent(1,"hhhh");
74 arr->setInfoOnComponent(2,"jj");
75 arr->setInfoOnComponent(3,"kkkkkk");
76 DataArrayInt *arr2=arr->convertToIntArr();
77 DataArrayDouble *arr3=arr2->convertToDblArr();
79 CPPUNIT_ASSERT(arr->isEqual(*arr3,1e-14));
84 void MEDCouplingBasicsTest1::testArray3()
86 DataArrayInt *arr1=DataArrayInt::New();
88 int *tmp=arr1->getPointer();
89 const int arr1Ref[14]={0,10,1,11,2,12,3,13,4,14,5,15,6,16};
90 std::copy(arr1Ref,arr1Ref+14,tmp);
91 CPPUNIT_ASSERT_EQUAL(7,arr1->getNumberOfTuples());
92 CPPUNIT_ASSERT_EQUAL(2,arr1->getNumberOfComponents());
93 CPPUNIT_ASSERT(std::equal(arr1Ref,arr1Ref+14,arr1->getConstPointer()));
94 DataArrayInt *arr2=arr1->substr(3);
95 CPPUNIT_ASSERT_EQUAL(4,arr2->getNumberOfTuples());
96 CPPUNIT_ASSERT_EQUAL(2,arr2->getNumberOfComponents());
97 CPPUNIT_ASSERT(std::equal(arr1Ref+6,arr1Ref+14,arr2->getConstPointer()));
99 DataArrayInt *arr3=arr1->substr(2,5);
100 CPPUNIT_ASSERT_EQUAL(3,arr3->getNumberOfTuples());
101 CPPUNIT_ASSERT_EQUAL(2,arr3->getNumberOfComponents());
102 CPPUNIT_ASSERT(std::equal(arr1Ref+4,arr1Ref+10,arr3->getConstPointer()));
106 DataArrayDouble *arr4=DataArrayDouble::New();
108 double *tmp2=arr4->getPointer();
109 const double arr4Ref[14]={0.8,10.8,1.9,11.9,2.1,12.1,3.2,13.2,4.3,14.3,5.4,15.4,6.5,16.5};
110 std::copy(arr4Ref,arr4Ref+14,tmp2);
111 CPPUNIT_ASSERT_EQUAL(7,arr4->getNumberOfTuples());
112 CPPUNIT_ASSERT_EQUAL(2,arr4->getNumberOfComponents());
113 CPPUNIT_ASSERT(std::equal(arr4Ref,arr4Ref+14,arr4->getConstPointer()));
114 DataArrayDouble *arr5=arr4->substr(3);
115 CPPUNIT_ASSERT_EQUAL(4,arr5->getNumberOfTuples());
116 CPPUNIT_ASSERT_EQUAL(2,arr5->getNumberOfComponents());
117 CPPUNIT_ASSERT(std::equal(arr4Ref+6,arr4Ref+14,arr5->getConstPointer()));
119 DataArrayDouble *arr6=arr4->substr(2,5);
120 CPPUNIT_ASSERT_EQUAL(3,arr6->getNumberOfTuples());
121 CPPUNIT_ASSERT_EQUAL(2,arr6->getNumberOfComponents());
122 CPPUNIT_ASSERT(std::equal(arr4Ref+4,arr4Ref+10,arr6->getConstPointer()));
127 void MEDCouplingBasicsTest1::testMesh()
129 const int nbOfCells=6;
130 const int nbOfNodes=12;
132 double coords[3*nbOfNodes]={
133 0.024155, 0.04183768725682622, -0.305, 0.04831000000000001, -1.015761910347357e-17, -0.305, 0.09662000000000001, -1.832979297858306e-18,
134 -0.305, 0.120775, 0.04183768725682623, -0.305, 0.09662000000000001, 0.08367537451365245, -0.305, 0.04831000000000001,
135 0.08367537451365246, -0.305, 0.024155, 0.04183768725682622, -0.2863, 0.04831000000000001, -1.015761910347357e-17, -0.2863,
136 0.09662000000000001, -1.832979297858306e-18, -0.2863, 0.120775, 0.04183768725682623, -0.2863, 0.09662000000000001, 0.08367537451365245,
137 -0.2863, 0.04831000000000001, 0.08367537451365246, -0.2863, };
139 int tab4[4*nbOfCells]={
140 1, 2, 8, 7, 2, 3, 9, 8, 3, 4, 10, 9, 4, 5, 11, 10, 5, 0, 6, 11,
143 MEDCouplingUMesh *mesh=MEDCouplingUMesh::New();
144 mesh->setMeshDimension(2);
145 mesh->allocateCells(8);
146 const int *curConn=tab4;
147 for(int i=0;i<nbOfCells;i++,curConn+=4)
148 mesh->insertNextCell(INTERP_KERNEL::NORM_QUAD4,4,curConn);
149 mesh->finishInsertingCells();
150 CPPUNIT_ASSERT_EQUAL(30,mesh->getNodalConnectivity()->getNbOfElems());
151 CPPUNIT_ASSERT_EQUAL(nbOfCells,mesh->getNumberOfCells());
152 //test 0 - no copy no ownership
153 DataArrayDouble *myCoords=DataArrayDouble::New();
154 myCoords->useArray(coords,false,CPP_DEALLOC,nbOfNodes,3);
155 mesh->setCoords(myCoords);
156 mesh->setCoords(myCoords);
158 CPPUNIT_ASSERT_EQUAL(nbOfCells,mesh->getNumberOfCells());
159 mesh->checkCoherency();
160 //test 1 - no copy ownership C++
161 myCoords=DataArrayDouble::New();
162 double *tmp=new double[3*nbOfNodes];
163 std::copy(coords,coords+3*nbOfNodes,tmp);
164 myCoords->useArray(tmp,true,CPP_DEALLOC,nbOfNodes,3);
165 mesh->setCoords(myCoords);
167 CPPUNIT_ASSERT_EQUAL(nbOfCells,mesh->getNumberOfCells());
168 mesh->checkCoherency();
169 //test 2 - no copy ownership C
170 myCoords=DataArrayDouble::New();
171 tmp=(double *)malloc(3*nbOfNodes*sizeof(double));
172 std::copy(coords,coords+3*nbOfNodes,tmp);
173 myCoords->useArray(tmp,true,C_DEALLOC,nbOfNodes,3);
174 mesh->setCoords(myCoords);
176 CPPUNIT_ASSERT_EQUAL(nbOfNodes,mesh->getNumberOfNodes());
177 mesh->checkCoherency();
179 myCoords=DataArrayDouble::New();
180 myCoords->alloc(nbOfNodes,3);
181 tmp=myCoords->getPointer();
182 std::copy(coords,coords+3*nbOfNodes,tmp);
183 // test 3 bis deepcopy
184 DataArrayDouble *myCoords2=DataArrayDouble::New();
185 *myCoords2=*myCoords;
186 myCoords2->decrRef();
188 mesh->setCoords(myCoords);
190 CPPUNIT_ASSERT_EQUAL(nbOfNodes,mesh->getNumberOfNodes());
191 mesh->checkCoherency();
192 CPPUNIT_ASSERT_EQUAL(3,mesh->getSpaceDimension());
193 // test clone not recursively
194 MEDCouplingUMesh *mesh2=mesh->clone(false);
195 CPPUNIT_ASSERT(mesh2!=mesh);
196 mesh2->checkCoherency();
197 CPPUNIT_ASSERT_EQUAL(nbOfCells,mesh2->getNumberOfCells());
198 CPPUNIT_ASSERT_EQUAL(nbOfNodes,mesh2->getNumberOfNodes());
199 CPPUNIT_ASSERT_EQUAL(3,mesh2->getSpaceDimension());
200 CPPUNIT_ASSERT(mesh!=mesh2);
201 CPPUNIT_ASSERT(mesh->getCoords()==mesh2->getCoords());
202 CPPUNIT_ASSERT_DOUBLES_EQUAL(-0.2863,mesh2->getCoords()->getIJ(11,2),1e-14);
203 CPPUNIT_ASSERT(mesh->getNodalConnectivity()==mesh2->getNodalConnectivity());
204 CPPUNIT_ASSERT_EQUAL(3,mesh2->getNodalConnectivity()->getIJ(7,0));
205 CPPUNIT_ASSERT(mesh->getNodalConnectivityIndex()==mesh2->getNodalConnectivityIndex());
206 CPPUNIT_ASSERT_EQUAL(15,mesh2->getNodalConnectivityIndex()->getIJ(3,0));
208 // test clone not recursively
209 MEDCouplingUMesh *mesh3=mesh->clone(true);
210 CPPUNIT_ASSERT(mesh3!=mesh);
211 mesh3->checkCoherency();
212 CPPUNIT_ASSERT_EQUAL(nbOfCells,mesh3->getNumberOfCells());
213 CPPUNIT_ASSERT_EQUAL(nbOfNodes,mesh3->getNumberOfNodes());
214 CPPUNIT_ASSERT_EQUAL(3,mesh3->getSpaceDimension());
215 CPPUNIT_ASSERT(mesh!=mesh3);
216 CPPUNIT_ASSERT(mesh->getCoords()!=mesh3->getCoords());
217 CPPUNIT_ASSERT_DOUBLES_EQUAL(-0.2863,mesh3->getCoords()->getIJ(11,2),1e-14);
218 CPPUNIT_ASSERT(mesh->getNodalConnectivity()!=mesh3->getNodalConnectivity());
219 CPPUNIT_ASSERT_EQUAL(3,mesh3->getNodalConnectivity()->getIJ(7,0));
220 CPPUNIT_ASSERT(mesh->getNodalConnectivityIndex()!=mesh3->getNodalConnectivityIndex());
221 CPPUNIT_ASSERT_EQUAL(15,mesh3->getNodalConnectivityIndex()->getIJ(3,0));
223 //test 4 - Field on cells
224 MEDCouplingFieldDouble *fieldOnCells=MEDCouplingFieldDouble::New(ON_CELLS);
225 fieldOnCells->setMesh(mesh);
226 DataArrayDouble *array=DataArrayDouble::New();
227 array->alloc(nbOfCells,9);
228 fieldOnCells->setArray(array);
229 tmp=array->getPointer();
231 std::fill(tmp,tmp+9*nbOfCells,7.);
232 //content of field changed -> declare it.
233 fieldOnCells->declareAsNew();
234 fieldOnCells->checkCoherency();
235 // testing clone of fields - no recursive
236 MEDCouplingFieldDouble *fieldOnCells2=fieldOnCells->clone(false);
237 CPPUNIT_ASSERT(fieldOnCells2!=fieldOnCells);
238 fieldOnCells2->checkCoherency();
239 CPPUNIT_ASSERT_EQUAL(nbOfCells,fieldOnCells2->getNumberOfTuples());
240 CPPUNIT_ASSERT_EQUAL(9,fieldOnCells2->getNumberOfComponents());
241 CPPUNIT_ASSERT(fieldOnCells2->getArray()==fieldOnCells->getArray());
242 CPPUNIT_ASSERT_DOUBLES_EQUAL(7.,fieldOnCells2->getArray()->getIJ(3,7),1e-14);
243 CPPUNIT_ASSERT(fieldOnCells2->getMesh()==fieldOnCells->getMesh());
244 // testing clone of fields - recursive
245 MEDCouplingFieldDouble *fieldOnCells3=fieldOnCells->clone(true);
246 CPPUNIT_ASSERT(fieldOnCells3!=fieldOnCells);
247 fieldOnCells3->checkCoherency();
248 CPPUNIT_ASSERT_EQUAL(nbOfCells,fieldOnCells3->getNumberOfTuples());
249 CPPUNIT_ASSERT_EQUAL(9,fieldOnCells3->getNumberOfComponents());
250 CPPUNIT_ASSERT(fieldOnCells3->getArray()!=fieldOnCells->getArray());
251 CPPUNIT_ASSERT_DOUBLES_EQUAL(7.,fieldOnCells3->getArray()->getIJ(3,7),1e-14);
252 CPPUNIT_ASSERT(fieldOnCells3->getMesh()==fieldOnCells->getMesh());
253 fieldOnCells2->decrRef();
254 fieldOnCells3->decrRef();
256 fieldOnCells->decrRef();
261 void MEDCouplingBasicsTest1::testMeshPointsCloud()
263 double targetCoords[27]={-0.3,-0.3,0.5, 0.2,-0.3,1., 0.7,-0.3,1.5, -0.3,0.2,0.5, 0.2,0.2,1., 0.7,0.2,1.5, -0.3,0.7,0.5, 0.2,0.7,1., 0.7,0.7,1.5};
264 const int targetConn[]={0,1,2,3,4,5,7,6};
265 MEDCouplingUMesh *targetMesh=MEDCouplingUMesh::New();
266 targetMesh->setMeshDimension(0);
267 targetMesh->allocateCells(8);
268 targetMesh->insertNextCell(INTERP_KERNEL::NORM_POINT1,1,targetConn);
269 targetMesh->insertNextCell(INTERP_KERNEL::NORM_POINT1,1,targetConn+1);
270 targetMesh->insertNextCell(INTERP_KERNEL::NORM_POINT1,1,targetConn+2);
271 targetMesh->insertNextCell(INTERP_KERNEL::NORM_POINT1,1,targetConn+3);
272 targetMesh->insertNextCell(INTERP_KERNEL::NORM_POINT1,1,targetConn+4);
273 targetMesh->insertNextCell(INTERP_KERNEL::NORM_POINT1,1,targetConn+5);
274 targetMesh->insertNextCell(INTERP_KERNEL::NORM_POINT1,1,targetConn+6);
275 targetMesh->insertNextCell(INTERP_KERNEL::NORM_POINT1,1,targetConn+7);
276 targetMesh->finishInsertingCells();
277 DataArrayDouble *myCoords=DataArrayDouble::New();
278 myCoords->alloc(9,3);
279 std::copy(targetCoords,targetCoords+27,myCoords->getPointer());
280 targetMesh->setCoords(myCoords);
283 targetMesh->checkCoherency();
284 CPPUNIT_ASSERT_EQUAL(3,targetMesh->getSpaceDimension());
285 CPPUNIT_ASSERT_EQUAL(8,targetMesh->getNumberOfCells());
286 CPPUNIT_ASSERT_EQUAL(9,targetMesh->getNumberOfNodes());
287 CPPUNIT_ASSERT_EQUAL(0,targetMesh->getMeshDimension());
289 targetMesh->decrRef();
292 void MEDCouplingBasicsTest1::testMeshM1D()
294 MEDCouplingUMesh *meshM1D=MEDCouplingUMesh::New();
295 CPPUNIT_ASSERT_THROW(meshM1D->getMeshDimension(),INTERP_KERNEL::Exception);
296 CPPUNIT_ASSERT_THROW(meshM1D->getNumberOfNodes(),INTERP_KERNEL::Exception);
297 CPPUNIT_ASSERT_THROW(meshM1D->getNumberOfCells(),INTERP_KERNEL::Exception);
298 CPPUNIT_ASSERT_THROW(meshM1D->setMeshDimension(-2),INTERP_KERNEL::Exception);
299 CPPUNIT_ASSERT_THROW(meshM1D->setMeshDimension(-10),INTERP_KERNEL::Exception);
300 CPPUNIT_ASSERT_THROW(meshM1D->checkCoherency(),INTERP_KERNEL::Exception);
301 meshM1D->setMeshDimension(-1);
302 meshM1D->checkCoherency();
303 CPPUNIT_ASSERT_EQUAL(-1,meshM1D->getMeshDimension());
304 CPPUNIT_ASSERT_EQUAL(1,meshM1D->getNumberOfCells());
305 CPPUNIT_ASSERT_THROW(meshM1D->getNumberOfNodes(),INTERP_KERNEL::Exception);
306 CPPUNIT_ASSERT_THROW(meshM1D->getSpaceDimension(),INTERP_KERNEL::Exception);
307 MEDCouplingUMesh *cpy=meshM1D->clone(true);
308 CPPUNIT_ASSERT(cpy->isEqual(meshM1D,1e-12));
310 MEDCouplingFieldDouble *fieldOnCells=MEDCouplingFieldDouble::New(ON_CELLS);
311 fieldOnCells->setMesh(meshM1D);
312 DataArrayDouble *array=DataArrayDouble::New();
314 fieldOnCells->setArray(array);
315 double *tmp=array->getPointer();
317 std::fill(tmp,tmp+6,7.);
318 fieldOnCells->checkCoherency();
320 fieldOnCells->decrRef();
324 void MEDCouplingBasicsTest1::testDeepCopy()
326 DataArrayDouble *array=DataArrayDouble::New();
328 std::fill(array->getPointer(),array->getPointer()+5*3,7.);
329 CPPUNIT_ASSERT_DOUBLES_EQUAL(7.,array->getIJ(3,2),1e-14);
330 double *tmp1=array->getPointer();
331 DataArrayDouble *array2=array->deepCpy();
332 double *tmp2=array2->getPointer();
333 CPPUNIT_ASSERT(tmp1!=tmp2);
335 CPPUNIT_ASSERT_DOUBLES_EQUAL(7.,array2->getIJ(3,2),1e-14);
338 DataArrayInt *array3=DataArrayInt::New();
340 std::fill(array3->getPointer(),array3->getPointer()+5*3,17);
341 CPPUNIT_ASSERT_EQUAL(17,array3->getIJ(3,2));
342 int *tmp3=array3->getPointer();
343 DataArrayInt *array4=array3->deepCpy();
344 int *tmp4=array4->getPointer();
345 CPPUNIT_ASSERT(tmp3!=tmp4);
347 CPPUNIT_ASSERT_EQUAL(17,array4->getIJ(3,2));
351 void MEDCouplingBasicsTest1::testRevNodal()
353 MEDCouplingUMesh *mesh=build2DTargetMesh_1();
354 DataArrayInt *revNodal=DataArrayInt::New();
355 DataArrayInt *revNodalIndx=DataArrayInt::New();
357 mesh->getReverseNodalConnectivity(revNodal,revNodalIndx);
358 const int revNodalExpected[18]={0,0,1,1,2,0,3,0,1,2,3,4,2,4,3,3,4,4};
359 const int revNodalIndexExpected[10]={0,1,3,5,7,12,14,15,17,18};
360 CPPUNIT_ASSERT_EQUAL(18,revNodal->getNbOfElems());
361 CPPUNIT_ASSERT_EQUAL(10,revNodalIndx->getNbOfElems());
362 CPPUNIT_ASSERT(std::equal(revNodalExpected,revNodalExpected+18,revNodal->getPointer()));
363 CPPUNIT_ASSERT(std::equal(revNodalIndexExpected,revNodalIndexExpected+10,revNodalIndx->getPointer()));
366 revNodalIndx->decrRef();
370 void MEDCouplingBasicsTest1::testConvertToPolyTypes()
373 MEDCouplingUMesh *mesh=build2DTargetMesh_1();
375 const int elts[2]={1,3};
376 std::vector<int> eltsV(elts,elts+2);
377 mesh->convertToPolyTypes(&eltsV[0],&eltsV[0]+eltsV.size());
378 mesh->checkCoherency();
379 CPPUNIT_ASSERT_EQUAL(5,mesh->getNumberOfCells());
380 CPPUNIT_ASSERT_EQUAL(23,mesh->getNodalConnectivity()->getNumberOfTuples());
381 const int *pt=mesh->getNodalConnectivity()->getConstPointer();
382 const int expected1[23]={4, 0, 3, 4, 1, 5, 1, 4, 2, 3, 4, 5, 2, 5, 6, 7, 4, 3, 4, 7, 8, 5, 4};
383 CPPUNIT_ASSERT(std::equal(expected1,expected1+23,pt));
387 mesh=build3DTargetMesh_1();
388 mesh->convertToPolyTypes(&eltsV[0],&eltsV[0]+eltsV.size());
389 mesh->checkCoherency();
390 CPPUNIT_ASSERT_EQUAL(8,mesh->getNumberOfCells());
391 CPPUNIT_ASSERT_EQUAL(114,mesh->getNodalConnectivity()->getNumberOfTuples());
392 mesh->convertToPolyTypes(&eltsV[0],&eltsV[0]+eltsV.size());
393 mesh->checkCoherency();
394 CPPUNIT_ASSERT_EQUAL(8,mesh->getNumberOfCells());
395 CPPUNIT_ASSERT_EQUAL(114,mesh->getNodalConnectivity()->getNumberOfTuples());
400 void MEDCouplingBasicsTest1::testDescConn2D()
402 MEDCouplingUMesh *mesh=build2DTargetMesh_1();
403 DataArrayInt *desc=DataArrayInt::New();
404 DataArrayInt *descIndx=DataArrayInt::New();
405 DataArrayInt *revDesc=DataArrayInt::New();
406 DataArrayInt *revDescIndx=DataArrayInt::New();
408 MEDCouplingUMesh *mesh2=mesh->buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
409 mesh2->checkCoherency();
410 CPPUNIT_ASSERT_EQUAL(1,mesh2->getMeshDimension());
411 CPPUNIT_ASSERT_EQUAL(13,mesh2->getNumberOfCells());
412 CPPUNIT_ASSERT_EQUAL(14,revDescIndx->getNbOfElems()); CPPUNIT_ASSERT_EQUAL(14,revDescIndx->getNumberOfTuples());
413 CPPUNIT_ASSERT_EQUAL(6,descIndx->getNbOfElems()); CPPUNIT_ASSERT_EQUAL(6,descIndx->getNumberOfTuples());
414 CPPUNIT_ASSERT_EQUAL(18,desc->getNbOfElems()); CPPUNIT_ASSERT_EQUAL(18,desc->getNumberOfTuples());
415 CPPUNIT_ASSERT_EQUAL(18,revDesc->getNbOfElems()); CPPUNIT_ASSERT_EQUAL(18,revDesc->getNumberOfTuples());
416 const int expected1[18]={0,1,2,3, 2,4,5, 6,7,4, 8,9,1,10, 11,12,6,9};
417 CPPUNIT_ASSERT(std::equal(expected1,expected1+18,desc->getConstPointer()));
418 const int expected2[6]={0,4,7,10,14,18};
419 CPPUNIT_ASSERT(std::equal(expected2,expected2+6,descIndx->getConstPointer()));
420 const int expected3[14]={0,1,3,5,6,8,9,11,12,13,15,16,17,18};
421 CPPUNIT_ASSERT(std::equal(expected3,expected3+14,revDescIndx->getConstPointer()));
422 const int expected4[18]={0, 0,3, 0,1, 0, 1,2, 1, 2,4, 2, 3, 3,4, 3, 4, 4};
423 CPPUNIT_ASSERT(std::equal(expected4,expected4+18,revDesc->getConstPointer()));
424 DataArrayInt *conn=mesh2->getNodalConnectivity();
425 DataArrayInt *connIndex=mesh2->getNodalConnectivityIndex();
426 const int expected5[14]={0,3,6,9,12,15,18,21,24,27,30,33,36,39};
427 CPPUNIT_ASSERT(std::equal(expected5,expected5+14,connIndex->getConstPointer()));
428 const int expected6[39]={1, 0, 3, 1, 3, 4, 1, 4, 1, 1, 1, 0, 1, 4, 2, 1, 2, 1, 1, 4, 5, 1, 5, 2, 1, 6, 7, 1, 7, 4, 1, 3, 6, 1, 7, 8, 1, 8, 5};
429 CPPUNIT_ASSERT(std::equal(expected6,expected6+39,conn->getConstPointer()));
434 revDescIndx->decrRef();
437 const int elts[2]={1,3};
438 std::vector<int> eltsV(elts,elts+2);
439 mesh->convertToPolyTypes(&eltsV[0],&eltsV[0]+eltsV.size());
440 mesh->checkCoherency();
442 desc=DataArrayInt::New();
443 descIndx=DataArrayInt::New();
444 revDesc=DataArrayInt::New();
445 revDescIndx=DataArrayInt::New();
447 mesh2=mesh->buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
448 mesh2->checkCoherency();
449 CPPUNIT_ASSERT_EQUAL(1,mesh2->getMeshDimension());
450 CPPUNIT_ASSERT_EQUAL(13,mesh2->getNumberOfCells());
451 CPPUNIT_ASSERT_EQUAL(14,revDescIndx->getNbOfElems()); CPPUNIT_ASSERT_EQUAL(14,revDescIndx->getNumberOfTuples());
452 CPPUNIT_ASSERT_EQUAL(6,descIndx->getNbOfElems()); CPPUNIT_ASSERT_EQUAL(6,descIndx->getNumberOfTuples());
453 CPPUNIT_ASSERT_EQUAL(18,desc->getNbOfElems()); CPPUNIT_ASSERT_EQUAL(18,desc->getNumberOfTuples());
454 CPPUNIT_ASSERT_EQUAL(18,revDesc->getNbOfElems()); CPPUNIT_ASSERT_EQUAL(18,revDesc->getNumberOfTuples());
455 CPPUNIT_ASSERT(std::equal(expected1,expected1+18,desc->getConstPointer()));
456 CPPUNIT_ASSERT(std::equal(expected2,expected2+6,descIndx->getConstPointer()));
457 CPPUNIT_ASSERT(std::equal(expected3,expected3+14,revDescIndx->getConstPointer()));
458 CPPUNIT_ASSERT(std::equal(expected4,expected4+18,revDesc->getConstPointer()));
459 conn=mesh2->getNodalConnectivity();
460 connIndex=mesh2->getNodalConnectivityIndex();
461 CPPUNIT_ASSERT(std::equal(expected5,expected5+14,connIndex->getConstPointer()));
462 CPPUNIT_ASSERT(std::equal(expected6,expected6+39,conn->getConstPointer()));
467 revDescIndx->decrRef();
472 void MEDCouplingBasicsTest1::testDescConn3D()
474 MEDCouplingUMesh *mesh=build3DTargetMesh_1();
475 DataArrayInt *desc=DataArrayInt::New();
476 DataArrayInt *descIndx=DataArrayInt::New();
477 DataArrayInt *revDesc=DataArrayInt::New();
478 DataArrayInt *revDescIndx=DataArrayInt::New();
480 MEDCouplingUMesh *mesh2=mesh->buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
481 mesh2->checkCoherency();
482 CPPUNIT_ASSERT_EQUAL(2,mesh2->getMeshDimension());
483 CPPUNIT_ASSERT_EQUAL(36,mesh2->getNumberOfCells());
484 CPPUNIT_ASSERT_EQUAL(37,revDescIndx->getNbOfElems()); CPPUNIT_ASSERT_EQUAL(37,revDescIndx->getNumberOfTuples());
485 CPPUNIT_ASSERT_EQUAL(9,descIndx->getNbOfElems()); CPPUNIT_ASSERT_EQUAL(9,descIndx->getNumberOfTuples());
486 CPPUNIT_ASSERT_EQUAL(48,desc->getNbOfElems()); CPPUNIT_ASSERT_EQUAL(48,desc->getNumberOfTuples());
487 CPPUNIT_ASSERT_EQUAL(48,revDesc->getNbOfElems()); CPPUNIT_ASSERT_EQUAL(48,revDesc->getNumberOfTuples());
488 const int expected1[9]={0, 6, 12, 18, 24, 30, 36, 42, 48};
489 const int expected2[48]={0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 3, 11, 12, 4, 13, 14, 15, 16, 17, 10, 18, 19, 13, 1, 20, 21, 22, 23, 24, 7, 25, 26, 27, 28, 22, 12, 29, 23, 30, 31, 32, 17, 33, 28, 34, 35, 30};
490 const int expected3[37]={0, 1, 3, 4, 6, 8, 9, 10, 12, 13, 14, 16, 17, 19, 21, 22, 23, 24, 26, 27, 28, 29, 30, 32, 34, 35, 36, 37, 38, 40, 41, 43, 44, 45, 46, 47, 48};
491 const int expected4[48]={0, 0, 4, 0, 0, 1, 0, 2, 0, 1, 1, 5, 1, 1, 1, 3, 2, 2, 6, 2, 3, 2, 2, 3, 3, 7, 3, 3, 4, 4, 4, 5, 4, 6, 4, 5, 5, 5, 5, 7, 6, 6, 7, 6, 6, 7, 7, 7};
492 const int expected5[37]={0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95, 100, 105, 110, 115, 120, 125, 130, 135, 140, 145, 150, 155, 160, 165, 170, 175, 180};
493 const int expected6[180]={4, 0, 1, 4, 3, 4, 9, 12, 13, 10, 4, 0, 9, 10, 1, 4, 1, 10, 13, 4, 4, 4, 13, 12, 3, 4, 3, 12, 9, 0, 4, 1, 2, 5, 4, 4, 10, 13, 14, 11, 4, 1, 10, 11, 2, 4, 2, 11, 14,
494 5, 4, 5, 14, 13, 4, 4, 3, 4, 7, 6, 4, 12, 15, 16, 13, 4, 4, 13, 16, 7, 4, 7, 16, 15, 6, 4, 6, 15, 12, 3, 4, 4, 5, 8, 7, 4, 13, 16, 17, 14, 4, 5, 14, 17, 8, 4, 8,
495 17, 16, 7, 4, 18, 21, 22, 19, 4, 9, 18, 19, 10, 4, 10, 19, 22, 13, 4, 13, 22, 21, 12, 4, 12, 21, 18, 9, 4, 19, 22, 23, 20, 4, 10, 19, 20, 11, 4, 11, 20, 23, 14, 4,
496 14, 23, 22, 13, 4, 21, 24, 25, 22, 4, 13, 22, 25, 16, 4, 16, 25, 24, 15, 4, 15, 24, 21, 12, 4, 22, 25, 26, 23, 4, 14, 23, 26, 17, 4, 17, 26, 25, 16};
497 const int expected7[180]={4, 0, 1, 4, 3, 4, 9, 12, 13, 10, 4, 0, 9, 10, 1, 4, 1, 10, 13, 4, 4, 4, 13, 12, 3, 4, 3, 12, 9, 0, 5, 1, 2, 5, 4, 5, 10, 13, 14, 11, 5, 1, 10, 11, 2, 5, 2, 11, 14,
498 5, 5, 5, 14, 13, 4, 4, 3, 4, 7, 6, 4, 12, 15, 16, 13, 4, 4, 13, 16, 7, 4, 7, 16, 15, 6, 4, 6, 15, 12, 3, 5, 4, 5, 8, 7, 5, 13, 16, 17, 14, 5, 5, 14, 17, 8, 5, 8,
499 17, 16, 7, 4, 18, 21, 22, 19, 4, 9, 18, 19, 10, 4, 10, 19, 22, 13, 4, 13, 22, 21, 12, 4, 12, 21, 18, 9, 4, 19, 22, 23, 20, 4, 10, 19, 20, 11, 4, 11, 20, 23, 14, 4,
500 14, 23, 22, 13, 4, 21, 24, 25, 22, 4, 13, 22, 25, 16, 4, 16, 25, 24, 15, 4, 15, 24, 21, 12, 4, 22, 25, 26, 23, 4, 14, 23, 26, 17, 4, 17, 26, 25, 16};
502 CPPUNIT_ASSERT(std::equal(expected1,expected1+9,descIndx->getConstPointer()));
503 CPPUNIT_ASSERT(std::equal(expected2,expected2+48,desc->getConstPointer()));
504 CPPUNIT_ASSERT(std::equal(expected3,expected3+37,revDescIndx->getConstPointer()));
505 CPPUNIT_ASSERT(std::equal(expected4,expected4+48,revDesc->getConstPointer()));
506 CPPUNIT_ASSERT(std::equal(expected5,expected5+37,mesh2->getNodalConnectivityIndex()->getConstPointer()));
507 CPPUNIT_ASSERT(std::equal(expected6,expected6+180,mesh2->getNodalConnectivity()->getConstPointer()));
512 revDescIndx->decrRef();
515 const int elts[2]={1,3};
516 std::vector<int> eltsV(elts,elts+2);
517 mesh->convertToPolyTypes(&eltsV[0],&eltsV[0]+eltsV.size());
518 mesh->checkCoherency();
519 desc=DataArrayInt::New();
520 descIndx=DataArrayInt::New();
521 revDesc=DataArrayInt::New();
522 revDescIndx=DataArrayInt::New();
523 mesh2=mesh->buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
524 mesh2->checkCoherency();
525 CPPUNIT_ASSERT_EQUAL(2,mesh2->getMeshDimension());
526 CPPUNIT_ASSERT_EQUAL(36,mesh2->getNumberOfCells());
527 CPPUNIT_ASSERT_EQUAL(37,revDescIndx->getNbOfElems()); CPPUNIT_ASSERT_EQUAL(37,revDescIndx->getNumberOfTuples());
528 CPPUNIT_ASSERT_EQUAL(9,descIndx->getNbOfElems()); CPPUNIT_ASSERT_EQUAL(9,descIndx->getNumberOfTuples());
529 CPPUNIT_ASSERT_EQUAL(48,desc->getNbOfElems()); CPPUNIT_ASSERT_EQUAL(48,desc->getNumberOfTuples());
530 CPPUNIT_ASSERT_EQUAL(48,revDesc->getNbOfElems()); CPPUNIT_ASSERT_EQUAL(48,revDesc->getNumberOfTuples());
531 CPPUNIT_ASSERT(std::equal(expected1,expected1+9,descIndx->getConstPointer()));
532 CPPUNIT_ASSERT(std::equal(expected2,expected2+48,desc->getConstPointer()));
533 CPPUNIT_ASSERT(std::equal(expected3,expected3+37,revDescIndx->getConstPointer()));
534 CPPUNIT_ASSERT(std::equal(expected4,expected4+48,revDesc->getConstPointer()));
535 CPPUNIT_ASSERT(std::equal(expected5,expected5+37,mesh2->getNodalConnectivityIndex()->getConstPointer()));
536 CPPUNIT_ASSERT(std::equal(expected7,expected7+180,mesh2->getNodalConnectivity()->getConstPointer()));
541 revDescIndx->decrRef();
546 void MEDCouplingBasicsTest1::testFindBoundaryNodes()
548 MEDCouplingUMesh *mesh=build3DTargetMesh_1();
549 DataArrayInt *boundaryNodes=mesh->findBoundaryNodes();
550 CPPUNIT_ASSERT_EQUAL(26,boundaryNodes->getNumberOfTuples());
551 CPPUNIT_ASSERT_EQUAL(1,boundaryNodes->getNumberOfComponents());
552 const int expected1[26]={0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26};
553 CPPUNIT_ASSERT(std::equal(expected1,expected1+26,boundaryNodes->begin()));
554 boundaryNodes->decrRef();
558 void MEDCouplingBasicsTest1::testBoundaryMesh()
560 MEDCouplingUMesh *mesh=build3DTargetMesh_1();
561 MEDCouplingPointSet *mesh2=mesh->buildBoundaryMesh(false);
562 CPPUNIT_ASSERT_EQUAL(24,mesh2->getNumberOfCells());
563 CPPUNIT_ASSERT_EQUAL(26,mesh2->getNumberOfNodes());
568 void MEDCouplingBasicsTest1::testBuildPartOfMySelf()
570 MEDCouplingUMesh *mesh=build2DTargetMesh_1();
571 mesh->setName("Toto");
572 const int tab1[2]={0,4};
573 const int tab2[3]={0,2,3};
575 MEDCouplingPointSet *subMeshSimple=mesh->buildPartOfMySelf(tab1,tab1+2,true);
576 MEDCouplingUMesh *subMesh=dynamic_cast<MEDCouplingUMesh *>(subMeshSimple);
577 CPPUNIT_ASSERT(subMesh);
578 std::string name(subMesh->getName());
579 CPPUNIT_ASSERT_EQUAL(2,(int)mesh->getAllTypes().size());
580 CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_TRI3,*mesh->getAllTypes().begin());
581 CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_QUAD4,*(++(mesh->getAllTypes().begin())));
582 CPPUNIT_ASSERT_EQUAL(1,(int)subMesh->getAllTypes().size());
583 CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_QUAD4,*subMesh->getAllTypes().begin());
584 CPPUNIT_ASSERT(name=="Toto");
585 CPPUNIT_ASSERT(mesh->getCoords()==subMesh->getCoords());
586 CPPUNIT_ASSERT_EQUAL(2,subMesh->getNumberOfCells());
587 const int subConn[10]={4,0,3,4,1,4,7,8,5,4};
588 const int subConnIndex[3]={0,5,10};
589 CPPUNIT_ASSERT_EQUAL(10,subMesh->getNodalConnectivity()->getNbOfElems());
590 CPPUNIT_ASSERT_EQUAL(3,subMesh->getNodalConnectivityIndex()->getNbOfElems());
591 CPPUNIT_ASSERT(std::equal(subConn,subConn+10,subMesh->getNodalConnectivity()->getPointer()));
592 CPPUNIT_ASSERT(std::equal(subConnIndex,subConnIndex+3,subMesh->getNodalConnectivityIndex()->getPointer()));
595 subMeshSimple=mesh->buildPartOfMySelf(tab2,tab2+3,true);
596 subMesh=dynamic_cast<MEDCouplingUMesh *>(subMeshSimple);
597 CPPUNIT_ASSERT(subMesh);
598 name=subMesh->getName();
599 CPPUNIT_ASSERT_EQUAL(2,(int)subMesh->getAllTypes().size());
600 CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_TRI3,*subMesh->getAllTypes().begin());
601 CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_QUAD4,*(++(subMesh->getAllTypes().begin())));
602 CPPUNIT_ASSERT(name=="Toto");
603 CPPUNIT_ASSERT(mesh->getCoords()==subMesh->getCoords());
604 CPPUNIT_ASSERT_EQUAL(3,subMesh->getNumberOfCells());
605 const int subConn2[14]={4,0,3,4,1,3,4,5,2,4,6,7,4,3};
606 const int subConnIndex2[4]={0,5,9,14};
607 CPPUNIT_ASSERT_EQUAL(14,subMesh->getNodalConnectivity()->getNbOfElems());
608 CPPUNIT_ASSERT_EQUAL(4,subMesh->getNodalConnectivityIndex()->getNbOfElems());
609 CPPUNIT_ASSERT(std::equal(subConn2,subConn2+14,subMesh->getNodalConnectivity()->getPointer()));
610 CPPUNIT_ASSERT(std::equal(subConnIndex2,subConnIndex2+4,subMesh->getNodalConnectivityIndex()->getPointer()));
611 const int tab3[3]={0,1,2};
612 MEDCouplingPointSet *subMeshSimple2=subMeshSimple->buildPartOfMySelf(tab3,tab3+3,true);
614 name=subMeshSimple2->getName();
615 CPPUNIT_ASSERT(name=="Toto");
616 subMeshSimple2->decrRef();
621 void MEDCouplingBasicsTest1::testBuildPartOfMySelfNode()
623 MEDCouplingUMesh *mesh=build2DTargetMesh_1();
624 const int tab1[4]={5,7,8,4};
625 MEDCouplingPointSet *subMeshSimple=mesh->buildPartOfMySelfNode(tab1,tab1+4,true);
626 MEDCouplingUMesh *subMesh=dynamic_cast<MEDCouplingUMesh *>(subMeshSimple);
627 CPPUNIT_ASSERT(subMesh);
628 CPPUNIT_ASSERT_EQUAL(1,(int)subMesh->getAllTypes().size());
629 CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_QUAD4,*subMesh->getAllTypes().begin());
630 CPPUNIT_ASSERT_EQUAL(1,subMesh->getNumberOfCells());
631 CPPUNIT_ASSERT_EQUAL(5,subMesh->getNodalConnectivity()->getNbOfElems());
632 CPPUNIT_ASSERT_EQUAL(2,subMesh->getNodalConnectivityIndex()->getNbOfElems());
633 const int subConn[5]={4,7,8,5,4};
634 const int subConnIndex[3]={0,5};
635 CPPUNIT_ASSERT(std::equal(subConn,subConn+5,subMesh->getNodalConnectivity()->getPointer()));
636 CPPUNIT_ASSERT(std::equal(subConnIndex,subConnIndex+2,subMesh->getNodalConnectivityIndex()->getPointer()));
637 CPPUNIT_ASSERT(subMesh->getCoords()==mesh->getCoords());
638 subMeshSimple->decrRef();
640 subMeshSimple=mesh->buildPartOfMySelfNode(tab1,tab1+2,false);
641 subMesh=dynamic_cast<MEDCouplingUMesh *>(subMeshSimple);
642 CPPUNIT_ASSERT(subMesh);
643 CPPUNIT_ASSERT_EQUAL(2,(int)subMesh->getAllTypes().size());
644 CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_TRI3,*subMesh->getAllTypes().begin());
645 CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_QUAD4,*(++subMesh->getAllTypes().begin()));
646 CPPUNIT_ASSERT_EQUAL(3,subMesh->getNumberOfCells());
647 CPPUNIT_ASSERT_EQUAL(14,subMesh->getNodalConnectivity()->getNbOfElems());
648 CPPUNIT_ASSERT_EQUAL(4,subMesh->getNodalConnectivityIndex()->getNbOfElems());
649 const int subConn2[14]={3,4,5,2,4,6,7,4,3,4,7,8,5,4};
650 const int subConnIndex2[4]={0,4,9,14};
651 CPPUNIT_ASSERT(std::equal(subConn2,subConn2+14,subMesh->getNodalConnectivity()->getPointer()));
652 CPPUNIT_ASSERT(std::equal(subConnIndex2,subConnIndex2+4,subMesh->getNodalConnectivityIndex()->getPointer()));
653 CPPUNIT_ASSERT(subMesh->getCoords()==mesh->getCoords());
654 subMeshSimple->decrRef();
655 //testing the case where length of tab2 is greater than max number of node per cell.
656 const int tab2[7]={0,3,2,1,4,5,6};
657 subMeshSimple=mesh->buildPartOfMySelfNode(tab2,tab2+7,true);
658 subMesh=dynamic_cast<MEDCouplingUMesh *>(subMeshSimple);
659 CPPUNIT_ASSERT(subMesh);
660 CPPUNIT_ASSERT_EQUAL(2,(int)subMesh->getAllTypes().size());
661 CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_TRI3,*subMesh->getAllTypes().begin());
662 CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_QUAD4,*(++subMesh->getAllTypes().begin()));
663 CPPUNIT_ASSERT_EQUAL(3,subMesh->getNumberOfCells());
664 subMeshSimple->decrRef();
669 void MEDCouplingBasicsTest1::testZipCoords()
671 MEDCouplingUMesh *mesh=build2DTargetMesh_1();
672 CPPUNIT_ASSERT_EQUAL(2,(int)mesh->getAllTypes().size());
673 CPPUNIT_ASSERT_EQUAL(2,mesh->getSpaceDimension());
674 CPPUNIT_ASSERT_EQUAL(9,mesh->getNumberOfNodes());
675 CPPUNIT_ASSERT_EQUAL(5,mesh->getNumberOfCells());
676 std::vector<int> oldConn(mesh->getNodalConnectivity()->getNbOfElems());
677 std::vector<int> oldConnIndex(mesh->getNumberOfCells()+1);
678 std::copy(mesh->getNodalConnectivity()->getPointer(),mesh->getNodalConnectivity()->getPointer()+oldConn.size(),oldConn.begin());
679 std::copy(mesh->getNodalConnectivityIndex()->getPointer(),mesh->getNodalConnectivityIndex()->getPointer()+mesh->getNumberOfCells()+1,oldConnIndex.begin());
680 DataArrayDouble *oldCoords=mesh->getCoords();
681 oldCoords->incrRef();
683 CPPUNIT_ASSERT_EQUAL(2,(int)mesh->getAllTypes().size());
684 CPPUNIT_ASSERT_EQUAL(2,mesh->getSpaceDimension());
685 CPPUNIT_ASSERT_EQUAL(9,mesh->getNumberOfNodes());
686 CPPUNIT_ASSERT_EQUAL(5,mesh->getNumberOfCells());
687 CPPUNIT_ASSERT(mesh->getCoords()!=oldCoords);
688 CPPUNIT_ASSERT(std::equal(mesh->getCoords()->getPointer(),mesh->getCoords()->getPointer()+2*9,oldCoords->getPointer()));
689 CPPUNIT_ASSERT(std::equal(oldConn.begin(),oldConn.end(),mesh->getNodalConnectivity()->getPointer()));
690 CPPUNIT_ASSERT(std::equal(oldConnIndex.begin(),oldConnIndex.end(),mesh->getNodalConnectivityIndex()->getPointer()));
691 oldCoords->decrRef();
693 const int tab1[2]={0,4};
694 MEDCouplingPointSet *subMeshPtSet=mesh->buildPartOfMySelf(tab1,tab1+2,true);
695 MEDCouplingUMesh *subMesh=dynamic_cast<MEDCouplingUMesh *>(subMeshPtSet);
696 CPPUNIT_ASSERT(subMesh);
697 DataArrayInt *traducer=subMesh->zipCoordsTraducer();
698 const int expectedTraducer[9]={0,1,-1,2,3,4,-1,5,6};
699 CPPUNIT_ASSERT(std::equal(expectedTraducer,expectedTraducer+9,traducer->getPointer()));
701 CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_QUAD4,*subMesh->getAllTypes().begin());
702 CPPUNIT_ASSERT_EQUAL(2,subMesh->getNumberOfCells());
703 const int subConn[10]={4,0,2,3,1,4,5,6,4,3};
704 const int subConnIndex[3]={0,5,10};
705 CPPUNIT_ASSERT_EQUAL(7,subMesh->getNumberOfNodes());
706 CPPUNIT_ASSERT_EQUAL(10,subMesh->getNodalConnectivity()->getNbOfElems());
707 CPPUNIT_ASSERT_EQUAL(3,subMesh->getNodalConnectivityIndex()->getNbOfElems());
708 CPPUNIT_ASSERT(std::equal(subConn,subConn+10,subMesh->getNodalConnectivity()->getPointer()));
709 CPPUNIT_ASSERT(std::equal(subConnIndex,subConnIndex+3,subMesh->getNodalConnectivityIndex()->getPointer()));
712 subMeshPtSet=mesh->buildPartOfMySelf(tab1,tab1+2,false);
713 subMesh=dynamic_cast<MEDCouplingUMesh *>(subMeshPtSet);
714 CPPUNIT_ASSERT(subMesh);
715 CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_QUAD4,*subMesh->getAllTypes().begin());
716 CPPUNIT_ASSERT_EQUAL(2,subMesh->getNumberOfCells());
717 CPPUNIT_ASSERT_EQUAL(7,subMesh->getNumberOfNodes());
718 CPPUNIT_ASSERT_EQUAL(10,subMesh->getNodalConnectivity()->getNbOfElems());
719 CPPUNIT_ASSERT_EQUAL(3,subMesh->getNodalConnectivityIndex()->getNbOfElems());
720 CPPUNIT_ASSERT(std::equal(subConn,subConn+10,subMesh->getNodalConnectivity()->getPointer()));
721 CPPUNIT_ASSERT(std::equal(subConnIndex,subConnIndex+3,subMesh->getNodalConnectivityIndex()->getPointer()));
727 void MEDCouplingBasicsTest1::testZipConnectivity()
729 MEDCouplingUMesh *m1=build2DTargetMesh_1();
730 MEDCouplingUMesh *m2=build2DTargetMesh_1();
731 int cells1[3]={2,3,4};
732 MEDCouplingPointSet *m3_1=m2->buildPartOfMySelf(cells1,cells1+3,true);
733 MEDCouplingUMesh *m3=dynamic_cast<MEDCouplingUMesh *>(m3_1);
736 MEDCouplingUMesh *m4=build2DSourceMesh_1();
737 MEDCouplingUMesh *m5=MEDCouplingUMesh::MergeUMeshes(m1,m3);
740 MEDCouplingUMesh *m6=MEDCouplingUMesh::MergeUMeshes(m5,m4);
746 CPPUNIT_ASSERT_EQUAL(10,m6->getNumberOfCells());
747 CPPUNIT_ASSERT_EQUAL(22,m6->getNumberOfNodes());
748 DataArrayInt *arr=m6->mergeNodes(1e-13,areNodesMerged,newNbOfNodes);
750 CPPUNIT_ASSERT(areNodesMerged);
751 CPPUNIT_ASSERT_EQUAL(10,m6->getNumberOfCells());
752 CPPUNIT_ASSERT_EQUAL(9,m6->getNumberOfNodes());
753 CPPUNIT_ASSERT_EQUAL(9,newNbOfNodes);
755 arr=m6->zipConnectivityTraducer(0);
756 CPPUNIT_ASSERT_EQUAL(7,m6->getNumberOfCells());
758 MEDCouplingUMesh *m7=m6->clone(true);
759 arr=m6->zipConnectivityTraducer(0);
760 CPPUNIT_ASSERT(m7->isEqual(m6,1e-12));
761 CPPUNIT_ASSERT_EQUAL(7,m6->getNumberOfCells());
768 void MEDCouplingBasicsTest1::testEqualMesh()
770 MEDCouplingUMesh *mesh1=build2DTargetMesh_1();
771 MEDCouplingUMesh *mesh2=build2DTargetMesh_1();
773 CPPUNIT_ASSERT(mesh1->isEqual(mesh1,1e-12));
775 CPPUNIT_ASSERT(mesh1->isEqual(mesh2,1e-12));
776 CPPUNIT_ASSERT(mesh2->isEqual(mesh1,1e-12));
777 double *pt=mesh2->getCoords()->getPointer();
780 CPPUNIT_ASSERT(!mesh1->isEqual(mesh2,1e-12));
781 CPPUNIT_ASSERT(!mesh2->isEqual(mesh1,1e-12));
783 CPPUNIT_ASSERT(mesh1->isEqual(mesh2,1e-12));
784 CPPUNIT_ASSERT(mesh2->isEqual(mesh1,1e-12));
786 int *pt2=mesh1->getNodalConnectivity()->getPointer();
788 CPPUNIT_ASSERT(!mesh1->isEqual(mesh2,1e-12));
789 CPPUNIT_ASSERT(!mesh2->isEqual(mesh1,1e-12));
791 CPPUNIT_ASSERT(mesh1->isEqual(mesh2,1e-12));
792 CPPUNIT_ASSERT(mesh2->isEqual(mesh1,1e-12));
794 pt2=mesh1->getNodalConnectivityIndex()->getPointer();
796 CPPUNIT_ASSERT(!mesh1->isEqual(mesh2,1e-12));
797 CPPUNIT_ASSERT(!mesh2->isEqual(mesh1,1e-12));
799 CPPUNIT_ASSERT(mesh1->isEqual(mesh2,1e-12));
800 CPPUNIT_ASSERT(mesh2->isEqual(mesh1,1e-12));
802 std::string tmp3=mesh1->getName();
803 mesh1->setName("lllll");
804 CPPUNIT_ASSERT(!mesh1->isEqual(mesh2,1e-12));
805 CPPUNIT_ASSERT(!mesh2->isEqual(mesh1,1e-12));
806 mesh1->setName(tmp3.c_str());
807 CPPUNIT_ASSERT(mesh1->isEqual(mesh2,1e-12));
808 CPPUNIT_ASSERT(mesh2->isEqual(mesh1,1e-12));
810 tmp3=mesh2->getCoords()->getInfoOnComponent(1);
811 mesh2->getCoords()->setInfoOnComponent(1,"kkkkkk");
812 CPPUNIT_ASSERT(!mesh1->isEqual(mesh2,1e-12));
813 CPPUNIT_ASSERT(!mesh2->isEqual(mesh1,1e-12));
814 mesh2->getCoords()->setInfoOnComponent(1,tmp3.c_str());
815 CPPUNIT_ASSERT(mesh1->isEqual(mesh2,1e-12));
816 CPPUNIT_ASSERT(mesh2->isEqual(mesh1,1e-12));
822 void MEDCouplingBasicsTest1::testEqualFieldDouble()
824 MEDCouplingUMesh *mesh1=build2DTargetMesh_1();
825 MEDCouplingUMesh *mesh2=build2DTargetMesh_1();
827 MEDCouplingFieldDouble *fieldOnCells1=MEDCouplingFieldDouble::New(ON_CELLS,NO_TIME);
828 fieldOnCells1->setMesh(mesh1);
829 MEDCouplingFieldDouble *fieldOnCells2=MEDCouplingFieldDouble::New(ON_CELLS,NO_TIME);
830 fieldOnCells2->setMesh(mesh2);
832 CPPUNIT_ASSERT(fieldOnCells1->isEqual(fieldOnCells2,1e-12,1e-15));
833 CPPUNIT_ASSERT(fieldOnCells2->isEqual(fieldOnCells1,1e-12,1e-15));
834 fieldOnCells2->decrRef();
836 MEDCouplingFieldDouble *fieldOnNodes1=MEDCouplingFieldDouble::New(ON_CELLS,NO_TIME);
837 CPPUNIT_ASSERT(!fieldOnCells1->isEqual(fieldOnNodes1,1e-12,1e-15));
838 CPPUNIT_ASSERT(!fieldOnNodes1->isEqual(fieldOnCells1,1e-12,1e-15));
839 fieldOnNodes1->decrRef();
841 fieldOnCells2=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
842 CPPUNIT_ASSERT(!fieldOnCells1->isEqual(fieldOnCells2,1e-12,1e-15));
843 CPPUNIT_ASSERT(!fieldOnCells2->isEqual(fieldOnCells1,1e-12,1e-15));
844 fieldOnCells1->decrRef();
845 fieldOnCells1=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
846 CPPUNIT_ASSERT(fieldOnCells1->isEqual(fieldOnCells2,1e-12,1e-15));
847 CPPUNIT_ASSERT(fieldOnCells2->isEqual(fieldOnCells1,1e-12,1e-15));
848 fieldOnCells1->setTime(4.,6,7);
849 CPPUNIT_ASSERT(!fieldOnCells1->isEqual(fieldOnCells2,1e-12,1e-15));
850 CPPUNIT_ASSERT(!fieldOnCells2->isEqual(fieldOnCells1,1e-12,1e-15));
851 fieldOnCells2->setTime(4.,6,7);
852 CPPUNIT_ASSERT(fieldOnCells1->isEqual(fieldOnCells2,1e-12,1e-15));
853 CPPUNIT_ASSERT(fieldOnCells2->isEqual(fieldOnCells1,1e-12,1e-15));
854 fieldOnCells1->setName("Power");
855 CPPUNIT_ASSERT(!fieldOnCells1->isEqual(fieldOnCells2,1e-12,1e-15));
856 CPPUNIT_ASSERT(!fieldOnCells2->isEqual(fieldOnCells1,1e-12,1e-15));
857 fieldOnCells2->setName("Power");
858 CPPUNIT_ASSERT(fieldOnCells1->isEqual(fieldOnCells2,1e-12,1e-15));
859 CPPUNIT_ASSERT(fieldOnCells2->isEqual(fieldOnCells1,1e-12,1e-15));
861 fieldOnCells1->setMesh(mesh1);
862 CPPUNIT_ASSERT(!fieldOnCells1->isEqual(fieldOnCells2,1e-12,1e-15));
863 CPPUNIT_ASSERT(!fieldOnCells2->isEqual(fieldOnCells1,1e-12,1e-15));
864 fieldOnCells2->setMesh(mesh1);
865 CPPUNIT_ASSERT(fieldOnCells1->isEqual(fieldOnCells2,1e-12,1e-15));
866 CPPUNIT_ASSERT(fieldOnCells2->isEqual(fieldOnCells1,1e-12,1e-15));
867 DataArrayDouble *arr=DataArrayDouble::New();
868 arr->setName("popo");
869 arr->alloc(mesh1->getNumberOfCells(),3);
870 double *pt=arr->getPointer();
871 std::fill(pt,pt+mesh1->getNumberOfCells()*3,6.);
872 fieldOnCells1->setArray(arr);
873 CPPUNIT_ASSERT(!fieldOnCells1->isEqual(fieldOnCells2,1e-12,1e-15));
874 CPPUNIT_ASSERT(!fieldOnCells2->isEqual(fieldOnCells1,1e-12,1e-15));
875 fieldOnCells2->setArray(arr);
877 CPPUNIT_ASSERT(fieldOnCells1->isEqual(fieldOnCells2,1e-12,1e-15));
878 CPPUNIT_ASSERT(fieldOnCells2->isEqual(fieldOnCells1,1e-12,1e-15));
880 DataArrayDouble *arr2=arr->deepCpy();
881 fieldOnCells2->setArray(arr2);
883 CPPUNIT_ASSERT(fieldOnCells1->isEqual(fieldOnCells2,1e-12,1e-15));
884 CPPUNIT_ASSERT(fieldOnCells2->isEqual(fieldOnCells1,1e-12,1e-15));
886 CPPUNIT_ASSERT(!fieldOnCells1->isEqual(fieldOnCells2,1e-12,1e-15));
887 CPPUNIT_ASSERT(!fieldOnCells2->isEqual(fieldOnCells1,1e-12,1e-15));
889 CPPUNIT_ASSERT(fieldOnCells1->isEqual(fieldOnCells2,1e-12,1e-15));
890 CPPUNIT_ASSERT(fieldOnCells2->isEqual(fieldOnCells1,1e-12,1e-15));
891 arr2->setName("popo2");
892 CPPUNIT_ASSERT(!fieldOnCells1->isEqual(fieldOnCells2,1e-12,1e-15));
893 CPPUNIT_ASSERT(!fieldOnCells2->isEqual(fieldOnCells1,1e-12,1e-15));
895 arr2->setName("popo");
896 CPPUNIT_ASSERT(fieldOnCells1->isEqual(fieldOnCells2,1e-12,1e-15));
897 CPPUNIT_ASSERT(fieldOnCells2->isEqual(fieldOnCells1,1e-12,1e-15));
899 arr2->setInfoOnComponent(2,"jjj");
900 CPPUNIT_ASSERT(!fieldOnCells1->isEqual(fieldOnCells2,1e-12,1e-15));
901 CPPUNIT_ASSERT(!fieldOnCells2->isEqual(fieldOnCells1,1e-12,1e-15));
902 arr->setInfoOnComponent(2,"jjj");
903 CPPUNIT_ASSERT(fieldOnCells1->isEqual(fieldOnCells2,1e-12,1e-15));
904 CPPUNIT_ASSERT(fieldOnCells2->isEqual(fieldOnCells1,1e-12,1e-15));
906 fieldOnCells1->decrRef();
907 fieldOnCells2->decrRef();
913 void MEDCouplingBasicsTest1::testNatureChecking()
915 MEDCouplingFieldDouble *field=MEDCouplingFieldDouble::New(ON_CELLS,NO_TIME);
916 field->setNature(Integral);
917 field->setNature(ConservativeVolumic);
918 field->setNature(IntegralGlobConstraint);
920 field=MEDCouplingFieldDouble::New(ON_NODES,NO_TIME);
921 field->setNature(ConservativeVolumic);
922 CPPUNIT_ASSERT_THROW(field->setNature(Integral),INTERP_KERNEL::Exception);
923 CPPUNIT_ASSERT_THROW(field->setNature(IntegralGlobConstraint),INTERP_KERNEL::Exception);
927 void MEDCouplingBasicsTest1::testBuildSubMeshData()
929 MEDCouplingUMesh *targetMesh=build2DTargetMesh_1();
930 //check buildSubMesh on field on cells
931 MEDCouplingFieldDouble *fieldCells=MEDCouplingFieldDouble::New(ON_CELLS,NO_TIME);
932 fieldCells->setMesh(targetMesh);
933 const int elts[3]={1,2,4};
935 MEDCouplingMesh *ret1=fieldCells->buildSubMeshData(elts,elts+3,di);
936 CPPUNIT_ASSERT_EQUAL(3,ret1->getNumberOfCells());
937 CPPUNIT_ASSERT_EQUAL(9,ret1->getNumberOfNodes());
938 CPPUNIT_ASSERT_EQUAL(3,di->getNumberOfTuples());
939 CPPUNIT_ASSERT_EQUAL(1,di->getNumberOfComponents());
940 const int *toCheck=di->getConstPointer();
941 CPPUNIT_ASSERT(std::equal(elts,elts+3,toCheck));
942 MEDCouplingUMesh *ret1DC=dynamic_cast<MEDCouplingUMesh *>(ret1);
943 CPPUNIT_ASSERT(ret1DC);
946 fieldCells->decrRef();
947 //check buildSubMesh on field on nodes
948 MEDCouplingFieldDouble *fieldNodes=MEDCouplingFieldDouble::New(ON_NODES,NO_TIME);
949 fieldNodes->setMesh(targetMesh);
950 MEDCouplingMesh *ret2=fieldNodes->buildSubMeshData(elts,elts+3,di);
951 MEDCouplingUMesh *ret2DC=dynamic_cast<MEDCouplingUMesh *>(ret2);
952 CPPUNIT_ASSERT(ret2DC);
953 CPPUNIT_ASSERT_EQUAL(3,ret2->getNumberOfCells());
954 CPPUNIT_ASSERT_EQUAL(6,ret2->getNumberOfNodes());
955 CPPUNIT_ASSERT_EQUAL(6,di->getNumberOfTuples());
956 CPPUNIT_ASSERT_EQUAL(1,di->getNumberOfComponents());
957 toCheck=di->getConstPointer();
958 const int expected[6]={1,2,4,5,7,8};
959 CPPUNIT_ASSERT(std::equal(expected,expected+6,toCheck));
962 fieldNodes->decrRef();
963 targetMesh->decrRef();
966 void MEDCouplingBasicsTest1::testExtrudedMesh1()
968 MEDCouplingUMesh *mesh2D=0;
969 MEDCouplingUMesh *mesh3D=build3DExtrudedUMesh_1(mesh2D);
970 MEDCouplingExtrudedMesh *ext=MEDCouplingExtrudedMesh::New(mesh3D,mesh2D,1);
971 CPPUNIT_ASSERT_EQUAL(18,ext->getNumberOfCells());
972 CPPUNIT_ASSERT_EQUAL(60,ext->getNumberOfNodes());
973 DataArrayInt *ids3D=ext->getMesh3DIds();
974 const int ids3DExpected[18]={5,4,3,2,1,0, 11,10,9,8,7,6, 17,16,15,14,13,12};
975 CPPUNIT_ASSERT_EQUAL(18,ids3D->getNumberOfTuples());
976 CPPUNIT_ASSERT_EQUAL(1,ids3D->getNumberOfComponents());
977 CPPUNIT_ASSERT(std::equal(ids3DExpected,ids3DExpected+18,ids3D->getConstPointer()));
978 MEDCouplingUMesh *mesh1D=ext->getMesh1D();
979 CPPUNIT_ASSERT_EQUAL(4,mesh1D->getNumberOfNodes());
980 CPPUNIT_ASSERT_EQUAL(3,mesh1D->getNumberOfCells());
981 const double mesh1DExpected[12]={0.66666666666666663, 1.4583333333333333, 0, 0.66666666666666663, 1.4583333333333333, 1, 0.66666666666666663, 1.4583333333333333, 2, 0.66666666666666663, 1.4583333333333333, 3};
982 DataArrayDouble *mesh1DCoords=mesh1D->getCoords();
983 CPPUNIT_ASSERT_EQUAL(4,mesh1DCoords->getNumberOfTuples());
984 CPPUNIT_ASSERT_EQUAL(3,mesh1DCoords->getNumberOfComponents());
985 CPPUNIT_ASSERT(std::equal(mesh1DExpected,mesh1DExpected+12,mesh1DCoords->getConstPointer()));
986 DataArrayInt *conn1D=mesh1D->getNodalConnectivity();
987 CPPUNIT_ASSERT_EQUAL(9,conn1D->getNumberOfTuples());
988 CPPUNIT_ASSERT_EQUAL(1,conn1D->getNumberOfComponents());
989 const int conn1DExpected[9]={1,0,1,1,1,2,1,2,3};
990 CPPUNIT_ASSERT(std::equal(conn1DExpected,conn1DExpected+9,conn1D->getConstPointer()));
996 void MEDCouplingBasicsTest1::testExtrudedMesh2()
998 MEDCouplingUMesh *mN,*mTT,*mTF;
999 build3DExtrudedUMesh_2(mN,mTT,mTF);
1003 DataArrayInt *da=mTT->mergeNodes(1e-12,b,newNbOfNodes);
1007 double pt[3]={300.,300.,0.};
1008 double v[3]={0.,0.,2.};
1009 mTT->findNodesOnPlane(pt,v,1e-12,n);
1010 CPPUNIT_ASSERT_EQUAL(43,(int)n.size());
1011 MEDCouplingUMesh *mTT3dSurf=(MEDCouplingUMesh *)mTT->buildFacePartOfMySelfNode(&n[0],&n[0]+n.size(),true);
1012 MEDCouplingExtrudedMesh *meTT=MEDCouplingExtrudedMesh::New(mTT,mTT3dSurf,0);
1013 CPPUNIT_ASSERT_EQUAL(200,meTT->getNumberOfCells());
1014 CPPUNIT_ASSERT_EQUAL(10,meTT->getMesh2D()->getNumberOfCells());
1015 CPPUNIT_ASSERT_EQUAL(20,meTT->getMesh1D()->getNumberOfCells());
1016 mTT3dSurf->decrRef();
1019 da=mN->mergeNodes(1e-12,b,newNbOfNodes);
1023 mN->findNodesOnPlane(pt,v,1e-12,n);
1024 CPPUNIT_ASSERT_EQUAL(30,(int)n.size());
1025 MEDCouplingUMesh *mN3dSurf=(MEDCouplingUMesh *)mN->buildFacePartOfMySelfNode(&n[0],&n[0]+n.size(),true);
1026 MEDCouplingExtrudedMesh *meN=MEDCouplingExtrudedMesh::New(mN,mN3dSurf,0);
1027 CPPUNIT_ASSERT_EQUAL(40,meN->getNumberOfCells());
1028 CPPUNIT_ASSERT_EQUAL(20,meN->getMesh2D()->getNumberOfCells());
1029 CPPUNIT_ASSERT_EQUAL(2,meN->getMesh1D()->getNumberOfCells());
1030 mN3dSurf->decrRef();
1033 da=mTF->mergeNodes(1e-12,b,newNbOfNodes);
1037 mTF->findNodesOnPlane(pt,v,1e-12,n);
1038 CPPUNIT_ASSERT_EQUAL(27,(int)n.size());
1039 MEDCouplingUMesh *mTF3dSurf=(MEDCouplingUMesh *)mTF->buildFacePartOfMySelfNode(&n[0],&n[0]+n.size(),true);
1040 MEDCouplingExtrudedMesh *meTF=MEDCouplingExtrudedMesh::New(mTF,mTF3dSurf,0);
1041 CPPUNIT_ASSERT_EQUAL(340,meTF->getNumberOfCells());
1042 CPPUNIT_ASSERT_EQUAL(17,meTF->getMesh2D()->getNumberOfCells());
1043 CPPUNIT_ASSERT_EQUAL(20,meTF->getMesh1D()->getNumberOfCells());
1044 mTF3dSurf->decrRef();
1056 * This test check MEDCouplingUMesh::buildExtrudedMesh method.
1058 void MEDCouplingBasicsTest1::testExtrudedMesh3()
1060 MEDCouplingUMesh *m1=build2DTargetMesh_1();
1061 m1->changeSpaceDimension(3);
1062 MEDCouplingUMesh *m2=buildCU1DMesh_U();
1063 m2->changeSpaceDimension(3);
1064 double center[3]={0.,0.,0.};
1065 double vector[3]={0,1,0};
1066 m2->rotate(center,vector,-M_PI/2.);
1067 MEDCouplingUMesh *m3=m1->buildExtrudedMesh(m2,0);
1069 MEDCouplingExtrudedMesh *m4=MEDCouplingExtrudedMesh::New(m3,m1,0);
1070 CPPUNIT_ASSERT_EQUAL(15,m4->getNumberOfCells());
1071 CPPUNIT_ASSERT_EQUAL(5,m4->getMesh2D()->getNumberOfCells());
1072 CPPUNIT_ASSERT_EQUAL(3,m4->getMesh1D()->getNumberOfCells());
1073 const int *m3DIds=m4->getMesh3DIds()->getConstPointer();
1074 for(int i=0;i<15;i++)
1075 CPPUNIT_ASSERT_EQUAL(i,m3DIds[i]);
1077 //some random in cells to check that extrusion alg find it correctly
1078 const int expected1[15]={1,3,2,0,6,5,7,10,11,8,12,9,14,13,4};
1079 m3->renumberCells(expected1,false);
1080 m4=MEDCouplingExtrudedMesh::New(m3,m1,0);
1081 CPPUNIT_ASSERT_EQUAL(15,m4->getNumberOfCells());
1082 CPPUNIT_ASSERT_EQUAL(5,m4->getMesh2D()->getNumberOfCells());
1083 CPPUNIT_ASSERT_EQUAL(3,m4->getMesh1D()->getNumberOfCells());
1084 m3DIds=m4->getMesh3DIds()->getConstPointer();
1085 for(int i=0;i<15;i++)
1086 CPPUNIT_ASSERT_EQUAL(expected1[i],m3DIds[i]);
1089 //play with polygons and polyedrons
1090 std::vector<int> cells(2); cells[0]=2; cells[1]=3;
1091 m1->convertToPolyTypes(&cells[0],&cells[0]+cells.size());
1092 m3=m1->buildExtrudedMesh(m2,0);
1093 CPPUNIT_ASSERT_EQUAL((int)INTERP_KERNEL::NORM_HEXA8,(int)m3->getTypeOfCell(0));
1094 CPPUNIT_ASSERT_EQUAL((int)INTERP_KERNEL::NORM_PENTA6,(int)m3->getTypeOfCell(1));
1095 CPPUNIT_ASSERT_EQUAL((int)INTERP_KERNEL::NORM_POLYHED,(int)m3->getTypeOfCell(2));
1096 CPPUNIT_ASSERT_EQUAL((int)INTERP_KERNEL::NORM_POLYHED,(int)m3->getTypeOfCell(3));
1097 CPPUNIT_ASSERT_EQUAL((int)INTERP_KERNEL::NORM_HEXA8,(int)m3->getTypeOfCell(4));
1098 m3->renumberCells(expected1,false);
1099 m4=MEDCouplingExtrudedMesh::New(m3,m1,0);
1100 CPPUNIT_ASSERT_EQUAL(15,m4->getNumberOfCells());
1101 CPPUNIT_ASSERT_EQUAL(5,m4->getMesh2D()->getNumberOfCells());
1102 CPPUNIT_ASSERT_EQUAL(3,m4->getMesh1D()->getNumberOfCells());
1103 m3DIds=m4->getMesh3DIds()->getConstPointer();
1104 for(int i=0;i<15;i++)
1105 CPPUNIT_ASSERT_EQUAL(expected1[i],m3DIds[i]);
1114 * This test check MEDCouplingUMesh::buildExtrudedMesh method, but also, MEDCouplingExtrudedMesh following methods :
1115 * getCellContainingPoint getMeasureField getNodeIdsOfCell getCoordinateOfNode getTypeOfCell build3DUnstructuredMesh.
1117 void MEDCouplingBasicsTest1::testExtrudedMesh4()
1119 MEDCouplingUMesh *m1=build2DTargetMesh_1();
1120 std::vector<int> cells(2); cells[0]=2; cells[1]=4;
1121 m1->convertToPolyTypes(&cells[0],&cells[0]+cells.size());
1122 m1->changeSpaceDimension(3);
1123 MEDCouplingUMesh *m2=buildCU1DMesh_U();
1124 m2->changeSpaceDimension(3);
1125 double center[3]={0.,0.,0.};
1126 double vector[3]={0.,1.,0.};
1127 m2->rotate(center,vector,-M_PI/2.);
1128 MEDCouplingUMesh *m3=m1->buildExtrudedMesh(m2,0);
1129 const int expected1[15]= {1,3,2,0,6,5,7,10,11,8,12,9,14,13,4};
1130 const int rexpected1[15]={3, 0, 2, 1, 14, 5, 4, 6, 9, 11, 7, 8, 10, 13, 12};
1131 m3->renumberCells(expected1,false);
1132 MEDCouplingExtrudedMesh *m4=MEDCouplingExtrudedMesh::New(m3,m1,0);
1133 CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_HEXA8,m4->getTypeOfCell(0));
1134 CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_HEXA8,m4->getTypeOfCell(1));
1135 CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_POLYHED,m4->getTypeOfCell(2));
1136 CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_PENTA6,m4->getTypeOfCell(7));
1137 MEDCouplingFieldDouble *f=m4->getMeasureField(true);
1138 DataArrayDouble *arr=f->getArray();
1139 CPPUNIT_ASSERT_EQUAL(15,arr->getNumberOfTuples());
1140 CPPUNIT_ASSERT_EQUAL(1,arr->getNumberOfComponents());
1141 const double *arrPtr=arr->getConstPointer();
1142 const double expected2[15]={0.075,0.0375,0.0375,0.075,0.075, 0.1125,0.05625,0.05625,0.1125,0.1125, 0.0625,0.03125,0.03125,0.0625,0.0625};
1143 for(int i=0;i<15;i++)
1144 CPPUNIT_ASSERT_DOUBLES_EQUAL(expected2[rexpected1[i]],arrPtr[i],1e-16);
1146 MEDCouplingUMesh *m5=m4->build3DUnstructuredMesh();
1147 CPPUNIT_ASSERT(m5->isEqual(m3,1e-12));
1148 f=m5->getMeasureField(true);
1150 arrPtr=arr->getConstPointer();
1151 for(int i=0;i<15;i++)
1152 CPPUNIT_ASSERT_DOUBLES_EQUAL(expected2[rexpected1[i]],arrPtr[i],1e-16);
1162 void MEDCouplingBasicsTest1::testFindCommonNodes()
1164 DataArrayInt *comm,*commI;
1165 MEDCouplingUMesh *targetMesh=build3DTargetMesh_1();
1166 targetMesh->findCommonNodes(1e-10,-1,comm,commI);
1167 CPPUNIT_ASSERT_EQUAL(1,commI->getNumberOfTuples());
1168 CPPUNIT_ASSERT_EQUAL(0,comm->getNumberOfTuples());
1170 DataArrayInt *o2n=targetMesh->buildNewNumberingFromCommonNodesFormat(comm,commI,newNbOfNodes);
1171 CPPUNIT_ASSERT_EQUAL(27,newNbOfNodes);
1172 CPPUNIT_ASSERT_EQUAL(27,o2n->getNumberOfTuples());
1173 const int o2nExp1[27]=
1175 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,
1178 CPPUNIT_ASSERT(std::equal(o2nExp1,o2nExp1+27,o2n->getConstPointer()));
1182 targetMesh->decrRef();
1184 targetMesh=build3DTargetMeshMergeNode_1();
1185 CPPUNIT_ASSERT_EQUAL(31,targetMesh->getNumberOfNodes());
1186 targetMesh->findCommonNodes(1e-10,-1,comm,commI);
1187 CPPUNIT_ASSERT_EQUAL(3,commI->getNumberOfTuples());
1188 CPPUNIT_ASSERT_EQUAL(6,comm->getNumberOfTuples());
1189 const int commExpected[6]={1,27,28,29,23,30};
1190 const int commIExpected[3]={0,4,6};
1191 CPPUNIT_ASSERT(std::equal(commExpected,commExpected+6,comm->getConstPointer()));
1192 CPPUNIT_ASSERT(std::equal(commIExpected,commIExpected+3,commI->getConstPointer()));
1193 o2n=targetMesh->buildNewNumberingFromCommonNodesFormat(comm,commI,newNbOfNodes);
1194 CPPUNIT_ASSERT_EQUAL(31,o2n->getNumberOfTuples());
1195 CPPUNIT_ASSERT_EQUAL(27,newNbOfNodes);
1196 const int o2nExp2[31]=
1198 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,
1199 21,22,23,24,25,26,1,1,1,23
1201 CPPUNIT_ASSERT(std::equal(o2nExp2,o2nExp2+31,o2n->getConstPointer()));
1205 targetMesh->decrRef();
1207 targetMesh=build3DTargetMesh_1();
1208 bool areNodesMerged;
1209 unsigned int time=targetMesh->getTimeOfThis();
1210 o2n=targetMesh->mergeNodes(1e-10,areNodesMerged,newNbOfNodes);
1211 targetMesh->updateTime();
1212 CPPUNIT_ASSERT(time==targetMesh->getTimeOfThis());
1213 CPPUNIT_ASSERT(!areNodesMerged);
1214 targetMesh->decrRef();
1217 targetMesh=build3DTargetMeshMergeNode_1();
1218 time=targetMesh->getTimeOfThis();
1219 o2n=targetMesh->mergeNodes(1e-10,areNodesMerged,newNbOfNodes);
1220 targetMesh->updateTime();
1221 CPPUNIT_ASSERT(time!=targetMesh->getTimeOfThis());
1222 CPPUNIT_ASSERT(areNodesMerged);
1223 int connExp[72]={18,0,1,4,3,9,10,13,12, 18,1,2,5,4,10,11,14,13, 18,3,4,7,6,12,13,16,15,
1224 18,4,5,8,7,13,14,17,16,
1225 18,9,10,13,12,18,19,22,21, 18,10,11,14,13,19,20,23,22, 18,12,13,16,15,21,22,25,24,
1226 18,13,14,17,16,22,23,26,25};
1227 CPPUNIT_ASSERT_EQUAL(72,targetMesh->getNodalConnectivity()->getNumberOfTuples());
1228 CPPUNIT_ASSERT(std::equal(connExp,connExp+72,targetMesh->getNodalConnectivity()->getConstPointer()));
1229 CPPUNIT_ASSERT_EQUAL(27,targetMesh->getCoords()->getNumberOfTuples());
1230 double coordsExp[81]={ 0., 0., 0., 50., 0., 0. , 200., 0., 0. , 0., 50., 0., 50., 50., 0. ,
1231 200., 50., 0., 0., 200., 0., 50., 200., 0. , 200., 200., 0. ,
1232 0., 0., 50., 50., 0., 50. , 200., 0., 50. , 0., 50., 50., 50.,
1233 50., 50. , 200., 50., 50., 0., 200., 50., 50., 200., 50. ,
1234 200., 200., 50. , 0., 0., 200., 50., 0., 200. , 200., 0., 200.
1235 , 0., 50., 200., 50., 50., 200. , 200., 50., 200.,
1236 0., 200., 200., 50., 200., 200. , 200., 200., 200. };
1237 CPPUNIT_ASSERT(std::equal(coordsExp,coordsExp+81,targetMesh->getCoords()->getConstPointer()));
1238 targetMesh->decrRef();
1241 targetMesh=build2DTargetMeshMergeNode_1();
1242 CPPUNIT_ASSERT_EQUAL(18,targetMesh->getNumberOfNodes());
1243 time=targetMesh->getTimeOfThis();
1244 o2n=targetMesh->mergeNodes(1e-10,areNodesMerged,newNbOfNodes);
1245 CPPUNIT_ASSERT(time!=targetMesh->getTimeOfThis());
1246 CPPUNIT_ASSERT(areNodesMerged);
1247 CPPUNIT_ASSERT_EQUAL(9,targetMesh->getNumberOfNodes());
1248 int connExp2[23]={4,0,4,3,1, 3,1,3,2, 3,3,5,2, 4,4,6,7,3, 4,7,8,5,3};
1249 CPPUNIT_ASSERT_EQUAL(23,targetMesh->getNodalConnectivity()->getNumberOfTuples());
1250 CPPUNIT_ASSERT(std::equal(connExp2,connExp2+23,targetMesh->getNodalConnectivity()->getConstPointer()));
1251 double coordsExp2[18]={-0.3,-0.3, 0.2,-0.3, 0.7,-0.3, 0.2,0.2, -0.3,0.2, 0.7,0.2, -0.3,0.7, 0.2,0.7, 0.7,0.7};
1252 CPPUNIT_ASSERT_EQUAL(9,targetMesh->getCoords()->getNumberOfTuples());
1253 CPPUNIT_ASSERT(std::equal(coordsExp2,coordsExp2+18,targetMesh->getCoords()->getConstPointer()));
1254 targetMesh->decrRef();
1258 void MEDCouplingBasicsTest1::testCheckButterflyCells()
1260 std::vector<int> cells;
1261 MEDCouplingUMesh *sourceMesh=build2DTargetMesh_1();
1262 sourceMesh->checkButterflyCells(cells);
1263 CPPUNIT_ASSERT(cells.empty());
1264 int *pt=sourceMesh->getNodalConnectivity()->getPointer();
1265 std::swap(pt[15],pt[16]);
1266 sourceMesh->checkButterflyCells(cells);
1267 CPPUNIT_ASSERT_EQUAL(1,(int)cells.size());
1268 CPPUNIT_ASSERT_EQUAL(3,cells[0]);
1270 std::swap(pt[15],pt[16]);
1271 sourceMesh->checkButterflyCells(cells);
1272 CPPUNIT_ASSERT(cells.empty());
1273 sourceMesh->decrRef();
1275 sourceMesh=build3DSurfTargetMesh_1();
1276 sourceMesh->checkButterflyCells(cells);
1277 CPPUNIT_ASSERT(cells.empty());
1278 pt=sourceMesh->getNodalConnectivity()->getPointer();
1279 std::swap(pt[15],pt[16]);
1280 sourceMesh->checkButterflyCells(cells);
1281 CPPUNIT_ASSERT_EQUAL(1,(int)cells.size());
1282 CPPUNIT_ASSERT_EQUAL(3,cells[0]);
1284 std::swap(pt[15],pt[16]);
1285 sourceMesh->checkButterflyCells(cells);
1286 CPPUNIT_ASSERT(cells.empty());
1287 sourceMesh->decrRef();
1290 void MEDCouplingBasicsTest1::testMergeMesh1()
1292 MEDCouplingUMesh *m1=build2DTargetMesh_1();
1293 MEDCouplingUMesh *m2=build2DSourceMesh_1();
1294 const double vec[2]={1.,0.};
1296 MEDCouplingMesh *m3=m1->mergeMyselfWith(m2);
1297 MEDCouplingUMesh *m3C=dynamic_cast<MEDCouplingUMesh *>(m3);
1298 CPPUNIT_ASSERT(m3C);
1299 m3->checkCoherency();
1300 MEDCouplingUMesh *m4=build2DTargetMeshMerged_1();
1301 CPPUNIT_ASSERT(m3->isEqual(m4,1.e-12));
1305 DataArrayInt *da=m3C->mergeNodes(1.e-12,isMerged,newNbOfNodes);
1306 CPPUNIT_ASSERT_EQUAL(11,m3C->getNumberOfNodes());
1307 CPPUNIT_ASSERT_EQUAL(11,newNbOfNodes);
1308 CPPUNIT_ASSERT(isMerged);
1315 void MEDCouplingBasicsTest1::testMergeMeshOnSameCoords1()
1317 MEDCouplingUMesh *m1=build2DTargetMesh_1();
1318 MEDCouplingUMesh *m2=build2DTargetMesh_1();
1319 std::vector<int> cells(5);
1320 for(int i=0;i<5;i++)
1322 m2->convertToPolyTypes(&cells[0],&cells[0]+cells.size());
1323 m1->tryToShareSameCoords(*m2,1e-12);
1324 MEDCouplingUMesh *m3=build2DTargetMesh_1();
1325 m3->tryToShareSameCoords(*m2,1e-12);
1326 std::vector<const MEDCouplingUMesh *> meshes;
1327 meshes.push_back(m1); meshes.push_back(m2); meshes.push_back(m3);
1328 MEDCouplingUMesh *m4=MEDCouplingUMesh::MergeUMeshesOnSameCoords(meshes);
1329 m4->checkCoherency();
1330 CPPUNIT_ASSERT(m4->getCoords()==m1->getCoords());
1331 CPPUNIT_ASSERT_EQUAL(15,m4->getNumberOfCells());
1332 const int cells1[5]={0,1,2,3,4};
1333 MEDCouplingPointSet *m1_1=m4->buildPartOfMySelf(cells1,cells1+5,true);
1334 m1_1->setName(m1->getName());
1335 CPPUNIT_ASSERT(m1->isEqual(m1_1,1e-12));
1336 const int cells2[5]={5,6,7,8,9};
1337 MEDCouplingPointSet *m2_1=m4->buildPartOfMySelf(cells2,cells2+5,true);
1338 m2_1->setName(m2->getName());
1339 CPPUNIT_ASSERT(m2->isEqual(m2_1,1e-12));
1340 const int cells3[5]={10,11,12,13,14};
1341 MEDCouplingPointSet *m3_1=m4->buildPartOfMySelf(cells3,cells3+5,true);
1342 m3_1->setName(m3->getName());
1343 CPPUNIT_ASSERT(m3->isEqual(m3_1,1e-12));
1344 m1_1->decrRef(); m2_1->decrRef(); m3_1->decrRef();
1352 void MEDCouplingBasicsTest1::testMergeField1()
1354 MEDCouplingUMesh *m1=build2DTargetMesh_1();
1355 MEDCouplingUMesh *m2=build2DSourceMesh_1();
1356 const double vec[2]={1.,0.};
1358 MEDCouplingFieldDouble *f1=m1->getMeasureField(true);
1359 MEDCouplingFieldDouble *f2=m2->getMeasureField(true);
1360 MEDCouplingFieldDouble *f3=MEDCouplingFieldDouble::MergeFields(f1,f2);
1361 f3->checkCoherency();
1362 MEDCouplingUMesh *m4=build2DTargetMeshMerged_1();
1363 CPPUNIT_ASSERT(f3->getMesh()->isEqual(m4,1.e-12));
1364 std::string name=f3->getName();
1365 CPPUNIT_ASSERT(name=="MeasureOfMesh_");
1366 CPPUNIT_ASSERT(f3->getTypeOfField()==ON_CELLS);
1367 CPPUNIT_ASSERT(f3->getTimeDiscretization()==ONE_TIME);
1368 CPPUNIT_ASSERT_EQUAL(1,f3->getNumberOfComponents());
1369 CPPUNIT_ASSERT_EQUAL(7,f3->getNumberOfTuples());
1370 double values[7]={0.25,0.125,0.125,0.25,0.25,0.5,0.5};
1371 const double *tmp=f3->getArray()->getConstPointer();
1372 std::transform(tmp,tmp+7,values,values,std::minus<double>());
1373 std::transform(values,values+7,values,std::ptr_fun<double,double>(fabs));
1374 double max=*std::max_element(values,values+7);
1375 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,max,1.e-12);
1384 bool func1(const double *pt, double *res);
1385 bool func2(const double *pt, double *res);
1386 bool func3(const double *pt, double *res);
1387 bool func4(const double *pt, double *res);
1389 bool func1(const double *pt, double *res)
1395 bool func2(const double *pt, double *res)
1398 res[1]=2.*(pt[0]+pt[1]);
1402 bool func3(const double *pt, double *res)
1404 if(fabs(pt[0]-0.2)<1e-12)
1406 res[0]=1./(pt[0]-0.2);
1410 void MEDCouplingBasicsTest1::testFillFromAnalytic()
1412 MEDCouplingUMesh *m=build2DTargetMesh_1();
1413 m->setTime(3.4,5,6); m->setTimeUnit("us");
1415 MEDCouplingFieldDouble *f1=m->fillFromAnalytic(ON_CELLS,1,func1);
1416 CPPUNIT_ASSERT_DOUBLES_EQUAL(3.4,f1->getTime(a,b),1.e-14);
1417 CPPUNIT_ASSERT_EQUAL(5,a); CPPUNIT_ASSERT_EQUAL(6,b);
1418 CPPUNIT_ASSERT_EQUAL(std::string(f1->getTimeUnit()),std::string("us"));
1419 f1->checkCoherency();
1420 CPPUNIT_ASSERT(f1->getTypeOfField()==ON_CELLS);
1421 CPPUNIT_ASSERT(f1->getTimeDiscretization()==ONE_TIME);
1422 CPPUNIT_ASSERT_EQUAL(1,f1->getNumberOfComponents());
1423 CPPUNIT_ASSERT_EQUAL(5,f1->getNumberOfTuples());
1424 double values1[5]={-0.1,0.23333333333333336,0.56666666666666665,0.4,0.9};
1425 const double *tmp=f1->getArray()->getConstPointer();
1426 std::transform(tmp,tmp+5,values1,values1,std::minus<double>());
1427 std::transform(values1,values1+5,values1,std::ptr_fun<double,double>(fabs));
1428 double max=*std::max_element(values1,values1+5);
1429 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,max,1.e-12);
1432 f1=m->fillFromAnalytic(ON_NODES,1,func1);
1433 f1->checkCoherency();
1434 CPPUNIT_ASSERT(f1->getTypeOfField()==ON_NODES);
1435 CPPUNIT_ASSERT(f1->getTimeDiscretization()==ONE_TIME);
1436 CPPUNIT_ASSERT_EQUAL(1,f1->getNumberOfComponents());
1437 CPPUNIT_ASSERT_EQUAL(9,f1->getNumberOfTuples());
1438 double values2[9]={-0.6,-0.1,0.4,-0.1,0.4,0.9,0.4,0.9,1.4};
1439 tmp=f1->getArray()->getConstPointer();
1440 std::transform(tmp,tmp+9,values2,values2,std::minus<double>());
1441 std::transform(values2,values2+9,values2,std::ptr_fun<double,double>(fabs));
1442 max=*std::max_element(values2,values2+9);
1443 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,max,1.e-12);
1446 f1=m->fillFromAnalytic(ON_NODES,2,func2);
1447 f1->checkCoherency();
1448 CPPUNIT_ASSERT(f1->getTypeOfField()==ON_NODES);
1449 CPPUNIT_ASSERT(f1->getTimeDiscretization()==ONE_TIME);
1450 CPPUNIT_ASSERT_EQUAL(2,f1->getNumberOfComponents());
1451 CPPUNIT_ASSERT_EQUAL(9,f1->getNumberOfTuples());
1452 double values3[18]={-0.6,-1.2,-0.1,-0.2,0.4,0.8,-0.1,-0.2,0.4,0.8,0.9,1.8,0.4,0.8,0.9,1.8,1.4,2.8};
1453 tmp=f1->getArray()->getConstPointer();
1454 std::transform(tmp,tmp+18,values3,values3,std::minus<double>());
1455 std::transform(values3,values3+18,values3,std::ptr_fun<double,double>(fabs));
1456 max=*std::max_element(values3,values3+18);
1457 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,max,1.e-12);
1459 f1->accumulate(values4);
1460 CPPUNIT_ASSERT_DOUBLES_EQUAL(3.6,values4[0],1.e-12);
1461 CPPUNIT_ASSERT_DOUBLES_EQUAL(7.2,values4[1],1.e-12);
1462 f1->integral(true,values4);
1463 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.5,values4[0],1.e-12);
1464 CPPUNIT_ASSERT_DOUBLES_EQUAL(1.,values4[1],1.e-12);
1467 CPPUNIT_ASSERT_THROW(f1=m->fillFromAnalytic(ON_NODES,1,func3),INTERP_KERNEL::Exception);
1472 void MEDCouplingBasicsTest1::testFillFromAnalytic2()
1474 MEDCouplingUMesh *m=build2DTargetMesh_1();
1475 MEDCouplingFieldDouble *f1=m->fillFromAnalytic(ON_CELLS,1,"y+x");
1476 f1->checkCoherency();
1477 CPPUNIT_ASSERT(f1->getTypeOfField()==ON_CELLS);
1478 CPPUNIT_ASSERT(f1->getTimeDiscretization()==ONE_TIME);
1479 CPPUNIT_ASSERT_EQUAL(1,f1->getNumberOfComponents());
1480 CPPUNIT_ASSERT_EQUAL(5,f1->getNumberOfTuples());
1481 double values1[5]={-0.1,0.23333333333333336,0.56666666666666665,0.4,0.9};
1482 const double *tmp=f1->getArray()->getConstPointer();
1483 std::transform(tmp,tmp+5,values1,values1,std::minus<double>());
1484 std::transform(values1,values1+5,values1,std::ptr_fun<double,double>(fabs));
1485 double max=*std::max_element(values1,values1+5);
1486 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,max,1.e-12);
1489 f1=m->fillFromAnalytic(ON_NODES,1,"y+2*x");
1490 f1->checkCoherency();
1491 CPPUNIT_ASSERT(f1->getTypeOfField()==ON_NODES);
1492 CPPUNIT_ASSERT(f1->getTimeDiscretization()==ONE_TIME);
1493 CPPUNIT_ASSERT_EQUAL(1,f1->getNumberOfComponents());
1494 CPPUNIT_ASSERT_EQUAL(9,f1->getNumberOfTuples());
1495 double values2[9]={-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1};
1496 tmp=f1->getArray()->getConstPointer();
1497 std::transform(tmp,tmp+9,values2,values2,std::minus<double>());
1498 std::transform(values2,values2+9,values2,std::ptr_fun<double,double>(fabs));
1499 max=*std::max_element(values2,values2+9);
1500 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,max,1.e-12);
1502 f1=m->fillFromAnalytic(ON_NODES,1,"2.*x+y");
1503 f1->checkCoherency();
1504 CPPUNIT_ASSERT(f1->getTypeOfField()==ON_NODES);
1505 CPPUNIT_ASSERT(f1->getTimeDiscretization()==ONE_TIME);
1506 CPPUNIT_ASSERT_EQUAL(1,f1->getNumberOfComponents());
1507 CPPUNIT_ASSERT_EQUAL(9,f1->getNumberOfTuples());
1508 tmp=f1->getArray()->getConstPointer();
1509 double values2Bis[9]={-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1};
1510 std::transform(tmp,tmp+9,values2Bis,values2Bis,std::minus<double>());
1511 std::transform(values2,values2+9,values2Bis,std::ptr_fun<double,double>(fabs));
1512 max=*std::max_element(values2Bis,values2Bis+9);
1513 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,max,1.e-12);
1516 f1=m->fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+2*(x+y)*JVec");
1517 f1->checkCoherency();
1518 CPPUNIT_ASSERT(f1->getTypeOfField()==ON_NODES);
1519 CPPUNIT_ASSERT(f1->getTimeDiscretization()==ONE_TIME);
1520 CPPUNIT_ASSERT_EQUAL(2,f1->getNumberOfComponents());
1521 CPPUNIT_ASSERT_EQUAL(9,f1->getNumberOfTuples());
1522 double values3[18]={-0.6,-1.2,-0.1,-0.2,0.4,0.8,-0.1,-0.2,0.4,0.8,0.9,1.8,0.4,0.8,0.9,1.8,1.4,2.8};
1523 tmp=f1->getArray()->getConstPointer();
1524 std::transform(tmp,tmp+18,values3,values3,std::minus<double>());
1525 std::transform(values3,values3+18,values3,std::ptr_fun<double,double>(fabs));
1526 max=*std::max_element(values3,values3+18);
1527 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,max,1.e-12);
1529 f1->accumulate(values4);
1530 CPPUNIT_ASSERT_DOUBLES_EQUAL(3.6,values4[0],1.e-12);
1531 CPPUNIT_ASSERT_DOUBLES_EQUAL(7.2,values4[1],1.e-12);
1532 f1->integral(true,values4);
1533 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.5,values4[0],1.e-12);
1534 CPPUNIT_ASSERT_DOUBLES_EQUAL(1.,values4[1],1.e-12);
1537 CPPUNIT_ASSERT_THROW(f1=m->fillFromAnalytic(ON_NODES,1,"1./(x-0.2)"),INTERP_KERNEL::Exception);
1542 void MEDCouplingBasicsTest1::testApplyFunc()
1544 MEDCouplingUMesh *m=build2DTargetMesh_1();
1545 MEDCouplingFieldDouble *f1=m->fillFromAnalytic(ON_NODES,2,func2);
1546 f1->checkCoherency();
1547 CPPUNIT_ASSERT(f1->getTypeOfField()==ON_NODES);
1548 CPPUNIT_ASSERT(f1->getTimeDiscretization()==ONE_TIME);
1549 CPPUNIT_ASSERT_EQUAL(2,f1->getNumberOfComponents());
1550 CPPUNIT_ASSERT_EQUAL(9,f1->getNumberOfTuples());
1551 f1->applyFunc(1,func1);
1552 CPPUNIT_ASSERT(f1->getTypeOfField()==ON_NODES);
1553 CPPUNIT_ASSERT(f1->getTimeDiscretization()==ONE_TIME);
1554 CPPUNIT_ASSERT_EQUAL(1,f1->getNumberOfComponents());
1555 CPPUNIT_ASSERT_EQUAL(9,f1->getNumberOfTuples());
1556 double values1[9]={-1.8,-0.3,1.2,-0.3,1.2,2.7,1.2,2.7,4.2};
1557 const double *tmp=f1->getArray()->getConstPointer();
1558 std::transform(tmp,tmp+9,values1,values1,std::minus<double>());
1559 std::transform(values1,values1+9,values1,std::ptr_fun<double,double>(fabs));
1560 double max=*std::max_element(values1,values1+9);
1561 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,max,1.e-12);
1566 void MEDCouplingBasicsTest1::testApplyFunc2()
1568 MEDCouplingUMesh *m=build2DTargetMesh_1();
1569 MEDCouplingFieldDouble *f1=m->fillFromAnalytic(ON_NODES,2,func2);
1570 f1->checkCoherency();
1571 CPPUNIT_ASSERT(f1->getTypeOfField()==ON_NODES);
1572 CPPUNIT_ASSERT(f1->getTimeDiscretization()==ONE_TIME);
1573 CPPUNIT_ASSERT_EQUAL(2,f1->getNumberOfComponents());
1574 CPPUNIT_ASSERT_EQUAL(9,f1->getNumberOfTuples());
1576 MEDCouplingFieldDouble *f2=f1->clone(true);
1577 CPPUNIT_ASSERT_THROW(f2->applyFunc(1,"a+b+c+d"),INTERP_KERNEL::Exception);
1578 CPPUNIT_ASSERT_THROW(f2->applyFunc(1,"a/0"),INTERP_KERNEL::Exception);
1579 CPPUNIT_ASSERT_THROW(f2->applyFunc("a/0"),INTERP_KERNEL::Exception);
1580 f2->applyFunc("abs(u)^2.4+2*u");
1581 CPPUNIT_ASSERT(f1->getTypeOfField()==ON_NODES);
1582 CPPUNIT_ASSERT(f1->getTimeDiscretization()==ONE_TIME);
1583 CPPUNIT_ASSERT_EQUAL(2,f1->getNumberOfComponents());
1584 CPPUNIT_ASSERT_EQUAL(9,f1->getNumberOfTuples());
1585 double values2[18]={-0.9065304805418678, -0.85105859001709905, -0.19601892829446504, -0.37898777756476987,
1586 0.91090317490482353, 2.1853504664669781, -0.19601892829446504, -0.37898777756476987,
1587 0.91090317490482353, 2.1853504664669781, 2.5765725275664879, 7.6987743736515295,
1588 0.91090317490482353, 2.1853504664669781, 2.5765725275664879, 7.6987743736515295,
1589 5.0423700574830965, 17.435300118916864};
1590 const double *tmp=f2->getArray()->getConstPointer();
1591 std::transform(tmp,tmp+18,values2,values2,std::minus<double>());
1592 std::transform(values2,values2+18,values2,std::ptr_fun<double,double>(fabs));
1593 double max=*std::max_element(values2,values2+18);
1594 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,max,1.e-12);
1597 f1->applyFunc(1,"x+y");
1598 CPPUNIT_ASSERT(f1->getTypeOfField()==ON_NODES);
1599 CPPUNIT_ASSERT(f1->getTimeDiscretization()==ONE_TIME);
1600 CPPUNIT_ASSERT_EQUAL(1,f1->getNumberOfComponents());
1601 CPPUNIT_ASSERT_EQUAL(9,f1->getNumberOfTuples());
1602 double values1[9]={-1.8,-0.3,1.2,-0.3,1.2,2.7,1.2,2.7,4.2};
1603 tmp=f1->getArray()->getConstPointer();
1604 std::transform(tmp,tmp+9,values1,values1,std::minus<double>());
1605 std::transform(values1,values1+9,values1,std::ptr_fun<double,double>(fabs));
1606 max=*std::max_element(values1,values1+9);
1607 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,max,1.e-12);
1612 void MEDCouplingBasicsTest1::testOperationsOnFields()
1614 MEDCouplingUMesh *m=build2DTargetMesh_1();
1615 MEDCouplingFieldDouble *f1=m->fillFromAnalytic(ON_NODES,1,func1);
1616 MEDCouplingFieldDouble *f2=m->fillFromAnalytic(ON_NODES,1,func1);
1617 f1->checkCoherency();
1618 f2->checkCoherency();
1619 MEDCouplingFieldDouble *f3=(*f1)+(*f2);
1620 f3->checkCoherency();
1621 CPPUNIT_ASSERT(f3->getTypeOfField()==ON_NODES);
1622 CPPUNIT_ASSERT(f3->getTimeDiscretization()==ONE_TIME);
1623 double values1[9]={-1.2,-0.2,0.8,-0.2,0.8,1.8,0.8,1.8,2.8};
1624 const double *tmp=f3->getArray()->getConstPointer();
1625 std::transform(tmp,tmp+9,values1,values1,std::minus<double>());
1626 std::transform(values1,values1+9,values1,std::ptr_fun<double,double>(fabs));
1627 double max=*std::max_element(values1,values1+9);
1628 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,max,1.e-12);
1632 f3->checkCoherency();
1633 CPPUNIT_ASSERT(f3->getTypeOfField()==ON_NODES);
1634 CPPUNIT_ASSERT(f3->getTimeDiscretization()==ONE_TIME);
1635 double values2[9]={0.36,0.01,0.16,0.01,0.16,0.81,0.16,0.81,1.96};
1636 tmp=f3->getArray()->getConstPointer();
1637 std::transform(tmp,tmp+9,values2,values2,std::minus<double>());
1638 std::transform(values2,values2+9,values2,std::ptr_fun<double,double>(fabs));
1639 max=*std::max_element(values2,values2+9);
1640 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,max,1.e-12);
1644 MEDCouplingFieldDouble *f4=(*f1)-(*f3);
1645 f4->checkCoherency();
1646 CPPUNIT_ASSERT(f4->getTypeOfField()==ON_NODES);
1647 CPPUNIT_ASSERT(f4->getTimeDiscretization()==ONE_TIME);
1648 double values3[9]={0.6,0.1,-0.4,0.1,-0.4,-0.9,-0.4,-0.9,-1.4};
1649 tmp=f4->getArray()->getConstPointer();
1650 std::transform(tmp,tmp+9,values3,values3,std::minus<double>());
1651 std::transform(values3,values3+9,values3,std::ptr_fun<double,double>(fabs));
1652 max=*std::max_element(values3,values3+9);
1653 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,max,1.e-12);
1659 f4->checkCoherency();
1660 CPPUNIT_ASSERT(f4->getTypeOfField()==ON_NODES);
1661 CPPUNIT_ASSERT(f4->getTimeDiscretization()==ONE_TIME);
1662 tmp=f4->getArray()->getConstPointer();
1663 for(int i=0;i<9;i++)
1664 CPPUNIT_ASSERT_DOUBLES_EQUAL(2.,tmp[i],1.e-12);
1668 f4=f2->buildNewTimeReprFromThis(NO_TIME,false);
1669 f4->checkCoherency();
1670 CPPUNIT_ASSERT(f4->getArray()==f2->getArray());
1671 CPPUNIT_ASSERT(f4->getTypeOfField()==ON_NODES);
1672 CPPUNIT_ASSERT(f4->getTimeDiscretization()==NO_TIME);
1673 CPPUNIT_ASSERT_THROW(f3=(*f1)+(*f4),INTERP_KERNEL::Exception);
1674 MEDCouplingFieldDouble *f5=f4->buildNewTimeReprFromThis(ONE_TIME,false);
1675 CPPUNIT_ASSERT(f4->getArray()==f5->getArray());
1676 CPPUNIT_ASSERT(f5->getTypeOfField()==ON_NODES);
1677 CPPUNIT_ASSERT(f5->getTimeDiscretization()==ONE_TIME);
1679 tmp=f3->getArray()->getConstPointer();
1680 double values4[9]={-1.2,-0.2,0.8,-0.2,0.8,1.8,0.8,1.8,2.8};
1681 std::transform(tmp,tmp+9,values4,values4,std::minus<double>());
1682 std::transform(values4,values4+9,values4,std::ptr_fun<double,double>(fabs));
1683 max=*std::max_element(values4,values4+9);
1684 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,max,1.e-12);
1689 f4=f2->buildNewTimeReprFromThis(NO_TIME,true);
1690 f4->checkCoherency();
1691 CPPUNIT_ASSERT(f4->getArray()!=f2->getArray());
1692 CPPUNIT_ASSERT(f4->getTypeOfField()==ON_NODES);
1693 CPPUNIT_ASSERT(f4->getTimeDiscretization()==NO_TIME);
1694 CPPUNIT_ASSERT_THROW(f3=(*f1)+(*f4),INTERP_KERNEL::Exception);
1695 f5=f4->buildNewTimeReprFromThis(ONE_TIME,true);
1696 CPPUNIT_ASSERT(f4->getArray()!=f5->getArray());
1697 CPPUNIT_ASSERT(f2->getArray()!=f5->getArray());
1698 CPPUNIT_ASSERT(f5->getTypeOfField()==ON_NODES);
1699 CPPUNIT_ASSERT(f5->getTimeDiscretization()==ONE_TIME);
1701 tmp=f3->getArray()->getConstPointer();
1702 double values5[9]={-1.2,-0.2,0.8,-0.2,0.8,1.8,0.8,1.8,2.8};
1703 std::transform(tmp,tmp+9,values5,values5,std::minus<double>());
1704 std::transform(values5,values5+9,values5,std::ptr_fun<double,double>(fabs));
1705 max=*std::max_element(values5,values5+9);
1706 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,max,1.e-12);
1716 void MEDCouplingBasicsTest1::testOperationsOnFields2()
1718 MEDCouplingUMesh *m=build3DSurfTargetMesh_1();
1719 m->setTime(3.4,5,6); m->setTimeUnit("us");
1721 MEDCouplingFieldDouble *f1=m->fillFromAnalytic(ON_NODES,1,"x+y+z");
1722 MEDCouplingFieldDouble *f2=m->fillFromAnalytic(ON_NODES,1,"a*a+b+c*c");
1723 MEDCouplingFieldDouble *f3=(*f1)/(*f2);
1724 f3->checkCoherency();
1725 CPPUNIT_ASSERT(f3->getTypeOfField()==ON_NODES);
1726 CPPUNIT_ASSERT(f3->getTimeDiscretization()==ONE_TIME);
1727 const double expected1[9]={-2.4999999999999991, 1.2162162162162162, 0.77868852459016391,
1728 0.7407407407407407, 1.129032258064516, 0.81632653061224492,
1729 0.86538461538461531, 1.0919540229885056, 0.84302325581395343};
1730 CPPUNIT_ASSERT_EQUAL(1,f3->getNumberOfComponents());
1731 CPPUNIT_ASSERT_EQUAL(9,f3->getNumberOfTuples());
1732 const double *val=f3->getArray()->getConstPointer();
1733 for(int i=0;i<9;i++)
1734 CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],val[i],1.e-12);
1739 f1=m->buildOrthogonalField();
1740 CPPUNIT_ASSERT_DOUBLES_EQUAL(3.4,f1->getTime(a,b),1.e-14);
1741 CPPUNIT_ASSERT_EQUAL(5,a); CPPUNIT_ASSERT_EQUAL(6,b);
1742 CPPUNIT_ASSERT_EQUAL(std::string(f1->getTimeUnit()),std::string("us"));
1743 f2=m->fillFromAnalytic(ON_CELLS,1,"x");
1745 const double expected2[15]={-0.035355339059327376,0.,0.035355339059327376, 0.2592724864350674,0.,-0.2592724864350674, 0.37712361663282529,0.,-0.37712361663282529, -0.035355339059327376,0.,0.035355339059327376, 0.31819805153394637,0.,-0.31819805153394637};
1746 val=f3->getArray()->getConstPointer();
1747 for(int i=0;i<15;i++)
1748 CPPUNIT_ASSERT_DOUBLES_EQUAL(expected2[i],val[i],1.e-12);
1752 val=f3->getArray()->getConstPointer();
1753 for(int i=0;i<15;i++)
1754 CPPUNIT_ASSERT_DOUBLES_EQUAL(expected2[i],val[i],1.e-12);
1763 void MEDCouplingBasicsTest1::testOperationsOnFields3()
1765 MEDCouplingUMesh *m=build3DSurfTargetMesh_1();
1766 MEDCouplingFieldDouble *f1=m->fillFromAnalytic(ON_NODES,1,"x+y+z");
1767 MEDCouplingFieldDouble *f2=m->fillFromAnalytic(ON_NODES,1,"a*a+b+c*c");
1769 f1->checkCoherency();
1770 CPPUNIT_ASSERT(f1->getTypeOfField()==ON_NODES);
1771 CPPUNIT_ASSERT(f1->getTimeDiscretization()==ONE_TIME);
1772 const double expected1[9]={-2.4999999999999991, 1.2162162162162162, 0.77868852459016391,
1773 0.7407407407407407, 1.129032258064516, 0.81632653061224492,
1774 0.86538461538461531, 1.0919540229885056, 0.84302325581395343};
1775 CPPUNIT_ASSERT_EQUAL(1,f1->getNumberOfComponents());
1776 CPPUNIT_ASSERT_EQUAL(9,f1->getNumberOfTuples());
1777 const double *val=f1->getArray()->getConstPointer();
1778 for(int i=0;i<9;i++)
1779 CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],val[i],1.e-12);
1783 f1=m->buildOrthogonalField();
1784 f2=m->fillFromAnalytic(ON_CELLS,1,"x");
1786 const double expected2[15]={-0.035355339059327376,0.,0.035355339059327376, 0.2592724864350674,0.,-0.2592724864350674, 0.37712361663282529,0.,-0.37712361663282529, -0.035355339059327376,0.,0.035355339059327376, 0.31819805153394637,0.,-0.31819805153394637};
1787 val=f1->getArray()->getConstPointer();
1788 for(int i=0;i<15;i++)
1789 CPPUNIT_ASSERT_DOUBLES_EQUAL(expected2[i],val[i],1.e-12);
1792 f1=m->buildOrthogonalField();
1793 CPPUNIT_ASSERT_THROW((*f2)*=(*f1),INTERP_KERNEL::Exception);
1801 * Check of LINEAR_TIME and CONST_ON_TIME_INTERVAL policies
1803 void MEDCouplingBasicsTest1::testOperationsOnFields4()
1805 MEDCouplingUMesh *m=build2DTargetMesh_1();
1806 int nbOfCells=m->getNumberOfCells();
1807 MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_CELLS,CONST_ON_TIME_INTERVAL);
1809 DataArrayDouble *array=DataArrayDouble::New();
1810 array->alloc(nbOfCells,3);
1811 f1->setArray(array);
1812 CPPUNIT_ASSERT_THROW(f1->setEndArray(array),INTERP_KERNEL::Exception);
1813 CPPUNIT_ASSERT_THROW(f1->getEndArray(),INTERP_KERNEL::Exception);
1815 double *tmp=array->getPointer();
1816 const double arr1[15]={0.,10.,20.,1.,11.,21.,2.,12.,22.,3.,13.,23.,4.,14.,24.};
1817 const double arr2[15]={5.,15.,25.,6.,16.,26.,7.,17.,27.,8.,18.,28.,9.,19.,29.};
1818 std::copy(arr1,arr1+15,tmp);
1819 f1->setStartTime(2.,0,0);
1820 f1->setEndTime(3.,0,0);
1821 f1->checkCoherency();
1823 const double pos[2]={0.3,-0.2};
1824 f1->getValueOn(pos,res);
1825 CPPUNIT_ASSERT_DOUBLES_EQUAL(arr1[3],res[0],1.e-12);
1826 CPPUNIT_ASSERT_DOUBLES_EQUAL(arr1[4],res[1],1.e-12);
1827 CPPUNIT_ASSERT_DOUBLES_EQUAL(arr1[5],res[2],1.e-12);
1828 std::fill(res,res+3,0.);
1829 f1->getValueOn(pos,2.2,res);
1830 CPPUNIT_ASSERT_DOUBLES_EQUAL(arr1[3],res[0],1.e-12);
1831 CPPUNIT_ASSERT_DOUBLES_EQUAL(arr1[4],res[1],1.e-12);
1832 CPPUNIT_ASSERT_DOUBLES_EQUAL(arr1[5],res[2],1.e-12);
1833 std::fill(res,res+3,0.);
1834 CPPUNIT_ASSERT_THROW(f1->getValueOn(pos,3.2,res),INTERP_KERNEL::Exception);
1835 MEDCouplingFieldDouble *f2=MEDCouplingFieldDouble::New(ON_CELLS,LINEAR_TIME);
1837 f2->setArray(f1->getArray());
1838 f2->setStartTime(2.,3,0);
1839 f2->setEndTime(4.,13,0);
1840 CPPUNIT_ASSERT_THROW(f2->checkCoherency(),INTERP_KERNEL::Exception);
1841 DataArrayDouble *array2=DataArrayDouble::New();
1842 array2->alloc(nbOfCells,3);
1843 tmp=array2->getPointer();
1844 std::copy(arr2,arr2+15,tmp);
1845 f2->setEndArray(array2);
1847 f2->checkCoherency();
1849 std::fill(res,res+3,0.);
1850 f2->getValueOn(pos,3.21,res);
1851 CPPUNIT_ASSERT_DOUBLES_EQUAL(4.025,res[0],1.e-12);
1852 CPPUNIT_ASSERT_DOUBLES_EQUAL(14.025,res[1],1.e-12);
1853 CPPUNIT_ASSERT_DOUBLES_EQUAL(24.025,res[2],1.e-12);
1854 MEDCouplingFieldDouble *f3=f2->clone(true);
1855 CPPUNIT_ASSERT(f2->isEqual(f3,1e-12,1e-12));
1856 f3->getEndArray()->getPointer()[0]=5.001;
1857 CPPUNIT_ASSERT(!f2->isEqual(f3,1e-12,1e-12));
1858 CPPUNIT_ASSERT(f2->isEqual(f3,1e-12,1e-2));
1859 f3->setStartTime(2.1,3,0);
1860 CPPUNIT_ASSERT(!f2->isEqual(f3,1e-12,1e-2));
1861 f3->setStartTime(2.,3,0);
1862 CPPUNIT_ASSERT(f2->isEqual(f3,1e-12,1e-2));
1863 f3->setStartTime(2.,4,0);
1864 CPPUNIT_ASSERT(!f2->isEqual(f3,1e-12,1e-2));
1865 f3->setStartTime(2.,3,1);
1866 CPPUNIT_ASSERT(!f2->isEqual(f3,1e-12,1e-2));
1867 f3->setStartTime(2.,3,0);
1868 CPPUNIT_ASSERT(f2->isEqual(f3,1e-12,1e-2));
1869 f3->setEndTime(4.1,13,0);
1870 CPPUNIT_ASSERT(!f2->isEqual(f3,1e-12,1e-2));
1871 f3->setEndTime(4.,13,0);
1872 CPPUNIT_ASSERT(f2->isEqual(f3,1e-12,1e-2));
1873 f3->setEndTime(4.,14,0);
1874 CPPUNIT_ASSERT(!f2->isEqual(f3,1e-12,1e-2));
1875 f3->setEndTime(4.,13,1);
1876 CPPUNIT_ASSERT(!f2->isEqual(f3,1e-12,1e-2));
1877 f3->setEndTime(4.,13,0);
1878 CPPUNIT_ASSERT(f2->isEqual(f3,1e-12,1e-2));
1880 MEDCouplingFieldDouble *f4=(*f2)+(*f2);
1881 std::fill(res,res+3,0.);
1882 f4->getValueOn(pos,3.21,res);
1883 CPPUNIT_ASSERT_DOUBLES_EQUAL(8.05,res[0],1.e-12);
1884 CPPUNIT_ASSERT_DOUBLES_EQUAL(28.05,res[1],1.e-12);
1885 CPPUNIT_ASSERT_DOUBLES_EQUAL(48.05,res[2],1.e-12);
1887 std::fill(res,res+3,0.);
1888 f4->getValueOn(pos,3.21,res);
1889 CPPUNIT_ASSERT_DOUBLES_EQUAL(12.075,res[0],1.e-12);
1890 CPPUNIT_ASSERT_DOUBLES_EQUAL(42.075,res[1],1.e-12);
1891 CPPUNIT_ASSERT_DOUBLES_EQUAL(72.075,res[2],1.e-12);
1899 bool func4(const double *pt, double *res)
1901 res[0]=pt[0]+pt[1]+pt[2];
1905 void MEDCouplingBasicsTest1::testMergeNodesOnField()
1908 MEDCouplingUMesh *targetMesh=build3DTargetMeshMergeNode_1();
1909 MEDCouplingFieldDouble *f1=targetMesh->fillFromAnalytic(ON_NODES,1,func4);
1910 f1->mergeNodes(1e-10);
1912 targetMesh->decrRef();
1914 targetMesh=build3DTargetMeshMergeNode_1();
1915 f1=targetMesh->fillFromAnalytic(ON_NODES,1,func4);
1916 tmp=f1->getArray()->getPointer();
1918 f1->mergeNodes(1e-10);
1920 targetMesh->decrRef();
1922 targetMesh=build3DTargetMeshMergeNode_1();
1923 f1=targetMesh->fillFromAnalytic(ON_NODES,1,func4);
1924 tmp=f1->getArray()->getPointer();
1926 CPPUNIT_ASSERT_THROW(f1->mergeNodes(1e-10),INTERP_KERNEL::Exception);
1928 targetMesh->decrRef();
1931 void MEDCouplingBasicsTest1::testCheckConsecutiveCellTypes()
1933 MEDCouplingUMesh *sourceMesh=build2DSourceMesh_1();
1934 MEDCouplingUMesh *targetMesh=build2DTargetMesh_1();
1935 CPPUNIT_ASSERT(sourceMesh->checkConsecutiveCellTypes());
1936 const INTERP_KERNEL::NormalizedCellType order1[]={INTERP_KERNEL::NORM_TRI3, INTERP_KERNEL::NORM_QUAD4};
1937 const INTERP_KERNEL::NormalizedCellType order2[]={INTERP_KERNEL::NORM_QUAD4, INTERP_KERNEL::NORM_TRI3};
1938 CPPUNIT_ASSERT(!targetMesh->checkConsecutiveCellTypes());
1939 CPPUNIT_ASSERT(!targetMesh->checkConsecutiveCellTypesAndOrder(order1,order1+2));
1940 CPPUNIT_ASSERT(!targetMesh->checkConsecutiveCellTypesAndOrder(order2,order2+2));
1941 DataArrayInt *da=targetMesh->getRenumArrForConsecutiveCellTypesSpec(order1,order1+2);
1942 CPPUNIT_ASSERT_EQUAL(5,da->getNumberOfTuples());
1943 CPPUNIT_ASSERT_EQUAL(1,da->getNumberOfComponents());
1944 const int expected1[5]={2,0,1,3,4};
1945 CPPUNIT_ASSERT(std::equal(expected1,expected1+5,da->getConstPointer()));
1947 da=targetMesh->getRenumArrForConsecutiveCellTypesSpec(order2,order2+2);
1948 CPPUNIT_ASSERT_EQUAL(5,da->getNumberOfTuples());
1949 CPPUNIT_ASSERT_EQUAL(1,da->getNumberOfComponents());
1950 const int expected2[5]={0,3,4,1,2};
1951 CPPUNIT_ASSERT(std::equal(expected2,expected2+5,da->getConstPointer()));
1953 const int renumber1[5]={4,0,1,2,3};
1954 targetMesh->renumberCells(renumber1,false);
1955 CPPUNIT_ASSERT(targetMesh->checkConsecutiveCellTypes());
1956 CPPUNIT_ASSERT(targetMesh->checkConsecutiveCellTypesAndOrder(order1,order1+2));
1957 CPPUNIT_ASSERT(!targetMesh->checkConsecutiveCellTypesAndOrder(order2,order2+2));
1958 targetMesh->decrRef();
1959 sourceMesh->decrRef();
1962 void MEDCouplingBasicsTest1::testRearrange2ConsecutiveCellTypes()
1964 MEDCouplingUMesh *m1_1=build2DSourceMesh_1();
1965 MEDCouplingUMesh *m2_1=build2DTargetMesh_1();
1966 DataArrayInt *arr1=m1_1->rearrange2ConsecutiveCellTypes();
1967 MEDCouplingUMesh *m1_2=build2DSourceMesh_1();
1968 CPPUNIT_ASSERT(m1_2->isEqual(m1_1,1e-12));
1969 const int expected1[2]={0,1};
1970 CPPUNIT_ASSERT_EQUAL(2,arr1->getNumberOfTuples());
1971 CPPUNIT_ASSERT_EQUAL(1,arr1->getNumberOfComponents());
1972 CPPUNIT_ASSERT(std::equal(expected1,expected1+2,arr1->getConstPointer()));
1974 const int expected2[5]={0,3,4,1,2};
1975 arr1=m2_1->rearrange2ConsecutiveCellTypes();
1976 CPPUNIT_ASSERT_EQUAL(5,arr1->getNumberOfTuples());
1977 CPPUNIT_ASSERT_EQUAL(1,arr1->getNumberOfComponents());
1978 CPPUNIT_ASSERT(std::equal(expected2,expected2+5,arr1->getConstPointer()));
1979 MEDCouplingUMesh *m2_2=build2DTargetMesh_1();
1980 CPPUNIT_ASSERT_EQUAL(5,arr1->getNumberOfTuples());
1981 CPPUNIT_ASSERT_EQUAL(1,arr1->getNumberOfComponents());
1982 CPPUNIT_ASSERT(std::equal(expected2,expected2+5,arr1->getConstPointer()));
1983 CPPUNIT_ASSERT(!m2_2->isEqual(m2_1,1e-12));
1984 m2_2->renumberCells(expected2,false);
1985 CPPUNIT_ASSERT(m2_2->isEqual(m2_1,1e-12));
1993 void MEDCouplingBasicsTest1::testSplitByType()
1995 MEDCouplingUMesh *m1=build3DSurfTargetMesh_1();
1996 std::vector<MEDCouplingUMesh *> v=m1->splitByType();
1997 CPPUNIT_ASSERT_EQUAL(3,(int)v.size());
1998 std::vector<const MEDCouplingUMesh *> v2(v.begin(),v.end());
1999 MEDCouplingUMesh *m2=MEDCouplingUMesh::MergeUMeshesOnSameCoords(v2);
2000 m2->setName(m1->getName());
2001 CPPUNIT_ASSERT(m1->isEqual(m2,1.e-12));
2002 for(std::vector<MEDCouplingUMesh *>::const_iterator iter=v.begin();iter!=v.end();iter++)
2008 void MEDCouplingBasicsTest1::testFuseUMeshesOnSameCoords()
2010 std::vector<const MEDCouplingUMesh *> meshes;
2011 MEDCouplingUMesh *m2=build2DTargetMesh_1();
2012 int cells1[3]={2,3,4};
2013 MEDCouplingPointSet *m3_1=m2->buildPartOfMySelf(cells1,cells1+3,true);
2014 MEDCouplingUMesh *m3=dynamic_cast<MEDCouplingUMesh *>(m3_1);
2016 meshes.push_back(m3);
2017 int cells2[3]={1,2,4};
2018 MEDCouplingPointSet *m4_1=m2->buildPartOfMySelf(cells2,cells2+3,true);
2019 MEDCouplingUMesh *m4=dynamic_cast<MEDCouplingUMesh *>(m4_1);
2021 meshes.push_back(m4);
2022 int cells3[2]={1,2};
2023 MEDCouplingPointSet *m5_1=m2->buildPartOfMySelf(cells3,cells3+2,true);
2024 MEDCouplingUMesh *m5=dynamic_cast<MEDCouplingUMesh *>(m5_1);
2026 meshes.push_back(m5);
2029 std::vector<DataArrayInt *> corr;
2030 MEDCouplingUMesh *m7=MEDCouplingUMesh::FuseUMeshesOnSameCoords(meshes,0,corr);
2031 CPPUNIT_ASSERT_EQUAL(4,m7->getNumberOfCells());
2032 CPPUNIT_ASSERT_EQUAL(3,(int)corr.size());
2033 const int expectedVals1[3]={3,3,2};
2034 const int expectedVals2[3][3]={{0,1,2},{3,0,2},{3,0,111111}};
2035 for(int i=0;i<3;i++)
2037 DataArrayInt *arr=corr[i];
2038 CPPUNIT_ASSERT_EQUAL(1,arr->getNumberOfComponents());
2039 int nbOfVals=expectedVals1[i];
2040 CPPUNIT_ASSERT_EQUAL(nbOfVals,arr->getNumberOfTuples());
2041 const int *vals=arr->getConstPointer();
2042 for(int j=0;j<nbOfVals;j++)
2043 CPPUNIT_ASSERT_EQUAL(expectedVals2[i][j],vals[j]);
2045 std::vector< std::vector<int> > fidsOfGroups;
2046 std::vector<const DataArrayInt *> corr2(corr.begin(),corr.end());
2047 DataArrayInt *arr2=DataArrayInt::MakePartition(corr2,m7->getNumberOfCells(),fidsOfGroups);
2048 const int fidExp[4]={5,1,3,4};
2049 const int fidsGrp[3][3]={{1,3,5},{3,4,5},{4,5,23344}};
2050 CPPUNIT_ASSERT_EQUAL(3,(int)fidsOfGroups.size());
2051 CPPUNIT_ASSERT_EQUAL(1,arr2->getNumberOfComponents());
2052 CPPUNIT_ASSERT_EQUAL(4,arr2->getNumberOfTuples());
2053 CPPUNIT_ASSERT(std::equal(fidExp,fidExp+4,arr2->getConstPointer()));
2054 for(int i=0;i<3;i++)
2056 int nbOfVals=expectedVals1[i];
2057 CPPUNIT_ASSERT_EQUAL(nbOfVals,(int)fidsOfGroups[i].size());
2058 CPPUNIT_ASSERT(std::equal(fidsOfGroups[i].begin(),fidsOfGroups[i].end(),fidsGrp[i]));
2060 for(std::vector<DataArrayInt *>::iterator iter=corr.begin();iter!=corr.end();iter++)
2070 void MEDCouplingBasicsTest1::testFuseUMeshesOnSameCoords2()
2072 MEDCouplingUMesh *m2;
2073 MEDCouplingUMesh *m1=build3DExtrudedUMesh_1(m2);
2075 const int part1[5]={2,3,6,4,10};
2076 MEDCouplingUMesh *m3=(MEDCouplingUMesh *)m1->buildPartOfMySelf(part1,part1+5,true);
2077 const int part2[4]={5,6,4,7};
2078 MEDCouplingUMesh *m4=(MEDCouplingUMesh *)m1->buildPartOfMySelf(part2,part2+4,true);
2079 std::vector<const MEDCouplingUMesh *> meshes;
2080 meshes.push_back(m1);
2081 meshes.push_back(m3);
2082 meshes.push_back(m3);
2083 meshes.push_back(m4);
2084 std::vector<DataArrayInt *> corr;
2085 MEDCouplingUMesh *m5=MEDCouplingUMesh::FuseUMeshesOnSameCoords(meshes,0,corr);
2086 CPPUNIT_ASSERT_EQUAL(18,m5->getNumberOfCells());
2087 std::vector<DataArrayInt *>::iterator it=corr.begin();
2088 const int exp1[4]={18,5,5,4};
2089 const int exp2[4][18]={
2090 {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17},
2091 {2,3,6,4,10,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1},
2092 {2,3,6,4,10,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1},
2093 {5,6,4,7,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1}
2096 for(;it!=corr.end();it++,i++)
2098 int sz=(*it)->getNumberOfTuples();
2099 CPPUNIT_ASSERT_EQUAL(exp1[i],sz);
2100 CPPUNIT_ASSERT(std::equal(exp2[i],exp2[i]+sz,(*it)->getConstPointer()));
2102 for(it=corr.begin();it!=corr.end();it++)
2110 void MEDCouplingBasicsTest1::testBuildOrthogonalField()
2112 MEDCouplingUMesh *targetMesh=build3DSurfTargetMesh_1();
2113 MEDCouplingFieldDouble *field=targetMesh->buildOrthogonalField();
2114 double expected[3]={0.70710678118654746,0.,-0.70710678118654746};
2115 CPPUNIT_ASSERT_EQUAL(5,field->getNumberOfTuples());
2116 CPPUNIT_ASSERT_EQUAL(3,field->getNumberOfComponents());
2117 const double *vals=field->getArray()->getConstPointer();
2118 for(int i=0;i<15;i++)
2119 CPPUNIT_ASSERT_DOUBLES_EQUAL(expected[i%3],vals[i],1e-12);
2121 targetMesh->decrRef();
2123 double targetCoords[12]={0.,0.,0.,0.5,0.,0.5,1.,0.,1.,0.,1.,0.};
2124 int targetConn[4]={0,1,2,3};
2125 targetMesh=MEDCouplingUMesh::New();
2126 targetMesh->setMeshDimension(2);
2127 targetMesh->allocateCells(1);
2128 targetMesh->insertNextCell(INTERP_KERNEL::NORM_QUAD4,4,targetConn);
2129 targetMesh->finishInsertingCells();
2130 DataArrayDouble *myCoords=DataArrayDouble::New();
2131 myCoords->alloc(4,3);
2132 std::copy(targetCoords,targetCoords+12,myCoords->getPointer());
2133 targetMesh->setCoords(myCoords);
2134 myCoords->decrRef();
2135 field=targetMesh->buildOrthogonalField();
2136 CPPUNIT_ASSERT_EQUAL(1,field->getNumberOfTuples());
2137 CPPUNIT_ASSERT_EQUAL(3,field->getNumberOfComponents());
2138 vals=field->getArray()->getConstPointer();
2139 CPPUNIT_ASSERT_DOUBLES_EQUAL(-0.70710678118654746,vals[0],1e-12);
2140 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,vals[1],1e-12);
2141 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.70710678118654746,vals[2],1e-12);
2143 targetMesh->decrRef();
2146 void MEDCouplingBasicsTest1::testGetCellsContainingPoint()
2148 MEDCouplingUMesh *targetMesh=build2DTargetMesh_1();
2149 double pos[12]={0.,0.,0.4,0.4,0.,0.4,0.1,0.1,0.25,0.,0.65,0.};
2150 std::vector<int> t1,t2;
2152 targetMesh->getCellsContainingPoints(pos,6,1e-12,t1,t2);
2153 CPPUNIT_ASSERT_EQUAL(6,(int)t1.size());
2154 CPPUNIT_ASSERT_EQUAL(7,(int)t2.size());
2155 const int expectedValues1[6]={0,4,3,0,1,2};
2156 const int expectedValues2[7]={0,1,2,3,4,5,6};
2157 CPPUNIT_ASSERT(std::equal(t1.begin(),t1.end(),expectedValues1));
2158 CPPUNIT_ASSERT(std::equal(t2.begin(),t2.end(),expectedValues2));
2159 //2D with no help of bounding box.
2160 double center[2]={0.2,0.2};
2161 MEDCouplingPointSet::Rotate2DAlg(center,0.78539816339744830962,6,pos);
2162 targetMesh->rotate(center,0,0.78539816339744830962);
2163 t1.clear(); t2.clear();
2164 targetMesh->getCellsContainingPoints(pos,6,1e-12,t1,t2);
2165 CPPUNIT_ASSERT_EQUAL(6,(int)t1.size());
2166 CPPUNIT_ASSERT_EQUAL(7,(int)t2.size());
2167 CPPUNIT_ASSERT(std::equal(t1.begin(),t1.end(),expectedValues1));
2168 CPPUNIT_ASSERT(std::equal(t2.begin(),t2.end(),expectedValues2));
2170 const double pos1bis[2]={-0.3303300858899107,-0.11819805153394641};
2171 CPPUNIT_ASSERT_EQUAL(-1,targetMesh->getCellContainingPoint(pos1bis,1e-12));
2172 targetMesh->decrRef();
2174 targetMesh=build2DTargetMesh_1();
2175 const double pos2[2]={0.2,-0.05};
2177 targetMesh->getCellsContainingPoint(pos2,1e-12,t1);
2178 CPPUNIT_ASSERT_EQUAL(2,(int)t1.size());
2179 const int expectedValues3[2]={0,1};
2180 CPPUNIT_ASSERT(std::equal(t1.begin(),t1.end(),expectedValues3));
2181 const double pos3[2]={0.2,0.2};
2183 targetMesh->getCellsContainingPoint(pos3,1e-12,t1);
2184 CPPUNIT_ASSERT_EQUAL(5,(int)t1.size());
2185 const int expectedValues4[5]={0,1,2,3,4};
2186 CPPUNIT_ASSERT(std::equal(t1.begin(),t1.end(),expectedValues4));
2187 CPPUNIT_ASSERT_EQUAL(0,targetMesh->getCellContainingPoint(pos3,1e-12));
2188 targetMesh->decrRef();
2190 targetMesh=build3DTargetMesh_1();
2191 const double pos4[3]={25.,25.,25.};
2192 CPPUNIT_ASSERT_EQUAL(0,targetMesh->getCellContainingPoint(pos4,1e-12));
2193 const double pos5[3]={50.,50.,50.};
2195 targetMesh->getCellsContainingPoint(pos5,1e-12,t1);
2196 CPPUNIT_ASSERT_EQUAL(8,(int)t1.size());
2197 const int expectedValues5[8]={0,1,2,3,4,5,6,7};
2198 CPPUNIT_ASSERT(std::equal(t1.begin(),t1.end(),expectedValues5));
2199 const double pos6[3]={0., 50., 0.};
2201 targetMesh->getCellsContainingPoint(pos6,1e-12,t1);
2202 CPPUNIT_ASSERT_EQUAL(2,(int)t1.size());
2203 const int expectedValues6[2]={0,2};
2204 CPPUNIT_ASSERT(std::equal(t1.begin(),t1.end(),expectedValues6));
2206 const double pos7[3]={-1.0,-1.0,0.};
2207 CPPUNIT_ASSERT_EQUAL(-1,targetMesh->getCellContainingPoint(pos7,1e-12));
2209 const double center2[3]={0.,0.,0.};
2210 const double vec2[3]={0.,-1.,0.};
2211 targetMesh->rotate(center2,vec2,0.78539816339744830962);
2212 const double pos8[3]={-25,25.,12.};
2213 CPPUNIT_ASSERT_EQUAL(-1,targetMesh->getCellContainingPoint(pos8,1e-12));
2215 targetMesh->decrRef();
2218 void MEDCouplingBasicsTest1::testGetValueOn1()
2220 MEDCouplingUMesh *targetMesh=build2DTargetMesh_1();
2221 MEDCouplingFieldDouble *fieldOnCells=MEDCouplingFieldDouble::New(ON_CELLS);
2222 int nbOfCells=targetMesh->getNumberOfCells();
2223 fieldOnCells->setMesh(targetMesh);
2224 DataArrayDouble *array=DataArrayDouble::New();
2225 array->alloc(nbOfCells,2);
2226 fieldOnCells->setArray(array);
2227 double *tmp=array->getPointer();
2228 for(int i=0;i<nbOfCells;i++)
2229 { tmp[2*i]=7.+(double)i; tmp[2*i+1]=17.+(double)i; }
2232 const double pos1[2]={0.25,0.};
2234 fieldOnCells->getValueOn(pos1,res);
2235 CPPUNIT_ASSERT_DOUBLES_EQUAL(8.,res[0],1e-12);
2236 CPPUNIT_ASSERT_DOUBLES_EQUAL(18.,res[1],1e-12);
2238 fieldOnCells->decrRef();
2239 targetMesh->decrRef();
2241 targetMesh=build2DSourceMesh_1();
2242 MEDCouplingFieldDouble *fieldOnNodes=MEDCouplingFieldDouble::New(ON_NODES);
2243 int nbOfNodes=targetMesh->getNumberOfNodes();
2244 fieldOnNodes->setMesh(targetMesh);
2245 array=DataArrayDouble::New();
2246 array->alloc(nbOfNodes,2);
2247 fieldOnNodes->setArray(array);
2248 tmp=array->getPointer();
2249 for(int i=0;i<nbOfNodes;i++)
2250 { tmp[2*i]=17.+(double)i; tmp[2*i+1]=27.+(double)i; }
2253 const double pos2[2]={-0.13333333333333333,-0.13333333333333333};
2254 fieldOnNodes->getValueOn(pos2,res);
2255 CPPUNIT_ASSERT_DOUBLES_EQUAL(17.5,res[0],1e-12);
2256 CPPUNIT_ASSERT_DOUBLES_EQUAL(27.5,res[1],1e-12);
2257 const double pos3[2]={0.033333333333333326,0.36666666666666664};
2258 fieldOnNodes->getValueOn(pos3,res);
2259 CPPUNIT_ASSERT_DOUBLES_EQUAL(18.666666666666667,res[0],1e-12);
2260 CPPUNIT_ASSERT_DOUBLES_EQUAL(28.666666666666667,res[1],1e-12);
2262 fieldOnNodes->decrRef();
2263 targetMesh->decrRef();
2266 void MEDCouplingBasicsTest1::testCMesh0()
2268 MEDCouplingCMesh* mesh=MEDCouplingCMesh::New();
2269 MEDCouplingCMesh* meshEmpty=mesh->clone(true);
2270 CPPUNIT_ASSERT(meshEmpty->isEqual(mesh,1e-12));
2272 DataArrayDouble* coordsX=DataArrayDouble::New();
2273 double arrX[4] = { -1., 1., 2., 4. };
2274 coordsX->useArray(arrX,false, CPP_DEALLOC,4,1);
2275 DataArrayDouble* coordsY=DataArrayDouble::New();
2276 double arrY[4] = { -2., 2., 4., 8. };
2277 coordsY->useArray(arrY,false, CPP_DEALLOC,4,1);
2278 DataArrayDouble* coordsZ=DataArrayDouble::New();
2279 double arrZ[4] = { -3., 3., 6., 12. };
2280 coordsZ->useArray(arrZ,false, CPP_DEALLOC,4,1);
2281 mesh->setCoords(coordsX,coordsY,coordsZ);
2286 MEDCouplingFieldDouble *fieldOnNodes=mesh->fillFromAnalytic(ON_NODES,1,"x+y/2.+z/3.");
2287 CPPUNIT_ASSERT_EQUAL(1,fieldOnNodes->getNumberOfComponents());
2288 CPPUNIT_ASSERT_EQUAL(64,fieldOnNodes->getNumberOfTuples());
2289 const double expected1[64]={-3., -1., 0., 2., -1., 1., 2., 4., 0., 2., 3., 5., 2., 4., 5., 7., -1., 1., 2.,
2290 4., 1., 3., 4., 6., 2., 4., 5., 7., 4., 6., 7., 9., 0., 2., 3., 5., 2., 4., 5.,
2291 7., 3., 5., 6., 8., 5., 7., 8., 10., 2., 4., 5.,
2292 7., 4., 6., 7., 9., 5., 7., 8., 10., 7., 9., 10., 12.};
2293 const double *val=fieldOnNodes->getArray()->getConstPointer();
2294 for(int i=0;i<64;i++)
2295 CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],val[i],1e-12);
2296 double res[1]; //size fieldOnNodes->getNumberOfComponents()
2297 fieldOnNodes->getValueOnPos(1,3,2,&res[0]);
2298 CPPUNIT_ASSERT_DOUBLES_EQUAL(7.,res[0],1e-12);
2299 fieldOnNodes->decrRef();
2301 MEDCouplingFieldDouble *fieldOnCells=mesh->fillFromAnalytic(ON_CELLS,1,"x+y/2.+z/3.");
2302 CPPUNIT_ASSERT_EQUAL(1,fieldOnCells->getNumberOfComponents());
2303 CPPUNIT_ASSERT_EQUAL(27,fieldOnCells->getNumberOfTuples());
2304 val=fieldOnCells->getArray()->getConstPointer();
2305 const double expected2[27]={0, 1.5, 3, 1.5, 3, 4.5, 3, 4.5, 6, 1.5, 3, 4.5, 3, 4.5,
2306 6, 4.5, 6, 7.5, 3, 4.5, 6, 4.5, 6, 7.5, 6, 7.5, 9};
2307 for(int i=0;i<27;i++)
2308 CPPUNIT_ASSERT_DOUBLES_EQUAL(expected2[i],val[i],1e-12);
2309 fieldOnCells->getValueOnPos(1,2,1,&res[0]);
2310 CPPUNIT_ASSERT_DOUBLES_EQUAL(6.,res[0],1e-12);
2311 fieldOnCells->decrRef();
2313 MEDCouplingMesh* meshDeepCopy=mesh->deepCpy();
2314 MEDCouplingCMesh* meshClone=mesh->clone(false);
2316 CPPUNIT_ASSERT_THROW(meshEmpty->copyTinyStringsFrom(0),INTERP_KERNEL::Exception);
2317 meshEmpty->copyTinyStringsFrom(mesh);
2318 //no data in meshEmpty, expected false
2319 CPPUNIT_ASSERT(!meshEmpty->isEqual(mesh,1e-12));
2321 CPPUNIT_ASSERT(meshDeepCopy->isEqual(mesh,1e-12));
2322 meshDeepCopy->copyTinyStringsFrom(mesh);
2323 CPPUNIT_ASSERT(meshDeepCopy->isEqual(mesh,1e-12));
2324 CPPUNIT_ASSERT(meshClone->isEqual(mesh,1e-12));
2326 CPPUNIT_ASSERT_EQUAL(CARTESIAN,mesh->getType());
2327 CPPUNIT_ASSERT_EQUAL(CARTESIAN,meshEmpty->getType());
2328 CPPUNIT_ASSERT_EQUAL(CARTESIAN,meshDeepCopy->getType());
2329 CPPUNIT_ASSERT_EQUAL(CARTESIAN,meshClone->getType());
2332 meshEmpty->decrRef();
2333 meshDeepCopy->decrRef();
2334 meshClone->decrRef();
2337 void MEDCouplingBasicsTest1::testCMesh1()
2339 MEDCouplingCMesh *mesh1,*mesh2,*mesh3;
2340 mesh1=MEDCouplingCMesh::New();
2341 DataArrayDouble* coordsX1=DataArrayDouble::New();
2342 double arrX1[4] = { -1., 1., 2., 4. };
2343 coordsX1->useArray(arrX1,false, CPP_DEALLOC,4,1);
2344 DataArrayDouble* coordsY1=DataArrayDouble::New();
2345 double arrY1[4] = { -2., 2., 4., 8. };
2346 coordsY1->useArray(arrY1,false, CPP_DEALLOC,4,1);
2347 DataArrayDouble* coordsZ1=DataArrayDouble::New();
2348 double arrZ1[4] = { -3., 3., 6., 12. };
2349 coordsZ1->useArray(arrZ1,false, CPP_DEALLOC,4,1);
2350 mesh1->setCoords(coordsX1,coordsY1,coordsZ1);
2352 mesh2=MEDCouplingCMesh::New();
2353 DataArrayDouble* coordsX2=DataArrayDouble::New();
2354 double arrX2[4] = { -1., 1., 2., 4. };
2355 coordsX2->useArray(arrX2,false, CPP_DEALLOC,4,1);
2356 DataArrayDouble* coordsY2=DataArrayDouble::New();
2357 double arrY2[4] = { -2., 2., 4., 8. };
2358 coordsY2->useArray(arrY2,false, CPP_DEALLOC,4,1);
2359 DataArrayDouble* coordsZ2=DataArrayDouble::New();
2360 double arrZ2[4] = { -3., 3., 6., 12.+1e-6 }; //here is not equal
2361 coordsZ2->useArray(arrZ2,false, CPP_DEALLOC,4,1);
2362 mesh2->setCoords(coordsX2,coordsY2,coordsZ2);
2364 mesh3=MEDCouplingCMesh::New();
2365 DataArrayDouble* coordsX3=DataArrayDouble::New();
2366 double arrX3[1] = { -1.};
2367 coordsX3->useArray(arrX3,false, CPP_DEALLOC,1,1);
2368 DataArrayDouble* coordsY3=DataArrayDouble::New();
2369 double arrY3[1] = { -2.};
2370 coordsY3->useArray(arrY3,false, CPP_DEALLOC,1,1);
2371 DataArrayDouble* coordsZ3=DataArrayDouble::New();
2372 double arrZ3[1] = { -3.};
2373 coordsZ3->useArray(arrZ3,false, CPP_DEALLOC,1,1);
2374 mesh3->setCoords(coordsX3,coordsY3,coordsZ3);
2376 CPPUNIT_ASSERT_EQUAL(3,mesh1->getSpaceDimension());
2377 CPPUNIT_ASSERT_EQUAL(3,mesh1->getMeshDimension());
2379 CPPUNIT_ASSERT(!mesh1->isEqual(mesh2,1e-12));
2380 CPPUNIT_ASSERT(!mesh2->isEqual(mesh1,1e-12));
2381 CPPUNIT_ASSERT(!mesh2->isEqualWithoutConsideringStr(mesh1,1e-12));
2382 CPPUNIT_ASSERT(mesh1->isEqual(mesh2,1e-5));
2383 CPPUNIT_ASSERT(!mesh1->isEqual(mesh2,1e-7));
2385 CPPUNIT_ASSERT_THROW(mesh3->checkCoherency1(1e-12),INTERP_KERNEL::Exception);
2386 mesh1->checkCoherency2(1e-12);
2387 CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_HEXA8,mesh1->getTypeOfCell(1));
2389 CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_HEXA8,*((mesh1->getAllGeoTypes()).begin()));
2390 CPPUNIT_ASSERT_EQUAL(27,mesh1->getNumberOfCellsWithType(INTERP_KERNEL::NORM_HEXA8));
2391 CPPUNIT_ASSERT_THROW(mesh1->getNumberOfCellsWithType(INTERP_KERNEL::NORM_QUAD4),INTERP_KERNEL::Exception);
2393 std::vector<double> coo;
2394 mesh1->getCoordinatesOfNode(0, coo);
2395 CPPUNIT_ASSERT_EQUAL(3,(int) coo.size());
2396 CPPUNIT_ASSERT_DOUBLES_EQUAL(-1.,coo[0],1e-14);
2397 CPPUNIT_ASSERT_DOUBLES_EQUAL(-2.,coo[1],1e-14);
2398 CPPUNIT_ASSERT_DOUBLES_EQUAL(-3.,coo[2],1e-14);
2400 mesh1->getCoordinatesOfNode(63, coo);
2401 CPPUNIT_ASSERT_EQUAL(3,(int) coo.size());
2402 CPPUNIT_ASSERT_DOUBLES_EQUAL(4.,coo[0],1e-14);
2403 CPPUNIT_ASSERT_DOUBLES_EQUAL(8.,coo[1],1e-14);
2404 CPPUNIT_ASSERT_DOUBLES_EQUAL(12.,coo[2],1e-14);
2407 repr=mesh1->simpleRepr();
2408 repr=mesh1->advancedRepr();
2409 CPPUNIT_ASSERT(!(repr.find("Cartesian")==std::string::npos));
2410 CPPUNIT_ASSERT(!(repr.find("Number of components : 1")==std::string::npos));
2411 CPPUNIT_ASSERT(!(repr.find("Number of tuples : 4")==std::string::npos));
2412 CPPUNIT_ASSERT(!(repr.find("Z Array :")==std::string::npos));
2413 coordsX1->decrRef();
2414 coordsY1->decrRef();
2415 coordsZ1->decrRef();
2416 coordsX2->decrRef();
2417 coordsY2->decrRef();
2418 coordsZ2->decrRef();
2419 coordsX3->decrRef();
2420 coordsY3->decrRef();
2421 coordsZ3->decrRef();
2427 void MEDCouplingBasicsTest1::testCMesh2()
2429 MEDCouplingCMesh *mesh1;
2430 mesh1=MEDCouplingCMesh::New();
2431 DataArrayDouble* coordsX1=DataArrayDouble::New();
2432 double arrX1[4] = { -1., 1., 2., 4. };
2433 coordsX1->useArray(arrX1,false, CPP_DEALLOC,4,1);
2434 DataArrayDouble* coordsY1=DataArrayDouble::New();
2435 double arrY1[4] = { -2., 2., 4., 8. };
2436 coordsY1->useArray(arrY1,false, CPP_DEALLOC,4,1);
2437 DataArrayDouble* coordsZ1=DataArrayDouble::New();
2438 double arrZ1[4] = { -3., 3., 6., 12. };
2439 coordsZ1->useArray(arrZ1,false, CPP_DEALLOC,4,1);
2440 mesh1->setCoords(coordsX1,coordsY1,coordsZ1);
2442 std::vector<int> dis=mesh1->getDistributionOfTypes();
2443 CPPUNIT_ASSERT_EQUAL(3,(int) dis.size());
2444 CPPUNIT_ASSERT_EQUAL((int) INTERP_KERNEL::NORM_HEXA8,dis[0]);
2445 CPPUNIT_ASSERT_EQUAL(27,dis[1]);
2446 CPPUNIT_ASSERT_EQUAL(0,dis[2]);
2448 std::vector<const DataArrayInt *> idsPerType;
2449 CPPUNIT_ASSERT_THROW(mesh1->checkTypeConsistencyAndContig(dis, idsPerType),INTERP_KERNEL::Exception);
2451 CPPUNIT_ASSERT(!(mesh1->checkTypeConsistencyAndContig(dis, idsPerType)));
2452 dis[0]=(int) INTERP_KERNEL::NORM_QUAD4;
2453 CPPUNIT_ASSERT_THROW(mesh1->checkTypeConsistencyAndContig(dis, idsPerType),INTERP_KERNEL::Exception);
2455 dis[0]=(int) INTERP_KERNEL::NORM_HEXA8;
2457 DataArrayInt *ids=DataArrayInt::New();
2459 ids->fillWithValue(111);
2460 idsPerType.push_back(ids);
2461 DataArrayInt* check=mesh1->checkTypeConsistencyAndContig(dis, idsPerType);
2462 CPPUNIT_ASSERT(check);
2463 CPPUNIT_ASSERT(check->isEqual(*ids));
2465 std::vector<int> code;
2466 std::vector<DataArrayInt *> idsInPflPerType;
2467 std::vector<DataArrayInt *> pfls;
2468 mesh1->splitProfilePerType(ids,code,idsInPflPerType,pfls);
2469 CPPUNIT_ASSERT_EQUAL(3,(int)code.size());
2470 CPPUNIT_ASSERT_EQUAL((int) INTERP_KERNEL::NORM_HEXA8,code[0]);
2471 CPPUNIT_ASSERT_EQUAL(27,code[1]);
2472 CPPUNIT_ASSERT_EQUAL(0,code[2]);
2473 CPPUNIT_ASSERT_EQUAL(1,(int)idsInPflPerType.size());
2474 CPPUNIT_ASSERT_EQUAL(1,(int)pfls.size());
2475 CPPUNIT_ASSERT(idsInPflPerType[0]->isEqual(*ids));
2476 CPPUNIT_ASSERT(pfls[0]->isEqual(*ids));
2477 idsInPflPerType[0]->decrRef();
2482 int cells1[4]={0,1,25,26};
2483 MEDCouplingUMesh *partMesh1=
2484 dynamic_cast<MEDCouplingUMesh *>(mesh1->buildPart(cells1,cells1+4));
2485 CPPUNIT_ASSERT(partMesh1);
2486 CPPUNIT_ASSERT_EQUAL(4,partMesh1->getNumberOfCellsWithType(INTERP_KERNEL::NORM_HEXA8));
2487 CPPUNIT_ASSERT_EQUAL(64,mesh1->getNumberOfNodes());
2488 CPPUNIT_ASSERT_EQUAL(64,partMesh1->getNumberOfNodes());
2490 int cells2[2]={25,26};
2492 MEDCouplingUMesh *partMesh2=
2493 dynamic_cast<MEDCouplingUMesh *>(mesh1->buildPartAndReduceNodes(cells2,cells2+2,arr1));
2494 CPPUNIT_ASSERT(partMesh2);
2495 CPPUNIT_ASSERT_EQUAL(2,partMesh2->getNumberOfCellsWithType(INTERP_KERNEL::NORM_HEXA8));
2496 CPPUNIT_ASSERT_EQUAL(12,partMesh2->getNumberOfNodes());
2498 int cells3[2]={2,3};
2500 MEDCouplingUMesh *partMesh3=
2501 dynamic_cast<MEDCouplingUMesh *>(partMesh1->buildPartAndReduceNodes(cells3,cells3+2,arr2));
2502 CPPUNIT_ASSERT(partMesh3);
2503 CPPUNIT_ASSERT_EQUAL(2,partMesh3->getNumberOfCellsWithType(INTERP_KERNEL::NORM_HEXA8));
2504 CPPUNIT_ASSERT_EQUAL(12,partMesh3->getNumberOfNodes());
2506 CPPUNIT_ASSERT_THROW(mesh1->simplexize(0),INTERP_KERNEL::Exception);
2507 CPPUNIT_ASSERT_THROW(mesh1->getMeasureFieldOnNode(true),INTERP_KERNEL::Exception);
2511 mesh1->getBoundingBox(bbox1);
2512 partMesh1->getBoundingBox(bbox2);
2513 for(int i=0;i<6;i++)
2514 CPPUNIT_ASSERT_DOUBLES_EQUAL(bbox1[i],bbox2[i],1e-12);
2515 partMesh3->getBoundingBox(bbox1);
2516 partMesh2->getBoundingBox(bbox2);
2517 for(int i=0;i<6;i++)
2518 CPPUNIT_ASSERT_DOUBLES_EQUAL(bbox1[i],bbox2[i],1e-12);
2520 CPPUNIT_ASSERT_THROW(mesh1->buildOrthogonalField(),INTERP_KERNEL::Exception);
2521 MEDCouplingCMesh *mesh2d=MEDCouplingCMesh::New();
2522 mesh2d->setCoords(coordsX1,coordsY1);
2523 MEDCouplingFieldDouble *f1=mesh2d->buildOrthogonalField();
2525 std::vector<double> tinyInfoD;
2526 std::vector<int> tinyInfo;
2527 std::vector<std::string> littleStrings;
2528 mesh2d->getTinySerializationInformation(tinyInfoD, tinyInfo, littleStrings);
2529 CPPUNIT_ASSERT_EQUAL(5,(int)tinyInfo.size());
2530 CPPUNIT_ASSERT_EQUAL(4,(int)tinyInfo[0]); //x
2531 CPPUNIT_ASSERT_EQUAL(4,(int)tinyInfo[1]); //y
2532 CPPUNIT_ASSERT_EQUAL(-1,(int)tinyInfo[2]); //z
2533 CPPUNIT_ASSERT_EQUAL(-1,(int)tinyInfo[3]); //it
2534 CPPUNIT_ASSERT_EQUAL(-1,(int)tinyInfo[4]); //order
2535 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,tinyInfoD[0],1e-14); //time
2536 DataArrayInt* d1=DataArrayInt::New();
2537 DataArrayDouble* d2=DataArrayDouble::New();
2538 mesh2d->resizeForUnserialization(tinyInfo, d1, d2, littleStrings);
2539 CPPUNIT_ASSERT_EQUAL(0,d1->getNumberOfTuples());
2540 CPPUNIT_ASSERT_EQUAL(8,d2->getNumberOfTuples());
2542 partMesh1->decrRef();
2543 partMesh2->decrRef();
2544 partMesh3->decrRef();
2551 coordsX1->decrRef();
2552 coordsY1->decrRef();
2553 coordsZ1->decrRef();
2557 void MEDCouplingBasicsTest1::testScale()
2559 MEDCouplingUMesh *mesh=build2DTargetMesh_1();
2560 const double pos[2]={0.2,0.2};
2561 mesh->scale(pos,0.5);
2562 const double expected1[18]={-0.05,-0.05, 0.2,-0.05, 0.45,-0.05, -0.05,0.2, 0.2,0.2, 0.45,0.2,
2563 -0.05,0.45, 0.2,0.45, 0.45,0.45};
2564 const double *val=mesh->getCoords()->getConstPointer();
2565 for(int i=0;i<18;i++)
2566 CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],val[i],1e-12);
2571 void MEDCouplingBasicsTest1::testTryToShareSameCoords()
2573 MEDCouplingUMesh *m1=build2DTargetMesh_1();
2574 MEDCouplingUMesh *m2=build2DTargetMesh_1();
2575 CPPUNIT_ASSERT(m1->getCoords()!=m2->getCoords());
2576 m1->tryToShareSameCoords(*m2,1e-12);
2577 CPPUNIT_ASSERT(m1->getCoords()==m2->getCoords());
2578 m1->tryToShareSameCoords(*m2,1e-12);
2579 CPPUNIT_ASSERT(m1->getCoords()==m2->getCoords());
2580 m2->tryToShareSameCoords(*m1,1e-12);
2581 CPPUNIT_ASSERT(m1->getCoords()==m2->getCoords());
2585 m1=build2DTargetMesh_1();
2586 m2=build2DTargetMesh_2();
2587 CPPUNIT_ASSERT(m1->getCoords()!=m2->getCoords());
2588 m1->tryToShareSameCoords(*m2,1e-12);
2589 CPPUNIT_ASSERT(m1->getCoords()==m2->getCoords());
2590 m1->tryToShareSameCoords(*m2,1e-12);
2591 CPPUNIT_ASSERT(m1->getCoords()==m2->getCoords());
2592 m2->tryToShareSameCoords(*m1,1e-12);
2593 CPPUNIT_ASSERT(m1->getCoords()==m2->getCoords());
2597 m1=build2DTargetMesh_1();
2598 m2=build2DSourceMesh_1();
2599 CPPUNIT_ASSERT(m1->getCoords()!=m2->getCoords());
2600 CPPUNIT_ASSERT_THROW(m1->tryToShareSameCoords(*m2,1e-12),INTERP_KERNEL::Exception);
2605 void MEDCouplingBasicsTest1::testFindNodeOnPlane()
2607 MEDCouplingUMesh *mesh=build3DTargetMesh_1();
2609 double pt[3]={300.,300.,0.};
2610 double v[3]={0.,0.,2.};
2611 mesh->findNodesOnPlane(pt,v,1e-12,n);
2612 CPPUNIT_ASSERT_EQUAL(9,(int)n.size());
2613 MEDCouplingUMesh *m3dSurf=(MEDCouplingUMesh *)mesh->buildFacePartOfMySelfNode(&n[0],&n[0]+n.size(),true);
2614 MEDCouplingExtrudedMesh *me=MEDCouplingExtrudedMesh::New(mesh,m3dSurf,0);
2615 const DataArrayInt *da=me->getMesh3DIds();
2616 CPPUNIT_ASSERT_EQUAL(8,me->getNumberOfCells());
2617 const int expected[8]={0,1,2,3,4,5,6,7};
2618 const int *val=da->getConstPointer();
2619 for(int i=0;i<8;i++)
2620 CPPUNIT_ASSERT_EQUAL(expected[i],val[i]);
2626 void MEDCouplingBasicsTest1::testRenumberCells()
2628 MEDCouplingUMesh *m=build3DSurfTargetMesh_1();
2629 MEDCouplingUMesh *m2=build3DSurfTargetMesh_1();
2630 CPPUNIT_ASSERT(m->isEqual(m2,0));
2631 const int arr[5]={12,3,25,2,26};
2632 m->renumberCells(arr,true);
2633 CPPUNIT_ASSERT(!m->isEqual(m2,0));
2634 CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_QUAD4,m->getTypeOfCell(0));
2635 CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_TRI3,m->getTypeOfCell(1));
2636 CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_QUAD4,m->getTypeOfCell(2));
2637 CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_TRI3,m->getTypeOfCell(3));
2638 CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_QUAD4,m->getTypeOfCell(4));
2639 const int arr2[5]={5,-1,-5,4,8};
2640 m->renumberCells(arr2,true);
2641 CPPUNIT_ASSERT(m->isEqual(m2,0));
2646 void MEDCouplingBasicsTest1::testChangeSpaceDimension()
2648 MEDCouplingUMesh *m1=build3DSurfTargetMesh_1();
2649 MEDCouplingUMesh *m2=build2DTargetMesh_1();
2651 CPPUNIT_ASSERT_EQUAL(3,m1->getSpaceDimension());
2652 m1->changeSpaceDimension(2);
2653 CPPUNIT_ASSERT_EQUAL(2,m1->getSpaceDimension());
2654 m1->setName(m2->getName());
2655 CPPUNIT_ASSERT(m1->isEqual(m2,1e-12));
2656 m1->changeSpaceDimension(3);
2657 CPPUNIT_ASSERT_EQUAL(3,m1->getSpaceDimension());
2658 const double expected[27]={-0.3,-0.3,0., 0.2,-0.3,0., 0.7,-0.3,0., -0.3,0.2,0., 0.2,0.2,0., 0.7,0.2,0., -0.3,0.7,0., 0.2,0.7,0., 0.7,0.7,0.};
2659 const double *val=m1->getCoords()->getConstPointer();
2660 for(int i=0;i<27;i++)
2661 CPPUNIT_ASSERT_DOUBLES_EQUAL(expected[i],val[i],1e-14);