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