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 int 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=="PartOf_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=="PartOf_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=="PartOf_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()==NO_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 MEDCouplingFieldDouble *f1=m->fillFromAnalytic(ON_CELLS,1,func1);
1414 f1->checkCoherency();
1415 CPPUNIT_ASSERT(f1->getTypeOfField()==ON_CELLS);
1416 CPPUNIT_ASSERT(f1->getTimeDiscretization()==NO_TIME);
1417 CPPUNIT_ASSERT_EQUAL(1,f1->getNumberOfComponents());
1418 CPPUNIT_ASSERT_EQUAL(5,f1->getNumberOfTuples());
1419 double values1[5]={-0.1,0.23333333333333336,0.56666666666666665,0.4,0.9};
1420 const double *tmp=f1->getArray()->getConstPointer();
1421 std::transform(tmp,tmp+5,values1,values1,std::minus<double>());
1422 std::transform(values1,values1+5,values1,std::ptr_fun<double,double>(fabs));
1423 double max=*std::max_element(values1,values1+5);
1424 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,max,1.e-12);
1427 f1=m->fillFromAnalytic(ON_NODES,1,func1);
1428 f1->checkCoherency();
1429 CPPUNIT_ASSERT(f1->getTypeOfField()==ON_NODES);
1430 CPPUNIT_ASSERT(f1->getTimeDiscretization()==NO_TIME);
1431 CPPUNIT_ASSERT_EQUAL(1,f1->getNumberOfComponents());
1432 CPPUNIT_ASSERT_EQUAL(9,f1->getNumberOfTuples());
1433 double values2[9]={-0.6,-0.1,0.4,-0.1,0.4,0.9,0.4,0.9,1.4};
1434 tmp=f1->getArray()->getConstPointer();
1435 std::transform(tmp,tmp+9,values2,values2,std::minus<double>());
1436 std::transform(values2,values2+9,values2,std::ptr_fun<double,double>(fabs));
1437 max=*std::max_element(values2,values2+9);
1438 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,max,1.e-12);
1441 f1=m->fillFromAnalytic(ON_NODES,2,func2);
1442 f1->checkCoherency();
1443 CPPUNIT_ASSERT(f1->getTypeOfField()==ON_NODES);
1444 CPPUNIT_ASSERT(f1->getTimeDiscretization()==NO_TIME);
1445 CPPUNIT_ASSERT_EQUAL(2,f1->getNumberOfComponents());
1446 CPPUNIT_ASSERT_EQUAL(9,f1->getNumberOfTuples());
1447 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};
1448 tmp=f1->getArray()->getConstPointer();
1449 std::transform(tmp,tmp+18,values3,values3,std::minus<double>());
1450 std::transform(values3,values3+18,values3,std::ptr_fun<double,double>(fabs));
1451 max=*std::max_element(values3,values3+18);
1452 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,max,1.e-12);
1454 f1->accumulate(values4);
1455 CPPUNIT_ASSERT_DOUBLES_EQUAL(3.6,values4[0],1.e-12);
1456 CPPUNIT_ASSERT_DOUBLES_EQUAL(7.2,values4[1],1.e-12);
1457 f1->integral(true,values4);
1458 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.5,values4[0],1.e-12);
1459 CPPUNIT_ASSERT_DOUBLES_EQUAL(1.,values4[1],1.e-12);
1462 CPPUNIT_ASSERT_THROW(f1=m->fillFromAnalytic(ON_NODES,1,func3),INTERP_KERNEL::Exception);
1467 void MEDCouplingBasicsTest1::testFillFromAnalytic2()
1469 MEDCouplingUMesh *m=build2DTargetMesh_1();
1470 MEDCouplingFieldDouble *f1=m->fillFromAnalytic(ON_CELLS,1,"y+x");
1471 f1->checkCoherency();
1472 CPPUNIT_ASSERT(f1->getTypeOfField()==ON_CELLS);
1473 CPPUNIT_ASSERT(f1->getTimeDiscretization()==NO_TIME);
1474 CPPUNIT_ASSERT_EQUAL(1,f1->getNumberOfComponents());
1475 CPPUNIT_ASSERT_EQUAL(5,f1->getNumberOfTuples());
1476 double values1[5]={-0.1,0.23333333333333336,0.56666666666666665,0.4,0.9};
1477 const double *tmp=f1->getArray()->getConstPointer();
1478 std::transform(tmp,tmp+5,values1,values1,std::minus<double>());
1479 std::transform(values1,values1+5,values1,std::ptr_fun<double,double>(fabs));
1480 double max=*std::max_element(values1,values1+5);
1481 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,max,1.e-12);
1484 f1=m->fillFromAnalytic(ON_NODES,1,"y+2*x");
1485 f1->checkCoherency();
1486 CPPUNIT_ASSERT(f1->getTypeOfField()==ON_NODES);
1487 CPPUNIT_ASSERT(f1->getTimeDiscretization()==NO_TIME);
1488 CPPUNIT_ASSERT_EQUAL(1,f1->getNumberOfComponents());
1489 CPPUNIT_ASSERT_EQUAL(9,f1->getNumberOfTuples());
1490 double values2[9]={-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1};
1491 tmp=f1->getArray()->getConstPointer();
1492 std::transform(tmp,tmp+9,values2,values2,std::minus<double>());
1493 std::transform(values2,values2+9,values2,std::ptr_fun<double,double>(fabs));
1494 max=*std::max_element(values2,values2+9);
1495 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,max,1.e-12);
1497 f1=m->fillFromAnalytic(ON_NODES,1,"2.*x+y");
1498 f1->checkCoherency();
1499 CPPUNIT_ASSERT(f1->getTypeOfField()==ON_NODES);
1500 CPPUNIT_ASSERT(f1->getTimeDiscretization()==NO_TIME);
1501 CPPUNIT_ASSERT_EQUAL(1,f1->getNumberOfComponents());
1502 CPPUNIT_ASSERT_EQUAL(9,f1->getNumberOfTuples());
1503 tmp=f1->getArray()->getConstPointer();
1504 double values2Bis[9]={-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1};
1505 std::transform(tmp,tmp+9,values2Bis,values2Bis,std::minus<double>());
1506 std::transform(values2,values2+9,values2Bis,std::ptr_fun<double,double>(fabs));
1507 max=*std::max_element(values2Bis,values2Bis+9);
1508 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,max,1.e-12);
1511 f1=m->fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+2*(x+y)*JVec");
1512 f1->checkCoherency();
1513 CPPUNIT_ASSERT(f1->getTypeOfField()==ON_NODES);
1514 CPPUNIT_ASSERT(f1->getTimeDiscretization()==NO_TIME);
1515 CPPUNIT_ASSERT_EQUAL(2,f1->getNumberOfComponents());
1516 CPPUNIT_ASSERT_EQUAL(9,f1->getNumberOfTuples());
1517 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};
1518 tmp=f1->getArray()->getConstPointer();
1519 std::transform(tmp,tmp+18,values3,values3,std::minus<double>());
1520 std::transform(values3,values3+18,values3,std::ptr_fun<double,double>(fabs));
1521 max=*std::max_element(values3,values3+18);
1522 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,max,1.e-12);
1524 f1->accumulate(values4);
1525 CPPUNIT_ASSERT_DOUBLES_EQUAL(3.6,values4[0],1.e-12);
1526 CPPUNIT_ASSERT_DOUBLES_EQUAL(7.2,values4[1],1.e-12);
1527 f1->integral(true,values4);
1528 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.5,values4[0],1.e-12);
1529 CPPUNIT_ASSERT_DOUBLES_EQUAL(1.,values4[1],1.e-12);
1532 CPPUNIT_ASSERT_THROW(f1=m->fillFromAnalytic(ON_NODES,1,"1./(x-0.2)"),INTERP_KERNEL::Exception);
1537 void MEDCouplingBasicsTest1::testApplyFunc()
1539 MEDCouplingUMesh *m=build2DTargetMesh_1();
1540 MEDCouplingFieldDouble *f1=m->fillFromAnalytic(ON_NODES,2,func2);
1541 f1->checkCoherency();
1542 CPPUNIT_ASSERT(f1->getTypeOfField()==ON_NODES);
1543 CPPUNIT_ASSERT(f1->getTimeDiscretization()==NO_TIME);
1544 CPPUNIT_ASSERT_EQUAL(2,f1->getNumberOfComponents());
1545 CPPUNIT_ASSERT_EQUAL(9,f1->getNumberOfTuples());
1546 f1->applyFunc(1,func1);
1547 CPPUNIT_ASSERT(f1->getTypeOfField()==ON_NODES);
1548 CPPUNIT_ASSERT(f1->getTimeDiscretization()==NO_TIME);
1549 CPPUNIT_ASSERT_EQUAL(1,f1->getNumberOfComponents());
1550 CPPUNIT_ASSERT_EQUAL(9,f1->getNumberOfTuples());
1551 double values1[9]={-1.8,-0.3,1.2,-0.3,1.2,2.7,1.2,2.7,4.2};
1552 const double *tmp=f1->getArray()->getConstPointer();
1553 std::transform(tmp,tmp+9,values1,values1,std::minus<double>());
1554 std::transform(values1,values1+9,values1,std::ptr_fun<double,double>(fabs));
1555 double max=*std::max_element(values1,values1+9);
1556 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,max,1.e-12);
1561 void MEDCouplingBasicsTest1::testApplyFunc2()
1563 MEDCouplingUMesh *m=build2DTargetMesh_1();
1564 MEDCouplingFieldDouble *f1=m->fillFromAnalytic(ON_NODES,2,func2);
1565 f1->checkCoherency();
1566 CPPUNIT_ASSERT(f1->getTypeOfField()==ON_NODES);
1567 CPPUNIT_ASSERT(f1->getTimeDiscretization()==NO_TIME);
1568 CPPUNIT_ASSERT_EQUAL(2,f1->getNumberOfComponents());
1569 CPPUNIT_ASSERT_EQUAL(9,f1->getNumberOfTuples());
1571 MEDCouplingFieldDouble *f2=f1->clone(true);
1572 CPPUNIT_ASSERT_THROW(f2->applyFunc(1,"a+b+c+d"),INTERP_KERNEL::Exception);
1573 CPPUNIT_ASSERT_THROW(f2->applyFunc(1,"a/0"),INTERP_KERNEL::Exception);
1574 CPPUNIT_ASSERT_THROW(f2->applyFunc("a/0"),INTERP_KERNEL::Exception);
1575 f2->applyFunc("abs(u)^2.4+2*u");
1576 CPPUNIT_ASSERT(f1->getTypeOfField()==ON_NODES);
1577 CPPUNIT_ASSERT(f1->getTimeDiscretization()==NO_TIME);
1578 CPPUNIT_ASSERT_EQUAL(2,f1->getNumberOfComponents());
1579 CPPUNIT_ASSERT_EQUAL(9,f1->getNumberOfTuples());
1580 double values2[18]={-0.9065304805418678, -0.85105859001709905, -0.19601892829446504, -0.37898777756476987,
1581 0.91090317490482353, 2.1853504664669781, -0.19601892829446504, -0.37898777756476987,
1582 0.91090317490482353, 2.1853504664669781, 2.5765725275664879, 7.6987743736515295,
1583 0.91090317490482353, 2.1853504664669781, 2.5765725275664879, 7.6987743736515295,
1584 5.0423700574830965, 17.435300118916864};
1585 const double *tmp=f2->getArray()->getConstPointer();
1586 std::transform(tmp,tmp+18,values2,values2,std::minus<double>());
1587 std::transform(values2,values2+18,values2,std::ptr_fun<double,double>(fabs));
1588 double max=*std::max_element(values2,values2+18);
1589 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,max,1.e-12);
1592 f1->applyFunc(1,"x+y");
1593 CPPUNIT_ASSERT(f1->getTypeOfField()==ON_NODES);
1594 CPPUNIT_ASSERT(f1->getTimeDiscretization()==NO_TIME);
1595 CPPUNIT_ASSERT_EQUAL(1,f1->getNumberOfComponents());
1596 CPPUNIT_ASSERT_EQUAL(9,f1->getNumberOfTuples());
1597 double values1[9]={-1.8,-0.3,1.2,-0.3,1.2,2.7,1.2,2.7,4.2};
1598 tmp=f1->getArray()->getConstPointer();
1599 std::transform(tmp,tmp+9,values1,values1,std::minus<double>());
1600 std::transform(values1,values1+9,values1,std::ptr_fun<double,double>(fabs));
1601 max=*std::max_element(values1,values1+9);
1602 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,max,1.e-12);
1607 void MEDCouplingBasicsTest1::testOperationsOnFields()
1609 MEDCouplingUMesh *m=build2DTargetMesh_1();
1610 MEDCouplingFieldDouble *f1=m->fillFromAnalytic(ON_NODES,1,func1);
1611 MEDCouplingFieldDouble *f2=m->fillFromAnalytic(ON_NODES,1,func1);
1612 f1->checkCoherency();
1613 f2->checkCoherency();
1614 MEDCouplingFieldDouble *f3=(*f1)+(*f2);
1615 f3->checkCoherency();
1616 CPPUNIT_ASSERT(f3->getTypeOfField()==ON_NODES);
1617 CPPUNIT_ASSERT(f3->getTimeDiscretization()==NO_TIME);
1618 double values1[9]={-1.2,-0.2,0.8,-0.2,0.8,1.8,0.8,1.8,2.8};
1619 const double *tmp=f3->getArray()->getConstPointer();
1620 std::transform(tmp,tmp+9,values1,values1,std::minus<double>());
1621 std::transform(values1,values1+9,values1,std::ptr_fun<double,double>(fabs));
1622 double max=*std::max_element(values1,values1+9);
1623 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,max,1.e-12);
1627 f3->checkCoherency();
1628 CPPUNIT_ASSERT(f3->getTypeOfField()==ON_NODES);
1629 CPPUNIT_ASSERT(f3->getTimeDiscretization()==NO_TIME);
1630 double values2[9]={0.36,0.01,0.16,0.01,0.16,0.81,0.16,0.81,1.96};
1631 tmp=f3->getArray()->getConstPointer();
1632 std::transform(tmp,tmp+9,values2,values2,std::minus<double>());
1633 std::transform(values2,values2+9,values2,std::ptr_fun<double,double>(fabs));
1634 max=*std::max_element(values2,values2+9);
1635 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,max,1.e-12);
1639 MEDCouplingFieldDouble *f4=(*f1)-(*f3);
1640 f4->checkCoherency();
1641 CPPUNIT_ASSERT(f4->getTypeOfField()==ON_NODES);
1642 CPPUNIT_ASSERT(f4->getTimeDiscretization()==NO_TIME);
1643 double values3[9]={0.6,0.1,-0.4,0.1,-0.4,-0.9,-0.4,-0.9,-1.4};
1644 tmp=f4->getArray()->getConstPointer();
1645 std::transform(tmp,tmp+9,values3,values3,std::minus<double>());
1646 std::transform(values3,values3+9,values3,std::ptr_fun<double,double>(fabs));
1647 max=*std::max_element(values3,values3+9);
1648 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,max,1.e-12);
1654 f4->checkCoherency();
1655 CPPUNIT_ASSERT(f4->getTypeOfField()==ON_NODES);
1656 CPPUNIT_ASSERT(f4->getTimeDiscretization()==NO_TIME);
1657 tmp=f4->getArray()->getConstPointer();
1658 for(int i=0;i<9;i++)
1659 CPPUNIT_ASSERT_DOUBLES_EQUAL(2.,tmp[i],1.e-12);
1663 f4=f2->buildNewTimeReprFromThis(ONE_TIME,false);
1664 f4->checkCoherency();
1665 CPPUNIT_ASSERT(f4->getArray()==f2->getArray());
1666 CPPUNIT_ASSERT(f4->getTypeOfField()==ON_NODES);
1667 CPPUNIT_ASSERT(f4->getTimeDiscretization()==ONE_TIME);
1668 CPPUNIT_ASSERT_THROW(f3=(*f1)+(*f4),INTERP_KERNEL::Exception);
1669 MEDCouplingFieldDouble *f5=f4->buildNewTimeReprFromThis(NO_TIME,false);
1670 CPPUNIT_ASSERT(f4->getArray()==f5->getArray());
1671 CPPUNIT_ASSERT(f5->getTypeOfField()==ON_NODES);
1672 CPPUNIT_ASSERT(f5->getTimeDiscretization()==NO_TIME);
1674 tmp=f3->getArray()->getConstPointer();
1675 double values4[9]={-1.2,-0.2,0.8,-0.2,0.8,1.8,0.8,1.8,2.8};
1676 std::transform(tmp,tmp+9,values4,values4,std::minus<double>());
1677 std::transform(values4,values4+9,values4,std::ptr_fun<double,double>(fabs));
1678 max=*std::max_element(values4,values4+9);
1679 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,max,1.e-12);
1684 f4=f2->buildNewTimeReprFromThis(ONE_TIME,true);
1685 f4->checkCoherency();
1686 CPPUNIT_ASSERT(f4->getArray()!=f2->getArray());
1687 CPPUNIT_ASSERT(f4->getTypeOfField()==ON_NODES);
1688 CPPUNIT_ASSERT(f4->getTimeDiscretization()==ONE_TIME);
1689 CPPUNIT_ASSERT_THROW(f3=(*f1)+(*f4),INTERP_KERNEL::Exception);
1690 f5=f4->buildNewTimeReprFromThis(NO_TIME,true);
1691 CPPUNIT_ASSERT(f4->getArray()!=f5->getArray());
1692 CPPUNIT_ASSERT(f2->getArray()!=f5->getArray());
1693 CPPUNIT_ASSERT(f5->getTypeOfField()==ON_NODES);
1694 CPPUNIT_ASSERT(f5->getTimeDiscretization()==NO_TIME);
1696 tmp=f3->getArray()->getConstPointer();
1697 double values5[9]={-1.2,-0.2,0.8,-0.2,0.8,1.8,0.8,1.8,2.8};
1698 std::transform(tmp,tmp+9,values5,values5,std::minus<double>());
1699 std::transform(values5,values5+9,values5,std::ptr_fun<double,double>(fabs));
1700 max=*std::max_element(values5,values5+9);
1701 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,max,1.e-12);
1711 void MEDCouplingBasicsTest1::testOperationsOnFields2()
1713 MEDCouplingUMesh *m=build3DSurfTargetMesh_1();
1714 MEDCouplingFieldDouble *f1=m->fillFromAnalytic(ON_NODES,1,"x+y+z");
1715 MEDCouplingFieldDouble *f2=m->fillFromAnalytic(ON_NODES,1,"a*a+b+c*c");
1716 MEDCouplingFieldDouble *f3=(*f1)/(*f2);
1717 f3->checkCoherency();
1718 CPPUNIT_ASSERT(f3->getTypeOfField()==ON_NODES);
1719 CPPUNIT_ASSERT(f3->getTimeDiscretization()==NO_TIME);
1720 const double expected1[9]={-2.4999999999999991, 1.2162162162162162, 0.77868852459016391,
1721 0.7407407407407407, 1.129032258064516, 0.81632653061224492,
1722 0.86538461538461531, 1.0919540229885056, 0.84302325581395343};
1723 CPPUNIT_ASSERT_EQUAL(1,f3->getNumberOfComponents());
1724 CPPUNIT_ASSERT_EQUAL(9,f3->getNumberOfTuples());
1725 const double *val=f3->getArray()->getConstPointer();
1726 for(int i=0;i<9;i++)
1727 CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],val[i],1.e-12);
1732 f1=m->buildOrthogonalField();
1733 f2=m->fillFromAnalytic(ON_CELLS,1,"x");
1735 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};
1736 val=f3->getArray()->getConstPointer();
1737 for(int i=0;i<15;i++)
1738 CPPUNIT_ASSERT_DOUBLES_EQUAL(expected2[i],val[i],1.e-12);
1742 val=f3->getArray()->getConstPointer();
1743 for(int i=0;i<15;i++)
1744 CPPUNIT_ASSERT_DOUBLES_EQUAL(expected2[i],val[i],1.e-12);
1753 void MEDCouplingBasicsTest1::testOperationsOnFields3()
1755 MEDCouplingUMesh *m=build3DSurfTargetMesh_1();
1756 MEDCouplingFieldDouble *f1=m->fillFromAnalytic(ON_NODES,1,"x+y+z");
1757 MEDCouplingFieldDouble *f2=m->fillFromAnalytic(ON_NODES,1,"a*a+b+c*c");
1759 f1->checkCoherency();
1760 CPPUNIT_ASSERT(f1->getTypeOfField()==ON_NODES);
1761 CPPUNIT_ASSERT(f1->getTimeDiscretization()==NO_TIME);
1762 const double expected1[9]={-2.4999999999999991, 1.2162162162162162, 0.77868852459016391,
1763 0.7407407407407407, 1.129032258064516, 0.81632653061224492,
1764 0.86538461538461531, 1.0919540229885056, 0.84302325581395343};
1765 CPPUNIT_ASSERT_EQUAL(1,f1->getNumberOfComponents());
1766 CPPUNIT_ASSERT_EQUAL(9,f1->getNumberOfTuples());
1767 const double *val=f1->getArray()->getConstPointer();
1768 for(int i=0;i<9;i++)
1769 CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],val[i],1.e-12);
1773 f1=m->buildOrthogonalField();
1774 f2=m->fillFromAnalytic(ON_CELLS,1,"x");
1776 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};
1777 val=f1->getArray()->getConstPointer();
1778 for(int i=0;i<15;i++)
1779 CPPUNIT_ASSERT_DOUBLES_EQUAL(expected2[i],val[i],1.e-12);
1782 f1=m->buildOrthogonalField();
1783 CPPUNIT_ASSERT_THROW((*f2)*=(*f1),INTERP_KERNEL::Exception);
1791 * Check of LINEAR_TIME and CONST_ON_TIME_INTERVAL policies
1793 void MEDCouplingBasicsTest1::testOperationsOnFields4()
1795 MEDCouplingUMesh *m=build2DTargetMesh_1();
1796 int nbOfCells=m->getNumberOfCells();
1797 MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_CELLS,CONST_ON_TIME_INTERVAL);
1799 DataArrayDouble *array=DataArrayDouble::New();
1800 array->alloc(nbOfCells,3);
1801 f1->setArray(array);
1802 CPPUNIT_ASSERT_THROW(f1->setEndArray(array),INTERP_KERNEL::Exception);
1803 CPPUNIT_ASSERT_THROW(f1->getEndArray(),INTERP_KERNEL::Exception);
1805 double *tmp=array->getPointer();
1806 const double arr1[15]={0.,10.,20.,1.,11.,21.,2.,12.,22.,3.,13.,23.,4.,14.,24.};
1807 const double arr2[15]={5.,15.,25.,6.,16.,26.,7.,17.,27.,8.,18.,28.,9.,19.,29.};
1808 std::copy(arr1,arr1+15,tmp);
1809 f1->setStartTime(2.,0,0);
1810 f1->setEndTime(3.,0,0);
1811 f1->checkCoherency();
1813 const double pos[2]={0.3,-0.2};
1814 f1->getValueOn(pos,res);
1815 CPPUNIT_ASSERT_DOUBLES_EQUAL(arr1[3],res[0],1.e-12);
1816 CPPUNIT_ASSERT_DOUBLES_EQUAL(arr1[4],res[1],1.e-12);
1817 CPPUNIT_ASSERT_DOUBLES_EQUAL(arr1[5],res[2],1.e-12);
1818 std::fill(res,res+3,0.);
1819 f1->getValueOn(pos,2.2,res);
1820 CPPUNIT_ASSERT_DOUBLES_EQUAL(arr1[3],res[0],1.e-12);
1821 CPPUNIT_ASSERT_DOUBLES_EQUAL(arr1[4],res[1],1.e-12);
1822 CPPUNIT_ASSERT_DOUBLES_EQUAL(arr1[5],res[2],1.e-12);
1823 std::fill(res,res+3,0.);
1824 CPPUNIT_ASSERT_THROW(f1->getValueOn(pos,3.2,res),INTERP_KERNEL::Exception);
1825 MEDCouplingFieldDouble *f2=MEDCouplingFieldDouble::New(ON_CELLS,LINEAR_TIME);
1827 f2->setArray(f1->getArray());
1828 f2->setStartTime(2.,3,0);
1829 f2->setEndTime(4.,13,0);
1830 CPPUNIT_ASSERT_THROW(f2->checkCoherency(),INTERP_KERNEL::Exception);
1831 DataArrayDouble *array2=DataArrayDouble::New();
1832 array2->alloc(nbOfCells,3);
1833 tmp=array2->getPointer();
1834 std::copy(arr2,arr2+15,tmp);
1835 f2->setEndArray(array2);
1837 f2->checkCoherency();
1839 std::fill(res,res+3,0.);
1840 f2->getValueOn(pos,3.21,res);
1841 CPPUNIT_ASSERT_DOUBLES_EQUAL(4.025,res[0],1.e-12);
1842 CPPUNIT_ASSERT_DOUBLES_EQUAL(14.025,res[1],1.e-12);
1843 CPPUNIT_ASSERT_DOUBLES_EQUAL(24.025,res[2],1.e-12);
1844 MEDCouplingFieldDouble *f3=f2->clone(true);
1845 CPPUNIT_ASSERT(f2->isEqual(f3,1e-12,1e-12));
1846 f3->getEndArray()->getPointer()[0]=5.001;
1847 CPPUNIT_ASSERT(!f2->isEqual(f3,1e-12,1e-12));
1848 CPPUNIT_ASSERT(f2->isEqual(f3,1e-12,1e-2));
1849 f3->setStartTime(2.1,3,0);
1850 CPPUNIT_ASSERT(!f2->isEqual(f3,1e-12,1e-2));
1851 f3->setStartTime(2.,3,0);
1852 CPPUNIT_ASSERT(f2->isEqual(f3,1e-12,1e-2));
1853 f3->setStartTime(2.,4,0);
1854 CPPUNIT_ASSERT(!f2->isEqual(f3,1e-12,1e-2));
1855 f3->setStartTime(2.,3,1);
1856 CPPUNIT_ASSERT(!f2->isEqual(f3,1e-12,1e-2));
1857 f3->setStartTime(2.,3,0);
1858 CPPUNIT_ASSERT(f2->isEqual(f3,1e-12,1e-2));
1859 f3->setEndTime(4.1,13,0);
1860 CPPUNIT_ASSERT(!f2->isEqual(f3,1e-12,1e-2));
1861 f3->setEndTime(4.,13,0);
1862 CPPUNIT_ASSERT(f2->isEqual(f3,1e-12,1e-2));
1863 f3->setEndTime(4.,14,0);
1864 CPPUNIT_ASSERT(!f2->isEqual(f3,1e-12,1e-2));
1865 f3->setEndTime(4.,13,1);
1866 CPPUNIT_ASSERT(!f2->isEqual(f3,1e-12,1e-2));
1867 f3->setEndTime(4.,13,0);
1868 CPPUNIT_ASSERT(f2->isEqual(f3,1e-12,1e-2));
1870 MEDCouplingFieldDouble *f4=(*f2)+(*f2);
1871 std::fill(res,res+3,0.);
1872 f4->getValueOn(pos,3.21,res);
1873 CPPUNIT_ASSERT_DOUBLES_EQUAL(8.05,res[0],1.e-12);
1874 CPPUNIT_ASSERT_DOUBLES_EQUAL(28.05,res[1],1.e-12);
1875 CPPUNIT_ASSERT_DOUBLES_EQUAL(48.05,res[2],1.e-12);
1877 std::fill(res,res+3,0.);
1878 f4->getValueOn(pos,3.21,res);
1879 CPPUNIT_ASSERT_DOUBLES_EQUAL(12.075,res[0],1.e-12);
1880 CPPUNIT_ASSERT_DOUBLES_EQUAL(42.075,res[1],1.e-12);
1881 CPPUNIT_ASSERT_DOUBLES_EQUAL(72.075,res[2],1.e-12);
1889 bool func4(const double *pt, double *res)
1891 res[0]=pt[0]+pt[1]+pt[2];
1895 void MEDCouplingBasicsTest1::testMergeNodesOnField()
1898 MEDCouplingUMesh *targetMesh=build3DTargetMeshMergeNode_1();
1899 MEDCouplingFieldDouble *f1=targetMesh->fillFromAnalytic(ON_NODES,1,func4);
1900 f1->mergeNodes(1e-10);
1902 targetMesh->decrRef();
1904 targetMesh=build3DTargetMeshMergeNode_1();
1905 f1=targetMesh->fillFromAnalytic(ON_NODES,1,func4);
1906 tmp=f1->getArray()->getPointer();
1908 f1->mergeNodes(1e-10);
1910 targetMesh->decrRef();
1912 targetMesh=build3DTargetMeshMergeNode_1();
1913 f1=targetMesh->fillFromAnalytic(ON_NODES,1,func4);
1914 tmp=f1->getArray()->getPointer();
1916 CPPUNIT_ASSERT_THROW(f1->mergeNodes(1e-10),INTERP_KERNEL::Exception);
1918 targetMesh->decrRef();
1921 void MEDCouplingBasicsTest1::testCheckConsecutiveCellTypes()
1923 MEDCouplingUMesh *sourceMesh=build2DSourceMesh_1();
1924 MEDCouplingUMesh *targetMesh=build2DTargetMesh_1();
1925 CPPUNIT_ASSERT(sourceMesh->checkConsecutiveCellTypes());
1926 const INTERP_KERNEL::NormalizedCellType order1[]={INTERP_KERNEL::NORM_TRI3, INTERP_KERNEL::NORM_QUAD4};
1927 const INTERP_KERNEL::NormalizedCellType order2[]={INTERP_KERNEL::NORM_QUAD4, INTERP_KERNEL::NORM_TRI3};
1928 CPPUNIT_ASSERT(!targetMesh->checkConsecutiveCellTypes());
1929 CPPUNIT_ASSERT(!targetMesh->checkConsecutiveCellTypesAndOrder(order1,order1+2));
1930 CPPUNIT_ASSERT(!targetMesh->checkConsecutiveCellTypesAndOrder(order2,order2+2));
1931 DataArrayInt *da=targetMesh->getRenumArrForConsecutiveCellTypesSpec(order1,order1+2);
1932 CPPUNIT_ASSERT_EQUAL(5,da->getNumberOfTuples());
1933 CPPUNIT_ASSERT_EQUAL(1,da->getNumberOfComponents());
1934 const int expected1[5]={2,0,1,3,4};
1935 CPPUNIT_ASSERT(std::equal(expected1,expected1+5,da->getConstPointer()));
1937 da=targetMesh->getRenumArrForConsecutiveCellTypesSpec(order2,order2+2);
1938 CPPUNIT_ASSERT_EQUAL(5,da->getNumberOfTuples());
1939 CPPUNIT_ASSERT_EQUAL(1,da->getNumberOfComponents());
1940 const int expected2[5]={0,3,4,1,2};
1941 CPPUNIT_ASSERT(std::equal(expected2,expected2+5,da->getConstPointer()));
1943 const int renumber1[5]={4,0,1,2,3};
1944 targetMesh->renumberCells(renumber1,false);
1945 CPPUNIT_ASSERT(targetMesh->checkConsecutiveCellTypes());
1946 CPPUNIT_ASSERT(targetMesh->checkConsecutiveCellTypesAndOrder(order1,order1+2));
1947 CPPUNIT_ASSERT(!targetMesh->checkConsecutiveCellTypesAndOrder(order2,order2+2));
1948 targetMesh->decrRef();
1949 sourceMesh->decrRef();
1952 void MEDCouplingBasicsTest1::testRearrange2ConsecutiveCellTypes()
1954 MEDCouplingUMesh *m1_1=build2DSourceMesh_1();
1955 MEDCouplingUMesh *m2_1=build2DTargetMesh_1();
1956 DataArrayInt *arr1=m1_1->rearrange2ConsecutiveCellTypes();
1957 MEDCouplingUMesh *m1_2=build2DSourceMesh_1();
1958 CPPUNIT_ASSERT(m1_2->isEqual(m1_1,1e-12));
1959 const int expected1[2]={0,1};
1960 CPPUNIT_ASSERT_EQUAL(2,arr1->getNumberOfTuples());
1961 CPPUNIT_ASSERT_EQUAL(1,arr1->getNumberOfComponents());
1962 CPPUNIT_ASSERT(std::equal(expected1,expected1+2,arr1->getConstPointer()));
1964 const int expected2[5]={0,3,4,1,2};
1965 arr1=m2_1->rearrange2ConsecutiveCellTypes();
1966 CPPUNIT_ASSERT_EQUAL(5,arr1->getNumberOfTuples());
1967 CPPUNIT_ASSERT_EQUAL(1,arr1->getNumberOfComponents());
1968 CPPUNIT_ASSERT(std::equal(expected2,expected2+5,arr1->getConstPointer()));
1969 MEDCouplingUMesh *m2_2=build2DTargetMesh_1();
1970 CPPUNIT_ASSERT_EQUAL(5,arr1->getNumberOfTuples());
1971 CPPUNIT_ASSERT_EQUAL(1,arr1->getNumberOfComponents());
1972 CPPUNIT_ASSERT(std::equal(expected2,expected2+5,arr1->getConstPointer()));
1973 CPPUNIT_ASSERT(!m2_2->isEqual(m2_1,1e-12));
1974 m2_2->renumberCells(expected2,false);
1975 CPPUNIT_ASSERT(m2_2->isEqual(m2_1,1e-12));
1983 void MEDCouplingBasicsTest1::testSplitByType()
1985 MEDCouplingUMesh *m1=build3DSurfTargetMesh_1();
1986 std::vector<MEDCouplingUMesh *> v=m1->splitByType();
1987 CPPUNIT_ASSERT_EQUAL(3,(int)v.size());
1988 std::vector<const MEDCouplingUMesh *> v2(v.begin(),v.end());
1989 MEDCouplingUMesh *m2=MEDCouplingUMesh::MergeUMeshesOnSameCoords(v2);
1990 m2->setName(m1->getName());
1991 CPPUNIT_ASSERT(m1->isEqual(m2,1.e-12));
1992 for(std::vector<MEDCouplingUMesh *>::const_iterator iter=v.begin();iter!=v.end();iter++)
1998 void MEDCouplingBasicsTest1::testFuseUMeshesOnSameCoords()
2000 std::vector<const MEDCouplingUMesh *> meshes;
2001 MEDCouplingUMesh *m2=build2DTargetMesh_1();
2002 int cells1[3]={2,3,4};
2003 MEDCouplingPointSet *m3_1=m2->buildPartOfMySelf(cells1,cells1+3,true);
2004 MEDCouplingUMesh *m3=dynamic_cast<MEDCouplingUMesh *>(m3_1);
2006 meshes.push_back(m3);
2007 int cells2[3]={1,2,4};
2008 MEDCouplingPointSet *m4_1=m2->buildPartOfMySelf(cells2,cells2+3,true);
2009 MEDCouplingUMesh *m4=dynamic_cast<MEDCouplingUMesh *>(m4_1);
2011 meshes.push_back(m4);
2012 int cells3[2]={1,2};
2013 MEDCouplingPointSet *m5_1=m2->buildPartOfMySelf(cells3,cells3+2,true);
2014 MEDCouplingUMesh *m5=dynamic_cast<MEDCouplingUMesh *>(m5_1);
2016 meshes.push_back(m5);
2019 std::vector<DataArrayInt *> corr;
2020 MEDCouplingUMesh *m7=MEDCouplingUMesh::FuseUMeshesOnSameCoords(meshes,0,corr);
2021 CPPUNIT_ASSERT_EQUAL(4,m7->getNumberOfCells());
2022 CPPUNIT_ASSERT_EQUAL(3,(int)corr.size());
2023 const int expectedVals1[3]={3,3,2};
2024 const int expectedVals2[3][3]={{0,1,2},{3,0,2},{3,0,111111}};
2025 for(int i=0;i<3;i++)
2027 DataArrayInt *arr=corr[i];
2028 CPPUNIT_ASSERT_EQUAL(1,arr->getNumberOfComponents());
2029 int nbOfVals=expectedVals1[i];
2030 CPPUNIT_ASSERT_EQUAL(nbOfVals,arr->getNumberOfTuples());
2031 const int *vals=arr->getConstPointer();
2032 for(int j=0;j<nbOfVals;j++)
2033 CPPUNIT_ASSERT_EQUAL(expectedVals2[i][j],vals[j]);
2035 std::vector< std::vector<int> > fidsOfGroups;
2036 std::vector<const DataArrayInt *> corr2(corr.begin(),corr.end());
2037 DataArrayInt *arr2=DataArrayInt::MakePartition(corr2,m7->getNumberOfCells(),fidsOfGroups);
2038 const int fidExp[4]={5,1,3,4};
2039 const int fidsGrp[3][3]={{1,3,5},{3,4,5},{4,5,23344}};
2040 CPPUNIT_ASSERT_EQUAL(3,(int)fidsOfGroups.size());
2041 CPPUNIT_ASSERT_EQUAL(1,arr2->getNumberOfComponents());
2042 CPPUNIT_ASSERT_EQUAL(4,arr2->getNumberOfTuples());
2043 CPPUNIT_ASSERT(std::equal(fidExp,fidExp+4,arr2->getConstPointer()));
2044 for(int i=0;i<3;i++)
2046 int nbOfVals=expectedVals1[i];
2047 CPPUNIT_ASSERT_EQUAL(nbOfVals,(int)fidsOfGroups[i].size());
2048 CPPUNIT_ASSERT(std::equal(fidsOfGroups[i].begin(),fidsOfGroups[i].end(),fidsGrp[i]));
2050 for(std::vector<DataArrayInt *>::iterator iter=corr.begin();iter!=corr.end();iter++)
2060 void MEDCouplingBasicsTest1::testFuseUMeshesOnSameCoords2()
2062 MEDCouplingUMesh *m2;
2063 MEDCouplingUMesh *m1=build3DExtrudedUMesh_1(m2);
2065 const int part1[5]={2,3,6,4,10};
2066 MEDCouplingUMesh *m3=(MEDCouplingUMesh *)m1->buildPartOfMySelf(part1,part1+5,true);
2067 const int part2[4]={5,6,4,7};
2068 MEDCouplingUMesh *m4=(MEDCouplingUMesh *)m1->buildPartOfMySelf(part2,part2+4,true);
2069 std::vector<const MEDCouplingUMesh *> meshes;
2070 meshes.push_back(m1);
2071 meshes.push_back(m3);
2072 meshes.push_back(m3);
2073 meshes.push_back(m4);
2074 std::vector<DataArrayInt *> corr;
2075 MEDCouplingUMesh *m5=MEDCouplingUMesh::FuseUMeshesOnSameCoords(meshes,0,corr);
2076 CPPUNIT_ASSERT_EQUAL(18,m5->getNumberOfCells());
2077 std::vector<DataArrayInt *>::iterator it=corr.begin();
2078 const int exp1[4]={18,5,5,4};
2079 const int exp2[4][18]={
2080 {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17},
2081 {2,3,6,4,10,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1},
2082 {2,3,6,4,10,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1},
2083 {5,6,4,7,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1}
2086 for(;it!=corr.end();it++,i++)
2088 int sz=(*it)->getNumberOfTuples();
2089 CPPUNIT_ASSERT_EQUAL(exp1[i],sz);
2090 CPPUNIT_ASSERT(std::equal(exp2[i],exp2[i]+sz,(*it)->getConstPointer()));
2092 for(it=corr.begin();it!=corr.end();it++)
2100 void MEDCouplingBasicsTest1::testBuildOrthogonalField()
2102 MEDCouplingUMesh *targetMesh=build3DSurfTargetMesh_1();
2103 MEDCouplingFieldDouble *field=targetMesh->buildOrthogonalField();
2104 double expected[3]={0.70710678118654746,0.,-0.70710678118654746};
2105 CPPUNIT_ASSERT_EQUAL(5,field->getNumberOfTuples());
2106 CPPUNIT_ASSERT_EQUAL(3,field->getNumberOfComponents());
2107 const double *vals=field->getArray()->getConstPointer();
2108 for(int i=0;i<15;i++)
2109 CPPUNIT_ASSERT_DOUBLES_EQUAL(expected[i%3],vals[i],1e-12);
2111 targetMesh->decrRef();
2113 double targetCoords[12]={0.,0.,0.,0.5,0.,0.5,1.,0.,1.,0.,1.,0.};
2114 int targetConn[4]={0,1,2,3};
2115 targetMesh=MEDCouplingUMesh::New();
2116 targetMesh->setMeshDimension(2);
2117 targetMesh->allocateCells(1);
2118 targetMesh->insertNextCell(INTERP_KERNEL::NORM_QUAD4,4,targetConn);
2119 targetMesh->finishInsertingCells();
2120 DataArrayDouble *myCoords=DataArrayDouble::New();
2121 myCoords->alloc(4,3);
2122 std::copy(targetCoords,targetCoords+12,myCoords->getPointer());
2123 targetMesh->setCoords(myCoords);
2124 myCoords->decrRef();
2125 field=targetMesh->buildOrthogonalField();
2126 CPPUNIT_ASSERT_EQUAL(1,field->getNumberOfTuples());
2127 CPPUNIT_ASSERT_EQUAL(3,field->getNumberOfComponents());
2128 vals=field->getArray()->getConstPointer();
2129 CPPUNIT_ASSERT_DOUBLES_EQUAL(-0.70710678118654746,vals[0],1e-12);
2130 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,vals[1],1e-12);
2131 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.70710678118654746,vals[2],1e-12);
2133 targetMesh->decrRef();
2136 void MEDCouplingBasicsTest1::testGetCellsContainingPoint()
2138 MEDCouplingUMesh *targetMesh=build2DTargetMesh_1();
2139 double pos[12]={0.,0.,0.4,0.4,0.,0.4,0.1,0.1,0.25,0.,0.65,0.};
2140 std::vector<int> t1,t2;
2142 targetMesh->getCellsContainingPoints(pos,6,1e-12,t1,t2);
2143 CPPUNIT_ASSERT_EQUAL(6,(int)t1.size());
2144 CPPUNIT_ASSERT_EQUAL(7,(int)t2.size());
2145 const int expectedValues1[6]={0,4,3,0,1,2};
2146 const int expectedValues2[7]={0,1,2,3,4,5,6};
2147 CPPUNIT_ASSERT(std::equal(t1.begin(),t1.end(),expectedValues1));
2148 CPPUNIT_ASSERT(std::equal(t2.begin(),t2.end(),expectedValues2));
2149 //2D with no help of bounding box.
2150 double center[2]={0.2,0.2};
2151 MEDCouplingPointSet::Rotate2DAlg(center,0.78539816339744830962,6,pos);
2152 targetMesh->rotate(center,0,0.78539816339744830962);
2153 t1.clear(); t2.clear();
2154 targetMesh->getCellsContainingPoints(pos,6,1e-12,t1,t2);
2155 CPPUNIT_ASSERT_EQUAL(6,(int)t1.size());
2156 CPPUNIT_ASSERT_EQUAL(7,(int)t2.size());
2157 CPPUNIT_ASSERT(std::equal(t1.begin(),t1.end(),expectedValues1));
2158 CPPUNIT_ASSERT(std::equal(t2.begin(),t2.end(),expectedValues2));
2160 const double pos1bis[2]={-0.3303300858899107,-0.11819805153394641};
2161 CPPUNIT_ASSERT_EQUAL(-1,targetMesh->getCellContainingPoint(pos1bis,1e-12));
2162 targetMesh->decrRef();
2164 targetMesh=build2DTargetMesh_1();
2165 const double pos2[2]={0.2,-0.05};
2167 targetMesh->getCellsContainingPoint(pos2,1e-12,t1);
2168 CPPUNIT_ASSERT_EQUAL(2,(int)t1.size());
2169 const int expectedValues3[2]={0,1};
2170 CPPUNIT_ASSERT(std::equal(t1.begin(),t1.end(),expectedValues3));
2171 const double pos3[2]={0.2,0.2};
2173 targetMesh->getCellsContainingPoint(pos3,1e-12,t1);
2174 CPPUNIT_ASSERT_EQUAL(5,(int)t1.size());
2175 const int expectedValues4[5]={0,1,2,3,4};
2176 CPPUNIT_ASSERT(std::equal(t1.begin(),t1.end(),expectedValues4));
2177 CPPUNIT_ASSERT_EQUAL(0,targetMesh->getCellContainingPoint(pos3,1e-12));
2178 targetMesh->decrRef();
2180 targetMesh=build3DTargetMesh_1();
2181 const double pos4[3]={25.,25.,25.};
2182 CPPUNIT_ASSERT_EQUAL(0,targetMesh->getCellContainingPoint(pos4,1e-12));
2183 const double pos5[3]={50.,50.,50.};
2185 targetMesh->getCellsContainingPoint(pos5,1e-12,t1);
2186 CPPUNIT_ASSERT_EQUAL(8,(int)t1.size());
2187 const int expectedValues5[8]={0,1,2,3,4,5,6,7};
2188 CPPUNIT_ASSERT(std::equal(t1.begin(),t1.end(),expectedValues5));
2189 const double pos6[3]={0., 50., 0.};
2191 targetMesh->getCellsContainingPoint(pos6,1e-12,t1);
2192 CPPUNIT_ASSERT_EQUAL(2,(int)t1.size());
2193 const int expectedValues6[2]={0,2};
2194 CPPUNIT_ASSERT(std::equal(t1.begin(),t1.end(),expectedValues6));
2196 const double pos7[3]={-1.0,-1.0,0.};
2197 CPPUNIT_ASSERT_EQUAL(-1,targetMesh->getCellContainingPoint(pos7,1e-12));
2199 const double center2[3]={0.,0.,0.};
2200 const double vec2[3]={0.,-1.,0.};
2201 targetMesh->rotate(center2,vec2,0.78539816339744830962);
2202 const double pos8[3]={-25,25.,12.};
2203 CPPUNIT_ASSERT_EQUAL(-1,targetMesh->getCellContainingPoint(pos8,1e-12));
2205 targetMesh->decrRef();
2208 void MEDCouplingBasicsTest1::testGetValueOn1()
2210 MEDCouplingUMesh *targetMesh=build2DTargetMesh_1();
2211 MEDCouplingFieldDouble *fieldOnCells=MEDCouplingFieldDouble::New(ON_CELLS);
2212 int nbOfCells=targetMesh->getNumberOfCells();
2213 fieldOnCells->setMesh(targetMesh);
2214 DataArrayDouble *array=DataArrayDouble::New();
2215 array->alloc(nbOfCells,2);
2216 fieldOnCells->setArray(array);
2217 double *tmp=array->getPointer();
2218 for(int i=0;i<nbOfCells;i++)
2219 { tmp[2*i]=7.+(double)i; tmp[2*i+1]=17.+(double)i; }
2222 const double pos1[2]={0.25,0.};
2224 fieldOnCells->getValueOn(pos1,res);
2225 CPPUNIT_ASSERT_DOUBLES_EQUAL(8.,res[0],1e-12);
2226 CPPUNIT_ASSERT_DOUBLES_EQUAL(18.,res[1],1e-12);
2228 fieldOnCells->decrRef();
2229 targetMesh->decrRef();
2231 targetMesh=build2DSourceMesh_1();
2232 MEDCouplingFieldDouble *fieldOnNodes=MEDCouplingFieldDouble::New(ON_NODES);
2233 int nbOfNodes=targetMesh->getNumberOfNodes();
2234 fieldOnNodes->setMesh(targetMesh);
2235 array=DataArrayDouble::New();
2236 array->alloc(nbOfNodes,2);
2237 fieldOnNodes->setArray(array);
2238 tmp=array->getPointer();
2239 for(int i=0;i<nbOfNodes;i++)
2240 { tmp[2*i]=17.+(double)i; tmp[2*i+1]=27.+(double)i; }
2243 const double pos2[2]={-0.13333333333333333,-0.13333333333333333};
2244 fieldOnNodes->getValueOn(pos2,res);
2245 CPPUNIT_ASSERT_DOUBLES_EQUAL(17.5,res[0],1e-12);
2246 CPPUNIT_ASSERT_DOUBLES_EQUAL(27.5,res[1],1e-12);
2247 const double pos3[2]={0.033333333333333326,0.36666666666666664};
2248 fieldOnNodes->getValueOn(pos3,res);
2249 CPPUNIT_ASSERT_DOUBLES_EQUAL(18.666666666666667,res[0],1e-12);
2250 CPPUNIT_ASSERT_DOUBLES_EQUAL(28.666666666666667,res[1],1e-12);
2252 fieldOnNodes->decrRef();
2253 targetMesh->decrRef();
2256 void MEDCouplingBasicsTest1::testCMesh0()
2258 MEDCouplingCMesh* mesh=MEDCouplingCMesh::New();
2259 MEDCouplingCMesh* meshEmpty=mesh->clone(true);
2260 CPPUNIT_ASSERT(meshEmpty->isEqual(mesh,1e-12));
2262 DataArrayDouble* coordsX=DataArrayDouble::New();
2263 double arrX[4] = { -1., 1., 2., 4. };
2264 coordsX->useArray(arrX,false, CPP_DEALLOC,4,1);
2265 DataArrayDouble* coordsY=DataArrayDouble::New();
2266 double arrY[4] = { -2., 2., 4., 8. };
2267 coordsY->useArray(arrY,false, CPP_DEALLOC,4,1);
2268 DataArrayDouble* coordsZ=DataArrayDouble::New();
2269 double arrZ[4] = { -3., 3., 6., 12. };
2270 coordsZ->useArray(arrZ,false, CPP_DEALLOC,4,1);
2271 mesh->setCoords(coordsX,coordsY,coordsZ);
2276 MEDCouplingFieldDouble *fieldOnNodes=mesh->fillFromAnalytic(ON_NODES,1,"x+y/2.+z/3.");
2277 CPPUNIT_ASSERT_EQUAL(1,fieldOnNodes->getNumberOfComponents());
2278 CPPUNIT_ASSERT_EQUAL(64,fieldOnNodes->getNumberOfTuples());
2279 const double expected1[64]={-3., -1., 0., 2., -1., 1., 2., 4., 0., 2., 3., 5., 2., 4., 5., 7., -1., 1., 2.,
2280 4., 1., 3., 4., 6., 2., 4., 5., 7., 4., 6., 7., 9., 0., 2., 3., 5., 2., 4., 5.,
2281 7., 3., 5., 6., 8., 5., 7., 8., 10., 2., 4., 5.,
2282 7., 4., 6., 7., 9., 5., 7., 8., 10., 7., 9., 10., 12.};
2283 const double *val=fieldOnNodes->getArray()->getConstPointer();
2284 for(int i=0;i<64;i++)
2285 CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],val[i],1e-12);
2286 double res[1]; //size fieldOnNodes->getNumberOfComponents()
2287 fieldOnNodes->getValueOnPos(1,3,2,&res[0]);
2288 CPPUNIT_ASSERT_DOUBLES_EQUAL(7.,res[0],1e-12);
2289 fieldOnNodes->decrRef();
2291 MEDCouplingFieldDouble *fieldOnCells=mesh->fillFromAnalytic(ON_CELLS,1,"x+y/2.+z/3.");
2292 CPPUNIT_ASSERT_EQUAL(1,fieldOnCells->getNumberOfComponents());
2293 CPPUNIT_ASSERT_EQUAL(27,fieldOnCells->getNumberOfTuples());
2294 val=fieldOnCells->getArray()->getConstPointer();
2295 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,
2296 6, 4.5, 6, 7.5, 3, 4.5, 6, 4.5, 6, 7.5, 6, 7.5, 9};
2297 for(int i=0;i<27;i++)
2298 CPPUNIT_ASSERT_DOUBLES_EQUAL(expected2[i],val[i],1e-12);
2299 fieldOnCells->getValueOnPos(1,2,1,&res[0]);
2300 CPPUNIT_ASSERT_DOUBLES_EQUAL(6.,res[0],1e-12);
2301 fieldOnCells->decrRef();
2303 MEDCouplingMesh* meshDeepCopy=mesh->deepCpy();
2304 MEDCouplingCMesh* meshClone=mesh->clone(false);
2306 CPPUNIT_ASSERT_THROW(meshEmpty->copyTinyStringsFrom(0),INTERP_KERNEL::Exception);
2307 meshEmpty->copyTinyStringsFrom(mesh);
2308 //no data in meshEmpty, expected false
2309 CPPUNIT_ASSERT(!meshEmpty->isEqual(mesh,1e-12));
2311 CPPUNIT_ASSERT(meshDeepCopy->isEqual(mesh,1e-12));
2312 meshDeepCopy->copyTinyStringsFrom(mesh);
2313 CPPUNIT_ASSERT(meshDeepCopy->isEqual(mesh,1e-12));
2314 CPPUNIT_ASSERT(meshClone->isEqual(mesh,1e-12));
2316 CPPUNIT_ASSERT_EQUAL(CARTESIAN,mesh->getType());
2317 CPPUNIT_ASSERT_EQUAL(CARTESIAN,meshEmpty->getType());
2318 CPPUNIT_ASSERT_EQUAL(CARTESIAN,meshDeepCopy->getType());
2319 CPPUNIT_ASSERT_EQUAL(CARTESIAN,meshClone->getType());
2322 meshEmpty->decrRef();
2323 meshDeepCopy->decrRef();
2324 meshClone->decrRef();
2327 void MEDCouplingBasicsTest1::testCMesh1()
2329 MEDCouplingCMesh *mesh1,*mesh2,*mesh3;
2330 mesh1=MEDCouplingCMesh::New();
2331 DataArrayDouble* coordsX1=DataArrayDouble::New();
2332 double arrX1[4] = { -1., 1., 2., 4. };
2333 coordsX1->useArray(arrX1,false, CPP_DEALLOC,4,1);
2334 DataArrayDouble* coordsY1=DataArrayDouble::New();
2335 double arrY1[4] = { -2., 2., 4., 8. };
2336 coordsY1->useArray(arrY1,false, CPP_DEALLOC,4,1);
2337 DataArrayDouble* coordsZ1=DataArrayDouble::New();
2338 double arrZ1[4] = { -3., 3., 6., 12. };
2339 coordsZ1->useArray(arrZ1,false, CPP_DEALLOC,4,1);
2340 mesh1->setCoords(coordsX1,coordsY1,coordsZ1);
2342 mesh2=MEDCouplingCMesh::New();
2343 DataArrayDouble* coordsX2=DataArrayDouble::New();
2344 double arrX2[4] = { -1., 1., 2., 4. };
2345 coordsX2->useArray(arrX2,false, CPP_DEALLOC,4,1);
2346 DataArrayDouble* coordsY2=DataArrayDouble::New();
2347 double arrY2[4] = { -2., 2., 4., 8. };
2348 coordsY2->useArray(arrY2,false, CPP_DEALLOC,4,1);
2349 DataArrayDouble* coordsZ2=DataArrayDouble::New();
2350 double arrZ2[4] = { -3., 3., 6., 12.+1e-6 }; //here is not equal
2351 coordsZ2->useArray(arrZ2,false, CPP_DEALLOC,4,1);
2352 mesh2->setCoords(coordsX2,coordsY2,coordsZ2);
2354 mesh3=MEDCouplingCMesh::New();
2355 DataArrayDouble* coordsX3=DataArrayDouble::New();
2356 double arrX3[1] = { -1.};
2357 coordsX3->useArray(arrX3,false, CPP_DEALLOC,1,1);
2358 DataArrayDouble* coordsY3=DataArrayDouble::New();
2359 double arrY3[1] = { -2.};
2360 coordsY3->useArray(arrY3,false, CPP_DEALLOC,1,1);
2361 DataArrayDouble* coordsZ3=DataArrayDouble::New();
2362 double arrZ3[1] = { -3.};
2363 coordsZ3->useArray(arrZ3,false, CPP_DEALLOC,1,1);
2364 mesh3->setCoords(coordsX3,coordsY3,coordsZ3);
2366 CPPUNIT_ASSERT_EQUAL(3,mesh1->getSpaceDimension());
2367 CPPUNIT_ASSERT_EQUAL(3,mesh1->getMeshDimension());
2369 CPPUNIT_ASSERT(!mesh1->isEqual(mesh2,1e-12));
2370 CPPUNIT_ASSERT(!mesh2->isEqual(mesh1,1e-12));
2371 CPPUNIT_ASSERT(!mesh2->isEqualWithoutConsideringStr(mesh1,1e-12));
2372 CPPUNIT_ASSERT(mesh1->isEqual(mesh2,1e-5));
2373 CPPUNIT_ASSERT(!mesh1->isEqual(mesh2,1e-7));
2375 CPPUNIT_ASSERT_THROW(mesh3->checkCoherency1(1e-12),INTERP_KERNEL::Exception);
2376 mesh1->checkCoherency2(1e-12);
2377 CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_HEXA8,mesh1->getTypeOfCell(1));
2379 CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_HEXA8,*((mesh1->getAllGeoTypes()).begin()));
2380 CPPUNIT_ASSERT_EQUAL(27,mesh1->getNumberOfCellsWithType(INTERP_KERNEL::NORM_HEXA8));
2381 CPPUNIT_ASSERT_THROW(mesh1->getNumberOfCellsWithType(INTERP_KERNEL::NORM_QUAD4),INTERP_KERNEL::Exception);
2383 std::vector<double> coo;
2384 mesh1->getCoordinatesOfNode(0, coo);
2385 CPPUNIT_ASSERT_EQUAL(3,(int) coo.size());
2386 CPPUNIT_ASSERT_DOUBLES_EQUAL(-1.,coo[0],1e-14);
2387 CPPUNIT_ASSERT_DOUBLES_EQUAL(-2.,coo[1],1e-14);
2388 CPPUNIT_ASSERT_DOUBLES_EQUAL(-3.,coo[2],1e-14);
2390 mesh1->getCoordinatesOfNode(63, coo);
2391 CPPUNIT_ASSERT_EQUAL(3,(int) coo.size());
2392 CPPUNIT_ASSERT_DOUBLES_EQUAL(4.,coo[0],1e-14);
2393 CPPUNIT_ASSERT_DOUBLES_EQUAL(8.,coo[1],1e-14);
2394 CPPUNIT_ASSERT_DOUBLES_EQUAL(12.,coo[2],1e-14);
2397 repr=mesh1->simpleRepr();
2398 repr=mesh1->advancedRepr();
2399 CPPUNIT_ASSERT(!(repr.find("Cartesian")==std::string::npos));
2400 CPPUNIT_ASSERT(!(repr.find("Number of components : 1")==std::string::npos));
2401 CPPUNIT_ASSERT(!(repr.find("Number of tuples : 4")==std::string::npos));
2402 CPPUNIT_ASSERT(!(repr.find("Z Array :")==std::string::npos));
2403 coordsX1->decrRef();
2404 coordsY1->decrRef();
2405 coordsZ1->decrRef();
2406 coordsX2->decrRef();
2407 coordsY2->decrRef();
2408 coordsZ2->decrRef();
2409 coordsX3->decrRef();
2410 coordsY3->decrRef();
2411 coordsZ3->decrRef();
2417 void MEDCouplingBasicsTest1::testCMesh2()
2419 MEDCouplingCMesh *mesh1;
2420 mesh1=MEDCouplingCMesh::New();
2421 DataArrayDouble* coordsX1=DataArrayDouble::New();
2422 double arrX1[4] = { -1., 1., 2., 4. };
2423 coordsX1->useArray(arrX1,false, CPP_DEALLOC,4,1);
2424 DataArrayDouble* coordsY1=DataArrayDouble::New();
2425 double arrY1[4] = { -2., 2., 4., 8. };
2426 coordsY1->useArray(arrY1,false, CPP_DEALLOC,4,1);
2427 DataArrayDouble* coordsZ1=DataArrayDouble::New();
2428 double arrZ1[4] = { -3., 3., 6., 12. };
2429 coordsZ1->useArray(arrZ1,false, CPP_DEALLOC,4,1);
2430 mesh1->setCoords(coordsX1,coordsY1,coordsZ1);
2432 std::vector<int> dis=mesh1->getDistributionOfTypes();
2433 CPPUNIT_ASSERT_EQUAL(3,(int) dis.size());
2434 CPPUNIT_ASSERT_EQUAL((int) INTERP_KERNEL::NORM_HEXA8,dis[0]);
2435 CPPUNIT_ASSERT_EQUAL(27,dis[1]);
2436 CPPUNIT_ASSERT_EQUAL(0,dis[2]);
2438 std::vector<const DataArrayInt *> idsPerType;
2439 CPPUNIT_ASSERT_THROW(mesh1->checkTypeConsistencyAndContig(dis, idsPerType),INTERP_KERNEL::Exception);
2441 CPPUNIT_ASSERT(!(mesh1->checkTypeConsistencyAndContig(dis, idsPerType)));
2442 dis[0]=(int) INTERP_KERNEL::NORM_QUAD4;
2443 CPPUNIT_ASSERT_THROW(mesh1->checkTypeConsistencyAndContig(dis, idsPerType),INTERP_KERNEL::Exception);
2445 dis[0]=(int) INTERP_KERNEL::NORM_HEXA8;
2447 DataArrayInt *ids=DataArrayInt::New();
2449 ids->fillWithValue(111);
2450 idsPerType.push_back(ids);
2451 DataArrayInt* check=mesh1->checkTypeConsistencyAndContig(dis, idsPerType);
2452 CPPUNIT_ASSERT(check);
2453 CPPUNIT_ASSERT(check->isEqual(*ids));
2455 std::vector<int> code;
2456 std::vector<DataArrayInt *> idsInPflPerType;
2457 std::vector<DataArrayInt *> pfls;
2458 mesh1->splitProfilePerType(ids,code,idsInPflPerType,pfls);
2459 CPPUNIT_ASSERT_EQUAL(3,(int)code.size());
2460 CPPUNIT_ASSERT_EQUAL((int) INTERP_KERNEL::NORM_HEXA8,code[0]);
2461 CPPUNIT_ASSERT_EQUAL(27,code[1]);
2462 CPPUNIT_ASSERT_EQUAL(0,code[2]);
2463 CPPUNIT_ASSERT_EQUAL(1,(int)idsInPflPerType.size());
2464 CPPUNIT_ASSERT_EQUAL(1,(int)pfls.size());
2465 CPPUNIT_ASSERT(idsInPflPerType[0]->isEqual(*ids));
2466 CPPUNIT_ASSERT(pfls[0]->isEqual(*ids));
2467 idsInPflPerType[0]->decrRef();
2472 int cells1[4]={0,1,25,26};
2473 MEDCouplingUMesh *partMesh1=
2474 dynamic_cast<MEDCouplingUMesh *>(mesh1->buildPart(cells1,cells1+4));
2475 CPPUNIT_ASSERT(partMesh1);
2476 CPPUNIT_ASSERT_EQUAL(4,partMesh1->getNumberOfCellsWithType(INTERP_KERNEL::NORM_HEXA8));
2477 CPPUNIT_ASSERT_EQUAL(64,mesh1->getNumberOfNodes());
2478 CPPUNIT_ASSERT_EQUAL(64,partMesh1->getNumberOfNodes());
2480 int cells2[2]={25,26};
2482 MEDCouplingUMesh *partMesh2=
2483 dynamic_cast<MEDCouplingUMesh *>(mesh1->buildPartAndReduceNodes(cells2,cells2+2,arr1));
2484 CPPUNIT_ASSERT(partMesh2);
2485 CPPUNIT_ASSERT_EQUAL(2,partMesh2->getNumberOfCellsWithType(INTERP_KERNEL::NORM_HEXA8));
2486 CPPUNIT_ASSERT_EQUAL(12,partMesh2->getNumberOfNodes());
2488 int cells3[2]={2,3};
2490 MEDCouplingUMesh *partMesh3=
2491 dynamic_cast<MEDCouplingUMesh *>(partMesh1->buildPartAndReduceNodes(cells3,cells3+2,arr2));
2492 CPPUNIT_ASSERT(partMesh3);
2493 CPPUNIT_ASSERT_EQUAL(2,partMesh3->getNumberOfCellsWithType(INTERP_KERNEL::NORM_HEXA8));
2494 CPPUNIT_ASSERT_EQUAL(12,partMesh3->getNumberOfNodes());
2496 CPPUNIT_ASSERT_THROW(mesh1->simplexize(0),INTERP_KERNEL::Exception);
2497 CPPUNIT_ASSERT_THROW(mesh1->getMeasureFieldOnNode(true),INTERP_KERNEL::Exception);
2501 mesh1->getBoundingBox(bbox1);
2502 partMesh1->getBoundingBox(bbox2);
2503 for(int i=0;i<6;i++)
2504 CPPUNIT_ASSERT_DOUBLES_EQUAL(bbox1[i],bbox2[i],1e-12);
2505 partMesh3->getBoundingBox(bbox1);
2506 partMesh2->getBoundingBox(bbox2);
2507 for(int i=0;i<6;i++)
2508 CPPUNIT_ASSERT_DOUBLES_EQUAL(bbox1[i],bbox2[i],1e-12);
2510 CPPUNIT_ASSERT_THROW(mesh1->buildOrthogonalField(),INTERP_KERNEL::Exception);
2511 MEDCouplingCMesh *mesh2d=MEDCouplingCMesh::New();
2512 mesh2d->setCoords(coordsX1,coordsY1);
2513 MEDCouplingFieldDouble *f1=mesh2d->buildOrthogonalField();
2515 std::vector<double> tinyInfoD;
2516 std::vector<int> tinyInfo;
2517 std::vector<std::string> littleStrings;
2518 mesh2d->getTinySerializationInformation(tinyInfoD, tinyInfo, littleStrings);
2519 CPPUNIT_ASSERT_EQUAL(5,(int)tinyInfo.size());
2520 CPPUNIT_ASSERT_EQUAL(4,(int)tinyInfo[0]); //x
2521 CPPUNIT_ASSERT_EQUAL(4,(int)tinyInfo[1]); //y
2522 CPPUNIT_ASSERT_EQUAL(-1,(int)tinyInfo[2]); //z
2523 CPPUNIT_ASSERT_EQUAL(-1,(int)tinyInfo[3]); //it
2524 CPPUNIT_ASSERT_EQUAL(-1,(int)tinyInfo[4]); //order
2525 CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,tinyInfoD[0],1e-14); //time
2526 DataArrayInt* d1=DataArrayInt::New();
2527 DataArrayDouble* d2=DataArrayDouble::New();
2528 mesh2d->resizeForUnserialization(tinyInfo, d1, d2, littleStrings);
2529 CPPUNIT_ASSERT_EQUAL(0,d1->getNumberOfTuples());
2530 CPPUNIT_ASSERT_EQUAL(8,d2->getNumberOfTuples());
2532 partMesh1->decrRef();
2533 partMesh2->decrRef();
2534 partMesh3->decrRef();
2541 coordsX1->decrRef();
2542 coordsY1->decrRef();
2543 coordsZ1->decrRef();
2547 void MEDCouplingBasicsTest1::testScale()
2549 MEDCouplingUMesh *mesh=build2DTargetMesh_1();
2550 const double pos[2]={0.2,0.2};
2551 mesh->scale(pos,0.5);
2552 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,
2553 -0.05,0.45, 0.2,0.45, 0.45,0.45};
2554 const double *val=mesh->getCoords()->getConstPointer();
2555 for(int i=0;i<18;i++)
2556 CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],val[i],1e-12);
2561 void MEDCouplingBasicsTest1::testTryToShareSameCoords()
2563 MEDCouplingUMesh *m1=build2DTargetMesh_1();
2564 MEDCouplingUMesh *m2=build2DTargetMesh_1();
2565 CPPUNIT_ASSERT(m1->getCoords()!=m2->getCoords());
2566 m1->tryToShareSameCoords(*m2,1e-12);
2567 CPPUNIT_ASSERT(m1->getCoords()==m2->getCoords());
2568 m1->tryToShareSameCoords(*m2,1e-12);
2569 CPPUNIT_ASSERT(m1->getCoords()==m2->getCoords());
2570 m2->tryToShareSameCoords(*m1,1e-12);
2571 CPPUNIT_ASSERT(m1->getCoords()==m2->getCoords());
2575 m1=build2DTargetMesh_1();
2576 m2=build2DTargetMesh_2();
2577 CPPUNIT_ASSERT(m1->getCoords()!=m2->getCoords());
2578 m1->tryToShareSameCoords(*m2,1e-12);
2579 CPPUNIT_ASSERT(m1->getCoords()==m2->getCoords());
2580 m1->tryToShareSameCoords(*m2,1e-12);
2581 CPPUNIT_ASSERT(m1->getCoords()==m2->getCoords());
2582 m2->tryToShareSameCoords(*m1,1e-12);
2583 CPPUNIT_ASSERT(m1->getCoords()==m2->getCoords());
2587 m1=build2DTargetMesh_1();
2588 m2=build2DSourceMesh_1();
2589 CPPUNIT_ASSERT(m1->getCoords()!=m2->getCoords());
2590 CPPUNIT_ASSERT_THROW(m1->tryToShareSameCoords(*m2,1e-12),INTERP_KERNEL::Exception);
2595 void MEDCouplingBasicsTest1::testFindNodeOnPlane()
2597 MEDCouplingUMesh *mesh=build3DTargetMesh_1();
2599 double pt[3]={300.,300.,0.};
2600 double v[3]={0.,0.,2.};
2601 mesh->findNodesOnPlane(pt,v,1e-12,n);
2602 CPPUNIT_ASSERT_EQUAL(9,(int)n.size());
2603 MEDCouplingUMesh *m3dSurf=(MEDCouplingUMesh *)mesh->buildFacePartOfMySelfNode(&n[0],&n[0]+n.size(),true);
2604 MEDCouplingExtrudedMesh *me=MEDCouplingExtrudedMesh::New(mesh,m3dSurf,0);
2605 const DataArrayInt *da=me->getMesh3DIds();
2606 CPPUNIT_ASSERT_EQUAL(8,me->getNumberOfCells());
2607 const int expected[8]={0,1,2,3,4,5,6,7};
2608 const int *val=da->getConstPointer();
2609 for(int i=0;i<8;i++)
2610 CPPUNIT_ASSERT_EQUAL(expected[i],val[i]);
2616 void MEDCouplingBasicsTest1::testRenumberCells()
2618 MEDCouplingUMesh *m=build3DSurfTargetMesh_1();
2619 MEDCouplingUMesh *m2=build3DSurfTargetMesh_1();
2620 CPPUNIT_ASSERT(m->isEqual(m2,0));
2621 const int arr[5]={12,3,25,2,26};
2622 m->renumberCells(arr,true);
2623 CPPUNIT_ASSERT(!m->isEqual(m2,0));
2624 CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_QUAD4,m->getTypeOfCell(0));
2625 CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_TRI3,m->getTypeOfCell(1));
2626 CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_QUAD4,m->getTypeOfCell(2));
2627 CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_TRI3,m->getTypeOfCell(3));
2628 CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_QUAD4,m->getTypeOfCell(4));
2629 const int arr2[5]={5,-1,-5,4,8};
2630 m->renumberCells(arr2,true);
2631 CPPUNIT_ASSERT(m->isEqual(m2,0));
2636 void MEDCouplingBasicsTest1::testChangeSpaceDimension()
2638 MEDCouplingUMesh *m1=build3DSurfTargetMesh_1();
2639 MEDCouplingUMesh *m2=build2DTargetMesh_1();
2641 CPPUNIT_ASSERT_EQUAL(3,m1->getSpaceDimension());
2642 m1->changeSpaceDimension(2);
2643 CPPUNIT_ASSERT_EQUAL(2,m1->getSpaceDimension());
2644 m1->setName(m2->getName());
2645 CPPUNIT_ASSERT(m1->isEqual(m2,1e-12));
2646 m1->changeSpaceDimension(3);
2647 CPPUNIT_ASSERT_EQUAL(3,m1->getSpaceDimension());
2648 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.};
2649 const double *val=m1->getCoords()->getConstPointer();
2650 for(int i=0;i<27;i++)
2651 CPPUNIT_ASSERT_DOUBLES_EQUAL(expected[i],val[i],1e-14);