1 # -*- coding: utf-8 -*-
2 # Copyright (C) 2007-2022 CEA/DEN, EDF R&D
4 # This library is free software; you can redistribute it and/or
5 # modify it under the terms of the GNU Lesser General Public
6 # License as published by the Free Software Foundation; either
7 # version 2.1 of the License, or (at your option) any later version.
9 # This library is distributed in the hope that it will be useful,
10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 # Lesser General Public License for more details.
14 # You should have received a copy of the GNU Lesser General Public
15 # License along with this library; if not, write to the Free Software
16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
22 if sys.platform == "win32":
23 from MEDCouplingCompat import *
25 from medcoupling import *
28 from math import pi,e,sqrt,cos,sin
29 from datetime import datetime
30 from MEDCouplingDataForTest import MEDCouplingDataForTest
31 import rlcompleter,readline # this line has to be here, to ensure a usability of MEDCoupling/MEDLoader. B4 removing it please notify to anthony.geay@edf.fr
33 class MEDCouplingBasicsTest1(unittest.TestCase):
35 arr=DataArrayDouble.New()
36 arr.setValues([12.,11.,10.,9.,8.,7.,6.,5.,4.,3.,2.,1.],3,4)
37 arr.setInfoOnComponent(0,"ggg");
38 arr.setInfoOnComponent(1,"hhhh");
39 arr.setInfoOnComponent(2,"jj");
40 arr.setInfoOnComponent(3,"kkkkkk");
41 arr2=arr.convertToIntArr();
42 arr3=arr2.convertToDblArr();
43 self.assertTrue(arr.isEqual(arr3,1e-14))
47 arr1=DataArrayInt.New();
48 arr1Ref=[0,10,1,11,2,12,3,13,4,14,5,15,6,16]
49 arr1.setValues(arr1Ref,7,2);
50 self.assertEqual(7,arr1.getNumberOfTuples());
51 self.assertEqual(2,arr1.getNumberOfComponents());
52 self.assertEqual(arr1Ref,list(arr1.getValues()));
53 arr2=arr1.subArray(3);
54 self.assertEqual(4,arr2.getNumberOfTuples());
55 self.assertEqual(2,arr2.getNumberOfComponents());
56 self.assertEqual(arr1Ref[6:],list(arr2.getValues()));
57 arr3=arr1.subArray(2,5);
58 self.assertEqual(3,arr3.getNumberOfTuples());
59 self.assertEqual(2,arr3.getNumberOfComponents());
60 self.assertEqual(arr1Ref[4:10],list(arr3.getValues()));
62 arr4=DataArrayDouble.New();
63 arr4Ref=[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]
64 arr4.setValues(arr4Ref,7,2);
65 self.assertEqual(7,arr4.getNumberOfTuples());
66 self.assertEqual(2,arr4.getNumberOfComponents());
69 self.assertTrue(abs(arr4Ref[i]-tmp[i])<1e-14);
71 arr5=arr4.subArray(3);
72 self.assertEqual(4,arr5.getNumberOfTuples());
73 self.assertEqual(2,arr5.getNumberOfComponents());
76 self.assertTrue(abs(arr4Ref[6+i]-tmp[i])<1e-14);
78 arr6=arr4.subArray(2,5);
79 self.assertEqual(3,arr6.getNumberOfTuples());
80 self.assertEqual(2,arr6.getNumberOfComponents());
83 self.assertTrue(abs(arr4Ref[4+i]-tmp[i])<1e-14);
88 tab4=[1, 2, 8, 7, 2, 3, 9, 8, 3,
89 4, 10, 9, 4, 5, 11, 10, 5,
90 0, 6, 11, 0, 1, 7, 6 ]
93 coords=[ 0.024155, 0.04183768725682622, -0.305, 0.04831000000000001, -1.015761910347357e-17,
94 -0.305, 0.09662000000000001, -1.832979297858306e-18, -0.305, 0.120775, 0.04183768725682623,
95 -0.305, 0.09662000000000001, 0.08367537451365245, -0.305, 0.04831000000000001, 0.08367537451365246,
96 -0.305, 0.024155, 0.04183768725682622, -0.2863, 0.04831000000000001, -1.015761910347357e-17, -0.2863,
97 0.09662000000000001, -1.832979297858306e-18, -0.2863, 0.120775, 0.04183768725682623, -0.2863, 0.09662000000000001,
98 0.08367537451365245, -0.2863, 0.04831000000000001, 0.08367537451365246, -0.2863 ]
99 self.assertEqual(MEDCouplingMesh.GetNumberOfNodesOfGeometricType(NORM_TRI3),3)
100 self.assertTrue(MEDCouplingMesh.IsStaticGeometricType(NORM_TRI3))
101 self.assertTrue(MEDCouplingMesh.IsLinearGeometricType(NORM_TRI3))
102 self.assertEqual(MEDCouplingMesh.GetDimensionOfGeometricType(NORM_TRI3),2)
103 self.assertEqual(MEDCouplingMesh.GetReprOfGeometricType(NORM_TRI3),"NORM_TRI3")
104 self.assertRaises(InterpKernelException,MEDCouplingMesh.GetNumberOfNodesOfGeometricType,NORM_POLYGON)
105 self.assertTrue(not MEDCouplingMesh.IsStaticGeometricType(NORM_POLYGON))
106 self.assertTrue(MEDCouplingMesh.IsLinearGeometricType(NORM_POLYGON))
107 self.assertEqual(MEDCouplingMesh.GetDimensionOfGeometricType(NORM_POLYGON),2)
108 self.assertEqual(MEDCouplingMesh.GetReprOfGeometricType(NORM_POLYGON),"NORM_POLYGON")
109 self.assertEqual(MEDCouplingMesh.GetNumberOfNodesOfGeometricType(NORM_TRI6),6)
110 self.assertTrue(MEDCouplingMesh.IsStaticGeometricType(NORM_TRI6))
111 self.assertTrue(not MEDCouplingMesh.IsLinearGeometricType(NORM_TRI6))
112 self.assertEqual(MEDCouplingMesh.GetDimensionOfGeometricType(NORM_TRI6),2)
113 self.assertEqual(MEDCouplingMesh.GetReprOfGeometricType(NORM_TRI6),"NORM_TRI6")
114 mesh=MEDCouplingUMesh.New()
115 mesh.setMeshDimension(2)
116 mesh.allocateCells(8);
117 mesh.setName("mesh1")
118 self.assertTrue(mesh.getName()=="mesh1")
119 for i in range(nbOfCells):
120 mesh.insertNextCell(NORM_QUAD4,4,tab4[4*i:4*(i+1)]);
122 mesh.finishInsertingCells()
123 self.assertTrue(mesh.getNumberOfCells()==nbOfCells)
124 self.assertTrue(mesh.getNodalConnectivity().getNbOfElems()==30)
125 self.assertTrue(mesh.getNodalConnectivityIndex().getNbOfElems()==nbOfCells+1)
126 myCoords=DataArrayDouble.New()
127 myCoords.setValues(coords,nbOfNodes,3);
128 self.assertTrue(myCoords.getIJ(3,2)==-0.305)
129 mesh.setCoords(myCoords);
130 mesh.checkConsistencyLight();
131 self.assertTrue(mesh.getAllGeoTypes()==[4])
132 myFalseConn=DataArrayInt.New()
133 myFalseConn.setValues(tab4,6,4)
134 self.assertTrue(myFalseConn.getIJ(1,1)==3)
136 field=MEDCouplingFieldDouble.New(ON_CELLS)
138 field.setNature(ExtensiveMaximum)
139 myCoords=DataArrayDouble.New()
141 for i in range(nbOfCells * 9):
142 sampleTab.append(float(i))
143 myCoords.setValues(sampleTab,nbOfCells,9);
144 field.setArray(myCoords)
145 self.assertTrue(3==mesh.getSpaceDimension())
146 field.checkConsistencyLight()
147 mesh2=mesh.clone(False)
148 mesh3=mesh.clone(True)
151 ## deep full recursively copy of field -> both field and mesh underneath copied
152 field2=field.clone(True)
153 field2.setMesh(field.getMesh().clone(True))
154 mesh3=mesh.clone(True)
155 field3=mesh3.fillFromAnalytic(ON_CELLS,2,"x*IVec+(y+z)*JVec")
156 field3.applyFunc("u*u*u+cos(u)")
159 def testMeshPointsCloud(self):
160 targetCoords=[-0.3,-0.3,0.5, 0.2,-0.3,1., 0.7,-0.3,1.5,
161 -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]
162 targetMesh=MEDCouplingUMesh.New();
163 targetMesh.setMeshDimension(0);
164 targetMesh.allocateCells(8);
165 targetMesh.insertNextCell(NORM_POINT1,1,[0]);
166 targetMesh.insertNextCell(NORM_POINT1,1,[1]);
167 targetMesh.insertNextCell(NORM_POINT1,1,[2]);
168 targetMesh.insertNextCell(NORM_POINT1,1,[3]);
169 targetMesh.insertNextCell(NORM_POINT1,1,[4]);
170 targetMesh.insertNextCell(NORM_POINT1,1,[5]);
171 targetMesh.insertNextCell(NORM_POINT1,1,[7]);
172 targetMesh.insertNextCell(NORM_POINT1,1,[6]);
173 targetMesh.finishInsertingCells();
174 self.assertRaises(InterpKernelException,targetMesh.checkConsistencyLight);
175 myCoords=DataArrayDouble.New();
176 myCoords.setValues(targetCoords,9,3);
177 targetMesh.setCoords(myCoords);
178 self.assertEqual(targetMesh.getSpaceDimension(),3)
179 self.assertEqual(targetMesh.getNumberOfCells(),8)
180 self.assertEqual(targetMesh.getNumberOfNodes(),9)
181 self.assertEqual(targetMesh.getMeshDimension(),0)
184 def testMeshM1D(self):
185 meshM1D=MEDCouplingUMesh.New();
186 self.assertRaises(InterpKernelException,meshM1D.getMeshDimension);
187 self.assertRaises(InterpKernelException,meshM1D.getNumberOfNodes);
188 self.assertRaises(InterpKernelException,meshM1D.getNumberOfCells);
189 self.assertRaises(InterpKernelException,meshM1D.setMeshDimension,-2)
190 self.assertRaises(InterpKernelException,meshM1D.setMeshDimension,-10)
191 meshM1D.setMeshDimension(-1);
192 meshM1D.checkConsistencyLight();
193 self.assertEqual(meshM1D.getMeshDimension(),-1);
194 self.assertEqual(meshM1D.getNumberOfCells(),1);
195 self.assertRaises(InterpKernelException,meshM1D.getNumberOfNodes);
196 self.assertRaises(InterpKernelException,meshM1D.getSpaceDimension);
197 cpy=meshM1D.clone(True);
198 self.assertTrue(cpy.isEqual(meshM1D,1e-12));
199 fieldOnCells=MEDCouplingFieldDouble.New(ON_CELLS);
200 fieldOnCells.setMesh(meshM1D);
201 array=DataArrayDouble.New();
202 array.setValues(6*[7.],1,6);
203 fieldOnCells.setArray(array);
204 fieldOnCells.checkConsistencyLight();
207 def testDeepCopy(self):
208 array=DataArrayDouble.New();
209 array.setValues(5*3*[7.],5,3);
210 self.assertEqual(array.getIJ(3,2),7.);
211 array2=array.deepCopy();
212 self.assertEqual(array2.getIJ(3,2),7.)
214 array3=DataArrayInt.New();
215 array3.setValues(5*3*[17],5,3);
216 self.assertEqual(array3.getIJ(3,2),17);
217 array4=array3.deepCopy();
218 self.assertEqual(array4.getIJ(3,2),17);
221 def testRevNodal(self):
222 mesh=MEDCouplingDataForTest.build2DTargetMesh_1()
223 revNodal,revNodalIndx=mesh.getReverseNodalConnectivity();
224 revNodalExpected=[0,0,1,1,2,0,3,0,1,2,3,4,2,4,3,3,4,4];
225 revNodalIndexExpected=[0,1,3,5,7,12,14,15,17,18];
226 self.assertEqual(revNodal.getNbOfElems(),18)
227 self.assertEqual(revNodalIndx.getNbOfElems(),10)
228 self.assertEqual(list(revNodal.getValues()),revNodalExpected)
229 self.assertEqual(list(revNodalIndx.getValues()),revNodalIndexExpected)
232 def testConvertToPolyTypes(self):
233 mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
235 mesh.convertToPolyTypes(elts);
236 mesh.checkConsistencyLight();
237 self.assertEqual(5,mesh.getNumberOfCells());
238 self.assertEqual(23,mesh.getNodalConnectivity().getNumberOfTuples());
239 expected1=[4, 0, 3, 4, 1, 5, 1, 4, 2, 3, 4, 5, 2, 5, 6, 7, 4, 3, 4, 7, 8, 5, 4]
240 self.assertEqual(expected1,list(mesh.getNodalConnectivity().getValues()));
242 mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
243 mesh.convertToPolyTypes(elts);
244 mesh.checkConsistencyLight();
245 self.assertEqual(8,mesh.getNumberOfCells());
246 self.assertEqual(114,mesh.getNodalConnectivity().getNumberOfTuples());
247 mesh.convertToPolyTypes(elts);
248 mesh.checkConsistencyLight();
249 self.assertEqual(8,mesh.getNumberOfCells());
250 self.assertEqual(114,mesh.getNodalConnectivity().getNumberOfTuples());
253 def testDescConn2D(self):
254 mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
255 desc=DataArrayInt.New();
256 descIndx=DataArrayInt.New();
257 revDesc=DataArrayInt.New();
258 revDescIndx=DataArrayInt.New();
259 mesh2=mesh.buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
260 mesh2.checkConsistencyLight();
261 self.assertEqual(1,mesh2.getMeshDimension());
262 self.assertEqual(13,mesh2.getNumberOfCells());
263 self.assertEqual(14,revDescIndx.getNbOfElems()); self.assertEqual(14,revDescIndx.getNumberOfTuples());
264 self.assertEqual(6,descIndx.getNbOfElems()); self.assertEqual(6,descIndx.getNumberOfTuples());
265 self.assertEqual(18,desc.getNbOfElems()); self.assertEqual(18,desc.getNumberOfTuples());
266 self.assertEqual(18,revDesc.getNbOfElems()); self.assertEqual(18,revDesc.getNumberOfTuples());
267 expected1=[0,1,2,3, 2,4,5, 6,7,4, 8,9,1,10, 11,12,6,9];
268 self.assertEqual(expected1,list(desc.getValues()));
269 expected2=[0,4,7,10,14,18];
270 self.assertEqual(expected2,list(descIndx.getValues()));
271 expected3=[0,1,3,5,6,8,9,11,12,13,15,16,17,18];
272 self.assertEqual(expected3,list(revDescIndx.getValues()));
273 expected4=[0, 0,3, 0,1, 0, 1,2, 1, 2,4, 2, 3, 3,4, 3, 4, 4];
274 self.assertEqual(expected4,list(revDesc.getValues()));
275 conn=mesh2.getNodalConnectivity();
276 connIndex=mesh2.getNodalConnectivityIndex();
277 expected5=[0,3,6,9,12,15,18,21,24,27,30,33,36,39];
278 self.assertEqual(expected5,list(connIndex.getValues()));
279 expected6=[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];
280 self.assertEqual(expected6,list(conn.getValues()));
283 mesh.convertToPolyTypes(eltsV);
284 mesh.checkConsistencyLight();
286 desc=DataArrayInt.New();
287 descIndx=DataArrayInt.New();
288 revDesc=DataArrayInt.New();
289 revDescIndx=DataArrayInt.New();
291 mesh2=mesh.buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
292 mesh2.checkConsistencyLight();
293 self.assertEqual(1,mesh2.getMeshDimension());
294 self.assertEqual(13,mesh2.getNumberOfCells());
295 self.assertEqual(14,revDescIndx.getNbOfElems()); self.assertEqual(14,revDescIndx.getNumberOfTuples());
296 self.assertEqual(6,descIndx.getNbOfElems()); self.assertEqual(6,descIndx.getNumberOfTuples());
297 self.assertEqual(18,desc.getNbOfElems()); self.assertEqual(18,desc.getNumberOfTuples());
298 self.assertEqual(18,revDesc.getNbOfElems()); self.assertEqual(18,revDesc.getNumberOfTuples());
299 self.assertEqual(expected1,list(desc.getValues()));
300 self.assertEqual(expected2,list(descIndx.getValues()));
301 self.assertEqual(expected3,list(revDescIndx.getValues()));
302 self.assertEqual(expected4,list(revDesc.getValues()));
303 conn=mesh2.getNodalConnectivity();
304 connIndex=mesh2.getNodalConnectivityIndex();
305 self.assertEqual(expected5,list(connIndex.getValues()));
306 self.assertEqual(expected6,list(conn.getValues()));
309 def testDescConn3D(self):
310 mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
311 desc=DataArrayInt.New();
312 descIndx=DataArrayInt.New();
313 revDesc=DataArrayInt.New();
314 revDescIndx=DataArrayInt.New();
316 mesh2=mesh.buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
317 mesh2.checkConsistencyLight();
318 self.assertEqual(2,mesh2.getMeshDimension());
319 self.assertEqual(36,mesh2.getNumberOfCells());
320 self.assertEqual(37,revDescIndx.getNbOfElems()); self.assertEqual(37,revDescIndx.getNumberOfTuples());
321 self.assertEqual(9,descIndx.getNbOfElems()); self.assertEqual(9,descIndx.getNumberOfTuples());
322 self.assertEqual(48,desc.getNbOfElems()); self.assertEqual(48,desc.getNumberOfTuples());
323 self.assertEqual(48,revDesc.getNbOfElems()); self.assertEqual(48,revDesc.getNumberOfTuples());
324 expected1=[0, 6, 12, 18, 24, 30, 36, 42, 48]
325 expected2=[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]
326 expected3=[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]
327 expected4=[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]
328 expected5=[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]
329 expected6=[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,
330 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,
331 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,
332 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]
333 expected7=[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,
334 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,
335 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,
336 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]
338 self.assertEqual(expected1,list(descIndx.getValues()));
339 self.assertEqual(expected2,list(desc.getValues()));
340 self.assertEqual(expected3,list(revDescIndx.getValues()));
341 self.assertEqual(expected4,list(revDesc.getValues()));
342 self.assertEqual(expected5,list(mesh2.getNodalConnectivityIndex().getValues()));
343 self.assertEqual(expected6,list(mesh2.getNodalConnectivity().getValues()));
346 mesh.convertToPolyTypes(eltsV);
347 mesh.checkConsistencyLight();
348 desc=DataArrayInt.New();
349 descIndx=DataArrayInt.New();
350 revDesc=DataArrayInt.New();
351 revDescIndx=DataArrayInt.New();
352 mesh2=mesh.buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
353 mesh2.checkConsistencyLight();
354 self.assertEqual(2,mesh2.getMeshDimension());
355 self.assertEqual(36,mesh2.getNumberOfCells());
356 self.assertEqual(37,revDescIndx.getNbOfElems()); self.assertEqual(37,revDescIndx.getNumberOfTuples());
357 self.assertEqual(9,descIndx.getNbOfElems()); self.assertEqual(9,descIndx.getNumberOfTuples());
358 self.assertEqual(48,desc.getNbOfElems()); self.assertEqual(48,desc.getNumberOfTuples());
359 self.assertEqual(48,revDesc.getNbOfElems()); self.assertEqual(48,revDesc.getNumberOfTuples());
360 self.assertEqual(expected1,list(descIndx.getValues()));
361 self.assertEqual(expected2,list(desc.getValues()));
362 self.assertEqual(expected3,list(revDescIndx.getValues()));
363 self.assertEqual(expected4,list(revDesc.getValues()));
364 self.assertEqual(expected5,list(mesh2.getNodalConnectivityIndex().getValues()));
365 self.assertEqual(expected7,list(mesh2.getNodalConnectivity().getValues()));
368 def testFindBoundaryNodes(self):
369 mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
370 boundaryNodes=mesh.findBoundaryNodes();
371 expected1=[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];
372 self.assertEqual(expected1,boundaryNodes.getValues());
375 def testBoundaryMesh(self):
376 mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
377 mesh2=mesh.buildBoundaryMesh(False);
378 self.assertEqual(24,mesh2.getNumberOfCells());
379 self.assertEqual(26,mesh2.getNumberOfNodes());
382 def testBuildPartOfMySelf(self):
383 mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
384 mesh.setName("Toto");
388 subMesh=mesh.buildPart(tab1)
389 self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
390 subMesh=mesh.buildPartOfMySelf(tab1,True);
391 self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
392 name=subMesh.getName();
393 self.assertEqual(2,len(mesh.getAllGeoTypes()));
394 self.assertEqual(NORM_TRI3,mesh.getAllGeoTypes()[0]);
395 self.assertEqual(NORM_QUAD4,mesh.getAllGeoTypes()[1]);
396 self.assertEqual(1,len(subMesh.getAllGeoTypes()));
397 self.assertEqual(NORM_QUAD4,subMesh.getAllGeoTypes()[0]);
398 self.assertEqual(name,"Toto");
399 self.assertEqual(2,subMesh.getNumberOfCells());
400 subConn=[4,0,3,4,1,4,7,8,5,4];
401 subConnIndex=[0,5,10];
402 self.assertEqual(10,subMesh.getNodalConnectivity().getNbOfElems());
403 self.assertEqual(3,subMesh.getNodalConnectivityIndex().getNbOfElems());
404 self.assertEqual(subConn[0:10],list(subMesh.getNodalConnectivity().getValues()));
405 self.assertEqual(subConnIndex[0:3],list(subMesh.getNodalConnectivityIndex().getValues()));
407 subMesh=mesh.buildPartOfMySelf(tab2[0:3],True);
408 self.assertTrue(isinstance(subMesh,MEDCouplingUMesh));
409 name=subMesh.getName();
410 self.assertEqual(2,len(subMesh.getAllGeoTypes()));
411 self.assertEqual(NORM_TRI3,subMesh.getAllGeoTypes()[0]);
412 self.assertEqual(NORM_QUAD4,subMesh.getAllGeoTypes()[1]);
413 self.assertEqual(name,"Toto");
414 self.assertEqual(3,subMesh.getNumberOfCells());
415 subConn2=[4,0,3,4,1,3,4,5,2,4,6,7,4,3]
416 subConnIndex2=[0,5,9,14]
417 self.assertEqual(14,subMesh.getNodalConnectivity().getNbOfElems());
418 self.assertEqual(4,subMesh.getNodalConnectivityIndex().getNbOfElems());
419 self.assertEqual(subConn2[0:14],list(subMesh.getNodalConnectivity().getValues()));
420 self.assertEqual(subConnIndex2[0:4],list(subMesh.getNodalConnectivityIndex().getValues()));
421 dd=DataArrayInt.New()
425 subMesh=subMesh.buildPartOfMySelf(dd,True);
426 self.assertEqual("coucou",subMesh.getName());
429 def testBuildPartOfMySelfNode(self):
430 mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
432 subMesh=mesh.buildPartOfMySelfNode(tab1[0:4],True);
433 self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
434 self.assertEqual(1,len(subMesh.getAllGeoTypes()));
435 self.assertEqual(NORM_QUAD4,subMesh.getAllGeoTypes()[0]);
436 self.assertEqual(1,subMesh.getNumberOfCells());
437 self.assertEqual(5,subMesh.getNodalConnectivity().getNbOfElems());
438 self.assertEqual(2,subMesh.getNodalConnectivityIndex().getNbOfElems());
441 self.assertEqual(subConn[0:5],list(subMesh.getNodalConnectivity().getValues()));
442 self.assertEqual(subConnIndex[0:2],list(subMesh.getNodalConnectivityIndex().getValues()));
444 ddd=DataArrayInt.New()
445 ddd.setValues(tab1[0:2],2,1)
447 subMesh=mesh.buildPartOfMySelfNode(ddd,False);
448 self.assertEqual("ddd",subMesh.getName())
449 self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
450 self.assertEqual(2,len(subMesh.getAllGeoTypes()));
451 self.assertEqual(NORM_TRI3,subMesh.getAllGeoTypes()[0]);
452 self.assertEqual(NORM_QUAD4,subMesh.getAllGeoTypes()[1]);
453 self.assertEqual(3,subMesh.getNumberOfCells());
454 self.assertEqual(14,subMesh.getNodalConnectivity().getNbOfElems());
455 self.assertEqual(4,subMesh.getNodalConnectivityIndex().getNbOfElems());
456 subConn2=[3,4,5,2,4,6,7,4,3,4,7,8,5,4]
457 subConnIndex2=[0,4,9,14]
458 self.assertEqual(subConn2[0:14],list(subMesh.getNodalConnectivity().getValues()));
459 self.assertEqual(subConnIndex2[0:4],list(subMesh.getNodalConnectivityIndex().getValues()));
460 #testing the case where length of tab2 is greater than max number of node per cell.
462 subMesh=mesh.buildPartOfMySelfNode(tab2[0:7],True);
463 self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
464 self.assertEqual(2,len(subMesh.getAllGeoTypes()));
465 self.assertEqual(NORM_TRI3,subMesh.getAllGeoTypes()[0]);
466 self.assertEqual(NORM_QUAD4,subMesh.getAllGeoTypes()[1]);
467 self.assertEqual(3,subMesh.getNumberOfCells());
470 def testZipCoords(self):
471 mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
472 self.assertEqual(2,len(mesh.getAllGeoTypes()));
473 self.assertEqual(2,mesh.getSpaceDimension());
474 self.assertEqual(9,mesh.getNumberOfNodes());
475 self.assertEqual(5,mesh.getNumberOfCells());
476 oldConn=mesh.getNodalConnectivity().getValues()[0:mesh.getNodalConnectivity().getNbOfElems()];
477 oldConnIndex=mesh.getNodalConnectivityIndex().getValues()[0:mesh.getNumberOfCells()+1]
478 oldCoords=mesh.getCoords();
480 self.assertEqual(2,len(mesh.getAllGeoTypes()));
481 self.assertEqual(2,mesh.getSpaceDimension());
482 self.assertEqual(9,mesh.getNumberOfNodes());
483 self.assertEqual(5,mesh.getNumberOfCells());
484 self.assertEqual(mesh.getCoords().getValues()[0:2*9],oldCoords.getValues());
485 self.assertEqual(list(oldConn),list(mesh.getNodalConnectivity().getValues()));
486 self.assertEqual(list(oldConnIndex),list(mesh.getNodalConnectivityIndex().getValues()));
489 subMesh=mesh.buildPartOfMySelf(tab1,True);
490 self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
491 traducer=subMesh.zipCoordsTraducer();
492 expectedTraducer=[0, 1, -1, 2, 3, 4, -1, 5, 6]
493 self.assertEqual(expectedTraducer,list(traducer.getValues()));
494 self.assertEqual(NORM_QUAD4,subMesh.getAllGeoTypes()[0]);
495 self.assertEqual(2,subMesh.getNumberOfCells());
496 subConn=[4,0,2,3,1,4,5,6,4,3]
497 subConnIndex=[0,5,10]
498 self.assertEqual(7,subMesh.getNumberOfNodes());
499 self.assertEqual(10,subMesh.getNodalConnectivity().getNbOfElems());
500 self.assertEqual(3,subMesh.getNodalConnectivityIndex().getNbOfElems());
501 self.assertEqual(subConn,list(subMesh.getNodalConnectivity().getValues()));
502 self.assertEqual(subConnIndex,list(subMesh.getNodalConnectivityIndex().getValues()));
504 subMesh=mesh.buildPartOfMySelf(tab1,False);
505 self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
506 self.assertEqual(NORM_QUAD4,subMesh.getAllGeoTypes()[0]);
507 self.assertEqual(2,subMesh.getNumberOfCells());
508 self.assertEqual(7,subMesh.getNumberOfNodes());
509 self.assertEqual(10,subMesh.getNodalConnectivity().getNbOfElems());
510 self.assertEqual(3,subMesh.getNodalConnectivityIndex().getNbOfElems());
511 self.assertEqual(subConn,list(subMesh.getNodalConnectivity().getValues()));
512 self.assertEqual(subConnIndex,list(subMesh.getNodalConnectivityIndex().getValues()));
515 def testZipConnectivity(self):
516 m1=MEDCouplingDataForTest.build2DTargetMesh_1();
517 m2=MEDCouplingDataForTest.build2DTargetMesh_1();
519 m3=m2.buildPartOfMySelf(cells1,True);
520 self.assertTrue(isinstance(m3,MEDCouplingUMesh))
521 m4=MEDCouplingDataForTest.build2DSourceMesh_1();
522 m5=MEDCouplingUMesh.MergeUMeshes(m1,m3);
523 m6=MEDCouplingUMesh.MergeUMeshes(m5,m4);
525 self.assertEqual(10,m6.getNumberOfCells());
526 self.assertEqual(22,m6.getNumberOfNodes());
527 (arr,areNodesMerged,newNbOfNodes)=m6.mergeNodes(1e-13);
528 self.assertTrue(areNodesMerged);
529 self.assertEqual(10,m6.getNumberOfCells());
530 self.assertEqual(9,m6.getNumberOfNodes());
532 arr=m6.zipConnectivityTraducer(0);
533 self.assertEqual(7,m6.getNumberOfCells());
535 arr=m6.zipConnectivityTraducer(0);
536 self.assertTrue(m7.isEqual(m6,1e-12));
537 self.assertEqual(7,m6.getNumberOfCells());
540 def testEqualMesh(self):
541 mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
542 mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
544 self.assertTrue(mesh1.isEqual(mesh1,1e-12));
546 self.assertTrue(mesh1.isEqual(mesh2,1e-12));
547 self.assertTrue(mesh2.isEqual(mesh1,1e-12));
548 pt=mesh2.getCoords().getValues();
550 mesh2.getCoords().setIJ(0,1,5.999);
551 self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
552 self.assertTrue(not mesh2.isEqual(mesh1,1e-12));
553 mesh2.getCoords().setIJ(0,1,tmp);
554 self.assertTrue(mesh1.isEqual(mesh2,1e-12));
555 self.assertTrue(mesh2.isEqual(mesh1,1e-12));
557 pt2=mesh1.getNodalConnectivity().getValues();
558 mesh1.getNodalConnectivity().setIJ(5,0,int(pt2[5])+1);
559 self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
560 self.assertTrue(not mesh2.isEqual(mesh1,1e-12));
561 mesh1.getNodalConnectivity().setIJ(5,0,int(pt2[5]));
562 self.assertTrue(mesh1.isEqual(mesh2,1e-12));
563 self.assertTrue(mesh2.isEqual(mesh1,1e-12));
565 pt2=mesh1.getNodalConnectivityIndex().getValues();
566 mesh1.getNodalConnectivityIndex().setIJ(1,0,int(pt2[1]+1));
567 self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
568 self.assertTrue(not mesh2.isEqual(mesh1,1e-12));
569 mesh1.getNodalConnectivityIndex().setIJ(1,0,int(pt2[1]));
570 self.assertTrue(mesh1.isEqual(mesh2,1e-12));
571 self.assertTrue(mesh2.isEqual(mesh1,1e-12));
573 tmp3=mesh1.getName();
574 mesh1.setName("lllll");
575 self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
576 self.assertTrue(not mesh2.isEqual(mesh1,1e-12));
578 self.assertTrue(mesh1.isEqual(mesh2,1e-12));
579 self.assertTrue(mesh2.isEqual(mesh1,1e-12));
581 tmp3=mesh2.getCoords().getInfoOnComponent(1);
582 mesh2.getCoords().setInfoOnComponent(1,"kkkkkk");
583 self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
584 self.assertTrue(not mesh2.isEqual(mesh1,1e-12));
585 mesh2.getCoords().setInfoOnComponent(1,tmp3);
586 self.assertTrue(mesh1.isEqual(mesh2,1e-12));
587 self.assertTrue(mesh2.isEqual(mesh1,1e-12));
590 def testEqualFieldDouble(self):
591 mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
592 mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
594 fieldOnCells1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
595 fieldOnCells1.setMesh(mesh1);
596 fieldOnCells2=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
597 fieldOnCells2.setMesh(mesh2);
599 self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
600 self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
602 fieldOnNodes1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
603 self.assertTrue(not fieldOnCells1.isEqual(fieldOnNodes1,1e-12,1e-15));
604 self.assertTrue(not fieldOnNodes1.isEqual(fieldOnCells1,1e-12,1e-15));
606 fieldOnCells2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
607 self.assertEqual(fieldOnCells2.getMesh(),None) # to check that convertMesh wrapping do not raise but return Py_None
608 self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
609 self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
610 fieldOnCells1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
611 self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
612 self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
613 fieldOnCells1.setTime(4.,6,7);
614 self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
615 self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
616 fieldOnCells2.setTime(4.,6,7);
617 self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
618 self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
619 fieldOnCells1.setName("Power");
620 self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
621 self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
622 fieldOnCells2.setName("Power");
623 self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
624 self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
626 fieldOnCells1.setMesh(mesh1);
627 self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
628 self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
629 fieldOnCells2.setMesh(mesh1);
630 self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
631 self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
632 arr=DataArrayDouble.New();
634 arr.setValues(mesh1.getNumberOfCells()*3*[6.],mesh1.getNumberOfCells(),3);
635 fieldOnCells1.setArray(arr);
636 self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
637 self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
638 fieldOnCells2.setArray(arr);
639 self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
640 self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
643 fieldOnCells2.setArray(arr2);
644 self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
645 self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
647 self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
648 self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
650 self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
651 self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
652 arr2.setName("popo2");
653 self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
654 self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
656 arr2.setName("popo");
657 self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
658 self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
660 arr2.setInfoOnComponent(2,"jjj");
661 self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
662 self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
663 arr.setInfoOnComponent(2,"jjj");
664 self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
665 self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
668 def testNatureChecking(self):
669 field=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
670 field.setNature(ExtensiveMaximum);
671 field.setNature(IntensiveMaximum);
672 field.setNature(ExtensiveConservation);
673 field=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
674 field.setNature(IntensiveMaximum);
675 self.assertRaises(InterpKernelException,field.setNature,ExtensiveMaximum);
676 self.assertRaises(InterpKernelException,field.setNature,ExtensiveConservation);
679 def testNatureOperations(self):
680 """ Check nature constraints on field operations """
681 m = MEDCouplingCMesh()
682 m.setCoordsAt(0, DataArrayDouble([1.0,2.0,3.0]))
683 m.setCoordsAt(1, DataArrayDouble([1.0,2.0,3.0]))
684 m = m.buildUnstructured()
685 f1, f2 = MEDCouplingFieldDouble.New(ON_CELLS, NO_TIME), MEDCouplingFieldDouble.New(ON_CELLS, NO_TIME)
686 f1.setNature(ExtensiveMaximum)
687 f2.setNature(IntensiveMaximum)
688 self.assertEqual(ExtensiveMaximum, f1.getNature())
689 self.assertEqual(IntensiveMaximum, f2.getNature())
691 da = DataArrayDouble([1.0,2.0,3.0,4.0])
692 f1.setMesh(m); f2.setMesh(m)
693 f1.setArray(da); f2.setArray(da.deepCopy())
694 # All this should complain about nature:
695 self.assertRaises(InterpKernelException, f1.__add__, f2)
696 self.assertRaises(InterpKernelException, f1.__iadd__, f2)
697 self.assertRaises(InterpKernelException, f1.__sub__, f2)
698 self.assertRaises(InterpKernelException, f1.__isub__, f2)
699 self.assertRaises(InterpKernelException, f1.__radd__, f2)
700 self.assertRaises(InterpKernelException, f1.__rsub__, f2)
701 self.assertRaises(InterpKernelException, MEDCouplingFieldDouble.AddFields, f1, f2)
702 self.assertRaises(InterpKernelException, MEDCouplingFieldDouble.SubstractFields, f1, f2)
703 self.assertRaises(InterpKernelException, MEDCouplingFieldDouble.MaxFields, f1, f2)
704 self.assertRaises(InterpKernelException, MEDCouplingFieldDouble.MinFields, f1, f2)
706 f3 = MEDCouplingFieldDouble.MultiplyFields(f1,f2)
707 self.assertEqual(NoNature, f3.getNature())
709 self.assertEqual(NoNature, f3.getNature())
710 f1Tmp = f1.deepCopy(); f1Tmp.setMesh(m); f1Tmp *= f2
711 self.assertEqual(NoNature, f1Tmp.getNature())
712 f3 = MEDCouplingFieldDouble.DivideFields(f1,f2)
713 self.assertEqual(NoNature, f3.getNature())
715 self.assertEqual(NoNature, f3.getNature())
716 f1Tmp = f1.deepCopy(); f1Tmp.setMesh(m); f1Tmp /= f2
717 self.assertEqual(NoNature, f1Tmp.getNature())
718 # f3 = MEDCouplingFieldDouble.PowFields(f1,f2)
719 # self.assertEqual(NoNature, f3.getNature())
721 self.assertEqual(NoNature, f3.getNature())
722 f1Tmp = f1.deepCopy(); f1Tmp.setMesh(m); f1Tmp **= f2
723 self.assertEqual(NoNature, f1Tmp.getNature())
724 f3 = MEDCouplingFieldDouble.DotFields(f1,f2)
725 self.assertEqual(NoNature, f3.getNature())
727 self.assertEqual(NoNature, f3.getNature())
729 da = DataArrayDouble.Meld([da, da, da])
730 f1.setArray(da); f2.setArray(da.deepCopy())
731 f3 = MEDCouplingFieldDouble.CrossProductFields(f1,f2)
732 self.assertEqual(NoNature, f3.getNature())
733 f3 = f1.crossProduct(f2)
735 def testBuildSubMeshData(self):
736 targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1()
737 #check buildSubMesh on field on cells
738 fieldCells=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
739 fieldCells.setMesh(targetMesh);
741 ret1,di=fieldCells.buildSubMeshData(elts);
742 self.assertTrue(isinstance(ret1,MEDCouplingUMesh))
743 self.assertEqual(3,ret1.getNumberOfCells());
744 self.assertEqual(9,ret1.getNumberOfNodes());
745 self.assertEqual(3,di.getNumberOfTuples());
746 self.assertEqual(1,di.getNumberOfComponents());
747 toCheck=di.getValues();
748 self.assertTrue(elts,toCheck);
749 #check buildSubMesh on field on nodes
750 fieldNodes=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
751 fieldNodes.setMesh(targetMesh);
752 ret2,di=fieldNodes.buildSubMeshData(elts);
753 self.assertTrue(isinstance(ret2,MEDCouplingUMesh))
754 self.assertEqual(3,ret2.getNumberOfCells());
755 self.assertEqual(6,ret2.getNumberOfNodes());
756 self.assertEqual(6,di.getNumberOfTuples());
757 self.assertEqual(1,di.getNumberOfComponents());
758 toCheck=di.getValues();
759 expected=[1,2,4,5,7,8]
760 self.assertEqual(expected,list(toCheck));
763 def testExtrudedMesh1(self):
764 mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
765 ext=MEDCouplingMappedExtrudedMesh.New(mesh3D,mesh2D,1);
766 self.assertEqual(18,ext.getNumberOfCells());
767 self.assertEqual(60,ext.getNumberOfNodes());
768 ids3D=ext.getMesh3DIds();
769 ids3DExpected=[5,4,3,2,1,0, 11,10,9,8,7,6, 17,16,15,14,13,12]
770 self.assertEqual(18,ids3D.getNumberOfTuples());
771 self.assertEqual(1,ids3D.getNumberOfComponents());
772 self.assertEqual(ids3DExpected,list(ids3D.getValues()));
773 mesh1D=ext.getMesh1D();
774 self.assertEqual(4,mesh1D.getNumberOfNodes());
775 self.assertEqual(3,mesh1D.getNumberOfCells());
776 mesh1DExpected=[0.66666666666666663, 1.4583333333333333, 0, 0.66666666666666663,
777 1.4583333333333333, 1, 0.66666666666666663, 1.4583333333333333,
778 2, 0.66666666666666663, 1.4583333333333333, 3]
779 mesh1DCoords=mesh1D.getCoords();
780 self.assertEqual(4,mesh1DCoords.getNumberOfTuples());
781 self.assertEqual(3,mesh1DCoords.getNumberOfComponents());
782 self.assertEqual(mesh1DExpected,mesh1DCoords.getValues());
783 conn1D=mesh1D.getNodalConnectivity();
784 self.assertEqual(9,conn1D.getNumberOfTuples());
785 self.assertEqual(1,conn1D.getNumberOfComponents());
786 conn1DExpected=[1,0,1,1,1,2,1,2,3]
787 self.assertEqual(conn1DExpected,list(conn1D.getValues()));
790 def testExtrudedMesh3(self):
791 m1=MEDCouplingDataForTest.build2DTargetMesh_1();
792 m1.changeSpaceDimension(3);
793 m2=MEDCouplingDataForTest.buildCU1DMesh_U();
794 m2.changeSpaceDimension(3);
797 m2.rotate(center,vector,-pi/2.);
798 m3=m1.buildExtrudedMesh(m2,0);
800 m4=MEDCouplingMappedExtrudedMesh.New(m3,m1,0);
801 self.assertEqual(15,m4.getNumberOfCells());
802 self.assertEqual(5,m4.getMesh2D().getNumberOfCells());
803 self.assertEqual(3,m4.getMesh1D().getNumberOfCells());
804 m3DIds=m4.getMesh3DIds().getValues();
805 self.assertEqual(list(range(15)), list(m3DIds));
806 #some random in cells to check that extrusion alg find it correctly
807 expected1=[1,3,2,0,6,5,7,10,11,8,12,9,14,13,4]
808 m3.renumberCells(expected1,False);
809 m4=MEDCouplingMappedExtrudedMesh.New(m3,m1,0);
810 self.assertEqual(15,m4.getNumberOfCells());
811 self.assertEqual(5,m4.getMesh2D().getNumberOfCells());
812 self.assertEqual(3,m4.getMesh1D().getNumberOfCells());
813 m3DIds=m4.getMesh3DIds().getValues();
814 self.assertEqual(expected1,list(m3DIds));
815 #play with polygons and polyedrons
817 m1.convertToPolyTypes(cells);
818 m3=m1.buildExtrudedMesh(m2,0);
819 self.assertEqual(NORM_HEXA8,m3.getTypeOfCell(0));
820 self.assertEqual(NORM_PENTA6,m3.getTypeOfCell(1));
821 self.assertEqual(NORM_POLYHED,m3.getTypeOfCell(2));
822 self.assertEqual(NORM_POLYHED,m3.getTypeOfCell(3));
823 self.assertEqual(NORM_HEXA8,m3.getTypeOfCell(4));
824 m3.renumberCells(expected1,False);
825 m4=MEDCouplingMappedExtrudedMesh.New(m3,m1,0);
826 self.assertEqual(15,m4.getNumberOfCells());
827 self.assertEqual(5,m4.getMesh2D().getNumberOfCells());
828 self.assertEqual(3,m4.getMesh1D().getNumberOfCells());
829 m3DIds=m4.getMesh3DIds().getValues();
830 self.assertEqual(expected1,list(m3DIds));
833 def testExtrudedMesh4(self):
834 m1=MEDCouplingDataForTest.build2DTargetMesh_1();
836 m1.convertToPolyTypes(cells);
837 m1.changeSpaceDimension(3);
838 m2=MEDCouplingDataForTest.buildCU1DMesh_U();
839 m2.changeSpaceDimension(3);
842 m2.rotate(center,vector,-pi/2.);
844 m3=m1.buildExtrudedMesh(m2,0);
845 expected1=[1,3,2,0,6,5,7,10,11,8,12,9,14,13,4]
846 rexpected1=[3, 0, 2, 1, 14, 5, 4, 6, 9, 11, 7, 8, 10, 13, 12]
847 m3.renumberCells(expected1,False);
848 m4=MEDCouplingMappedExtrudedMesh.New(m3,m1,0);
849 self.assertEqual(NORM_HEXA8,m4.getTypeOfCell(0));
850 self.assertEqual(NORM_HEXA8,m4.getTypeOfCell(1));
851 self.assertEqual(NORM_POLYHED,m4.getTypeOfCell(2));
852 self.assertEqual(NORM_PENTA6,m4.getTypeOfCell(7));
853 f=m4.getMeasureField(True);
855 self.assertEqual(15,arr.getNumberOfTuples());
856 self.assertEqual(1,arr.getNumberOfComponents());
857 arrPtr=arr.getValues();
858 expected2=[0.075,0.0375,0.0375,0.075,0.075,
859 0.1125,0.05625,0.05625,0.1125,0.1125,
860 0.0625,0.03125,0.03125,0.0625,0.0625]
862 self.assertAlmostEqual(expected2[rexpected1[i]],arrPtr[i],16);
864 m5=m4.build3DUnstructuredMesh();
866 self.assertTrue(m5.isEqual(m3,1e-12));
867 f=m5.getMeasureField(True);
869 self.assertTrue(isinstance(f.getMesh(),MEDCouplingMappedExtrudedMesh))
871 arrPtr=arr.getValues();
873 self.assertAlmostEqual(expected2[rexpected1[i]],arrPtr[i],15);
877 def testFindCommonNodes(self):
878 targetMesh=MEDCouplingDataForTest.build3DTargetMesh_1();
879 comm,commI=targetMesh.findCommonNodes(1e-10,-1);
880 self.assertEqual(1,commI.getNumberOfTuples());
881 self.assertEqual(0,comm.getNumberOfTuples());
882 o2n,newNbOfNodes=targetMesh.buildNewNumberingFromCommonNodesFormat(comm,commI);
883 self.assertEqual(27,newNbOfNodes);
884 self.assertEqual(27,o2n.getNumberOfTuples());
885 o2nExp1 = list(range(27))
886 self.assertEqual(o2nExp1,list(o2n.getValues()));
888 targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
889 self.assertEqual(31,targetMesh.getNumberOfNodes());
890 comm,commI=targetMesh.findCommonNodes(1e-10);# testing default parameter
891 self.assertEqual(3,commI.getNumberOfTuples());
892 self.assertEqual(6,comm.getNumberOfTuples());
893 commExpected=[1,27,28,29,23,30]
894 commIExpected=[0,4,6]
895 self.assertEqual(commExpected,list(comm.getValues()));
896 self.assertEqual(commIExpected,list(commI.getValues()));
897 o2n,newNbOfNodes=targetMesh.buildNewNumberingFromCommonNodesFormat(comm,commI);
898 self.assertEqual(31,o2n.getNumberOfTuples());
899 self.assertEqual(27,newNbOfNodes);
900 o2nExp2=[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,
901 21,22,23,24,25,26,1,1,1,23]
902 self.assertEqual(o2nExp2,list(o2n.getValues()));
904 targetMesh=MEDCouplingDataForTest.build3DTargetMesh_1();
905 time=targetMesh.getTimeOfThis();
906 o2n,areNodesMerged,newNbOfNodes=targetMesh.mergeNodes(1e-10);
907 targetMesh.updateTime();
908 self.assertEqual(time,targetMesh.getTimeOfThis());
909 self.assertTrue(not areNodesMerged);
911 targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
912 time=targetMesh.getTimeOfThis();
913 o2n,areNodesMerged,newNbOfNodes=targetMesh.mergeNodes(1e-10);
914 targetMesh.updateTime();
915 self.assertTrue(time!=targetMesh.getTimeOfThis());
916 self.assertTrue(areNodesMerged);
917 connExp=[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,
918 18,4,5,8,7,13,14,17,16,
919 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,
920 18,13,14,17,16,22,23,26,25]
921 self.assertEqual(72,targetMesh.getNodalConnectivity().getNumberOfTuples());
922 self.assertEqual(connExp,list(targetMesh.getNodalConnectivity().getValues()));
923 self.assertEqual(27,targetMesh.getCoords().getNumberOfTuples());
924 coordsExp=[ 0., 0., 0., 50., 0., 0. , 200., 0., 0. , 0., 50., 0., 50., 50., 0. ,
925 200., 50., 0., 0., 200., 0., 50., 200., 0. , 200., 200., 0. ,
926 0., 0., 50., 50., 0., 50. , 200., 0., 50. , 0., 50., 50., 50.,
927 50., 50. , 200., 50., 50., 0., 200., 50., 50., 200., 50. ,
928 200., 200., 50. , 0., 0., 200., 50., 0., 200. , 200., 0., 200.
929 , 0., 50., 200., 50., 50., 200. , 200., 50., 200.,
930 0., 200., 200., 50., 200., 200. , 200., 200., 200. ]
931 self.assertEqual(coordsExp,targetMesh.getCoords().getValues());
933 targetMesh=MEDCouplingDataForTest.build2DTargetMeshMergeNode_1();
934 self.assertEqual(18,targetMesh.getNumberOfNodes());
935 time=targetMesh.getTimeOfThis();
936 o2n,areNodesMerged,newNbOfNodes=targetMesh.mergeNodes(1e-10);
937 self.assertTrue(time!=targetMesh.getTimeOfThis());
938 self.assertTrue(areNodesMerged);
939 self.assertEqual(9,targetMesh.getNumberOfNodes());
940 connExp2=[4,0,4,3,1, 3,1,3,2, 3,3,5,2, 4,4,6,7,3, 4,7,8,5,3]
941 self.assertEqual(23,targetMesh.getNodalConnectivity().getNumberOfTuples());
942 self.assertEqual(connExp2,list(targetMesh.getNodalConnectivity().getValues()));
943 coordsExp2=[-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]
944 self.assertEqual(9,targetMesh.getCoords().getNumberOfTuples());
945 self.assertEqual(coordsExp2,targetMesh.getCoords().getValues());
948 def testCheckButterflyCells(self):
949 sourceMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
950 cells=sourceMesh.checkButterflyCells();
951 self.assertEqual(0,len(cells));
952 conn=sourceMesh.getNodalConnectivity()
954 conn.setIJ(15,0,conn.getIJ(16,0))
956 cells=sourceMesh.checkButterflyCells();
957 self.assertEqual(1,len(cells));
958 self.assertEqual([3],cells.getValues());
960 conn.setIJ(15,0,conn.getIJ(16,0))
962 cells=sourceMesh.checkButterflyCells();
963 self.assertEqual(0,len(cells));
965 sourceMesh=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
966 cells=sourceMesh.checkButterflyCells();
967 self.assertEqual(0,len(cells));
968 conn=sourceMesh.getNodalConnectivity()
970 conn.setIJ(15,0,conn.getIJ(16,0))
972 cells=sourceMesh.checkButterflyCells();
973 self.assertEqual(1,len(cells));
974 self.assertEqual([3],cells.getValues());
976 conn.setIJ(15,0,conn.getIJ(16,0))
978 cells=sourceMesh.checkButterflyCells();
979 self.assertEqual(0,len(cells));
982 def testMergeMesh1(self):
983 m1=MEDCouplingDataForTest.build2DTargetMesh_1();
984 m2=MEDCouplingDataForTest.build2DSourceMesh_1();
987 m3=m1.mergeMyselfWith(m2);
988 self.assertTrue(isinstance(m3,MEDCouplingUMesh));
989 m3.checkConsistencyLight();
990 m4=MEDCouplingDataForTest.build2DTargetMeshMerged_1();
991 self.assertTrue(m3.isEqual(m4,1.e-12));
992 da,isMerged,newNbOfNodes=m3.mergeNodes(1.e-12);
993 self.assertEqual(11,m3.getNumberOfNodes());
994 self.assertTrue(isMerged);
997 def testMergeMeshOnSameCoords1(self):
998 m1=MEDCouplingDataForTest.build2DTargetMesh_1();
999 m2=MEDCouplingDataForTest.build2DTargetMesh_1();
1000 cells = list(range(5));
1001 m2.convertToPolyTypes(cells);
1002 m1.tryToShareSameCoords(m2,1e-12);
1003 m3=MEDCouplingDataForTest.build2DTargetMesh_1();
1004 m3.tryToShareSameCoords(m2,1e-12);
1006 m4=MEDCouplingUMesh.MergeUMeshesOnSameCoords(meshes);
1007 m4.checkConsistencyLight();
1008 self.assertEqual(15,m4.getNumberOfCells());
1010 m1_1=m4.buildPartOfMySelf(cells1,True);
1011 m1_1.setName(m1.getName());
1012 self.assertTrue(m1.isEqual(m1_1,1e-12));
1014 m2_1=m4.buildPartOfMySelf(cells2,True);
1015 m2_1.setName(m2.getName());
1016 self.assertTrue(m2.isEqual(m2_1,1e-12));
1017 cells3=[10,11,12,13,14]
1018 m3_1=m4.buildPartOfMySelf(cells3,True);
1019 m3_1.setName(m3.getName());
1020 self.assertTrue(m3.isEqual(m3_1,1e-12));
1023 def testMergeField1(self):
1024 m1=MEDCouplingDataForTest.build2DTargetMesh_1();
1025 m2=MEDCouplingDataForTest.build2DSourceMesh_1();
1028 f1=m1.getMeasureField(True);
1029 f2=m2.getMeasureField(True);
1030 f3=MEDCouplingFieldDouble.MergeFields(f1,f2);
1031 f3.checkConsistencyLight();
1032 m4=MEDCouplingDataForTest.build2DTargetMeshMerged_1();
1033 m4.setName(f1.getMesh().getName())
1034 self.assertTrue(f3.getMesh().isEqual(m4,1.e-12));
1036 self.assertEqual(name,"MeasureOfMesh_");
1037 self.assertEqual(f3.getTypeOfField(),ON_CELLS);
1038 self.assertEqual(f3.getTimeDiscretization(),ONE_TIME);
1039 self.assertEqual(1,f3.getNumberOfComponents());
1040 self.assertEqual(7,f3.getNumberOfTuples());
1041 values=[0.25,0.125,0.125,0.25,0.25,0.5,0.5]
1042 tmp=f3.getArray().getValues();
1043 self.assertEqual(len(values),len(tmp))
1045 self.assertTrue(abs(values[i]-tmp[i])<1e-12)
1049 def testFillFromAnalytic(self):
1050 m=MEDCouplingDataForTest.build2DTargetMesh_1();
1051 m.setTime(3.4,5,6); m.setTimeUnit("us");
1052 f1=m.fillFromAnalytic(ON_CELLS,1,"x+y");
1053 self.assertAlmostEqual(3.4,f1.getTime()[0],12) ; self.assertEqual(5,f1.getTime()[1]) ; self.assertEqual(6,f1.getTime()[2])
1054 self.assertEqual("us",f1.getTimeUnit())
1055 f1.checkConsistencyLight();
1056 self.assertEqual(f1.getTypeOfField(),ON_CELLS);
1057 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1058 self.assertEqual(1,f1.getNumberOfComponents());
1059 self.assertEqual(5,f1.getNumberOfTuples());
1060 values1=[-0.1,0.23333333333333336,0.56666666666666665,0.4,0.9]
1061 tmp=f1.getArray().getValues();
1062 self.assertEqual(len(values1),len(tmp))
1063 for i in range(len(tmp)):
1064 self.assertTrue(abs(tmp[i]-values1[i])<1.e-12)
1067 f1=m.fillFromAnalytic(ON_NODES,1,"x+y");
1068 f1.checkConsistencyLight();
1069 self.assertEqual(f1.getTypeOfField(),ON_NODES);
1070 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1071 self.assertEqual(1,f1.getNumberOfComponents());
1072 self.assertEqual(9,f1.getNumberOfTuples());
1073 values2=[-0.6,-0.1,0.4,-0.1,0.4,0.9,0.4,0.9,1.4]
1074 tmp=f1.getArray().getValues();
1075 self.assertEqual(len(values2),len(tmp))
1076 for i in range(len(tmp)):
1077 self.assertTrue(abs(tmp[i]-values2[i])<1.e-12)
1080 f1=m.fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+(2*(x+y))*JVec");
1081 f1.checkConsistencyLight();
1082 self.assertEqual(f1.getTypeOfField(),ON_NODES);
1083 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1084 self.assertEqual(2,f1.getNumberOfComponents());
1085 self.assertEqual(9,f1.getNumberOfTuples());
1086 values3=[-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]
1087 tmp=f1.getArray().getValues();
1088 self.assertEqual(len(values3),len(tmp))
1089 for i in range(len(tmp)):
1090 self.assertTrue(abs(tmp[i]-values3[i])<1.e-12)
1092 values4=f1.accumulate();
1093 self.assertEqual(2,len(values4))
1094 self.assertTrue(abs(3.6-values4[0])<1.e-12);
1095 self.assertTrue(abs(7.2-values4[1])<1.e-12);
1096 values4=f1.integral(True);
1097 #0.4 == 0.25/4*-0.6+(0.25/4+0.125/3)*-0.1+0.4*(0.125/3.+0.125/3)+(-0.1)*(0.25/4+0.25/4)+0.4*(0.25/4+0.125/3+0.125/3+0.25/4+0.25/4)+0.9*(0.25/4+0.125/3)+0.4*0.25/4+0.9*(0.25/4+0.25/4)+1.4*0.25/4
1098 self.assertEqual(2,len(values4))
1099 self.assertTrue(abs(0.4-values4[0])<1.e-12);
1100 self.assertTrue(abs(0.8-values4[1])<1.e-12);
1102 self.assertRaises(InterpKernelException,m.fillFromAnalytic,ON_NODES,1,"1./(x-0.2)");
1105 def testFillFromAnalytic2(self):
1106 m=MEDCouplingDataForTest.build2DTargetMesh_1();
1107 f1=m.fillFromAnalytic(ON_CELLS,1,"y+x");
1108 f1.checkConsistencyLight();
1109 self.assertEqual(f1.getTypeOfField(),ON_CELLS);
1110 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1111 self.assertEqual(1,f1.getNumberOfComponents());
1112 self.assertEqual(5,f1.getNumberOfTuples());
1113 values1=[-0.1,0.23333333333333336,0.56666666666666665,0.4,0.9]
1114 tmp=f1.getArray().getValues();
1115 self.assertEqual(len(values1),len(tmp))
1116 for i in range(len(values1)):
1117 self.assertTrue(abs(values1[i]-tmp[i])<1.e-12);
1120 f1=m.fillFromAnalytic(ON_NODES,1,"y+2*x");
1121 f1.checkConsistencyLight();
1122 self.assertEqual(f1.getTypeOfField(),ON_NODES);
1123 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1124 self.assertEqual(1,f1.getNumberOfComponents());
1125 self.assertEqual(9,f1.getNumberOfTuples());
1126 values2=[-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1]
1127 tmp=f1.getArray().getValues();
1128 self.assertEqual(len(values2),len(tmp))
1129 for i in range(len(values2)):
1130 self.assertTrue(abs(values2[i]-tmp[i])<1.e-12);
1132 f1=m.fillFromAnalytic(ON_NODES,1,"2.*x+y");
1133 f1.checkConsistencyLight();
1134 self.assertEqual(f1.getTypeOfField(),ON_NODES);
1135 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1136 self.assertEqual(1,f1.getNumberOfComponents());
1137 self.assertEqual(9,f1.getNumberOfTuples());
1138 tmp=f1.getArray().getValues();
1139 values2Bis=[-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1]
1140 self.assertEqual(len(values2Bis),len(tmp))
1141 for i in range(len(values2Bis)):
1142 self.assertTrue(abs(values2Bis[i]-tmp[i])<1.e-12);
1145 f1=m.fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+2*(x+y)*JVec");
1146 f1.checkConsistencyLight();
1147 self.assertEqual(f1.getTypeOfField(),ON_NODES);
1148 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1149 self.assertEqual(2,f1.getNumberOfComponents());
1150 self.assertEqual(9,f1.getNumberOfTuples());
1151 values3=[-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]
1152 tmp=f1.getArray().getValues();
1153 self.assertEqual(len(values3),len(tmp))
1154 for i in range(len(values3)):
1155 self.assertTrue(abs(values3[i]-tmp[i])<1.e-12);
1157 values4=f1.accumulate();
1158 self.assertTrue(abs(3.6-values4[0])<1.e-12);
1159 self.assertTrue(abs(7.2-values4[1])<1.e-12);
1160 values4=f1.integral(True);
1161 self.assertTrue(abs(0.4-values4[0])<1.e-12);
1162 self.assertTrue(abs(0.8-values4[1])<1.e-12);
1165 def testApplyFunc(self):
1166 m=MEDCouplingDataForTest.build2DTargetMesh_1();
1167 f1=m.fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+(2*(x+y))*JVec");
1168 f1.checkConsistencyLight();
1169 self.assertEqual(f1.getTypeOfField(),ON_NODES);
1170 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1171 self.assertEqual(2,f1.getNumberOfComponents());
1172 self.assertEqual(9,f1.getNumberOfTuples());
1173 f1.applyFunc(1,"x+y");
1174 self.assertEqual(f1.getTypeOfField(),ON_NODES);
1175 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1176 self.assertEqual(1,f1.getNumberOfComponents());
1177 self.assertEqual(9,f1.getNumberOfTuples());
1178 values1=[-1.8,-0.3,1.2,-0.3,1.2,2.7,1.2,2.7,4.2]
1179 tmp=f1.getArray().getValues();
1180 self.assertEqual(len(values1),len(tmp))
1181 for i in range(len(tmp)):
1182 self.assertTrue(abs(tmp[i]-values1[i])<1.e-12)
1186 def testApplyFunc2(self):
1187 m=MEDCouplingDataForTest.build2DTargetMesh_1();
1188 f1=m.fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+2*(x+y)*JVec");
1189 f1.checkConsistencyLight();
1190 self.assertEqual(f1.getTypeOfField(),ON_NODES);
1191 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1192 self.assertEqual(2,f1.getNumberOfComponents());
1193 self.assertEqual(9,f1.getNumberOfTuples());
1196 self.assertRaises(InterpKernelException, f2.applyFunc, 1, "a+b+c+d");
1197 self.assertRaises(InterpKernelException, f2.applyFunc, 1, "a/0");
1198 self.assertRaises(InterpKernelException, f2.applyFunc, "a/0");
1199 f2.applyFunc("abs(u)^2.4+2*u");
1200 self.assertEqual(f1.getTypeOfField(),ON_NODES);
1201 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1202 self.assertEqual(2,f1.getNumberOfComponents());
1203 self.assertEqual(9,f1.getNumberOfTuples());
1204 values2=[-0.9065304805418678, -0.85105859001709905, -0.19601892829446504, -0.37898777756476987,
1205 0.91090317490482353, 2.1853504664669781, -0.19601892829446504, -0.37898777756476987,
1206 0.91090317490482353, 2.1853504664669781, 2.5765725275664879, 7.6987743736515295,
1207 0.91090317490482353, 2.1853504664669781, 2.5765725275664879, 7.6987743736515295,
1208 5.0423700574830965, 17.435300118916864]
1209 tmp=f2.getArray().getValues();
1210 self.assertEqual(len(tmp),len(values2))
1211 for i in range(len(tmp)):
1212 self.assertTrue(abs(tmp[i]-values2[i])<1.e-12)
1215 f1.applyFunc(1,"x+y");
1216 self.assertEqual(f1.getTypeOfField(),ON_NODES);
1217 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1218 self.assertEqual(1,f1.getNumberOfComponents());
1219 self.assertEqual(9,f1.getNumberOfTuples());
1220 values1=[-1.8,-0.3,1.2,-0.3,1.2,2.7,1.2,2.7,4.2]
1221 tmp=f1.getArray().getValues();
1222 self.assertEqual(len(tmp),len(values1))
1223 for i in range(len(tmp)):
1224 self.assertTrue(abs(tmp[i]-values1[i])<1.e-12)
1228 def testOperationsOnFields(self):
1229 m=MEDCouplingDataForTest.build2DTargetMesh_1();
1230 f1=m.fillFromAnalytic(ON_NODES,1,"x+y");
1231 f2=m.fillFromAnalytic(ON_NODES,1,"x+y");
1232 f1.checkConsistencyLight();
1233 f2.checkConsistencyLight();
1235 f3.checkConsistencyLight();
1236 self.assertEqual(f3.getTypeOfField(),ON_NODES);
1237 self.assertEqual(f3.getTimeDiscretization(),ONE_TIME);
1238 values1=[-1.2,-0.2,0.8,-0.2,0.8,1.8,0.8,1.8,2.8]
1239 tmp=f3.getArray().getValues();
1240 self.assertEqual(len(values1),len(tmp))
1241 for i in range(len(tmp)):
1242 self.assertTrue(abs(tmp[i]-values1[i])<1.e-12)
1246 f3.checkConsistencyLight();
1247 self.assertEqual(f3.getTypeOfField(),ON_NODES);
1248 self.assertEqual(f3.getTimeDiscretization(),ONE_TIME);
1249 values2=[0.36,0.01,0.16,0.01,0.16,0.81,0.16,0.81,1.96]
1250 tmp=f3.getArray().getValues();
1251 self.assertEqual(len(values2),len(tmp))
1252 for i in range(len(tmp)):
1253 self.assertTrue(abs(tmp[i]-values2[i])<1.e-12)
1258 f4.checkConsistencyLight();
1259 self.assertEqual(f4.getTypeOfField(),ON_NODES);
1260 self.assertEqual(f4.getTimeDiscretization(),ONE_TIME);
1261 values3=[0.6,0.1,-0.4,0.1,-0.4,-0.9,-0.4,-0.9,-1.4]
1262 tmp=f4.getArray().getValues();
1263 self.assertEqual(len(values3),len(tmp))
1264 for i in range(len(tmp)):
1265 self.assertTrue(abs(tmp[i]-values3[i])<1.e-12)
1270 f4.checkConsistencyLight();
1271 self.assertEqual(f4.getTypeOfField(),ON_NODES);
1272 self.assertEqual(f4.getTimeDiscretization(),ONE_TIME);
1273 tmp=f4.getArray().getValues();
1274 for i in range(len(tmp)):
1275 self.assertTrue(abs(tmp[i]-2.)<1.e-12)
1278 f4=f2.buildNewTimeReprFromThis(NO_TIME,False);
1279 f4.checkConsistencyLight();
1280 self.assertEqual(f4.getTypeOfField(),ON_NODES);
1281 self.assertEqual(f4.getTimeDiscretization(),NO_TIME);
1282 self.assertRaises(InterpKernelException,f1.__add__,f4);
1283 f5=f4.buildNewTimeReprFromThis(ONE_TIME,False);
1284 self.assertEqual(f5.getTypeOfField(),ON_NODES);
1285 self.assertEqual(f5.getTimeDiscretization(),ONE_TIME);
1287 tmp=f3.getArray().getValues();
1288 values4=[-1.2,-0.2,0.8,-0.2,0.8,1.8,0.8,1.8,2.8]
1289 self.assertEqual(len(values3),len(tmp))
1290 for i in range(len(tmp)):
1291 self.assertTrue(abs(tmp[i]-values4[i])<1.e-12)
1294 f4=f2.buildNewTimeReprFromThis(NO_TIME,True);
1295 f4.checkConsistencyLight();
1296 self.assertEqual(f4.getTypeOfField(),ON_NODES);
1297 self.assertEqual(f4.getTimeDiscretization(),NO_TIME);
1298 self.assertRaises(InterpKernelException,f1.__add__,f4);
1299 f5=f4.buildNewTimeReprFromThis(ONE_TIME,True);
1300 self.assertEqual(f5.getTypeOfField(),ON_NODES);
1301 self.assertEqual(f5.getTimeDiscretization(),ONE_TIME);
1303 tmp=f3.getArray().getValues();
1304 values5=[-1.2,-0.2,0.8,-0.2,0.8,1.8,0.8,1.8,2.8]
1305 self.assertEqual(len(values5),len(tmp))
1306 for i in range(len(tmp)):
1307 self.assertTrue(abs(tmp[i]-values5[i])<1.e-12)
1311 def testOperationsOnFields2(self):
1312 m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1313 m.setTime(3.4,5,6); m.setTimeUnit("us");
1314 f1=m.fillFromAnalytic(ON_NODES,1,"x+y+z");
1315 f2=m.fillFromAnalytic(ON_NODES,1,"a*a+b+c*c");
1317 f3.checkConsistencyLight();
1318 self.assertEqual(f3.getTypeOfField(),ON_NODES);
1319 self.assertEqual(f3.getTimeDiscretization(),ONE_TIME);
1320 expected1=[-2.4999999999999991, 1.2162162162162162, 0.77868852459016391,
1321 0.7407407407407407, 1.129032258064516, 0.81632653061224492,
1322 0.86538461538461531, 1.0919540229885056, 0.84302325581395343]
1323 self.assertEqual(1,f3.getNumberOfComponents());
1324 self.assertEqual(9,f3.getNumberOfTuples());
1325 val=f3.getArray().getValues();
1327 self.assertTrue(abs(expected1[i]-val[i])<1.e-12);
1329 f1=m.buildOrthogonalField();
1330 self.assertAlmostEqual(3.4,f1.getTime()[0],12) ; self.assertEqual(5,f1.getTime()[1]) ; self.assertEqual(6,f1.getTime()[2])
1331 self.assertEqual("us",f1.getTimeUnit())
1332 f2=m.fillFromAnalytic(ON_CELLS,1,"x");
1334 expected2=[-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]
1335 val=f3.getArray().getValues();
1337 self.assertTrue(abs(expected2[i]-val[i])<1.e-12);
1341 val=f3.getArray().getValues();
1343 self.assertTrue(abs(expected2[i]-val[i])<1.e-12);
1347 def testOperationsOnFields3(self):
1348 m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1349 f1=m.fillFromAnalytic(ON_NODES,1,"x+y+z");
1350 f2=m.fillFromAnalytic(ON_NODES,1,"a*a+b+c*c");
1352 f1.checkConsistencyLight();
1353 self.assertEqual(f1.getTypeOfField(),ON_NODES);
1354 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1355 expected1=[-2.4999999999999991, 1.2162162162162162, 0.77868852459016391,
1356 0.7407407407407407, 1.129032258064516, 0.81632653061224492,
1357 0.86538461538461531, 1.0919540229885056, 0.84302325581395343]
1358 self.assertEqual(1,f1.getNumberOfComponents());
1359 self.assertEqual(9,f1.getNumberOfTuples());
1360 val=f1.getArray().getValues();
1362 self.assertTrue(abs(expected1[i]-val[i])<1.e-12);
1365 f1=m.buildOrthogonalField();
1366 f2=m.fillFromAnalytic(ON_CELLS,1,"x");
1368 expected2=[-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]
1369 val=f1.getArray().getValues();
1371 self.assertTrue(abs(expected2[i]-val[i])<1.e-12);
1374 f1=m.buildOrthogonalField();
1375 # to avoid valgrind leaks
1376 # self.assertRaises(InterpKernelException,f2.__imul__,f1);
1379 def testOperationsOnFields4(self):
1380 m=MEDCouplingDataForTest.build2DTargetMesh_1();
1381 nbOfCells=m.getNumberOfCells();
1382 f1=MEDCouplingFieldDouble.New(ON_CELLS,CONST_ON_TIME_INTERVAL);
1384 array=DataArrayDouble.New();
1386 self.assertRaises(InterpKernelException,f1.setEndArray,array);
1387 self.assertRaises(InterpKernelException,f1.getEndArray);
1388 arr1=[0.,10.,20.,1.,11.,21.,2.,12.,22.,3.,13.,23.,4.,14.,24.]
1389 arr2=[5.,15.,25.,6.,16.,26.,7.,17.,27.,8.,18.,28.,9.,19.,29.]
1390 array.setValues(arr1,nbOfCells,3);
1391 f1.setStartTime(2.,0,0);
1392 f1.setEndTime(3.,0,0);
1393 f1.checkConsistencyLight();
1395 res=f1.getValueOn(pos);
1396 self.assertTrue(abs(arr1[3]-res[0])<1.e-12);
1397 self.assertTrue(abs(arr1[4]-res[1])<1.e-12);
1398 self.assertTrue(abs(arr1[5]-res[2])<1.e-12);
1400 res=f1.getValueOn(pos,2.2);
1401 self.assertTrue(abs(arr1[3]-res[0])<1.e-12);
1402 self.assertTrue(abs(arr1[4]-res[1])<1.e-12);
1403 self.assertTrue(abs(arr1[5]-res[2])<1.e-12);
1405 self.assertRaises(InterpKernelException,f1.getValueOn,pos,3.2)
1406 f2=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
1408 f2.setArray(f1.getArray());
1409 f2.setStartTime(2.,3,0);
1410 f2.setEndTime(4.,13,0);
1411 self.assertRaises(InterpKernelException,f2.checkConsistencyLight)
1412 array2=DataArrayDouble.New();
1413 array2.setValues(arr2,nbOfCells,3);
1414 f2.setEndArray(array2);
1415 f2.checkConsistencyLight();
1418 res=f2.getValueOn(pos,3.21);
1419 self.assertTrue(abs(4.025-res[0])<1.e-12);
1420 self.assertTrue(abs(14.025-res[1])<1.e-12);
1421 self.assertTrue(abs(24.025-res[2])<1.e-12);
1423 self.assertTrue(f2.isEqual(f3,1e-12,1e-12));
1424 f3.getEndArray().setIJ(0,0,5.001);
1425 self.assertTrue(not f2.isEqual(f3,1e-12,1e-12));
1426 self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1427 f3.setStartTime(2.1,3,0);
1428 self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1429 f3.setStartTime(2.,3,0);
1430 self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1431 f3.setStartTime(2.,4,0);
1432 self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1433 f3.setStartTime(2.,3,1);
1434 self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1435 f3.setStartTime(2.,3,0);
1436 self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1437 f3.setEndTime(4.1,13,0);
1438 self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1439 f3.setEndTime(4.,13,0);
1440 self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1441 f3.setEndTime(4.,14,0);
1442 self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1443 f3.setEndTime(4.,13,1);
1444 self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1445 f3.setEndTime(4.,13,0);
1446 self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1449 res=f4.getValueOn(pos,3.21);
1450 self.assertTrue(abs(8.05-res[0])<1.e-12);
1451 self.assertTrue(abs(28.05-res[1])<1.e-12);
1452 self.assertTrue(abs(48.05-res[2])<1.e-12);
1455 res=f4.getValueOn(pos,3.21);
1456 self.assertTrue(abs(12.075-res[0])<1.e-12);
1457 self.assertTrue(abs(42.075-res[1])<1.e-12);
1458 self.assertTrue(abs(72.075-res[2])<1.e-12);
1461 def testMergeNodesOnField(self):
1462 targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
1463 f1=targetMesh.fillFromAnalytic(ON_NODES,1,"x+y+z");
1464 f1.mergeNodes(1e-10);
1466 targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
1467 f1=targetMesh.fillFromAnalytic(ON_NODES,1,"x+y+z");
1469 tmp.setIJ(0,0,1000.);
1470 f1.mergeNodes(1e-10);
1472 targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
1473 f1=targetMesh.fillFromAnalytic(ON_NODES,1,"x+y+z");
1475 tmp.setIJ(1,0,1000.);
1476 self.assertRaises(InterpKernelException,f1.mergeNodes,1.e-10)
1479 def testCheckConsecutiveCellTypes(self):
1480 sourceMesh=MEDCouplingDataForTest.build2DSourceMesh_1();
1481 targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1482 self.assertTrue(sourceMesh.checkConsecutiveCellTypes());
1483 order1=[NORM_TRI3,NORM_QUAD4]
1484 order2=[NORM_QUAD4,NORM_TRI3]
1485 self.assertTrue(not targetMesh.checkConsecutiveCellTypes());
1486 self.assertTrue(not targetMesh.checkConsecutiveCellTypesAndOrder(order1));
1487 self.assertTrue(not targetMesh.checkConsecutiveCellTypesAndOrder(order2));
1488 da=targetMesh.getRenumArrForConsecutiveCellTypesSpec(order1);
1489 self.assertEqual(5,da.getNumberOfTuples());
1490 self.assertEqual(1,da.getNumberOfComponents());
1491 expected1=[2,0,1,3,4]
1492 self.assertTrue(expected1==list(da.getValues()));
1493 da=targetMesh.getRenumArrForConsecutiveCellTypesSpec(order2);
1494 self.assertEqual(5,da.getNumberOfTuples());
1495 self.assertEqual(1,da.getNumberOfComponents());
1496 expected2=[0,3,4,1,2]
1497 self.assertTrue(expected2==list(da.getValues()));
1498 renumber1=[4,0,1,2,3]
1499 targetMesh.renumberCells(renumber1,False);
1500 self.assertTrue(targetMesh.checkConsecutiveCellTypes());
1501 self.assertTrue(targetMesh.checkConsecutiveCellTypesAndOrder(order1));
1502 self.assertTrue(not targetMesh.checkConsecutiveCellTypesAndOrder(order2));
1505 def testRearrange2ConsecutiveCellTypes(self):
1506 m1_1=MEDCouplingDataForTest.build2DSourceMesh_1();
1507 m2_1=MEDCouplingDataForTest.build2DTargetMesh_1();
1508 arr1=m1_1.rearrange2ConsecutiveCellTypes();
1509 m1_2=MEDCouplingDataForTest.build2DSourceMesh_1();
1510 self.assertTrue(m1_2.isEqual(m1_1,1e-12));
1512 self.assertEqual(2,arr1.getNumberOfTuples());
1513 self.assertEqual(1,arr1.getNumberOfComponents());
1514 self.assertEqual(expected1,arr1.getValues());
1515 expected2=[0,3,4,1,2]
1516 arr1=m2_1.rearrange2ConsecutiveCellTypes();
1517 self.assertEqual(5,arr1.getNumberOfTuples());
1518 self.assertEqual(1,arr1.getNumberOfComponents());
1519 self.assertEqual(expected2,list(arr1.getValues()));
1520 m2_2=MEDCouplingDataForTest.build2DTargetMesh_1();
1521 self.assertEqual(5,arr1.getNumberOfTuples());
1522 self.assertEqual(1,arr1.getNumberOfComponents());
1523 self.assertEqual(expected2,list(arr1.getValues()));
1524 self.assertTrue(not m2_2.isEqual(m2_1,1e-12));
1525 m2_2.renumberCells(expected2,False);
1526 self.assertTrue(m2_2.isEqual(m2_1,1e-12));
1529 def testSplitByType(self):
1530 m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1532 self.assertEqual(3,len(v));
1533 m2=MEDCouplingUMesh.MergeUMeshesOnSameCoords(v);
1534 m2.setName(m1.getName());
1535 self.assertTrue(m1.isEqual(m2,1.e-12));
1538 def testFuseUMeshesOnSameCoords(self):
1539 m2=MEDCouplingDataForTest.build2DTargetMesh_1();
1541 m3=m2.buildPartOfMySelf(cells1,True);
1542 self.assertTrue(isinstance(m3,MEDCouplingUMesh))
1544 m4=m2.buildPartOfMySelf(cells2,True);
1545 self.assertTrue(isinstance(m4,MEDCouplingUMesh))
1547 m5=m2.buildPartOfMySelf(cells3,True);
1548 self.assertTrue(isinstance(m5,MEDCouplingUMesh))
1551 m7,corr=MEDCouplingUMesh.FuseUMeshesOnSameCoords(meshes,0);
1552 self.assertEqual(4,m7.getNumberOfCells());
1553 self.assertEqual(3,len(corr));
1554 expectedVals1=[3,3,2]
1555 expectedVals2=[[0,1,2],[3,0,2],[3,0]]
1558 self.assertEqual(1,arr.getNumberOfComponents());
1559 nbOfVals=expectedVals1[i];
1560 self.assertEqual(nbOfVals,arr.getNumberOfTuples());
1561 vals=arr.getValues();
1562 self.assertEqual(expectedVals2[i],list(vals));
1564 arr2,fidsOfGroups=DataArrayInt.MakePartition(corr,m7.getNumberOfCells());
1566 fidsGrp=[[1,3,5],[3,4,5],[4,5]]
1567 self.assertEqual(3,len(fidsOfGroups));
1568 self.assertEqual(1,arr2.getNumberOfComponents());
1569 self.assertEqual(4,arr2.getNumberOfTuples());
1570 self.assertEqual(fidExp,list(arr2.getValues()));
1572 nbOfVals=expectedVals1[i];
1573 self.assertEqual(list(fidsOfGroups[i]),fidsGrp[i]);
1577 def testFuseUMeshesOnSameCoords2(self):
1578 m1,m2=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
1580 m3=m1.buildPartOfMySelf(part1,True);
1582 m4=m1.buildPartOfMySelf(part2,True);
1583 meshes=[m1,m3,m3,m4]
1584 m5,corr=MEDCouplingUMesh.FuseUMeshesOnSameCoords(meshes,0);
1585 self.assertEqual(18,m5.getNumberOfCells());
1587 [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17],
1593 self.assertEqual(exp2[i],list(it.getValues()));
1598 def testBuildOrthogonalField(self):
1599 targetMesh=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1600 field=targetMesh.buildOrthogonalField();
1601 expected=[0.70710678118654746,0.,-0.70710678118654746]
1602 self.assertEqual(5,field.getNumberOfTuples());
1603 self.assertEqual(3,field.getNumberOfComponents());
1604 vals=field.getArray().getValues();
1606 self.assertTrue(abs(expected[i%3]-vals[i])<1e-12);
1608 targetCoords=[0.,0.,0.,0.5,0.,0.5,1.,0.,1.,0.,1.,0.]
1609 targetConn=[0,1,2,3]
1610 targetMesh=MEDCouplingUMesh.New();
1611 targetMesh.setMeshDimension(2);
1612 targetMesh.allocateCells(1);
1613 targetMesh.insertNextCell(NORM_QUAD4,targetConn[0:4])
1614 targetMesh.finishInsertingCells();
1615 myCoords=DataArrayDouble.New();
1616 myCoords.setValues(targetCoords,4,3);
1617 targetMesh.setCoords(myCoords);
1618 field=targetMesh.buildOrthogonalField();
1619 self.assertEqual(1,field.getNumberOfTuples());
1620 self.assertEqual(3,field.getNumberOfComponents());
1621 vals=field.getArray().getValues();
1622 self.assertTrue(abs(-0.70710678118654746-vals[0])<1e-12);
1623 self.assertTrue(abs(0.-vals[1])<1e-12);
1624 self.assertTrue(abs(0.70710678118654746-vals[2])<1e-12);
1627 def testGetCellsContainingPoint(self):
1628 targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1629 pos=[0.,0.,0.4,0.4,0.,0.4,0.1,0.1,0.25,0.,0.65,0.]
1631 t1,t2=targetMesh.getCellsContainingPoints(pos,6,1e-12);
1632 self.assertEqual(6,t1.getNumberOfTuples());
1633 self.assertEqual(1,t1.getNumberOfComponents());
1634 self.assertEqual(7,t2.getNumberOfTuples());
1635 self.assertEqual(1,t2.getNumberOfComponents());
1636 expectedValues1=[0,4,3,0,1,2]
1637 expectedValues2=[0,1,2,3,4,5,6]
1638 self.assertEqual(list(t1.getValues()),expectedValues1);
1639 self.assertEqual(list(t2.getValues()),expectedValues2);
1640 #2D with no help of bounding box.
1642 MEDCouplingPointSet.Rotate2DAlg(center,0.78539816339744830962,6,pos);
1643 targetMesh.rotate(center,0.78539816339744830962);
1646 t1,t2=targetMesh.getCellsContainingPoints(pos,1e-12);
1647 self.assertEqual(6,t1.getNumberOfTuples());
1648 self.assertEqual(7,t2.getNumberOfTuples());
1649 self.assertEqual(list(t1.getValues()),expectedValues1);
1650 self.assertEqual(list(t2.getValues()),expectedValues2);
1651 t1,t2=targetMesh.getCellsContainingPoints(DataArrayDouble.New(pos,6,2),1e-12);
1652 self.assertEqual(6,t1.getNumberOfTuples());
1653 self.assertEqual(7,t2.getNumberOfTuples());
1654 self.assertEqual(list(t1.getValues()),expectedValues1);
1655 self.assertEqual(list(t2.getValues()),expectedValues2);
1656 self.assertRaises(InterpKernelException,targetMesh.getCellsContainingPoints,DataArrayDouble.New(pos,4,3),1e-12);
1658 pos1bis=[-0.3303300858899107,-0.11819805153394641]
1659 self.assertEqual(-1,targetMesh.getCellContainingPoint(pos1bis,1e-12));
1661 targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1664 t1=targetMesh.getCellsContainingPoint(pos2,1e-12)
1665 self.assertEqual(2,len(t1));
1666 expectedValues3=[0,1]
1667 self.assertEqual(list(t1.getValues()),expectedValues3);
1670 t1=targetMesh.getCellsContainingPoint(pos3,1e-12);
1671 self.assertEqual(5,len(t1));
1672 expectedValues4=[0,1,2,3,4]
1673 self.assertEqual(list(t1.getValues()),expectedValues4);
1674 self.assertEqual(0,targetMesh.getCellContainingPoint(pos3,1e-12));
1676 targetMesh=MEDCouplingDataForTest.build3DTargetMesh_1();
1678 self.assertEqual(0,targetMesh.getCellContainingPoint(pos4,1e-12));
1681 t1=targetMesh.getCellsContainingPoint(pos5,1e-12);
1682 self.assertEqual(8,len(t1));
1683 expectedValues5=[0,1,2,3,4,5,6,7]
1684 self.assertEqual(list(t1.getValues()),expectedValues5);
1687 t1=targetMesh.getCellsContainingPoint(pos6,1e-12);
1688 self.assertEqual(2,len(t1));
1689 expectedValues6=[0,2]
1690 self.assertEqual(list(t1.getValues()),expectedValues6);
1693 self.assertEqual(-1,targetMesh.getCellContainingPoint(pos7,1e-12));
1697 targetMesh.rotate(center2,vec2,0.78539816339744830962);
1699 self.assertEqual(-1,targetMesh.getCellContainingPoint(pos8,1e-12));
1702 def testGetValueOn1(self):
1703 targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1704 fieldOnCells=MEDCouplingFieldDouble.New(ON_CELLS);
1705 nbOfCells=targetMesh.getNumberOfCells();
1706 fieldOnCells.setMesh(targetMesh);
1707 array=DataArrayDouble.New();
1708 tmp=2*nbOfCells*[None]
1709 for i in range(nbOfCells):
1710 tmp[2*i]=7.+float(i);
1711 tmp[2*i+1]=17.+float(i)
1713 array.setValues(tmp,nbOfCells,2);
1714 fieldOnCells.setArray(array);
1717 res=fieldOnCells.getValueOn(pos1);
1718 self.assertEqual(2,len(res))
1719 self.assertTrue(abs(8.-res[0])<1e-12);
1720 self.assertTrue(abs(18.-res[1])<1e-12);
1723 targetMesh=MEDCouplingDataForTest.build2DSourceMesh_1();
1724 fieldOnNodes=MEDCouplingFieldDouble.New(ON_NODES);
1725 nbOfNodes=targetMesh.getNumberOfNodes();
1726 fieldOnNodes.setMesh(targetMesh);
1727 array=DataArrayDouble.New();
1728 tmp=2*nbOfNodes*[None]
1729 for i in range(nbOfNodes):
1730 tmp[2*i]=17.+float(i);
1731 tmp[2*i+1]=27.+float(i)
1733 array.setValues(tmp,nbOfNodes,2);
1734 fieldOnNodes.setArray(array);
1736 pos2=[-0.13333333333333333,-0.13333333333333333]
1738 res=fieldOnNodes.getValueOn(pos2);
1739 self.assertEqual(2,len(res))
1740 self.assertTrue(abs(17.5-res[0])<1e-12);
1741 self.assertTrue(abs(27.5-res[1])<1e-12);
1742 pos3=[0.033333333333333326,0.36666666666666664]
1744 res=fieldOnNodes.getValueOn(pos3);
1745 self.assertEqual(2,len(res))
1746 self.assertTrue(abs(18.666666666666667-res[0])<1e-12);
1747 self.assertTrue(abs(28.666666666666667-res[1])<1e-12);
1750 def testCMesh0(self):
1751 mesh=MEDCouplingCMesh.New();
1752 meshEmpty=mesh.clone(True);
1753 self.assertTrue(meshEmpty.isEqual(mesh, 1e-12));
1755 coordsX=DataArrayDouble.New();
1756 arrX=[ -1., 1., 2., 4. ]
1757 coordsX.setValues(arrX, 4, 1);
1758 coordsY=DataArrayDouble.New();
1759 arrY=[ -2., 2., 4., 8. ]
1760 coordsY.setValues(arrY, 4, 1);
1761 coordsZ=DataArrayDouble.New();
1762 arrZ=[ -3., 3., 6., 12. ]
1763 coordsZ.setValues(arrZ, 4, 1);
1764 mesh.setCoords(coordsX, coordsY, coordsZ);
1766 fieldOnNodes=mesh.fillFromAnalytic(ON_NODES, 1, "x+y/2.+z/3.");
1767 self.assertEqual(1, fieldOnNodes.getNumberOfComponents());
1768 self.assertEqual(64, fieldOnNodes.getNumberOfTuples());
1769 expected1=[-3., -1., 0., 2., -1., 1., 2., 4., 0., 2., 3., 5., 2., 4., 5., 7., -1., 1., 2.,
1770 4., 1., 3., 4., 6., 2., 4., 5., 7., 4., 6., 7., 9., 0., 2., 3., 5., 2., 4., 5.,
1771 7., 3., 5., 6., 8., 5., 7., 8., 10., 2., 4., 5.,
1772 7., 4., 6., 7., 9., 5., 7., 8., 10., 7., 9., 10., 12.];
1774 val=fieldOnNodes.getArray().getValues();
1776 self.assertAlmostEqual(expected1[i], val[i], 12)
1777 res=fieldOnNodes.getValueOnPos(1, 3, 2);
1778 self.assertAlmostEqual(7., res[0], 12);
1780 fieldOnCells=mesh.fillFromAnalytic(ON_CELLS, 1, "x+y/2.+z/3.");
1781 self.assertEqual(1, fieldOnCells.getNumberOfComponents());
1782 self.assertEqual(27, fieldOnCells.getNumberOfTuples());
1783 val=fieldOnCells.getArray().getValues();
1784 expected2=[0, 1.5, 3, 1.5, 3, 4.5, 3, 4.5, 6, 1.5, 3, 4.5, 3, 4.5,
1785 6, 4.5, 6, 7.5, 3, 4.5, 6, 4.5, 6, 7.5, 6, 7.5, 9];
1787 self.assertAlmostEqual(expected2[i], val[i], 12);
1788 #res=fieldOnCells.getValueOnPos(1,2,1);
1789 #self.assertAlmostEqual(6.,res,12);
1791 meshDeepCopy=mesh.deepCopy();
1792 meshClone=mesh.clone(False);
1794 meshEmpty.copyTinyStringsFrom(mesh);
1795 #no data in meshEmpty, expected False
1796 self.assertTrue(not meshEmpty.isEqual(mesh, 1e-12));
1798 self.assertTrue(meshDeepCopy.isEqual(mesh, 1e-12));
1799 meshDeepCopy.copyTinyStringsFrom(mesh);
1800 self.assertTrue(meshDeepCopy.isEqual(mesh, 1e-12));
1801 self.assertTrue(meshClone.isEqual(mesh, 1e-12));
1803 self.assertEqual(CARTESIAN, mesh.getType());
1804 self.assertEqual(CARTESIAN, meshEmpty.getType());
1805 self.assertEqual(CARTESIAN, meshDeepCopy.getType());
1806 self.assertEqual(CARTESIAN, meshClone.getType());
1809 def testCMesh1(self):
1810 mesh1=MEDCouplingCMesh.New();
1811 coordsX1=DataArrayDouble.New();
1812 arrX1=[ -1., 1., 2., 4. ]
1813 coordsX1.setValues(arrX1, 4, 1);
1814 coordsY1=DataArrayDouble.New();
1815 arrY1=[ -2., 2., 4., 8. ]
1816 coordsY1.setValues(arrY1, 4, 1);
1817 coordsZ1=DataArrayDouble.New();
1818 arrZ1=[ -3., 3., 6., 12. ]
1819 coordsZ1.setValues(arrZ1, 4, 1);
1820 mesh1.setCoords(coordsX1, coordsY1, coordsZ1);
1822 mesh2=MEDCouplingCMesh.New();
1823 coordsX2=DataArrayDouble.New();
1824 arrX2=[ -1., 1., 2., 4. ]
1825 coordsX2.setValues(arrX2, 4, 1);
1826 coordsY2=DataArrayDouble.New();
1827 arrY2=[ -2., 2., 4., 8. ]
1828 coordsY2.setValues(arrY2, 4, 1);
1829 coordsZ2=DataArrayDouble.New();
1830 arrZ2=[ -3., 3., 6., 12.+1e-6 ]
1831 coordsZ2.setValues(arrZ2, 4, 1);
1832 mesh2.setCoords(coordsX2, coordsY2, coordsZ2);
1834 mesh3=MEDCouplingCMesh.New();
1835 coordsX3=DataArrayDouble.New();
1837 coordsX3.setValues(arrX3, 1, 1);
1838 coordsY3=DataArrayDouble.New();
1840 coordsY3.setValues(arrY3, 1, 1);
1841 coordsZ3=DataArrayDouble.New();
1843 coordsZ3.setValues(arrZ3, 1, 1);
1844 mesh3.setCoords(coordsX3, coordsY3, coordsZ3);
1846 self.assertEqual(3, mesh1.getSpaceDimension());
1847 self.assertEqual(3, mesh1.getMeshDimension());
1849 self.assertTrue(not mesh1.isEqual(mesh2, 1e-12));
1850 self.assertTrue(not mesh2.isEqual(mesh1, 1e-12));
1851 self.assertTrue(not mesh2.isEqualWithoutConsideringStr(mesh1, 1e-12));
1852 self.assertTrue(mesh1.isEqual(mesh2, 1e-5));
1853 self.assertTrue(not mesh1.isEqual(mesh2, 1e-7));
1855 self.assertRaises(InterpKernelException, mesh3.checkConsistency, 1e-12);
1856 mesh1.checkConsistency(1e-12);
1857 self.assertEqual(NORM_HEXA8, mesh1.getTypeOfCell(1));
1859 self.assertEqual(NORM_HEXA8, mesh1.getAllGeoTypes()[0]);
1860 self.assertEqual(27, mesh1.getNumberOfCellsWithType(NORM_HEXA8));
1861 self.assertRaises(InterpKernelException, mesh1.getNumberOfCellsWithType, NORM_QUAD4);
1863 coo=mesh1.getCoordinatesOfNode(0);
1864 self.assertEqual(3, len(coo));
1865 self.assertAlmostEqual(-1., coo[0], 14);
1866 self.assertAlmostEqual(-2., coo[1], 14);
1867 self.assertAlmostEqual(-3., coo[2], 14);
1868 coo=mesh1.getCoordinatesOfNode(63);
1869 self.assertEqual(3, len(coo));
1870 self.assertAlmostEqual(4., coo[0], 14);
1871 self.assertAlmostEqual(8., coo[1], 14);
1872 self.assertAlmostEqual(12., coo[2], 14);
1875 repr=mesh1.simpleRepr();
1876 repr=mesh1.advancedRepr();
1877 self.assertTrue("Cartesian" in repr);
1878 self.assertTrue("Number of components : 1" in repr);
1879 self.assertTrue("Number of tuples : 4" in repr);
1880 self.assertTrue("Z Array :" in repr);
1883 def testCMesh2(self):
1884 mesh1=MEDCouplingCMesh.New();
1885 coordsX1=DataArrayDouble.New();
1886 arrX1=[ -1., 1., 2., 4. ]
1887 coordsX1.setValues(arrX1, 4, 1);
1888 coordsY1=DataArrayDouble.New();
1889 arrY1=[ -2., 2., 4., 8. ]
1890 coordsY1.setValues(arrY1, 4, 1);
1891 coordsZ1=DataArrayDouble.New();
1892 arrZ1=[ -3., 3., 6., 12. ]
1893 coordsZ1.setValues(arrZ1, 4, 1);
1894 mesh1.setCoords(coordsX1, coordsY1, coordsZ1);
1896 dis=mesh1.getDistributionOfTypes();
1897 self.assertEqual(1, len(dis));
1898 self.assertEqual(NORM_HEXA8, dis[0][0]);
1899 self.assertEqual(27, dis[0][1]);
1900 self.assertEqual(-1, dis[0][2]);
1903 self.assertTrue(not mesh1.checkTypeConsistencyAndContig(dis, idsPerType));
1904 dis[0][0]=NORM_QUAD4;
1905 self.assertRaises(InterpKernelException, mesh1.checkTypeConsistencyAndContig, dis, idsPerType);
1906 dis[0][0]=NORM_HEXA8;
1908 ids=DataArrayInt.New();
1910 ids.fillWithValue(23);
1912 check=mesh1.checkTypeConsistencyAndContig(dis, idsPerType);
1913 self.assertTrue(check);
1914 self.assertTrue(check.isEqual(ids));
1916 code, idsInPflPerType, pfls=mesh1.splitProfilePerType(ids);
1917 self.assertEqual(1, len(code));
1918 self.assertEqual(NORM_HEXA8, code[0][0]);
1919 self.assertEqual(10, code[0][1]);
1920 self.assertEqual(0, code[0][2]);
1921 self.assertEqual(1, len(idsInPflPerType));
1922 self.assertEqual(1, len(pfls));
1923 self.assertTrue(idsInPflPerType[0].isEqual(DataArrayInt([0,1,2,3,4,5,6,7,8,9])));
1924 self.assertTrue(pfls[0].isEqual(ids));
1926 cells1=[0, 1, 25, 26]
1927 partMesh1=mesh1.buildPart(cells1)
1928 self.assertTrue(isinstance(partMesh1,MEDCouplingMesh))
1929 self.assertEqual(4, partMesh1.getNumberOfCellsWithType(NORM_HEXA8));
1930 self.assertEqual(64, mesh1.getNumberOfNodes());
1931 self.assertEqual(64, partMesh1.getNumberOfNodes());
1934 partMesh2, arr1=mesh1.buildPartAndReduceNodes(cells2)
1935 self.assertTrue(isinstance(partMesh2,MEDCouplingCMesh))
1936 self.assertEqual(2,partMesh2.getNumberOfCellsWithType(NORM_HEXA8));
1937 self.assertEqual(12,partMesh2.getNumberOfNodes());
1940 partMesh3, arr2=partMesh1.buildPartAndReduceNodes(cells3)
1941 self.assertTrue(isinstance(partMesh3,MEDCouplingUMesh))
1942 self.assertEqual(2, partMesh3.getNumberOfCellsWithType(NORM_HEXA8));
1943 self.assertEqual(12, partMesh3.getNumberOfNodes());
1945 self.assertRaises(InterpKernelException, mesh1.simplexize, 0);
1946 self.assertRaises(InterpKernelException, mesh1.getMeasureFieldOnNode, True);
1950 bbox1=mesh1.getBoundingBox(); #[(-1.0, 4.0), (-2.0, 8.0), (-3.0, 12.0)]
1951 bbox2=partMesh1.getBoundingBox();
1952 self.assertTrue(bbox1==bbox2);
1953 bbox1=partMesh3.getBoundingBox();
1954 bbox2=partMesh2.getBoundingBox();
1955 self.assertTrue(bbox1==bbox2);
1957 self.assertRaises(InterpKernelException, mesh1.buildOrthogonalField);
1958 mesh2d=MEDCouplingCMesh.New();
1959 mesh2d.setCoords(coordsX1, coordsY1);
1960 f1=mesh2d.buildOrthogonalField();
1964 def testScale(self):
1965 mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1967 mesh.scale(pos,0.5);
1968 expected1=[-0.05,-0.05, 0.2,-0.05, 0.45,-0.05, -0.05,0.2, 0.2,0.2, 0.45,0.2,
1969 -0.05,0.45, 0.2,0.45, 0.45,0.45]
1970 val=mesh.getCoords().getValues();
1971 self.assertEqual(18,len(val))
1973 self.assertTrue(abs(expected1[i]-val[i])<1e-12);
1977 def testTryToShareSameCoords(self):
1978 m1=MEDCouplingDataForTest.build2DTargetMesh_1();
1979 m2=MEDCouplingDataForTest.build2DTargetMesh_1();
1980 self.assertTrue(m1.getCoords().getHiddenCppPointer()!=m2.getCoords().getHiddenCppPointer());
1981 m1.tryToShareSameCoords(m2,1e-12);
1982 self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1983 m1.tryToShareSameCoords(m2,1e-12);
1984 self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1985 m2.tryToShareSameCoords(m1,1e-12);
1986 self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1988 m1=MEDCouplingDataForTest.build2DTargetMesh_1();
1989 m2=MEDCouplingDataForTest.build2DTargetMesh_2();
1990 self.assertTrue(m1.getCoords().getHiddenCppPointer()!=m2.getCoords().getHiddenCppPointer());
1991 m1.tryToShareSameCoords(m2,1e-12);
1992 self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1993 m1.tryToShareSameCoords(m2,1e-12);
1994 self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1995 m2.tryToShareSameCoords(m1,1e-12);
1996 self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1998 m1=MEDCouplingDataForTest.build2DTargetMesh_1();
1999 m2=MEDCouplingDataForTest.build2DSourceMesh_1();
2000 self.assertTrue(m1.getCoords().getHiddenCppPointer()!=m2.getCoords().getHiddenCppPointer());
2001 self.assertRaises(InterpKernelException,m1.tryToShareSameCoords,m2,1e-12)
2004 def testFindNodeOnPlane(self):
2005 mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
2008 n=mesh.findNodesOnPlane(pt,v,1e-12);
2009 self.assertEqual(9,len(n));
2010 m3dSurf=mesh.buildFacePartOfMySelfNode(n,True);
2011 self.assertTrue(isinstance(m3dSurf,MEDCouplingUMesh))
2012 me=MEDCouplingMappedExtrudedMesh.New(mesh,m3dSurf,0);
2013 da=me.getMesh3DIds();
2014 self.assertEqual(8,me.getNumberOfCells());
2015 expected=[0,1,2,3,4,5,6,7]
2017 self.assertEqual(expected,list(val));
2019 m3dSurf=mesh.buildFacePartOfMySelfNode(n,True);
2020 self.assertTrue(isinstance(m3dSurf,MEDCouplingUMesh))
2021 me=MEDCouplingMappedExtrudedMesh.New(mesh,m3dSurf,0);
2022 da=me.getMesh3DIds();
2023 self.assertEqual(8,me.getNumberOfCells());
2024 expected=[0,1,2,3,4,5,6,7]
2026 self.assertEqual(expected,list(val));
2029 def testRenumberCells(self):
2030 m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2031 m2=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2032 self.assertTrue(m.isEqual(m2,0));
2034 m.renumberCells(arr,True);
2035 self.assertTrue(not m.isEqual(m2,0));
2036 self.assertEqual(NORM_QUAD4,m.getTypeOfCell(0));
2037 self.assertEqual(NORM_TRI3,m.getTypeOfCell(1));
2038 self.assertEqual(NORM_QUAD4,m.getTypeOfCell(2));
2039 self.assertEqual(NORM_TRI3,m.getTypeOfCell(3));
2040 self.assertEqual(NORM_QUAD4,m.getTypeOfCell(4));
2042 m.renumberCells(arr2,True);
2043 self.assertTrue(m.isEqual(m2,0));
2046 def testChangeSpaceDimension(self):
2047 m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2048 m2=MEDCouplingDataForTest.build2DTargetMesh_1();
2050 self.assertEqual(3,m1.getSpaceDimension());
2051 m1.changeSpaceDimension(2);
2052 self.assertEqual(2,m1.getSpaceDimension());
2053 m1.setName(m2.getName());
2054 self.assertTrue(m1.isEqual(m2,1e-12));
2055 m1.changeSpaceDimension(3);
2056 self.assertEqual(3,m1.getSpaceDimension());
2057 expected=[-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.]
2058 val=m1.getCoords().getValues();
2060 self.assertTrue(abs(expected[i]-val[i])<1e-14);
2064 def testGaussPointField1(self):
2065 _a=0.446948490915965;
2066 _b=0.091576213509771;
2067 _p1=0.11169079483905;
2068 _p2=0.0549758718227661;
2069 refCoo1=[ 0.,0., 1.,0., 0.,1. ]
2070 gsCoo1=[ 2*_b-1, 1-4*_b, 2*_b-1, 2.07*_b-1, 1-4*_b,
2071 2*_b-1, 1-4*_a, 2*_a-1, 2*_a-1, 1-4*_a, 2*_a-1, 2*_a-1 ]
2072 wg1=[ 4*_p2, 4*_p2, 4*_p2, 4*_p1, 4*_p1, 4*_p1 ]
2077 m=MEDCouplingDataForTest.build2DTargetMesh_1();
2078 f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,NO_TIME);
2080 self.assertEqual(5,f.getNumberOfMeshPlacesExpected());
2081 self.assertEqual(0,f.getNbOfGaussLocalization());
2082 f.setGaussLocalizationOnType(NORM_TRI3,_refCoo1,_gsCoo1,_wg1);
2083 f.setGaussLocalizationOnType(NORM_TRI3,_refCoo1,_gsCoo1,_wg1); # not a bug only to check that it works well
2084 self.assertRaises(InterpKernelException,f.setGaussLocalizationOnType,NORM_QUAD4,_refCoo1,_gsCoo1,_wg1)
2085 self.assertEqual(1,f.getNbOfGaussLocalization());
2086 refCoo2=[ 0.,0., 1.,0., 1.,1., 0.,1. ]
2088 _gsCoo1=_gsCoo1[0:4]
2090 f.setGaussLocalizationOnType(NORM_QUAD4,_refCoo2,_gsCoo1,_wg1);
2091 self.assertEqual(2,f.getNbOfGaussLocalization());
2092 array=DataArrayDouble.New();
2094 for i in range(18 * 2):
2096 array.setValues(ptr,18,2);
2097 ptr=array.getPointer();
2099 f.setName("MyFirstFieldOnGaussPoint");
2100 f.checkConsistencyLight();
2101 self.assertAlmostEqual(27.,f.getIJK(2,5,0),14);
2102 self.assertAlmostEqual(16.,f.getIJK(1,5,1),14);
2104 f.clearGaussLocalizations();
2105 self.assertEqual(0,f.getNbOfGaussLocalization());
2106 self.assertRaises(InterpKernelException,f.checkConsistencyLight);
2108 self.assertRaises(InterpKernelException,f.setGaussLocalizationOnCells,ids1,_refCoo2,_gsCoo1,_wg1);
2109 self.assertEqual(0,f.getNbOfGaussLocalization());
2111 f.setGaussLocalizationOnCells(ids2,_refCoo2,_gsCoo1,_wg1);
2112 self.assertEqual(1,f.getNbOfGaussLocalization());
2113 self.assertEqual(0,f.getGaussLocalizationIdOfOneCell(0));
2114 self.assertRaises(InterpKernelException,f.getGaussLocalizationIdOfOneCell,1);
2116 f.setGaussLocalizationOnCells(ids3,_refCoo1,_gsCoo1,_wg1);
2117 self.assertEqual(2,f.getNbOfGaussLocalization());
2118 self.assertEqual(0,f.getGaussLocalizationIdOfOneCell(0));
2119 self.assertEqual(1,f.getGaussLocalizationIdOfOneCell(1));
2120 self.assertEqual(1,f.getGaussLocalizationIdOfOneCell(2));
2121 self.assertRaises(InterpKernelException,f.checkConsistencyLight);#<- cell 3 has no localization
2125 _gsCoo2[0]=0.8888777776666;
2126 _wg2[0]=0.1234567892377;
2127 f.setGaussLocalizationOnCells(ids4,_refCoo2,_gsCoo2,_wg2);
2128 self.assertEqual(3,f.getNbOfGaussLocalization());
2129 tmpIds=f.getCellIdsHavingGaussLocalization(0);
2130 self.assertEqual(ids2,list(tmpIds.getValues()));
2131 self.assertRaises(InterpKernelException,f.checkConsistencyLight);#<- it's always not ok because undelying array not with the good size.
2132 array2=f.getArray().subArray(0,10);
2134 f.checkConsistencyLight();#<- here it is OK
2136 self.assertTrue(f.isEqual(f2,1e-14,1e-14));
2137 gl1=f2.getGaussLocalization(0);
2138 tmp=gl1.getGaussCoord(1,1);
2139 self.assertAlmostEqual(2.07*_b-1,tmp,14);
2140 gl1.setGaussCoord(1,1,0.07);
2141 self.assertTrue(not f.isEqual(f2,1e-14,1e-14));
2142 gl1.setGaussCoord(1,1,tmp);
2143 self.assertTrue(f.isEqual(f2,1e-14,1e-14));
2144 f2.checkConsistencyLight();
2147 def testGaussPointNEField1(self):
2148 m=MEDCouplingDataForTest.build2DTargetMesh_1();
2149 f=MEDCouplingFieldDouble.New(ON_GAUSS_NE,NO_TIME);
2151 self.assertEqual(5,f.getNumberOfMeshPlacesExpected());
2152 f.setName("MyFirstFieldOnNE");
2153 f.setDescription("MyDescriptionNE");
2154 array=DataArrayDouble.New();
2156 for i in range(18 * 2):
2159 array.setValues(tmp,18,2);
2160 ptr=array.getPointer();
2163 f.checkConsistencyLight();
2165 self.assertTrue(f.isEqual(f2,1e-14,1e-14));
2166 self.assertAlmostEqual(21.,f.getIJK(2,0,0),14);
2167 self.assertAlmostEqual(18.,f.getIJK(1,1,1),14);
2170 def testCellOrientation1(self):
2171 m=MEDCouplingDataForTest.build2DTargetMesh_1();
2173 self.assertRaises(InterpKernelException,m.are2DCellsNotCorrectlyOriented,vec,False);
2174 m.changeSpaceDimension(3);
2175 res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2176 self.assertTrue(len(res1)==0);
2178 res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2179 self.assertEqual(5,len(res1));
2182 # connectivity inversion
2183 conn=m.getNodalConnectivity().getValues();
2187 m.getNodalConnectivity().setValues(conn,len(conn),1)
2188 res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2189 self.assertEqual(1,len(res1));
2190 self.assertEqual(2,res1.getValues()[0]);
2191 m.orientCorrectly2DCells(vec,False);
2192 res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2193 self.assertTrue(len(res1)==0);
2194 m2=MEDCouplingDataForTest.build2DTargetMesh_1();
2195 m2.changeSpaceDimension(3);
2196 self.assertTrue(m.isEqual(m2,1e-12));
2199 def testCellOrientation2(self):
2200 m2,m1=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
2201 res1=m2.arePolyhedronsNotCorrectlyOriented();
2202 self.assertEqual(6,len(res1));
2203 m2.orientCorrectlyPolyhedrons();
2204 res1=m2.arePolyhedronsNotCorrectlyOriented();
2205 self.assertTrue(len(res1)==0);
2206 m2.checkConsistencyLight();
2207 self.assertEqual(18,m2.getNumberOfCells());
2209 m2.convertToPolyTypes(cellIds2);
2210 m2.orientCorrectlyPolyhedrons();
2211 res1=m2.arePolyhedronsNotCorrectlyOriented();
2212 self.assertTrue(len(res1)==0);
2213 f2=m2.getMeasureField(False);
2214 f2Ptr=f2.getArray().getValues();
2215 #Test to check global reverse in MEDCouplingUMesh::tryToCorrectPolyhedronOrientation
2216 m3=MEDCouplingDataForTest.build2DTargetMesh_1();
2218 m3.changeSpaceDimension(3);
2220 m3.convertToPolyTypes(ids2);
2221 m3.orientCorrectly2DCells(vec,False);
2222 m4=MEDCouplingDataForTest.buildCU1DMesh_U();
2223 m4.changeSpaceDimension(3);
2226 m4.rotate(center,vector,-pi/2.);
2227 m5=m3.buildExtrudedMesh(m4,0);
2228 res1=m5.arePolyhedronsNotCorrectlyOriented();
2229 self.assertEqual(15,len(res1));
2230 m5.orientCorrectlyPolyhedrons();
2231 res1=m5.arePolyhedronsNotCorrectlyOriented();
2232 self.assertTrue(len(res1)==0);
2233 f3=m5.getMeasureField(False);
2234 self.assertEqual(15,f3.getArray().getNumberOfTuples());
2235 self.assertEqual(1,f3.getNumberOfComponents());
2236 f3Ptr=f3.getArray().getValues();
2237 expected1=[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];
2239 self.assertTrue(abs(expected1[i]-f3Ptr[i])<1e-12);
2241 f4=m5.computeCellCenterOfMass();
2242 self.assertEqual(15,f4.getNumberOfTuples());
2243 self.assertEqual(3,f4.getNumberOfComponents());
2244 f4Ptr=f4.getValues();
2245 expected2=[-0.05,-0.05,0.15, 0.3666666666666667,-0.13333333333333333,0.15, 0.53333333333333333,0.033333333333333333,0.15, -0.05,0.45,0.15, 0.45,0.45,0.15,-0.05,-0.05,0.525, 0.3666666666666667,-0.13333333333333333,0.525, 0.53333333333333333,0.033333333333333333,0.525, -0.05,0.45,0.525, 0.45,0.45,0.525,-0.05,-0.05,0.875, 0.3666666666666667,-0.13333333333333333,0.875, 0.53333333333333333,0.033333333333333333,0.875, -0.05,0.45,0.875, 0.45,0.45,0.875];
2247 self.assertTrue(abs(expected2[i]-f4Ptr[i])<1e-12);
2251 def testCellOrientation3(self):
2252 from cmath import rect
2254 c = [rect(1.0, i * pi / 4.0) for i in range(8)]
2255 coords = [c[-1].real,c[-1].imag, c[3].real,c[3].imag,
2256 c[5].real,c[5].imag, c[1].real,c[1].imag]
2258 baseMesh = MEDCouplingUMesh.New("circle", 2)
2259 baseMesh.allocateCells(1)
2260 meshCoords = DataArrayDouble.New(coords, 4, 2)
2261 baseMesh.setCoords(meshCoords)
2262 baseMesh.insertNextCell(NORM_QPOLYG, connec) # a circle
2263 baseMesh.finishInsertingCells()
2264 baseMesh.changeSpaceDimension(3)
2265 Oz = [0.0, 0.0, -1.0]
2266 cell_lst = baseMesh.are2DCellsNotCorrectlyOriented(Oz, False)
2267 self.assertEqual(cell_lst.getNumberOfTuples(), 0)
2269 cell_lst = baseMesh.are2DCellsNotCorrectlyOriented(Oz, False)
2270 self.assertEqual(cell_lst.getNumberOfTuples(), 1)
2272 def testCellOrientation4(self):
2273 """ Non regression for NORM_QPOLYG whose linear version is self-intersecting. """
2274 mesh = MEDCouplingUMesh('merge', 2)
2275 coo = DataArrayDouble([(38.45,0),(37.8659,6.67677),(38.57,0),(38.51,0),(38.3563,2.68214),(38.4266,1.34189),(38.0758,5.35121),(38.2394,4.01912),(37.6098,7.9942),(37.1398,9.95159),(37.2558,9.98265),(38.24,5.0344),(37.1978,9.96712),(37.3876,8.97597)])
2277 c = DataArrayInt([32, 9, 8, 6, 4, 0, 2, 10, 13, 1, 7, 5, 3, 11, 12])
2278 cI = DataArrayInt([0, 15])
2279 mesh.setConnectivity(c, cI)
2281 mesh.changeSpaceDimension(3)
2282 mesh.orientCorrectly2DCells(vec, False)
2283 mesh.changeSpaceDimension(2)
2284 cRef = [32, 9, 10, 2, 0, 4, 6, 8, 12, 11, 3, 5, 7, 1, 13]
2286 self.assertEqual(mesh.getNodalConnectivity().getValues(), cRef)
2287 self.assertEqual(mesh.getNodalConnectivityIndex().getValues(), cIRef)
2290 def testCellOrientation5(self):
2291 """ Non regression for NORM_QPOLYG """
2292 mesh = MEDCouplingUMesh('Mesh_3', 2)
2293 coo = DataArrayDouble([(-34.3035,5.1),(-35.2018,4.59163),(-34.9509,6.21985),(-35.0858,5.4072),(-34.7527,4.84582),(-34.6641,5.63857)])
2295 c = DataArrayInt([6, 2, 1, 0, 3, 4, 5])
2296 cI = DataArrayInt([0, 7])
2297 mesh.setConnectivity(c, cI)
2299 mesh.changeSpaceDimension(3)
2300 mesh.orientCorrectly2DCells(vec, False)
2301 mesh.changeSpaceDimension(2)
2302 cRef = [6, 2, 0, 1, 5, 4, 3]
2304 self.assertEqual(mesh.getNodalConnectivity().getValues(), cRef)
2305 self.assertEqual(mesh.getNodalConnectivityIndex().getValues(), cIRef)
2306 # Second call doest not change anything:
2307 mesh.changeSpaceDimension(3)
2308 mesh.orientCorrectly2DCells(vec, False)
2309 mesh.changeSpaceDimension(2)
2310 self.assertEqual(mesh.getNodalConnectivity().getValues(), cRef)
2311 self.assertEqual(mesh.getNodalConnectivityIndex().getValues(), cIRef)
2314 def testCellOrientation6(self):
2315 # CCTP 2.3.1 (bos #26452)
2316 mesh = MEDCouplingUMesh('Orientation', 3)
2317 coo = [0,0,0, 0,10,0, 10,0,0, 10,10,0, -10,0,0, -10,10,-0, 0,0,10, 10,0,10, -10,0,10, 0,-10,0, 10,-10,0, -10,-10,0, 0,5,0, 5,0,0, 10,5,0, 5,10,0, -5,0,-0, -10,5,-0, -5,10,-0, 0,0,5, 10,0,5, 5,0,10, -10,0,5, -5,0,10, 0,-5,0, 10,-5,0, 5,-10,0, -10,-5,0, -5,-10,0, 5,5,0, -5,5,-0, 5,0,5, -5,0,5, 5,-5,0, -5,-5,0]
2318 meshCoords = DataArrayDouble.New(coo, 35, 3)
2319 mesh.setCoords(meshCoords)
2320 mesh.setMeshDimension( 2 )
2321 conn = [ 1,12,29,15, 15,29,14, 3, 12, 0,13,29, 29,13, 2,14, 1,12,30,18, 18,30,17, 5, 12, 0,16,30, 30,16, 4,17, 6,19,31,21, 21,31,20, 7, 19, 0,13,31, 31,13, 2,20, 6,19,32,23, 23,32,22, 8, 19, 0,16,32, 32,16, 4,22, 9,24,33,26, 26,33,25,10, 24, 0,13,33, 33,13, 2,25, 9,24,34,28, 28,34,27,11, 24, 0,16,34, 34,16, 4,27]
2322 mesh.allocateCells(24)
2324 mesh.insertNextCell(NORM_QUAD4,4,conn[4*i:4*(i+1)]);
2325 mesh.finishInsertingCells()
2326 Group_1 = list( range( 0, 4 ))
2327 Group_2 = list( range( 4, 8 ))
2328 Group_3 = list( range( 8, 12 ))
2329 Group_5 = list( range( 16, 20 ))
2331 Group_8 = list( range( 12, 16 ))
2333 # example 1.1 - check failure on non-manifold
2334 objMesh = mesh.buildPartOfMySelf( Group_1 + Group_3 + Group_5 )
2335 refMesh = mesh.buildPartOfMySelf( Group_1 )
2336 self.assertRaisesRegex(Exception, "Non-manifold",
2337 objMesh.orientCorrectly2DCells, refMesh )
2339 # - do nothing, as request "de non-appartenance de la reference a la cible" dropped
2341 # example 1.3 - fix orientation of Group_1 and Group_8
2342 objMesh = mesh.buildPartOfMySelf( Group_1 + Group_2 + Group_7 + Group_8 )
2343 refMesh = mesh.buildPartOfMySelf( Group_7 )
2344 objMesh.orientCorrectly2DCells( refMesh )
2346 self.assertEqual( objMesh.getNodeIdsOfCell( 0 ), [ 1, 15, 29, 12 ])
2347 self.assertEqual( objMesh.getNodeIdsOfCell( 1 ), [ 15, 3, 14, 29 ])
2348 self.assertEqual( objMesh.getNodeIdsOfCell( 2 ), [ 12, 29, 13, 0 ])
2349 self.assertEqual( objMesh.getNodeIdsOfCell( 3 ), [ 29, 14, 2, 13 ])
2351 self.assertEqual( objMesh.getNodeIdsOfCell( 12 ), [ 6, 23, 32, 19 ])
2352 self.assertEqual( objMesh.getNodeIdsOfCell( 13 ), [ 23, 8, 22, 32 ])
2353 self.assertEqual( objMesh.getNodeIdsOfCell( 14 ), [ 19, 32, 16, 0 ])
2354 self.assertEqual( objMesh.getNodeIdsOfCell( 15 ), [ 32, 22, 4, 16 ])
2356 # Case with no reference given. Group_2 and Group_7 must reverse
2357 objMesh = mesh.buildPartOfMySelf( Group_1 + Group_2 + Group_7 + Group_8 )
2358 objMesh.orientCorrectly2DCells( None )
2360 self.assertEqual( objMesh.getNodeIdsOfCell( 4 ), [ 1, 18, 30, 12 ])
2361 self.assertEqual( objMesh.getNodeIdsOfCell( 5 ), [ 18, 5, 17, 30 ])
2362 self.assertEqual( objMesh.getNodeIdsOfCell( 6 ), [ 12, 30, 16, 0 ])
2363 self.assertEqual( objMesh.getNodeIdsOfCell( 7 ), [ 30, 17, 4, 16 ])
2365 self.assertEqual( objMesh.getNodeIdsOfCell( 8 ), [ 6, 21, 31, 19 ])
2366 self.assertEqual( objMesh.getNodeIdsOfCell( 9 ), [ 21, 7, 20, 31 ])
2367 self.assertEqual( objMesh.getNodeIdsOfCell( 10 ), [ 19, 31, 13, 0 ])
2368 self.assertEqual( objMesh.getNodeIdsOfCell( 11 ), [ 31, 20, 2, 13 ])
2370 # Case with differently oriented reference faces. Expect an exception
2371 objMesh = mesh.buildPartOfMySelf( Group_1 + Group_2 + Group_7 + Group_8 )
2372 refMesh = mesh.buildPartOfMySelf( Group_1 + Group_2 )
2373 self.assertRaisesRegex(Exception, "Different orientation",
2374 objMesh.orientCorrectly2DCells, refMesh )
2377 def testPolyhedronBarycenter(self):
2378 connN=[0,3,2,1, -1, 4,5,6,7, -1, 0,4,7,3, -1, 3,7,6,2, -1, 2,6,5,1, -1, 1,5,4,0];
2379 coords=[0.,0.,0., 1.,0.,0., 1.,1.,0., 0.,1.,0., 0.,0.,1., 1.,0.,1., 1.,1.,1., 0.,1.,1., 0.5, 0.5, 0.5];
2380 meshN=MEDCouplingUMesh.New();
2381 meshN.setName("ForBary");
2382 meshN.setMeshDimension(3);
2383 meshN.allocateCells(4);
2384 meshN.insertNextCell(NORM_POLYHED,29,connN[0:29])
2385 meshN.finishInsertingCells();
2386 myCoords=DataArrayDouble.New();
2387 myCoords.setValues(coords,9,3);
2388 meshN.setCoords(myCoords);
2389 meshN.checkConsistencyLight();
2391 res1=meshN.arePolyhedronsNotCorrectlyOriented();
2392 meshN.orientCorrectlyPolyhedrons();
2393 self.assertTrue(len(res1)==0);
2394 da=meshN.computeCellCenterOfMass();
2395 self.assertEqual(1,da.getNumberOfTuples());
2396 self.assertEqual(3,da.getNumberOfComponents());
2397 daPtr=da.getValues();
2398 ref=meshN.getCoords().getValues()[24:];
2400 self.assertTrue(abs(ref[i]-daPtr[i])<1e-12);
2405 da=meshN.computeCellCenterOfMass();
2406 daPtr=da.getValues();
2407 ref=meshN.getCoords().getValues()[24:];
2409 self.assertTrue(abs(ref[i]-daPtr[i])<1e-12);
2412 meshN.rotate(center,vec,pi/7.);
2413 meshN.translate(vec);
2414 da=meshN.computeCellCenterOfMass();
2415 daPtr=da.getValues();
2416 ref=meshN.getCoords().getValues()[24:];
2418 self.assertTrue(abs(ref[i]-daPtr[i])<1e-12);
2421 center2=[1.12,3.45,6.78]
2423 meshN.rotate(center2,vec2,e);
2424 meshN.translate(vec2);
2425 da=meshN.computeCellCenterOfMass();
2426 daPtr=da.getValues();
2427 ref=meshN.getCoords().getValues()[24:];
2429 self.assertTrue(abs(ref[i]-daPtr[i])<1e-10);
2433 def testNormL12Integ1D(self):
2434 m1=MEDCouplingDataForTest.build1DTargetMesh_3();
2435 f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2437 array=DataArrayDouble.New();
2438 arr=[-5.23,15.45,-25.56,6.67,-16.78,26.89,-7.91,17.23,-27.43,8.21,-18.63,28.72]
2439 array.setValues(arr,m1.getNumberOfCells(),3);
2442 f3=m1.computeCellCenterOfMass();
2443 self.assertEqual(4,f3.getNumberOfTuples());
2444 self.assertEqual(1,f3.getNumberOfComponents());
2445 expected9=[0.75,5.105,0.8,5.155]
2448 self.assertTrue(abs(expected9[i]-ptr[i])<1e-12);
2451 f2=m1.getMeasureField(False);
2452 self.assertEqual(4,f2.getArray().getNumberOfTuples());
2453 self.assertEqual(1,f2.getNumberOfComponents());
2454 expected1=[0.5,0.21,-0.6,-0.31]
2455 ptr=f2.getArray().getValues();
2457 self.assertTrue(abs(expected1[i]-ptr[i])<1e-12);
2459 expected2=[0.5,0.21,0.6,0.31]
2460 f2=m1.getMeasureField(True);
2461 ptr=f2.getArray().getValues();
2463 self.assertTrue(abs(expected2[i]-ptr[i])<1e-12);
2466 self.assertTrue(4,f1.getNumberOfTuples())
2467 res=f1.integral(False);
2468 self.assertTrue(3,len(res))
2469 expected3=[0.9866,-0.3615,0.4217]
2471 self.assertTrue(abs(expected3[i]-res[i])<1e-12);
2473 self.assertTrue(abs(expected3[0]-f1.integral(0,False))<1e-12);
2474 self.assertTrue(abs(expected3[1]-f1.integral(1,False))<1e-12);
2475 self.assertTrue(abs(expected3[2]-f1.integral(2,False))<1e-12);
2476 res=f1.integral(True);
2477 expected4=[-3.4152,8.7639,-14.6879]
2479 self.assertTrue(abs(expected4[i]-res[i])<1e-12);
2483 self.assertTrue(3,len(res))
2484 expected5=[6.979506172839505, 16.89018518518518, 27.02969135802469]
2486 self.assertTrue(abs(expected5[i]-res[i])<1e-12);
2488 self.assertTrue(abs(expected5[0]-f1.normL1(0))<1e-12);
2489 self.assertTrue(abs(expected5[1]-f1.normL1(1))<1e-12);
2490 self.assertTrue(abs(expected5[2]-f1.normL1(2))<1e-12);
2493 self.assertTrue(3,len(res))
2494 expected7=[7.090910979452395, 16.9275542960123, 27.053271464160858]
2496 self.assertTrue(abs(expected7[i]-res[i])<1e-9);
2498 self.assertTrue(abs(expected7[0]-f1.normL2(0))<1e-9);
2499 self.assertTrue(abs(expected7[1]-f1.normL2(1))<1e-9);
2500 self.assertTrue(abs(expected7[2]-f1.normL2(2))<1e-9);
2502 f4=f1.buildMeasureField(False);
2503 self.assertTrue(abs(-0.2-f4.accumulate(0))<1e-12);
2504 f4=f1.buildMeasureField(True);
2505 self.assertTrue(abs(1.62-f4.accumulate(0))<1e-12);
2506 # Testing with 2D Curve
2507 m1=MEDCouplingDataForTest.build2DCurveTargetMesh_3();
2508 f2=m1.getMeasureField(False);
2509 self.assertEqual(4,f2.getArray().getNumberOfTuples());
2510 self.assertEqual(1,f2.getNumberOfComponents());
2511 ptr=f2.getArray().getValues();
2513 self.assertTrue(abs(sqrt(2.)*expected2[i]-ptr[i])<1e-12);
2515 f2=m1.getMeasureField(True);
2516 self.assertEqual(4,f2.getArray().getNumberOfTuples());
2517 self.assertEqual(1,f2.getNumberOfComponents());
2518 ptr=f2.getArray().getValues();
2520 self.assertTrue(abs(expected2[i]*sqrt(2.)-ptr[i])<1e-12);
2523 f3=m1.computeCellCenterOfMass();
2524 self.assertEqual(4,f3.getNumberOfTuples());
2525 self.assertEqual(2,f3.getNumberOfComponents());
2526 expected10=[0.75,0.75,5.105,5.105,0.8,0.8,5.155,5.155]
2529 self.assertTrue(abs(expected10[i]-ptr[i])<1e-12);
2532 f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2534 array=DataArrayDouble.New();
2535 array.setValues(arr,m1.getNumberOfCells(),3);
2537 res=f1.integral(False);
2539 self.assertTrue(abs(sqrt(2.)*expected4[i]-res[i])<1e-12);
2541 res=f1.integral(True);
2543 self.assertTrue(abs(sqrt(2.)*expected4[i]-res[i])<1e-12);
2547 self.assertTrue(abs(expected5[i]-res[i])<1e-12);
2551 self.assertTrue(abs(expected7[i]-res[i])<1e-12);
2555 def testAreaBary2D(self):
2556 m1=MEDCouplingDataForTest.build2DTargetMesh_3();
2557 f1=m1.getMeasureField(False);
2558 self.assertEqual(10,f1.getArray().getNumberOfTuples());
2559 self.assertEqual(1,f1.getNumberOfComponents());
2560 expected1=[-0.5,-1,-1.5,-0.5,-1, 0.5,1,1.5,0.5,1]
2561 ptr=f1.getArray().getValues();
2563 self.assertTrue(abs(expected1[i]-ptr[i])<1e-12);
2565 f1=m1.getMeasureField(True);
2566 ptr=f1.getArray().getValues();
2568 self.assertTrue(abs(abs(expected1[i])-ptr[i])<1e-12);
2570 f2=m1.computeCellCenterOfMass();
2571 self.assertEqual(10,f2.getNumberOfTuples());
2572 self.assertEqual(2,f2.getNumberOfComponents());
2573 expected2=[0.5,0.3333333333333333,0.5,0.5,0.5,0.77777777777777777,0.5,0.3333333333333333,0.5,0.5,0.5,0.3333333333333333,0.5,0.5,0.5,0.77777777777777777,0.5,0.3333333333333333,0.5,0.5]
2576 self.assertTrue(abs(expected2[i]-ptr[i])<1e-12);
2578 m1.changeSpaceDimension(3);
2579 f1=m1.getMeasureField(False);
2580 self.assertEqual(10,f1.getArray().getNumberOfTuples());
2581 self.assertEqual(1,f1.getNumberOfComponents());
2582 ptr=f1.getArray().getValues();
2584 self.assertTrue(abs(abs(expected1[i])-ptr[i])<1e-12);
2586 f2=m1.computeCellCenterOfMass();
2587 self.assertEqual(10,f2.getNumberOfTuples());
2588 self.assertEqual(3,f2.getNumberOfComponents());
2590 expected3=[0.5,0.3333333333333333,0.,0.5,0.5,0.,0.5,0.77777777777777777,0.,0.5,0.3333333333333333,0.,0.5,0.5,0., 0.5,0.3333333333333333,0.,0.5,0.5,0.,0.5,0.77777777777777777,0.,0.5,0.3333333333333333,0.,0.5,0.5,0.]
2592 self.assertTrue(abs(expected3[i]-ptr[i])<1e-12);
2596 def testAreaBary3D(self):
2597 coords=[ 0.241310763507 , 0.0504777305619 , 0.0682283524903 , 0.252501053866 , -0.0625176732937 , 0.137272639894 ,
2598 0.152262663601 , 0.241816569527 , 0.133812556197 , 0.18047750211 , -0.0789949051358 , 0.339098173401 ,
2599 0.151741971857 , 0.238885278571 , 0.137715037333 , 0.242532155481 , -0.0928169086456 , 0.0678043417367 ,
2600 0.240941965335 , -0.015461491464 , 0.0617186345825 , 0.24127650112 , 0.0499427876717 , 0.0679634099148 ,
2601 -0.145828917428 , 0.206291632565 , 0.0310071927543 , 0.0125651775307 , 0.266262085828 , 0.105228430543 ,
2602 -0.0994066533286 , 0.233224271238 , 0.0572213839567 , -0.0951345338317 , 0.234819509426 , 0.0592126284538 ,
2603 0.136580574205 , -0.205486212579 , 0.0572866072014 , 0.0637270784978 , -0.168886355238 , 0.446614057077 ,
2604 0.041337157151 , -0.213402568198 , 0.372407095999 , 0.0411601970268 , -0.202387875756 , 0.411334979491 ,
2605 -0.108355701857 , 0.193636239335 , 0.204886756738 , 0.00639779029829 , 0.155296981517 , 0.252585892979 ,
2606 0.0262473111702 , -0.112919732543 , 0.424286639249 ,-0.224103052733 , -0.139430015438 , -0.0122352295701 ,
2607 -0.0312760589481 , -0.274272003594 , 0.0323959636568 , -0.166663422532 , -0.217754445175 , 0.00392109070364 ,
2608 -0.30586619777 , -0.0475168041091 , -0.0144585228182 , -0.280881480586 , 0.135571293538 , 0.00623923647986 ,
2609 -0.25548538234 , 0.156819217766 , 0.0645277879769 , -0.131567009284 , 0.184133752309 , 0.206021802753 ,
2610 -0.196204010965 , 0.151602971681 , 0.212974777736 , -0.183713879463 , 0.0802946639531 , 0.260115662599 ,
2611 -0.244241178767 , -0.0738873389604 , 0.144590565817 , -0.155804057829 , -0.164892720025 , 0.210613950558 ,
2612 -0.170950800428 , -0.215099334026 , 0.00610122860092 , -0.30552634869 , -0.0490020791904 , -0.0132786533145 ,
2613 0.271831011884 , 0.15105657296 , 0.0230534827908 , 0.281919192283 , 0.0898544306288 , -0.0625201489143 ,
2614 0.260240727276 , -0.0120688706637 , -0.0532316588626 , 0.244947737722 , 0.0197984684293 , 0.0309341209233 ,
2615 0.23439631578 , 0.229825279875 , 0.0508520585381 , 0.160921316875 , 0.265078502128 , 0.121716560626 ,
2616 -0.315088694175 , 0.0747700471918 , -0.245836615071 , -0.327728781776 , 0.0857114674649 , -0.239431905957 ,
2617 -0.308385460634 , 0.145142997084 , -0.149886828433 , 0.0488236045164 , 0.309462801914 , 0.0849169148265 ,
2618 -0.0244964803395 , 0.33145611751 , -0.0476415818061 , 0.0060567994229 , 0.32418412014 , 0.0367779543812 ,
2619 -0.0950221448063 , 0.236675326003 , 0.0572594453983 , 0.248723023186 , 0.0886648784791 , -0.176629430538 ,
2620 0.116796984 , 0.256596599567 , -0.292863523603 , 0.118024552914 , 0.229154257843 , -0.34233232501 ,
2621 0.217507892549 , -0.0417822335742 , -0.176771782888 , -0.224429321304 , 0.0125595300114 , -0.362064725588 ,
2622 0.0937301100955 , -0.0500824832657 , -0.299713548444 , -0.244162220397 , 0.0383853931293 , -0.389856984411 ,
2623 -0.0281989366102 , 0.097392811563 , -0.458244577284 , -0.385010847162 , 0.10122766194 , -0.140052859922 ,
2624 -0.377936358012 , 0.110875172128 , -0.176207095463 , 0.244483045556 , -0.0991073977045 , 0.0575134372934 ,
2625 0.262605120167 , -0.100243191645 , -0.0495620806935 , 0.240306880972 , -0.136153701579 , -0.114745281696 ,
2626 0.215763176129 , -0.0836766059189 , -0.183249640616 , 0.237870396603 , -0.132449578286 , -0.121598854639 ,
2627 -0.0637683083097 , -0.27921020214 , -0.149112321992 , -0.0856211014977 , -0.2973233473 , -0.0446878139589 ,
2628 0.104675342288 , -0.0625908305324 , -0.290346256534 , 0.0248264249186 , -0.247797708548 , -0.165830884019 ,
2629 0.0719302438309 , -0.178468260473 , -0.211432157345 , 0.142871843159 , -0.208769948542 , 0.0454101128246 ,
2630 0.167803379307 , -0.207851396623 , -0.088802726124 , 0.12868717152 , -0.230920439715 , 0.00760508389036 ,
2631 -0.0372812069535 , -0.286740286332 , 0.00963701291166 ]
2633 connN = [ #polyhedron 0
2634 0 , 1 , 3 , 4 , 2 , -1 , 1 , 5 , 6 , 7 , 0 , -1 , 0 , 7 , 8 , 10 , 11 , 9 , 2 , -1 , 1 , 5 , 12 , 14 , 15 , 13 , 3 , -1 , 16 , 9 , 2 , 4 , 17 , -1
2635 , 4 , 3 , 13 , 18 , 17 , -1 , 5 , 6 , 19 , 21 , 20 , 12 , -1 , 6 , 7 , 8 , 23 , 22 , 19 , -1 , 23 , 24 , 10 , 8 , -1 , 25 , 11 , 9 , 16 , -1
2636 , 24 , 26 , 25 , 11 , 10 , -1 , 12 , 14 , 20 , -1 , 27 , 28 , 29 , 15 , 13 , 18 , -1 , 14 , 15 , 29 , 30 , 21 , 20 , -1 , 26 , 27 , 18 , 17 , 16 , 25 , -1
2637 , 22 , 19 , 21 , 30 , 31 , -1 , 22 , 31 , 28 , 27 , 26 , 24 , 23 , -1 , 31 , 30 , 29 , 28,
2639 0 , 7 , 8 , 10 , 11 , 9 , 2 , -1 , 32 , 0 , 7 , 35 , 34 , 33 , -1 , 32 , 0 , 2 , 37 , 36 , -1 , 35 , 7 , 8 , 40 , 39 , 38 , -1
2640 , 2 , 37 , 41 , 9 , -1 , 40 , 8 , 10 , 44 , 43 , 42 , -1 , 41 , 9 , 11 , 44 , 43 , -1 , 44 , 11 , 10 , -1 , 32 , 33 , 45 , 47 , 46 , 36 , -1
2641 , 33 , 34 , 48 , 45 , -1 , 35 , 34 , 48 , 50 , 49 , 38 , -1 , 41 , 43 , 42 , 46 , 36 , 37 , -1 , 38 , 39 , 51 , 49 , -1
2642 , 39 , 40 , 42 , 46 , 47 , 52 , 51 , -1 , 45 , 47 , 52 , 50 , 48 , -1 , 52 , 51 , 49 , 50,
2644 6 , 7 , 8 , 23 , 22 , 19 , -1 , 6 , 35 , 7 , -1 , 6 , 35 , 38 , 19 , -1 , 35 , 7 , 8 , 40 , 39 , 38 , -1 , 53 , 22 , 19 , 38 , 39 , 54 , -1
2645 , 23 , 53 , 54 , 40 , 8 , -1 , 53 , 22 , 23 , -1 , 39 , 54 , 40,
2647 35 , 34 , 48 , 50 , 49 , 38 , -1 , 6 , 35 , 34 , 56 , 55 , 5 , -1 , 6 , 35 , 38 , 19 , -1 , 34 , 56 , 57 , 59 , 58 , 48 , -1
2648 , 60 , 61 , 21 , 19 , 38 , 49 , -1 , 62 , 50 , 48 , 58 , -1 , 60 , 63 , 64 , 62 , 50 , 49 , -1 , 5 , 6 , 19 , 21 , 20 , 12 , -1
2649 , 55 , 5 , 12 , 65 , -1 , 66 , 67 , 65 , 55 , 56 , 57 , -1 , 63 , 66 , 57 , 59 , 64 , -1 , 64 , 62 , 58 , 59 , -1
2650 , 60 , 63 , 66 , 67 , 68 , 61 , -1 , 61 , 68 , 20 , 21 , -1 , 67 , 68 , 20 , 12 , 65]
2652 barys = [ -0.0165220465527 , -0.0190922868195 , 0.158882733414 ,
2653 0.0287618656076 , 0.135874379934 , -0.14601588119 ,
2654 -0.147128055553 , 0.0465995097041 , -0.049391174453 ,
2655 -0.00142506732317 , -0.0996953090351 , -0.115159183132 ]
2656 meshN=MEDCouplingUMesh.New();
2657 meshN.setName("ForBary");
2658 meshN.setMeshDimension(3);
2659 meshN.allocateCells(4);
2660 meshN.insertNextCell(NORM_POLYHED,113,connN);
2661 meshN.insertNextCell(NORM_POLYHED,99,connN[113:]);
2662 meshN.insertNextCell(NORM_POLYHED,43,connN[212:]);
2663 meshN.insertNextCell(NORM_POLYHED,92,connN[255:]);
2664 meshN.finishInsertingCells();
2665 myCoords=DataArrayDouble.New();
2666 myCoords.setValues(coords,69,3);
2667 meshN.setCoords(myCoords);
2668 meshN.checkConsistencyLight();
2669 res1=meshN.arePolyhedronsNotCorrectlyOriented();
2670 meshN.orientCorrectlyPolyhedrons();
2671 res1=meshN.arePolyhedronsNotCorrectlyOriented();
2672 self.assertTrue(len(res1)==0);
2674 da=meshN.computeCellCenterOfMass();
2675 self.assertEqual(4,da.getNumberOfTuples());
2676 self.assertEqual(3,da.getNumberOfComponents());
2677 daPtr=da.getValues();
2679 self.assertTrue(abs(barys[i]-daPtr[i])<1e-12);
2683 def testRenumberCellsForFields(self):
2684 m=MEDCouplingDataForTest.build2DTargetMesh_1();
2685 f=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2687 arr=DataArrayDouble.New();
2688 nbOfCells=m.getNumberOfCells();
2689 values1=[7.,107.,10007.,8.,108.,10008.,9.,109.,10009.,10.,110.,10010.,11.,111.,10011.]
2690 arr.setValues(values1,nbOfCells,3);
2692 renumber1=[3,1,0,4,2]
2693 loc=[-0.05,-0.05, 0.55,-0.25, 0.55,0.15, -0.05,0.45, 0.45,0.45]
2695 res=f.getValueOn(loc[2*j:2*j+2]);
2697 self.assertTrue(abs(values1[i+3*j]-res[i])<1e-12);
2700 f.renumberCells(renumber1,False);
2701 ptr=f.getArray().getValues();
2702 expected1=[9.,109.,10009.,8.,108.,10008.,11.,111.,10011.,7.,107.,10007.,10.,110.,10010.]
2704 self.assertTrue(abs(expected1[i]-ptr[i])<1e-12);
2706 #check that fields remains the same geometrically
2708 res=f.getValueOn(loc[2*j:2*(j+1)]);
2710 self.assertTrue(abs(values1[i+3*j]-res[i])<1e-12);
2714 f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,NO_TIME);
2716 _a=0.446948490915965;
2717 _b=0.091576213509771;
2718 _p1=0.11169079483905;
2719 _p2=0.0549758718227661;
2720 refCoo1=[ 0.,0., 1.,0., 0.,1. ]
2721 gsCoo1=[ 2*_b-1, 1-4*_b, 2*_b-1, 2.07*_b-1, 1-4*_b, 2*_b-1, 1-4*_a, 2*_a-1, 2*_a-1, 1-4*_a, 2*_a-1, 2*_a-1 ];
2722 wg1=[ 4*_p2, 4*_p2, 4*_p2, 4*_p1, 4*_p1, 4*_p1 ]
2723 _refCoo1=refCoo1[0:6];
2724 _gsCoo1=gsCoo1[0:12];
2726 f.setGaussLocalizationOnType(NORM_TRI3,_refCoo1,_gsCoo1,_wg1);
2727 refCoo2=[ 0.,0., 1.,0., 1.,1., 0.,1. ]
2728 _refCoo2=refCoo2[0:8];
2729 _gsCoo1=_gsCoo1[0:4]
2731 f.setGaussLocalizationOnType(NORM_QUAD4,_refCoo2,_gsCoo1,_wg1);
2732 arr=DataArrayDouble.New();
2733 values2=[1.,1001.,2.,1002., 11.,1011.,12.,1012.,13.,1013.,14.,1014.,15.,1015.,16.,1016., 21.,1021.,22.,1022.,23.,1023.,24.,1024.,25.,1025.,26.,1026., 31.,1031.,32.,1032., 41.,1041.,42.,1042.]
2734 arr.setValues(values2,18,2);
2736 f.checkConsistencyLight();
2738 self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2739 f.renumberCells(renumber1,False);
2740 self.assertTrue(not f.isEqual(fCpy,1e-12,1e-12));
2741 expected2=[21.,1021.,22.,1022.,23.,1023.,24.,1024.,25.,1025.,26.,1026., 11.,1011.,12.,1012.,13.,1013.,14.,1014.,15.,1015.,16.,1016., 41.,1041.,42.,1042., 1.,1001.,2.,1002., 31.,1031.,32.,1032.]
2742 ptr=f.getArray().getValues();
2744 self.assertTrue(abs(expected2[i]-ptr[i])<1e-12);
2746 renumber2=[2,1,4,0,3]
2747 f.renumberCells(renumber2,False);
2748 self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2750 f=MEDCouplingFieldDouble.New(ON_GAUSS_NE,NO_TIME);
2752 arr=DataArrayDouble.New();
2753 values3=[1.,1001.,2.,1002.,3.,1003.,4.,1004., 11.,1011.,12.,1012.,13.,1013., 21.,1021.,22.,1022.,23.,1023., 31.,1031.,32.,1032.,33.,1033.,34.,1034., 41.,1041.,42.,1042.,43.,1043.,44.,1044.]
2754 arr.setValues(values3,18,2);
2756 f.checkConsistencyLight();
2758 self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2759 f.renumberCells(renumber1,False);
2760 self.assertTrue(not f.isEqual(fCpy,1e-12,1e-12));
2761 expected3=[21.,1021.,22.,1022.,23.,1023.,11.,1011.,12.,1012.,13.,1013.,41.,1041.,42.,1042.,43.,1043.,44.,1044.,1.,1001.,2.,1002.,3.,1003.,4.,1004.,31.,1031.,32.,1032.,33.,1033.,34.,1034.]
2762 ptr=f.getArray().getValues();
2764 self.assertTrue(abs(expected3[i]-ptr[i])<1e-12);
2766 f.renumberCells(renumber2,False);#perform reverse operation of renumbering to check that the resulting field is equal.
2767 self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2771 def testRenumberNodesForFields(self):
2772 m=MEDCouplingDataForTest.build2DTargetMesh_1();
2773 f=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
2775 self.assertEqual(9,f.getNumberOfMeshPlacesExpected());
2776 arr=DataArrayDouble.New();
2777 nbOfNodes=m.getNumberOfNodes();
2778 values1=[7.,107.,10007.,8.,108.,10008.,9.,109.,10009.,10.,110.,10010.,11.,111.,10011.,12.,112.,10012.,13.,113.,10013.,14.,114.,10014.,15.,115.,10015.]
2779 arr.setValues(values1,nbOfNodes,3);
2781 f.checkConsistencyLight();
2782 renumber1=[0,4,1,3,5,2,6,7,8]
2783 loc=[0.5432,-0.2432, 0.5478,0.1528]
2784 expected1=[9.0272, 109.0272, 10009.0272, 11.4124,111.4124,10011.4124]
2786 res=f.getValueOn(loc[2*j:2*j+2]);
2788 self.assertTrue(abs(expected1[i+3*j]-res[i])<1e-12);
2792 self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2793 f.renumberNodes(renumber1);
2794 self.assertTrue(not f.isEqual(fCpy,1e-12,1e-12));
2796 res=f.getValueOn(loc[2*j:2*j+2]);
2798 self.assertTrue(abs(expected1[i+3*j]-res[i])<1e-12);
2801 expected2=[7.,107.,10007.,9.,109.,10009.,12.,112.,10012.,10.,110.,10010.,8.,108.,10008.,11.,111.,10011.,13.,113.,10013.,14.,114.,10014.,15.,115.,10015.]
2803 self.assertTrue(abs(expected2[i]-f.getArray().getValues()[i])<1e-12);
2805 renumber2=[0,2,5,3,1,4,6,7,8]
2806 f.renumberNodes(renumber2);
2807 self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2810 def testConvertQuadraticCellsToLinear(self):
2811 mesh=MEDCouplingDataForTest.build2DTargetMesh_3();
2812 mesh.checkConsistencyLight();
2813 types=mesh.getAllGeoTypes();
2815 self.assertEqual(5,len(types));
2816 expected1 = [NORM_POLYGON, NORM_TRI3, NORM_QUAD4, NORM_TRI6, NORM_QUAD8]
2818 self.assertEqual(expected1,types);
2819 self.assertTrue(mesh.isPresenceOfQuadratic());
2820 self.assertEqual(62,mesh.getNodalConnectivityArrayLen());
2821 f1=mesh.getMeasureField(False);
2823 mesh.convertQuadraticCellsToLinear();
2824 self.assertTrue(not mesh.isPresenceOfQuadratic());
2826 mesh.checkConsistencyLight();
2827 f2=mesh.getMeasureField(False);
2828 self.assertTrue(f1.getArray().isEqual(f2.getArray(),1e-12));
2829 self.assertEqual(48,mesh.getNodalConnectivityArrayLen());
2830 types2=mesh.getAllGeoTypes();
2832 self.assertEqual(3,len(types2));
2833 expected2=[NORM_POLYGON, NORM_TRI3, NORM_QUAD4]
2835 self.assertEqual(expected2,types2);
2838 def testCheckGeoEquivalWith(self):
2839 mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2840 mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2842 cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh1,0,1e-12);#deepEqual
2843 self.assertTrue(cellCor==None);
2844 self.assertTrue(nodeCor==None);
2845 cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh1,1,1e-12);#fastEqual
2846 self.assertTrue(cellCor==None);
2847 self.assertTrue(nodeCor==None);
2848 cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh1,10,1e-12);#deepEqual with geo permutations
2849 self.assertTrue(cellCor==None);
2850 self.assertTrue(nodeCor==None);
2851 #Second test mesh1 and mesh2 are 2 different meshes instance
2852 cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,0,1e-12);#deepEqual
2853 self.assertTrue(cellCor==None);
2854 self.assertTrue(nodeCor==None);
2855 cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,1,1e-12);#fastEqual
2856 self.assertTrue(cellCor==None);
2857 self.assertTrue(nodeCor==None);
2858 cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);#deepEqual with geo permutations
2859 self.assertTrue(cellCor==None);
2860 self.assertTrue(nodeCor==None);
2861 #Third test : cell permutation by keeping the first the middle and the last as it is.
2862 renum=[0,2,1,3,4,5,6,8,7,9]
2863 mesh2.renumberCells(renum,False);
2864 self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12);#deepEqual fails
2865 self.assertTrue(cellCor==None);
2866 self.assertTrue(nodeCor==None);
2867 cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,1,1e-12);#fastEqual do not see anything
2868 self.assertTrue(cellCor==None);
2869 self.assertTrue(nodeCor==None);
2870 cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);#deepEqual with geo permutations
2871 self.assertTrue(cellCor);
2872 self.assertEqual(10,cellCor.getNumberOfTuples());
2873 self.assertEqual(1,cellCor.getNumberOfComponents());
2874 self.assertEqual(renum,list(cellCor.getValues()))
2875 self.assertTrue(nodeCor==None);
2877 self.assertTrue(nodeCor==None);
2878 a,b=mesh1.checkDeepEquivalWith(mesh2,0,1e-12);
2879 self.assertEqual(renum,list(a.getValues()))
2880 self.assertTrue(b==None);
2881 mesh2.setCoords(mesh1.getCoords())
2882 a=mesh1.checkDeepEquivalOnSameNodesWith(mesh2,0,1e-12);
2883 self.assertEqual(renum,list(a.getValues()))
2884 #4th test : cell and node permutation by keeping the first the middle and the last as it is.
2885 mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2886 renum2=[0,2,1,3,4,5,6,8,7,9,10]
2887 mesh2.renumberCells(renum,False);
2888 mesh2.renumberNodes(renum2,11);
2891 self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12);#deepEqual fails
2892 self.assertTrue(cellCor==None);
2893 self.assertTrue(nodeCor==None);
2894 cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,1,1e-12);#fastEqual do not see anything
2895 self.assertTrue(cellCor==None);
2896 self.assertTrue(nodeCor==None);
2897 cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);#deepEqual with geo permutations
2898 self.assertTrue(cellCor);
2899 self.assertEqual(10,cellCor.getNumberOfTuples());
2900 self.assertEqual(1,cellCor.getNumberOfComponents());
2901 self.assertEqual(renum,list(cellCor.getValues()))
2902 self.assertTrue(nodeCor);
2903 self.assertEqual(11,nodeCor.getNumberOfTuples());
2904 self.assertEqual(1,nodeCor.getNumberOfComponents());
2905 self.assertEqual(renum2,list(nodeCor.getValues()))
2908 #5th test : modification of the last cell to check fastCheck detection.
2909 mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2910 renum3=[0,2,1,3,4,5,6,8,9,7]
2911 mesh2.renumberCells(renum3,False);
2912 mesh2.renumberNodes(renum2,11);
2915 self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12)
2916 self.assertTrue(cellCor==None);
2917 self.assertTrue(nodeCor==None);
2918 self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,1,1e-12)
2919 self.assertTrue(cellCor==None);
2920 self.assertTrue(nodeCor==None);
2921 cellCor,nodeCor=mesh2.checkGeoEquivalWith(mesh1,10,1e-12);#deepEqual with geo permutations
2922 self.assertTrue(cellCor!=None);
2923 self.assertEqual(10,cellCor.getNumberOfTuples());
2924 self.assertEqual(1,cellCor.getNumberOfComponents());
2925 self.assertEqual(renum3,list(cellCor.getValues()))
2926 self.assertTrue(nodeCor!=None);
2927 self.assertEqual(11,nodeCor.getNumberOfTuples());
2928 self.assertEqual(1,nodeCor.getNumberOfComponents());
2929 self.assertEqual(renum2,list(nodeCor.getValues()));
2932 def testCheckGeoEquivalWith2(self):
2933 mesh1=MEDCouplingDataForTest.build2DTargetMesh_4();
2934 mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
2935 cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);
2936 self.assertEqual(None,cellCor);
2937 self.assertNotEqual(None,nodeCor);
2938 expected1=[0, 1, 3, 4, 5, 6, 7, 8, 9]
2940 self.assertEqual(expected1[i],nodeCor.getIJ(i,0));
2944 def testSwig2CheckDeepEquivalWith1(self):
2946 mcart = MEDCouplingCMesh()
2947 mcart.setCoordsAt(0, DataArrayDouble([0.0,1.5,2.0]))
2948 mcart.setCoordsAt(1, DataArrayDouble([1.0,2.5,3.0,4.0]))
2949 m = mcart.buildUnstructured()
2950 m2 = m[1:m.getNumberOfCells()]
2951 self.assertRaises(InterpKernelException, m.checkDeepEquivalWith, m2, 0, eps)
2952 self.assertRaises(InterpKernelException, m.checkDeepEquivalWith, m2, 1, eps)
2953 self.assertRaises(InterpKernelException, m.checkDeepEquivalWith, m2, 2, eps)
2956 def testSwig2CheckDeepEquivalWith2(self):
2958 m = MEDCouplingUMesh("tst", 2)
2959 m.setCoords(DataArrayDouble([], 0,2))
2960 m.setConnectivity(DataArrayInt([]), DataArrayInt([0]))
2962 m.checkDeepEquivalWith(m2, 0, eps) # Should not raise!
2965 def testCopyTinyStringsFromOnFields(self):
2966 m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2967 nbOfCells=m.getNumberOfCells();
2968 f=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
2970 self.assertEqual(5,f.getNumberOfMeshPlacesExpected());
2972 f.setDescription("b");
2973 a1=DataArrayDouble.New();
2974 a1.alloc(nbOfCells,2);
2976 a1.setInfoOnComponent(0,"c");
2977 a1.setInfoOnComponent(1,"d");
2979 a2.setInfoOnComponent(0,"e");
2980 a2.setInfoOnComponent(1,"f");
2983 f.setEndTime(3.,3,4);
2985 m.getCoords().setInfoOnComponent(0,"h");
2986 m.getCoords().setInfoOnComponent(1,"i");
2987 m.getCoords().setInfoOnComponent(2,"j");
2989 f.checkConsistencyLight();
2991 self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2993 self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2994 f2.copyTinyStringsFrom(f);
2995 self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2996 f2.setDescription("GGG");
2997 self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2998 f2.copyTinyStringsFrom(f);
2999 self.assertTrue(f2.isEqual(f,1e-12,1e-12));
3000 f2.getArray().setInfoOnComponent(0,"mmmm");
3001 self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
3002 f2.copyTinyStringsFrom(f);
3003 self.assertTrue(f2.isEqual(f,1e-12,1e-12));
3004 f2.getEndArray().setInfoOnComponent(1,"mmmm");
3005 self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
3006 f2.copyTinyStringsFrom(f);
3007 self.assertTrue(f2.isEqual(f,1e-12,1e-12));
3009 self.assertTrue(m2.isEqual(m,1e-12));
3011 self.assertTrue(not m2.isEqual(m,1e-12));
3012 m2.copyTinyStringsFrom(m);
3013 self.assertTrue(m2.isEqual(m,1e-12));
3014 m2.getCoords().setInfoOnComponent(1,"eee");
3015 self.assertTrue(not m2.isEqual(m,1e-12));
3016 m2.copyTinyStringsFrom(m);
3017 self.assertTrue(m2.isEqual(m,1e-12));
3020 def testTryToShareSameCoordsPermute(self):
3021 m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
3022 m2=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
3023 #self.assertTrue(m.getCoords()!=m2.getCoords());
3024 m.tryToShareSameCoordsPermute(m2,1e-12);
3025 #self.assertTrue(m.getCoords()==m2.getCoords());
3026 self.assertTrue(m2.isEqual(m,1e-12));
3027 renum1=[1,2,0,5,8,7,4,3,6]
3028 r1=DataArrayInt.New()
3029 r1.setValues(renum1,len(renum1),1)
3030 m.renumberNodes(r1,9);
3031 #self.assertTrue(m.getCoords()!=m2.getCoords());
3032 self.assertTrue(not m2.isEqual(m,1e-12));
3033 m.tryToShareSameCoordsPermute(m2,1e-12);
3034 #self.assertTrue(m.getCoords()==m2.getCoords());
3035 self.assertTrue(m2.isEqual(m,1e-12));
3038 def testTryToShareSameCoordsPermute2(self):
3039 m1=MEDCouplingDataForTest.build2DTargetMesh_4();
3040 targetCoords=[-0.3,-0.3, 0.2,-0.3, -0.3,0.2, 0.2,0.2 ]
3041 targetConn=[0,2,3,1]
3042 m2=MEDCouplingUMesh.New();
3043 m2.setMeshDimension(2);
3044 m2.allocateCells(1);
3045 m2.insertNextCell(NORM_QUAD4,targetConn[0:4])
3046 m2.finishInsertingCells();
3047 myCoords=DataArrayDouble.New();
3048 myCoords.setValues(targetCoords,4,2);
3049 m2.setCoords(myCoords);
3050 m2.checkConsistencyLight();
3051 m1.checkConsistencyLight();
3053 expected1=[0.25,0.125,0.125,0.25,0.25]
3054 f1=m1.getMeasureField(False);
3055 f2=m2.getMeasureField(False);
3056 self.assertEqual(5,f1.getArray().getNumberOfTuples());
3057 self.assertEqual(1,f2.getArray().getNumberOfTuples());
3059 self.assertAlmostEqual(expected1[i],f1.getIJ(i,0),12);
3061 self.assertAlmostEqual(expected1[0],f2.getIJ(0,0),12);
3062 self.assertRaises(InterpKernelException,m1.tryToShareSameCoordsPermute,m2,1e-12);# <- here in this order the sharing is impossible.
3063 # Let's go for deeper test of tryToShareSameCoordsPermute
3064 m2.tryToShareSameCoordsPermute(m1,1e-12);
3065 f1=m1.getMeasureField(False);
3066 f2=m2.getMeasureField(False);
3067 self.assertEqual(5,f1.getArray().getNumberOfTuples());
3068 self.assertEqual(1,f2.getArray().getNumberOfTuples());
3070 self.assertAlmostEqual(expected1[i],f1.getIJ(i,0),12);
3072 self.assertAlmostEqual(expected1[0],f2.getIJ(0,0),12);
3075 def testChangeUnderlyingMesh1(self):
3076 mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
3077 mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
3078 f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3080 array=DataArrayDouble.New();
3081 arr=[7., 107., 8., 108., 9., 109., 10., 110., 11., 111., 12., 112., 13., 113., 14., 114., 15., 115., 16., 116.]
3082 array.setValues(arr,mesh1.getNumberOfCells(),2);
3085 renum=[0,2,1,3,4,5,6,8,7,9]
3086 mesh2.renumberCells(renum,False);
3087 #self.assertTrue(f1.getMesh()==mesh1);
3088 f1.changeUnderlyingMesh(mesh1,10,1e-12);# nothing done only to check that nothing done.
3089 #self.assertTrue(f1.getMesh()==mesh1);
3090 f1.changeUnderlyingMesh(mesh2,10,1e-12);
3091 #self.assertTrue(f1.getMesh()==mesh2);
3092 expected1=[7.,107.,9.,109.,8.,108.,10.,110.,11.,111.,12.,112.,13.,113.,15.,115.,14.,114.,16.,116.]
3094 self.assertAlmostEqual(expected1[i],f1.getArray().getIJ(0,i),12);
3097 f1=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
3099 array=DataArrayDouble.New();
3100 arr2=[7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.,17.,117.]
3101 array.setValues(arr2,mesh1.getNumberOfNodes(),2);
3104 renum2=[0,2,10,3,4,5,6,8,7,9,1]
3105 mesh2.renumberNodes(renum2,11);
3106 #self.assertTrue(f1.getMesh()==mesh1);
3107 f1.changeUnderlyingMesh(mesh2,10,1e-12);
3108 #self.assertTrue(f1.getMesh()==mesh2);
3109 expected2=[7.,107.,17.,117.,8.,108.,10.,110.,11.,111.,12.,112.,13.,113.,15.,115.,14.,114.,16.,116.,9.,109.]
3111 self.assertAlmostEqual(expected2[i],f1.getArray().getIJ(0,i),12);
3115 def testGetMaxValue1(self):
3116 m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
3117 nbOfCells=m.getNumberOfCells();
3118 f=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
3120 a1=DataArrayDouble.New();
3121 val1=[3.,4.,5.,6.,7.]
3122 a1.setValues(val1,nbOfCells,1);
3123 a2=DataArrayDouble.New();
3124 val2=[0.,1.,2.,8.,7.]
3125 a2.setValues(val2,nbOfCells,1);
3128 f.setEndTime(3.,3,4);
3129 f.checkConsistencyLight();
3131 self.assertAlmostEqual(8.,f.getMaxValue(),14);
3132 self.assertAlmostEqual(0.,f.getMinValue(),14);
3133 self.assertAlmostEqual(5.,f.getAverageValue(),14);
3134 self.assertAlmostEqual(5.125,f.getWeightedAverageValue(0,True),14);
3136 self.assertAlmostEqual(9.5,f.getMaxValue(),14);
3137 self.assertAlmostEqual(0.,f.getMinValue(),14);
3139 self.assertAlmostEqual(9.5,f.getMaxValue(),14);
3140 self.assertAlmostEqual(1.,f.getMinValue(),14);
3143 def testSubstractInPlaceDM1(self):
3144 mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
3145 mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
3146 f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3148 array=DataArrayDouble.New();
3149 arr=[7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.]
3150 array.setValues(arr,mesh1.getNumberOfCells(),2);
3153 self.assertEqual(10,f1.getNumberOfTuples());
3154 self.assertEqual(2,f1.getNumberOfComponents());
3155 self.assertEqual(20,f1.getNumberOfValues());
3157 renum=[0,2,3,1,4,5,6,8,7,9]
3158 mesh2.renumberCells(renum,False);
3160 f2=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3162 array=DataArrayDouble.New();
3163 arr2=[7.1,107.1,10.1,110.1,8.1,108.1,9.1,109.1,11.1,111.1,12.1,112.1,13.1,113.1,15.1,115.1,14.1,114.1,16.1,116.1]
3164 array.setValues(arr2,mesh2.getNumberOfCells(),2);
3167 f1.substractInPlaceDM(f2,10,1e-12);
3168 f1.applyFunc(1,"abs(x+y+0.2)");
3169 self.assertAlmostEqual(0.,f1.getMaxValue(),13);
3172 def testDotCrossProduct1(self):
3173 mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
3174 f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3175 f1.setTime(2.3,5,6);
3177 array=DataArrayDouble.New();
3178 arr1=[7.,107.,207.,8.,108.,208.,9.,109.,209.,10.,110.,210.,11.,111.,211.,12.,112.,212.,13.,113.,213.,14.,114.,214.,15.,115.,215.,16.,116.,216.]
3179 array.setValues(arr1,mesh1.getNumberOfCells(),3);
3181 f2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3182 f2.setTime(7.8,4,5);
3184 array=DataArrayDouble.New();
3185 arr2=[1.,2.,3.,4.,5.,6.,7.,8.,9.,10.,11.,12.,13.,14.,15.,16.,17.,18.,19.,20.,21.,22.,23.,24.,25.,26.,27.,28.,29.,30.]
3186 array.setValues(arr2,mesh1.getNumberOfCells(),3);
3190 expected1=[842.,1820.,2816.,3830.,4862.,5912.,6980.,8066.,9170.,10292.]
3192 self.assertAlmostEqual(expected1[i],f3.getIJ(i,0),9);
3195 f4=f1.crossProduct(f2);
3196 expected2=[-93., 186., -93., -392., 784., -392., -691., 1382., -691., -990., 1980., -990., -1289., 2578., -1289., -1588., 3176., -1588., -1887., 3774., -1887., -2186., 4372., -2186., -2485., 4970., -2485., -2784., 5568., -2784.]
3198 self.assertAlmostEqual(expected2[i],f4.getIJ(0,i),9);
3204 if __name__ == '__main__':