1 # -*- coding: utf-8 -*-
2 # Copyright (C) 2007-2022 CEA/DEN, EDF R&D
4 # This library is free software; you can redistribute it and/or
5 # modify it under the terms of the GNU Lesser General Public
6 # License as published by the Free Software Foundation; either
7 # version 2.1 of the License, or (at your option) any later version.
9 # This library is distributed in the hope that it will be useful,
10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 # Lesser General Public License for more details.
14 # You should have received a copy of the GNU Lesser General Public
15 # License along with this library; if not, write to the Free Software
16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
22 from medcoupling import *
25 from math import pi,e,sqrt,cos,sin
26 from datetime import datetime
27 from MEDCouplingDataForTest import MEDCouplingDataForTest
28 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
30 class MEDCouplingBasicsTest1(unittest.TestCase):
32 arr=DataArrayDouble.New()
33 arr.setValues([12.,11.,10.,9.,8.,7.,6.,5.,4.,3.,2.,1.],3,4)
34 arr.setInfoOnComponent(0,"ggg");
35 arr.setInfoOnComponent(1,"hhhh");
36 arr.setInfoOnComponent(2,"jj");
37 arr.setInfoOnComponent(3,"kkkkkk");
38 arr2=arr.convertToIntArr();
39 arr3=arr2.convertToDblArr();
40 self.assertTrue(arr.isEqual(arr3,1e-14))
44 arr1=DataArrayInt.New();
45 arr1Ref=[0,10,1,11,2,12,3,13,4,14,5,15,6,16]
46 arr1.setValues(arr1Ref,7,2);
47 self.assertEqual(7,arr1.getNumberOfTuples());
48 self.assertEqual(2,arr1.getNumberOfComponents());
49 self.assertEqual(arr1Ref,list(arr1.getValues()));
50 arr2=arr1.subArray(3);
51 self.assertEqual(4,arr2.getNumberOfTuples());
52 self.assertEqual(2,arr2.getNumberOfComponents());
53 self.assertEqual(arr1Ref[6:],list(arr2.getValues()));
54 arr3=arr1.subArray(2,5);
55 self.assertEqual(3,arr3.getNumberOfTuples());
56 self.assertEqual(2,arr3.getNumberOfComponents());
57 self.assertEqual(arr1Ref[4:10],list(arr3.getValues()));
59 arr4=DataArrayDouble.New();
60 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]
61 arr4.setValues(arr4Ref,7,2);
62 self.assertEqual(7,arr4.getNumberOfTuples());
63 self.assertEqual(2,arr4.getNumberOfComponents());
66 self.assertTrue(abs(arr4Ref[i]-tmp[i])<1e-14);
68 arr5=arr4.subArray(3);
69 self.assertEqual(4,arr5.getNumberOfTuples());
70 self.assertEqual(2,arr5.getNumberOfComponents());
73 self.assertTrue(abs(arr4Ref[6+i]-tmp[i])<1e-14);
75 arr6=arr4.subArray(2,5);
76 self.assertEqual(3,arr6.getNumberOfTuples());
77 self.assertEqual(2,arr6.getNumberOfComponents());
80 self.assertTrue(abs(arr4Ref[4+i]-tmp[i])<1e-14);
85 tab4=[1, 2, 8, 7, 2, 3, 9, 8, 3,
86 4, 10, 9, 4, 5, 11, 10, 5,
87 0, 6, 11, 0, 1, 7, 6 ]
90 coords=[ 0.024155, 0.04183768725682622, -0.305, 0.04831000000000001, -1.015761910347357e-17,
91 -0.305, 0.09662000000000001, -1.832979297858306e-18, -0.305, 0.120775, 0.04183768725682623,
92 -0.305, 0.09662000000000001, 0.08367537451365245, -0.305, 0.04831000000000001, 0.08367537451365246,
93 -0.305, 0.024155, 0.04183768725682622, -0.2863, 0.04831000000000001, -1.015761910347357e-17, -0.2863,
94 0.09662000000000001, -1.832979297858306e-18, -0.2863, 0.120775, 0.04183768725682623, -0.2863, 0.09662000000000001,
95 0.08367537451365245, -0.2863, 0.04831000000000001, 0.08367537451365246, -0.2863 ]
96 self.assertEqual(MEDCouplingMesh.GetNumberOfNodesOfGeometricType(NORM_TRI3),3)
97 self.assertTrue(MEDCouplingMesh.IsStaticGeometricType(NORM_TRI3))
98 self.assertTrue(MEDCouplingMesh.IsLinearGeometricType(NORM_TRI3))
99 self.assertEqual(MEDCouplingMesh.GetDimensionOfGeometricType(NORM_TRI3),2)
100 self.assertEqual(MEDCouplingMesh.GetReprOfGeometricType(NORM_TRI3),"NORM_TRI3")
101 self.assertRaises(InterpKernelException,MEDCouplingMesh.GetNumberOfNodesOfGeometricType,NORM_POLYGON)
102 self.assertTrue(not MEDCouplingMesh.IsStaticGeometricType(NORM_POLYGON))
103 self.assertTrue(MEDCouplingMesh.IsLinearGeometricType(NORM_POLYGON))
104 self.assertEqual(MEDCouplingMesh.GetDimensionOfGeometricType(NORM_POLYGON),2)
105 self.assertEqual(MEDCouplingMesh.GetReprOfGeometricType(NORM_POLYGON),"NORM_POLYGON")
106 self.assertEqual(MEDCouplingMesh.GetNumberOfNodesOfGeometricType(NORM_TRI6),6)
107 self.assertTrue(MEDCouplingMesh.IsStaticGeometricType(NORM_TRI6))
108 self.assertTrue(not MEDCouplingMesh.IsLinearGeometricType(NORM_TRI6))
109 self.assertEqual(MEDCouplingMesh.GetDimensionOfGeometricType(NORM_TRI6),2)
110 self.assertEqual(MEDCouplingMesh.GetReprOfGeometricType(NORM_TRI6),"NORM_TRI6")
111 mesh=MEDCouplingUMesh.New()
112 mesh.setMeshDimension(2)
113 mesh.allocateCells(8);
114 mesh.setName("mesh1")
115 self.assertTrue(mesh.getName()=="mesh1")
116 for i in range(nbOfCells):
117 mesh.insertNextCell(NORM_QUAD4,4,tab4[4*i:4*(i+1)]);
119 mesh.finishInsertingCells()
120 self.assertTrue(mesh.getNumberOfCells()==nbOfCells)
121 self.assertTrue(mesh.getNodalConnectivity().getNbOfElems()==30)
122 self.assertTrue(mesh.getNodalConnectivityIndex().getNbOfElems()==nbOfCells+1)
123 myCoords=DataArrayDouble.New()
124 myCoords.setValues(coords,nbOfNodes,3);
125 self.assertTrue(myCoords.getIJ(3,2)==-0.305)
126 mesh.setCoords(myCoords);
127 mesh.checkConsistencyLight();
128 self.assertTrue(mesh.getAllGeoTypes()==[4])
129 myFalseConn=DataArrayInt.New()
130 myFalseConn.setValues(tab4,6,4)
131 self.assertTrue(myFalseConn.getIJ(1,1)==3)
133 field=MEDCouplingFieldDouble.New(ON_CELLS)
135 field.setNature(ExtensiveMaximum)
136 myCoords=DataArrayDouble.New()
138 for i in range(nbOfCells * 9):
139 sampleTab.append(float(i))
140 myCoords.setValues(sampleTab,nbOfCells,9);
141 field.setArray(myCoords)
142 self.assertTrue(3==mesh.getSpaceDimension())
143 field.checkConsistencyLight()
144 mesh2=mesh.clone(False)
145 mesh3=mesh.clone(True)
148 ## deep full recursively copy of field -> both field and mesh underneath copied
149 field2=field.clone(True)
150 field2.setMesh(field.getMesh().clone(True))
151 mesh3=mesh.clone(True)
152 field3=mesh3.fillFromAnalytic(ON_CELLS,2,"x*IVec+(y+z)*JVec")
153 field3.applyFunc("u*u*u+cos(u)")
156 def testMeshPointsCloud(self):
157 targetCoords=[-0.3,-0.3,0.5, 0.2,-0.3,1., 0.7,-0.3,1.5,
158 -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]
159 targetMesh=MEDCouplingUMesh.New();
160 targetMesh.setMeshDimension(0);
161 targetMesh.allocateCells(8);
162 targetMesh.insertNextCell(NORM_POINT1,1,[0]);
163 targetMesh.insertNextCell(NORM_POINT1,1,[1]);
164 targetMesh.insertNextCell(NORM_POINT1,1,[2]);
165 targetMesh.insertNextCell(NORM_POINT1,1,[3]);
166 targetMesh.insertNextCell(NORM_POINT1,1,[4]);
167 targetMesh.insertNextCell(NORM_POINT1,1,[5]);
168 targetMesh.insertNextCell(NORM_POINT1,1,[7]);
169 targetMesh.insertNextCell(NORM_POINT1,1,[6]);
170 targetMesh.finishInsertingCells();
171 self.assertRaises(InterpKernelException,targetMesh.checkConsistencyLight);
172 myCoords=DataArrayDouble.New();
173 myCoords.setValues(targetCoords,9,3);
174 targetMesh.setCoords(myCoords);
175 self.assertEqual(targetMesh.getSpaceDimension(),3)
176 self.assertEqual(targetMesh.getNumberOfCells(),8)
177 self.assertEqual(targetMesh.getNumberOfNodes(),9)
178 self.assertEqual(targetMesh.getMeshDimension(),0)
181 def testMeshM1D(self):
182 meshM1D=MEDCouplingUMesh.New();
183 self.assertRaises(InterpKernelException,meshM1D.getMeshDimension);
184 self.assertRaises(InterpKernelException,meshM1D.getNumberOfNodes);
185 self.assertRaises(InterpKernelException,meshM1D.getNumberOfCells);
186 self.assertRaises(InterpKernelException,meshM1D.setMeshDimension,-2)
187 self.assertRaises(InterpKernelException,meshM1D.setMeshDimension,-10)
188 meshM1D.setMeshDimension(-1);
189 meshM1D.checkConsistencyLight();
190 self.assertEqual(meshM1D.getMeshDimension(),-1);
191 self.assertEqual(meshM1D.getNumberOfCells(),1);
192 self.assertRaises(InterpKernelException,meshM1D.getNumberOfNodes);
193 self.assertRaises(InterpKernelException,meshM1D.getSpaceDimension);
194 cpy=meshM1D.clone(True);
195 self.assertTrue(cpy.isEqual(meshM1D,1e-12));
196 fieldOnCells=MEDCouplingFieldDouble.New(ON_CELLS);
197 fieldOnCells.setMesh(meshM1D);
198 array=DataArrayDouble.New();
199 array.setValues(6*[7.],1,6);
200 fieldOnCells.setArray(array);
201 fieldOnCells.checkConsistencyLight();
204 def testDeepCopy(self):
205 array=DataArrayDouble.New();
206 array.setValues(5*3*[7.],5,3);
207 self.assertEqual(array.getIJ(3,2),7.);
208 array2=array.deepCopy();
209 self.assertEqual(array2.getIJ(3,2),7.)
211 array3=DataArrayInt.New();
212 array3.setValues(5*3*[17],5,3);
213 self.assertEqual(array3.getIJ(3,2),17);
214 array4=array3.deepCopy();
215 self.assertEqual(array4.getIJ(3,2),17);
218 def testRevNodal(self):
219 mesh=MEDCouplingDataForTest.build2DTargetMesh_1()
220 revNodal,revNodalIndx=mesh.getReverseNodalConnectivity();
221 revNodalExpected=[0,0,1,1,2,0,3,0,1,2,3,4,2,4,3,3,4,4];
222 revNodalIndexExpected=[0,1,3,5,7,12,14,15,17,18];
223 self.assertEqual(revNodal.getNbOfElems(),18)
224 self.assertEqual(revNodalIndx.getNbOfElems(),10)
225 self.assertEqual(list(revNodal.getValues()),revNodalExpected)
226 self.assertEqual(list(revNodalIndx.getValues()),revNodalIndexExpected)
229 def testConvertToPolyTypes(self):
230 mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
232 mesh.convertToPolyTypes(elts);
233 mesh.checkConsistencyLight();
234 self.assertEqual(5,mesh.getNumberOfCells());
235 self.assertEqual(23,mesh.getNodalConnectivity().getNumberOfTuples());
236 expected1=[4, 0, 3, 4, 1, 5, 1, 4, 2, 3, 4, 5, 2, 5, 6, 7, 4, 3, 4, 7, 8, 5, 4]
237 self.assertEqual(expected1,list(mesh.getNodalConnectivity().getValues()));
239 mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
240 mesh.convertToPolyTypes(elts);
241 mesh.checkConsistencyLight();
242 self.assertEqual(8,mesh.getNumberOfCells());
243 self.assertEqual(114,mesh.getNodalConnectivity().getNumberOfTuples());
244 mesh.convertToPolyTypes(elts);
245 mesh.checkConsistencyLight();
246 self.assertEqual(8,mesh.getNumberOfCells());
247 self.assertEqual(114,mesh.getNodalConnectivity().getNumberOfTuples());
250 def testDescConn2D(self):
251 mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
252 desc=DataArrayInt.New();
253 descIndx=DataArrayInt.New();
254 revDesc=DataArrayInt.New();
255 revDescIndx=DataArrayInt.New();
256 mesh2=mesh.buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
257 mesh2.checkConsistencyLight();
258 self.assertEqual(1,mesh2.getMeshDimension());
259 self.assertEqual(13,mesh2.getNumberOfCells());
260 self.assertEqual(14,revDescIndx.getNbOfElems()); self.assertEqual(14,revDescIndx.getNumberOfTuples());
261 self.assertEqual(6,descIndx.getNbOfElems()); self.assertEqual(6,descIndx.getNumberOfTuples());
262 self.assertEqual(18,desc.getNbOfElems()); self.assertEqual(18,desc.getNumberOfTuples());
263 self.assertEqual(18,revDesc.getNbOfElems()); self.assertEqual(18,revDesc.getNumberOfTuples());
264 expected1=[0,1,2,3, 2,4,5, 6,7,4, 8,9,1,10, 11,12,6,9];
265 self.assertEqual(expected1,list(desc.getValues()));
266 expected2=[0,4,7,10,14,18];
267 self.assertEqual(expected2,list(descIndx.getValues()));
268 expected3=[0,1,3,5,6,8,9,11,12,13,15,16,17,18];
269 self.assertEqual(expected3,list(revDescIndx.getValues()));
270 expected4=[0, 0,3, 0,1, 0, 1,2, 1, 2,4, 2, 3, 3,4, 3, 4, 4];
271 self.assertEqual(expected4,list(revDesc.getValues()));
272 conn=mesh2.getNodalConnectivity();
273 connIndex=mesh2.getNodalConnectivityIndex();
274 expected5=[0,3,6,9,12,15,18,21,24,27,30,33,36,39];
275 self.assertEqual(expected5,list(connIndex.getValues()));
276 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];
277 self.assertEqual(expected6,list(conn.getValues()));
280 mesh.convertToPolyTypes(eltsV);
281 mesh.checkConsistencyLight();
283 desc=DataArrayInt.New();
284 descIndx=DataArrayInt.New();
285 revDesc=DataArrayInt.New();
286 revDescIndx=DataArrayInt.New();
288 mesh2=mesh.buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
289 mesh2.checkConsistencyLight();
290 self.assertEqual(1,mesh2.getMeshDimension());
291 self.assertEqual(13,mesh2.getNumberOfCells());
292 self.assertEqual(14,revDescIndx.getNbOfElems()); self.assertEqual(14,revDescIndx.getNumberOfTuples());
293 self.assertEqual(6,descIndx.getNbOfElems()); self.assertEqual(6,descIndx.getNumberOfTuples());
294 self.assertEqual(18,desc.getNbOfElems()); self.assertEqual(18,desc.getNumberOfTuples());
295 self.assertEqual(18,revDesc.getNbOfElems()); self.assertEqual(18,revDesc.getNumberOfTuples());
296 self.assertEqual(expected1,list(desc.getValues()));
297 self.assertEqual(expected2,list(descIndx.getValues()));
298 self.assertEqual(expected3,list(revDescIndx.getValues()));
299 self.assertEqual(expected4,list(revDesc.getValues()));
300 conn=mesh2.getNodalConnectivity();
301 connIndex=mesh2.getNodalConnectivityIndex();
302 self.assertEqual(expected5,list(connIndex.getValues()));
303 self.assertEqual(expected6,list(conn.getValues()));
306 def testDescConn3D(self):
307 mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
308 desc=DataArrayInt.New();
309 descIndx=DataArrayInt.New();
310 revDesc=DataArrayInt.New();
311 revDescIndx=DataArrayInt.New();
313 mesh2=mesh.buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
314 mesh2.checkConsistencyLight();
315 self.assertEqual(2,mesh2.getMeshDimension());
316 self.assertEqual(36,mesh2.getNumberOfCells());
317 self.assertEqual(37,revDescIndx.getNbOfElems()); self.assertEqual(37,revDescIndx.getNumberOfTuples());
318 self.assertEqual(9,descIndx.getNbOfElems()); self.assertEqual(9,descIndx.getNumberOfTuples());
319 self.assertEqual(48,desc.getNbOfElems()); self.assertEqual(48,desc.getNumberOfTuples());
320 self.assertEqual(48,revDesc.getNbOfElems()); self.assertEqual(48,revDesc.getNumberOfTuples());
321 expected1=[0, 6, 12, 18, 24, 30, 36, 42, 48]
322 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]
323 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]
324 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]
325 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]
326 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,
327 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,
328 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,
329 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]
330 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,
331 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,
332 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,
333 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]
335 self.assertEqual(expected1,list(descIndx.getValues()));
336 self.assertEqual(expected2,list(desc.getValues()));
337 self.assertEqual(expected3,list(revDescIndx.getValues()));
338 self.assertEqual(expected4,list(revDesc.getValues()));
339 self.assertEqual(expected5,list(mesh2.getNodalConnectivityIndex().getValues()));
340 self.assertEqual(expected6,list(mesh2.getNodalConnectivity().getValues()));
343 mesh.convertToPolyTypes(eltsV);
344 mesh.checkConsistencyLight();
345 desc=DataArrayInt.New();
346 descIndx=DataArrayInt.New();
347 revDesc=DataArrayInt.New();
348 revDescIndx=DataArrayInt.New();
349 mesh2=mesh.buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
350 mesh2.checkConsistencyLight();
351 self.assertEqual(2,mesh2.getMeshDimension());
352 self.assertEqual(36,mesh2.getNumberOfCells());
353 self.assertEqual(37,revDescIndx.getNbOfElems()); self.assertEqual(37,revDescIndx.getNumberOfTuples());
354 self.assertEqual(9,descIndx.getNbOfElems()); self.assertEqual(9,descIndx.getNumberOfTuples());
355 self.assertEqual(48,desc.getNbOfElems()); self.assertEqual(48,desc.getNumberOfTuples());
356 self.assertEqual(48,revDesc.getNbOfElems()); self.assertEqual(48,revDesc.getNumberOfTuples());
357 self.assertEqual(expected1,list(descIndx.getValues()));
358 self.assertEqual(expected2,list(desc.getValues()));
359 self.assertEqual(expected3,list(revDescIndx.getValues()));
360 self.assertEqual(expected4,list(revDesc.getValues()));
361 self.assertEqual(expected5,list(mesh2.getNodalConnectivityIndex().getValues()));
362 self.assertEqual(expected7,list(mesh2.getNodalConnectivity().getValues()));
365 def testFindBoundaryNodes(self):
366 mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
367 boundaryNodes=mesh.findBoundaryNodes();
368 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];
369 self.assertEqual(expected1,boundaryNodes.getValues());
372 def testBoundaryMesh(self):
373 mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
374 mesh2=mesh.buildBoundaryMesh(False);
375 self.assertEqual(24,mesh2.getNumberOfCells());
376 self.assertEqual(26,mesh2.getNumberOfNodes());
379 def testBuildPartOfMySelf(self):
380 mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
381 mesh.setName("Toto");
385 subMesh=mesh.buildPart(tab1)
386 self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
387 subMesh=mesh.buildPartOfMySelf(tab1,True);
388 self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
389 name=subMesh.getName();
390 self.assertEqual(2,len(mesh.getAllGeoTypes()));
391 self.assertEqual(NORM_TRI3,mesh.getAllGeoTypes()[0]);
392 self.assertEqual(NORM_QUAD4,mesh.getAllGeoTypes()[1]);
393 self.assertEqual(1,len(subMesh.getAllGeoTypes()));
394 self.assertEqual(NORM_QUAD4,subMesh.getAllGeoTypes()[0]);
395 self.assertEqual(name,"Toto");
396 self.assertEqual(2,subMesh.getNumberOfCells());
397 subConn=[4,0,3,4,1,4,7,8,5,4];
398 subConnIndex=[0,5,10];
399 self.assertEqual(10,subMesh.getNodalConnectivity().getNbOfElems());
400 self.assertEqual(3,subMesh.getNodalConnectivityIndex().getNbOfElems());
401 self.assertEqual(subConn[0:10],list(subMesh.getNodalConnectivity().getValues()));
402 self.assertEqual(subConnIndex[0:3],list(subMesh.getNodalConnectivityIndex().getValues()));
404 subMesh=mesh.buildPartOfMySelf(tab2[0:3],True);
405 self.assertTrue(isinstance(subMesh,MEDCouplingUMesh));
406 name=subMesh.getName();
407 self.assertEqual(2,len(subMesh.getAllGeoTypes()));
408 self.assertEqual(NORM_TRI3,subMesh.getAllGeoTypes()[0]);
409 self.assertEqual(NORM_QUAD4,subMesh.getAllGeoTypes()[1]);
410 self.assertEqual(name,"Toto");
411 self.assertEqual(3,subMesh.getNumberOfCells());
412 subConn2=[4,0,3,4,1,3,4,5,2,4,6,7,4,3]
413 subConnIndex2=[0,5,9,14]
414 self.assertEqual(14,subMesh.getNodalConnectivity().getNbOfElems());
415 self.assertEqual(4,subMesh.getNodalConnectivityIndex().getNbOfElems());
416 self.assertEqual(subConn2[0:14],list(subMesh.getNodalConnectivity().getValues()));
417 self.assertEqual(subConnIndex2[0:4],list(subMesh.getNodalConnectivityIndex().getValues()));
418 dd=DataArrayInt.New()
422 subMesh=subMesh.buildPartOfMySelf(dd,True);
423 self.assertEqual("coucou",subMesh.getName());
426 def testBuildPartOfMySelfNode(self):
427 mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
429 subMesh=mesh.buildPartOfMySelfNode(tab1[0:4],True);
430 self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
431 self.assertEqual(1,len(subMesh.getAllGeoTypes()));
432 self.assertEqual(NORM_QUAD4,subMesh.getAllGeoTypes()[0]);
433 self.assertEqual(1,subMesh.getNumberOfCells());
434 self.assertEqual(5,subMesh.getNodalConnectivity().getNbOfElems());
435 self.assertEqual(2,subMesh.getNodalConnectivityIndex().getNbOfElems());
438 self.assertEqual(subConn[0:5],list(subMesh.getNodalConnectivity().getValues()));
439 self.assertEqual(subConnIndex[0:2],list(subMesh.getNodalConnectivityIndex().getValues()));
441 ddd=DataArrayInt.New()
442 ddd.setValues(tab1[0:2],2,1)
444 subMesh=mesh.buildPartOfMySelfNode(ddd,False);
445 self.assertEqual("ddd",subMesh.getName())
446 self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
447 self.assertEqual(2,len(subMesh.getAllGeoTypes()));
448 self.assertEqual(NORM_TRI3,subMesh.getAllGeoTypes()[0]);
449 self.assertEqual(NORM_QUAD4,subMesh.getAllGeoTypes()[1]);
450 self.assertEqual(3,subMesh.getNumberOfCells());
451 self.assertEqual(14,subMesh.getNodalConnectivity().getNbOfElems());
452 self.assertEqual(4,subMesh.getNodalConnectivityIndex().getNbOfElems());
453 subConn2=[3,4,5,2,4,6,7,4,3,4,7,8,5,4]
454 subConnIndex2=[0,4,9,14]
455 self.assertEqual(subConn2[0:14],list(subMesh.getNodalConnectivity().getValues()));
456 self.assertEqual(subConnIndex2[0:4],list(subMesh.getNodalConnectivityIndex().getValues()));
457 #testing the case where length of tab2 is greater than max number of node per cell.
459 subMesh=mesh.buildPartOfMySelfNode(tab2[0:7],True);
460 self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
461 self.assertEqual(2,len(subMesh.getAllGeoTypes()));
462 self.assertEqual(NORM_TRI3,subMesh.getAllGeoTypes()[0]);
463 self.assertEqual(NORM_QUAD4,subMesh.getAllGeoTypes()[1]);
464 self.assertEqual(3,subMesh.getNumberOfCells());
467 def testZipCoords(self):
468 mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
469 self.assertEqual(2,len(mesh.getAllGeoTypes()));
470 self.assertEqual(2,mesh.getSpaceDimension());
471 self.assertEqual(9,mesh.getNumberOfNodes());
472 self.assertEqual(5,mesh.getNumberOfCells());
473 oldConn=mesh.getNodalConnectivity().getValues()[0:mesh.getNodalConnectivity().getNbOfElems()];
474 oldConnIndex=mesh.getNodalConnectivityIndex().getValues()[0:mesh.getNumberOfCells()+1]
475 oldCoords=mesh.getCoords();
477 self.assertEqual(2,len(mesh.getAllGeoTypes()));
478 self.assertEqual(2,mesh.getSpaceDimension());
479 self.assertEqual(9,mesh.getNumberOfNodes());
480 self.assertEqual(5,mesh.getNumberOfCells());
481 self.assertEqual(mesh.getCoords().getValues()[0:2*9],oldCoords.getValues());
482 self.assertEqual(list(oldConn),list(mesh.getNodalConnectivity().getValues()));
483 self.assertEqual(list(oldConnIndex),list(mesh.getNodalConnectivityIndex().getValues()));
486 subMesh=mesh.buildPartOfMySelf(tab1,True);
487 self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
488 traducer=subMesh.zipCoordsTraducer();
489 expectedTraducer=[0, 1, -1, 2, 3, 4, -1, 5, 6]
490 self.assertEqual(expectedTraducer,list(traducer.getValues()));
491 self.assertEqual(NORM_QUAD4,subMesh.getAllGeoTypes()[0]);
492 self.assertEqual(2,subMesh.getNumberOfCells());
493 subConn=[4,0,2,3,1,4,5,6,4,3]
494 subConnIndex=[0,5,10]
495 self.assertEqual(7,subMesh.getNumberOfNodes());
496 self.assertEqual(10,subMesh.getNodalConnectivity().getNbOfElems());
497 self.assertEqual(3,subMesh.getNodalConnectivityIndex().getNbOfElems());
498 self.assertEqual(subConn,list(subMesh.getNodalConnectivity().getValues()));
499 self.assertEqual(subConnIndex,list(subMesh.getNodalConnectivityIndex().getValues()));
501 subMesh=mesh.buildPartOfMySelf(tab1,False);
502 self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
503 self.assertEqual(NORM_QUAD4,subMesh.getAllGeoTypes()[0]);
504 self.assertEqual(2,subMesh.getNumberOfCells());
505 self.assertEqual(7,subMesh.getNumberOfNodes());
506 self.assertEqual(10,subMesh.getNodalConnectivity().getNbOfElems());
507 self.assertEqual(3,subMesh.getNodalConnectivityIndex().getNbOfElems());
508 self.assertEqual(subConn,list(subMesh.getNodalConnectivity().getValues()));
509 self.assertEqual(subConnIndex,list(subMesh.getNodalConnectivityIndex().getValues()));
512 def testZipConnectivity(self):
513 m1=MEDCouplingDataForTest.build2DTargetMesh_1();
514 m2=MEDCouplingDataForTest.build2DTargetMesh_1();
516 m3=m2.buildPartOfMySelf(cells1,True);
517 self.assertTrue(isinstance(m3,MEDCouplingUMesh))
518 m4=MEDCouplingDataForTest.build2DSourceMesh_1();
519 m5=MEDCouplingUMesh.MergeUMeshes(m1,m3);
520 m6=MEDCouplingUMesh.MergeUMeshes(m5,m4);
522 self.assertEqual(10,m6.getNumberOfCells());
523 self.assertEqual(22,m6.getNumberOfNodes());
524 (arr,areNodesMerged,newNbOfNodes)=m6.mergeNodes(1e-13);
525 self.assertTrue(areNodesMerged);
526 self.assertEqual(10,m6.getNumberOfCells());
527 self.assertEqual(9,m6.getNumberOfNodes());
529 arr=m6.zipConnectivityTraducer(0);
530 self.assertEqual(7,m6.getNumberOfCells());
532 arr=m6.zipConnectivityTraducer(0);
533 self.assertTrue(m7.isEqual(m6,1e-12));
534 self.assertEqual(7,m6.getNumberOfCells());
537 def testEqualMesh(self):
538 mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
539 mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
541 self.assertTrue(mesh1.isEqual(mesh1,1e-12));
543 self.assertTrue(mesh1.isEqual(mesh2,1e-12));
544 self.assertTrue(mesh2.isEqual(mesh1,1e-12));
545 pt=mesh2.getCoords().getValues();
547 mesh2.getCoords().setIJ(0,1,5.999);
548 self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
549 self.assertTrue(not mesh2.isEqual(mesh1,1e-12));
550 mesh2.getCoords().setIJ(0,1,tmp);
551 self.assertTrue(mesh1.isEqual(mesh2,1e-12));
552 self.assertTrue(mesh2.isEqual(mesh1,1e-12));
554 pt2=mesh1.getNodalConnectivity().getValues();
555 mesh1.getNodalConnectivity().setIJ(5,0,int(pt2[5])+1);
556 self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
557 self.assertTrue(not mesh2.isEqual(mesh1,1e-12));
558 mesh1.getNodalConnectivity().setIJ(5,0,int(pt2[5]));
559 self.assertTrue(mesh1.isEqual(mesh2,1e-12));
560 self.assertTrue(mesh2.isEqual(mesh1,1e-12));
562 pt2=mesh1.getNodalConnectivityIndex().getValues();
563 mesh1.getNodalConnectivityIndex().setIJ(1,0,int(pt2[1]+1));
564 self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
565 self.assertTrue(not mesh2.isEqual(mesh1,1e-12));
566 mesh1.getNodalConnectivityIndex().setIJ(1,0,int(pt2[1]));
567 self.assertTrue(mesh1.isEqual(mesh2,1e-12));
568 self.assertTrue(mesh2.isEqual(mesh1,1e-12));
570 tmp3=mesh1.getName();
571 mesh1.setName("lllll");
572 self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
573 self.assertTrue(not mesh2.isEqual(mesh1,1e-12));
575 self.assertTrue(mesh1.isEqual(mesh2,1e-12));
576 self.assertTrue(mesh2.isEqual(mesh1,1e-12));
578 tmp3=mesh2.getCoords().getInfoOnComponent(1);
579 mesh2.getCoords().setInfoOnComponent(1,"kkkkkk");
580 self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
581 self.assertTrue(not mesh2.isEqual(mesh1,1e-12));
582 mesh2.getCoords().setInfoOnComponent(1,tmp3);
583 self.assertTrue(mesh1.isEqual(mesh2,1e-12));
584 self.assertTrue(mesh2.isEqual(mesh1,1e-12));
587 def testEqualFieldDouble(self):
588 mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
589 mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
591 fieldOnCells1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
592 fieldOnCells1.setMesh(mesh1);
593 fieldOnCells2=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
594 fieldOnCells2.setMesh(mesh2);
596 self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
597 self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
599 fieldOnNodes1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
600 self.assertTrue(not fieldOnCells1.isEqual(fieldOnNodes1,1e-12,1e-15));
601 self.assertTrue(not fieldOnNodes1.isEqual(fieldOnCells1,1e-12,1e-15));
603 fieldOnCells2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
604 self.assertEqual(fieldOnCells2.getMesh(),None) # to check that convertMesh wrapping do not raise but return Py_None
605 self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
606 self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
607 fieldOnCells1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
608 self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
609 self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
610 fieldOnCells1.setTime(4.,6,7);
611 self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
612 self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
613 fieldOnCells2.setTime(4.,6,7);
614 self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
615 self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
616 fieldOnCells1.setName("Power");
617 self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
618 self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
619 fieldOnCells2.setName("Power");
620 self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
621 self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
623 fieldOnCells1.setMesh(mesh1);
624 self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
625 self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
626 fieldOnCells2.setMesh(mesh1);
627 self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
628 self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
629 arr=DataArrayDouble.New();
631 arr.setValues(mesh1.getNumberOfCells()*3*[6.],mesh1.getNumberOfCells(),3);
632 fieldOnCells1.setArray(arr);
633 self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
634 self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
635 fieldOnCells2.setArray(arr);
636 self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
637 self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
640 fieldOnCells2.setArray(arr2);
641 self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
642 self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
644 self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
645 self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
647 self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
648 self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
649 arr2.setName("popo2");
650 self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
651 self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
653 arr2.setName("popo");
654 self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
655 self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
657 arr2.setInfoOnComponent(2,"jjj");
658 self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
659 self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
660 arr.setInfoOnComponent(2,"jjj");
661 self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
662 self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
665 def testNatureChecking(self):
666 field=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
667 field.setNature(ExtensiveMaximum);
668 field.setNature(IntensiveMaximum);
669 field.setNature(ExtensiveConservation);
670 field=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
671 field.setNature(IntensiveMaximum);
672 self.assertRaises(InterpKernelException,field.setNature,ExtensiveMaximum);
673 self.assertRaises(InterpKernelException,field.setNature,ExtensiveConservation);
676 def testNatureOperations(self):
677 """ Check nature constraints on field operations """
678 m = MEDCouplingCMesh()
679 m.setCoordsAt(0, DataArrayDouble([1.0,2.0,3.0]))
680 m.setCoordsAt(1, DataArrayDouble([1.0,2.0,3.0]))
681 m = m.buildUnstructured()
682 f1, f2 = MEDCouplingFieldDouble.New(ON_CELLS, NO_TIME), MEDCouplingFieldDouble.New(ON_CELLS, NO_TIME)
683 f1.setNature(ExtensiveMaximum)
684 f2.setNature(IntensiveMaximum)
685 self.assertEqual(ExtensiveMaximum, f1.getNature())
686 self.assertEqual(IntensiveMaximum, f2.getNature())
688 da = DataArrayDouble([1.0,2.0,3.0,4.0])
689 f1.setMesh(m); f2.setMesh(m)
690 f1.setArray(da); f2.setArray(da.deepCopy())
691 # All this should complain about nature:
692 self.assertRaises(InterpKernelException, f1.__add__, f2)
693 self.assertRaises(InterpKernelException, f1.__iadd__, f2)
694 self.assertRaises(InterpKernelException, f1.__sub__, f2)
695 self.assertRaises(InterpKernelException, f1.__isub__, f2)
696 self.assertRaises(InterpKernelException, f1.__radd__, f2)
697 self.assertRaises(InterpKernelException, f1.__rsub__, f2)
698 self.assertRaises(InterpKernelException, MEDCouplingFieldDouble.AddFields, f1, f2)
699 self.assertRaises(InterpKernelException, MEDCouplingFieldDouble.SubstractFields, f1, f2)
700 self.assertRaises(InterpKernelException, MEDCouplingFieldDouble.MaxFields, f1, f2)
701 self.assertRaises(InterpKernelException, MEDCouplingFieldDouble.MinFields, f1, f2)
703 f3 = MEDCouplingFieldDouble.MultiplyFields(f1,f2)
704 self.assertEqual(NoNature, f3.getNature())
706 self.assertEqual(NoNature, f3.getNature())
707 f1Tmp = f1.deepCopy(); f1Tmp.setMesh(m); f1Tmp *= f2
708 self.assertEqual(NoNature, f1Tmp.getNature())
709 f3 = MEDCouplingFieldDouble.DivideFields(f1,f2)
710 self.assertEqual(NoNature, f3.getNature())
712 self.assertEqual(NoNature, f3.getNature())
713 f1Tmp = f1.deepCopy(); f1Tmp.setMesh(m); f1Tmp /= f2
714 self.assertEqual(NoNature, f1Tmp.getNature())
715 # f3 = MEDCouplingFieldDouble.PowFields(f1,f2)
716 # self.assertEqual(NoNature, f3.getNature())
718 self.assertEqual(NoNature, f3.getNature())
719 f1Tmp = f1.deepCopy(); f1Tmp.setMesh(m); f1Tmp **= f2
720 self.assertEqual(NoNature, f1Tmp.getNature())
721 f3 = MEDCouplingFieldDouble.DotFields(f1,f2)
722 self.assertEqual(NoNature, f3.getNature())
724 self.assertEqual(NoNature, f3.getNature())
726 da = DataArrayDouble.Meld([da, da, da])
727 f1.setArray(da); f2.setArray(da.deepCopy())
728 f3 = MEDCouplingFieldDouble.CrossProductFields(f1,f2)
729 self.assertEqual(NoNature, f3.getNature())
730 f3 = f1.crossProduct(f2)
732 def testBuildSubMeshData(self):
733 targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1()
734 #check buildSubMesh on field on cells
735 fieldCells=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
736 fieldCells.setMesh(targetMesh);
738 ret1,di=fieldCells.buildSubMeshData(elts);
739 self.assertTrue(isinstance(ret1,MEDCouplingUMesh))
740 self.assertEqual(3,ret1.getNumberOfCells());
741 self.assertEqual(9,ret1.getNumberOfNodes());
742 self.assertEqual(3,di.getNumberOfTuples());
743 self.assertEqual(1,di.getNumberOfComponents());
744 toCheck=di.getValues();
745 self.assertTrue(elts,toCheck);
746 #check buildSubMesh on field on nodes
747 fieldNodes=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
748 fieldNodes.setMesh(targetMesh);
749 ret2,di=fieldNodes.buildSubMeshData(elts);
750 self.assertTrue(isinstance(ret2,MEDCouplingUMesh))
751 self.assertEqual(3,ret2.getNumberOfCells());
752 self.assertEqual(6,ret2.getNumberOfNodes());
753 self.assertEqual(6,di.getNumberOfTuples());
754 self.assertEqual(1,di.getNumberOfComponents());
755 toCheck=di.getValues();
756 expected=[1,2,4,5,7,8]
757 self.assertEqual(expected,list(toCheck));
760 def testExtrudedMesh1(self):
761 mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
762 ext=MEDCouplingMappedExtrudedMesh.New(mesh3D,mesh2D,1);
763 self.assertEqual(18,ext.getNumberOfCells());
764 self.assertEqual(60,ext.getNumberOfNodes());
765 ids3D=ext.getMesh3DIds();
766 ids3DExpected=[5,4,3,2,1,0, 11,10,9,8,7,6, 17,16,15,14,13,12]
767 self.assertEqual(18,ids3D.getNumberOfTuples());
768 self.assertEqual(1,ids3D.getNumberOfComponents());
769 self.assertEqual(ids3DExpected,list(ids3D.getValues()));
770 mesh1D=ext.getMesh1D();
771 self.assertEqual(4,mesh1D.getNumberOfNodes());
772 self.assertEqual(3,mesh1D.getNumberOfCells());
773 mesh1DExpected=[0.66666666666666663, 1.4583333333333333, 0, 0.66666666666666663,
774 1.4583333333333333, 1, 0.66666666666666663, 1.4583333333333333,
775 2, 0.66666666666666663, 1.4583333333333333, 3]
776 mesh1DCoords=mesh1D.getCoords();
777 self.assertEqual(4,mesh1DCoords.getNumberOfTuples());
778 self.assertEqual(3,mesh1DCoords.getNumberOfComponents());
779 self.assertEqual(mesh1DExpected,mesh1DCoords.getValues());
780 conn1D=mesh1D.getNodalConnectivity();
781 self.assertEqual(9,conn1D.getNumberOfTuples());
782 self.assertEqual(1,conn1D.getNumberOfComponents());
783 conn1DExpected=[1,0,1,1,1,2,1,2,3]
784 self.assertEqual(conn1DExpected,list(conn1D.getValues()));
787 def testExtrudedMesh3(self):
788 m1=MEDCouplingDataForTest.build2DTargetMesh_1();
789 m1.changeSpaceDimension(3);
790 m2=MEDCouplingDataForTest.buildCU1DMesh_U();
791 m2.changeSpaceDimension(3);
794 m2.rotate(center,vector,-pi/2.);
795 m3=m1.buildExtrudedMesh(m2,0);
797 m4=MEDCouplingMappedExtrudedMesh.New(m3,m1,0);
798 self.assertEqual(15,m4.getNumberOfCells());
799 self.assertEqual(5,m4.getMesh2D().getNumberOfCells());
800 self.assertEqual(3,m4.getMesh1D().getNumberOfCells());
801 m3DIds=m4.getMesh3DIds().getValues();
802 self.assertEqual(list(range(15)), list(m3DIds));
803 #some random in cells to check that extrusion alg find it correctly
804 expected1=[1,3,2,0,6,5,7,10,11,8,12,9,14,13,4]
805 m3.renumberCells(expected1,False);
806 m4=MEDCouplingMappedExtrudedMesh.New(m3,m1,0);
807 self.assertEqual(15,m4.getNumberOfCells());
808 self.assertEqual(5,m4.getMesh2D().getNumberOfCells());
809 self.assertEqual(3,m4.getMesh1D().getNumberOfCells());
810 m3DIds=m4.getMesh3DIds().getValues();
811 self.assertEqual(expected1,list(m3DIds));
812 #play with polygons and polyedrons
814 m1.convertToPolyTypes(cells);
815 m3=m1.buildExtrudedMesh(m2,0);
816 self.assertEqual(NORM_HEXA8,m3.getTypeOfCell(0));
817 self.assertEqual(NORM_PENTA6,m3.getTypeOfCell(1));
818 self.assertEqual(NORM_POLYHED,m3.getTypeOfCell(2));
819 self.assertEqual(NORM_POLYHED,m3.getTypeOfCell(3));
820 self.assertEqual(NORM_HEXA8,m3.getTypeOfCell(4));
821 m3.renumberCells(expected1,False);
822 m4=MEDCouplingMappedExtrudedMesh.New(m3,m1,0);
823 self.assertEqual(15,m4.getNumberOfCells());
824 self.assertEqual(5,m4.getMesh2D().getNumberOfCells());
825 self.assertEqual(3,m4.getMesh1D().getNumberOfCells());
826 m3DIds=m4.getMesh3DIds().getValues();
827 self.assertEqual(expected1,list(m3DIds));
830 def testExtrudedMesh4(self):
831 m1=MEDCouplingDataForTest.build2DTargetMesh_1();
833 m1.convertToPolyTypes(cells);
834 m1.changeSpaceDimension(3);
835 m2=MEDCouplingDataForTest.buildCU1DMesh_U();
836 m2.changeSpaceDimension(3);
839 m2.rotate(center,vector,-pi/2.);
841 m3=m1.buildExtrudedMesh(m2,0);
842 expected1=[1,3,2,0,6,5,7,10,11,8,12,9,14,13,4]
843 rexpected1=[3, 0, 2, 1, 14, 5, 4, 6, 9, 11, 7, 8, 10, 13, 12]
844 m3.renumberCells(expected1,False);
845 m4=MEDCouplingMappedExtrudedMesh.New(m3,m1,0);
846 self.assertEqual(NORM_HEXA8,m4.getTypeOfCell(0));
847 self.assertEqual(NORM_HEXA8,m4.getTypeOfCell(1));
848 self.assertEqual(NORM_POLYHED,m4.getTypeOfCell(2));
849 self.assertEqual(NORM_PENTA6,m4.getTypeOfCell(7));
850 f=m4.getMeasureField(True);
852 self.assertEqual(15,arr.getNumberOfTuples());
853 self.assertEqual(1,arr.getNumberOfComponents());
854 arrPtr=arr.getValues();
855 expected2=[0.075,0.0375,0.0375,0.075,0.075,
856 0.1125,0.05625,0.05625,0.1125,0.1125,
857 0.0625,0.03125,0.03125,0.0625,0.0625]
859 self.assertAlmostEqual(expected2[rexpected1[i]],arrPtr[i],16);
861 m5=m4.build3DUnstructuredMesh();
863 self.assertTrue(m5.isEqual(m3,1e-12));
864 f=m5.getMeasureField(True);
866 self.assertTrue(isinstance(f.getMesh(),MEDCouplingMappedExtrudedMesh))
868 arrPtr=arr.getValues();
870 self.assertAlmostEqual(expected2[rexpected1[i]],arrPtr[i],15);
874 def testFindCommonNodes(self):
875 targetMesh=MEDCouplingDataForTest.build3DTargetMesh_1();
876 comm,commI=targetMesh.findCommonNodes(1e-10,-1);
877 self.assertEqual(1,commI.getNumberOfTuples());
878 self.assertEqual(0,comm.getNumberOfTuples());
879 o2n,newNbOfNodes=targetMesh.buildNewNumberingFromCommonNodesFormat(comm,commI);
880 self.assertEqual(27,newNbOfNodes);
881 self.assertEqual(27,o2n.getNumberOfTuples());
882 o2nExp1 = list(range(27))
883 self.assertEqual(o2nExp1,list(o2n.getValues()));
885 targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
886 self.assertEqual(31,targetMesh.getNumberOfNodes());
887 comm,commI=targetMesh.findCommonNodes(1e-10);# testing default parameter
888 self.assertEqual(3,commI.getNumberOfTuples());
889 self.assertEqual(6,comm.getNumberOfTuples());
890 commExpected=[1,27,28,29,23,30]
891 commIExpected=[0,4,6]
892 self.assertEqual(commExpected,list(comm.getValues()));
893 self.assertEqual(commIExpected,list(commI.getValues()));
894 o2n,newNbOfNodes=targetMesh.buildNewNumberingFromCommonNodesFormat(comm,commI);
895 self.assertEqual(31,o2n.getNumberOfTuples());
896 self.assertEqual(27,newNbOfNodes);
897 o2nExp2=[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,
898 21,22,23,24,25,26,1,1,1,23]
899 self.assertEqual(o2nExp2,list(o2n.getValues()));
901 targetMesh=MEDCouplingDataForTest.build3DTargetMesh_1();
902 time=targetMesh.getTimeOfThis();
903 o2n,areNodesMerged,newNbOfNodes=targetMesh.mergeNodes(1e-10);
904 targetMesh.updateTime();
905 self.assertEqual(time,targetMesh.getTimeOfThis());
906 self.assertTrue(not areNodesMerged);
908 targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
909 time=targetMesh.getTimeOfThis();
910 o2n,areNodesMerged,newNbOfNodes=targetMesh.mergeNodes(1e-10);
911 targetMesh.updateTime();
912 self.assertTrue(time!=targetMesh.getTimeOfThis());
913 self.assertTrue(areNodesMerged);
914 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,
915 18,4,5,8,7,13,14,17,16,
916 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,
917 18,13,14,17,16,22,23,26,25]
918 self.assertEqual(72,targetMesh.getNodalConnectivity().getNumberOfTuples());
919 self.assertEqual(connExp,list(targetMesh.getNodalConnectivity().getValues()));
920 self.assertEqual(27,targetMesh.getCoords().getNumberOfTuples());
921 coordsExp=[ 0., 0., 0., 50., 0., 0. , 200., 0., 0. , 0., 50., 0., 50., 50., 0. ,
922 200., 50., 0., 0., 200., 0., 50., 200., 0. , 200., 200., 0. ,
923 0., 0., 50., 50., 0., 50. , 200., 0., 50. , 0., 50., 50., 50.,
924 50., 50. , 200., 50., 50., 0., 200., 50., 50., 200., 50. ,
925 200., 200., 50. , 0., 0., 200., 50., 0., 200. , 200., 0., 200.
926 , 0., 50., 200., 50., 50., 200. , 200., 50., 200.,
927 0., 200., 200., 50., 200., 200. , 200., 200., 200. ]
928 self.assertEqual(coordsExp,targetMesh.getCoords().getValues());
930 targetMesh=MEDCouplingDataForTest.build2DTargetMeshMergeNode_1();
931 self.assertEqual(18,targetMesh.getNumberOfNodes());
932 time=targetMesh.getTimeOfThis();
933 o2n,areNodesMerged,newNbOfNodes=targetMesh.mergeNodes(1e-10);
934 self.assertTrue(time!=targetMesh.getTimeOfThis());
935 self.assertTrue(areNodesMerged);
936 self.assertEqual(9,targetMesh.getNumberOfNodes());
937 connExp2=[4,0,4,3,1, 3,1,3,2, 3,3,5,2, 4,4,6,7,3, 4,7,8,5,3]
938 self.assertEqual(23,targetMesh.getNodalConnectivity().getNumberOfTuples());
939 self.assertEqual(connExp2,list(targetMesh.getNodalConnectivity().getValues()));
940 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]
941 self.assertEqual(9,targetMesh.getCoords().getNumberOfTuples());
942 self.assertEqual(coordsExp2,targetMesh.getCoords().getValues());
945 def testCheckButterflyCells(self):
946 sourceMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
947 cells=sourceMesh.checkButterflyCells();
948 self.assertEqual(0,len(cells));
949 conn=sourceMesh.getNodalConnectivity()
951 conn.setIJ(15,0,conn.getIJ(16,0))
953 cells=sourceMesh.checkButterflyCells();
954 self.assertEqual(1,len(cells));
955 self.assertEqual([3],cells.getValues());
957 conn.setIJ(15,0,conn.getIJ(16,0))
959 cells=sourceMesh.checkButterflyCells();
960 self.assertEqual(0,len(cells));
962 sourceMesh=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
963 cells=sourceMesh.checkButterflyCells();
964 self.assertEqual(0,len(cells));
965 conn=sourceMesh.getNodalConnectivity()
967 conn.setIJ(15,0,conn.getIJ(16,0))
969 cells=sourceMesh.checkButterflyCells();
970 self.assertEqual(1,len(cells));
971 self.assertEqual([3],cells.getValues());
973 conn.setIJ(15,0,conn.getIJ(16,0))
975 cells=sourceMesh.checkButterflyCells();
976 self.assertEqual(0,len(cells));
979 def testMergeMesh1(self):
980 m1=MEDCouplingDataForTest.build2DTargetMesh_1();
981 m2=MEDCouplingDataForTest.build2DSourceMesh_1();
984 m3=m1.mergeMyselfWith(m2);
985 self.assertTrue(isinstance(m3,MEDCouplingUMesh));
986 m3.checkConsistencyLight();
987 m4=MEDCouplingDataForTest.build2DTargetMeshMerged_1();
988 self.assertTrue(m3.isEqual(m4,1.e-12));
989 da,isMerged,newNbOfNodes=m3.mergeNodes(1.e-12);
990 self.assertEqual(11,m3.getNumberOfNodes());
991 self.assertTrue(isMerged);
994 def testMergeMeshOnSameCoords1(self):
995 m1=MEDCouplingDataForTest.build2DTargetMesh_1();
996 m2=MEDCouplingDataForTest.build2DTargetMesh_1();
997 cells = list(range(5));
998 m2.convertToPolyTypes(cells);
999 m1.tryToShareSameCoords(m2,1e-12);
1000 m3=MEDCouplingDataForTest.build2DTargetMesh_1();
1001 m3.tryToShareSameCoords(m2,1e-12);
1003 m4=MEDCouplingUMesh.MergeUMeshesOnSameCoords(meshes);
1004 m4.checkConsistencyLight();
1005 self.assertEqual(15,m4.getNumberOfCells());
1007 m1_1=m4.buildPartOfMySelf(cells1,True);
1008 m1_1.setName(m1.getName());
1009 self.assertTrue(m1.isEqual(m1_1,1e-12));
1011 m2_1=m4.buildPartOfMySelf(cells2,True);
1012 m2_1.setName(m2.getName());
1013 self.assertTrue(m2.isEqual(m2_1,1e-12));
1014 cells3=[10,11,12,13,14]
1015 m3_1=m4.buildPartOfMySelf(cells3,True);
1016 m3_1.setName(m3.getName());
1017 self.assertTrue(m3.isEqual(m3_1,1e-12));
1020 def testMergeField1(self):
1021 m1=MEDCouplingDataForTest.build2DTargetMesh_1();
1022 m2=MEDCouplingDataForTest.build2DSourceMesh_1();
1025 f1=m1.getMeasureField(True);
1026 f2=m2.getMeasureField(True);
1027 f3=MEDCouplingFieldDouble.MergeFields(f1,f2);
1028 f3.checkConsistencyLight();
1029 m4=MEDCouplingDataForTest.build2DTargetMeshMerged_1();
1030 m4.setName(f1.getMesh().getName())
1031 self.assertTrue(f3.getMesh().isEqual(m4,1.e-12));
1033 self.assertEqual(name,"MeasureOfMesh_");
1034 self.assertEqual(f3.getTypeOfField(),ON_CELLS);
1035 self.assertEqual(f3.getTimeDiscretization(),ONE_TIME);
1036 self.assertEqual(1,f3.getNumberOfComponents());
1037 self.assertEqual(7,f3.getNumberOfTuples());
1038 values=[0.25,0.125,0.125,0.25,0.25,0.5,0.5]
1039 tmp=f3.getArray().getValues();
1040 self.assertEqual(len(values),len(tmp))
1042 self.assertTrue(abs(values[i]-tmp[i])<1e-12)
1046 def testFillFromAnalytic(self):
1047 m=MEDCouplingDataForTest.build2DTargetMesh_1();
1048 m.setTime(3.4,5,6); m.setTimeUnit("us");
1049 f1=m.fillFromAnalytic(ON_CELLS,1,"x+y");
1050 self.assertAlmostEqual(3.4,f1.getTime()[0],12) ; self.assertEqual(5,f1.getTime()[1]) ; self.assertEqual(6,f1.getTime()[2])
1051 self.assertEqual("us",f1.getTimeUnit())
1052 f1.checkConsistencyLight();
1053 self.assertEqual(f1.getTypeOfField(),ON_CELLS);
1054 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1055 self.assertEqual(1,f1.getNumberOfComponents());
1056 self.assertEqual(5,f1.getNumberOfTuples());
1057 values1=[-0.1,0.23333333333333336,0.56666666666666665,0.4,0.9]
1058 tmp=f1.getArray().getValues();
1059 self.assertEqual(len(values1),len(tmp))
1060 for i in range(len(tmp)):
1061 self.assertTrue(abs(tmp[i]-values1[i])<1.e-12)
1064 f1=m.fillFromAnalytic(ON_NODES,1,"x+y");
1065 f1.checkConsistencyLight();
1066 self.assertEqual(f1.getTypeOfField(),ON_NODES);
1067 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1068 self.assertEqual(1,f1.getNumberOfComponents());
1069 self.assertEqual(9,f1.getNumberOfTuples());
1070 values2=[-0.6,-0.1,0.4,-0.1,0.4,0.9,0.4,0.9,1.4]
1071 tmp=f1.getArray().getValues();
1072 self.assertEqual(len(values2),len(tmp))
1073 for i in range(len(tmp)):
1074 self.assertTrue(abs(tmp[i]-values2[i])<1.e-12)
1077 f1=m.fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+(2*(x+y))*JVec");
1078 f1.checkConsistencyLight();
1079 self.assertEqual(f1.getTypeOfField(),ON_NODES);
1080 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1081 self.assertEqual(2,f1.getNumberOfComponents());
1082 self.assertEqual(9,f1.getNumberOfTuples());
1083 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]
1084 tmp=f1.getArray().getValues();
1085 self.assertEqual(len(values3),len(tmp))
1086 for i in range(len(tmp)):
1087 self.assertTrue(abs(tmp[i]-values3[i])<1.e-12)
1089 values4=f1.accumulate();
1090 self.assertEqual(2,len(values4))
1091 self.assertTrue(abs(3.6-values4[0])<1.e-12);
1092 self.assertTrue(abs(7.2-values4[1])<1.e-12);
1093 values4=f1.integral(True);
1094 #0.4 == 0.25/4*-0.6+(0.25/4+0.125/3)*-0.1+0.4*(0.125/3.+0.125/3)+(-0.1)*(0.25/4+0.25/4)+0.4*(0.25/4+0.125/3+0.125/3+0.25/4+0.25/4)+0.9*(0.25/4+0.125/3)+0.4*0.25/4+0.9*(0.25/4+0.25/4)+1.4*0.25/4
1095 self.assertEqual(2,len(values4))
1096 self.assertTrue(abs(0.4-values4[0])<1.e-12);
1097 self.assertTrue(abs(0.8-values4[1])<1.e-12);
1099 self.assertRaises(InterpKernelException,m.fillFromAnalytic,ON_NODES,1,"1./(x-0.2)");
1102 def testFillFromAnalytic2(self):
1103 m=MEDCouplingDataForTest.build2DTargetMesh_1();
1104 f1=m.fillFromAnalytic(ON_CELLS,1,"y+x");
1105 f1.checkConsistencyLight();
1106 self.assertEqual(f1.getTypeOfField(),ON_CELLS);
1107 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1108 self.assertEqual(1,f1.getNumberOfComponents());
1109 self.assertEqual(5,f1.getNumberOfTuples());
1110 values1=[-0.1,0.23333333333333336,0.56666666666666665,0.4,0.9]
1111 tmp=f1.getArray().getValues();
1112 self.assertEqual(len(values1),len(tmp))
1113 for i in range(len(values1)):
1114 self.assertTrue(abs(values1[i]-tmp[i])<1.e-12);
1117 f1=m.fillFromAnalytic(ON_NODES,1,"y+2*x");
1118 f1.checkConsistencyLight();
1119 self.assertEqual(f1.getTypeOfField(),ON_NODES);
1120 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1121 self.assertEqual(1,f1.getNumberOfComponents());
1122 self.assertEqual(9,f1.getNumberOfTuples());
1123 values2=[-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1]
1124 tmp=f1.getArray().getValues();
1125 self.assertEqual(len(values2),len(tmp))
1126 for i in range(len(values2)):
1127 self.assertTrue(abs(values2[i]-tmp[i])<1.e-12);
1129 f1=m.fillFromAnalytic(ON_NODES,1,"2.*x+y");
1130 f1.checkConsistencyLight();
1131 self.assertEqual(f1.getTypeOfField(),ON_NODES);
1132 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1133 self.assertEqual(1,f1.getNumberOfComponents());
1134 self.assertEqual(9,f1.getNumberOfTuples());
1135 tmp=f1.getArray().getValues();
1136 values2Bis=[-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1]
1137 self.assertEqual(len(values2Bis),len(tmp))
1138 for i in range(len(values2Bis)):
1139 self.assertTrue(abs(values2Bis[i]-tmp[i])<1.e-12);
1142 f1=m.fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+2*(x+y)*JVec");
1143 f1.checkConsistencyLight();
1144 self.assertEqual(f1.getTypeOfField(),ON_NODES);
1145 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1146 self.assertEqual(2,f1.getNumberOfComponents());
1147 self.assertEqual(9,f1.getNumberOfTuples());
1148 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]
1149 tmp=f1.getArray().getValues();
1150 self.assertEqual(len(values3),len(tmp))
1151 for i in range(len(values3)):
1152 self.assertTrue(abs(values3[i]-tmp[i])<1.e-12);
1154 values4=f1.accumulate();
1155 self.assertTrue(abs(3.6-values4[0])<1.e-12);
1156 self.assertTrue(abs(7.2-values4[1])<1.e-12);
1157 values4=f1.integral(True);
1158 self.assertTrue(abs(0.4-values4[0])<1.e-12);
1159 self.assertTrue(abs(0.8-values4[1])<1.e-12);
1162 def testApplyFunc(self):
1163 m=MEDCouplingDataForTest.build2DTargetMesh_1();
1164 f1=m.fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+(2*(x+y))*JVec");
1165 f1.checkConsistencyLight();
1166 self.assertEqual(f1.getTypeOfField(),ON_NODES);
1167 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1168 self.assertEqual(2,f1.getNumberOfComponents());
1169 self.assertEqual(9,f1.getNumberOfTuples());
1170 f1.applyFunc(1,"x+y");
1171 self.assertEqual(f1.getTypeOfField(),ON_NODES);
1172 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1173 self.assertEqual(1,f1.getNumberOfComponents());
1174 self.assertEqual(9,f1.getNumberOfTuples());
1175 values1=[-1.8,-0.3,1.2,-0.3,1.2,2.7,1.2,2.7,4.2]
1176 tmp=f1.getArray().getValues();
1177 self.assertEqual(len(values1),len(tmp))
1178 for i in range(len(tmp)):
1179 self.assertTrue(abs(tmp[i]-values1[i])<1.e-12)
1183 def testApplyFunc2(self):
1184 m=MEDCouplingDataForTest.build2DTargetMesh_1();
1185 f1=m.fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+2*(x+y)*JVec");
1186 f1.checkConsistencyLight();
1187 self.assertEqual(f1.getTypeOfField(),ON_NODES);
1188 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1189 self.assertEqual(2,f1.getNumberOfComponents());
1190 self.assertEqual(9,f1.getNumberOfTuples());
1193 self.assertRaises(InterpKernelException, f2.applyFunc, 1, "a+b+c+d");
1194 self.assertRaises(InterpKernelException, f2.applyFunc, 1, "a/0");
1195 self.assertRaises(InterpKernelException, f2.applyFunc, "a/0");
1196 f2.applyFunc("abs(u)^2.4+2*u");
1197 self.assertEqual(f1.getTypeOfField(),ON_NODES);
1198 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1199 self.assertEqual(2,f1.getNumberOfComponents());
1200 self.assertEqual(9,f1.getNumberOfTuples());
1201 values2=[-0.9065304805418678, -0.85105859001709905, -0.19601892829446504, -0.37898777756476987,
1202 0.91090317490482353, 2.1853504664669781, -0.19601892829446504, -0.37898777756476987,
1203 0.91090317490482353, 2.1853504664669781, 2.5765725275664879, 7.6987743736515295,
1204 0.91090317490482353, 2.1853504664669781, 2.5765725275664879, 7.6987743736515295,
1205 5.0423700574830965, 17.435300118916864]
1206 tmp=f2.getArray().getValues();
1207 self.assertEqual(len(tmp),len(values2))
1208 for i in range(len(tmp)):
1209 self.assertTrue(abs(tmp[i]-values2[i])<1.e-12)
1212 f1.applyFunc(1,"x+y");
1213 self.assertEqual(f1.getTypeOfField(),ON_NODES);
1214 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1215 self.assertEqual(1,f1.getNumberOfComponents());
1216 self.assertEqual(9,f1.getNumberOfTuples());
1217 values1=[-1.8,-0.3,1.2,-0.3,1.2,2.7,1.2,2.7,4.2]
1218 tmp=f1.getArray().getValues();
1219 self.assertEqual(len(tmp),len(values1))
1220 for i in range(len(tmp)):
1221 self.assertTrue(abs(tmp[i]-values1[i])<1.e-12)
1225 def testOperationsOnFields(self):
1226 m=MEDCouplingDataForTest.build2DTargetMesh_1();
1227 f1=m.fillFromAnalytic(ON_NODES,1,"x+y");
1228 f2=m.fillFromAnalytic(ON_NODES,1,"x+y");
1229 f1.checkConsistencyLight();
1230 f2.checkConsistencyLight();
1232 f3.checkConsistencyLight();
1233 self.assertEqual(f3.getTypeOfField(),ON_NODES);
1234 self.assertEqual(f3.getTimeDiscretization(),ONE_TIME);
1235 values1=[-1.2,-0.2,0.8,-0.2,0.8,1.8,0.8,1.8,2.8]
1236 tmp=f3.getArray().getValues();
1237 self.assertEqual(len(values1),len(tmp))
1238 for i in range(len(tmp)):
1239 self.assertTrue(abs(tmp[i]-values1[i])<1.e-12)
1243 f3.checkConsistencyLight();
1244 self.assertEqual(f3.getTypeOfField(),ON_NODES);
1245 self.assertEqual(f3.getTimeDiscretization(),ONE_TIME);
1246 values2=[0.36,0.01,0.16,0.01,0.16,0.81,0.16,0.81,1.96]
1247 tmp=f3.getArray().getValues();
1248 self.assertEqual(len(values2),len(tmp))
1249 for i in range(len(tmp)):
1250 self.assertTrue(abs(tmp[i]-values2[i])<1.e-12)
1255 f4.checkConsistencyLight();
1256 self.assertEqual(f4.getTypeOfField(),ON_NODES);
1257 self.assertEqual(f4.getTimeDiscretization(),ONE_TIME);
1258 values3=[0.6,0.1,-0.4,0.1,-0.4,-0.9,-0.4,-0.9,-1.4]
1259 tmp=f4.getArray().getValues();
1260 self.assertEqual(len(values3),len(tmp))
1261 for i in range(len(tmp)):
1262 self.assertTrue(abs(tmp[i]-values3[i])<1.e-12)
1267 f4.checkConsistencyLight();
1268 self.assertEqual(f4.getTypeOfField(),ON_NODES);
1269 self.assertEqual(f4.getTimeDiscretization(),ONE_TIME);
1270 tmp=f4.getArray().getValues();
1271 for i in range(len(tmp)):
1272 self.assertTrue(abs(tmp[i]-2.)<1.e-12)
1275 f4=f2.buildNewTimeReprFromThis(NO_TIME,False);
1276 f4.checkConsistencyLight();
1277 self.assertEqual(f4.getTypeOfField(),ON_NODES);
1278 self.assertEqual(f4.getTimeDiscretization(),NO_TIME);
1279 self.assertRaises(InterpKernelException,f1.__add__,f4);
1280 f5=f4.buildNewTimeReprFromThis(ONE_TIME,False);
1281 self.assertEqual(f5.getTypeOfField(),ON_NODES);
1282 self.assertEqual(f5.getTimeDiscretization(),ONE_TIME);
1284 tmp=f3.getArray().getValues();
1285 values4=[-1.2,-0.2,0.8,-0.2,0.8,1.8,0.8,1.8,2.8]
1286 self.assertEqual(len(values3),len(tmp))
1287 for i in range(len(tmp)):
1288 self.assertTrue(abs(tmp[i]-values4[i])<1.e-12)
1291 f4=f2.buildNewTimeReprFromThis(NO_TIME,True);
1292 f4.checkConsistencyLight();
1293 self.assertEqual(f4.getTypeOfField(),ON_NODES);
1294 self.assertEqual(f4.getTimeDiscretization(),NO_TIME);
1295 self.assertRaises(InterpKernelException,f1.__add__,f4);
1296 f5=f4.buildNewTimeReprFromThis(ONE_TIME,True);
1297 self.assertEqual(f5.getTypeOfField(),ON_NODES);
1298 self.assertEqual(f5.getTimeDiscretization(),ONE_TIME);
1300 tmp=f3.getArray().getValues();
1301 values5=[-1.2,-0.2,0.8,-0.2,0.8,1.8,0.8,1.8,2.8]
1302 self.assertEqual(len(values5),len(tmp))
1303 for i in range(len(tmp)):
1304 self.assertTrue(abs(tmp[i]-values5[i])<1.e-12)
1308 def testOperationsOnFields2(self):
1309 m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1310 m.setTime(3.4,5,6); m.setTimeUnit("us");
1311 f1=m.fillFromAnalytic(ON_NODES,1,"x+y+z");
1312 f2=m.fillFromAnalytic(ON_NODES,1,"a*a+b+c*c");
1314 f3.checkConsistencyLight();
1315 self.assertEqual(f3.getTypeOfField(),ON_NODES);
1316 self.assertEqual(f3.getTimeDiscretization(),ONE_TIME);
1317 expected1=[-2.4999999999999991, 1.2162162162162162, 0.77868852459016391,
1318 0.7407407407407407, 1.129032258064516, 0.81632653061224492,
1319 0.86538461538461531, 1.0919540229885056, 0.84302325581395343]
1320 self.assertEqual(1,f3.getNumberOfComponents());
1321 self.assertEqual(9,f3.getNumberOfTuples());
1322 val=f3.getArray().getValues();
1324 self.assertTrue(abs(expected1[i]-val[i])<1.e-12);
1326 f1=m.buildOrthogonalField();
1327 self.assertAlmostEqual(3.4,f1.getTime()[0],12) ; self.assertEqual(5,f1.getTime()[1]) ; self.assertEqual(6,f1.getTime()[2])
1328 self.assertEqual("us",f1.getTimeUnit())
1329 f2=m.fillFromAnalytic(ON_CELLS,1,"x");
1331 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]
1332 val=f3.getArray().getValues();
1334 self.assertTrue(abs(expected2[i]-val[i])<1.e-12);
1338 val=f3.getArray().getValues();
1340 self.assertTrue(abs(expected2[i]-val[i])<1.e-12);
1344 def testOperationsOnFields3(self):
1345 m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1346 f1=m.fillFromAnalytic(ON_NODES,1,"x+y+z");
1347 f2=m.fillFromAnalytic(ON_NODES,1,"a*a+b+c*c");
1349 f1.checkConsistencyLight();
1350 self.assertEqual(f1.getTypeOfField(),ON_NODES);
1351 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1352 expected1=[-2.4999999999999991, 1.2162162162162162, 0.77868852459016391,
1353 0.7407407407407407, 1.129032258064516, 0.81632653061224492,
1354 0.86538461538461531, 1.0919540229885056, 0.84302325581395343]
1355 self.assertEqual(1,f1.getNumberOfComponents());
1356 self.assertEqual(9,f1.getNumberOfTuples());
1357 val=f1.getArray().getValues();
1359 self.assertTrue(abs(expected1[i]-val[i])<1.e-12);
1362 f1=m.buildOrthogonalField();
1363 f2=m.fillFromAnalytic(ON_CELLS,1,"x");
1365 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]
1366 val=f1.getArray().getValues();
1368 self.assertTrue(abs(expected2[i]-val[i])<1.e-12);
1371 f1=m.buildOrthogonalField();
1372 # to avoid valgrind leaks
1373 # self.assertRaises(InterpKernelException,f2.__imul__,f1);
1376 def testOperationsOnFields4(self):
1377 m=MEDCouplingDataForTest.build2DTargetMesh_1();
1378 nbOfCells=m.getNumberOfCells();
1379 f1=MEDCouplingFieldDouble.New(ON_CELLS,CONST_ON_TIME_INTERVAL);
1381 array=DataArrayDouble.New();
1383 self.assertRaises(InterpKernelException,f1.setEndArray,array);
1384 self.assertRaises(InterpKernelException,f1.getEndArray);
1385 arr1=[0.,10.,20.,1.,11.,21.,2.,12.,22.,3.,13.,23.,4.,14.,24.]
1386 arr2=[5.,15.,25.,6.,16.,26.,7.,17.,27.,8.,18.,28.,9.,19.,29.]
1387 array.setValues(arr1,nbOfCells,3);
1388 f1.setStartTime(2.,0,0);
1389 f1.setEndTime(3.,0,0);
1390 f1.checkConsistencyLight();
1392 res=f1.getValueOn(pos);
1393 self.assertTrue(abs(arr1[3]-res[0])<1.e-12);
1394 self.assertTrue(abs(arr1[4]-res[1])<1.e-12);
1395 self.assertTrue(abs(arr1[5]-res[2])<1.e-12);
1397 res=f1.getValueOn(pos,2.2);
1398 self.assertTrue(abs(arr1[3]-res[0])<1.e-12);
1399 self.assertTrue(abs(arr1[4]-res[1])<1.e-12);
1400 self.assertTrue(abs(arr1[5]-res[2])<1.e-12);
1402 self.assertRaises(InterpKernelException,f1.getValueOn,pos,3.2)
1403 f2=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
1405 f2.setArray(f1.getArray());
1406 f2.setStartTime(2.,3,0);
1407 f2.setEndTime(4.,13,0);
1408 self.assertRaises(InterpKernelException,f2.checkConsistencyLight)
1409 array2=DataArrayDouble.New();
1410 array2.setValues(arr2,nbOfCells,3);
1411 f2.setEndArray(array2);
1412 f2.checkConsistencyLight();
1415 res=f2.getValueOn(pos,3.21);
1416 self.assertTrue(abs(4.025-res[0])<1.e-12);
1417 self.assertTrue(abs(14.025-res[1])<1.e-12);
1418 self.assertTrue(abs(24.025-res[2])<1.e-12);
1420 self.assertTrue(f2.isEqual(f3,1e-12,1e-12));
1421 f3.getEndArray().setIJ(0,0,5.001);
1422 self.assertTrue(not f2.isEqual(f3,1e-12,1e-12));
1423 self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1424 f3.setStartTime(2.1,3,0);
1425 self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1426 f3.setStartTime(2.,3,0);
1427 self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1428 f3.setStartTime(2.,4,0);
1429 self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1430 f3.setStartTime(2.,3,1);
1431 self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1432 f3.setStartTime(2.,3,0);
1433 self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1434 f3.setEndTime(4.1,13,0);
1435 self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1436 f3.setEndTime(4.,13,0);
1437 self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1438 f3.setEndTime(4.,14,0);
1439 self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1440 f3.setEndTime(4.,13,1);
1441 self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1442 f3.setEndTime(4.,13,0);
1443 self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1446 res=f4.getValueOn(pos,3.21);
1447 self.assertTrue(abs(8.05-res[0])<1.e-12);
1448 self.assertTrue(abs(28.05-res[1])<1.e-12);
1449 self.assertTrue(abs(48.05-res[2])<1.e-12);
1452 res=f4.getValueOn(pos,3.21);
1453 self.assertTrue(abs(12.075-res[0])<1.e-12);
1454 self.assertTrue(abs(42.075-res[1])<1.e-12);
1455 self.assertTrue(abs(72.075-res[2])<1.e-12);
1458 def testMergeNodesOnField(self):
1459 targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
1460 f1=targetMesh.fillFromAnalytic(ON_NODES,1,"x+y+z");
1461 f1.mergeNodes(1e-10);
1463 targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
1464 f1=targetMesh.fillFromAnalytic(ON_NODES,1,"x+y+z");
1466 tmp.setIJ(0,0,1000.);
1467 f1.mergeNodes(1e-10);
1469 targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
1470 f1=targetMesh.fillFromAnalytic(ON_NODES,1,"x+y+z");
1472 tmp.setIJ(1,0,1000.);
1473 self.assertRaises(InterpKernelException,f1.mergeNodes,1.e-10)
1476 def testCheckConsecutiveCellTypes(self):
1477 sourceMesh=MEDCouplingDataForTest.build2DSourceMesh_1();
1478 targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1479 self.assertTrue(sourceMesh.checkConsecutiveCellTypes());
1480 order1=[NORM_TRI3,NORM_QUAD4]
1481 order2=[NORM_QUAD4,NORM_TRI3]
1482 self.assertTrue(not targetMesh.checkConsecutiveCellTypes());
1483 self.assertTrue(not targetMesh.checkConsecutiveCellTypesAndOrder(order1));
1484 self.assertTrue(not targetMesh.checkConsecutiveCellTypesAndOrder(order2));
1485 da=targetMesh.getRenumArrForConsecutiveCellTypesSpec(order1);
1486 self.assertEqual(5,da.getNumberOfTuples());
1487 self.assertEqual(1,da.getNumberOfComponents());
1488 expected1=[2,0,1,3,4]
1489 self.assertTrue(expected1==list(da.getValues()));
1490 da=targetMesh.getRenumArrForConsecutiveCellTypesSpec(order2);
1491 self.assertEqual(5,da.getNumberOfTuples());
1492 self.assertEqual(1,da.getNumberOfComponents());
1493 expected2=[0,3,4,1,2]
1494 self.assertTrue(expected2==list(da.getValues()));
1495 renumber1=[4,0,1,2,3]
1496 targetMesh.renumberCells(renumber1,False);
1497 self.assertTrue(targetMesh.checkConsecutiveCellTypes());
1498 self.assertTrue(targetMesh.checkConsecutiveCellTypesAndOrder(order1));
1499 self.assertTrue(not targetMesh.checkConsecutiveCellTypesAndOrder(order2));
1502 def testRearrange2ConsecutiveCellTypes(self):
1503 m1_1=MEDCouplingDataForTest.build2DSourceMesh_1();
1504 m2_1=MEDCouplingDataForTest.build2DTargetMesh_1();
1505 arr1=m1_1.rearrange2ConsecutiveCellTypes();
1506 m1_2=MEDCouplingDataForTest.build2DSourceMesh_1();
1507 self.assertTrue(m1_2.isEqual(m1_1,1e-12));
1509 self.assertEqual(2,arr1.getNumberOfTuples());
1510 self.assertEqual(1,arr1.getNumberOfComponents());
1511 self.assertEqual(expected1,arr1.getValues());
1512 expected2=[0,3,4,1,2]
1513 arr1=m2_1.rearrange2ConsecutiveCellTypes();
1514 self.assertEqual(5,arr1.getNumberOfTuples());
1515 self.assertEqual(1,arr1.getNumberOfComponents());
1516 self.assertEqual(expected2,list(arr1.getValues()));
1517 m2_2=MEDCouplingDataForTest.build2DTargetMesh_1();
1518 self.assertEqual(5,arr1.getNumberOfTuples());
1519 self.assertEqual(1,arr1.getNumberOfComponents());
1520 self.assertEqual(expected2,list(arr1.getValues()));
1521 self.assertTrue(not m2_2.isEqual(m2_1,1e-12));
1522 m2_2.renumberCells(expected2,False);
1523 self.assertTrue(m2_2.isEqual(m2_1,1e-12));
1526 def testSplitByType(self):
1527 m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1529 self.assertEqual(3,len(v));
1530 m2=MEDCouplingUMesh.MergeUMeshesOnSameCoords(v);
1531 m2.setName(m1.getName());
1532 self.assertTrue(m1.isEqual(m2,1.e-12));
1535 def testFuseUMeshesOnSameCoords(self):
1536 m2=MEDCouplingDataForTest.build2DTargetMesh_1();
1538 m3=m2.buildPartOfMySelf(cells1,True);
1539 self.assertTrue(isinstance(m3,MEDCouplingUMesh))
1541 m4=m2.buildPartOfMySelf(cells2,True);
1542 self.assertTrue(isinstance(m4,MEDCouplingUMesh))
1544 m5=m2.buildPartOfMySelf(cells3,True);
1545 self.assertTrue(isinstance(m5,MEDCouplingUMesh))
1548 m7,corr=MEDCouplingUMesh.FuseUMeshesOnSameCoords(meshes,0);
1549 self.assertEqual(4,m7.getNumberOfCells());
1550 self.assertEqual(3,len(corr));
1551 expectedVals1=[3,3,2]
1552 expectedVals2=[[0,1,2],[3,0,2],[3,0]]
1555 self.assertEqual(1,arr.getNumberOfComponents());
1556 nbOfVals=expectedVals1[i];
1557 self.assertEqual(nbOfVals,arr.getNumberOfTuples());
1558 vals=arr.getValues();
1559 self.assertEqual(expectedVals2[i],list(vals));
1561 arr2,fidsOfGroups=DataArrayInt.MakePartition(corr,m7.getNumberOfCells());
1563 fidsGrp=[[1,3,5],[3,4,5],[4,5]]
1564 self.assertEqual(3,len(fidsOfGroups));
1565 self.assertEqual(1,arr2.getNumberOfComponents());
1566 self.assertEqual(4,arr2.getNumberOfTuples());
1567 self.assertEqual(fidExp,list(arr2.getValues()));
1569 nbOfVals=expectedVals1[i];
1570 self.assertEqual(list(fidsOfGroups[i]),fidsGrp[i]);
1574 def testFuseUMeshesOnSameCoords2(self):
1575 m1,m2=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
1577 m3=m1.buildPartOfMySelf(part1,True);
1579 m4=m1.buildPartOfMySelf(part2,True);
1580 meshes=[m1,m3,m3,m4]
1581 m5,corr=MEDCouplingUMesh.FuseUMeshesOnSameCoords(meshes,0);
1582 self.assertEqual(18,m5.getNumberOfCells());
1584 [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17],
1590 self.assertEqual(exp2[i],list(it.getValues()));
1595 def testBuildOrthogonalField(self):
1596 targetMesh=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1597 field=targetMesh.buildOrthogonalField();
1598 expected=[0.70710678118654746,0.,-0.70710678118654746]
1599 self.assertEqual(5,field.getNumberOfTuples());
1600 self.assertEqual(3,field.getNumberOfComponents());
1601 vals=field.getArray().getValues();
1603 self.assertTrue(abs(expected[i%3]-vals[i])<1e-12);
1605 targetCoords=[0.,0.,0.,0.5,0.,0.5,1.,0.,1.,0.,1.,0.]
1606 targetConn=[0,1,2,3]
1607 targetMesh=MEDCouplingUMesh.New();
1608 targetMesh.setMeshDimension(2);
1609 targetMesh.allocateCells(1);
1610 targetMesh.insertNextCell(NORM_QUAD4,targetConn[0:4])
1611 targetMesh.finishInsertingCells();
1612 myCoords=DataArrayDouble.New();
1613 myCoords.setValues(targetCoords,4,3);
1614 targetMesh.setCoords(myCoords);
1615 field=targetMesh.buildOrthogonalField();
1616 self.assertEqual(1,field.getNumberOfTuples());
1617 self.assertEqual(3,field.getNumberOfComponents());
1618 vals=field.getArray().getValues();
1619 self.assertTrue(abs(-0.70710678118654746-vals[0])<1e-12);
1620 self.assertTrue(abs(0.-vals[1])<1e-12);
1621 self.assertTrue(abs(0.70710678118654746-vals[2])<1e-12);
1624 def testGetCellsContainingPoint(self):
1625 targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1626 pos=[0.,0.,0.4,0.4,0.,0.4,0.1,0.1,0.25,0.,0.65,0.]
1628 t1,t2=targetMesh.getCellsContainingPoints(pos,6,1e-12);
1629 self.assertEqual(6,t1.getNumberOfTuples());
1630 self.assertEqual(1,t1.getNumberOfComponents());
1631 self.assertEqual(7,t2.getNumberOfTuples());
1632 self.assertEqual(1,t2.getNumberOfComponents());
1633 expectedValues1=[0,4,3,0,1,2]
1634 expectedValues2=[0,1,2,3,4,5,6]
1635 self.assertEqual(list(t1.getValues()),expectedValues1);
1636 self.assertEqual(list(t2.getValues()),expectedValues2);
1637 #2D with no help of bounding box.
1639 MEDCouplingPointSet.Rotate2DAlg(center,0.78539816339744830962,6,pos);
1640 targetMesh.rotate(center,0.78539816339744830962);
1643 t1,t2=targetMesh.getCellsContainingPoints(pos,1e-12);
1644 self.assertEqual(6,t1.getNumberOfTuples());
1645 self.assertEqual(7,t2.getNumberOfTuples());
1646 self.assertEqual(list(t1.getValues()),expectedValues1);
1647 self.assertEqual(list(t2.getValues()),expectedValues2);
1648 t1,t2=targetMesh.getCellsContainingPoints(DataArrayDouble.New(pos,6,2),1e-12);
1649 self.assertEqual(6,t1.getNumberOfTuples());
1650 self.assertEqual(7,t2.getNumberOfTuples());
1651 self.assertEqual(list(t1.getValues()),expectedValues1);
1652 self.assertEqual(list(t2.getValues()),expectedValues2);
1653 self.assertRaises(InterpKernelException,targetMesh.getCellsContainingPoints,DataArrayDouble.New(pos,4,3),1e-12);
1655 pos1bis=[-0.3303300858899107,-0.11819805153394641]
1656 self.assertEqual(-1,targetMesh.getCellContainingPoint(pos1bis,1e-12));
1658 targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1661 t1=targetMesh.getCellsContainingPoint(pos2,1e-12)
1662 self.assertEqual(2,len(t1));
1663 expectedValues3=[0,1]
1664 self.assertEqual(list(t1.getValues()),expectedValues3);
1667 t1=targetMesh.getCellsContainingPoint(pos3,1e-12);
1668 self.assertEqual(5,len(t1));
1669 expectedValues4=[0,1,2,3,4]
1670 self.assertEqual(list(t1.getValues()),expectedValues4);
1671 self.assertEqual(0,targetMesh.getCellContainingPoint(pos3,1e-12));
1673 targetMesh=MEDCouplingDataForTest.build3DTargetMesh_1();
1675 self.assertEqual(0,targetMesh.getCellContainingPoint(pos4,1e-12));
1678 t1=targetMesh.getCellsContainingPoint(pos5,1e-12);
1679 self.assertEqual(8,len(t1));
1680 expectedValues5=[0,1,2,3,4,5,6,7]
1681 self.assertEqual(list(t1.getValues()),expectedValues5);
1684 t1=targetMesh.getCellsContainingPoint(pos6,1e-12);
1685 self.assertEqual(2,len(t1));
1686 expectedValues6=[0,2]
1687 self.assertEqual(list(t1.getValues()),expectedValues6);
1690 self.assertEqual(-1,targetMesh.getCellContainingPoint(pos7,1e-12));
1694 targetMesh.rotate(center2,vec2,0.78539816339744830962);
1696 self.assertEqual(-1,targetMesh.getCellContainingPoint(pos8,1e-12));
1699 def testGetValueOn1(self):
1700 targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1701 fieldOnCells=MEDCouplingFieldDouble.New(ON_CELLS);
1702 nbOfCells=targetMesh.getNumberOfCells();
1703 fieldOnCells.setMesh(targetMesh);
1704 array=DataArrayDouble.New();
1705 tmp=2*nbOfCells*[None]
1706 for i in range(nbOfCells):
1707 tmp[2*i]=7.+float(i);
1708 tmp[2*i+1]=17.+float(i)
1710 array.setValues(tmp,nbOfCells,2);
1711 fieldOnCells.setArray(array);
1714 res=fieldOnCells.getValueOn(pos1);
1715 self.assertEqual(2,len(res))
1716 self.assertTrue(abs(8.-res[0])<1e-12);
1717 self.assertTrue(abs(18.-res[1])<1e-12);
1720 targetMesh=MEDCouplingDataForTest.build2DSourceMesh_1();
1721 fieldOnNodes=MEDCouplingFieldDouble.New(ON_NODES);
1722 nbOfNodes=targetMesh.getNumberOfNodes();
1723 fieldOnNodes.setMesh(targetMesh);
1724 array=DataArrayDouble.New();
1725 tmp=2*nbOfNodes*[None]
1726 for i in range(nbOfNodes):
1727 tmp[2*i]=17.+float(i);
1728 tmp[2*i+1]=27.+float(i)
1730 array.setValues(tmp,nbOfNodes,2);
1731 fieldOnNodes.setArray(array);
1733 pos2=[-0.13333333333333333,-0.13333333333333333]
1735 res=fieldOnNodes.getValueOn(pos2);
1736 self.assertEqual(2,len(res))
1737 self.assertTrue(abs(17.5-res[0])<1e-12);
1738 self.assertTrue(abs(27.5-res[1])<1e-12);
1739 pos3=[0.033333333333333326,0.36666666666666664]
1741 res=fieldOnNodes.getValueOn(pos3);
1742 self.assertEqual(2,len(res))
1743 self.assertTrue(abs(18.666666666666667-res[0])<1e-12);
1744 self.assertTrue(abs(28.666666666666667-res[1])<1e-12);
1747 def testCMesh0(self):
1748 mesh=MEDCouplingCMesh.New();
1749 meshEmpty=mesh.clone(True);
1750 self.assertTrue(meshEmpty.isEqual(mesh, 1e-12));
1752 coordsX=DataArrayDouble.New();
1753 arrX=[ -1., 1., 2., 4. ]
1754 coordsX.setValues(arrX, 4, 1);
1755 coordsY=DataArrayDouble.New();
1756 arrY=[ -2., 2., 4., 8. ]
1757 coordsY.setValues(arrY, 4, 1);
1758 coordsZ=DataArrayDouble.New();
1759 arrZ=[ -3., 3., 6., 12. ]
1760 coordsZ.setValues(arrZ, 4, 1);
1761 mesh.setCoords(coordsX, coordsY, coordsZ);
1763 fieldOnNodes=mesh.fillFromAnalytic(ON_NODES, 1, "x+y/2.+z/3.");
1764 self.assertEqual(1, fieldOnNodes.getNumberOfComponents());
1765 self.assertEqual(64, fieldOnNodes.getNumberOfTuples());
1766 expected1=[-3., -1., 0., 2., -1., 1., 2., 4., 0., 2., 3., 5., 2., 4., 5., 7., -1., 1., 2.,
1767 4., 1., 3., 4., 6., 2., 4., 5., 7., 4., 6., 7., 9., 0., 2., 3., 5., 2., 4., 5.,
1768 7., 3., 5., 6., 8., 5., 7., 8., 10., 2., 4., 5.,
1769 7., 4., 6., 7., 9., 5., 7., 8., 10., 7., 9., 10., 12.];
1771 val=fieldOnNodes.getArray().getValues();
1773 self.assertAlmostEqual(expected1[i], val[i], 12)
1774 res=fieldOnNodes.getValueOnPos(1, 3, 2);
1775 self.assertAlmostEqual(7., res[0], 12);
1777 fieldOnCells=mesh.fillFromAnalytic(ON_CELLS, 1, "x+y/2.+z/3.");
1778 self.assertEqual(1, fieldOnCells.getNumberOfComponents());
1779 self.assertEqual(27, fieldOnCells.getNumberOfTuples());
1780 val=fieldOnCells.getArray().getValues();
1781 expected2=[0, 1.5, 3, 1.5, 3, 4.5, 3, 4.5, 6, 1.5, 3, 4.5, 3, 4.5,
1782 6, 4.5, 6, 7.5, 3, 4.5, 6, 4.5, 6, 7.5, 6, 7.5, 9];
1784 self.assertAlmostEqual(expected2[i], val[i], 12);
1785 #res=fieldOnCells.getValueOnPos(1,2,1);
1786 #self.assertAlmostEqual(6.,res,12);
1788 meshDeepCopy=mesh.deepCopy();
1789 meshClone=mesh.clone(False);
1791 meshEmpty.copyTinyStringsFrom(mesh);
1792 #no data in meshEmpty, expected False
1793 self.assertTrue(not meshEmpty.isEqual(mesh, 1e-12));
1795 self.assertTrue(meshDeepCopy.isEqual(mesh, 1e-12));
1796 meshDeepCopy.copyTinyStringsFrom(mesh);
1797 self.assertTrue(meshDeepCopy.isEqual(mesh, 1e-12));
1798 self.assertTrue(meshClone.isEqual(mesh, 1e-12));
1800 self.assertEqual(CARTESIAN, mesh.getType());
1801 self.assertEqual(CARTESIAN, meshEmpty.getType());
1802 self.assertEqual(CARTESIAN, meshDeepCopy.getType());
1803 self.assertEqual(CARTESIAN, meshClone.getType());
1806 def testCMesh1(self):
1807 mesh1=MEDCouplingCMesh.New();
1808 coordsX1=DataArrayDouble.New();
1809 arrX1=[ -1., 1., 2., 4. ]
1810 coordsX1.setValues(arrX1, 4, 1);
1811 coordsY1=DataArrayDouble.New();
1812 arrY1=[ -2., 2., 4., 8. ]
1813 coordsY1.setValues(arrY1, 4, 1);
1814 coordsZ1=DataArrayDouble.New();
1815 arrZ1=[ -3., 3., 6., 12. ]
1816 coordsZ1.setValues(arrZ1, 4, 1);
1817 mesh1.setCoords(coordsX1, coordsY1, coordsZ1);
1819 mesh2=MEDCouplingCMesh.New();
1820 coordsX2=DataArrayDouble.New();
1821 arrX2=[ -1., 1., 2., 4. ]
1822 coordsX2.setValues(arrX2, 4, 1);
1823 coordsY2=DataArrayDouble.New();
1824 arrY2=[ -2., 2., 4., 8. ]
1825 coordsY2.setValues(arrY2, 4, 1);
1826 coordsZ2=DataArrayDouble.New();
1827 arrZ2=[ -3., 3., 6., 12.+1e-6 ]
1828 coordsZ2.setValues(arrZ2, 4, 1);
1829 mesh2.setCoords(coordsX2, coordsY2, coordsZ2);
1831 mesh3=MEDCouplingCMesh.New();
1832 coordsX3=DataArrayDouble.New();
1834 coordsX3.setValues(arrX3, 1, 1);
1835 coordsY3=DataArrayDouble.New();
1837 coordsY3.setValues(arrY3, 1, 1);
1838 coordsZ3=DataArrayDouble.New();
1840 coordsZ3.setValues(arrZ3, 1, 1);
1841 mesh3.setCoords(coordsX3, coordsY3, coordsZ3);
1843 self.assertEqual(3, mesh1.getSpaceDimension());
1844 self.assertEqual(3, mesh1.getMeshDimension());
1846 self.assertTrue(not mesh1.isEqual(mesh2, 1e-12));
1847 self.assertTrue(not mesh2.isEqual(mesh1, 1e-12));
1848 self.assertTrue(not mesh2.isEqualWithoutConsideringStr(mesh1, 1e-12));
1849 self.assertTrue(mesh1.isEqual(mesh2, 1e-5));
1850 self.assertTrue(not mesh1.isEqual(mesh2, 1e-7));
1852 self.assertRaises(InterpKernelException, mesh3.checkConsistency, 1e-12);
1853 mesh1.checkConsistency(1e-12);
1854 self.assertEqual(NORM_HEXA8, mesh1.getTypeOfCell(1));
1856 self.assertEqual(NORM_HEXA8, mesh1.getAllGeoTypes()[0]);
1857 self.assertEqual(27, mesh1.getNumberOfCellsWithType(NORM_HEXA8));
1858 self.assertRaises(InterpKernelException, mesh1.getNumberOfCellsWithType, NORM_QUAD4);
1860 coo=mesh1.getCoordinatesOfNode(0);
1861 self.assertEqual(3, len(coo));
1862 self.assertAlmostEqual(-1., coo[0], 14);
1863 self.assertAlmostEqual(-2., coo[1], 14);
1864 self.assertAlmostEqual(-3., coo[2], 14);
1865 coo=mesh1.getCoordinatesOfNode(63);
1866 self.assertEqual(3, len(coo));
1867 self.assertAlmostEqual(4., coo[0], 14);
1868 self.assertAlmostEqual(8., coo[1], 14);
1869 self.assertAlmostEqual(12., coo[2], 14);
1872 repr=mesh1.simpleRepr();
1873 repr=mesh1.advancedRepr();
1874 self.assertTrue("Cartesian" in repr);
1875 self.assertTrue("Number of components : 1" in repr);
1876 self.assertTrue("Number of tuples : 4" in repr);
1877 self.assertTrue("Z Array :" in repr);
1880 def testCMesh2(self):
1881 mesh1=MEDCouplingCMesh.New();
1882 coordsX1=DataArrayDouble.New();
1883 arrX1=[ -1., 1., 2., 4. ]
1884 coordsX1.setValues(arrX1, 4, 1);
1885 coordsY1=DataArrayDouble.New();
1886 arrY1=[ -2., 2., 4., 8. ]
1887 coordsY1.setValues(arrY1, 4, 1);
1888 coordsZ1=DataArrayDouble.New();
1889 arrZ1=[ -3., 3., 6., 12. ]
1890 coordsZ1.setValues(arrZ1, 4, 1);
1891 mesh1.setCoords(coordsX1, coordsY1, coordsZ1);
1893 dis=mesh1.getDistributionOfTypes();
1894 self.assertEqual(1, len(dis));
1895 self.assertEqual(NORM_HEXA8, dis[0][0]);
1896 self.assertEqual(27, dis[0][1]);
1897 self.assertEqual(-1, dis[0][2]);
1900 self.assertTrue(not mesh1.checkTypeConsistencyAndContig(dis, idsPerType));
1901 dis[0][0]=NORM_QUAD4;
1902 self.assertRaises(InterpKernelException, mesh1.checkTypeConsistencyAndContig, dis, idsPerType);
1903 dis[0][0]=NORM_HEXA8;
1905 ids=DataArrayInt.New();
1907 ids.fillWithValue(23);
1909 check=mesh1.checkTypeConsistencyAndContig(dis, idsPerType);
1910 self.assertTrue(check);
1911 self.assertTrue(check.isEqual(ids));
1913 code, idsInPflPerType, pfls=mesh1.splitProfilePerType(ids);
1914 self.assertEqual(1, len(code));
1915 self.assertEqual(NORM_HEXA8, code[0][0]);
1916 self.assertEqual(10, code[0][1]);
1917 self.assertEqual(0, code[0][2]);
1918 self.assertEqual(1, len(idsInPflPerType));
1919 self.assertEqual(1, len(pfls));
1920 self.assertTrue(idsInPflPerType[0].isEqual(DataArrayInt([0,1,2,3,4,5,6,7,8,9])));
1921 self.assertTrue(pfls[0].isEqual(ids));
1923 cells1=[0, 1, 25, 26]
1924 partMesh1=mesh1.buildPart(cells1)
1925 self.assertTrue(isinstance(partMesh1,MEDCouplingMesh))
1926 self.assertEqual(4, partMesh1.getNumberOfCellsWithType(NORM_HEXA8));
1927 self.assertEqual(64, mesh1.getNumberOfNodes());
1928 self.assertEqual(64, partMesh1.getNumberOfNodes());
1931 partMesh2, arr1=mesh1.buildPartAndReduceNodes(cells2)
1932 self.assertTrue(isinstance(partMesh2,MEDCouplingCMesh))
1933 self.assertEqual(2,partMesh2.getNumberOfCellsWithType(NORM_HEXA8));
1934 self.assertEqual(12,partMesh2.getNumberOfNodes());
1937 partMesh3, arr2=partMesh1.buildPartAndReduceNodes(cells3)
1938 self.assertTrue(isinstance(partMesh3,MEDCouplingUMesh))
1939 self.assertEqual(2, partMesh3.getNumberOfCellsWithType(NORM_HEXA8));
1940 self.assertEqual(12, partMesh3.getNumberOfNodes());
1942 self.assertRaises(InterpKernelException, mesh1.simplexize, 0);
1943 self.assertRaises(InterpKernelException, mesh1.getMeasureFieldOnNode, True);
1947 bbox1=mesh1.getBoundingBox(); #[(-1.0, 4.0), (-2.0, 8.0), (-3.0, 12.0)]
1948 bbox2=partMesh1.getBoundingBox();
1949 self.assertTrue(bbox1==bbox2);
1950 bbox1=partMesh3.getBoundingBox();
1951 bbox2=partMesh2.getBoundingBox();
1952 self.assertTrue(bbox1==bbox2);
1954 self.assertRaises(InterpKernelException, mesh1.buildOrthogonalField);
1955 mesh2d=MEDCouplingCMesh.New();
1956 mesh2d.setCoords(coordsX1, coordsY1);
1957 f1=mesh2d.buildOrthogonalField();
1961 def testScale(self):
1962 mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1964 mesh.scale(pos,0.5);
1965 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,
1966 -0.05,0.45, 0.2,0.45, 0.45,0.45]
1967 val=mesh.getCoords().getValues();
1968 self.assertEqual(18,len(val))
1970 self.assertTrue(abs(expected1[i]-val[i])<1e-12);
1974 def testTryToShareSameCoords(self):
1975 m1=MEDCouplingDataForTest.build2DTargetMesh_1();
1976 m2=MEDCouplingDataForTest.build2DTargetMesh_1();
1977 self.assertTrue(m1.getCoords().getHiddenCppPointer()!=m2.getCoords().getHiddenCppPointer());
1978 m1.tryToShareSameCoords(m2,1e-12);
1979 self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1980 m1.tryToShareSameCoords(m2,1e-12);
1981 self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1982 m2.tryToShareSameCoords(m1,1e-12);
1983 self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1985 m1=MEDCouplingDataForTest.build2DTargetMesh_1();
1986 m2=MEDCouplingDataForTest.build2DTargetMesh_2();
1987 self.assertTrue(m1.getCoords().getHiddenCppPointer()!=m2.getCoords().getHiddenCppPointer());
1988 m1.tryToShareSameCoords(m2,1e-12);
1989 self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1990 m1.tryToShareSameCoords(m2,1e-12);
1991 self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1992 m2.tryToShareSameCoords(m1,1e-12);
1993 self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1995 m1=MEDCouplingDataForTest.build2DTargetMesh_1();
1996 m2=MEDCouplingDataForTest.build2DSourceMesh_1();
1997 self.assertTrue(m1.getCoords().getHiddenCppPointer()!=m2.getCoords().getHiddenCppPointer());
1998 self.assertRaises(InterpKernelException,m1.tryToShareSameCoords,m2,1e-12)
2001 def testFindNodeOnPlane(self):
2002 mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
2005 n=mesh.findNodesOnPlane(pt,v,1e-12);
2006 self.assertEqual(9,len(n));
2007 m3dSurf=mesh.buildFacePartOfMySelfNode(n,True);
2008 self.assertTrue(isinstance(m3dSurf,MEDCouplingUMesh))
2009 me=MEDCouplingMappedExtrudedMesh.New(mesh,m3dSurf,0);
2010 da=me.getMesh3DIds();
2011 self.assertEqual(8,me.getNumberOfCells());
2012 expected=[0,1,2,3,4,5,6,7]
2014 self.assertEqual(expected,list(val));
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));
2026 def testRenumberCells(self):
2027 m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2028 m2=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2029 self.assertTrue(m.isEqual(m2,0));
2031 m.renumberCells(arr,True);
2032 self.assertTrue(not m.isEqual(m2,0));
2033 self.assertEqual(NORM_QUAD4,m.getTypeOfCell(0));
2034 self.assertEqual(NORM_TRI3,m.getTypeOfCell(1));
2035 self.assertEqual(NORM_QUAD4,m.getTypeOfCell(2));
2036 self.assertEqual(NORM_TRI3,m.getTypeOfCell(3));
2037 self.assertEqual(NORM_QUAD4,m.getTypeOfCell(4));
2039 m.renumberCells(arr2,True);
2040 self.assertTrue(m.isEqual(m2,0));
2043 def testChangeSpaceDimension(self):
2044 m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2045 m2=MEDCouplingDataForTest.build2DTargetMesh_1();
2047 self.assertEqual(3,m1.getSpaceDimension());
2048 m1.changeSpaceDimension(2);
2049 self.assertEqual(2,m1.getSpaceDimension());
2050 m1.setName(m2.getName());
2051 self.assertTrue(m1.isEqual(m2,1e-12));
2052 m1.changeSpaceDimension(3);
2053 self.assertEqual(3,m1.getSpaceDimension());
2054 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.]
2055 val=m1.getCoords().getValues();
2057 self.assertTrue(abs(expected[i]-val[i])<1e-14);
2061 def testGaussPointField1(self):
2062 _a=0.446948490915965;
2063 _b=0.091576213509771;
2064 _p1=0.11169079483905;
2065 _p2=0.0549758718227661;
2066 refCoo1=[ 0.,0., 1.,0., 0.,1. ]
2067 gsCoo1=[ 2*_b-1, 1-4*_b, 2*_b-1, 2.07*_b-1, 1-4*_b,
2068 2*_b-1, 1-4*_a, 2*_a-1, 2*_a-1, 1-4*_a, 2*_a-1, 2*_a-1 ]
2069 wg1=[ 4*_p2, 4*_p2, 4*_p2, 4*_p1, 4*_p1, 4*_p1 ]
2074 m=MEDCouplingDataForTest.build2DTargetMesh_1();
2075 f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,NO_TIME);
2077 self.assertEqual(5,f.getNumberOfMeshPlacesExpected());
2078 self.assertEqual(0,f.getNbOfGaussLocalization());
2079 f.setGaussLocalizationOnType(NORM_TRI3,_refCoo1,_gsCoo1,_wg1);
2080 f.setGaussLocalizationOnType(NORM_TRI3,_refCoo1,_gsCoo1,_wg1); # not a bug only to check that it works well
2081 self.assertRaises(InterpKernelException,f.setGaussLocalizationOnType,NORM_QUAD4,_refCoo1,_gsCoo1,_wg1)
2082 self.assertEqual(1,f.getNbOfGaussLocalization());
2083 refCoo2=[ 0.,0., 1.,0., 1.,1., 0.,1. ]
2085 _gsCoo1=_gsCoo1[0:4]
2087 f.setGaussLocalizationOnType(NORM_QUAD4,_refCoo2,_gsCoo1,_wg1);
2088 self.assertEqual(2,f.getNbOfGaussLocalization());
2089 array=DataArrayDouble.New();
2091 for i in range(18 * 2):
2093 array.setValues(ptr,18,2);
2094 ptr=array.getPointer();
2096 f.setName("MyFirstFieldOnGaussPoint");
2097 f.checkConsistencyLight();
2098 self.assertAlmostEqual(27.,f.getIJK(2,5,0),14);
2099 self.assertAlmostEqual(16.,f.getIJK(1,5,1),14);
2101 f.clearGaussLocalizations();
2102 self.assertEqual(0,f.getNbOfGaussLocalization());
2103 self.assertRaises(InterpKernelException,f.checkConsistencyLight);
2105 self.assertRaises(InterpKernelException,f.setGaussLocalizationOnCells,ids1,_refCoo2,_gsCoo1,_wg1);
2106 self.assertEqual(0,f.getNbOfGaussLocalization());
2108 f.setGaussLocalizationOnCells(ids2,_refCoo2,_gsCoo1,_wg1);
2109 self.assertEqual(1,f.getNbOfGaussLocalization());
2110 self.assertEqual(0,f.getGaussLocalizationIdOfOneCell(0));
2111 self.assertRaises(InterpKernelException,f.getGaussLocalizationIdOfOneCell,1);
2113 f.setGaussLocalizationOnCells(ids3,_refCoo1,_gsCoo1,_wg1);
2114 self.assertEqual(2,f.getNbOfGaussLocalization());
2115 self.assertEqual(0,f.getGaussLocalizationIdOfOneCell(0));
2116 self.assertEqual(1,f.getGaussLocalizationIdOfOneCell(1));
2117 self.assertEqual(1,f.getGaussLocalizationIdOfOneCell(2));
2118 self.assertRaises(InterpKernelException,f.checkConsistencyLight);#<- cell 3 has no localization
2122 _gsCoo2[0]=0.8888777776666;
2123 _wg2[0]=0.1234567892377;
2124 f.setGaussLocalizationOnCells(ids4,_refCoo2,_gsCoo2,_wg2);
2125 self.assertEqual(3,f.getNbOfGaussLocalization());
2126 tmpIds=f.getCellIdsHavingGaussLocalization(0);
2127 self.assertEqual(ids2,list(tmpIds.getValues()));
2128 self.assertRaises(InterpKernelException,f.checkConsistencyLight);#<- it's always not ok because undelying array not with the good size.
2129 array2=f.getArray().subArray(0,10);
2131 f.checkConsistencyLight();#<- here it is OK
2133 self.assertTrue(f.isEqual(f2,1e-14,1e-14));
2134 gl1=f2.getGaussLocalization(0);
2135 tmp=gl1.getGaussCoord(1,1);
2136 self.assertAlmostEqual(2.07*_b-1,tmp,14);
2137 gl1.setGaussCoord(1,1,0.07);
2138 self.assertTrue(not f.isEqual(f2,1e-14,1e-14));
2139 gl1.setGaussCoord(1,1,tmp);
2140 self.assertTrue(f.isEqual(f2,1e-14,1e-14));
2141 f2.checkConsistencyLight();
2144 def testGaussPointNEField1(self):
2145 m=MEDCouplingDataForTest.build2DTargetMesh_1();
2146 f=MEDCouplingFieldDouble.New(ON_GAUSS_NE,NO_TIME);
2148 self.assertEqual(5,f.getNumberOfMeshPlacesExpected());
2149 f.setName("MyFirstFieldOnNE");
2150 f.setDescription("MyDescriptionNE");
2151 array=DataArrayDouble.New();
2153 for i in range(18 * 2):
2156 array.setValues(tmp,18,2);
2157 ptr=array.getPointer();
2160 f.checkConsistencyLight();
2162 self.assertTrue(f.isEqual(f2,1e-14,1e-14));
2163 self.assertAlmostEqual(21.,f.getIJK(2,0,0),14);
2164 self.assertAlmostEqual(18.,f.getIJK(1,1,1),14);
2167 def testCellOrientation1(self):
2168 m=MEDCouplingDataForTest.build2DTargetMesh_1();
2170 self.assertRaises(InterpKernelException,m.are2DCellsNotCorrectlyOriented,vec,False);
2171 m.changeSpaceDimension(3);
2172 res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2173 self.assertTrue(len(res1)==0);
2175 res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2176 self.assertEqual(5,len(res1));
2179 # connectivity inversion
2180 conn=m.getNodalConnectivity().getValues();
2184 m.getNodalConnectivity().setValues(conn,len(conn),1)
2185 res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2186 self.assertEqual(1,len(res1));
2187 self.assertEqual(2,res1.getValues()[0]);
2188 m.orientCorrectly2DCells(vec,False);
2189 res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2190 self.assertTrue(len(res1)==0);
2191 m2=MEDCouplingDataForTest.build2DTargetMesh_1();
2192 m2.changeSpaceDimension(3);
2193 self.assertTrue(m.isEqual(m2,1e-12));
2196 def testCellOrientation2(self):
2197 m2,m1=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
2198 res1=m2.arePolyhedronsNotCorrectlyOriented();
2199 self.assertEqual(6,len(res1));
2200 m2.orientCorrectlyPolyhedrons();
2201 res1=m2.arePolyhedronsNotCorrectlyOriented();
2202 self.assertTrue(len(res1)==0);
2203 m2.checkConsistencyLight();
2204 self.assertEqual(18,m2.getNumberOfCells());
2206 m2.convertToPolyTypes(cellIds2);
2207 m2.orientCorrectlyPolyhedrons();
2208 res1=m2.arePolyhedronsNotCorrectlyOriented();
2209 self.assertTrue(len(res1)==0);
2210 f2=m2.getMeasureField(False);
2211 f2Ptr=f2.getArray().getValues();
2212 #Test to check global reverse in MEDCouplingUMesh::tryToCorrectPolyhedronOrientation
2213 m3=MEDCouplingDataForTest.build2DTargetMesh_1();
2215 m3.changeSpaceDimension(3);
2217 m3.convertToPolyTypes(ids2);
2218 m3.orientCorrectly2DCells(vec,False);
2219 m4=MEDCouplingDataForTest.buildCU1DMesh_U();
2220 m4.changeSpaceDimension(3);
2223 m4.rotate(center,vector,-pi/2.);
2224 m5=m3.buildExtrudedMesh(m4,0);
2225 res1=m5.arePolyhedronsNotCorrectlyOriented();
2226 self.assertEqual(15,len(res1));
2227 m5.orientCorrectlyPolyhedrons();
2228 res1=m5.arePolyhedronsNotCorrectlyOriented();
2229 self.assertTrue(len(res1)==0);
2230 f3=m5.getMeasureField(False);
2231 self.assertEqual(15,f3.getArray().getNumberOfTuples());
2232 self.assertEqual(1,f3.getNumberOfComponents());
2233 f3Ptr=f3.getArray().getValues();
2234 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];
2236 self.assertTrue(abs(expected1[i]-f3Ptr[i])<1e-12);
2238 f4=m5.computeCellCenterOfMass();
2239 self.assertEqual(15,f4.getNumberOfTuples());
2240 self.assertEqual(3,f4.getNumberOfComponents());
2241 f4Ptr=f4.getValues();
2242 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];
2244 self.assertTrue(abs(expected2[i]-f4Ptr[i])<1e-12);
2248 def testCellOrientation3(self):
2249 from cmath import rect
2251 c = [rect(1.0, i * pi / 4.0) for i in range(8)]
2252 coords = [c[-1].real,c[-1].imag, c[3].real,c[3].imag,
2253 c[5].real,c[5].imag, c[1].real,c[1].imag]
2255 baseMesh = MEDCouplingUMesh.New("circle", 2)
2256 baseMesh.allocateCells(1)
2257 meshCoords = DataArrayDouble.New(coords, 4, 2)
2258 baseMesh.setCoords(meshCoords)
2259 baseMesh.insertNextCell(NORM_QPOLYG, connec) # a circle
2260 baseMesh.finishInsertingCells()
2261 baseMesh.changeSpaceDimension(3)
2262 Oz = [0.0, 0.0, -1.0]
2263 cell_lst = baseMesh.are2DCellsNotCorrectlyOriented(Oz, False)
2264 self.assertEqual(cell_lst.getNumberOfTuples(), 0)
2266 cell_lst = baseMesh.are2DCellsNotCorrectlyOriented(Oz, False)
2267 self.assertEqual(cell_lst.getNumberOfTuples(), 1)
2269 def testCellOrientation4(self):
2270 """ Non regression for NORM_QPOLYG whose linear version is self-intersecting. """
2271 mesh = MEDCouplingUMesh('merge', 2)
2272 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)])
2274 c = DataArrayInt([32, 9, 8, 6, 4, 0, 2, 10, 13, 1, 7, 5, 3, 11, 12])
2275 cI = DataArrayInt([0, 15])
2276 mesh.setConnectivity(c, cI)
2278 mesh.changeSpaceDimension(3)
2279 mesh.orientCorrectly2DCells(vec, False)
2280 mesh.changeSpaceDimension(2)
2281 cRef = [32, 9, 10, 2, 0, 4, 6, 8, 12, 11, 3, 5, 7, 1, 13]
2283 self.assertEqual(mesh.getNodalConnectivity().getValues(), cRef)
2284 self.assertEqual(mesh.getNodalConnectivityIndex().getValues(), cIRef)
2287 def testCellOrientation5(self):
2288 """ Non regression for NORM_QPOLYG """
2289 mesh = MEDCouplingUMesh('Mesh_3', 2)
2290 coo = DataArrayDouble([(-34.3035,5.1),(-35.2018,4.59163),(-34.9509,6.21985),(-35.0858,5.4072),(-34.7527,4.84582),(-34.6641,5.63857)])
2292 c = DataArrayInt([6, 2, 1, 0, 3, 4, 5])
2293 cI = DataArrayInt([0, 7])
2294 mesh.setConnectivity(c, cI)
2296 mesh.changeSpaceDimension(3)
2297 mesh.orientCorrectly2DCells(vec, False)
2298 mesh.changeSpaceDimension(2)
2299 cRef = [6, 2, 0, 1, 5, 4, 3]
2301 self.assertEqual(mesh.getNodalConnectivity().getValues(), cRef)
2302 self.assertEqual(mesh.getNodalConnectivityIndex().getValues(), cIRef)
2303 # Second call doest not change anything:
2304 mesh.changeSpaceDimension(3)
2305 mesh.orientCorrectly2DCells(vec, False)
2306 mesh.changeSpaceDimension(2)
2307 self.assertEqual(mesh.getNodalConnectivity().getValues(), cRef)
2308 self.assertEqual(mesh.getNodalConnectivityIndex().getValues(), cIRef)
2311 def testCellOrientation6(self):
2312 # CCTP 2.3.1 (bos #26452)
2313 mesh = MEDCouplingUMesh('Orientation', 3)
2314 coo = [0,0,0, 0,10,0, 10,0,0, 10,10,0, -10,0,0, -10,10,-0, 0,0,10, 10,0,10, -10,0,10, 0,-10,0, 10,-10,0, -10,-10,0, 0,5,0, 5,0,0, 10,5,0, 5,10,0, -5,0,-0, -10,5,-0, -5,10,-0, 0,0,5, 10,0,5, 5,0,10, -10,0,5, -5,0,10, 0,-5,0, 10,-5,0, 5,-10,0, -10,-5,0, -5,-10,0, 5,5,0, -5,5,-0, 5,0,5, -5,0,5, 5,-5,0, -5,-5,0]
2315 meshCoords = DataArrayDouble.New(coo, 35, 3)
2316 mesh.setCoords(meshCoords)
2317 mesh.setMeshDimension( 2 )
2318 conn = [ 1,12,29,15, 15,29,14, 3, 12, 0,13,29, 29,13, 2,14, 1,12,30,18, 18,30,17, 5, 12, 0,16,30, 30,16, 4,17, 6,19,31,21, 21,31,20, 7, 19, 0,13,31, 31,13, 2,20, 6,19,32,23, 23,32,22, 8, 19, 0,16,32, 32,16, 4,22, 9,24,33,26, 26,33,25,10, 24, 0,13,33, 33,13, 2,25, 9,24,34,28, 28,34,27,11, 24, 0,16,34, 34,16, 4,27]
2319 mesh.allocateCells(24)
2321 mesh.insertNextCell(NORM_QUAD4,4,conn[4*i:4*(i+1)]);
2322 mesh.finishInsertingCells()
2323 Group_1 = list( range( 0, 4 ))
2324 Group_2 = list( range( 4, 8 ))
2325 Group_3 = list( range( 8, 12 ))
2326 Group_5 = list( range( 16, 20 ))
2328 Group_8 = list( range( 12, 16 ))
2330 # example 1.1 - check failure on non-manifold
2331 objMesh = mesh.buildPartOfMySelf( Group_1 + Group_3 + Group_5 )
2332 refMesh = mesh.buildPartOfMySelf( Group_1 )
2333 self.assertRaisesRegex(Exception, "Non-manifold",
2334 objMesh.orientCorrectly2DCells, refMesh )
2336 # - do nothing, as request "de non-appartenance de la reference a la cible" dropped
2338 # example 1.3 - fix orientation of Group_1 and Group_8
2339 objMesh = mesh.buildPartOfMySelf( Group_1 + Group_2 + Group_7 + Group_8 )
2340 refMesh = mesh.buildPartOfMySelf( Group_7 )
2341 objMesh.orientCorrectly2DCells( refMesh )
2343 self.assertEqual( objMesh.getNodeIdsOfCell( 0 ), [ 1, 15, 29, 12 ])
2344 self.assertEqual( objMesh.getNodeIdsOfCell( 1 ), [ 15, 3, 14, 29 ])
2345 self.assertEqual( objMesh.getNodeIdsOfCell( 2 ), [ 12, 29, 13, 0 ])
2346 self.assertEqual( objMesh.getNodeIdsOfCell( 3 ), [ 29, 14, 2, 13 ])
2348 self.assertEqual( objMesh.getNodeIdsOfCell( 12 ), [ 6, 23, 32, 19 ])
2349 self.assertEqual( objMesh.getNodeIdsOfCell( 13 ), [ 23, 8, 22, 32 ])
2350 self.assertEqual( objMesh.getNodeIdsOfCell( 14 ), [ 19, 32, 16, 0 ])
2351 self.assertEqual( objMesh.getNodeIdsOfCell( 15 ), [ 32, 22, 4, 16 ])
2353 # Case with no reference given. Group_2 and Group_7 must reverse
2354 objMesh = mesh.buildPartOfMySelf( Group_1 + Group_2 + Group_7 + Group_8 )
2355 objMesh.orientCorrectly2DCells( None )
2357 self.assertEqual( objMesh.getNodeIdsOfCell( 4 ), [ 1, 18, 30, 12 ])
2358 self.assertEqual( objMesh.getNodeIdsOfCell( 5 ), [ 18, 5, 17, 30 ])
2359 self.assertEqual( objMesh.getNodeIdsOfCell( 6 ), [ 12, 30, 16, 0 ])
2360 self.assertEqual( objMesh.getNodeIdsOfCell( 7 ), [ 30, 17, 4, 16 ])
2362 self.assertEqual( objMesh.getNodeIdsOfCell( 8 ), [ 6, 21, 31, 19 ])
2363 self.assertEqual( objMesh.getNodeIdsOfCell( 9 ), [ 21, 7, 20, 31 ])
2364 self.assertEqual( objMesh.getNodeIdsOfCell( 10 ), [ 19, 31, 13, 0 ])
2365 self.assertEqual( objMesh.getNodeIdsOfCell( 11 ), [ 31, 20, 2, 13 ])
2367 # Case with differently oriented reference faces. Expect an exception
2368 objMesh = mesh.buildPartOfMySelf( Group_1 + Group_2 + Group_7 + Group_8 )
2369 refMesh = mesh.buildPartOfMySelf( Group_1 + Group_2 )
2370 self.assertRaisesRegex(Exception, "Different orientation",
2371 objMesh.orientCorrectly2DCells, refMesh )
2374 def testPolyhedronBarycenter(self):
2375 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];
2376 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];
2377 meshN=MEDCouplingUMesh.New();
2378 meshN.setName("ForBary");
2379 meshN.setMeshDimension(3);
2380 meshN.allocateCells(4);
2381 meshN.insertNextCell(NORM_POLYHED,29,connN[0:29])
2382 meshN.finishInsertingCells();
2383 myCoords=DataArrayDouble.New();
2384 myCoords.setValues(coords,9,3);
2385 meshN.setCoords(myCoords);
2386 meshN.checkConsistencyLight();
2388 res1=meshN.arePolyhedronsNotCorrectlyOriented();
2389 meshN.orientCorrectlyPolyhedrons();
2390 self.assertTrue(len(res1)==0);
2391 da=meshN.computeCellCenterOfMass();
2392 self.assertEqual(1,da.getNumberOfTuples());
2393 self.assertEqual(3,da.getNumberOfComponents());
2394 daPtr=da.getValues();
2395 ref=meshN.getCoords().getValues()[24:];
2397 self.assertTrue(abs(ref[i]-daPtr[i])<1e-12);
2402 da=meshN.computeCellCenterOfMass();
2403 daPtr=da.getValues();
2404 ref=meshN.getCoords().getValues()[24:];
2406 self.assertTrue(abs(ref[i]-daPtr[i])<1e-12);
2409 meshN.rotate(center,vec,pi/7.);
2410 meshN.translate(vec);
2411 da=meshN.computeCellCenterOfMass();
2412 daPtr=da.getValues();
2413 ref=meshN.getCoords().getValues()[24:];
2415 self.assertTrue(abs(ref[i]-daPtr[i])<1e-12);
2418 center2=[1.12,3.45,6.78]
2420 meshN.rotate(center2,vec2,e);
2421 meshN.translate(vec2);
2422 da=meshN.computeCellCenterOfMass();
2423 daPtr=da.getValues();
2424 ref=meshN.getCoords().getValues()[24:];
2426 self.assertTrue(abs(ref[i]-daPtr[i])<1e-10);
2430 def testNormL12Integ1D(self):
2431 m1=MEDCouplingDataForTest.build1DTargetMesh_3();
2432 f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2434 array=DataArrayDouble.New();
2435 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]
2436 array.setValues(arr,m1.getNumberOfCells(),3);
2439 f3=m1.computeCellCenterOfMass();
2440 self.assertEqual(4,f3.getNumberOfTuples());
2441 self.assertEqual(1,f3.getNumberOfComponents());
2442 expected9=[0.75,5.105,0.8,5.155]
2445 self.assertTrue(abs(expected9[i]-ptr[i])<1e-12);
2448 f2=m1.getMeasureField(False);
2449 self.assertEqual(4,f2.getArray().getNumberOfTuples());
2450 self.assertEqual(1,f2.getNumberOfComponents());
2451 expected1=[0.5,0.21,-0.6,-0.31]
2452 ptr=f2.getArray().getValues();
2454 self.assertTrue(abs(expected1[i]-ptr[i])<1e-12);
2456 expected2=[0.5,0.21,0.6,0.31]
2457 f2=m1.getMeasureField(True);
2458 ptr=f2.getArray().getValues();
2460 self.assertTrue(abs(expected2[i]-ptr[i])<1e-12);
2463 self.assertTrue(4,f1.getNumberOfTuples())
2464 res=f1.integral(False);
2465 self.assertTrue(3,len(res))
2466 expected3=[0.9866,-0.3615,0.4217]
2468 self.assertTrue(abs(expected3[i]-res[i])<1e-12);
2470 self.assertTrue(abs(expected3[0]-f1.integral(0,False))<1e-12);
2471 self.assertTrue(abs(expected3[1]-f1.integral(1,False))<1e-12);
2472 self.assertTrue(abs(expected3[2]-f1.integral(2,False))<1e-12);
2473 res=f1.integral(True);
2474 expected4=[-3.4152,8.7639,-14.6879]
2476 self.assertTrue(abs(expected4[i]-res[i])<1e-12);
2480 self.assertTrue(3,len(res))
2481 expected5=[6.979506172839505, 16.89018518518518, 27.02969135802469]
2483 self.assertTrue(abs(expected5[i]-res[i])<1e-12);
2485 self.assertTrue(abs(expected5[0]-f1.normL1(0))<1e-12);
2486 self.assertTrue(abs(expected5[1]-f1.normL1(1))<1e-12);
2487 self.assertTrue(abs(expected5[2]-f1.normL1(2))<1e-12);
2490 self.assertTrue(3,len(res))
2491 expected7=[7.090910979452395, 16.9275542960123, 27.053271464160858]
2493 self.assertTrue(abs(expected7[i]-res[i])<1e-9);
2495 self.assertTrue(abs(expected7[0]-f1.normL2(0))<1e-9);
2496 self.assertTrue(abs(expected7[1]-f1.normL2(1))<1e-9);
2497 self.assertTrue(abs(expected7[2]-f1.normL2(2))<1e-9);
2499 f4=f1.buildMeasureField(False);
2500 self.assertTrue(abs(-0.2-f4.accumulate(0))<1e-12);
2501 f4=f1.buildMeasureField(True);
2502 self.assertTrue(abs(1.62-f4.accumulate(0))<1e-12);
2503 # Testing with 2D Curve
2504 m1=MEDCouplingDataForTest.build2DCurveTargetMesh_3();
2505 f2=m1.getMeasureField(False);
2506 self.assertEqual(4,f2.getArray().getNumberOfTuples());
2507 self.assertEqual(1,f2.getNumberOfComponents());
2508 ptr=f2.getArray().getValues();
2510 self.assertTrue(abs(sqrt(2.)*expected2[i]-ptr[i])<1e-12);
2512 f2=m1.getMeasureField(True);
2513 self.assertEqual(4,f2.getArray().getNumberOfTuples());
2514 self.assertEqual(1,f2.getNumberOfComponents());
2515 ptr=f2.getArray().getValues();
2517 self.assertTrue(abs(expected2[i]*sqrt(2.)-ptr[i])<1e-12);
2520 f3=m1.computeCellCenterOfMass();
2521 self.assertEqual(4,f3.getNumberOfTuples());
2522 self.assertEqual(2,f3.getNumberOfComponents());
2523 expected10=[0.75,0.75,5.105,5.105,0.8,0.8,5.155,5.155]
2526 self.assertTrue(abs(expected10[i]-ptr[i])<1e-12);
2529 f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2531 array=DataArrayDouble.New();
2532 array.setValues(arr,m1.getNumberOfCells(),3);
2534 res=f1.integral(False);
2536 self.assertTrue(abs(sqrt(2.)*expected4[i]-res[i])<1e-12);
2538 res=f1.integral(True);
2540 self.assertTrue(abs(sqrt(2.)*expected4[i]-res[i])<1e-12);
2544 self.assertTrue(abs(expected5[i]-res[i])<1e-12);
2548 self.assertTrue(abs(expected7[i]-res[i])<1e-12);
2552 def testAreaBary2D(self):
2553 m1=MEDCouplingDataForTest.build2DTargetMesh_3();
2554 f1=m1.getMeasureField(False);
2555 self.assertEqual(10,f1.getArray().getNumberOfTuples());
2556 self.assertEqual(1,f1.getNumberOfComponents());
2557 expected1=[-0.5,-1,-1.5,-0.5,-1, 0.5,1,1.5,0.5,1]
2558 ptr=f1.getArray().getValues();
2560 self.assertTrue(abs(expected1[i]-ptr[i])<1e-12);
2562 f1=m1.getMeasureField(True);
2563 ptr=f1.getArray().getValues();
2565 self.assertTrue(abs(abs(expected1[i])-ptr[i])<1e-12);
2567 f2=m1.computeCellCenterOfMass();
2568 self.assertEqual(10,f2.getNumberOfTuples());
2569 self.assertEqual(2,f2.getNumberOfComponents());
2570 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]
2573 self.assertTrue(abs(expected2[i]-ptr[i])<1e-12);
2575 m1.changeSpaceDimension(3);
2576 f1=m1.getMeasureField(False);
2577 self.assertEqual(10,f1.getArray().getNumberOfTuples());
2578 self.assertEqual(1,f1.getNumberOfComponents());
2579 ptr=f1.getArray().getValues();
2581 self.assertTrue(abs(abs(expected1[i])-ptr[i])<1e-12);
2583 f2=m1.computeCellCenterOfMass();
2584 self.assertEqual(10,f2.getNumberOfTuples());
2585 self.assertEqual(3,f2.getNumberOfComponents());
2587 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.]
2589 self.assertTrue(abs(expected3[i]-ptr[i])<1e-12);
2593 def testAreaBary3D(self):
2594 coords=[ 0.241310763507 , 0.0504777305619 , 0.0682283524903 , 0.252501053866 , -0.0625176732937 , 0.137272639894 ,
2595 0.152262663601 , 0.241816569527 , 0.133812556197 , 0.18047750211 , -0.0789949051358 , 0.339098173401 ,
2596 0.151741971857 , 0.238885278571 , 0.137715037333 , 0.242532155481 , -0.0928169086456 , 0.0678043417367 ,
2597 0.240941965335 , -0.015461491464 , 0.0617186345825 , 0.24127650112 , 0.0499427876717 , 0.0679634099148 ,
2598 -0.145828917428 , 0.206291632565 , 0.0310071927543 , 0.0125651775307 , 0.266262085828 , 0.105228430543 ,
2599 -0.0994066533286 , 0.233224271238 , 0.0572213839567 , -0.0951345338317 , 0.234819509426 , 0.0592126284538 ,
2600 0.136580574205 , -0.205486212579 , 0.0572866072014 , 0.0637270784978 , -0.168886355238 , 0.446614057077 ,
2601 0.041337157151 , -0.213402568198 , 0.372407095999 , 0.0411601970268 , -0.202387875756 , 0.411334979491 ,
2602 -0.108355701857 , 0.193636239335 , 0.204886756738 , 0.00639779029829 , 0.155296981517 , 0.252585892979 ,
2603 0.0262473111702 , -0.112919732543 , 0.424286639249 ,-0.224103052733 , -0.139430015438 , -0.0122352295701 ,
2604 -0.0312760589481 , -0.274272003594 , 0.0323959636568 , -0.166663422532 , -0.217754445175 , 0.00392109070364 ,
2605 -0.30586619777 , -0.0475168041091 , -0.0144585228182 , -0.280881480586 , 0.135571293538 , 0.00623923647986 ,
2606 -0.25548538234 , 0.156819217766 , 0.0645277879769 , -0.131567009284 , 0.184133752309 , 0.206021802753 ,
2607 -0.196204010965 , 0.151602971681 , 0.212974777736 , -0.183713879463 , 0.0802946639531 , 0.260115662599 ,
2608 -0.244241178767 , -0.0738873389604 , 0.144590565817 , -0.155804057829 , -0.164892720025 , 0.210613950558 ,
2609 -0.170950800428 , -0.215099334026 , 0.00610122860092 , -0.30552634869 , -0.0490020791904 , -0.0132786533145 ,
2610 0.271831011884 , 0.15105657296 , 0.0230534827908 , 0.281919192283 , 0.0898544306288 , -0.0625201489143 ,
2611 0.260240727276 , -0.0120688706637 , -0.0532316588626 , 0.244947737722 , 0.0197984684293 , 0.0309341209233 ,
2612 0.23439631578 , 0.229825279875 , 0.0508520585381 , 0.160921316875 , 0.265078502128 , 0.121716560626 ,
2613 -0.315088694175 , 0.0747700471918 , -0.245836615071 , -0.327728781776 , 0.0857114674649 , -0.239431905957 ,
2614 -0.308385460634 , 0.145142997084 , -0.149886828433 , 0.0488236045164 , 0.309462801914 , 0.0849169148265 ,
2615 -0.0244964803395 , 0.33145611751 , -0.0476415818061 , 0.0060567994229 , 0.32418412014 , 0.0367779543812 ,
2616 -0.0950221448063 , 0.236675326003 , 0.0572594453983 , 0.248723023186 , 0.0886648784791 , -0.176629430538 ,
2617 0.116796984 , 0.256596599567 , -0.292863523603 , 0.118024552914 , 0.229154257843 , -0.34233232501 ,
2618 0.217507892549 , -0.0417822335742 , -0.176771782888 , -0.224429321304 , 0.0125595300114 , -0.362064725588 ,
2619 0.0937301100955 , -0.0500824832657 , -0.299713548444 , -0.244162220397 , 0.0383853931293 , -0.389856984411 ,
2620 -0.0281989366102 , 0.097392811563 , -0.458244577284 , -0.385010847162 , 0.10122766194 , -0.140052859922 ,
2621 -0.377936358012 , 0.110875172128 , -0.176207095463 , 0.244483045556 , -0.0991073977045 , 0.0575134372934 ,
2622 0.262605120167 , -0.100243191645 , -0.0495620806935 , 0.240306880972 , -0.136153701579 , -0.114745281696 ,
2623 0.215763176129 , -0.0836766059189 , -0.183249640616 , 0.237870396603 , -0.132449578286 , -0.121598854639 ,
2624 -0.0637683083097 , -0.27921020214 , -0.149112321992 , -0.0856211014977 , -0.2973233473 , -0.0446878139589 ,
2625 0.104675342288 , -0.0625908305324 , -0.290346256534 , 0.0248264249186 , -0.247797708548 , -0.165830884019 ,
2626 0.0719302438309 , -0.178468260473 , -0.211432157345 , 0.142871843159 , -0.208769948542 , 0.0454101128246 ,
2627 0.167803379307 , -0.207851396623 , -0.088802726124 , 0.12868717152 , -0.230920439715 , 0.00760508389036 ,
2628 -0.0372812069535 , -0.286740286332 , 0.00963701291166 ]
2630 connN = [ #polyhedron 0
2631 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
2632 , 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
2633 , 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
2634 , 22 , 19 , 21 , 30 , 31 , -1 , 22 , 31 , 28 , 27 , 26 , 24 , 23 , -1 , 31 , 30 , 29 , 28,
2636 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
2637 , 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
2638 , 33 , 34 , 48 , 45 , -1 , 35 , 34 , 48 , 50 , 49 , 38 , -1 , 41 , 43 , 42 , 46 , 36 , 37 , -1 , 38 , 39 , 51 , 49 , -1
2639 , 39 , 40 , 42 , 46 , 47 , 52 , 51 , -1 , 45 , 47 , 52 , 50 , 48 , -1 , 52 , 51 , 49 , 50,
2641 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
2642 , 23 , 53 , 54 , 40 , 8 , -1 , 53 , 22 , 23 , -1 , 39 , 54 , 40,
2644 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
2645 , 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
2646 , 55 , 5 , 12 , 65 , -1 , 66 , 67 , 65 , 55 , 56 , 57 , -1 , 63 , 66 , 57 , 59 , 64 , -1 , 64 , 62 , 58 , 59 , -1
2647 , 60 , 63 , 66 , 67 , 68 , 61 , -1 , 61 , 68 , 20 , 21 , -1 , 67 , 68 , 20 , 12 , 65]
2649 barys = [ -0.0165220465527 , -0.0190922868195 , 0.158882733414 ,
2650 0.0287618656076 , 0.135874379934 , -0.14601588119 ,
2651 -0.147128055553 , 0.0465995097041 , -0.049391174453 ,
2652 -0.00142506732317 , -0.0996953090351 , -0.115159183132 ]
2653 meshN=MEDCouplingUMesh.New();
2654 meshN.setName("ForBary");
2655 meshN.setMeshDimension(3);
2656 meshN.allocateCells(4);
2657 meshN.insertNextCell(NORM_POLYHED,113,connN);
2658 meshN.insertNextCell(NORM_POLYHED,99,connN[113:]);
2659 meshN.insertNextCell(NORM_POLYHED,43,connN[212:]);
2660 meshN.insertNextCell(NORM_POLYHED,92,connN[255:]);
2661 meshN.finishInsertingCells();
2662 myCoords=DataArrayDouble.New();
2663 myCoords.setValues(coords,69,3);
2664 meshN.setCoords(myCoords);
2665 meshN.checkConsistencyLight();
2666 res1=meshN.arePolyhedronsNotCorrectlyOriented();
2667 meshN.orientCorrectlyPolyhedrons();
2668 res1=meshN.arePolyhedronsNotCorrectlyOriented();
2669 self.assertTrue(len(res1)==0);
2671 da=meshN.computeCellCenterOfMass();
2672 self.assertEqual(4,da.getNumberOfTuples());
2673 self.assertEqual(3,da.getNumberOfComponents());
2674 daPtr=da.getValues();
2676 self.assertTrue(abs(barys[i]-daPtr[i])<1e-12);
2680 def testRenumberCellsForFields(self):
2681 m=MEDCouplingDataForTest.build2DTargetMesh_1();
2682 f=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2684 arr=DataArrayDouble.New();
2685 nbOfCells=m.getNumberOfCells();
2686 values1=[7.,107.,10007.,8.,108.,10008.,9.,109.,10009.,10.,110.,10010.,11.,111.,10011.]
2687 arr.setValues(values1,nbOfCells,3);
2689 renumber1=[3,1,0,4,2]
2690 loc=[-0.05,-0.05, 0.55,-0.25, 0.55,0.15, -0.05,0.45, 0.45,0.45]
2692 res=f.getValueOn(loc[2*j:2*j+2]);
2694 self.assertTrue(abs(values1[i+3*j]-res[i])<1e-12);
2697 f.renumberCells(renumber1,False);
2698 ptr=f.getArray().getValues();
2699 expected1=[9.,109.,10009.,8.,108.,10008.,11.,111.,10011.,7.,107.,10007.,10.,110.,10010.]
2701 self.assertTrue(abs(expected1[i]-ptr[i])<1e-12);
2703 #check that fields remains the same geometrically
2705 res=f.getValueOn(loc[2*j:2*(j+1)]);
2707 self.assertTrue(abs(values1[i+3*j]-res[i])<1e-12);
2711 f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,NO_TIME);
2713 _a=0.446948490915965;
2714 _b=0.091576213509771;
2715 _p1=0.11169079483905;
2716 _p2=0.0549758718227661;
2717 refCoo1=[ 0.,0., 1.,0., 0.,1. ]
2718 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 ];
2719 wg1=[ 4*_p2, 4*_p2, 4*_p2, 4*_p1, 4*_p1, 4*_p1 ]
2720 _refCoo1=refCoo1[0:6];
2721 _gsCoo1=gsCoo1[0:12];
2723 f.setGaussLocalizationOnType(NORM_TRI3,_refCoo1,_gsCoo1,_wg1);
2724 refCoo2=[ 0.,0., 1.,0., 1.,1., 0.,1. ]
2725 _refCoo2=refCoo2[0:8];
2726 _gsCoo1=_gsCoo1[0:4]
2728 f.setGaussLocalizationOnType(NORM_QUAD4,_refCoo2,_gsCoo1,_wg1);
2729 arr=DataArrayDouble.New();
2730 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.]
2731 arr.setValues(values2,18,2);
2733 f.checkConsistencyLight();
2735 self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2736 f.renumberCells(renumber1,False);
2737 self.assertTrue(not f.isEqual(fCpy,1e-12,1e-12));
2738 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.]
2739 ptr=f.getArray().getValues();
2741 self.assertTrue(abs(expected2[i]-ptr[i])<1e-12);
2743 renumber2=[2,1,4,0,3]
2744 f.renumberCells(renumber2,False);
2745 self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2747 f=MEDCouplingFieldDouble.New(ON_GAUSS_NE,NO_TIME);
2749 arr=DataArrayDouble.New();
2750 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.]
2751 arr.setValues(values3,18,2);
2753 f.checkConsistencyLight();
2755 self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2756 f.renumberCells(renumber1,False);
2757 self.assertTrue(not f.isEqual(fCpy,1e-12,1e-12));
2758 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.]
2759 ptr=f.getArray().getValues();
2761 self.assertTrue(abs(expected3[i]-ptr[i])<1e-12);
2763 f.renumberCells(renumber2,False);#perform reverse operation of renumbering to check that the resulting field is equal.
2764 self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2768 def testRenumberNodesForFields(self):
2769 m=MEDCouplingDataForTest.build2DTargetMesh_1();
2770 f=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
2772 self.assertEqual(9,f.getNumberOfMeshPlacesExpected());
2773 arr=DataArrayDouble.New();
2774 nbOfNodes=m.getNumberOfNodes();
2775 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.]
2776 arr.setValues(values1,nbOfNodes,3);
2778 f.checkConsistencyLight();
2779 renumber1=[0,4,1,3,5,2,6,7,8]
2780 loc=[0.5432,-0.2432, 0.5478,0.1528]
2781 expected1=[9.0272, 109.0272, 10009.0272, 11.4124,111.4124,10011.4124]
2783 res=f.getValueOn(loc[2*j:2*j+2]);
2785 self.assertTrue(abs(expected1[i+3*j]-res[i])<1e-12);
2789 self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2790 f.renumberNodes(renumber1);
2791 self.assertTrue(not f.isEqual(fCpy,1e-12,1e-12));
2793 res=f.getValueOn(loc[2*j:2*j+2]);
2795 self.assertTrue(abs(expected1[i+3*j]-res[i])<1e-12);
2798 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.]
2800 self.assertTrue(abs(expected2[i]-f.getArray().getValues()[i])<1e-12);
2802 renumber2=[0,2,5,3,1,4,6,7,8]
2803 f.renumberNodes(renumber2);
2804 self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2807 def testConvertQuadraticCellsToLinear(self):
2808 mesh=MEDCouplingDataForTest.build2DTargetMesh_3();
2809 mesh.checkConsistencyLight();
2810 types=mesh.getAllGeoTypes();
2812 self.assertEqual(5,len(types));
2813 expected1 = [NORM_POLYGON, NORM_TRI3, NORM_QUAD4, NORM_TRI6, NORM_QUAD8]
2815 self.assertEqual(expected1,types);
2816 self.assertTrue(mesh.isPresenceOfQuadratic());
2817 self.assertEqual(62,mesh.getNodalConnectivityArrayLen());
2818 f1=mesh.getMeasureField(False);
2820 mesh.convertQuadraticCellsToLinear();
2821 self.assertTrue(not mesh.isPresenceOfQuadratic());
2823 mesh.checkConsistencyLight();
2824 f2=mesh.getMeasureField(False);
2825 self.assertTrue(f1.getArray().isEqual(f2.getArray(),1e-12));
2826 self.assertEqual(48,mesh.getNodalConnectivityArrayLen());
2827 types2=mesh.getAllGeoTypes();
2829 self.assertEqual(3,len(types2));
2830 expected2=[NORM_POLYGON, NORM_TRI3, NORM_QUAD4]
2832 self.assertEqual(expected2,types2);
2835 def testCheckGeoEquivalWith(self):
2836 mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2837 mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2839 cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh1,0,1e-12);#deepEqual
2840 self.assertTrue(cellCor==None);
2841 self.assertTrue(nodeCor==None);
2842 cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh1,1,1e-12);#fastEqual
2843 self.assertTrue(cellCor==None);
2844 self.assertTrue(nodeCor==None);
2845 cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh1,10,1e-12);#deepEqual with geo permutations
2846 self.assertTrue(cellCor==None);
2847 self.assertTrue(nodeCor==None);
2848 #Second test mesh1 and mesh2 are 2 different meshes instance
2849 cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,0,1e-12);#deepEqual
2850 self.assertTrue(cellCor==None);
2851 self.assertTrue(nodeCor==None);
2852 cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,1,1e-12);#fastEqual
2853 self.assertTrue(cellCor==None);
2854 self.assertTrue(nodeCor==None);
2855 cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);#deepEqual with geo permutations
2856 self.assertTrue(cellCor==None);
2857 self.assertTrue(nodeCor==None);
2858 #Third test : cell permutation by keeping the first the middle and the last as it is.
2859 renum=[0,2,1,3,4,5,6,8,7,9]
2860 mesh2.renumberCells(renum,False);
2861 self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12);#deepEqual fails
2862 self.assertTrue(cellCor==None);
2863 self.assertTrue(nodeCor==None);
2864 cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,1,1e-12);#fastEqual do not see anything
2865 self.assertTrue(cellCor==None);
2866 self.assertTrue(nodeCor==None);
2867 cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);#deepEqual with geo permutations
2868 self.assertTrue(cellCor);
2869 self.assertEqual(10,cellCor.getNumberOfTuples());
2870 self.assertEqual(1,cellCor.getNumberOfComponents());
2871 self.assertEqual(renum,list(cellCor.getValues()))
2872 self.assertTrue(nodeCor==None);
2874 self.assertTrue(nodeCor==None);
2875 a,b=mesh1.checkDeepEquivalWith(mesh2,0,1e-12);
2876 self.assertEqual(renum,list(a.getValues()))
2877 self.assertTrue(b==None);
2878 mesh2.setCoords(mesh1.getCoords())
2879 a=mesh1.checkDeepEquivalOnSameNodesWith(mesh2,0,1e-12);
2880 self.assertEqual(renum,list(a.getValues()))
2881 #4th test : cell and node permutation by keeping the first the middle and the last as it is.
2882 mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2883 renum2=[0,2,1,3,4,5,6,8,7,9,10]
2884 mesh2.renumberCells(renum,False);
2885 mesh2.renumberNodes(renum2,11);
2888 self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12);#deepEqual fails
2889 self.assertTrue(cellCor==None);
2890 self.assertTrue(nodeCor==None);
2891 cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,1,1e-12);#fastEqual do not see anything
2892 self.assertTrue(cellCor==None);
2893 self.assertTrue(nodeCor==None);
2894 cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);#deepEqual with geo permutations
2895 self.assertTrue(cellCor);
2896 self.assertEqual(10,cellCor.getNumberOfTuples());
2897 self.assertEqual(1,cellCor.getNumberOfComponents());
2898 self.assertEqual(renum,list(cellCor.getValues()))
2899 self.assertTrue(nodeCor);
2900 self.assertEqual(11,nodeCor.getNumberOfTuples());
2901 self.assertEqual(1,nodeCor.getNumberOfComponents());
2902 self.assertEqual(renum2,list(nodeCor.getValues()))
2905 #5th test : modification of the last cell to check fastCheck detection.
2906 mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2907 renum3=[0,2,1,3,4,5,6,8,9,7]
2908 mesh2.renumberCells(renum3,False);
2909 mesh2.renumberNodes(renum2,11);
2912 self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12)
2913 self.assertTrue(cellCor==None);
2914 self.assertTrue(nodeCor==None);
2915 self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,1,1e-12)
2916 self.assertTrue(cellCor==None);
2917 self.assertTrue(nodeCor==None);
2918 cellCor,nodeCor=mesh2.checkGeoEquivalWith(mesh1,10,1e-12);#deepEqual with geo permutations
2919 self.assertTrue(cellCor!=None);
2920 self.assertEqual(10,cellCor.getNumberOfTuples());
2921 self.assertEqual(1,cellCor.getNumberOfComponents());
2922 self.assertEqual(renum3,list(cellCor.getValues()))
2923 self.assertTrue(nodeCor!=None);
2924 self.assertEqual(11,nodeCor.getNumberOfTuples());
2925 self.assertEqual(1,nodeCor.getNumberOfComponents());
2926 self.assertEqual(renum2,list(nodeCor.getValues()));
2929 def testCheckGeoEquivalWith2(self):
2930 mesh1=MEDCouplingDataForTest.build2DTargetMesh_4();
2931 mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
2932 cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);
2933 self.assertEqual(None,cellCor);
2934 self.assertNotEqual(None,nodeCor);
2935 expected1=[0, 1, 3, 4, 5, 6, 7, 8, 9]
2937 self.assertEqual(expected1[i],nodeCor.getIJ(i,0));
2941 def testSwig2CheckDeepEquivalWith1(self):
2943 mcart = MEDCouplingCMesh()
2944 mcart.setCoordsAt(0, DataArrayDouble([0.0,1.5,2.0]))
2945 mcart.setCoordsAt(1, DataArrayDouble([1.0,2.5,3.0,4.0]))
2946 m = mcart.buildUnstructured()
2947 m2 = m[1:m.getNumberOfCells()]
2948 self.assertRaises(InterpKernelException, m.checkDeepEquivalWith, m2, 0, eps)
2949 self.assertRaises(InterpKernelException, m.checkDeepEquivalWith, m2, 1, eps)
2950 self.assertRaises(InterpKernelException, m.checkDeepEquivalWith, m2, 2, eps)
2953 def testSwig2CheckDeepEquivalWith2(self):
2955 m = MEDCouplingUMesh("tst", 2)
2956 m.setCoords(DataArrayDouble([], 0,2))
2957 m.setConnectivity(DataArrayInt([]), DataArrayInt([0]))
2959 m.checkDeepEquivalWith(m2, 0, eps) # Should not raise!
2962 def testCopyTinyStringsFromOnFields(self):
2963 m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2964 nbOfCells=m.getNumberOfCells();
2965 f=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
2967 self.assertEqual(5,f.getNumberOfMeshPlacesExpected());
2969 f.setDescription("b");
2970 a1=DataArrayDouble.New();
2971 a1.alloc(nbOfCells,2);
2973 a1.setInfoOnComponent(0,"c");
2974 a1.setInfoOnComponent(1,"d");
2976 a2.setInfoOnComponent(0,"e");
2977 a2.setInfoOnComponent(1,"f");
2980 f.setEndTime(3.,3,4);
2982 m.getCoords().setInfoOnComponent(0,"h");
2983 m.getCoords().setInfoOnComponent(1,"i");
2984 m.getCoords().setInfoOnComponent(2,"j");
2986 f.checkConsistencyLight();
2988 self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2990 self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2991 f2.copyTinyStringsFrom(f);
2992 self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2993 f2.setDescription("GGG");
2994 self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2995 f2.copyTinyStringsFrom(f);
2996 self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2997 f2.getArray().setInfoOnComponent(0,"mmmm");
2998 self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2999 f2.copyTinyStringsFrom(f);
3000 self.assertTrue(f2.isEqual(f,1e-12,1e-12));
3001 f2.getEndArray().setInfoOnComponent(1,"mmmm");
3002 self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
3003 f2.copyTinyStringsFrom(f);
3004 self.assertTrue(f2.isEqual(f,1e-12,1e-12));
3006 self.assertTrue(m2.isEqual(m,1e-12));
3008 self.assertTrue(not m2.isEqual(m,1e-12));
3009 m2.copyTinyStringsFrom(m);
3010 self.assertTrue(m2.isEqual(m,1e-12));
3011 m2.getCoords().setInfoOnComponent(1,"eee");
3012 self.assertTrue(not m2.isEqual(m,1e-12));
3013 m2.copyTinyStringsFrom(m);
3014 self.assertTrue(m2.isEqual(m,1e-12));
3017 def testTryToShareSameCoordsPermute(self):
3018 m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
3019 m2=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
3020 #self.assertTrue(m.getCoords()!=m2.getCoords());
3021 m.tryToShareSameCoordsPermute(m2,1e-12);
3022 #self.assertTrue(m.getCoords()==m2.getCoords());
3023 self.assertTrue(m2.isEqual(m,1e-12));
3024 renum1=[1,2,0,5,8,7,4,3,6]
3025 r1=DataArrayInt.New()
3026 r1.setValues(renum1,len(renum1),1)
3027 m.renumberNodes(r1,9);
3028 #self.assertTrue(m.getCoords()!=m2.getCoords());
3029 self.assertTrue(not m2.isEqual(m,1e-12));
3030 m.tryToShareSameCoordsPermute(m2,1e-12);
3031 #self.assertTrue(m.getCoords()==m2.getCoords());
3032 self.assertTrue(m2.isEqual(m,1e-12));
3035 def testTryToShareSameCoordsPermute2(self):
3036 m1=MEDCouplingDataForTest.build2DTargetMesh_4();
3037 targetCoords=[-0.3,-0.3, 0.2,-0.3, -0.3,0.2, 0.2,0.2 ]
3038 targetConn=[0,2,3,1]
3039 m2=MEDCouplingUMesh.New();
3040 m2.setMeshDimension(2);
3041 m2.allocateCells(1);
3042 m2.insertNextCell(NORM_QUAD4,targetConn[0:4])
3043 m2.finishInsertingCells();
3044 myCoords=DataArrayDouble.New();
3045 myCoords.setValues(targetCoords,4,2);
3046 m2.setCoords(myCoords);
3047 m2.checkConsistencyLight();
3048 m1.checkConsistencyLight();
3050 expected1=[0.25,0.125,0.125,0.25,0.25]
3051 f1=m1.getMeasureField(False);
3052 f2=m2.getMeasureField(False);
3053 self.assertEqual(5,f1.getArray().getNumberOfTuples());
3054 self.assertEqual(1,f2.getArray().getNumberOfTuples());
3056 self.assertAlmostEqual(expected1[i],f1.getIJ(i,0),12);
3058 self.assertAlmostEqual(expected1[0],f2.getIJ(0,0),12);
3059 self.assertRaises(InterpKernelException,m1.tryToShareSameCoordsPermute,m2,1e-12);# <- here in this order the sharing is impossible.
3060 # Let's go for deeper test of tryToShareSameCoordsPermute
3061 m2.tryToShareSameCoordsPermute(m1,1e-12);
3062 f1=m1.getMeasureField(False);
3063 f2=m2.getMeasureField(False);
3064 self.assertEqual(5,f1.getArray().getNumberOfTuples());
3065 self.assertEqual(1,f2.getArray().getNumberOfTuples());
3067 self.assertAlmostEqual(expected1[i],f1.getIJ(i,0),12);
3069 self.assertAlmostEqual(expected1[0],f2.getIJ(0,0),12);
3072 def testChangeUnderlyingMesh1(self):
3073 mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
3074 mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
3075 f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3077 array=DataArrayDouble.New();
3078 arr=[7., 107., 8., 108., 9., 109., 10., 110., 11., 111., 12., 112., 13., 113., 14., 114., 15., 115., 16., 116.]
3079 array.setValues(arr,mesh1.getNumberOfCells(),2);
3082 renum=[0,2,1,3,4,5,6,8,7,9]
3083 mesh2.renumberCells(renum,False);
3084 #self.assertTrue(f1.getMesh()==mesh1);
3085 f1.changeUnderlyingMesh(mesh1,10,1e-12);# nothing done only to check that nothing done.
3086 #self.assertTrue(f1.getMesh()==mesh1);
3087 f1.changeUnderlyingMesh(mesh2,10,1e-12);
3088 #self.assertTrue(f1.getMesh()==mesh2);
3089 expected1=[7.,107.,9.,109.,8.,108.,10.,110.,11.,111.,12.,112.,13.,113.,15.,115.,14.,114.,16.,116.]
3091 self.assertAlmostEqual(expected1[i],f1.getArray().getIJ(0,i),12);
3094 f1=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
3096 array=DataArrayDouble.New();
3097 arr2=[7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.,17.,117.]
3098 array.setValues(arr2,mesh1.getNumberOfNodes(),2);
3101 renum2=[0,2,10,3,4,5,6,8,7,9,1]
3102 mesh2.renumberNodes(renum2,11);
3103 #self.assertTrue(f1.getMesh()==mesh1);
3104 f1.changeUnderlyingMesh(mesh2,10,1e-12);
3105 #self.assertTrue(f1.getMesh()==mesh2);
3106 expected2=[7.,107.,17.,117.,8.,108.,10.,110.,11.,111.,12.,112.,13.,113.,15.,115.,14.,114.,16.,116.,9.,109.]
3108 self.assertAlmostEqual(expected2[i],f1.getArray().getIJ(0,i),12);
3112 def testGetMaxValue1(self):
3113 m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
3114 nbOfCells=m.getNumberOfCells();
3115 f=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
3117 a1=DataArrayDouble.New();
3118 val1=[3.,4.,5.,6.,7.]
3119 a1.setValues(val1,nbOfCells,1);
3120 a2=DataArrayDouble.New();
3121 val2=[0.,1.,2.,8.,7.]
3122 a2.setValues(val2,nbOfCells,1);
3125 f.setEndTime(3.,3,4);
3126 f.checkConsistencyLight();
3128 self.assertAlmostEqual(8.,f.getMaxValue(),14);
3129 self.assertAlmostEqual(0.,f.getMinValue(),14);
3130 self.assertAlmostEqual(5.,f.getAverageValue(),14);
3131 self.assertAlmostEqual(5.125,f.getWeightedAverageValue(0,True),14);
3133 self.assertAlmostEqual(9.5,f.getMaxValue(),14);
3134 self.assertAlmostEqual(0.,f.getMinValue(),14);
3136 self.assertAlmostEqual(9.5,f.getMaxValue(),14);
3137 self.assertAlmostEqual(1.,f.getMinValue(),14);
3140 def testSubstractInPlaceDM1(self):
3141 mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
3142 mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
3143 f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3145 array=DataArrayDouble.New();
3146 arr=[7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.]
3147 array.setValues(arr,mesh1.getNumberOfCells(),2);
3150 self.assertEqual(10,f1.getNumberOfTuples());
3151 self.assertEqual(2,f1.getNumberOfComponents());
3152 self.assertEqual(20,f1.getNumberOfValues());
3154 renum=[0,2,3,1,4,5,6,8,7,9]
3155 mesh2.renumberCells(renum,False);
3157 f2=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3159 array=DataArrayDouble.New();
3160 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]
3161 array.setValues(arr2,mesh2.getNumberOfCells(),2);
3164 f1.substractInPlaceDM(f2,10,1e-12);
3165 f1.applyFunc(1,"abs(x+y+0.2)");
3166 self.assertAlmostEqual(0.,f1.getMaxValue(),13);
3169 def testDotCrossProduct1(self):
3170 mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
3171 f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3172 f1.setTime(2.3,5,6);
3174 array=DataArrayDouble.New();
3175 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.]
3176 array.setValues(arr1,mesh1.getNumberOfCells(),3);
3178 f2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3179 f2.setTime(7.8,4,5);
3181 array=DataArrayDouble.New();
3182 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.]
3183 array.setValues(arr2,mesh1.getNumberOfCells(),3);
3187 expected1=[842.,1820.,2816.,3830.,4862.,5912.,6980.,8066.,9170.,10292.]
3189 self.assertAlmostEqual(expected1[i],f3.getIJ(i,0),9);
3192 f4=f1.crossProduct(f2);
3193 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.]
3195 self.assertAlmostEqual(expected2[i],f4.getIJ(0,i),9);
3201 if __name__ == '__main__':