1 # -*- coding: utf-8 -*-
2 # Copyright (C) 2007-2016 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 unittest.TestCase.setUp(self)
36 print "start %s" % self.id()
39 unittest.TestCase.tearDown(self)
40 print "finish %s" % self.id()
43 arr=DataArrayDouble.New()
44 arr.setValues([12.,11.,10.,9.,8.,7.,6.,5.,4.,3.,2.,1.],3,4)
45 arr.setInfoOnComponent(0,"ggg");
46 arr.setInfoOnComponent(1,"hhhh");
47 arr.setInfoOnComponent(2,"jj");
48 arr.setInfoOnComponent(3,"kkkkkk");
49 arr2=arr.convertToIntArr();
50 arr3=arr2.convertToDblArr();
51 self.assertTrue(arr.isEqual(arr3,1e-14))
55 arr1=DataArrayInt.New();
56 arr1Ref=[0,10,1,11,2,12,3,13,4,14,5,15,6,16]
57 arr1.setValues(arr1Ref,7,2);
58 self.assertEqual(7,arr1.getNumberOfTuples());
59 self.assertEqual(2,arr1.getNumberOfComponents());
60 self.assertEqual(arr1Ref,list(arr1.getValues()));
61 arr2=arr1.subArray(3);
62 self.assertEqual(4,arr2.getNumberOfTuples());
63 self.assertEqual(2,arr2.getNumberOfComponents());
64 self.assertEqual(arr1Ref[6:],list(arr2.getValues()));
65 arr3=arr1.subArray(2,5);
66 self.assertEqual(3,arr3.getNumberOfTuples());
67 self.assertEqual(2,arr3.getNumberOfComponents());
68 self.assertEqual(arr1Ref[4:10],list(arr3.getValues()));
70 arr4=DataArrayDouble.New();
71 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]
72 arr4.setValues(arr4Ref,7,2);
73 self.assertEqual(7,arr4.getNumberOfTuples());
74 self.assertEqual(2,arr4.getNumberOfComponents());
77 self.assertTrue(abs(arr4Ref[i]-tmp[i])<1e-14);
79 arr5=arr4.subArray(3);
80 self.assertEqual(4,arr5.getNumberOfTuples());
81 self.assertEqual(2,arr5.getNumberOfComponents());
84 self.assertTrue(abs(arr4Ref[6+i]-tmp[i])<1e-14);
86 arr6=arr4.subArray(2,5);
87 self.assertEqual(3,arr6.getNumberOfTuples());
88 self.assertEqual(2,arr6.getNumberOfComponents());
91 self.assertTrue(abs(arr4Ref[4+i]-tmp[i])<1e-14);
96 tab4=[1, 2, 8, 7, 2, 3, 9, 8, 3,
97 4, 10, 9, 4, 5, 11, 10, 5,
98 0, 6, 11, 0, 1, 7, 6 ]
101 coords=[ 0.024155, 0.04183768725682622, -0.305, 0.04831000000000001, -1.015761910347357e-17,
102 -0.305, 0.09662000000000001, -1.832979297858306e-18, -0.305, 0.120775, 0.04183768725682623,
103 -0.305, 0.09662000000000001, 0.08367537451365245, -0.305, 0.04831000000000001, 0.08367537451365246,
104 -0.305, 0.024155, 0.04183768725682622, -0.2863, 0.04831000000000001, -1.015761910347357e-17, -0.2863,
105 0.09662000000000001, -1.832979297858306e-18, -0.2863, 0.120775, 0.04183768725682623, -0.2863, 0.09662000000000001,
106 0.08367537451365245, -0.2863, 0.04831000000000001, 0.08367537451365246, -0.2863 ]
107 self.assertEqual(MEDCouplingMesh.GetNumberOfNodesOfGeometricType(NORM_TRI3),3)
108 self.assertTrue(MEDCouplingMesh.IsStaticGeometricType(NORM_TRI3))
109 self.assertTrue(MEDCouplingMesh.IsLinearGeometricType(NORM_TRI3))
110 self.assertEqual(MEDCouplingMesh.GetDimensionOfGeometricType(NORM_TRI3),2)
111 self.assertEqual(MEDCouplingMesh.GetReprOfGeometricType(NORM_TRI3),"NORM_TRI3")
112 self.assertRaises(InterpKernelException,MEDCouplingMesh.GetNumberOfNodesOfGeometricType,NORM_POLYGON)
113 self.assertTrue(not MEDCouplingMesh.IsStaticGeometricType(NORM_POLYGON))
114 self.assertTrue(MEDCouplingMesh.IsLinearGeometricType(NORM_POLYGON))
115 self.assertEqual(MEDCouplingMesh.GetDimensionOfGeometricType(NORM_POLYGON),2)
116 self.assertEqual(MEDCouplingMesh.GetReprOfGeometricType(NORM_POLYGON),"NORM_POLYGON")
117 self.assertEqual(MEDCouplingMesh.GetNumberOfNodesOfGeometricType(NORM_TRI6),6)
118 self.assertTrue(MEDCouplingMesh.IsStaticGeometricType(NORM_TRI6))
119 self.assertTrue(not MEDCouplingMesh.IsLinearGeometricType(NORM_TRI6))
120 self.assertEqual(MEDCouplingMesh.GetDimensionOfGeometricType(NORM_TRI6),2)
121 self.assertEqual(MEDCouplingMesh.GetReprOfGeometricType(NORM_TRI6),"NORM_TRI6")
122 mesh=MEDCouplingUMesh.New()
123 mesh.setMeshDimension(2)
124 mesh.allocateCells(8);
125 mesh.setName("mesh1")
126 self.assertTrue(mesh.getName()=="mesh1")
127 for i in range(nbOfCells):
128 mesh.insertNextCell(NORM_QUAD4,4,tab4[4*i:4*(i+1)]);
130 mesh.finishInsertingCells()
131 self.assertTrue(mesh.getNumberOfCells()==nbOfCells)
132 self.assertTrue(mesh.getNodalConnectivity().getNbOfElems()==30)
133 self.assertTrue(mesh.getNodalConnectivityIndex().getNbOfElems()==nbOfCells+1)
134 myCoords=DataArrayDouble.New()
135 myCoords.setValues(coords,nbOfNodes,3);
136 self.assertTrue(myCoords.getIJ(3,2)==-0.305)
137 mesh.setCoords(myCoords);
138 mesh.checkConsistencyLight();
139 self.assertTrue(mesh.getAllGeoTypes()==[4])
140 myFalseConn=DataArrayInt.New()
141 myFalseConn.setValues(tab4,6,4)
142 self.assertTrue(myFalseConn.getIJ(1,1)==3)
144 field=MEDCouplingFieldDouble.New(ON_CELLS)
146 field.setNature(ExtensiveMaximum)
147 myCoords=DataArrayDouble.New()
149 for i in range(nbOfCells * 9):
150 sampleTab.append(float(i))
151 myCoords.setValues(sampleTab,nbOfCells,9);
152 field.setArray(myCoords)
153 self.assertTrue(3==mesh.getSpaceDimension())
154 field.checkConsistencyLight()
155 mesh2=mesh.clone(False)
156 mesh3=mesh.clone(True)
159 ## deep full recursively copy of field -> both field and mesh underneath copied
160 field2=field.clone(True)
161 field2.setMesh(field.getMesh().clone(True))
162 mesh3=mesh.clone(True)
163 field3=mesh3.fillFromAnalytic(ON_CELLS,2,"x*IVec+(y+z)*JVec")
164 field3.applyFunc("u*u*u+cos(u)")
167 def testMeshPointsCloud(self):
168 targetCoords=[-0.3,-0.3,0.5, 0.2,-0.3,1., 0.7,-0.3,1.5,
169 -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]
170 targetMesh=MEDCouplingUMesh.New();
171 targetMesh.setMeshDimension(0);
172 targetMesh.allocateCells(8);
173 targetMesh.insertNextCell(NORM_POINT1,1,[0]);
174 targetMesh.insertNextCell(NORM_POINT1,1,[1]);
175 targetMesh.insertNextCell(NORM_POINT1,1,[2]);
176 targetMesh.insertNextCell(NORM_POINT1,1,[3]);
177 targetMesh.insertNextCell(NORM_POINT1,1,[4]);
178 targetMesh.insertNextCell(NORM_POINT1,1,[5]);
179 targetMesh.insertNextCell(NORM_POINT1,1,[7]);
180 targetMesh.insertNextCell(NORM_POINT1,1,[6]);
181 targetMesh.finishInsertingCells();
182 self.assertRaises(InterpKernelException,targetMesh.checkConsistencyLight);
183 myCoords=DataArrayDouble.New();
184 myCoords.setValues(targetCoords,9,3);
185 targetMesh.setCoords(myCoords);
186 self.assertEqual(targetMesh.getSpaceDimension(),3)
187 self.assertEqual(targetMesh.getNumberOfCells(),8)
188 self.assertEqual(targetMesh.getNumberOfNodes(),9)
189 self.assertEqual(targetMesh.getMeshDimension(),0)
192 def testMeshM1D(self):
193 meshM1D=MEDCouplingUMesh.New();
194 self.assertRaises(InterpKernelException,meshM1D.getMeshDimension);
195 self.assertRaises(InterpKernelException,meshM1D.getNumberOfNodes);
196 self.assertRaises(InterpKernelException,meshM1D.getNumberOfCells);
197 self.assertRaises(InterpKernelException,meshM1D.setMeshDimension,-2)
198 self.assertRaises(InterpKernelException,meshM1D.setMeshDimension,-10)
199 meshM1D.setMeshDimension(-1);
200 meshM1D.checkConsistencyLight();
201 self.assertEqual(meshM1D.getMeshDimension(),-1);
202 self.assertEqual(meshM1D.getNumberOfCells(),1);
203 self.assertRaises(InterpKernelException,meshM1D.getNumberOfNodes);
204 self.assertRaises(InterpKernelException,meshM1D.getSpaceDimension);
205 cpy=meshM1D.clone(True);
206 self.assertTrue(cpy.isEqual(meshM1D,1e-12));
207 fieldOnCells=MEDCouplingFieldDouble.New(ON_CELLS);
208 fieldOnCells.setMesh(meshM1D);
209 array=DataArrayDouble.New();
210 array.setValues(6*[7.],1,6);
211 fieldOnCells.setArray(array);
212 fieldOnCells.checkConsistencyLight();
215 def testDeepCopy(self):
216 array=DataArrayDouble.New();
217 array.setValues(5*3*[7.],5,3);
218 self.assertEqual(array.getIJ(3,2),7.);
219 array2=array.deepCopy();
220 self.assertEqual(array2.getIJ(3,2),7.)
222 array3=DataArrayInt.New();
223 array3.setValues(5*3*[17],5,3);
224 self.assertEqual(array3.getIJ(3,2),17);
225 array4=array3.deepCopy();
226 self.assertEqual(array4.getIJ(3,2),17);
229 def testRevNodal(self):
230 mesh=MEDCouplingDataForTest.build2DTargetMesh_1()
231 revNodal,revNodalIndx=mesh.getReverseNodalConnectivity();
232 revNodalExpected=[0,0,1,1,2,0,3,0,1,2,3,4,2,4,3,3,4,4];
233 revNodalIndexExpected=[0,1,3,5,7,12,14,15,17,18];
234 self.assertEqual(revNodal.getNbOfElems(),18)
235 self.assertEqual(revNodalIndx.getNbOfElems(),10)
236 self.assertEqual(list(revNodal.getValues()),revNodalExpected)
237 self.assertEqual(list(revNodalIndx.getValues()),revNodalIndexExpected)
240 def testConvertToPolyTypes(self):
241 mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
243 mesh.convertToPolyTypes(elts);
244 mesh.checkConsistencyLight();
245 self.assertEqual(5,mesh.getNumberOfCells());
246 self.assertEqual(23,mesh.getNodalConnectivity().getNumberOfTuples());
247 expected1=[4, 0, 3, 4, 1, 5, 1, 4, 2, 3, 4, 5, 2, 5, 6, 7, 4, 3, 4, 7, 8, 5, 4]
248 self.assertEqual(expected1,list(mesh.getNodalConnectivity().getValues()));
250 mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
251 mesh.convertToPolyTypes(elts);
252 mesh.checkConsistencyLight();
253 self.assertEqual(8,mesh.getNumberOfCells());
254 self.assertEqual(114,mesh.getNodalConnectivity().getNumberOfTuples());
255 mesh.convertToPolyTypes(elts);
256 mesh.checkConsistencyLight();
257 self.assertEqual(8,mesh.getNumberOfCells());
258 self.assertEqual(114,mesh.getNodalConnectivity().getNumberOfTuples());
261 def testDescConn2D(self):
262 mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
263 desc=DataArrayInt.New();
264 descIndx=DataArrayInt.New();
265 revDesc=DataArrayInt.New();
266 revDescIndx=DataArrayInt.New();
267 mesh2=mesh.buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
268 mesh2.checkConsistencyLight();
269 self.assertEqual(1,mesh2.getMeshDimension());
270 self.assertEqual(13,mesh2.getNumberOfCells());
271 self.assertEqual(14,revDescIndx.getNbOfElems()); self.assertEqual(14,revDescIndx.getNumberOfTuples());
272 self.assertEqual(6,descIndx.getNbOfElems()); self.assertEqual(6,descIndx.getNumberOfTuples());
273 self.assertEqual(18,desc.getNbOfElems()); self.assertEqual(18,desc.getNumberOfTuples());
274 self.assertEqual(18,revDesc.getNbOfElems()); self.assertEqual(18,revDesc.getNumberOfTuples());
275 expected1=[0,1,2,3, 2,4,5, 6,7,4, 8,9,1,10, 11,12,6,9];
276 self.assertEqual(expected1,list(desc.getValues()));
277 expected2=[0,4,7,10,14,18];
278 self.assertEqual(expected2,list(descIndx.getValues()));
279 expected3=[0,1,3,5,6,8,9,11,12,13,15,16,17,18];
280 self.assertEqual(expected3,list(revDescIndx.getValues()));
281 expected4=[0, 0,3, 0,1, 0, 1,2, 1, 2,4, 2, 3, 3,4, 3, 4, 4];
282 self.assertEqual(expected4,list(revDesc.getValues()));
283 conn=mesh2.getNodalConnectivity();
284 connIndex=mesh2.getNodalConnectivityIndex();
285 expected5=[0,3,6,9,12,15,18,21,24,27,30,33,36,39];
286 self.assertEqual(expected5,list(connIndex.getValues()));
287 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];
288 self.assertEqual(expected6,list(conn.getValues()));
291 mesh.convertToPolyTypes(eltsV);
292 mesh.checkConsistencyLight();
294 desc=DataArrayInt.New();
295 descIndx=DataArrayInt.New();
296 revDesc=DataArrayInt.New();
297 revDescIndx=DataArrayInt.New();
299 mesh2=mesh.buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
300 mesh2.checkConsistencyLight();
301 self.assertEqual(1,mesh2.getMeshDimension());
302 self.assertEqual(13,mesh2.getNumberOfCells());
303 self.assertEqual(14,revDescIndx.getNbOfElems()); self.assertEqual(14,revDescIndx.getNumberOfTuples());
304 self.assertEqual(6,descIndx.getNbOfElems()); self.assertEqual(6,descIndx.getNumberOfTuples());
305 self.assertEqual(18,desc.getNbOfElems()); self.assertEqual(18,desc.getNumberOfTuples());
306 self.assertEqual(18,revDesc.getNbOfElems()); self.assertEqual(18,revDesc.getNumberOfTuples());
307 self.assertEqual(expected1,list(desc.getValues()));
308 self.assertEqual(expected2,list(descIndx.getValues()));
309 self.assertEqual(expected3,list(revDescIndx.getValues()));
310 self.assertEqual(expected4,list(revDesc.getValues()));
311 conn=mesh2.getNodalConnectivity();
312 connIndex=mesh2.getNodalConnectivityIndex();
313 self.assertEqual(expected5,list(connIndex.getValues()));
314 self.assertEqual(expected6,list(conn.getValues()));
317 def testDescConn3D(self):
318 mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
319 desc=DataArrayInt.New();
320 descIndx=DataArrayInt.New();
321 revDesc=DataArrayInt.New();
322 revDescIndx=DataArrayInt.New();
324 mesh2=mesh.buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
325 mesh2.checkConsistencyLight();
326 self.assertEqual(2,mesh2.getMeshDimension());
327 self.assertEqual(36,mesh2.getNumberOfCells());
328 self.assertEqual(37,revDescIndx.getNbOfElems()); self.assertEqual(37,revDescIndx.getNumberOfTuples());
329 self.assertEqual(9,descIndx.getNbOfElems()); self.assertEqual(9,descIndx.getNumberOfTuples());
330 self.assertEqual(48,desc.getNbOfElems()); self.assertEqual(48,desc.getNumberOfTuples());
331 self.assertEqual(48,revDesc.getNbOfElems()); self.assertEqual(48,revDesc.getNumberOfTuples());
332 expected1=[0, 6, 12, 18, 24, 30, 36, 42, 48]
333 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]
334 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]
335 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]
336 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]
337 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,
338 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,
339 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,
340 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]
341 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,
342 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,
343 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,
344 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]
346 self.assertEqual(expected1,list(descIndx.getValues()));
347 self.assertEqual(expected2,list(desc.getValues()));
348 self.assertEqual(expected3,list(revDescIndx.getValues()));
349 self.assertEqual(expected4,list(revDesc.getValues()));
350 self.assertEqual(expected5,list(mesh2.getNodalConnectivityIndex().getValues()));
351 self.assertEqual(expected6,list(mesh2.getNodalConnectivity().getValues()));
354 mesh.convertToPolyTypes(eltsV);
355 mesh.checkConsistencyLight();
356 desc=DataArrayInt.New();
357 descIndx=DataArrayInt.New();
358 revDesc=DataArrayInt.New();
359 revDescIndx=DataArrayInt.New();
360 mesh2=mesh.buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
361 mesh2.checkConsistencyLight();
362 self.assertEqual(2,mesh2.getMeshDimension());
363 self.assertEqual(36,mesh2.getNumberOfCells());
364 self.assertEqual(37,revDescIndx.getNbOfElems()); self.assertEqual(37,revDescIndx.getNumberOfTuples());
365 self.assertEqual(9,descIndx.getNbOfElems()); self.assertEqual(9,descIndx.getNumberOfTuples());
366 self.assertEqual(48,desc.getNbOfElems()); self.assertEqual(48,desc.getNumberOfTuples());
367 self.assertEqual(48,revDesc.getNbOfElems()); self.assertEqual(48,revDesc.getNumberOfTuples());
368 self.assertEqual(expected1,list(descIndx.getValues()));
369 self.assertEqual(expected2,list(desc.getValues()));
370 self.assertEqual(expected3,list(revDescIndx.getValues()));
371 self.assertEqual(expected4,list(revDesc.getValues()));
372 self.assertEqual(expected5,list(mesh2.getNodalConnectivityIndex().getValues()));
373 self.assertEqual(expected7,list(mesh2.getNodalConnectivity().getValues()));
376 def testFindBoundaryNodes(self):
377 mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
378 boundaryNodes=mesh.findBoundaryNodes();
379 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];
380 self.assertEqual(expected1,boundaryNodes.getValues());
383 def testBoundaryMesh(self):
384 mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
385 mesh2=mesh.buildBoundaryMesh(False);
386 self.assertEqual(24,mesh2.getNumberOfCells());
387 self.assertEqual(26,mesh2.getNumberOfNodes());
390 def testBuildPartOfMySelf(self):
391 mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
392 mesh.setName("Toto");
396 subMesh=mesh.buildPart(tab1)
397 self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
398 subMesh=mesh.buildPartOfMySelf(tab1,True);
399 self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
400 name=subMesh.getName();
401 self.assertEqual(2,len(mesh.getAllGeoTypes()));
402 self.assertEqual(NORM_TRI3,mesh.getAllGeoTypes()[0]);
403 self.assertEqual(NORM_QUAD4,mesh.getAllGeoTypes()[1]);
404 self.assertEqual(1,len(subMesh.getAllGeoTypes()));
405 self.assertEqual(NORM_QUAD4,subMesh.getAllGeoTypes()[0]);
406 self.assertEqual(name,"Toto");
407 self.assertEqual(2,subMesh.getNumberOfCells());
408 subConn=[4,0,3,4,1,4,7,8,5,4];
409 subConnIndex=[0,5,10];
410 self.assertEqual(10,subMesh.getNodalConnectivity().getNbOfElems());
411 self.assertEqual(3,subMesh.getNodalConnectivityIndex().getNbOfElems());
412 self.assertEqual(subConn[0:10],list(subMesh.getNodalConnectivity().getValues()));
413 self.assertEqual(subConnIndex[0:3],list(subMesh.getNodalConnectivityIndex().getValues()));
415 subMesh=mesh.buildPartOfMySelf(tab2[0:3],True);
416 self.assertTrue(isinstance(subMesh,MEDCouplingUMesh));
417 name=subMesh.getName();
418 self.assertEqual(2,len(subMesh.getAllGeoTypes()));
419 self.assertEqual(NORM_TRI3,subMesh.getAllGeoTypes()[0]);
420 self.assertEqual(NORM_QUAD4,subMesh.getAllGeoTypes()[1]);
421 self.assertEqual(name,"Toto");
422 self.assertEqual(3,subMesh.getNumberOfCells());
423 subConn2=[4,0,3,4,1,3,4,5,2,4,6,7,4,3]
424 subConnIndex2=[0,5,9,14]
425 self.assertEqual(14,subMesh.getNodalConnectivity().getNbOfElems());
426 self.assertEqual(4,subMesh.getNodalConnectivityIndex().getNbOfElems());
427 self.assertEqual(subConn2[0:14],list(subMesh.getNodalConnectivity().getValues()));
428 self.assertEqual(subConnIndex2[0:4],list(subMesh.getNodalConnectivityIndex().getValues()));
429 dd=DataArrayInt.New()
433 subMesh=subMesh.buildPartOfMySelf(dd,True);
434 self.assertEqual("coucou",subMesh.getName());
437 def testBuildPartOfMySelfNode(self):
438 mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
440 subMesh=mesh.buildPartOfMySelfNode(tab1[0:4],True);
441 self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
442 self.assertEqual(1,len(subMesh.getAllGeoTypes()));
443 self.assertEqual(NORM_QUAD4,subMesh.getAllGeoTypes()[0]);
444 self.assertEqual(1,subMesh.getNumberOfCells());
445 self.assertEqual(5,subMesh.getNodalConnectivity().getNbOfElems());
446 self.assertEqual(2,subMesh.getNodalConnectivityIndex().getNbOfElems());
449 self.assertEqual(subConn[0:5],list(subMesh.getNodalConnectivity().getValues()));
450 self.assertEqual(subConnIndex[0:2],list(subMesh.getNodalConnectivityIndex().getValues()));
452 ddd=DataArrayInt.New()
453 ddd.setValues(tab1[0:2],2,1)
455 subMesh=mesh.buildPartOfMySelfNode(ddd,False);
456 self.assertEqual("ddd",subMesh.getName())
457 self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
458 self.assertEqual(2,len(subMesh.getAllGeoTypes()));
459 self.assertEqual(NORM_TRI3,subMesh.getAllGeoTypes()[0]);
460 self.assertEqual(NORM_QUAD4,subMesh.getAllGeoTypes()[1]);
461 self.assertEqual(3,subMesh.getNumberOfCells());
462 self.assertEqual(14,subMesh.getNodalConnectivity().getNbOfElems());
463 self.assertEqual(4,subMesh.getNodalConnectivityIndex().getNbOfElems());
464 subConn2=[3,4,5,2,4,6,7,4,3,4,7,8,5,4]
465 subConnIndex2=[0,4,9,14]
466 self.assertEqual(subConn2[0:14],list(subMesh.getNodalConnectivity().getValues()));
467 self.assertEqual(subConnIndex2[0:4],list(subMesh.getNodalConnectivityIndex().getValues()));
468 #testing the case where length of tab2 is greater than max number of node per cell.
470 subMesh=mesh.buildPartOfMySelfNode(tab2[0:7],True);
471 self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
472 self.assertEqual(2,len(subMesh.getAllGeoTypes()));
473 self.assertEqual(NORM_TRI3,subMesh.getAllGeoTypes()[0]);
474 self.assertEqual(NORM_QUAD4,subMesh.getAllGeoTypes()[1]);
475 self.assertEqual(3,subMesh.getNumberOfCells());
478 def testZipCoords(self):
479 mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
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 oldConn=mesh.getNodalConnectivity().getValues()[0:mesh.getNodalConnectivity().getNbOfElems()];
485 oldConnIndex=mesh.getNodalConnectivityIndex().getValues()[0:mesh.getNumberOfCells()+1]
486 oldCoords=mesh.getCoords();
488 self.assertEqual(2,len(mesh.getAllGeoTypes()));
489 self.assertEqual(2,mesh.getSpaceDimension());
490 self.assertEqual(9,mesh.getNumberOfNodes());
491 self.assertEqual(5,mesh.getNumberOfCells());
492 self.assertEqual(mesh.getCoords().getValues()[0:2*9],oldCoords.getValues());
493 self.assertEqual(list(oldConn),list(mesh.getNodalConnectivity().getValues()));
494 self.assertEqual(list(oldConnIndex),list(mesh.getNodalConnectivityIndex().getValues()));
497 subMesh=mesh.buildPartOfMySelf(tab1,True);
498 self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
499 traducer=subMesh.zipCoordsTraducer();
500 expectedTraducer=[0, 1, -1, 2, 3, 4, -1, 5, 6]
501 self.assertEqual(expectedTraducer,list(traducer.getValues()));
502 self.assertEqual(NORM_QUAD4,subMesh.getAllGeoTypes()[0]);
503 self.assertEqual(2,subMesh.getNumberOfCells());
504 subConn=[4,0,2,3,1,4,5,6,4,3]
505 subConnIndex=[0,5,10]
506 self.assertEqual(7,subMesh.getNumberOfNodes());
507 self.assertEqual(10,subMesh.getNodalConnectivity().getNbOfElems());
508 self.assertEqual(3,subMesh.getNodalConnectivityIndex().getNbOfElems());
509 self.assertEqual(subConn,list(subMesh.getNodalConnectivity().getValues()));
510 self.assertEqual(subConnIndex,list(subMesh.getNodalConnectivityIndex().getValues()));
512 subMesh=mesh.buildPartOfMySelf(tab1,False);
513 self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
514 self.assertEqual(NORM_QUAD4,subMesh.getAllGeoTypes()[0]);
515 self.assertEqual(2,subMesh.getNumberOfCells());
516 self.assertEqual(7,subMesh.getNumberOfNodes());
517 self.assertEqual(10,subMesh.getNodalConnectivity().getNbOfElems());
518 self.assertEqual(3,subMesh.getNodalConnectivityIndex().getNbOfElems());
519 self.assertEqual(subConn,list(subMesh.getNodalConnectivity().getValues()));
520 self.assertEqual(subConnIndex,list(subMesh.getNodalConnectivityIndex().getValues()));
523 def testZipConnectivity(self):
524 m1=MEDCouplingDataForTest.build2DTargetMesh_1();
525 m2=MEDCouplingDataForTest.build2DTargetMesh_1();
527 m3=m2.buildPartOfMySelf(cells1,True);
528 self.assertTrue(isinstance(m3,MEDCouplingUMesh))
529 m4=MEDCouplingDataForTest.build2DSourceMesh_1();
530 m5=MEDCouplingUMesh.MergeUMeshes(m1,m3);
531 m6=MEDCouplingUMesh.MergeUMeshes(m5,m4);
533 self.assertEqual(10,m6.getNumberOfCells());
534 self.assertEqual(22,m6.getNumberOfNodes());
535 (arr,areNodesMerged,newNbOfNodes)=m6.mergeNodes(1e-13);
536 self.assertTrue(areNodesMerged);
537 self.assertEqual(10,m6.getNumberOfCells());
538 self.assertEqual(9,m6.getNumberOfNodes());
540 arr=m6.zipConnectivityTraducer(0);
541 self.assertEqual(7,m6.getNumberOfCells());
543 arr=m6.zipConnectivityTraducer(0);
544 self.assertTrue(m7.isEqual(m6,1e-12));
545 self.assertEqual(7,m6.getNumberOfCells());
548 def testEqualMesh(self):
549 mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
550 mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
552 self.assertTrue(mesh1.isEqual(mesh1,1e-12));
554 self.assertTrue(mesh1.isEqual(mesh2,1e-12));
555 self.assertTrue(mesh2.isEqual(mesh1,1e-12));
556 pt=mesh2.getCoords().getValues();
558 mesh2.getCoords().setIJ(0,1,5.999);
559 self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
560 self.assertTrue(not mesh2.isEqual(mesh1,1e-12));
561 mesh2.getCoords().setIJ(0,1,tmp);
562 self.assertTrue(mesh1.isEqual(mesh2,1e-12));
563 self.assertTrue(mesh2.isEqual(mesh1,1e-12));
565 pt2=mesh1.getNodalConnectivity().getValues();
566 mesh1.getNodalConnectivity().setIJ(5,0,int(pt2[5])+1);
567 self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
568 self.assertTrue(not mesh2.isEqual(mesh1,1e-12));
569 mesh1.getNodalConnectivity().setIJ(5,0,int(pt2[5]));
570 self.assertTrue(mesh1.isEqual(mesh2,1e-12));
571 self.assertTrue(mesh2.isEqual(mesh1,1e-12));
573 pt2=mesh1.getNodalConnectivityIndex().getValues();
574 mesh1.getNodalConnectivityIndex().setIJ(1,0,int(pt2[1]+1));
575 self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
576 self.assertTrue(not mesh2.isEqual(mesh1,1e-12));
577 mesh1.getNodalConnectivityIndex().setIJ(1,0,int(pt2[1]));
578 self.assertTrue(mesh1.isEqual(mesh2,1e-12));
579 self.assertTrue(mesh2.isEqual(mesh1,1e-12));
581 tmp3=mesh1.getName();
582 mesh1.setName("lllll");
583 self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
584 self.assertTrue(not mesh2.isEqual(mesh1,1e-12));
586 self.assertTrue(mesh1.isEqual(mesh2,1e-12));
587 self.assertTrue(mesh2.isEqual(mesh1,1e-12));
589 tmp3=mesh2.getCoords().getInfoOnComponent(1);
590 mesh2.getCoords().setInfoOnComponent(1,"kkkkkk");
591 self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
592 self.assertTrue(not mesh2.isEqual(mesh1,1e-12));
593 mesh2.getCoords().setInfoOnComponent(1,tmp3);
594 self.assertTrue(mesh1.isEqual(mesh2,1e-12));
595 self.assertTrue(mesh2.isEqual(mesh1,1e-12));
598 def testEqualFieldDouble(self):
599 mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
600 mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
602 fieldOnCells1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
603 fieldOnCells1.setMesh(mesh1);
604 fieldOnCells2=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
605 fieldOnCells2.setMesh(mesh2);
607 self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
608 self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
610 fieldOnNodes1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
611 self.assertTrue(not fieldOnCells1.isEqual(fieldOnNodes1,1e-12,1e-15));
612 self.assertTrue(not fieldOnNodes1.isEqual(fieldOnCells1,1e-12,1e-15));
614 fieldOnCells2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
615 self.assertEqual(fieldOnCells2.getMesh(),None) # to check that convertMesh wrapping do not raise but return Py_None
616 self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
617 self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
618 fieldOnCells1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
619 self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
620 self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
621 fieldOnCells1.setTime(4.,6,7);
622 self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
623 self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
624 fieldOnCells2.setTime(4.,6,7);
625 self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
626 self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
627 fieldOnCells1.setName("Power");
628 self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
629 self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
630 fieldOnCells2.setName("Power");
631 self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
632 self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
634 fieldOnCells1.setMesh(mesh1);
635 self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
636 self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
637 fieldOnCells2.setMesh(mesh1);
638 self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
639 self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
640 arr=DataArrayDouble.New();
642 arr.setValues(mesh1.getNumberOfCells()*3*[6.],mesh1.getNumberOfCells(),3);
643 fieldOnCells1.setArray(arr);
644 self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
645 self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
646 fieldOnCells2.setArray(arr);
647 self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
648 self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
651 fieldOnCells2.setArray(arr2);
652 self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
653 self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
655 self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
656 self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
658 self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
659 self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
660 arr2.setName("popo2");
661 self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
662 self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
664 arr2.setName("popo");
665 self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
666 self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
668 arr2.setInfoOnComponent(2,"jjj");
669 self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
670 self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
671 arr.setInfoOnComponent(2,"jjj");
672 self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
673 self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
676 def testNatureChecking(self):
677 field=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
678 field.setNature(ExtensiveMaximum);
679 field.setNature(IntensiveMaximum);
680 field.setNature(ExtensiveConservation);
681 field=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
682 field.setNature(IntensiveMaximum);
683 self.assertRaises(InterpKernelException,field.setNature,ExtensiveMaximum);
684 self.assertRaises(InterpKernelException,field.setNature,ExtensiveConservation);
687 def testNatureOperations(self):
688 """ Check nature constraints on field operations """
689 m = MEDCouplingCMesh()
690 m.setCoordsAt(0, DataArrayDouble([1.0,2.0,3.0]))
691 m.setCoordsAt(1, DataArrayDouble([1.0,2.0,3.0]))
692 m = m.buildUnstructured()
693 f1, f2 = MEDCouplingFieldDouble.New(ON_CELLS, NO_TIME), MEDCouplingFieldDouble.New(ON_CELLS, NO_TIME)
694 f1.setNature(ExtensiveMaximum)
695 f2.setNature(IntensiveMaximum)
696 self.assertEqual(ExtensiveMaximum, f1.getNature())
697 self.assertEqual(IntensiveMaximum, f2.getNature())
699 da = DataArrayDouble([1.0,2.0,3.0,4.0])
700 f1.setMesh(m); f2.setMesh(m)
701 f1.setArray(da); f2.setArray(da.deepCopy())
702 # All this should complain about nature:
703 self.assertRaises(InterpKernelException, f1.__add__, f2)
704 self.assertRaises(InterpKernelException, f1.__iadd__, f2)
705 self.assertRaises(InterpKernelException, f1.__sub__, f2)
706 self.assertRaises(InterpKernelException, f1.__isub__, f2)
707 self.assertRaises(InterpKernelException, f1.__radd__, f2)
708 self.assertRaises(InterpKernelException, f1.__rsub__, f2)
709 self.assertRaises(InterpKernelException, MEDCouplingFieldDouble.AddFields, f1, f2)
710 self.assertRaises(InterpKernelException, MEDCouplingFieldDouble.SubstractFields, f1, f2)
711 self.assertRaises(InterpKernelException, MEDCouplingFieldDouble.MaxFields, f1, f2)
712 self.assertRaises(InterpKernelException, MEDCouplingFieldDouble.MinFields, f1, f2)
714 f3 = MEDCouplingFieldDouble.MultiplyFields(f1,f2)
715 self.assertEqual(NoNature, f3.getNature())
717 self.assertEqual(NoNature, f3.getNature())
718 f1Tmp = f1.deepCopy(); f1Tmp.setMesh(m); f1Tmp *= f2
719 self.assertEqual(NoNature, f1Tmp.getNature())
720 f3 = MEDCouplingFieldDouble.DivideFields(f1,f2)
721 self.assertEqual(NoNature, f3.getNature())
723 self.assertEqual(NoNature, f3.getNature())
724 f1Tmp = f1.deepCopy(); f1Tmp.setMesh(m); f1Tmp /= f2
725 self.assertEqual(NoNature, f1Tmp.getNature())
726 # f3 = MEDCouplingFieldDouble.PowFields(f1,f2)
727 # self.assertEqual(NoNature, f3.getNature())
729 self.assertEqual(NoNature, f3.getNature())
730 f1Tmp = f1.deepCopy(); f1Tmp.setMesh(m); f1Tmp **= f2
731 self.assertEqual(NoNature, f1Tmp.getNature())
732 f3 = MEDCouplingFieldDouble.DotFields(f1,f2)
733 self.assertEqual(NoNature, f3.getNature())
735 self.assertEqual(NoNature, f3.getNature())
737 da = DataArrayDouble.Meld([da, da, da])
738 f1.setArray(da); f2.setArray(da.deepCopy())
739 f3 = MEDCouplingFieldDouble.CrossProductFields(f1,f2)
740 self.assertEqual(NoNature, f3.getNature())
741 f3 = f1.crossProduct(f2)
743 def testBuildSubMeshData(self):
744 targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1()
745 #check buildSubMesh on field on cells
746 fieldCells=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
747 fieldCells.setMesh(targetMesh);
749 ret1,di=fieldCells.buildSubMeshData(elts);
750 self.assertTrue(isinstance(ret1,MEDCouplingUMesh))
751 self.assertEqual(3,ret1.getNumberOfCells());
752 self.assertEqual(9,ret1.getNumberOfNodes());
753 self.assertEqual(3,di.getNumberOfTuples());
754 self.assertEqual(1,di.getNumberOfComponents());
755 toCheck=di.getValues();
756 self.assertTrue(elts,toCheck);
757 #check buildSubMesh on field on nodes
758 fieldNodes=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
759 fieldNodes.setMesh(targetMesh);
760 ret2,di=fieldNodes.buildSubMeshData(elts);
761 self.assertTrue(isinstance(ret2,MEDCouplingUMesh))
762 self.assertEqual(3,ret2.getNumberOfCells());
763 self.assertEqual(6,ret2.getNumberOfNodes());
764 self.assertEqual(6,di.getNumberOfTuples());
765 self.assertEqual(1,di.getNumberOfComponents());
766 toCheck=di.getValues();
767 expected=[1,2,4,5,7,8]
768 self.assertEqual(expected,list(toCheck));
771 def testExtrudedMesh1(self):
772 mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
773 ext=MEDCouplingMappedExtrudedMesh.New(mesh3D,mesh2D,1);
774 self.assertEqual(18,ext.getNumberOfCells());
775 self.assertEqual(60,ext.getNumberOfNodes());
776 ids3D=ext.getMesh3DIds();
777 ids3DExpected=[5,4,3,2,1,0, 11,10,9,8,7,6, 17,16,15,14,13,12]
778 self.assertEqual(18,ids3D.getNumberOfTuples());
779 self.assertEqual(1,ids3D.getNumberOfComponents());
780 self.assertEqual(ids3DExpected,list(ids3D.getValues()));
781 mesh1D=ext.getMesh1D();
782 self.assertEqual(4,mesh1D.getNumberOfNodes());
783 self.assertEqual(3,mesh1D.getNumberOfCells());
784 mesh1DExpected=[0.66666666666666663, 1.4583333333333333, 0, 0.66666666666666663,
785 1.4583333333333333, 1, 0.66666666666666663, 1.4583333333333333,
786 2, 0.66666666666666663, 1.4583333333333333, 3]
787 mesh1DCoords=mesh1D.getCoords();
788 self.assertEqual(4,mesh1DCoords.getNumberOfTuples());
789 self.assertEqual(3,mesh1DCoords.getNumberOfComponents());
790 self.assertEqual(mesh1DExpected,mesh1DCoords.getValues());
791 conn1D=mesh1D.getNodalConnectivity();
792 self.assertEqual(9,conn1D.getNumberOfTuples());
793 self.assertEqual(1,conn1D.getNumberOfComponents());
794 conn1DExpected=[1,0,1,1,1,2,1,2,3]
795 self.assertEqual(conn1DExpected,list(conn1D.getValues()));
798 def testExtrudedMesh3(self):
799 m1=MEDCouplingDataForTest.build2DTargetMesh_1();
800 m1.changeSpaceDimension(3);
801 m2=MEDCouplingDataForTest.buildCU1DMesh_U();
802 m2.changeSpaceDimension(3);
805 m2.rotate(center,vector,-pi/2.);
806 m3=m1.buildExtrudedMesh(m2,0);
808 m4=MEDCouplingMappedExtrudedMesh.New(m3,m1,0);
809 self.assertEqual(15,m4.getNumberOfCells());
810 self.assertEqual(5,m4.getMesh2D().getNumberOfCells());
811 self.assertEqual(3,m4.getMesh1D().getNumberOfCells());
812 m3DIds=m4.getMesh3DIds().getValues();
813 self.assertEqual(list(range(15)), list(m3DIds));
814 #some random in cells to check that extrusion alg find it correctly
815 expected1=[1,3,2,0,6,5,7,10,11,8,12,9,14,13,4]
816 m3.renumberCells(expected1,False);
817 m4=MEDCouplingMappedExtrudedMesh.New(m3,m1,0);
818 self.assertEqual(15,m4.getNumberOfCells());
819 self.assertEqual(5,m4.getMesh2D().getNumberOfCells());
820 self.assertEqual(3,m4.getMesh1D().getNumberOfCells());
821 m3DIds=m4.getMesh3DIds().getValues();
822 self.assertEqual(expected1,list(m3DIds));
823 #play with polygons and polyedrons
825 m1.convertToPolyTypes(cells);
826 m3=m1.buildExtrudedMesh(m2,0);
827 self.assertEqual(NORM_HEXA8,m3.getTypeOfCell(0));
828 self.assertEqual(NORM_PENTA6,m3.getTypeOfCell(1));
829 self.assertEqual(NORM_POLYHED,m3.getTypeOfCell(2));
830 self.assertEqual(NORM_POLYHED,m3.getTypeOfCell(3));
831 self.assertEqual(NORM_HEXA8,m3.getTypeOfCell(4));
832 m3.renumberCells(expected1,False);
833 m4=MEDCouplingMappedExtrudedMesh.New(m3,m1,0);
834 self.assertEqual(15,m4.getNumberOfCells());
835 self.assertEqual(5,m4.getMesh2D().getNumberOfCells());
836 self.assertEqual(3,m4.getMesh1D().getNumberOfCells());
837 m3DIds=m4.getMesh3DIds().getValues();
838 self.assertEqual(expected1,list(m3DIds));
841 def testExtrudedMesh4(self):
842 m1=MEDCouplingDataForTest.build2DTargetMesh_1();
844 m1.convertToPolyTypes(cells);
845 m1.changeSpaceDimension(3);
846 m2=MEDCouplingDataForTest.buildCU1DMesh_U();
847 m2.changeSpaceDimension(3);
850 m2.rotate(center,vector,-pi/2.);
852 m3=m1.buildExtrudedMesh(m2,0);
853 expected1=[1,3,2,0,6,5,7,10,11,8,12,9,14,13,4]
854 rexpected1=[3, 0, 2, 1, 14, 5, 4, 6, 9, 11, 7, 8, 10, 13, 12]
855 m3.renumberCells(expected1,False);
856 m4=MEDCouplingMappedExtrudedMesh.New(m3,m1,0);
857 self.assertEqual(NORM_HEXA8,m4.getTypeOfCell(0));
858 self.assertEqual(NORM_HEXA8,m4.getTypeOfCell(1));
859 self.assertEqual(NORM_POLYHED,m4.getTypeOfCell(2));
860 self.assertEqual(NORM_PENTA6,m4.getTypeOfCell(7));
861 f=m4.getMeasureField(True);
863 self.assertEqual(15,arr.getNumberOfTuples());
864 self.assertEqual(1,arr.getNumberOfComponents());
865 arrPtr=arr.getValues();
866 expected2=[0.075,0.0375,0.0375,0.075,0.075,
867 0.1125,0.05625,0.05625,0.1125,0.1125,
868 0.0625,0.03125,0.03125,0.0625,0.0625]
870 self.assertAlmostEqual(expected2[rexpected1[i]],arrPtr[i],16);
872 m5=m4.build3DUnstructuredMesh();
874 self.assertTrue(m5.isEqual(m3,1e-12));
875 f=m5.getMeasureField(True);
877 self.assertTrue(isinstance(f.getMesh(),MEDCouplingMappedExtrudedMesh))
879 arrPtr=arr.getValues();
881 self.assertAlmostEqual(expected2[rexpected1[i]],arrPtr[i],15);
885 def testFindCommonNodes(self):
886 targetMesh=MEDCouplingDataForTest.build3DTargetMesh_1();
887 comm,commI=targetMesh.findCommonNodes(1e-10,-1);
888 self.assertEqual(1,commI.getNumberOfTuples());
889 self.assertEqual(0,comm.getNumberOfTuples());
890 o2n,newNbOfNodes=targetMesh.buildNewNumberingFromCommonNodesFormat(comm,commI);
891 self.assertEqual(27,newNbOfNodes);
892 self.assertEqual(27,o2n.getNumberOfTuples());
893 o2nExp1 = list(range(27))
894 self.assertEqual(o2nExp1,list(o2n.getValues()));
896 targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
897 self.assertEqual(31,targetMesh.getNumberOfNodes());
898 comm,commI=targetMesh.findCommonNodes(1e-10);# testing default parameter
899 self.assertEqual(3,commI.getNumberOfTuples());
900 self.assertEqual(6,comm.getNumberOfTuples());
901 commExpected=[1,27,28,29,23,30]
902 commIExpected=[0,4,6]
903 self.assertEqual(commExpected,list(comm.getValues()));
904 self.assertEqual(commIExpected,list(commI.getValues()));
905 o2n,newNbOfNodes=targetMesh.buildNewNumberingFromCommonNodesFormat(comm,commI);
906 self.assertEqual(31,o2n.getNumberOfTuples());
907 self.assertEqual(27,newNbOfNodes);
908 o2nExp2=[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,
909 21,22,23,24,25,26,1,1,1,23]
910 self.assertEqual(o2nExp2,list(o2n.getValues()));
912 targetMesh=MEDCouplingDataForTest.build3DTargetMesh_1();
913 time=targetMesh.getTimeOfThis();
914 o2n,areNodesMerged,newNbOfNodes=targetMesh.mergeNodes(1e-10);
915 targetMesh.updateTime();
916 self.assertEqual(time,targetMesh.getTimeOfThis());
917 self.assertTrue(not areNodesMerged);
919 targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
920 time=targetMesh.getTimeOfThis();
921 o2n,areNodesMerged,newNbOfNodes=targetMesh.mergeNodes(1e-10);
922 targetMesh.updateTime();
923 self.assertTrue(time!=targetMesh.getTimeOfThis());
924 self.assertTrue(areNodesMerged);
925 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,
926 18,4,5,8,7,13,14,17,16,
927 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,
928 18,13,14,17,16,22,23,26,25]
929 self.assertEqual(72,targetMesh.getNodalConnectivity().getNumberOfTuples());
930 self.assertEqual(connExp,list(targetMesh.getNodalConnectivity().getValues()));
931 self.assertEqual(27,targetMesh.getCoords().getNumberOfTuples());
932 coordsExp=[ 0., 0., 0., 50., 0., 0. , 200., 0., 0. , 0., 50., 0., 50., 50., 0. ,
933 200., 50., 0., 0., 200., 0., 50., 200., 0. , 200., 200., 0. ,
934 0., 0., 50., 50., 0., 50. , 200., 0., 50. , 0., 50., 50., 50.,
935 50., 50. , 200., 50., 50., 0., 200., 50., 50., 200., 50. ,
936 200., 200., 50. , 0., 0., 200., 50., 0., 200. , 200., 0., 200.
937 , 0., 50., 200., 50., 50., 200. , 200., 50., 200.,
938 0., 200., 200., 50., 200., 200. , 200., 200., 200. ]
939 self.assertEqual(coordsExp,targetMesh.getCoords().getValues());
941 targetMesh=MEDCouplingDataForTest.build2DTargetMeshMergeNode_1();
942 self.assertEqual(18,targetMesh.getNumberOfNodes());
943 time=targetMesh.getTimeOfThis();
944 o2n,areNodesMerged,newNbOfNodes=targetMesh.mergeNodes(1e-10);
945 self.assertTrue(time!=targetMesh.getTimeOfThis());
946 self.assertTrue(areNodesMerged);
947 self.assertEqual(9,targetMesh.getNumberOfNodes());
948 connExp2=[4,0,4,3,1, 3,1,3,2, 3,3,5,2, 4,4,6,7,3, 4,7,8,5,3]
949 self.assertEqual(23,targetMesh.getNodalConnectivity().getNumberOfTuples());
950 self.assertEqual(connExp2,list(targetMesh.getNodalConnectivity().getValues()));
951 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]
952 self.assertEqual(9,targetMesh.getCoords().getNumberOfTuples());
953 self.assertEqual(coordsExp2,targetMesh.getCoords().getValues());
956 def testCheckButterflyCells(self):
957 sourceMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
958 cells=sourceMesh.checkButterflyCells();
959 self.assertEqual(0,len(cells));
960 conn=sourceMesh.getNodalConnectivity()
962 conn.setIJ(15,0,conn.getIJ(16,0))
964 cells=sourceMesh.checkButterflyCells();
965 self.assertEqual(1,len(cells));
966 self.assertEqual([3],cells.getValues());
968 conn.setIJ(15,0,conn.getIJ(16,0))
970 cells=sourceMesh.checkButterflyCells();
971 self.assertEqual(0,len(cells));
973 sourceMesh=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
974 cells=sourceMesh.checkButterflyCells();
975 self.assertEqual(0,len(cells));
976 conn=sourceMesh.getNodalConnectivity()
978 conn.setIJ(15,0,conn.getIJ(16,0))
980 cells=sourceMesh.checkButterflyCells();
981 self.assertEqual(1,len(cells));
982 self.assertEqual([3],cells.getValues());
984 conn.setIJ(15,0,conn.getIJ(16,0))
986 cells=sourceMesh.checkButterflyCells();
987 self.assertEqual(0,len(cells));
990 def testMergeMesh1(self):
991 m1=MEDCouplingDataForTest.build2DTargetMesh_1();
992 m2=MEDCouplingDataForTest.build2DSourceMesh_1();
995 m3=m1.mergeMyselfWith(m2);
996 self.assertTrue(isinstance(m3,MEDCouplingUMesh));
997 m3.checkConsistencyLight();
998 m4=MEDCouplingDataForTest.build2DTargetMeshMerged_1();
999 self.assertTrue(m3.isEqual(m4,1.e-12));
1000 da,isMerged,newNbOfNodes=m3.mergeNodes(1.e-12);
1001 self.assertEqual(11,m3.getNumberOfNodes());
1002 self.assertTrue(isMerged);
1005 def testMergeMeshOnSameCoords1(self):
1006 m1=MEDCouplingDataForTest.build2DTargetMesh_1();
1007 m2=MEDCouplingDataForTest.build2DTargetMesh_1();
1008 cells = list(range(5));
1009 m2.convertToPolyTypes(cells);
1010 m1.tryToShareSameCoords(m2,1e-12);
1011 m3=MEDCouplingDataForTest.build2DTargetMesh_1();
1012 m3.tryToShareSameCoords(m2,1e-12);
1014 m4=MEDCouplingUMesh.MergeUMeshesOnSameCoords(meshes);
1015 m4.checkConsistencyLight();
1016 self.assertEqual(15,m4.getNumberOfCells());
1018 m1_1=m4.buildPartOfMySelf(cells1,True);
1019 m1_1.setName(m1.getName());
1020 self.assertTrue(m1.isEqual(m1_1,1e-12));
1022 m2_1=m4.buildPartOfMySelf(cells2,True);
1023 m2_1.setName(m2.getName());
1024 self.assertTrue(m2.isEqual(m2_1,1e-12));
1025 cells3=[10,11,12,13,14]
1026 m3_1=m4.buildPartOfMySelf(cells3,True);
1027 m3_1.setName(m3.getName());
1028 self.assertTrue(m3.isEqual(m3_1,1e-12));
1031 def testMergeField1(self):
1032 m1=MEDCouplingDataForTest.build2DTargetMesh_1();
1033 m2=MEDCouplingDataForTest.build2DSourceMesh_1();
1036 f1=m1.getMeasureField(True);
1037 f2=m2.getMeasureField(True);
1038 f3=MEDCouplingFieldDouble.MergeFields(f1,f2);
1039 f3.checkConsistencyLight();
1040 m4=MEDCouplingDataForTest.build2DTargetMeshMerged_1();
1041 self.assertTrue(f3.getMesh().isEqual(m4,1.e-12));
1043 self.assertEqual(name,"MeasureOfMesh_");
1044 self.assertEqual(f3.getTypeOfField(),ON_CELLS);
1045 self.assertEqual(f3.getTimeDiscretization(),ONE_TIME);
1046 self.assertEqual(1,f3.getNumberOfComponents());
1047 self.assertEqual(7,f3.getNumberOfTuples());
1048 values=[0.25,0.125,0.125,0.25,0.25,0.5,0.5]
1049 tmp=f3.getArray().getValues();
1050 self.assertEqual(len(values),len(tmp))
1052 self.assertTrue(abs(values[i]-tmp[i])<1e-12)
1056 def testFillFromAnalytic(self):
1057 m=MEDCouplingDataForTest.build2DTargetMesh_1();
1058 m.setTime(3.4,5,6); m.setTimeUnit("us");
1059 f1=m.fillFromAnalytic(ON_CELLS,1,"x+y");
1060 self.assertAlmostEqual(3.4,f1.getTime()[0],12) ; self.assertEqual(5,f1.getTime()[1]) ; self.assertEqual(6,f1.getTime()[2])
1061 self.assertEqual("us",f1.getTimeUnit())
1062 f1.checkConsistencyLight();
1063 self.assertEqual(f1.getTypeOfField(),ON_CELLS);
1064 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1065 self.assertEqual(1,f1.getNumberOfComponents());
1066 self.assertEqual(5,f1.getNumberOfTuples());
1067 values1=[-0.1,0.23333333333333336,0.56666666666666665,0.4,0.9]
1068 tmp=f1.getArray().getValues();
1069 self.assertEqual(len(values1),len(tmp))
1070 for i in range(len(tmp)):
1071 self.assertTrue(abs(tmp[i]-values1[i])<1.e-12)
1074 f1=m.fillFromAnalytic(ON_NODES,1,"x+y");
1075 f1.checkConsistencyLight();
1076 self.assertEqual(f1.getTypeOfField(),ON_NODES);
1077 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1078 self.assertEqual(1,f1.getNumberOfComponents());
1079 self.assertEqual(9,f1.getNumberOfTuples());
1080 values2=[-0.6,-0.1,0.4,-0.1,0.4,0.9,0.4,0.9,1.4]
1081 tmp=f1.getArray().getValues();
1082 self.assertEqual(len(values2),len(tmp))
1083 for i in range(len(tmp)):
1084 self.assertTrue(abs(tmp[i]-values2[i])<1.e-12)
1087 f1=m.fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+(2*(x+y))*JVec");
1088 f1.checkConsistencyLight();
1089 self.assertEqual(f1.getTypeOfField(),ON_NODES);
1090 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1091 self.assertEqual(2,f1.getNumberOfComponents());
1092 self.assertEqual(9,f1.getNumberOfTuples());
1093 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]
1094 tmp=f1.getArray().getValues();
1095 self.assertEqual(len(values3),len(tmp))
1096 for i in range(len(tmp)):
1097 self.assertTrue(abs(tmp[i]-values3[i])<1.e-12)
1099 values4=f1.accumulate();
1100 self.assertEqual(2,len(values4))
1101 self.assertTrue(abs(3.6-values4[0])<1.e-12);
1102 self.assertTrue(abs(7.2-values4[1])<1.e-12);
1103 values4=f1.integral(True);
1104 self.assertEqual(2,len(values4))
1105 self.assertTrue(abs(0.5-values4[0])<1.e-12);
1106 self.assertTrue(abs(1.-values4[1])<1.e-12);
1108 self.assertRaises(InterpKernelException,m.fillFromAnalytic,ON_NODES,1,"1./(x-0.2)");
1111 def testFillFromAnalytic2(self):
1112 m=MEDCouplingDataForTest.build2DTargetMesh_1();
1113 f1=m.fillFromAnalytic(ON_CELLS,1,"y+x");
1114 f1.checkConsistencyLight();
1115 self.assertEqual(f1.getTypeOfField(),ON_CELLS);
1116 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1117 self.assertEqual(1,f1.getNumberOfComponents());
1118 self.assertEqual(5,f1.getNumberOfTuples());
1119 values1=[-0.1,0.23333333333333336,0.56666666666666665,0.4,0.9]
1120 tmp=f1.getArray().getValues();
1121 self.assertEqual(len(values1),len(tmp))
1122 for i in range(len(values1)):
1123 self.assertTrue(abs(values1[i]-tmp[i])<1.e-12);
1126 f1=m.fillFromAnalytic(ON_NODES,1,"y+2*x");
1127 f1.checkConsistencyLight();
1128 self.assertEqual(f1.getTypeOfField(),ON_NODES);
1129 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1130 self.assertEqual(1,f1.getNumberOfComponents());
1131 self.assertEqual(9,f1.getNumberOfTuples());
1132 values2=[-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1]
1133 tmp=f1.getArray().getValues();
1134 self.assertEqual(len(values2),len(tmp))
1135 for i in range(len(values2)):
1136 self.assertTrue(abs(values2[i]-tmp[i])<1.e-12);
1138 f1=m.fillFromAnalytic(ON_NODES,1,"2.*x+y");
1139 f1.checkConsistencyLight();
1140 self.assertEqual(f1.getTypeOfField(),ON_NODES);
1141 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1142 self.assertEqual(1,f1.getNumberOfComponents());
1143 self.assertEqual(9,f1.getNumberOfTuples());
1144 tmp=f1.getArray().getValues();
1145 values2Bis=[-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1]
1146 self.assertEqual(len(values2Bis),len(tmp))
1147 for i in range(len(values2Bis)):
1148 self.assertTrue(abs(values2Bis[i]-tmp[i])<1.e-12);
1151 f1=m.fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+2*(x+y)*JVec");
1152 f1.checkConsistencyLight();
1153 self.assertEqual(f1.getTypeOfField(),ON_NODES);
1154 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1155 self.assertEqual(2,f1.getNumberOfComponents());
1156 self.assertEqual(9,f1.getNumberOfTuples());
1157 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]
1158 tmp=f1.getArray().getValues();
1159 self.assertEqual(len(values3),len(tmp))
1160 for i in range(len(values3)):
1161 self.assertTrue(abs(values3[i]-tmp[i])<1.e-12);
1163 values4=f1.accumulate();
1164 self.assertTrue(abs(3.6-values4[0])<1.e-12);
1165 self.assertTrue(abs(7.2-values4[1])<1.e-12);
1166 values4=f1.integral(True);
1167 self.assertTrue(abs(0.5-values4[0])<1.e-12);
1168 self.assertTrue(abs(1.-values4[1])<1.e-12);
1171 def testApplyFunc(self):
1172 m=MEDCouplingDataForTest.build2DTargetMesh_1();
1173 f1=m.fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+(2*(x+y))*JVec");
1174 f1.checkConsistencyLight();
1175 self.assertEqual(f1.getTypeOfField(),ON_NODES);
1176 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1177 self.assertEqual(2,f1.getNumberOfComponents());
1178 self.assertEqual(9,f1.getNumberOfTuples());
1179 f1.applyFunc(1,"x+y");
1180 self.assertEqual(f1.getTypeOfField(),ON_NODES);
1181 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1182 self.assertEqual(1,f1.getNumberOfComponents());
1183 self.assertEqual(9,f1.getNumberOfTuples());
1184 values1=[-1.8,-0.3,1.2,-0.3,1.2,2.7,1.2,2.7,4.2]
1185 tmp=f1.getArray().getValues();
1186 self.assertEqual(len(values1),len(tmp))
1187 for i in range(len(tmp)):
1188 self.assertTrue(abs(tmp[i]-values1[i])<1.e-12)
1192 def testApplyFunc2(self):
1193 m=MEDCouplingDataForTest.build2DTargetMesh_1();
1194 f1=m.fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+2*(x+y)*JVec");
1195 f1.checkConsistencyLight();
1196 self.assertEqual(f1.getTypeOfField(),ON_NODES);
1197 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1198 self.assertEqual(2,f1.getNumberOfComponents());
1199 self.assertEqual(9,f1.getNumberOfTuples());
1202 self.assertRaises(InterpKernelException, f2.applyFunc, 1, "a+b+c+d");
1203 self.assertRaises(InterpKernelException, f2.applyFunc, 1, "a/0");
1204 self.assertRaises(InterpKernelException, f2.applyFunc, "a/0");
1205 f2.applyFunc("abs(u)^2.4+2*u");
1206 self.assertEqual(f1.getTypeOfField(),ON_NODES);
1207 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1208 self.assertEqual(2,f1.getNumberOfComponents());
1209 self.assertEqual(9,f1.getNumberOfTuples());
1210 values2=[-0.9065304805418678, -0.85105859001709905, -0.19601892829446504, -0.37898777756476987,
1211 0.91090317490482353, 2.1853504664669781, -0.19601892829446504, -0.37898777756476987,
1212 0.91090317490482353, 2.1853504664669781, 2.5765725275664879, 7.6987743736515295,
1213 0.91090317490482353, 2.1853504664669781, 2.5765725275664879, 7.6987743736515295,
1214 5.0423700574830965, 17.435300118916864]
1215 tmp=f2.getArray().getValues();
1216 self.assertEqual(len(tmp),len(values2))
1217 for i in range(len(tmp)):
1218 self.assertTrue(abs(tmp[i]-values2[i])<1.e-12)
1221 f1.applyFunc(1,"x+y");
1222 self.assertEqual(f1.getTypeOfField(),ON_NODES);
1223 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1224 self.assertEqual(1,f1.getNumberOfComponents());
1225 self.assertEqual(9,f1.getNumberOfTuples());
1226 values1=[-1.8,-0.3,1.2,-0.3,1.2,2.7,1.2,2.7,4.2]
1227 tmp=f1.getArray().getValues();
1228 self.assertEqual(len(tmp),len(values1))
1229 for i in range(len(tmp)):
1230 self.assertTrue(abs(tmp[i]-values1[i])<1.e-12)
1234 def testOperationsOnFields(self):
1235 m=MEDCouplingDataForTest.build2DTargetMesh_1();
1236 f1=m.fillFromAnalytic(ON_NODES,1,"x+y");
1237 f2=m.fillFromAnalytic(ON_NODES,1,"x+y");
1238 f1.checkConsistencyLight();
1239 f2.checkConsistencyLight();
1241 f3.checkConsistencyLight();
1242 self.assertEqual(f3.getTypeOfField(),ON_NODES);
1243 self.assertEqual(f3.getTimeDiscretization(),ONE_TIME);
1244 values1=[-1.2,-0.2,0.8,-0.2,0.8,1.8,0.8,1.8,2.8]
1245 tmp=f3.getArray().getValues();
1246 self.assertEqual(len(values1),len(tmp))
1247 for i in range(len(tmp)):
1248 self.assertTrue(abs(tmp[i]-values1[i])<1.e-12)
1252 f3.checkConsistencyLight();
1253 self.assertEqual(f3.getTypeOfField(),ON_NODES);
1254 self.assertEqual(f3.getTimeDiscretization(),ONE_TIME);
1255 values2=[0.36,0.01,0.16,0.01,0.16,0.81,0.16,0.81,1.96]
1256 tmp=f3.getArray().getValues();
1257 self.assertEqual(len(values2),len(tmp))
1258 for i in range(len(tmp)):
1259 self.assertTrue(abs(tmp[i]-values2[i])<1.e-12)
1264 f4.checkConsistencyLight();
1265 self.assertEqual(f4.getTypeOfField(),ON_NODES);
1266 self.assertEqual(f4.getTimeDiscretization(),ONE_TIME);
1267 values3=[0.6,0.1,-0.4,0.1,-0.4,-0.9,-0.4,-0.9,-1.4]
1268 tmp=f4.getArray().getValues();
1269 self.assertEqual(len(values3),len(tmp))
1270 for i in range(len(tmp)):
1271 self.assertTrue(abs(tmp[i]-values3[i])<1.e-12)
1276 f4.checkConsistencyLight();
1277 self.assertEqual(f4.getTypeOfField(),ON_NODES);
1278 self.assertEqual(f4.getTimeDiscretization(),ONE_TIME);
1279 tmp=f4.getArray().getValues();
1280 for i in range(len(tmp)):
1281 self.assertTrue(abs(tmp[i]-2.)<1.e-12)
1284 f4=f2.buildNewTimeReprFromThis(NO_TIME,False);
1285 f4.checkConsistencyLight();
1286 self.assertEqual(f4.getTypeOfField(),ON_NODES);
1287 self.assertEqual(f4.getTimeDiscretization(),NO_TIME);
1288 self.assertRaises(InterpKernelException,f1.__add__,f4);
1289 f5=f4.buildNewTimeReprFromThis(ONE_TIME,False);
1290 self.assertEqual(f5.getTypeOfField(),ON_NODES);
1291 self.assertEqual(f5.getTimeDiscretization(),ONE_TIME);
1293 tmp=f3.getArray().getValues();
1294 values4=[-1.2,-0.2,0.8,-0.2,0.8,1.8,0.8,1.8,2.8]
1295 self.assertEqual(len(values3),len(tmp))
1296 for i in range(len(tmp)):
1297 self.assertTrue(abs(tmp[i]-values4[i])<1.e-12)
1300 f4=f2.buildNewTimeReprFromThis(NO_TIME,True);
1301 f4.checkConsistencyLight();
1302 self.assertEqual(f4.getTypeOfField(),ON_NODES);
1303 self.assertEqual(f4.getTimeDiscretization(),NO_TIME);
1304 self.assertRaises(InterpKernelException,f1.__add__,f4);
1305 f5=f4.buildNewTimeReprFromThis(ONE_TIME,True);
1306 self.assertEqual(f5.getTypeOfField(),ON_NODES);
1307 self.assertEqual(f5.getTimeDiscretization(),ONE_TIME);
1309 tmp=f3.getArray().getValues();
1310 values5=[-1.2,-0.2,0.8,-0.2,0.8,1.8,0.8,1.8,2.8]
1311 self.assertEqual(len(values5),len(tmp))
1312 for i in range(len(tmp)):
1313 self.assertTrue(abs(tmp[i]-values5[i])<1.e-12)
1317 def testOperationsOnFields2(self):
1318 m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1319 m.setTime(3.4,5,6); m.setTimeUnit("us");
1320 f1=m.fillFromAnalytic(ON_NODES,1,"x+y+z");
1321 f2=m.fillFromAnalytic(ON_NODES,1,"a*a+b+c*c");
1323 f3.checkConsistencyLight();
1324 self.assertEqual(f3.getTypeOfField(),ON_NODES);
1325 self.assertEqual(f3.getTimeDiscretization(),ONE_TIME);
1326 expected1=[-2.4999999999999991, 1.2162162162162162, 0.77868852459016391,
1327 0.7407407407407407, 1.129032258064516, 0.81632653061224492,
1328 0.86538461538461531, 1.0919540229885056, 0.84302325581395343]
1329 self.assertEqual(1,f3.getNumberOfComponents());
1330 self.assertEqual(9,f3.getNumberOfTuples());
1331 val=f3.getArray().getValues();
1333 self.assertTrue(abs(expected1[i]-val[i])<1.e-12);
1335 f1=m.buildOrthogonalField();
1336 self.assertAlmostEqual(3.4,f1.getTime()[0],12) ; self.assertEqual(5,f1.getTime()[1]) ; self.assertEqual(6,f1.getTime()[2])
1337 self.assertEqual("us",f1.getTimeUnit())
1338 f2=m.fillFromAnalytic(ON_CELLS,1,"x");
1340 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]
1341 val=f3.getArray().getValues();
1343 self.assertTrue(abs(expected2[i]-val[i])<1.e-12);
1347 val=f3.getArray().getValues();
1349 self.assertTrue(abs(expected2[i]-val[i])<1.e-12);
1353 def testOperationsOnFields3(self):
1354 m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1355 f1=m.fillFromAnalytic(ON_NODES,1,"x+y+z");
1356 f2=m.fillFromAnalytic(ON_NODES,1,"a*a+b+c*c");
1358 f1.checkConsistencyLight();
1359 self.assertEqual(f1.getTypeOfField(),ON_NODES);
1360 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1361 expected1=[-2.4999999999999991, 1.2162162162162162, 0.77868852459016391,
1362 0.7407407407407407, 1.129032258064516, 0.81632653061224492,
1363 0.86538461538461531, 1.0919540229885056, 0.84302325581395343]
1364 self.assertEqual(1,f1.getNumberOfComponents());
1365 self.assertEqual(9,f1.getNumberOfTuples());
1366 val=f1.getArray().getValues();
1368 self.assertTrue(abs(expected1[i]-val[i])<1.e-12);
1371 f1=m.buildOrthogonalField();
1372 f2=m.fillFromAnalytic(ON_CELLS,1,"x");
1374 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]
1375 val=f1.getArray().getValues();
1377 self.assertTrue(abs(expected2[i]-val[i])<1.e-12);
1380 f1=m.buildOrthogonalField();
1381 # to avoid valgrind leaks
1382 # self.assertRaises(InterpKernelException,f2.__imul__,f1);
1385 def testOperationsOnFields4(self):
1386 m=MEDCouplingDataForTest.build2DTargetMesh_1();
1387 nbOfCells=m.getNumberOfCells();
1388 f1=MEDCouplingFieldDouble.New(ON_CELLS,CONST_ON_TIME_INTERVAL);
1390 array=DataArrayDouble.New();
1392 self.assertRaises(InterpKernelException,f1.setEndArray,array);
1393 self.assertRaises(InterpKernelException,f1.getEndArray);
1394 arr1=[0.,10.,20.,1.,11.,21.,2.,12.,22.,3.,13.,23.,4.,14.,24.]
1395 arr2=[5.,15.,25.,6.,16.,26.,7.,17.,27.,8.,18.,28.,9.,19.,29.]
1396 array.setValues(arr1,nbOfCells,3);
1397 f1.setStartTime(2.,0,0);
1398 f1.setEndTime(3.,0,0);
1399 f1.checkConsistencyLight();
1401 res=f1.getValueOn(pos);
1402 self.assertTrue(abs(arr1[3]-res[0])<1.e-12);
1403 self.assertTrue(abs(arr1[4]-res[1])<1.e-12);
1404 self.assertTrue(abs(arr1[5]-res[2])<1.e-12);
1406 res=f1.getValueOn(pos,2.2);
1407 self.assertTrue(abs(arr1[3]-res[0])<1.e-12);
1408 self.assertTrue(abs(arr1[4]-res[1])<1.e-12);
1409 self.assertTrue(abs(arr1[5]-res[2])<1.e-12);
1411 self.assertRaises(InterpKernelException,f1.getValueOn,pos,3.2)
1412 f2=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
1414 f2.setArray(f1.getArray());
1415 f2.setStartTime(2.,3,0);
1416 f2.setEndTime(4.,13,0);
1417 self.assertRaises(InterpKernelException,f2.checkConsistencyLight)
1418 array2=DataArrayDouble.New();
1419 array2.setValues(arr2,nbOfCells,3);
1420 f2.setEndArray(array2);
1421 f2.checkConsistencyLight();
1424 res=f2.getValueOn(pos,3.21);
1425 self.assertTrue(abs(4.025-res[0])<1.e-12);
1426 self.assertTrue(abs(14.025-res[1])<1.e-12);
1427 self.assertTrue(abs(24.025-res[2])<1.e-12);
1429 self.assertTrue(f2.isEqual(f3,1e-12,1e-12));
1430 f3.getEndArray().setIJ(0,0,5.001);
1431 self.assertTrue(not f2.isEqual(f3,1e-12,1e-12));
1432 self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1433 f3.setStartTime(2.1,3,0);
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.setStartTime(2.,4,0);
1438 self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1439 f3.setStartTime(2.,3,1);
1440 self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1441 f3.setStartTime(2.,3,0);
1442 self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1443 f3.setEndTime(4.1,13,0);
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));
1447 f3.setEndTime(4.,14,0);
1448 self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1449 f3.setEndTime(4.,13,1);
1450 self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1451 f3.setEndTime(4.,13,0);
1452 self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1455 res=f4.getValueOn(pos,3.21);
1456 self.assertTrue(abs(8.05-res[0])<1.e-12);
1457 self.assertTrue(abs(28.05-res[1])<1.e-12);
1458 self.assertTrue(abs(48.05-res[2])<1.e-12);
1461 res=f4.getValueOn(pos,3.21);
1462 self.assertTrue(abs(12.075-res[0])<1.e-12);
1463 self.assertTrue(abs(42.075-res[1])<1.e-12);
1464 self.assertTrue(abs(72.075-res[2])<1.e-12);
1467 def testMergeNodesOnField(self):
1468 targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
1469 f1=targetMesh.fillFromAnalytic(ON_NODES,1,"x+y+z");
1470 f1.mergeNodes(1e-10);
1472 targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
1473 f1=targetMesh.fillFromAnalytic(ON_NODES,1,"x+y+z");
1475 tmp.setIJ(0,0,1000.);
1476 f1.mergeNodes(1e-10);
1478 targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
1479 f1=targetMesh.fillFromAnalytic(ON_NODES,1,"x+y+z");
1481 tmp.setIJ(1,0,1000.);
1482 self.assertRaises(InterpKernelException,f1.mergeNodes,1.e-10)
1485 def testCheckConsecutiveCellTypes(self):
1486 sourceMesh=MEDCouplingDataForTest.build2DSourceMesh_1();
1487 targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1488 self.assertTrue(sourceMesh.checkConsecutiveCellTypes());
1489 order1=[NORM_TRI3,NORM_QUAD4]
1490 order2=[NORM_QUAD4,NORM_TRI3]
1491 self.assertTrue(not targetMesh.checkConsecutiveCellTypes());
1492 self.assertTrue(not targetMesh.checkConsecutiveCellTypesAndOrder(order1));
1493 self.assertTrue(not targetMesh.checkConsecutiveCellTypesAndOrder(order2));
1494 da=targetMesh.getRenumArrForConsecutiveCellTypesSpec(order1);
1495 self.assertEqual(5,da.getNumberOfTuples());
1496 self.assertEqual(1,da.getNumberOfComponents());
1497 expected1=[2,0,1,3,4]
1498 self.assertTrue(expected1==list(da.getValues()));
1499 da=targetMesh.getRenumArrForConsecutiveCellTypesSpec(order2);
1500 self.assertEqual(5,da.getNumberOfTuples());
1501 self.assertEqual(1,da.getNumberOfComponents());
1502 expected2=[0,3,4,1,2]
1503 self.assertTrue(expected2==list(da.getValues()));
1504 renumber1=[4,0,1,2,3]
1505 targetMesh.renumberCells(renumber1,False);
1506 self.assertTrue(targetMesh.checkConsecutiveCellTypes());
1507 self.assertTrue(targetMesh.checkConsecutiveCellTypesAndOrder(order1));
1508 self.assertTrue(not targetMesh.checkConsecutiveCellTypesAndOrder(order2));
1511 def testRearrange2ConsecutiveCellTypes(self):
1512 m1_1=MEDCouplingDataForTest.build2DSourceMesh_1();
1513 m2_1=MEDCouplingDataForTest.build2DTargetMesh_1();
1514 arr1=m1_1.rearrange2ConsecutiveCellTypes();
1515 m1_2=MEDCouplingDataForTest.build2DSourceMesh_1();
1516 self.assertTrue(m1_2.isEqual(m1_1,1e-12));
1518 self.assertEqual(2,arr1.getNumberOfTuples());
1519 self.assertEqual(1,arr1.getNumberOfComponents());
1520 self.assertEqual(expected1,arr1.getValues());
1521 expected2=[0,3,4,1,2]
1522 arr1=m2_1.rearrange2ConsecutiveCellTypes();
1523 self.assertEqual(5,arr1.getNumberOfTuples());
1524 self.assertEqual(1,arr1.getNumberOfComponents());
1525 self.assertEqual(expected2,list(arr1.getValues()));
1526 m2_2=MEDCouplingDataForTest.build2DTargetMesh_1();
1527 self.assertEqual(5,arr1.getNumberOfTuples());
1528 self.assertEqual(1,arr1.getNumberOfComponents());
1529 self.assertEqual(expected2,list(arr1.getValues()));
1530 self.assertTrue(not m2_2.isEqual(m2_1,1e-12));
1531 m2_2.renumberCells(expected2,False);
1532 self.assertTrue(m2_2.isEqual(m2_1,1e-12));
1535 def testSplitByType(self):
1536 m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1538 self.assertEqual(3,len(v));
1539 m2=MEDCouplingUMesh.MergeUMeshesOnSameCoords(v);
1540 m2.setName(m1.getName());
1541 self.assertTrue(m1.isEqual(m2,1.e-12));
1544 def testFuseUMeshesOnSameCoords(self):
1545 m2=MEDCouplingDataForTest.build2DTargetMesh_1();
1547 m3=m2.buildPartOfMySelf(cells1,True);
1548 self.assertTrue(isinstance(m3,MEDCouplingUMesh))
1550 m4=m2.buildPartOfMySelf(cells2,True);
1551 self.assertTrue(isinstance(m4,MEDCouplingUMesh))
1553 m5=m2.buildPartOfMySelf(cells3,True);
1554 self.assertTrue(isinstance(m5,MEDCouplingUMesh))
1557 m7,corr=MEDCouplingUMesh.FuseUMeshesOnSameCoords(meshes,0);
1558 self.assertEqual(4,m7.getNumberOfCells());
1559 self.assertEqual(3,len(corr));
1560 expectedVals1=[3,3,2]
1561 expectedVals2=[[0,1,2],[3,0,2],[3,0]]
1564 self.assertEqual(1,arr.getNumberOfComponents());
1565 nbOfVals=expectedVals1[i];
1566 self.assertEqual(nbOfVals,arr.getNumberOfTuples());
1567 vals=arr.getValues();
1568 self.assertEqual(expectedVals2[i],list(vals));
1570 arr2,fidsOfGroups=DataArrayInt.MakePartition(corr,m7.getNumberOfCells());
1572 fidsGrp=[[1,3,5],[3,4,5],[4,5]]
1573 self.assertEqual(3,len(fidsOfGroups));
1574 self.assertEqual(1,arr2.getNumberOfComponents());
1575 self.assertEqual(4,arr2.getNumberOfTuples());
1576 self.assertEqual(fidExp,list(arr2.getValues()));
1578 nbOfVals=expectedVals1[i];
1579 self.assertEqual(list(fidsOfGroups[i]),fidsGrp[i]);
1583 def testFuseUMeshesOnSameCoords2(self):
1584 m1,m2=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
1586 m3=m1.buildPartOfMySelf(part1,True);
1588 m4=m1.buildPartOfMySelf(part2,True);
1589 meshes=[m1,m3,m3,m4]
1590 m5,corr=MEDCouplingUMesh.FuseUMeshesOnSameCoords(meshes,0);
1591 self.assertEqual(18,m5.getNumberOfCells());
1593 [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17],
1599 self.assertEqual(exp2[i],list(it.getValues()));
1604 def testBuildOrthogonalField(self):
1605 targetMesh=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1606 field=targetMesh.buildOrthogonalField();
1607 expected=[0.70710678118654746,0.,-0.70710678118654746]
1608 self.assertEqual(5,field.getNumberOfTuples());
1609 self.assertEqual(3,field.getNumberOfComponents());
1610 vals=field.getArray().getValues();
1612 self.assertTrue(abs(expected[i%3]-vals[i])<1e-12);
1614 targetCoords=[0.,0.,0.,0.5,0.,0.5,1.,0.,1.,0.,1.,0.]
1615 targetConn=[0,1,2,3]
1616 targetMesh=MEDCouplingUMesh.New();
1617 targetMesh.setMeshDimension(2);
1618 targetMesh.allocateCells(1);
1619 targetMesh.insertNextCell(NORM_QUAD4,targetConn[0:4])
1620 targetMesh.finishInsertingCells();
1621 myCoords=DataArrayDouble.New();
1622 myCoords.setValues(targetCoords,4,3);
1623 targetMesh.setCoords(myCoords);
1624 field=targetMesh.buildOrthogonalField();
1625 self.assertEqual(1,field.getNumberOfTuples());
1626 self.assertEqual(3,field.getNumberOfComponents());
1627 vals=field.getArray().getValues();
1628 self.assertTrue(abs(-0.70710678118654746-vals[0])<1e-12);
1629 self.assertTrue(abs(0.-vals[1])<1e-12);
1630 self.assertTrue(abs(0.70710678118654746-vals[2])<1e-12);
1633 def testGetCellsContainingPoint(self):
1634 targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1635 pos=[0.,0.,0.4,0.4,0.,0.4,0.1,0.1,0.25,0.,0.65,0.]
1637 t1,t2=targetMesh.getCellsContainingPoints(pos,6,1e-12);
1638 self.assertEqual(6,t1.getNumberOfTuples());
1639 self.assertEqual(1,t1.getNumberOfComponents());
1640 self.assertEqual(7,t2.getNumberOfTuples());
1641 self.assertEqual(1,t2.getNumberOfComponents());
1642 expectedValues1=[0,4,3,0,1,2]
1643 expectedValues2=[0,1,2,3,4,5,6]
1644 self.assertEqual(list(t1.getValues()),expectedValues1);
1645 self.assertEqual(list(t2.getValues()),expectedValues2);
1646 #2D with no help of bounding box.
1648 MEDCouplingPointSet.Rotate2DAlg(center,0.78539816339744830962,6,pos);
1649 targetMesh.rotate(center,0.78539816339744830962);
1652 t1,t2=targetMesh.getCellsContainingPoints(pos,1e-12);
1653 self.assertEqual(6,t1.getNumberOfTuples());
1654 self.assertEqual(7,t2.getNumberOfTuples());
1655 self.assertEqual(list(t1.getValues()),expectedValues1);
1656 self.assertEqual(list(t2.getValues()),expectedValues2);
1657 t1,t2=targetMesh.getCellsContainingPoints(DataArrayDouble.New(pos,6,2),1e-12);
1658 self.assertEqual(6,t1.getNumberOfTuples());
1659 self.assertEqual(7,t2.getNumberOfTuples());
1660 self.assertEqual(list(t1.getValues()),expectedValues1);
1661 self.assertEqual(list(t2.getValues()),expectedValues2);
1662 self.assertRaises(InterpKernelException,targetMesh.getCellsContainingPoints,DataArrayDouble.New(pos,4,3),1e-12);
1664 pos1bis=[-0.3303300858899107,-0.11819805153394641]
1665 self.assertEqual(-1,targetMesh.getCellContainingPoint(pos1bis,1e-12));
1667 targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1670 t1=targetMesh.getCellsContainingPoint(pos2,1e-12)
1671 self.assertEqual(2,len(t1));
1672 expectedValues3=[0,1]
1673 self.assertEqual(list(t1.getValues()),expectedValues3);
1676 t1=targetMesh.getCellsContainingPoint(pos3,1e-12);
1677 self.assertEqual(5,len(t1));
1678 expectedValues4=[0,1,2,3,4]
1679 self.assertEqual(list(t1.getValues()),expectedValues4);
1680 self.assertEqual(0,targetMesh.getCellContainingPoint(pos3,1e-12));
1682 targetMesh=MEDCouplingDataForTest.build3DTargetMesh_1();
1684 self.assertEqual(0,targetMesh.getCellContainingPoint(pos4,1e-12));
1687 t1=targetMesh.getCellsContainingPoint(pos5,1e-12);
1688 self.assertEqual(8,len(t1));
1689 expectedValues5=[0,1,2,3,4,5,6,7]
1690 self.assertEqual(list(t1.getValues()),expectedValues5);
1693 t1=targetMesh.getCellsContainingPoint(pos6,1e-12);
1694 self.assertEqual(2,len(t1));
1695 expectedValues6=[0,2]
1696 self.assertEqual(list(t1.getValues()),expectedValues6);
1699 self.assertEqual(-1,targetMesh.getCellContainingPoint(pos7,1e-12));
1703 targetMesh.rotate(center2,vec2,0.78539816339744830962);
1705 self.assertEqual(-1,targetMesh.getCellContainingPoint(pos8,1e-12));
1708 def testGetValueOn1(self):
1709 targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1710 fieldOnCells=MEDCouplingFieldDouble.New(ON_CELLS);
1711 nbOfCells=targetMesh.getNumberOfCells();
1712 fieldOnCells.setMesh(targetMesh);
1713 array=DataArrayDouble.New();
1714 tmp=2*nbOfCells*[None]
1715 for i in range(nbOfCells):
1716 tmp[2*i]=7.+float(i);
1717 tmp[2*i+1]=17.+float(i)
1719 array.setValues(tmp,nbOfCells,2);
1720 fieldOnCells.setArray(array);
1723 res=fieldOnCells.getValueOn(pos1);
1724 self.assertEqual(2,len(res))
1725 self.assertTrue(abs(8.-res[0])<1e-12);
1726 self.assertTrue(abs(18.-res[1])<1e-12);
1729 targetMesh=MEDCouplingDataForTest.build2DSourceMesh_1();
1730 fieldOnNodes=MEDCouplingFieldDouble.New(ON_NODES);
1731 nbOfNodes=targetMesh.getNumberOfNodes();
1732 fieldOnNodes.setMesh(targetMesh);
1733 array=DataArrayDouble.New();
1734 tmp=2*nbOfNodes*[None]
1735 for i in range(nbOfNodes):
1736 tmp[2*i]=17.+float(i);
1737 tmp[2*i+1]=27.+float(i)
1739 array.setValues(tmp,nbOfNodes,2);
1740 fieldOnNodes.setArray(array);
1742 pos2=[-0.13333333333333333,-0.13333333333333333]
1744 res=fieldOnNodes.getValueOn(pos2);
1745 self.assertEqual(2,len(res))
1746 self.assertTrue(abs(17.5-res[0])<1e-12);
1747 self.assertTrue(abs(27.5-res[1])<1e-12);
1748 pos3=[0.033333333333333326,0.36666666666666664]
1750 res=fieldOnNodes.getValueOn(pos3);
1751 self.assertEqual(2,len(res))
1752 self.assertTrue(abs(18.666666666666667-res[0])<1e-12);
1753 self.assertTrue(abs(28.666666666666667-res[1])<1e-12);
1756 def testCMesh0(self):
1757 mesh=MEDCouplingCMesh.New();
1758 meshEmpty=mesh.clone(True);
1759 self.assertTrue(meshEmpty.isEqual(mesh, 1e-12));
1761 coordsX=DataArrayDouble.New();
1762 arrX=[ -1., 1., 2., 4. ]
1763 coordsX.setValues(arrX, 4, 1);
1764 coordsY=DataArrayDouble.New();
1765 arrY=[ -2., 2., 4., 8. ]
1766 coordsY.setValues(arrY, 4, 1);
1767 coordsZ=DataArrayDouble.New();
1768 arrZ=[ -3., 3., 6., 12. ]
1769 coordsZ.setValues(arrZ, 4, 1);
1770 mesh.setCoords(coordsX, coordsY, coordsZ);
1772 fieldOnNodes=mesh.fillFromAnalytic(ON_NODES, 1, "x+y/2.+z/3.");
1773 self.assertEqual(1, fieldOnNodes.getNumberOfComponents());
1774 self.assertEqual(64, fieldOnNodes.getNumberOfTuples());
1775 expected1=[-3., -1., 0., 2., -1., 1., 2., 4., 0., 2., 3., 5., 2., 4., 5., 7., -1., 1., 2.,
1776 4., 1., 3., 4., 6., 2., 4., 5., 7., 4., 6., 7., 9., 0., 2., 3., 5., 2., 4., 5.,
1777 7., 3., 5., 6., 8., 5., 7., 8., 10., 2., 4., 5.,
1778 7., 4., 6., 7., 9., 5., 7., 8., 10., 7., 9., 10., 12.];
1780 val=fieldOnNodes.getArray().getValues();
1782 self.assertAlmostEqual(expected1[i], val[i], 12)
1783 res=fieldOnNodes.getValueOnPos(1, 3, 2);
1784 self.assertAlmostEqual(7., res[0], 12);
1786 fieldOnCells=mesh.fillFromAnalytic(ON_CELLS, 1, "x+y/2.+z/3.");
1787 self.assertEqual(1, fieldOnCells.getNumberOfComponents());
1788 self.assertEqual(27, fieldOnCells.getNumberOfTuples());
1789 val=fieldOnCells.getArray().getValues();
1790 expected2=[0, 1.5, 3, 1.5, 3, 4.5, 3, 4.5, 6, 1.5, 3, 4.5, 3, 4.5,
1791 6, 4.5, 6, 7.5, 3, 4.5, 6, 4.5, 6, 7.5, 6, 7.5, 9];
1793 self.assertAlmostEqual(expected2[i], val[i], 12);
1794 #res=fieldOnCells.getValueOnPos(1,2,1);
1795 #self.assertAlmostEqual(6.,res,12);
1797 meshDeepCopy=mesh.deepCopy();
1798 meshClone=mesh.clone(False);
1800 meshEmpty.copyTinyStringsFrom(mesh);
1801 #no data in meshEmpty, expected False
1802 self.assertTrue(not meshEmpty.isEqual(mesh, 1e-12));
1804 self.assertTrue(meshDeepCopy.isEqual(mesh, 1e-12));
1805 meshDeepCopy.copyTinyStringsFrom(mesh);
1806 self.assertTrue(meshDeepCopy.isEqual(mesh, 1e-12));
1807 self.assertTrue(meshClone.isEqual(mesh, 1e-12));
1809 self.assertEqual(CARTESIAN, mesh.getType());
1810 self.assertEqual(CARTESIAN, meshEmpty.getType());
1811 self.assertEqual(CARTESIAN, meshDeepCopy.getType());
1812 self.assertEqual(CARTESIAN, meshClone.getType());
1815 def testCMesh1(self):
1816 mesh1=MEDCouplingCMesh.New();
1817 coordsX1=DataArrayDouble.New();
1818 arrX1=[ -1., 1., 2., 4. ]
1819 coordsX1.setValues(arrX1, 4, 1);
1820 coordsY1=DataArrayDouble.New();
1821 arrY1=[ -2., 2., 4., 8. ]
1822 coordsY1.setValues(arrY1, 4, 1);
1823 coordsZ1=DataArrayDouble.New();
1824 arrZ1=[ -3., 3., 6., 12. ]
1825 coordsZ1.setValues(arrZ1, 4, 1);
1826 mesh1.setCoords(coordsX1, coordsY1, coordsZ1);
1828 mesh2=MEDCouplingCMesh.New();
1829 coordsX2=DataArrayDouble.New();
1830 arrX2=[ -1., 1., 2., 4. ]
1831 coordsX2.setValues(arrX2, 4, 1);
1832 coordsY2=DataArrayDouble.New();
1833 arrY2=[ -2., 2., 4., 8. ]
1834 coordsY2.setValues(arrY2, 4, 1);
1835 coordsZ2=DataArrayDouble.New();
1836 arrZ2=[ -3., 3., 6., 12.+1e-6 ]
1837 coordsZ2.setValues(arrZ2, 4, 1);
1838 mesh2.setCoords(coordsX2, coordsY2, coordsZ2);
1840 mesh3=MEDCouplingCMesh.New();
1841 coordsX3=DataArrayDouble.New();
1843 coordsX3.setValues(arrX3, 1, 1);
1844 coordsY3=DataArrayDouble.New();
1846 coordsY3.setValues(arrY3, 1, 1);
1847 coordsZ3=DataArrayDouble.New();
1849 coordsZ3.setValues(arrZ3, 1, 1);
1850 mesh3.setCoords(coordsX3, coordsY3, coordsZ3);
1852 self.assertEqual(3, mesh1.getSpaceDimension());
1853 self.assertEqual(3, mesh1.getMeshDimension());
1855 self.assertTrue(not mesh1.isEqual(mesh2, 1e-12));
1856 self.assertTrue(not mesh2.isEqual(mesh1, 1e-12));
1857 self.assertTrue(not mesh2.isEqualWithoutConsideringStr(mesh1, 1e-12));
1858 self.assertTrue(mesh1.isEqual(mesh2, 1e-5));
1859 self.assertTrue(not mesh1.isEqual(mesh2, 1e-7));
1861 self.assertRaises(InterpKernelException, mesh3.checkConsistency, 1e-12);
1862 mesh1.checkConsistency(1e-12);
1863 self.assertEqual(NORM_HEXA8, mesh1.getTypeOfCell(1));
1865 self.assertEqual(NORM_HEXA8, mesh1.getAllGeoTypes()[0]);
1866 self.assertEqual(27, mesh1.getNumberOfCellsWithType(NORM_HEXA8));
1867 self.assertRaises(InterpKernelException, mesh1.getNumberOfCellsWithType, NORM_QUAD4);
1869 coo=mesh1.getCoordinatesOfNode(0);
1870 self.assertEqual(3, len(coo));
1871 self.assertAlmostEqual(-1., coo[0], 14);
1872 self.assertAlmostEqual(-2., coo[1], 14);
1873 self.assertAlmostEqual(-3., coo[2], 14);
1874 coo=mesh1.getCoordinatesOfNode(63);
1875 self.assertEqual(3, len(coo));
1876 self.assertAlmostEqual(4., coo[0], 14);
1877 self.assertAlmostEqual(8., coo[1], 14);
1878 self.assertAlmostEqual(12., coo[2], 14);
1881 repr=mesh1.simpleRepr();
1882 repr=mesh1.advancedRepr();
1883 self.assertTrue("Cartesian" in repr);
1884 self.assertTrue("Number of components : 1" in repr);
1885 self.assertTrue("Number of tuples : 4" in repr);
1886 self.assertTrue("Z Array :" in repr);
1889 def testCMesh2(self):
1890 mesh1=MEDCouplingCMesh.New();
1891 coordsX1=DataArrayDouble.New();
1892 arrX1=[ -1., 1., 2., 4. ]
1893 coordsX1.setValues(arrX1, 4, 1);
1894 coordsY1=DataArrayDouble.New();
1895 arrY1=[ -2., 2., 4., 8. ]
1896 coordsY1.setValues(arrY1, 4, 1);
1897 coordsZ1=DataArrayDouble.New();
1898 arrZ1=[ -3., 3., 6., 12. ]
1899 coordsZ1.setValues(arrZ1, 4, 1);
1900 mesh1.setCoords(coordsX1, coordsY1, coordsZ1);
1902 dis=mesh1.getDistributionOfTypes();
1903 self.assertEqual(1, len(dis));
1904 self.assertEqual(NORM_HEXA8, dis[0][0]);
1905 self.assertEqual(27, dis[0][1]);
1906 self.assertEqual(-1, dis[0][2]);
1909 self.assertTrue(not mesh1.checkTypeConsistencyAndContig(dis, idsPerType));
1910 dis[0][0]=NORM_QUAD4;
1911 self.assertRaises(InterpKernelException, mesh1.checkTypeConsistencyAndContig, dis, idsPerType);
1912 dis[0][0]=NORM_HEXA8;
1914 ids=DataArrayInt.New();
1916 ids.fillWithValue(23);
1918 check=mesh1.checkTypeConsistencyAndContig(dis, idsPerType);
1919 self.assertTrue(check);
1920 self.assertTrue(check.isEqual(ids));
1922 code, idsInPflPerType, pfls=mesh1.splitProfilePerType(ids);
1923 self.assertEqual(1, len(code));
1924 self.assertEqual(NORM_HEXA8, code[0][0]);
1925 self.assertEqual(10, code[0][1]);
1926 self.assertEqual(0, code[0][2]);
1927 self.assertEqual(1, len(idsInPflPerType));
1928 self.assertEqual(1, len(pfls));
1929 self.assertTrue(idsInPflPerType[0].isEqual(DataArrayInt([0,1,2,3,4,5,6,7,8,9])));
1930 self.assertTrue(pfls[0].isEqual(ids));
1932 cells1=[0, 1, 25, 26]
1933 partMesh1=mesh1.buildPart(cells1)
1934 self.assertTrue(isinstance(partMesh1,MEDCouplingMesh))
1935 self.assertEqual(4, partMesh1.getNumberOfCellsWithType(NORM_HEXA8));
1936 self.assertEqual(64, mesh1.getNumberOfNodes());
1937 self.assertEqual(64, partMesh1.getNumberOfNodes());
1940 partMesh2, arr1=mesh1.buildPartAndReduceNodes(cells2)
1941 self.assertTrue(isinstance(partMesh2,MEDCouplingCMesh))
1942 self.assertEqual(2,partMesh2.getNumberOfCellsWithType(NORM_HEXA8));
1943 self.assertEqual(12,partMesh2.getNumberOfNodes());
1946 partMesh3, arr2=partMesh1.buildPartAndReduceNodes(cells3)
1947 self.assertTrue(isinstance(partMesh3,MEDCouplingUMesh))
1948 self.assertEqual(2, partMesh3.getNumberOfCellsWithType(NORM_HEXA8));
1949 self.assertEqual(12, partMesh3.getNumberOfNodes());
1951 self.assertRaises(InterpKernelException, mesh1.simplexize, 0);
1952 self.assertRaises(InterpKernelException, mesh1.getMeasureFieldOnNode, True);
1956 bbox1=mesh1.getBoundingBox(); #[(-1.0, 4.0), (-2.0, 8.0), (-3.0, 12.0)]
1957 bbox2=partMesh1.getBoundingBox();
1958 self.assertTrue(bbox1==bbox2);
1959 bbox1=partMesh3.getBoundingBox();
1960 bbox2=partMesh2.getBoundingBox();
1961 self.assertTrue(bbox1==bbox2);
1963 self.assertRaises(InterpKernelException, mesh1.buildOrthogonalField);
1964 mesh2d=MEDCouplingCMesh.New();
1965 mesh2d.setCoords(coordsX1, coordsY1);
1966 f1=mesh2d.buildOrthogonalField();
1970 def testScale(self):
1971 mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1973 mesh.scale(pos,0.5);
1974 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,
1975 -0.05,0.45, 0.2,0.45, 0.45,0.45]
1976 val=mesh.getCoords().getValues();
1977 self.assertEqual(18,len(val))
1979 self.assertTrue(abs(expected1[i]-val[i])<1e-12);
1983 def testTryToShareSameCoords(self):
1984 m1=MEDCouplingDataForTest.build2DTargetMesh_1();
1985 m2=MEDCouplingDataForTest.build2DTargetMesh_1();
1986 self.assertTrue(m1.getCoords().getHiddenCppPointer()!=m2.getCoords().getHiddenCppPointer());
1987 m1.tryToShareSameCoords(m2,1e-12);
1988 self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1989 m1.tryToShareSameCoords(m2,1e-12);
1990 self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1991 m2.tryToShareSameCoords(m1,1e-12);
1992 self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1994 m1=MEDCouplingDataForTest.build2DTargetMesh_1();
1995 m2=MEDCouplingDataForTest.build2DTargetMesh_2();
1996 self.assertTrue(m1.getCoords().getHiddenCppPointer()!=m2.getCoords().getHiddenCppPointer());
1997 m1.tryToShareSameCoords(m2,1e-12);
1998 self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1999 m1.tryToShareSameCoords(m2,1e-12);
2000 self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
2001 m2.tryToShareSameCoords(m1,1e-12);
2002 self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
2004 m1=MEDCouplingDataForTest.build2DTargetMesh_1();
2005 m2=MEDCouplingDataForTest.build2DSourceMesh_1();
2006 self.assertTrue(m1.getCoords().getHiddenCppPointer()!=m2.getCoords().getHiddenCppPointer());
2007 self.assertRaises(InterpKernelException,m1.tryToShareSameCoords,m2,1e-12)
2010 def testFindNodeOnPlane(self):
2011 mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
2014 n=mesh.findNodesOnPlane(pt,v,1e-12);
2015 self.assertEqual(9,len(n));
2016 m3dSurf=mesh.buildFacePartOfMySelfNode(n,True);
2017 self.assertTrue(isinstance(m3dSurf,MEDCouplingUMesh))
2018 me=MEDCouplingMappedExtrudedMesh.New(mesh,m3dSurf,0);
2019 da=me.getMesh3DIds();
2020 self.assertEqual(8,me.getNumberOfCells());
2021 expected=[0,1,2,3,4,5,6,7]
2023 self.assertEqual(expected,list(val));
2025 m3dSurf=mesh.buildFacePartOfMySelfNode(n,True);
2026 self.assertTrue(isinstance(m3dSurf,MEDCouplingUMesh))
2027 me=MEDCouplingMappedExtrudedMesh.New(mesh,m3dSurf,0);
2028 da=me.getMesh3DIds();
2029 self.assertEqual(8,me.getNumberOfCells());
2030 expected=[0,1,2,3,4,5,6,7]
2032 self.assertEqual(expected,list(val));
2035 def testRenumberCells(self):
2036 m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2037 m2=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2038 self.assertTrue(m.isEqual(m2,0));
2040 m.renumberCells(arr,True);
2041 self.assertTrue(not m.isEqual(m2,0));
2042 self.assertEqual(NORM_QUAD4,m.getTypeOfCell(0));
2043 self.assertEqual(NORM_TRI3,m.getTypeOfCell(1));
2044 self.assertEqual(NORM_QUAD4,m.getTypeOfCell(2));
2045 self.assertEqual(NORM_TRI3,m.getTypeOfCell(3));
2046 self.assertEqual(NORM_QUAD4,m.getTypeOfCell(4));
2048 m.renumberCells(arr2,True);
2049 self.assertTrue(m.isEqual(m2,0));
2052 def testChangeSpaceDimension(self):
2053 m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2054 m2=MEDCouplingDataForTest.build2DTargetMesh_1();
2056 self.assertEqual(3,m1.getSpaceDimension());
2057 m1.changeSpaceDimension(2);
2058 self.assertEqual(2,m1.getSpaceDimension());
2059 m1.setName(m2.getName());
2060 self.assertTrue(m1.isEqual(m2,1e-12));
2061 m1.changeSpaceDimension(3);
2062 self.assertEqual(3,m1.getSpaceDimension());
2063 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.]
2064 val=m1.getCoords().getValues();
2066 self.assertTrue(abs(expected[i]-val[i])<1e-14);
2070 def testGaussPointField1(self):
2071 _a=0.446948490915965;
2072 _b=0.091576213509771;
2073 _p1=0.11169079483905;
2074 _p2=0.0549758718227661;
2075 refCoo1=[ 0.,0., 1.,0., 0.,1. ]
2076 gsCoo1=[ 2*_b-1, 1-4*_b, 2*_b-1, 2.07*_b-1, 1-4*_b,
2077 2*_b-1, 1-4*_a, 2*_a-1, 2*_a-1, 1-4*_a, 2*_a-1, 2*_a-1 ]
2078 wg1=[ 4*_p2, 4*_p2, 4*_p2, 4*_p1, 4*_p1, 4*_p1 ]
2083 m=MEDCouplingDataForTest.build2DTargetMesh_1();
2084 f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,NO_TIME);
2086 self.assertEqual(5,f.getNumberOfMeshPlacesExpected());
2087 self.assertEqual(0,f.getNbOfGaussLocalization());
2088 f.setGaussLocalizationOnType(NORM_TRI3,_refCoo1,_gsCoo1,_wg1);
2089 f.setGaussLocalizationOnType(NORM_TRI3,_refCoo1,_gsCoo1,_wg1); # not a bug only to check that it works well
2090 self.assertRaises(InterpKernelException,f.setGaussLocalizationOnType,NORM_QUAD4,_refCoo1,_gsCoo1,_wg1)
2091 self.assertEqual(1,f.getNbOfGaussLocalization());
2092 refCoo2=[ 0.,0., 1.,0., 1.,1., 0.,1. ]
2094 _gsCoo1=_gsCoo1[0:4]
2096 f.setGaussLocalizationOnType(NORM_QUAD4,_refCoo2,_gsCoo1,_wg1);
2097 self.assertEqual(2,f.getNbOfGaussLocalization());
2098 array=DataArrayDouble.New();
2100 for i in range(18 * 2):
2102 array.setValues(ptr,18,2);
2103 ptr=array.getPointer();
2105 f.setName("MyFirstFieldOnGaussPoint");
2106 f.checkConsistencyLight();
2107 self.assertAlmostEqual(27.,f.getIJK(2,5,0),14);
2108 self.assertAlmostEqual(16.,f.getIJK(1,5,1),14);
2110 f.clearGaussLocalizations();
2111 self.assertEqual(0,f.getNbOfGaussLocalization());
2112 self.assertRaises(InterpKernelException,f.checkConsistencyLight);
2114 self.assertRaises(InterpKernelException,f.setGaussLocalizationOnCells,ids1,_refCoo2,_gsCoo1,_wg1);
2115 self.assertEqual(0,f.getNbOfGaussLocalization());
2117 f.setGaussLocalizationOnCells(ids2,_refCoo2,_gsCoo1,_wg1);
2118 self.assertEqual(1,f.getNbOfGaussLocalization());
2119 self.assertEqual(0,f.getGaussLocalizationIdOfOneCell(0));
2120 self.assertRaises(InterpKernelException,f.getGaussLocalizationIdOfOneCell,1);
2122 f.setGaussLocalizationOnCells(ids3,_refCoo1,_gsCoo1,_wg1);
2123 self.assertEqual(2,f.getNbOfGaussLocalization());
2124 self.assertEqual(0,f.getGaussLocalizationIdOfOneCell(0));
2125 self.assertEqual(1,f.getGaussLocalizationIdOfOneCell(1));
2126 self.assertEqual(1,f.getGaussLocalizationIdOfOneCell(2));
2127 self.assertRaises(InterpKernelException,f.checkConsistencyLight);#<- cell 3 has no localization
2131 _gsCoo2[0]=0.8888777776666;
2132 _wg2[0]=0.1234567892377;
2133 f.setGaussLocalizationOnCells(ids4,_refCoo2,_gsCoo2,_wg2);
2134 self.assertEqual(3,f.getNbOfGaussLocalization());
2135 tmpIds=f.getCellIdsHavingGaussLocalization(0);
2136 self.assertEqual(ids2,list(tmpIds.getValues()));
2137 self.assertRaises(InterpKernelException,f.checkConsistencyLight);#<- it's always not ok because undelying array not with the good size.
2138 array2=f.getArray().subArray(0,10);
2140 f.checkConsistencyLight();#<- here it is OK
2142 self.assertTrue(f.isEqual(f2,1e-14,1e-14));
2143 gl1=f2.getGaussLocalization(0);
2144 tmp=gl1.getGaussCoord(1,1);
2145 self.assertAlmostEqual(2.07*_b-1,tmp,14);
2146 gl1.setGaussCoord(1,1,0.07);
2147 self.assertTrue(not f.isEqual(f2,1e-14,1e-14));
2148 gl1.setGaussCoord(1,1,tmp);
2149 self.assertTrue(f.isEqual(f2,1e-14,1e-14));
2150 f2.checkConsistencyLight();
2153 def testGaussPointNEField1(self):
2154 m=MEDCouplingDataForTest.build2DTargetMesh_1();
2155 f=MEDCouplingFieldDouble.New(ON_GAUSS_NE,NO_TIME);
2157 self.assertEqual(5,f.getNumberOfMeshPlacesExpected());
2158 f.setName("MyFirstFieldOnNE");
2159 f.setDescription("MyDescriptionNE");
2160 array=DataArrayDouble.New();
2162 for i in range(18 * 2):
2165 array.setValues(tmp,18,2);
2166 ptr=array.getPointer();
2169 f.checkConsistencyLight();
2171 self.assertTrue(f.isEqual(f2,1e-14,1e-14));
2172 self.assertAlmostEqual(21.,f.getIJK(2,0,0),14);
2173 self.assertAlmostEqual(18.,f.getIJK(1,1,1),14);
2176 def testCellOrientation1(self):
2177 m=MEDCouplingDataForTest.build2DTargetMesh_1();
2179 self.assertRaises(InterpKernelException,m.are2DCellsNotCorrectlyOriented,vec,False);
2180 m.changeSpaceDimension(3);
2181 res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2182 self.assertTrue(len(res1)==0);
2184 res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2185 self.assertEqual(5,len(res1));
2188 # connectivity inversion
2189 conn=m.getNodalConnectivity().getValues();
2193 m.getNodalConnectivity().setValues(conn,len(conn),1)
2194 res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2195 self.assertEqual(1,len(res1));
2196 self.assertEqual(2,res1.getValues()[0]);
2197 m.orientCorrectly2DCells(vec,False);
2198 res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2199 self.assertTrue(len(res1)==0);
2200 m2=MEDCouplingDataForTest.build2DTargetMesh_1();
2201 m2.changeSpaceDimension(3);
2202 self.assertTrue(m.isEqual(m2,1e-12));
2205 def testCellOrientation2(self):
2206 m2,m1=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
2207 res1=m2.arePolyhedronsNotCorrectlyOriented();
2208 self.assertEqual(6,len(res1));
2209 m2.orientCorrectlyPolyhedrons();
2210 res1=m2.arePolyhedronsNotCorrectlyOriented();
2211 self.assertTrue(len(res1)==0);
2212 m2.checkConsistencyLight();
2213 self.assertEqual(18,m2.getNumberOfCells());
2215 m2.convertToPolyTypes(cellIds2);
2216 m2.orientCorrectlyPolyhedrons();
2217 res1=m2.arePolyhedronsNotCorrectlyOriented();
2218 self.assertTrue(len(res1)==0);
2219 f2=m2.getMeasureField(False);
2220 f2Ptr=f2.getArray().getValues();
2221 #Test to check global reverse in MEDCouplingUMesh::tryToCorrectPolyhedronOrientation
2222 m3=MEDCouplingDataForTest.build2DTargetMesh_1();
2224 m3.changeSpaceDimension(3);
2226 m3.convertToPolyTypes(ids2);
2227 m3.orientCorrectly2DCells(vec,False);
2228 m4=MEDCouplingDataForTest.buildCU1DMesh_U();
2229 m4.changeSpaceDimension(3);
2232 m4.rotate(center,vector,-pi/2.);
2233 m5=m3.buildExtrudedMesh(m4,0);
2234 res1=m5.arePolyhedronsNotCorrectlyOriented();
2235 self.assertEqual(15,len(res1));
2236 m5.orientCorrectlyPolyhedrons();
2237 res1=m5.arePolyhedronsNotCorrectlyOriented();
2238 self.assertTrue(len(res1)==0);
2239 f3=m5.getMeasureField(False);
2240 self.assertEqual(15,f3.getArray().getNumberOfTuples());
2241 self.assertEqual(1,f3.getNumberOfComponents());
2242 f3Ptr=f3.getArray().getValues();
2243 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];
2245 self.assertTrue(abs(expected1[i]-f3Ptr[i])<1e-12);
2247 f4=m5.computeCellCenterOfMass();
2248 self.assertEqual(15,f4.getNumberOfTuples());
2249 self.assertEqual(3,f4.getNumberOfComponents());
2250 f4Ptr=f4.getValues();
2251 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];
2253 self.assertTrue(abs(expected2[i]-f4Ptr[i])<1e-12);
2257 def testCellOrientation3(self):
2258 from cmath import rect
2260 c = [rect(1.0, i * pi / 4.0) for i in range(8)]
2261 coords = [c[-1].real,c[-1].imag, c[3].real,c[3].imag,
2262 c[5].real,c[5].imag, c[1].real,c[1].imag]
2264 baseMesh = MEDCouplingUMesh.New("circle", 2)
2265 baseMesh.allocateCells(1)
2266 meshCoords = DataArrayDouble.New(coords, 4, 2)
2267 baseMesh.setCoords(meshCoords)
2268 baseMesh.insertNextCell(NORM_QPOLYG, connec) # a circle
2269 baseMesh.finishInsertingCells()
2270 baseMesh.changeSpaceDimension(3)
2271 Oz = [0.0, 0.0, -1.0]
2272 cell_lst = baseMesh.are2DCellsNotCorrectlyOriented(Oz, False)
2273 self.assertEqual(cell_lst.getNumberOfTuples(), 0)
2275 cell_lst = baseMesh.are2DCellsNotCorrectlyOriented(Oz, False)
2276 self.assertEqual(cell_lst.getNumberOfTuples(), 1)
2278 def testCellOrientation4(self):
2279 """ Non regression for NORM_QPOLYG whose linear version is self-intersecting. """
2280 mesh = MEDCouplingUMesh('merge', 2)
2281 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)])
2283 c = DataArrayInt([32, 9, 8, 6, 4, 0, 2, 10, 13, 1, 7, 5, 3, 11, 12])
2284 cI = DataArrayInt([0, 15])
2285 mesh.setConnectivity(c, cI)
2287 mesh.changeSpaceDimension(3)
2288 mesh.orientCorrectly2DCells(vec, False)
2289 mesh.changeSpaceDimension(2)
2290 cRef = [32, 9, 10, 2, 0, 4, 6, 8, 12, 11, 3, 5, 7, 1, 13]
2292 self.assertEqual(mesh.getNodalConnectivity().getValues(), cRef)
2293 self.assertEqual(mesh.getNodalConnectivityIndex().getValues(), cIRef)
2296 def testPolyhedronBarycenter(self):
2297 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];
2298 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];
2299 meshN=MEDCouplingUMesh.New();
2300 meshN.setName("ForBary");
2301 meshN.setMeshDimension(3);
2302 meshN.allocateCells(4);
2303 meshN.insertNextCell(NORM_POLYHED,29,connN[0:29])
2304 meshN.finishInsertingCells();
2305 myCoords=DataArrayDouble.New();
2306 myCoords.setValues(coords,9,3);
2307 meshN.setCoords(myCoords);
2308 meshN.checkConsistencyLight();
2310 res1=meshN.arePolyhedronsNotCorrectlyOriented();
2311 meshN.orientCorrectlyPolyhedrons();
2312 self.assertTrue(len(res1)==0);
2313 da=meshN.computeCellCenterOfMass();
2314 self.assertEqual(1,da.getNumberOfTuples());
2315 self.assertEqual(3,da.getNumberOfComponents());
2316 daPtr=da.getValues();
2317 ref=meshN.getCoords().getValues()[24:];
2319 self.assertTrue(abs(ref[i]-daPtr[i])<1e-12);
2324 da=meshN.computeCellCenterOfMass();
2325 daPtr=da.getValues();
2326 ref=meshN.getCoords().getValues()[24:];
2328 self.assertTrue(abs(ref[i]-daPtr[i])<1e-12);
2331 meshN.rotate(center,vec,pi/7.);
2332 meshN.translate(vec);
2333 da=meshN.computeCellCenterOfMass();
2334 daPtr=da.getValues();
2335 ref=meshN.getCoords().getValues()[24:];
2337 self.assertTrue(abs(ref[i]-daPtr[i])<1e-12);
2340 center2=[1.12,3.45,6.78]
2342 meshN.rotate(center2,vec2,e);
2343 meshN.translate(vec2);
2344 da=meshN.computeCellCenterOfMass();
2345 daPtr=da.getValues();
2346 ref=meshN.getCoords().getValues()[24:];
2348 self.assertTrue(abs(ref[i]-daPtr[i])<1e-10);
2352 def testNormL12Integ1D(self):
2353 m1=MEDCouplingDataForTest.build1DTargetMesh_3();
2354 f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2356 array=DataArrayDouble.New();
2357 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]
2358 array.setValues(arr,m1.getNumberOfCells(),3);
2361 f3=m1.computeCellCenterOfMass();
2362 self.assertEqual(4,f3.getNumberOfTuples());
2363 self.assertEqual(1,f3.getNumberOfComponents());
2364 expected9=[0.75,5.105,0.8,5.155]
2367 self.assertTrue(abs(expected9[i]-ptr[i])<1e-12);
2370 f2=m1.getMeasureField(False);
2371 self.assertEqual(4,f2.getArray().getNumberOfTuples());
2372 self.assertEqual(1,f2.getNumberOfComponents());
2373 expected1=[0.5,0.21,-0.6,-0.31]
2374 ptr=f2.getArray().getValues();
2376 self.assertTrue(abs(expected1[i]-ptr[i])<1e-12);
2378 expected2=[0.5,0.21,0.6,0.31]
2379 f2=m1.getMeasureField(True);
2380 ptr=f2.getArray().getValues();
2382 self.assertTrue(abs(expected2[i]-ptr[i])<1e-12);
2385 self.assertTrue(4,f1.getNumberOfTuples())
2386 res=f1.integral(False);
2387 self.assertTrue(3,len(res))
2388 expected3=[0.9866,-0.3615,0.4217]
2390 self.assertTrue(abs(expected3[i]-res[i])<1e-12);
2392 self.assertTrue(abs(expected3[0]-f1.integral(0,False))<1e-12);
2393 self.assertTrue(abs(expected3[1]-f1.integral(1,False))<1e-12);
2394 self.assertTrue(abs(expected3[2]-f1.integral(2,False))<1e-12);
2395 res=f1.integral(True);
2396 expected4=[-3.4152,8.7639,-14.6879]
2398 self.assertTrue(abs(expected4[i]-res[i])<1e-12);
2402 self.assertTrue(3,len(res))
2403 expected5=[6.979506172839505, 16.89018518518518, 27.02969135802469]
2405 self.assertTrue(abs(expected5[i]-res[i])<1e-12);
2407 self.assertTrue(abs(expected5[0]-f1.normL1(0))<1e-12);
2408 self.assertTrue(abs(expected5[1]-f1.normL1(1))<1e-12);
2409 self.assertTrue(abs(expected5[2]-f1.normL1(2))<1e-12);
2412 self.assertTrue(3,len(res))
2413 expected7=[7.090910979452395, 16.9275542960123, 27.053271464160858]
2415 self.assertTrue(abs(expected7[i]-res[i])<1e-9);
2417 self.assertTrue(abs(expected7[0]-f1.normL2(0))<1e-9);
2418 self.assertTrue(abs(expected7[1]-f1.normL2(1))<1e-9);
2419 self.assertTrue(abs(expected7[2]-f1.normL2(2))<1e-9);
2421 f4=f1.buildMeasureField(False);
2422 self.assertTrue(abs(-0.2-f4.accumulate(0))<1e-12);
2423 f4=f1.buildMeasureField(True);
2424 self.assertTrue(abs(1.62-f4.accumulate(0))<1e-12);
2425 # Testing with 2D Curve
2426 m1=MEDCouplingDataForTest.build2DCurveTargetMesh_3();
2427 f2=m1.getMeasureField(False);
2428 self.assertEqual(4,f2.getArray().getNumberOfTuples());
2429 self.assertEqual(1,f2.getNumberOfComponents());
2430 ptr=f2.getArray().getValues();
2432 self.assertTrue(abs(sqrt(2.)*expected2[i]-ptr[i])<1e-12);
2434 f2=m1.getMeasureField(True);
2435 self.assertEqual(4,f2.getArray().getNumberOfTuples());
2436 self.assertEqual(1,f2.getNumberOfComponents());
2437 ptr=f2.getArray().getValues();
2439 self.assertTrue(abs(expected2[i]*sqrt(2.)-ptr[i])<1e-12);
2442 f3=m1.computeCellCenterOfMass();
2443 self.assertEqual(4,f3.getNumberOfTuples());
2444 self.assertEqual(2,f3.getNumberOfComponents());
2445 expected10=[0.75,0.75,5.105,5.105,0.8,0.8,5.155,5.155]
2448 self.assertTrue(abs(expected10[i]-ptr[i])<1e-12);
2451 f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2453 array=DataArrayDouble.New();
2454 array.setValues(arr,m1.getNumberOfCells(),3);
2456 res=f1.integral(False);
2458 self.assertTrue(abs(sqrt(2.)*expected4[i]-res[i])<1e-12);
2460 res=f1.integral(True);
2462 self.assertTrue(abs(sqrt(2.)*expected4[i]-res[i])<1e-12);
2466 self.assertTrue(abs(expected5[i]-res[i])<1e-12);
2470 self.assertTrue(abs(expected7[i]-res[i])<1e-12);
2474 def testAreaBary2D(self):
2475 m1=MEDCouplingDataForTest.build2DTargetMesh_3();
2476 f1=m1.getMeasureField(False);
2477 self.assertEqual(10,f1.getArray().getNumberOfTuples());
2478 self.assertEqual(1,f1.getNumberOfComponents());
2479 expected1=[-0.5,-1,-1.5,-0.5,-1, 0.5,1,1.5,0.5,1]
2480 ptr=f1.getArray().getValues();
2482 self.assertTrue(abs(expected1[i]-ptr[i])<1e-12);
2484 f1=m1.getMeasureField(True);
2485 ptr=f1.getArray().getValues();
2487 self.assertTrue(abs(abs(expected1[i])-ptr[i])<1e-12);
2489 f2=m1.computeCellCenterOfMass();
2490 self.assertEqual(10,f2.getNumberOfTuples());
2491 self.assertEqual(2,f2.getNumberOfComponents());
2492 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]
2495 self.assertTrue(abs(expected2[i]-ptr[i])<1e-12);
2497 m1.changeSpaceDimension(3);
2498 f1=m1.getMeasureField(False);
2499 self.assertEqual(10,f1.getArray().getNumberOfTuples());
2500 self.assertEqual(1,f1.getNumberOfComponents());
2501 ptr=f1.getArray().getValues();
2503 self.assertTrue(abs(abs(expected1[i])-ptr[i])<1e-12);
2505 f2=m1.computeCellCenterOfMass();
2506 self.assertEqual(10,f2.getNumberOfTuples());
2507 self.assertEqual(3,f2.getNumberOfComponents());
2509 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.]
2511 self.assertTrue(abs(expected3[i]-ptr[i])<1e-12);
2515 def testAreaBary3D(self):
2516 coords=[ 0.241310763507 , 0.0504777305619 , 0.0682283524903 , 0.252501053866 , -0.0625176732937 , 0.137272639894 ,
2517 0.152262663601 , 0.241816569527 , 0.133812556197 , 0.18047750211 , -0.0789949051358 , 0.339098173401 ,
2518 0.151741971857 , 0.238885278571 , 0.137715037333 , 0.242532155481 , -0.0928169086456 , 0.0678043417367 ,
2519 0.240941965335 , -0.015461491464 , 0.0617186345825 , 0.24127650112 , 0.0499427876717 , 0.0679634099148 ,
2520 -0.145828917428 , 0.206291632565 , 0.0310071927543 , 0.0125651775307 , 0.266262085828 , 0.105228430543 ,
2521 -0.0994066533286 , 0.233224271238 , 0.0572213839567 , -0.0951345338317 , 0.234819509426 , 0.0592126284538 ,
2522 0.136580574205 , -0.205486212579 , 0.0572866072014 , 0.0637270784978 , -0.168886355238 , 0.446614057077 ,
2523 0.041337157151 , -0.213402568198 , 0.372407095999 , 0.0411601970268 , -0.202387875756 , 0.411334979491 ,
2524 -0.108355701857 , 0.193636239335 , 0.204886756738 , 0.00639779029829 , 0.155296981517 , 0.252585892979 ,
2525 0.0262473111702 , -0.112919732543 , 0.424286639249 ,-0.224103052733 , -0.139430015438 , -0.0122352295701 ,
2526 -0.0312760589481 , -0.274272003594 , 0.0323959636568 , -0.166663422532 , -0.217754445175 , 0.00392109070364 ,
2527 -0.30586619777 , -0.0475168041091 , -0.0144585228182 , -0.280881480586 , 0.135571293538 , 0.00623923647986 ,
2528 -0.25548538234 , 0.156819217766 , 0.0645277879769 , -0.131567009284 , 0.184133752309 , 0.206021802753 ,
2529 -0.196204010965 , 0.151602971681 , 0.212974777736 , -0.183713879463 , 0.0802946639531 , 0.260115662599 ,
2530 -0.244241178767 , -0.0738873389604 , 0.144590565817 , -0.155804057829 , -0.164892720025 , 0.210613950558 ,
2531 -0.170950800428 , -0.215099334026 , 0.00610122860092 , -0.30552634869 , -0.0490020791904 , -0.0132786533145 ,
2532 0.271831011884 , 0.15105657296 , 0.0230534827908 , 0.281919192283 , 0.0898544306288 , -0.0625201489143 ,
2533 0.260240727276 , -0.0120688706637 , -0.0532316588626 , 0.244947737722 , 0.0197984684293 , 0.0309341209233 ,
2534 0.23439631578 , 0.229825279875 , 0.0508520585381 , 0.160921316875 , 0.265078502128 , 0.121716560626 ,
2535 -0.315088694175 , 0.0747700471918 , -0.245836615071 , -0.327728781776 , 0.0857114674649 , -0.239431905957 ,
2536 -0.308385460634 , 0.145142997084 , -0.149886828433 , 0.0488236045164 , 0.309462801914 , 0.0849169148265 ,
2537 -0.0244964803395 , 0.33145611751 , -0.0476415818061 , 0.0060567994229 , 0.32418412014 , 0.0367779543812 ,
2538 -0.0950221448063 , 0.236675326003 , 0.0572594453983 , 0.248723023186 , 0.0886648784791 , -0.176629430538 ,
2539 0.116796984 , 0.256596599567 , -0.292863523603 , 0.118024552914 , 0.229154257843 , -0.34233232501 ,
2540 0.217507892549 , -0.0417822335742 , -0.176771782888 , -0.224429321304 , 0.0125595300114 , -0.362064725588 ,
2541 0.0937301100955 , -0.0500824832657 , -0.299713548444 , -0.244162220397 , 0.0383853931293 , -0.389856984411 ,
2542 -0.0281989366102 , 0.097392811563 , -0.458244577284 , -0.385010847162 , 0.10122766194 , -0.140052859922 ,
2543 -0.377936358012 , 0.110875172128 , -0.176207095463 , 0.244483045556 , -0.0991073977045 , 0.0575134372934 ,
2544 0.262605120167 , -0.100243191645 , -0.0495620806935 , 0.240306880972 , -0.136153701579 , -0.114745281696 ,
2545 0.215763176129 , -0.0836766059189 , -0.183249640616 , 0.237870396603 , -0.132449578286 , -0.121598854639 ,
2546 -0.0637683083097 , -0.27921020214 , -0.149112321992 , -0.0856211014977 , -0.2973233473 , -0.0446878139589 ,
2547 0.104675342288 , -0.0625908305324 , -0.290346256534 , 0.0248264249186 , -0.247797708548 , -0.165830884019 ,
2548 0.0719302438309 , -0.178468260473 , -0.211432157345 , 0.142871843159 , -0.208769948542 , 0.0454101128246 ,
2549 0.167803379307 , -0.207851396623 , -0.088802726124 , 0.12868717152 , -0.230920439715 , 0.00760508389036 ,
2550 -0.0372812069535 , -0.286740286332 , 0.00963701291166 ]
2552 connN = [ #polyhedron 0
2553 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
2554 , 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
2555 , 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
2556 , 22 , 19 , 21 , 30 , 31 , -1 , 22 , 31 , 28 , 27 , 26 , 24 , 23 , -1 , 31 , 30 , 29 , 28,
2558 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
2559 , 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
2560 , 33 , 34 , 48 , 45 , -1 , 35 , 34 , 48 , 50 , 49 , 38 , -1 , 41 , 43 , 42 , 46 , 36 , 37 , -1 , 38 , 39 , 51 , 49 , -1
2561 , 39 , 40 , 42 , 46 , 47 , 52 , 51 , -1 , 45 , 47 , 52 , 50 , 48 , -1 , 52 , 51 , 49 , 50,
2563 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
2564 , 23 , 53 , 54 , 40 , 8 , -1 , 53 , 22 , 23 , -1 , 39 , 54 , 40,
2566 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
2567 , 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
2568 , 55 , 5 , 12 , 65 , -1 , 66 , 67 , 65 , 55 , 56 , 57 , -1 , 63 , 66 , 57 , 59 , 64 , -1 , 64 , 62 , 58 , 59 , -1
2569 , 60 , 63 , 66 , 67 , 68 , 61 , -1 , 61 , 68 , 20 , 21 , -1 , 67 , 68 , 20 , 12 , 65]
2571 barys = [ -0.0165220465527 , -0.0190922868195 , 0.158882733414 ,
2572 0.0287618656076 , 0.135874379934 , -0.14601588119 ,
2573 -0.147128055553 , 0.0465995097041 , -0.049391174453 ,
2574 -0.00142506732317 , -0.0996953090351 , -0.115159183132 ]
2575 meshN=MEDCouplingUMesh.New();
2576 meshN.setName("ForBary");
2577 meshN.setMeshDimension(3);
2578 meshN.allocateCells(4);
2579 meshN.insertNextCell(NORM_POLYHED,113,connN);
2580 meshN.insertNextCell(NORM_POLYHED,99,connN[113:]);
2581 meshN.insertNextCell(NORM_POLYHED,43,connN[212:]);
2582 meshN.insertNextCell(NORM_POLYHED,92,connN[255:]);
2583 meshN.finishInsertingCells();
2584 myCoords=DataArrayDouble.New();
2585 myCoords.setValues(coords,69,3);
2586 meshN.setCoords(myCoords);
2587 meshN.checkConsistencyLight();
2588 res1=meshN.arePolyhedronsNotCorrectlyOriented();
2589 meshN.orientCorrectlyPolyhedrons();
2590 res1=meshN.arePolyhedronsNotCorrectlyOriented();
2591 self.assertTrue(len(res1)==0);
2593 da=meshN.computeCellCenterOfMass();
2594 self.assertEqual(4,da.getNumberOfTuples());
2595 self.assertEqual(3,da.getNumberOfComponents());
2596 daPtr=da.getValues();
2598 self.assertTrue(abs(barys[i]-daPtr[i])<1e-12);
2602 def testRenumberCellsForFields(self):
2603 m=MEDCouplingDataForTest.build2DTargetMesh_1();
2604 f=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2606 arr=DataArrayDouble.New();
2607 nbOfCells=m.getNumberOfCells();
2608 values1=[7.,107.,10007.,8.,108.,10008.,9.,109.,10009.,10.,110.,10010.,11.,111.,10011.]
2609 arr.setValues(values1,nbOfCells,3);
2611 renumber1=[3,1,0,4,2]
2612 loc=[-0.05,-0.05, 0.55,-0.25, 0.55,0.15, -0.05,0.45, 0.45,0.45]
2614 res=f.getValueOn(loc[2*j:2*j+2]);
2616 self.assertTrue(abs(values1[i+3*j]-res[i])<1e-12);
2619 f.renumberCells(renumber1,False);
2620 ptr=f.getArray().getValues();
2621 expected1=[9.,109.,10009.,8.,108.,10008.,11.,111.,10011.,7.,107.,10007.,10.,110.,10010.]
2623 self.assertTrue(abs(expected1[i]-ptr[i])<1e-12);
2625 #check that fields remains the same geometrically
2627 res=f.getValueOn(loc[2*j:2*(j+1)]);
2629 self.assertTrue(abs(values1[i+3*j]-res[i])<1e-12);
2633 f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,NO_TIME);
2635 _a=0.446948490915965;
2636 _b=0.091576213509771;
2637 _p1=0.11169079483905;
2638 _p2=0.0549758718227661;
2639 refCoo1=[ 0.,0., 1.,0., 0.,1. ]
2640 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 ];
2641 wg1=[ 4*_p2, 4*_p2, 4*_p2, 4*_p1, 4*_p1, 4*_p1 ]
2642 _refCoo1=refCoo1[0:6];
2643 _gsCoo1=gsCoo1[0:12];
2645 f.setGaussLocalizationOnType(NORM_TRI3,_refCoo1,_gsCoo1,_wg1);
2646 refCoo2=[ 0.,0., 1.,0., 1.,1., 0.,1. ]
2647 _refCoo2=refCoo2[0:8];
2648 _gsCoo1=_gsCoo1[0:4]
2650 f.setGaussLocalizationOnType(NORM_QUAD4,_refCoo2,_gsCoo1,_wg1);
2651 arr=DataArrayDouble.New();
2652 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.]
2653 arr.setValues(values2,18,2);
2655 f.checkConsistencyLight();
2657 self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2658 f.renumberCells(renumber1,False);
2659 self.assertTrue(not f.isEqual(fCpy,1e-12,1e-12));
2660 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.]
2661 ptr=f.getArray().getValues();
2663 self.assertTrue(abs(expected2[i]-ptr[i])<1e-12);
2665 renumber2=[2,1,4,0,3]
2666 f.renumberCells(renumber2,False);
2667 self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2669 f=MEDCouplingFieldDouble.New(ON_GAUSS_NE,NO_TIME);
2671 arr=DataArrayDouble.New();
2672 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.]
2673 arr.setValues(values3,18,2);
2675 f.checkConsistencyLight();
2677 self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2678 f.renumberCells(renumber1,False);
2679 self.assertTrue(not f.isEqual(fCpy,1e-12,1e-12));
2680 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.]
2681 ptr=f.getArray().getValues();
2683 self.assertTrue(abs(expected3[i]-ptr[i])<1e-12);
2685 f.renumberCells(renumber2,False);#perform reverse operation of renumbering to check that the resulting field is equal.
2686 self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2690 def testRenumberNodesForFields(self):
2691 m=MEDCouplingDataForTest.build2DTargetMesh_1();
2692 f=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
2694 self.assertEqual(9,f.getNumberOfMeshPlacesExpected());
2695 arr=DataArrayDouble.New();
2696 nbOfNodes=m.getNumberOfNodes();
2697 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.]
2698 arr.setValues(values1,nbOfNodes,3);
2700 f.checkConsistencyLight();
2701 renumber1=[0,4,1,3,5,2,6,7,8]
2702 loc=[0.5432,-0.2432, 0.5478,0.1528]
2703 expected1=[9.0272, 109.0272, 10009.0272, 11.4124,111.4124,10011.4124]
2705 res=f.getValueOn(loc[2*j:2*j+2]);
2707 self.assertTrue(abs(expected1[i+3*j]-res[i])<1e-12);
2711 self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2712 f.renumberNodes(renumber1);
2713 self.assertTrue(not f.isEqual(fCpy,1e-12,1e-12));
2715 res=f.getValueOn(loc[2*j:2*j+2]);
2717 self.assertTrue(abs(expected1[i+3*j]-res[i])<1e-12);
2720 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.]
2722 self.assertTrue(abs(expected2[i]-f.getArray().getValues()[i])<1e-12);
2724 renumber2=[0,2,5,3,1,4,6,7,8]
2725 f.renumberNodes(renumber2);
2726 self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2729 def testConvertQuadraticCellsToLinear(self):
2730 mesh=MEDCouplingDataForTest.build2DTargetMesh_3();
2731 mesh.checkConsistencyLight();
2732 types=mesh.getAllGeoTypes();
2734 self.assertEqual(5,len(types));
2735 expected1 = [NORM_POLYGON, NORM_TRI3, NORM_QUAD4, NORM_TRI6, NORM_QUAD8]
2737 self.assertEqual(expected1,types);
2738 self.assertTrue(mesh.isPresenceOfQuadratic());
2739 self.assertEqual(62,mesh.getNodalConnectivityArrayLen());
2740 f1=mesh.getMeasureField(False);
2742 mesh.convertQuadraticCellsToLinear();
2743 self.assertTrue(not mesh.isPresenceOfQuadratic());
2745 mesh.checkConsistencyLight();
2746 f2=mesh.getMeasureField(False);
2747 self.assertTrue(f1.getArray().isEqual(f2.getArray(),1e-12));
2748 self.assertEqual(48,mesh.getNodalConnectivityArrayLen());
2749 types2=mesh.getAllGeoTypes();
2751 self.assertEqual(3,len(types2));
2752 expected2=[NORM_POLYGON, NORM_TRI3, NORM_QUAD4]
2754 self.assertEqual(expected2,types2);
2757 def testCheckGeoEquivalWith(self):
2758 mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2759 mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2761 cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh1,0,1e-12);#deepEqual
2762 self.assertTrue(cellCor==None);
2763 self.assertTrue(nodeCor==None);
2764 cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh1,1,1e-12);#fastEqual
2765 self.assertTrue(cellCor==None);
2766 self.assertTrue(nodeCor==None);
2767 cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh1,10,1e-12);#deepEqual with geo permutations
2768 self.assertTrue(cellCor==None);
2769 self.assertTrue(nodeCor==None);
2770 #Second test mesh1 and mesh2 are 2 different meshes instance
2771 cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,0,1e-12);#deepEqual
2772 self.assertTrue(cellCor==None);
2773 self.assertTrue(nodeCor==None);
2774 cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,1,1e-12);#fastEqual
2775 self.assertTrue(cellCor==None);
2776 self.assertTrue(nodeCor==None);
2777 cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);#deepEqual with geo permutations
2778 self.assertTrue(cellCor==None);
2779 self.assertTrue(nodeCor==None);
2780 #Third test : cell permutation by keeping the first the middle and the last as it is.
2781 renum=[0,2,1,3,4,5,6,8,7,9]
2782 mesh2.renumberCells(renum,False);
2783 self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12);#deepEqual fails
2784 self.assertTrue(cellCor==None);
2785 self.assertTrue(nodeCor==None);
2786 cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,1,1e-12);#fastEqual do not see anything
2787 self.assertTrue(cellCor==None);
2788 self.assertTrue(nodeCor==None);
2789 cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);#deepEqual with geo permutations
2790 self.assertTrue(cellCor);
2791 self.assertEqual(10,cellCor.getNumberOfTuples());
2792 self.assertEqual(1,cellCor.getNumberOfComponents());
2793 self.assertEqual(renum,list(cellCor.getValues()))
2794 self.assertTrue(nodeCor==None);
2796 self.assertTrue(nodeCor==None);
2797 a,b=mesh1.checkDeepEquivalWith(mesh2,0,1e-12);
2798 self.assertEqual(renum,list(a.getValues()))
2799 self.assertTrue(b==None);
2800 mesh2.setCoords(mesh1.getCoords())
2801 a=mesh1.checkDeepEquivalOnSameNodesWith(mesh2,0,1e-12);
2802 self.assertEqual(renum,list(a.getValues()))
2803 #4th test : cell and node permutation by keeping the first the middle and the last as it is.
2804 mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2805 renum2=[0,2,1,3,4,5,6,8,7,9,10]
2806 mesh2.renumberCells(renum,False);
2807 mesh2.renumberNodes(renum2,11);
2810 self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12);#deepEqual fails
2811 self.assertTrue(cellCor==None);
2812 self.assertTrue(nodeCor==None);
2813 cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,1,1e-12);#fastEqual do not see anything
2814 self.assertTrue(cellCor==None);
2815 self.assertTrue(nodeCor==None);
2816 cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);#deepEqual with geo permutations
2817 self.assertTrue(cellCor);
2818 self.assertEqual(10,cellCor.getNumberOfTuples());
2819 self.assertEqual(1,cellCor.getNumberOfComponents());
2820 self.assertEqual(renum,list(cellCor.getValues()))
2821 self.assertTrue(nodeCor);
2822 self.assertEqual(11,nodeCor.getNumberOfTuples());
2823 self.assertEqual(1,nodeCor.getNumberOfComponents());
2824 self.assertEqual(renum2,list(nodeCor.getValues()))
2827 #5th test : modification of the last cell to check fastCheck detection.
2828 mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2829 renum3=[0,2,1,3,4,5,6,8,9,7]
2830 mesh2.renumberCells(renum3,False);
2831 mesh2.renumberNodes(renum2,11);
2834 self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12)
2835 self.assertTrue(cellCor==None);
2836 self.assertTrue(nodeCor==None);
2837 self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,1,1e-12)
2838 self.assertTrue(cellCor==None);
2839 self.assertTrue(nodeCor==None);
2840 cellCor,nodeCor=mesh2.checkGeoEquivalWith(mesh1,10,1e-12);#deepEqual with geo permutations
2841 self.assertTrue(cellCor!=None);
2842 self.assertEqual(10,cellCor.getNumberOfTuples());
2843 self.assertEqual(1,cellCor.getNumberOfComponents());
2844 self.assertEqual(renum3,list(cellCor.getValues()))
2845 self.assertTrue(nodeCor!=None);
2846 self.assertEqual(11,nodeCor.getNumberOfTuples());
2847 self.assertEqual(1,nodeCor.getNumberOfComponents());
2848 self.assertEqual(renum2,list(nodeCor.getValues()));
2851 def testCheckGeoEquivalWith2(self):
2852 mesh1=MEDCouplingDataForTest.build2DTargetMesh_4();
2853 mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
2854 cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);
2855 self.assertEqual(None,cellCor);
2856 self.assertNotEqual(None,nodeCor);
2857 expected1=[0, 1, 3, 4, 5, 6, 7, 8, 9]
2859 self.assertEqual(expected1[i],nodeCor.getIJ(i,0));
2863 def testSwig2CheckDeepEquivalWith1(self):
2865 mcart = MEDCouplingCMesh()
2866 mcart.setCoordsAt(0, DataArrayDouble([0.0,1.5,2.0]))
2867 mcart.setCoordsAt(1, DataArrayDouble([1.0,2.5,3.0,4.0]))
2868 m = mcart.buildUnstructured()
2869 m2 = m[1:m.getNumberOfCells()]
2870 self.assertRaises(InterpKernelException, m.checkDeepEquivalWith, m2, 0, eps)
2871 self.assertRaises(InterpKernelException, m.checkDeepEquivalWith, m2, 1, eps)
2872 self.assertRaises(InterpKernelException, m.checkDeepEquivalWith, m2, 2, eps)
2875 def testSwig2CheckDeepEquivalWith2(self):
2877 m = MEDCouplingUMesh("tst", 2)
2878 m.setCoords(DataArrayDouble([], 0,2))
2879 m.setConnectivity(DataArrayInt([]), DataArrayInt([0]))
2881 m.checkDeepEquivalWith(m2, 0, eps) # Should not raise!
2884 def testCopyTinyStringsFromOnFields(self):
2885 m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2886 nbOfCells=m.getNumberOfCells();
2887 f=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
2889 self.assertEqual(5,f.getNumberOfMeshPlacesExpected());
2891 f.setDescription("b");
2892 a1=DataArrayDouble.New();
2893 a1.alloc(nbOfCells,2);
2895 a1.setInfoOnComponent(0,"c");
2896 a1.setInfoOnComponent(1,"d");
2898 a2.setInfoOnComponent(0,"e");
2899 a2.setInfoOnComponent(1,"f");
2902 f.setEndTime(3.,3,4);
2904 m.getCoords().setInfoOnComponent(0,"h");
2905 m.getCoords().setInfoOnComponent(1,"i");
2906 m.getCoords().setInfoOnComponent(2,"j");
2908 f.checkConsistencyLight();
2910 self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2912 self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2913 f2.copyTinyStringsFrom(f);
2914 self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2915 f2.setDescription("GGG");
2916 self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2917 f2.copyTinyStringsFrom(f);
2918 self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2919 f2.getArray().setInfoOnComponent(0,"mmmm");
2920 self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2921 f2.copyTinyStringsFrom(f);
2922 self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2923 f2.getEndArray().setInfoOnComponent(1,"mmmm");
2924 self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2925 f2.copyTinyStringsFrom(f);
2926 self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2928 self.assertTrue(m2.isEqual(m,1e-12));
2930 self.assertTrue(not m2.isEqual(m,1e-12));
2931 m2.copyTinyStringsFrom(m);
2932 self.assertTrue(m2.isEqual(m,1e-12));
2933 m2.getCoords().setInfoOnComponent(1,"eee");
2934 self.assertTrue(not m2.isEqual(m,1e-12));
2935 m2.copyTinyStringsFrom(m);
2936 self.assertTrue(m2.isEqual(m,1e-12));
2939 def testTryToShareSameCoordsPermute(self):
2940 m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2941 m2=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2942 #self.assertTrue(m.getCoords()!=m2.getCoords());
2943 m.tryToShareSameCoordsPermute(m2,1e-12);
2944 #self.assertTrue(m.getCoords()==m2.getCoords());
2945 self.assertTrue(m2.isEqual(m,1e-12));
2946 renum1=[1,2,0,5,8,7,4,3,6]
2947 r1=DataArrayInt.New()
2948 r1.setValues(renum1,len(renum1),1)
2949 m.renumberNodes(r1,9);
2950 #self.assertTrue(m.getCoords()!=m2.getCoords());
2951 self.assertTrue(not m2.isEqual(m,1e-12));
2952 m.tryToShareSameCoordsPermute(m2,1e-12);
2953 #self.assertTrue(m.getCoords()==m2.getCoords());
2954 self.assertTrue(m2.isEqual(m,1e-12));
2957 def testTryToShareSameCoordsPermute2(self):
2958 m1=MEDCouplingDataForTest.build2DTargetMesh_4();
2959 targetCoords=[-0.3,-0.3, 0.2,-0.3, -0.3,0.2, 0.2,0.2 ]
2960 targetConn=[0,2,3,1]
2961 m2=MEDCouplingUMesh.New();
2962 m2.setMeshDimension(2);
2963 m2.allocateCells(1);
2964 m2.insertNextCell(NORM_QUAD4,targetConn[0:4])
2965 m2.finishInsertingCells();
2966 myCoords=DataArrayDouble.New();
2967 myCoords.setValues(targetCoords,4,2);
2968 m2.setCoords(myCoords);
2969 m2.checkConsistencyLight();
2970 m1.checkConsistencyLight();
2972 expected1=[0.25,0.125,0.125,0.25,0.25]
2973 f1=m1.getMeasureField(False);
2974 f2=m2.getMeasureField(False);
2975 self.assertEqual(5,f1.getArray().getNumberOfTuples());
2976 self.assertEqual(1,f2.getArray().getNumberOfTuples());
2978 self.assertAlmostEqual(expected1[i],f1.getIJ(i,0),12);
2980 self.assertAlmostEqual(expected1[0],f2.getIJ(0,0),12);
2981 self.assertRaises(InterpKernelException,m1.tryToShareSameCoordsPermute,m2,1e-12);# <- here in this order the sharing is impossible.
2982 # Let's go for deeper test of tryToShareSameCoordsPermute
2983 m2.tryToShareSameCoordsPermute(m1,1e-12);
2984 f1=m1.getMeasureField(False);
2985 f2=m2.getMeasureField(False);
2986 self.assertEqual(5,f1.getArray().getNumberOfTuples());
2987 self.assertEqual(1,f2.getArray().getNumberOfTuples());
2989 self.assertAlmostEqual(expected1[i],f1.getIJ(i,0),12);
2991 self.assertAlmostEqual(expected1[0],f2.getIJ(0,0),12);
2994 def testChangeUnderlyingMesh1(self):
2995 mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2996 mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2997 f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2999 array=DataArrayDouble.New();
3000 arr=[7., 107., 8., 108., 9., 109., 10., 110., 11., 111., 12., 112., 13., 113., 14., 114., 15., 115., 16., 116.]
3001 array.setValues(arr,mesh1.getNumberOfCells(),2);
3004 renum=[0,2,1,3,4,5,6,8,7,9]
3005 mesh2.renumberCells(renum,False);
3006 #self.assertTrue(f1.getMesh()==mesh1);
3007 f1.changeUnderlyingMesh(mesh1,10,1e-12);# nothing done only to check that nothing done.
3008 #self.assertTrue(f1.getMesh()==mesh1);
3009 f1.changeUnderlyingMesh(mesh2,10,1e-12);
3010 #self.assertTrue(f1.getMesh()==mesh2);
3011 expected1=[7.,107.,9.,109.,8.,108.,10.,110.,11.,111.,12.,112.,13.,113.,15.,115.,14.,114.,16.,116.]
3013 self.assertAlmostEqual(expected1[i],f1.getArray().getIJ(0,i),12);
3016 f1=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
3018 array=DataArrayDouble.New();
3019 arr2=[7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.,17.,117.]
3020 array.setValues(arr2,mesh1.getNumberOfNodes(),2);
3023 renum2=[0,2,10,3,4,5,6,8,7,9,1]
3024 mesh2.renumberNodes(renum2,11);
3025 #self.assertTrue(f1.getMesh()==mesh1);
3026 f1.changeUnderlyingMesh(mesh2,10,1e-12);
3027 #self.assertTrue(f1.getMesh()==mesh2);
3028 expected2=[7.,107.,17.,117.,8.,108.,10.,110.,11.,111.,12.,112.,13.,113.,15.,115.,14.,114.,16.,116.,9.,109.]
3030 self.assertAlmostEqual(expected2[i],f1.getArray().getIJ(0,i),12);
3034 def testGetMaxValue1(self):
3035 m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
3036 nbOfCells=m.getNumberOfCells();
3037 f=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
3039 a1=DataArrayDouble.New();
3040 val1=[3.,4.,5.,6.,7.]
3041 a1.setValues(val1,nbOfCells,1);
3042 a2=DataArrayDouble.New();
3043 val2=[0.,1.,2.,8.,7.]
3044 a2.setValues(val2,nbOfCells,1);
3047 f.setEndTime(3.,3,4);
3048 f.checkConsistencyLight();
3050 self.assertAlmostEqual(8.,f.getMaxValue(),14);
3051 self.assertAlmostEqual(0.,f.getMinValue(),14);
3052 self.assertAlmostEqual(5.,f.getAverageValue(),14);
3053 self.assertAlmostEqual(5.125,f.getWeightedAverageValue(0,True),14);
3055 self.assertAlmostEqual(9.5,f.getMaxValue(),14);
3056 self.assertAlmostEqual(0.,f.getMinValue(),14);
3058 self.assertAlmostEqual(9.5,f.getMaxValue(),14);
3059 self.assertAlmostEqual(1.,f.getMinValue(),14);
3062 def testSubstractInPlaceDM1(self):
3063 mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
3064 mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
3065 f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3067 array=DataArrayDouble.New();
3068 arr=[7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.]
3069 array.setValues(arr,mesh1.getNumberOfCells(),2);
3072 self.assertEqual(10,f1.getNumberOfTuples());
3073 self.assertEqual(2,f1.getNumberOfComponents());
3074 self.assertEqual(20,f1.getNumberOfValues());
3076 renum=[0,2,3,1,4,5,6,8,7,9]
3077 mesh2.renumberCells(renum,False);
3079 f2=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3081 array=DataArrayDouble.New();
3082 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]
3083 array.setValues(arr2,mesh2.getNumberOfCells(),2);
3086 f1.substractInPlaceDM(f2,10,1e-12);
3087 f1.applyFunc(1,"abs(x+y+0.2)");
3088 self.assertAlmostEqual(0.,f1.getMaxValue(),13);
3091 def testDotCrossProduct1(self):
3092 mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
3093 f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3094 f1.setTime(2.3,5,6);
3096 array=DataArrayDouble.New();
3097 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.]
3098 array.setValues(arr1,mesh1.getNumberOfCells(),3);
3100 f2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3101 f2.setTime(7.8,4,5);
3103 array=DataArrayDouble.New();
3104 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.]
3105 array.setValues(arr2,mesh1.getNumberOfCells(),3);
3109 expected1=[842.,1820.,2816.,3830.,4862.,5912.,6980.,8066.,9170.,10292.]
3111 self.assertAlmostEqual(expected1[i],f3.getIJ(i,0),9);
3114 f4=f1.crossProduct(f2);
3115 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.]
3117 self.assertAlmostEqual(expected2[i],f4.getIJ(0,i),9);
3123 if __name__ == '__main__':