1 # -*- coding: utf-8 -*-
2 # Copyright (C) 2007-2016 CEA/DEN, EDF R&D
4 # This library is free software; you can redistribute it and/or
5 # modify it under the terms of the GNU Lesser General Public
6 # License as published by the Free Software Foundation; either
7 # version 2.1 of the License, or (at your option) any later version.
9 # This library is distributed in the hope that it will be useful,
10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 # Lesser General Public License for more details.
14 # You should have received a copy of the GNU Lesser General Public
15 # License along with this library; if not, write to the Free Software
16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
22 if sys.platform == "win32":
23 from MEDCouplingCompat import *
25 from MEDCoupling import *
28 from math import pi,e,sqrt,cos,sin
29 from datetime import datetime
30 from MEDCouplingDataForTest import MEDCouplingDataForTest
31 import rlcompleter,readline # this line has to be here, to ensure a usability of MEDCoupling/MEDLoader. B4 removing it please notify to anthony.geay@edf.fr
33 class MEDCouplingBasicsTest1(unittest.TestCase):
35 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 self.assertTrue(f3.getMesh().isEqual(m4,1.e-12));
1035 self.assertEqual(name,"MeasureOfMesh_");
1036 self.assertEqual(f3.getTypeOfField(),ON_CELLS);
1037 self.assertEqual(f3.getTimeDiscretization(),ONE_TIME);
1038 self.assertEqual(1,f3.getNumberOfComponents());
1039 self.assertEqual(7,f3.getNumberOfTuples());
1040 values=[0.25,0.125,0.125,0.25,0.25,0.5,0.5]
1041 tmp=f3.getArray().getValues();
1042 self.assertEqual(len(values),len(tmp))
1044 self.assertTrue(abs(values[i]-tmp[i])<1e-12)
1048 def testFillFromAnalytic(self):
1049 m=MEDCouplingDataForTest.build2DTargetMesh_1();
1050 m.setTime(3.4,5,6); m.setTimeUnit("us");
1051 f1=m.fillFromAnalytic(ON_CELLS,1,"x+y");
1052 self.assertAlmostEqual(3.4,f1.getTime()[0],12) ; self.assertEqual(5,f1.getTime()[1]) ; self.assertEqual(6,f1.getTime()[2])
1053 self.assertEqual("us",f1.getTimeUnit())
1054 f1.checkConsistencyLight();
1055 self.assertEqual(f1.getTypeOfField(),ON_CELLS);
1056 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1057 self.assertEqual(1,f1.getNumberOfComponents());
1058 self.assertEqual(5,f1.getNumberOfTuples());
1059 values1=[-0.1,0.23333333333333336,0.56666666666666665,0.4,0.9]
1060 tmp=f1.getArray().getValues();
1061 self.assertEqual(len(values1),len(tmp))
1062 for i in range(len(tmp)):
1063 self.assertTrue(abs(tmp[i]-values1[i])<1.e-12)
1066 f1=m.fillFromAnalytic(ON_NODES,1,"x+y");
1067 f1.checkConsistencyLight();
1068 self.assertEqual(f1.getTypeOfField(),ON_NODES);
1069 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1070 self.assertEqual(1,f1.getNumberOfComponents());
1071 self.assertEqual(9,f1.getNumberOfTuples());
1072 values2=[-0.6,-0.1,0.4,-0.1,0.4,0.9,0.4,0.9,1.4]
1073 tmp=f1.getArray().getValues();
1074 self.assertEqual(len(values2),len(tmp))
1075 for i in range(len(tmp)):
1076 self.assertTrue(abs(tmp[i]-values2[i])<1.e-12)
1079 f1=m.fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+(2*(x+y))*JVec");
1080 f1.checkConsistencyLight();
1081 self.assertEqual(f1.getTypeOfField(),ON_NODES);
1082 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1083 self.assertEqual(2,f1.getNumberOfComponents());
1084 self.assertEqual(9,f1.getNumberOfTuples());
1085 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]
1086 tmp=f1.getArray().getValues();
1087 self.assertEqual(len(values3),len(tmp))
1088 for i in range(len(tmp)):
1089 self.assertTrue(abs(tmp[i]-values3[i])<1.e-12)
1091 values4=f1.accumulate();
1092 self.assertEqual(2,len(values4))
1093 self.assertTrue(abs(3.6-values4[0])<1.e-12);
1094 self.assertTrue(abs(7.2-values4[1])<1.e-12);
1095 values4=f1.integral(True);
1096 self.assertEqual(2,len(values4))
1097 self.assertTrue(abs(0.5-values4[0])<1.e-12);
1098 self.assertTrue(abs(1.-values4[1])<1.e-12);
1100 self.assertRaises(InterpKernelException,m.fillFromAnalytic,ON_NODES,1,"1./(x-0.2)");
1103 def testFillFromAnalytic2(self):
1104 m=MEDCouplingDataForTest.build2DTargetMesh_1();
1105 f1=m.fillFromAnalytic(ON_CELLS,1,"y+x");
1106 f1.checkConsistencyLight();
1107 self.assertEqual(f1.getTypeOfField(),ON_CELLS);
1108 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1109 self.assertEqual(1,f1.getNumberOfComponents());
1110 self.assertEqual(5,f1.getNumberOfTuples());
1111 values1=[-0.1,0.23333333333333336,0.56666666666666665,0.4,0.9]
1112 tmp=f1.getArray().getValues();
1113 self.assertEqual(len(values1),len(tmp))
1114 for i in range(len(values1)):
1115 self.assertTrue(abs(values1[i]-tmp[i])<1.e-12);
1118 f1=m.fillFromAnalytic(ON_NODES,1,"y+2*x");
1119 f1.checkConsistencyLight();
1120 self.assertEqual(f1.getTypeOfField(),ON_NODES);
1121 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1122 self.assertEqual(1,f1.getNumberOfComponents());
1123 self.assertEqual(9,f1.getNumberOfTuples());
1124 values2=[-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1]
1125 tmp=f1.getArray().getValues();
1126 self.assertEqual(len(values2),len(tmp))
1127 for i in range(len(values2)):
1128 self.assertTrue(abs(values2[i]-tmp[i])<1.e-12);
1130 f1=m.fillFromAnalytic(ON_NODES,1,"2.*x+y");
1131 f1.checkConsistencyLight();
1132 self.assertEqual(f1.getTypeOfField(),ON_NODES);
1133 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1134 self.assertEqual(1,f1.getNumberOfComponents());
1135 self.assertEqual(9,f1.getNumberOfTuples());
1136 tmp=f1.getArray().getValues();
1137 values2Bis=[-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1]
1138 self.assertEqual(len(values2Bis),len(tmp))
1139 for i in range(len(values2Bis)):
1140 self.assertTrue(abs(values2Bis[i]-tmp[i])<1.e-12);
1143 f1=m.fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+2*(x+y)*JVec");
1144 f1.checkConsistencyLight();
1145 self.assertEqual(f1.getTypeOfField(),ON_NODES);
1146 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1147 self.assertEqual(2,f1.getNumberOfComponents());
1148 self.assertEqual(9,f1.getNumberOfTuples());
1149 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]
1150 tmp=f1.getArray().getValues();
1151 self.assertEqual(len(values3),len(tmp))
1152 for i in range(len(values3)):
1153 self.assertTrue(abs(values3[i]-tmp[i])<1.e-12);
1155 values4=f1.accumulate();
1156 self.assertTrue(abs(3.6-values4[0])<1.e-12);
1157 self.assertTrue(abs(7.2-values4[1])<1.e-12);
1158 values4=f1.integral(True);
1159 self.assertTrue(abs(0.5-values4[0])<1.e-12);
1160 self.assertTrue(abs(1.-values4[1])<1.e-12);
1163 def testApplyFunc(self):
1164 m=MEDCouplingDataForTest.build2DTargetMesh_1();
1165 f1=m.fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+(2*(x+y))*JVec");
1166 f1.checkConsistencyLight();
1167 self.assertEqual(f1.getTypeOfField(),ON_NODES);
1168 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1169 self.assertEqual(2,f1.getNumberOfComponents());
1170 self.assertEqual(9,f1.getNumberOfTuples());
1171 f1.applyFunc(1,"x+y");
1172 self.assertEqual(f1.getTypeOfField(),ON_NODES);
1173 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1174 self.assertEqual(1,f1.getNumberOfComponents());
1175 self.assertEqual(9,f1.getNumberOfTuples());
1176 values1=[-1.8,-0.3,1.2,-0.3,1.2,2.7,1.2,2.7,4.2]
1177 tmp=f1.getArray().getValues();
1178 self.assertEqual(len(values1),len(tmp))
1179 for i in range(len(tmp)):
1180 self.assertTrue(abs(tmp[i]-values1[i])<1.e-12)
1184 def testApplyFunc2(self):
1185 m=MEDCouplingDataForTest.build2DTargetMesh_1();
1186 f1=m.fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+2*(x+y)*JVec");
1187 f1.checkConsistencyLight();
1188 self.assertEqual(f1.getTypeOfField(),ON_NODES);
1189 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1190 self.assertEqual(2,f1.getNumberOfComponents());
1191 self.assertEqual(9,f1.getNumberOfTuples());
1194 self.assertRaises(InterpKernelException, f2.applyFunc, 1, "a+b+c+d");
1195 self.assertRaises(InterpKernelException, f2.applyFunc, 1, "a/0");
1196 self.assertRaises(InterpKernelException, f2.applyFunc, "a/0");
1197 f2.applyFunc("abs(u)^2.4+2*u");
1198 self.assertEqual(f1.getTypeOfField(),ON_NODES);
1199 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1200 self.assertEqual(2,f1.getNumberOfComponents());
1201 self.assertEqual(9,f1.getNumberOfTuples());
1202 values2=[-0.9065304805418678, -0.85105859001709905, -0.19601892829446504, -0.37898777756476987,
1203 0.91090317490482353, 2.1853504664669781, -0.19601892829446504, -0.37898777756476987,
1204 0.91090317490482353, 2.1853504664669781, 2.5765725275664879, 7.6987743736515295,
1205 0.91090317490482353, 2.1853504664669781, 2.5765725275664879, 7.6987743736515295,
1206 5.0423700574830965, 17.435300118916864]
1207 tmp=f2.getArray().getValues();
1208 self.assertEqual(len(tmp),len(values2))
1209 for i in range(len(tmp)):
1210 self.assertTrue(abs(tmp[i]-values2[i])<1.e-12)
1213 f1.applyFunc(1,"x+y");
1214 self.assertEqual(f1.getTypeOfField(),ON_NODES);
1215 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1216 self.assertEqual(1,f1.getNumberOfComponents());
1217 self.assertEqual(9,f1.getNumberOfTuples());
1218 values1=[-1.8,-0.3,1.2,-0.3,1.2,2.7,1.2,2.7,4.2]
1219 tmp=f1.getArray().getValues();
1220 self.assertEqual(len(tmp),len(values1))
1221 for i in range(len(tmp)):
1222 self.assertTrue(abs(tmp[i]-values1[i])<1.e-12)
1226 def testOperationsOnFields(self):
1227 m=MEDCouplingDataForTest.build2DTargetMesh_1();
1228 f1=m.fillFromAnalytic(ON_NODES,1,"x+y");
1229 f2=m.fillFromAnalytic(ON_NODES,1,"x+y");
1230 f1.checkConsistencyLight();
1231 f2.checkConsistencyLight();
1233 f3.checkConsistencyLight();
1234 self.assertEqual(f3.getTypeOfField(),ON_NODES);
1235 self.assertEqual(f3.getTimeDiscretization(),ONE_TIME);
1236 values1=[-1.2,-0.2,0.8,-0.2,0.8,1.8,0.8,1.8,2.8]
1237 tmp=f3.getArray().getValues();
1238 self.assertEqual(len(values1),len(tmp))
1239 for i in range(len(tmp)):
1240 self.assertTrue(abs(tmp[i]-values1[i])<1.e-12)
1244 f3.checkConsistencyLight();
1245 self.assertEqual(f3.getTypeOfField(),ON_NODES);
1246 self.assertEqual(f3.getTimeDiscretization(),ONE_TIME);
1247 values2=[0.36,0.01,0.16,0.01,0.16,0.81,0.16,0.81,1.96]
1248 tmp=f3.getArray().getValues();
1249 self.assertEqual(len(values2),len(tmp))
1250 for i in range(len(tmp)):
1251 self.assertTrue(abs(tmp[i]-values2[i])<1.e-12)
1256 f4.checkConsistencyLight();
1257 self.assertEqual(f4.getTypeOfField(),ON_NODES);
1258 self.assertEqual(f4.getTimeDiscretization(),ONE_TIME);
1259 values3=[0.6,0.1,-0.4,0.1,-0.4,-0.9,-0.4,-0.9,-1.4]
1260 tmp=f4.getArray().getValues();
1261 self.assertEqual(len(values3),len(tmp))
1262 for i in range(len(tmp)):
1263 self.assertTrue(abs(tmp[i]-values3[i])<1.e-12)
1268 f4.checkConsistencyLight();
1269 self.assertEqual(f4.getTypeOfField(),ON_NODES);
1270 self.assertEqual(f4.getTimeDiscretization(),ONE_TIME);
1271 tmp=f4.getArray().getValues();
1272 for i in range(len(tmp)):
1273 self.assertTrue(abs(tmp[i]-2.)<1.e-12)
1276 f4=f2.buildNewTimeReprFromThis(NO_TIME,False);
1277 f4.checkConsistencyLight();
1278 self.assertEqual(f4.getTypeOfField(),ON_NODES);
1279 self.assertEqual(f4.getTimeDiscretization(),NO_TIME);
1280 self.assertRaises(InterpKernelException,f1.__add__,f4);
1281 f5=f4.buildNewTimeReprFromThis(ONE_TIME,False);
1282 self.assertEqual(f5.getTypeOfField(),ON_NODES);
1283 self.assertEqual(f5.getTimeDiscretization(),ONE_TIME);
1285 tmp=f3.getArray().getValues();
1286 values4=[-1.2,-0.2,0.8,-0.2,0.8,1.8,0.8,1.8,2.8]
1287 self.assertEqual(len(values3),len(tmp))
1288 for i in range(len(tmp)):
1289 self.assertTrue(abs(tmp[i]-values4[i])<1.e-12)
1292 f4=f2.buildNewTimeReprFromThis(NO_TIME,True);
1293 f4.checkConsistencyLight();
1294 self.assertEqual(f4.getTypeOfField(),ON_NODES);
1295 self.assertEqual(f4.getTimeDiscretization(),NO_TIME);
1296 self.assertRaises(InterpKernelException,f1.__add__,f4);
1297 f5=f4.buildNewTimeReprFromThis(ONE_TIME,True);
1298 self.assertEqual(f5.getTypeOfField(),ON_NODES);
1299 self.assertEqual(f5.getTimeDiscretization(),ONE_TIME);
1301 tmp=f3.getArray().getValues();
1302 values5=[-1.2,-0.2,0.8,-0.2,0.8,1.8,0.8,1.8,2.8]
1303 self.assertEqual(len(values5),len(tmp))
1304 for i in range(len(tmp)):
1305 self.assertTrue(abs(tmp[i]-values5[i])<1.e-12)
1309 def testOperationsOnFields2(self):
1310 m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1311 m.setTime(3.4,5,6); m.setTimeUnit("us");
1312 f1=m.fillFromAnalytic(ON_NODES,1,"x+y+z");
1313 f2=m.fillFromAnalytic(ON_NODES,1,"a*a+b+c*c");
1315 f3.checkConsistencyLight();
1316 self.assertEqual(f3.getTypeOfField(),ON_NODES);
1317 self.assertEqual(f3.getTimeDiscretization(),ONE_TIME);
1318 expected1=[-2.4999999999999991, 1.2162162162162162, 0.77868852459016391,
1319 0.7407407407407407, 1.129032258064516, 0.81632653061224492,
1320 0.86538461538461531, 1.0919540229885056, 0.84302325581395343]
1321 self.assertEqual(1,f3.getNumberOfComponents());
1322 self.assertEqual(9,f3.getNumberOfTuples());
1323 val=f3.getArray().getValues();
1325 self.assertTrue(abs(expected1[i]-val[i])<1.e-12);
1327 f1=m.buildOrthogonalField();
1328 self.assertAlmostEqual(3.4,f1.getTime()[0],12) ; self.assertEqual(5,f1.getTime()[1]) ; self.assertEqual(6,f1.getTime()[2])
1329 self.assertEqual("us",f1.getTimeUnit())
1330 f2=m.fillFromAnalytic(ON_CELLS,1,"x");
1332 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]
1333 val=f3.getArray().getValues();
1335 self.assertTrue(abs(expected2[i]-val[i])<1.e-12);
1339 val=f3.getArray().getValues();
1341 self.assertTrue(abs(expected2[i]-val[i])<1.e-12);
1345 def testOperationsOnFields3(self):
1346 m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1347 f1=m.fillFromAnalytic(ON_NODES,1,"x+y+z");
1348 f2=m.fillFromAnalytic(ON_NODES,1,"a*a+b+c*c");
1350 f1.checkConsistencyLight();
1351 self.assertEqual(f1.getTypeOfField(),ON_NODES);
1352 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1353 expected1=[-2.4999999999999991, 1.2162162162162162, 0.77868852459016391,
1354 0.7407407407407407, 1.129032258064516, 0.81632653061224492,
1355 0.86538461538461531, 1.0919540229885056, 0.84302325581395343]
1356 self.assertEqual(1,f1.getNumberOfComponents());
1357 self.assertEqual(9,f1.getNumberOfTuples());
1358 val=f1.getArray().getValues();
1360 self.assertTrue(abs(expected1[i]-val[i])<1.e-12);
1363 f1=m.buildOrthogonalField();
1364 f2=m.fillFromAnalytic(ON_CELLS,1,"x");
1366 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]
1367 val=f1.getArray().getValues();
1369 self.assertTrue(abs(expected2[i]-val[i])<1.e-12);
1372 f1=m.buildOrthogonalField();
1373 # to avoid valgrind leaks
1374 # self.assertRaises(InterpKernelException,f2.__imul__,f1);
1377 def testOperationsOnFields4(self):
1378 m=MEDCouplingDataForTest.build2DTargetMesh_1();
1379 nbOfCells=m.getNumberOfCells();
1380 f1=MEDCouplingFieldDouble.New(ON_CELLS,CONST_ON_TIME_INTERVAL);
1382 array=DataArrayDouble.New();
1384 self.assertRaises(InterpKernelException,f1.setEndArray,array);
1385 self.assertRaises(InterpKernelException,f1.getEndArray);
1386 arr1=[0.,10.,20.,1.,11.,21.,2.,12.,22.,3.,13.,23.,4.,14.,24.]
1387 arr2=[5.,15.,25.,6.,16.,26.,7.,17.,27.,8.,18.,28.,9.,19.,29.]
1388 array.setValues(arr1,nbOfCells,3);
1389 f1.setStartTime(2.,0,0);
1390 f1.setEndTime(3.,0,0);
1391 f1.checkConsistencyLight();
1393 res=f1.getValueOn(pos);
1394 self.assertTrue(abs(arr1[3]-res[0])<1.e-12);
1395 self.assertTrue(abs(arr1[4]-res[1])<1.e-12);
1396 self.assertTrue(abs(arr1[5]-res[2])<1.e-12);
1398 res=f1.getValueOn(pos,2.2);
1399 self.assertTrue(abs(arr1[3]-res[0])<1.e-12);
1400 self.assertTrue(abs(arr1[4]-res[1])<1.e-12);
1401 self.assertTrue(abs(arr1[5]-res[2])<1.e-12);
1403 self.assertRaises(InterpKernelException,f1.getValueOn,pos,3.2)
1404 f2=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
1406 f2.setArray(f1.getArray());
1407 f2.setStartTime(2.,3,0);
1408 f2.setEndTime(4.,13,0);
1409 self.assertRaises(InterpKernelException,f2.checkConsistencyLight)
1410 array2=DataArrayDouble.New();
1411 array2.setValues(arr2,nbOfCells,3);
1412 f2.setEndArray(array2);
1413 f2.checkConsistencyLight();
1416 res=f2.getValueOn(pos,3.21);
1417 self.assertTrue(abs(4.025-res[0])<1.e-12);
1418 self.assertTrue(abs(14.025-res[1])<1.e-12);
1419 self.assertTrue(abs(24.025-res[2])<1.e-12);
1421 self.assertTrue(f2.isEqual(f3,1e-12,1e-12));
1422 f3.getEndArray().setIJ(0,0,5.001);
1423 self.assertTrue(not f2.isEqual(f3,1e-12,1e-12));
1424 self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1425 f3.setStartTime(2.1,3,0);
1426 self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1427 f3.setStartTime(2.,3,0);
1428 self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1429 f3.setStartTime(2.,4,0);
1430 self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1431 f3.setStartTime(2.,3,1);
1432 self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1433 f3.setStartTime(2.,3,0);
1434 self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1435 f3.setEndTime(4.1,13,0);
1436 self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1437 f3.setEndTime(4.,13,0);
1438 self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1439 f3.setEndTime(4.,14,0);
1440 self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1441 f3.setEndTime(4.,13,1);
1442 self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1443 f3.setEndTime(4.,13,0);
1444 self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1447 res=f4.getValueOn(pos,3.21);
1448 self.assertTrue(abs(8.05-res[0])<1.e-12);
1449 self.assertTrue(abs(28.05-res[1])<1.e-12);
1450 self.assertTrue(abs(48.05-res[2])<1.e-12);
1453 res=f4.getValueOn(pos,3.21);
1454 self.assertTrue(abs(12.075-res[0])<1.e-12);
1455 self.assertTrue(abs(42.075-res[1])<1.e-12);
1456 self.assertTrue(abs(72.075-res[2])<1.e-12);
1459 def testMergeNodesOnField(self):
1460 targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
1461 f1=targetMesh.fillFromAnalytic(ON_NODES,1,"x+y+z");
1462 f1.mergeNodes(1e-10);
1464 targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
1465 f1=targetMesh.fillFromAnalytic(ON_NODES,1,"x+y+z");
1467 tmp.setIJ(0,0,1000.);
1468 f1.mergeNodes(1e-10);
1470 targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
1471 f1=targetMesh.fillFromAnalytic(ON_NODES,1,"x+y+z");
1473 tmp.setIJ(1,0,1000.);
1474 self.assertRaises(InterpKernelException,f1.mergeNodes,1.e-10)
1477 def testCheckConsecutiveCellTypes(self):
1478 sourceMesh=MEDCouplingDataForTest.build2DSourceMesh_1();
1479 targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1480 self.assertTrue(sourceMesh.checkConsecutiveCellTypes());
1481 order1=[NORM_TRI3,NORM_QUAD4]
1482 order2=[NORM_QUAD4,NORM_TRI3]
1483 self.assertTrue(not targetMesh.checkConsecutiveCellTypes());
1484 self.assertTrue(not targetMesh.checkConsecutiveCellTypesAndOrder(order1));
1485 self.assertTrue(not targetMesh.checkConsecutiveCellTypesAndOrder(order2));
1486 da=targetMesh.getRenumArrForConsecutiveCellTypesSpec(order1);
1487 self.assertEqual(5,da.getNumberOfTuples());
1488 self.assertEqual(1,da.getNumberOfComponents());
1489 expected1=[2,0,1,3,4]
1490 self.assertTrue(expected1==list(da.getValues()));
1491 da=targetMesh.getRenumArrForConsecutiveCellTypesSpec(order2);
1492 self.assertEqual(5,da.getNumberOfTuples());
1493 self.assertEqual(1,da.getNumberOfComponents());
1494 expected2=[0,3,4,1,2]
1495 self.assertTrue(expected2==list(da.getValues()));
1496 renumber1=[4,0,1,2,3]
1497 targetMesh.renumberCells(renumber1,False);
1498 self.assertTrue(targetMesh.checkConsecutiveCellTypes());
1499 self.assertTrue(targetMesh.checkConsecutiveCellTypesAndOrder(order1));
1500 self.assertTrue(not targetMesh.checkConsecutiveCellTypesAndOrder(order2));
1503 def testRearrange2ConsecutiveCellTypes(self):
1504 m1_1=MEDCouplingDataForTest.build2DSourceMesh_1();
1505 m2_1=MEDCouplingDataForTest.build2DTargetMesh_1();
1506 arr1=m1_1.rearrange2ConsecutiveCellTypes();
1507 m1_2=MEDCouplingDataForTest.build2DSourceMesh_1();
1508 self.assertTrue(m1_2.isEqual(m1_1,1e-12));
1510 self.assertEqual(2,arr1.getNumberOfTuples());
1511 self.assertEqual(1,arr1.getNumberOfComponents());
1512 self.assertEqual(expected1,arr1.getValues());
1513 expected2=[0,3,4,1,2]
1514 arr1=m2_1.rearrange2ConsecutiveCellTypes();
1515 self.assertEqual(5,arr1.getNumberOfTuples());
1516 self.assertEqual(1,arr1.getNumberOfComponents());
1517 self.assertEqual(expected2,list(arr1.getValues()));
1518 m2_2=MEDCouplingDataForTest.build2DTargetMesh_1();
1519 self.assertEqual(5,arr1.getNumberOfTuples());
1520 self.assertEqual(1,arr1.getNumberOfComponents());
1521 self.assertEqual(expected2,list(arr1.getValues()));
1522 self.assertTrue(not m2_2.isEqual(m2_1,1e-12));
1523 m2_2.renumberCells(expected2,False);
1524 self.assertTrue(m2_2.isEqual(m2_1,1e-12));
1527 def testSplitByType(self):
1528 m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1530 self.assertEqual(3,len(v));
1531 m2=MEDCouplingUMesh.MergeUMeshesOnSameCoords(v);
1532 m2.setName(m1.getName());
1533 self.assertTrue(m1.isEqual(m2,1.e-12));
1536 def testFuseUMeshesOnSameCoords(self):
1537 m2=MEDCouplingDataForTest.build2DTargetMesh_1();
1539 m3=m2.buildPartOfMySelf(cells1,True);
1540 self.assertTrue(isinstance(m3,MEDCouplingUMesh))
1542 m4=m2.buildPartOfMySelf(cells2,True);
1543 self.assertTrue(isinstance(m4,MEDCouplingUMesh))
1545 m5=m2.buildPartOfMySelf(cells3,True);
1546 self.assertTrue(isinstance(m5,MEDCouplingUMesh))
1549 m7,corr=MEDCouplingUMesh.FuseUMeshesOnSameCoords(meshes,0);
1550 self.assertEqual(4,m7.getNumberOfCells());
1551 self.assertEqual(3,len(corr));
1552 expectedVals1=[3,3,2]
1553 expectedVals2=[[0,1,2],[3,0,2],[3,0]]
1556 self.assertEqual(1,arr.getNumberOfComponents());
1557 nbOfVals=expectedVals1[i];
1558 self.assertEqual(nbOfVals,arr.getNumberOfTuples());
1559 vals=arr.getValues();
1560 self.assertEqual(expectedVals2[i],list(vals));
1562 arr2,fidsOfGroups=DataArrayInt.MakePartition(corr,m7.getNumberOfCells());
1564 fidsGrp=[[1,3,5],[3,4,5],[4,5]]
1565 self.assertEqual(3,len(fidsOfGroups));
1566 self.assertEqual(1,arr2.getNumberOfComponents());
1567 self.assertEqual(4,arr2.getNumberOfTuples());
1568 self.assertEqual(fidExp,list(arr2.getValues()));
1570 nbOfVals=expectedVals1[i];
1571 self.assertEqual(list(fidsOfGroups[i]),fidsGrp[i]);
1575 def testFuseUMeshesOnSameCoords2(self):
1576 m1,m2=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
1578 m3=m1.buildPartOfMySelf(part1,True);
1580 m4=m1.buildPartOfMySelf(part2,True);
1581 meshes=[m1,m3,m3,m4]
1582 m5,corr=MEDCouplingUMesh.FuseUMeshesOnSameCoords(meshes,0);
1583 self.assertEqual(18,m5.getNumberOfCells());
1585 [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17],
1591 self.assertEqual(exp2[i],list(it.getValues()));
1596 def testBuildOrthogonalField(self):
1597 targetMesh=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1598 field=targetMesh.buildOrthogonalField();
1599 expected=[0.70710678118654746,0.,-0.70710678118654746]
1600 self.assertEqual(5,field.getNumberOfTuples());
1601 self.assertEqual(3,field.getNumberOfComponents());
1602 vals=field.getArray().getValues();
1604 self.assertTrue(abs(expected[i%3]-vals[i])<1e-12);
1606 targetCoords=[0.,0.,0.,0.5,0.,0.5,1.,0.,1.,0.,1.,0.]
1607 targetConn=[0,1,2,3]
1608 targetMesh=MEDCouplingUMesh.New();
1609 targetMesh.setMeshDimension(2);
1610 targetMesh.allocateCells(1);
1611 targetMesh.insertNextCell(NORM_QUAD4,targetConn[0:4])
1612 targetMesh.finishInsertingCells();
1613 myCoords=DataArrayDouble.New();
1614 myCoords.setValues(targetCoords,4,3);
1615 targetMesh.setCoords(myCoords);
1616 field=targetMesh.buildOrthogonalField();
1617 self.assertEqual(1,field.getNumberOfTuples());
1618 self.assertEqual(3,field.getNumberOfComponents());
1619 vals=field.getArray().getValues();
1620 self.assertTrue(abs(-0.70710678118654746-vals[0])<1e-12);
1621 self.assertTrue(abs(0.-vals[1])<1e-12);
1622 self.assertTrue(abs(0.70710678118654746-vals[2])<1e-12);
1625 def testGetCellsContainingPoint(self):
1626 targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1627 pos=[0.,0.,0.4,0.4,0.,0.4,0.1,0.1,0.25,0.,0.65,0.]
1629 t1,t2=targetMesh.getCellsContainingPoints(pos,6,1e-12);
1630 self.assertEqual(6,t1.getNumberOfTuples());
1631 self.assertEqual(1,t1.getNumberOfComponents());
1632 self.assertEqual(7,t2.getNumberOfTuples());
1633 self.assertEqual(1,t2.getNumberOfComponents());
1634 expectedValues1=[0,4,3,0,1,2]
1635 expectedValues2=[0,1,2,3,4,5,6]
1636 self.assertEqual(list(t1.getValues()),expectedValues1);
1637 self.assertEqual(list(t2.getValues()),expectedValues2);
1638 #2D with no help of bounding box.
1640 MEDCouplingPointSet.Rotate2DAlg(center,0.78539816339744830962,6,pos);
1641 targetMesh.rotate(center,0.78539816339744830962);
1644 t1,t2=targetMesh.getCellsContainingPoints(pos,1e-12);
1645 self.assertEqual(6,t1.getNumberOfTuples());
1646 self.assertEqual(7,t2.getNumberOfTuples());
1647 self.assertEqual(list(t1.getValues()),expectedValues1);
1648 self.assertEqual(list(t2.getValues()),expectedValues2);
1649 t1,t2=targetMesh.getCellsContainingPoints(DataArrayDouble.New(pos,6,2),1e-12);
1650 self.assertEqual(6,t1.getNumberOfTuples());
1651 self.assertEqual(7,t2.getNumberOfTuples());
1652 self.assertEqual(list(t1.getValues()),expectedValues1);
1653 self.assertEqual(list(t2.getValues()),expectedValues2);
1654 self.assertRaises(InterpKernelException,targetMesh.getCellsContainingPoints,DataArrayDouble.New(pos,4,3),1e-12);
1656 pos1bis=[-0.3303300858899107,-0.11819805153394641]
1657 self.assertEqual(-1,targetMesh.getCellContainingPoint(pos1bis,1e-12));
1659 targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1662 t1=targetMesh.getCellsContainingPoint(pos2,1e-12)
1663 self.assertEqual(2,len(t1));
1664 expectedValues3=[0,1]
1665 self.assertEqual(list(t1.getValues()),expectedValues3);
1668 t1=targetMesh.getCellsContainingPoint(pos3,1e-12);
1669 self.assertEqual(5,len(t1));
1670 expectedValues4=[0,1,2,3,4]
1671 self.assertEqual(list(t1.getValues()),expectedValues4);
1672 self.assertEqual(0,targetMesh.getCellContainingPoint(pos3,1e-12));
1674 targetMesh=MEDCouplingDataForTest.build3DTargetMesh_1();
1676 self.assertEqual(0,targetMesh.getCellContainingPoint(pos4,1e-12));
1679 t1=targetMesh.getCellsContainingPoint(pos5,1e-12);
1680 self.assertEqual(8,len(t1));
1681 expectedValues5=[0,1,2,3,4,5,6,7]
1682 self.assertEqual(list(t1.getValues()),expectedValues5);
1685 t1=targetMesh.getCellsContainingPoint(pos6,1e-12);
1686 self.assertEqual(2,len(t1));
1687 expectedValues6=[0,2]
1688 self.assertEqual(list(t1.getValues()),expectedValues6);
1691 self.assertEqual(-1,targetMesh.getCellContainingPoint(pos7,1e-12));
1695 targetMesh.rotate(center2,vec2,0.78539816339744830962);
1697 self.assertEqual(-1,targetMesh.getCellContainingPoint(pos8,1e-12));
1700 def testGetValueOn1(self):
1701 targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1702 fieldOnCells=MEDCouplingFieldDouble.New(ON_CELLS);
1703 nbOfCells=targetMesh.getNumberOfCells();
1704 fieldOnCells.setMesh(targetMesh);
1705 array=DataArrayDouble.New();
1706 tmp=2*nbOfCells*[None]
1707 for i in range(nbOfCells):
1708 tmp[2*i]=7.+float(i);
1709 tmp[2*i+1]=17.+float(i)
1711 array.setValues(tmp,nbOfCells,2);
1712 fieldOnCells.setArray(array);
1715 res=fieldOnCells.getValueOn(pos1);
1716 self.assertEqual(2,len(res))
1717 self.assertTrue(abs(8.-res[0])<1e-12);
1718 self.assertTrue(abs(18.-res[1])<1e-12);
1721 targetMesh=MEDCouplingDataForTest.build2DSourceMesh_1();
1722 fieldOnNodes=MEDCouplingFieldDouble.New(ON_NODES);
1723 nbOfNodes=targetMesh.getNumberOfNodes();
1724 fieldOnNodes.setMesh(targetMesh);
1725 array=DataArrayDouble.New();
1726 tmp=2*nbOfNodes*[None]
1727 for i in range(nbOfNodes):
1728 tmp[2*i]=17.+float(i);
1729 tmp[2*i+1]=27.+float(i)
1731 array.setValues(tmp,nbOfNodes,2);
1732 fieldOnNodes.setArray(array);
1734 pos2=[-0.13333333333333333,-0.13333333333333333]
1736 res=fieldOnNodes.getValueOn(pos2);
1737 self.assertEqual(2,len(res))
1738 self.assertTrue(abs(17.5-res[0])<1e-12);
1739 self.assertTrue(abs(27.5-res[1])<1e-12);
1740 pos3=[0.033333333333333326,0.36666666666666664]
1742 res=fieldOnNodes.getValueOn(pos3);
1743 self.assertEqual(2,len(res))
1744 self.assertTrue(abs(18.666666666666667-res[0])<1e-12);
1745 self.assertTrue(abs(28.666666666666667-res[1])<1e-12);
1748 def testCMesh0(self):
1749 mesh=MEDCouplingCMesh.New();
1750 meshEmpty=mesh.clone(True);
1751 self.assertTrue(meshEmpty.isEqual(mesh, 1e-12));
1753 coordsX=DataArrayDouble.New();
1754 arrX=[ -1., 1., 2., 4. ]
1755 coordsX.setValues(arrX, 4, 1);
1756 coordsY=DataArrayDouble.New();
1757 arrY=[ -2., 2., 4., 8. ]
1758 coordsY.setValues(arrY, 4, 1);
1759 coordsZ=DataArrayDouble.New();
1760 arrZ=[ -3., 3., 6., 12. ]
1761 coordsZ.setValues(arrZ, 4, 1);
1762 mesh.setCoords(coordsX, coordsY, coordsZ);
1764 fieldOnNodes=mesh.fillFromAnalytic(ON_NODES, 1, "x+y/2.+z/3.");
1765 self.assertEqual(1, fieldOnNodes.getNumberOfComponents());
1766 self.assertEqual(64, fieldOnNodes.getNumberOfTuples());
1767 expected1=[-3., -1., 0., 2., -1., 1., 2., 4., 0., 2., 3., 5., 2., 4., 5., 7., -1., 1., 2.,
1768 4., 1., 3., 4., 6., 2., 4., 5., 7., 4., 6., 7., 9., 0., 2., 3., 5., 2., 4., 5.,
1769 7., 3., 5., 6., 8., 5., 7., 8., 10., 2., 4., 5.,
1770 7., 4., 6., 7., 9., 5., 7., 8., 10., 7., 9., 10., 12.];
1772 val=fieldOnNodes.getArray().getValues();
1774 self.assertAlmostEqual(expected1[i], val[i], 12)
1775 res=fieldOnNodes.getValueOnPos(1, 3, 2);
1776 self.assertAlmostEqual(7., res[0], 12);
1778 fieldOnCells=mesh.fillFromAnalytic(ON_CELLS, 1, "x+y/2.+z/3.");
1779 self.assertEqual(1, fieldOnCells.getNumberOfComponents());
1780 self.assertEqual(27, fieldOnCells.getNumberOfTuples());
1781 val=fieldOnCells.getArray().getValues();
1782 expected2=[0, 1.5, 3, 1.5, 3, 4.5, 3, 4.5, 6, 1.5, 3, 4.5, 3, 4.5,
1783 6, 4.5, 6, 7.5, 3, 4.5, 6, 4.5, 6, 7.5, 6, 7.5, 9];
1785 self.assertAlmostEqual(expected2[i], val[i], 12);
1786 #res=fieldOnCells.getValueOnPos(1,2,1);
1787 #self.assertAlmostEqual(6.,res,12);
1789 meshDeepCopy=mesh.deepCopy();
1790 meshClone=mesh.clone(False);
1792 meshEmpty.copyTinyStringsFrom(mesh);
1793 #no data in meshEmpty, expected False
1794 self.assertTrue(not meshEmpty.isEqual(mesh, 1e-12));
1796 self.assertTrue(meshDeepCopy.isEqual(mesh, 1e-12));
1797 meshDeepCopy.copyTinyStringsFrom(mesh);
1798 self.assertTrue(meshDeepCopy.isEqual(mesh, 1e-12));
1799 self.assertTrue(meshClone.isEqual(mesh, 1e-12));
1801 self.assertEqual(CARTESIAN, mesh.getType());
1802 self.assertEqual(CARTESIAN, meshEmpty.getType());
1803 self.assertEqual(CARTESIAN, meshDeepCopy.getType());
1804 self.assertEqual(CARTESIAN, meshClone.getType());
1807 def testCMesh1(self):
1808 mesh1=MEDCouplingCMesh.New();
1809 coordsX1=DataArrayDouble.New();
1810 arrX1=[ -1., 1., 2., 4. ]
1811 coordsX1.setValues(arrX1, 4, 1);
1812 coordsY1=DataArrayDouble.New();
1813 arrY1=[ -2., 2., 4., 8. ]
1814 coordsY1.setValues(arrY1, 4, 1);
1815 coordsZ1=DataArrayDouble.New();
1816 arrZ1=[ -3., 3., 6., 12. ]
1817 coordsZ1.setValues(arrZ1, 4, 1);
1818 mesh1.setCoords(coordsX1, coordsY1, coordsZ1);
1820 mesh2=MEDCouplingCMesh.New();
1821 coordsX2=DataArrayDouble.New();
1822 arrX2=[ -1., 1., 2., 4. ]
1823 coordsX2.setValues(arrX2, 4, 1);
1824 coordsY2=DataArrayDouble.New();
1825 arrY2=[ -2., 2., 4., 8. ]
1826 coordsY2.setValues(arrY2, 4, 1);
1827 coordsZ2=DataArrayDouble.New();
1828 arrZ2=[ -3., 3., 6., 12.+1e-6 ]
1829 coordsZ2.setValues(arrZ2, 4, 1);
1830 mesh2.setCoords(coordsX2, coordsY2, coordsZ2);
1832 mesh3=MEDCouplingCMesh.New();
1833 coordsX3=DataArrayDouble.New();
1835 coordsX3.setValues(arrX3, 1, 1);
1836 coordsY3=DataArrayDouble.New();
1838 coordsY3.setValues(arrY3, 1, 1);
1839 coordsZ3=DataArrayDouble.New();
1841 coordsZ3.setValues(arrZ3, 1, 1);
1842 mesh3.setCoords(coordsX3, coordsY3, coordsZ3);
1844 self.assertEqual(3, mesh1.getSpaceDimension());
1845 self.assertEqual(3, mesh1.getMeshDimension());
1847 self.assertTrue(not mesh1.isEqual(mesh2, 1e-12));
1848 self.assertTrue(not mesh2.isEqual(mesh1, 1e-12));
1849 self.assertTrue(not mesh2.isEqualWithoutConsideringStr(mesh1, 1e-12));
1850 self.assertTrue(mesh1.isEqual(mesh2, 1e-5));
1851 self.assertTrue(not mesh1.isEqual(mesh2, 1e-7));
1853 self.assertRaises(InterpKernelException, mesh3.checkConsistency, 1e-12);
1854 mesh1.checkConsistency(1e-12);
1855 self.assertEqual(NORM_HEXA8, mesh1.getTypeOfCell(1));
1857 self.assertEqual(NORM_HEXA8, mesh1.getAllGeoTypes()[0]);
1858 self.assertEqual(27, mesh1.getNumberOfCellsWithType(NORM_HEXA8));
1859 self.assertRaises(InterpKernelException, mesh1.getNumberOfCellsWithType, NORM_QUAD4);
1861 coo=mesh1.getCoordinatesOfNode(0);
1862 self.assertEqual(3, len(coo));
1863 self.assertAlmostEqual(-1., coo[0], 14);
1864 self.assertAlmostEqual(-2., coo[1], 14);
1865 self.assertAlmostEqual(-3., coo[2], 14);
1866 coo=mesh1.getCoordinatesOfNode(63);
1867 self.assertEqual(3, len(coo));
1868 self.assertAlmostEqual(4., coo[0], 14);
1869 self.assertAlmostEqual(8., coo[1], 14);
1870 self.assertAlmostEqual(12., coo[2], 14);
1873 repr=mesh1.simpleRepr();
1874 repr=mesh1.advancedRepr();
1875 self.assertTrue("Cartesian" in repr);
1876 self.assertTrue("Number of components : 1" in repr);
1877 self.assertTrue("Number of tuples : 4" in repr);
1878 self.assertTrue("Z Array :" in repr);
1881 def testCMesh2(self):
1882 mesh1=MEDCouplingCMesh.New();
1883 coordsX1=DataArrayDouble.New();
1884 arrX1=[ -1., 1., 2., 4. ]
1885 coordsX1.setValues(arrX1, 4, 1);
1886 coordsY1=DataArrayDouble.New();
1887 arrY1=[ -2., 2., 4., 8. ]
1888 coordsY1.setValues(arrY1, 4, 1);
1889 coordsZ1=DataArrayDouble.New();
1890 arrZ1=[ -3., 3., 6., 12. ]
1891 coordsZ1.setValues(arrZ1, 4, 1);
1892 mesh1.setCoords(coordsX1, coordsY1, coordsZ1);
1894 dis=mesh1.getDistributionOfTypes();
1895 self.assertEqual(1, len(dis));
1896 self.assertEqual(NORM_HEXA8, dis[0][0]);
1897 self.assertEqual(27, dis[0][1]);
1898 self.assertEqual(-1, dis[0][2]);
1901 self.assertTrue(not mesh1.checkTypeConsistencyAndContig(dis, idsPerType));
1902 dis[0][0]=NORM_QUAD4;
1903 self.assertRaises(InterpKernelException, mesh1.checkTypeConsistencyAndContig, dis, idsPerType);
1904 dis[0][0]=NORM_HEXA8;
1906 ids=DataArrayInt.New();
1908 ids.fillWithValue(23);
1910 check=mesh1.checkTypeConsistencyAndContig(dis, idsPerType);
1911 self.assertTrue(check);
1912 self.assertTrue(check.isEqual(ids));
1914 code, idsInPflPerType, pfls=mesh1.splitProfilePerType(ids);
1915 self.assertEqual(1, len(code));
1916 self.assertEqual(NORM_HEXA8, code[0][0]);
1917 self.assertEqual(10, code[0][1]);
1918 self.assertEqual(0, code[0][2]);
1919 self.assertEqual(1, len(idsInPflPerType));
1920 self.assertEqual(1, len(pfls));
1921 self.assertTrue(idsInPflPerType[0].isEqual(DataArrayInt([0,1,2,3,4,5,6,7,8,9])));
1922 self.assertTrue(pfls[0].isEqual(ids));
1924 cells1=[0, 1, 25, 26]
1925 partMesh1=mesh1.buildPart(cells1)
1926 self.assertTrue(isinstance(partMesh1,MEDCouplingMesh))
1927 self.assertEqual(4, partMesh1.getNumberOfCellsWithType(NORM_HEXA8));
1928 self.assertEqual(64, mesh1.getNumberOfNodes());
1929 self.assertEqual(64, partMesh1.getNumberOfNodes());
1932 partMesh2, arr1=mesh1.buildPartAndReduceNodes(cells2)
1933 self.assertTrue(isinstance(partMesh2,MEDCouplingCMesh))
1934 self.assertEqual(2,partMesh2.getNumberOfCellsWithType(NORM_HEXA8));
1935 self.assertEqual(12,partMesh2.getNumberOfNodes());
1938 partMesh3, arr2=partMesh1.buildPartAndReduceNodes(cells3)
1939 self.assertTrue(isinstance(partMesh3,MEDCouplingUMesh))
1940 self.assertEqual(2, partMesh3.getNumberOfCellsWithType(NORM_HEXA8));
1941 self.assertEqual(12, partMesh3.getNumberOfNodes());
1943 self.assertRaises(InterpKernelException, mesh1.simplexize, 0);
1944 self.assertRaises(InterpKernelException, mesh1.getMeasureFieldOnNode, True);
1948 bbox1=mesh1.getBoundingBox(); #[(-1.0, 4.0), (-2.0, 8.0), (-3.0, 12.0)]
1949 bbox2=partMesh1.getBoundingBox();
1950 self.assertTrue(bbox1==bbox2);
1951 bbox1=partMesh3.getBoundingBox();
1952 bbox2=partMesh2.getBoundingBox();
1953 self.assertTrue(bbox1==bbox2);
1955 self.assertRaises(InterpKernelException, mesh1.buildOrthogonalField);
1956 mesh2d=MEDCouplingCMesh.New();
1957 mesh2d.setCoords(coordsX1, coordsY1);
1958 f1=mesh2d.buildOrthogonalField();
1962 def testScale(self):
1963 mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1965 mesh.scale(pos,0.5);
1966 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,
1967 -0.05,0.45, 0.2,0.45, 0.45,0.45]
1968 val=mesh.getCoords().getValues();
1969 self.assertEqual(18,len(val))
1971 self.assertTrue(abs(expected1[i]-val[i])<1e-12);
1975 def testTryToShareSameCoords(self):
1976 m1=MEDCouplingDataForTest.build2DTargetMesh_1();
1977 m2=MEDCouplingDataForTest.build2DTargetMesh_1();
1978 self.assertTrue(m1.getCoords().getHiddenCppPointer()!=m2.getCoords().getHiddenCppPointer());
1979 m1.tryToShareSameCoords(m2,1e-12);
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 m2.tryToShareSameCoords(m1,1e-12);
1984 self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1986 m1=MEDCouplingDataForTest.build2DTargetMesh_1();
1987 m2=MEDCouplingDataForTest.build2DTargetMesh_2();
1988 self.assertTrue(m1.getCoords().getHiddenCppPointer()!=m2.getCoords().getHiddenCppPointer());
1989 m1.tryToShareSameCoords(m2,1e-12);
1990 self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1991 m1.tryToShareSameCoords(m2,1e-12);
1992 self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1993 m2.tryToShareSameCoords(m1,1e-12);
1994 self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1996 m1=MEDCouplingDataForTest.build2DTargetMesh_1();
1997 m2=MEDCouplingDataForTest.build2DSourceMesh_1();
1998 self.assertTrue(m1.getCoords().getHiddenCppPointer()!=m2.getCoords().getHiddenCppPointer());
1999 self.assertRaises(InterpKernelException,m1.tryToShareSameCoords,m2,1e-12)
2002 def testFindNodeOnPlane(self):
2003 mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
2006 n=mesh.findNodesOnPlane(pt,v,1e-12);
2007 self.assertEqual(9,len(n));
2008 m3dSurf=mesh.buildFacePartOfMySelfNode(n,True);
2009 self.assertTrue(isinstance(m3dSurf,MEDCouplingUMesh))
2010 me=MEDCouplingMappedExtrudedMesh.New(mesh,m3dSurf,0);
2011 da=me.getMesh3DIds();
2012 self.assertEqual(8,me.getNumberOfCells());
2013 expected=[0,1,2,3,4,5,6,7]
2015 self.assertEqual(expected,list(val));
2017 m3dSurf=mesh.buildFacePartOfMySelfNode(n,True);
2018 self.assertTrue(isinstance(m3dSurf,MEDCouplingUMesh))
2019 me=MEDCouplingMappedExtrudedMesh.New(mesh,m3dSurf,0);
2020 da=me.getMesh3DIds();
2021 self.assertEqual(8,me.getNumberOfCells());
2022 expected=[0,1,2,3,4,5,6,7]
2024 self.assertEqual(expected,list(val));
2027 def testRenumberCells(self):
2028 m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2029 m2=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2030 self.assertTrue(m.isEqual(m2,0));
2032 m.renumberCells(arr,True);
2033 self.assertTrue(not m.isEqual(m2,0));
2034 self.assertEqual(NORM_QUAD4,m.getTypeOfCell(0));
2035 self.assertEqual(NORM_TRI3,m.getTypeOfCell(1));
2036 self.assertEqual(NORM_QUAD4,m.getTypeOfCell(2));
2037 self.assertEqual(NORM_TRI3,m.getTypeOfCell(3));
2038 self.assertEqual(NORM_QUAD4,m.getTypeOfCell(4));
2040 m.renumberCells(arr2,True);
2041 self.assertTrue(m.isEqual(m2,0));
2044 def testChangeSpaceDimension(self):
2045 m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2046 m2=MEDCouplingDataForTest.build2DTargetMesh_1();
2048 self.assertEqual(3,m1.getSpaceDimension());
2049 m1.changeSpaceDimension(2);
2050 self.assertEqual(2,m1.getSpaceDimension());
2051 m1.setName(m2.getName());
2052 self.assertTrue(m1.isEqual(m2,1e-12));
2053 m1.changeSpaceDimension(3);
2054 self.assertEqual(3,m1.getSpaceDimension());
2055 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.]
2056 val=m1.getCoords().getValues();
2058 self.assertTrue(abs(expected[i]-val[i])<1e-14);
2062 def testGaussPointField1(self):
2063 _a=0.446948490915965;
2064 _b=0.091576213509771;
2065 _p1=0.11169079483905;
2066 _p2=0.0549758718227661;
2067 refCoo1=[ 0.,0., 1.,0., 0.,1. ]
2068 gsCoo1=[ 2*_b-1, 1-4*_b, 2*_b-1, 2.07*_b-1, 1-4*_b,
2069 2*_b-1, 1-4*_a, 2*_a-1, 2*_a-1, 1-4*_a, 2*_a-1, 2*_a-1 ]
2070 wg1=[ 4*_p2, 4*_p2, 4*_p2, 4*_p1, 4*_p1, 4*_p1 ]
2075 m=MEDCouplingDataForTest.build2DTargetMesh_1();
2076 f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,NO_TIME);
2078 self.assertEqual(5,f.getNumberOfMeshPlacesExpected());
2079 self.assertEqual(0,f.getNbOfGaussLocalization());
2080 f.setGaussLocalizationOnType(NORM_TRI3,_refCoo1,_gsCoo1,_wg1);
2081 f.setGaussLocalizationOnType(NORM_TRI3,_refCoo1,_gsCoo1,_wg1); # not a bug only to check that it works well
2082 self.assertRaises(InterpKernelException,f.setGaussLocalizationOnType,NORM_QUAD4,_refCoo1,_gsCoo1,_wg1)
2083 self.assertEqual(1,f.getNbOfGaussLocalization());
2084 refCoo2=[ 0.,0., 1.,0., 1.,1., 0.,1. ]
2086 _gsCoo1=_gsCoo1[0:4]
2088 f.setGaussLocalizationOnType(NORM_QUAD4,_refCoo2,_gsCoo1,_wg1);
2089 self.assertEqual(2,f.getNbOfGaussLocalization());
2090 array=DataArrayDouble.New();
2092 for i in range(18 * 2):
2094 array.setValues(ptr,18,2);
2095 ptr=array.getPointer();
2097 f.setName("MyFirstFieldOnGaussPoint");
2098 f.checkConsistencyLight();
2099 self.assertAlmostEqual(27.,f.getIJK(2,5,0),14);
2100 self.assertAlmostEqual(16.,f.getIJK(1,5,1),14);
2102 f.clearGaussLocalizations();
2103 self.assertEqual(0,f.getNbOfGaussLocalization());
2104 self.assertRaises(InterpKernelException,f.checkConsistencyLight);
2106 self.assertRaises(InterpKernelException,f.setGaussLocalizationOnCells,ids1,_refCoo2,_gsCoo1,_wg1);
2107 self.assertEqual(0,f.getNbOfGaussLocalization());
2109 f.setGaussLocalizationOnCells(ids2,_refCoo2,_gsCoo1,_wg1);
2110 self.assertEqual(1,f.getNbOfGaussLocalization());
2111 self.assertEqual(0,f.getGaussLocalizationIdOfOneCell(0));
2112 self.assertRaises(InterpKernelException,f.getGaussLocalizationIdOfOneCell,1);
2114 f.setGaussLocalizationOnCells(ids3,_refCoo1,_gsCoo1,_wg1);
2115 self.assertEqual(2,f.getNbOfGaussLocalization());
2116 self.assertEqual(0,f.getGaussLocalizationIdOfOneCell(0));
2117 self.assertEqual(1,f.getGaussLocalizationIdOfOneCell(1));
2118 self.assertEqual(1,f.getGaussLocalizationIdOfOneCell(2));
2119 self.assertRaises(InterpKernelException,f.checkConsistencyLight);#<- cell 3 has no localization
2123 _gsCoo2[0]=0.8888777776666;
2124 _wg2[0]=0.1234567892377;
2125 f.setGaussLocalizationOnCells(ids4,_refCoo2,_gsCoo2,_wg2);
2126 self.assertEqual(3,f.getNbOfGaussLocalization());
2127 tmpIds=f.getCellIdsHavingGaussLocalization(0);
2128 self.assertEqual(ids2,list(tmpIds.getValues()));
2129 self.assertRaises(InterpKernelException,f.checkConsistencyLight);#<- it's always not ok because undelying array not with the good size.
2130 array2=f.getArray().subArray(0,10);
2132 f.checkConsistencyLight();#<- here it is OK
2134 self.assertTrue(f.isEqual(f2,1e-14,1e-14));
2135 gl1=f2.getGaussLocalization(0);
2136 tmp=gl1.getGaussCoord(1,1);
2137 self.assertAlmostEqual(2.07*_b-1,tmp,14);
2138 gl1.setGaussCoord(1,1,0.07);
2139 self.assertTrue(not f.isEqual(f2,1e-14,1e-14));
2140 gl1.setGaussCoord(1,1,tmp);
2141 self.assertTrue(f.isEqual(f2,1e-14,1e-14));
2142 f2.checkConsistencyLight();
2145 def testGaussPointNEField1(self):
2146 m=MEDCouplingDataForTest.build2DTargetMesh_1();
2147 f=MEDCouplingFieldDouble.New(ON_GAUSS_NE,NO_TIME);
2149 self.assertEqual(5,f.getNumberOfMeshPlacesExpected());
2150 f.setName("MyFirstFieldOnNE");
2151 f.setDescription("MyDescriptionNE");
2152 array=DataArrayDouble.New();
2154 for i in range(18 * 2):
2157 array.setValues(tmp,18,2);
2158 ptr=array.getPointer();
2161 f.checkConsistencyLight();
2163 self.assertTrue(f.isEqual(f2,1e-14,1e-14));
2164 self.assertAlmostEqual(21.,f.getIJK(2,0,0),14);
2165 self.assertAlmostEqual(18.,f.getIJK(1,1,1),14);
2168 def testCellOrientation1(self):
2169 m=MEDCouplingDataForTest.build2DTargetMesh_1();
2171 self.assertRaises(InterpKernelException,m.are2DCellsNotCorrectlyOriented,vec,False);
2172 m.changeSpaceDimension(3);
2173 res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2174 self.assertTrue(len(res1)==0);
2176 res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2177 self.assertEqual(5,len(res1));
2180 # connectivity inversion
2181 conn=m.getNodalConnectivity().getValues();
2185 m.getNodalConnectivity().setValues(conn,len(conn),1)
2186 res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2187 self.assertEqual(1,len(res1));
2188 self.assertEqual(2,res1.getValues()[0]);
2189 m.orientCorrectly2DCells(vec,False);
2190 res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2191 self.assertTrue(len(res1)==0);
2192 m2=MEDCouplingDataForTest.build2DTargetMesh_1();
2193 m2.changeSpaceDimension(3);
2194 self.assertTrue(m.isEqual(m2,1e-12));
2197 def testCellOrientation2(self):
2198 m2,m1=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
2199 res1=m2.arePolyhedronsNotCorrectlyOriented();
2200 self.assertEqual(6,len(res1));
2201 m2.orientCorrectlyPolyhedrons();
2202 res1=m2.arePolyhedronsNotCorrectlyOriented();
2203 self.assertTrue(len(res1)==0);
2204 m2.checkConsistencyLight();
2205 self.assertEqual(18,m2.getNumberOfCells());
2207 m2.convertToPolyTypes(cellIds2);
2208 m2.orientCorrectlyPolyhedrons();
2209 res1=m2.arePolyhedronsNotCorrectlyOriented();
2210 self.assertTrue(len(res1)==0);
2211 f2=m2.getMeasureField(False);
2212 f2Ptr=f2.getArray().getValues();
2213 #Test to check global reverse in MEDCouplingUMesh::tryToCorrectPolyhedronOrientation
2214 m3=MEDCouplingDataForTest.build2DTargetMesh_1();
2216 m3.changeSpaceDimension(3);
2218 m3.convertToPolyTypes(ids2);
2219 m3.orientCorrectly2DCells(vec,False);
2220 m4=MEDCouplingDataForTest.buildCU1DMesh_U();
2221 m4.changeSpaceDimension(3);
2224 m4.rotate(center,vector,-pi/2.);
2225 m5=m3.buildExtrudedMesh(m4,0);
2226 res1=m5.arePolyhedronsNotCorrectlyOriented();
2227 self.assertEqual(15,len(res1));
2228 m5.orientCorrectlyPolyhedrons();
2229 res1=m5.arePolyhedronsNotCorrectlyOriented();
2230 self.assertTrue(len(res1)==0);
2231 f3=m5.getMeasureField(False);
2232 self.assertEqual(15,f3.getArray().getNumberOfTuples());
2233 self.assertEqual(1,f3.getNumberOfComponents());
2234 f3Ptr=f3.getArray().getValues();
2235 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];
2237 self.assertTrue(abs(expected1[i]-f3Ptr[i])<1e-12);
2239 f4=m5.computeCellCenterOfMass();
2240 self.assertEqual(15,f4.getNumberOfTuples());
2241 self.assertEqual(3,f4.getNumberOfComponents());
2242 f4Ptr=f4.getValues();
2243 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];
2245 self.assertTrue(abs(expected2[i]-f4Ptr[i])<1e-12);
2249 def testCellOrientation3(self):
2250 from cmath import rect
2252 c = [rect(1.0, i * pi / 4.0) for i in range(8)]
2253 coords = [c[-1].real,c[-1].imag, c[3].real,c[3].imag,
2254 c[5].real,c[5].imag, c[1].real,c[1].imag]
2256 baseMesh = MEDCouplingUMesh.New("circle", 2)
2257 baseMesh.allocateCells(1)
2258 meshCoords = DataArrayDouble.New(coords, 4, 2)
2259 baseMesh.setCoords(meshCoords)
2260 baseMesh.insertNextCell(NORM_QPOLYG, connec) # a circle
2261 baseMesh.finishInsertingCells()
2262 baseMesh.changeSpaceDimension(3)
2263 Oz = [0.0, 0.0, -1.0]
2264 cell_lst = baseMesh.are2DCellsNotCorrectlyOriented(Oz, False)
2265 self.assertEqual(cell_lst.getNumberOfTuples(), 0)
2267 cell_lst = baseMesh.are2DCellsNotCorrectlyOriented(Oz, False)
2268 self.assertEqual(cell_lst.getNumberOfTuples(), 1)
2270 def testCellOrientation4(self):
2271 """ Non regression for NORM_QPOLYG whose linear version is self-intersecting. """
2272 mesh = MEDCouplingUMesh('merge', 2)
2273 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)])
2275 c = DataArrayInt([32, 9, 8, 6, 4, 0, 2, 10, 13, 1, 7, 5, 3, 11, 12])
2276 cI = DataArrayInt([0, 15])
2277 mesh.setConnectivity(c, cI)
2279 mesh.changeSpaceDimension(3)
2280 mesh.orientCorrectly2DCells(vec, False)
2281 mesh.changeSpaceDimension(2)
2282 cRef = [32, 9, 10, 2, 0, 4, 6, 8, 12, 11, 3, 5, 7, 1, 13]
2284 self.assertEqual(mesh.getNodalConnectivity().getValues(), cRef)
2285 self.assertEqual(mesh.getNodalConnectivityIndex().getValues(), cIRef)
2288 def testPolyhedronBarycenter(self):
2289 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];
2290 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];
2291 meshN=MEDCouplingUMesh.New();
2292 meshN.setName("ForBary");
2293 meshN.setMeshDimension(3);
2294 meshN.allocateCells(4);
2295 meshN.insertNextCell(NORM_POLYHED,29,connN[0:29])
2296 meshN.finishInsertingCells();
2297 myCoords=DataArrayDouble.New();
2298 myCoords.setValues(coords,9,3);
2299 meshN.setCoords(myCoords);
2300 meshN.checkConsistencyLight();
2302 res1=meshN.arePolyhedronsNotCorrectlyOriented();
2303 meshN.orientCorrectlyPolyhedrons();
2304 self.assertTrue(len(res1)==0);
2305 da=meshN.computeCellCenterOfMass();
2306 self.assertEqual(1,da.getNumberOfTuples());
2307 self.assertEqual(3,da.getNumberOfComponents());
2308 daPtr=da.getValues();
2309 ref=meshN.getCoords().getValues()[24:];
2311 self.assertTrue(abs(ref[i]-daPtr[i])<1e-12);
2316 da=meshN.computeCellCenterOfMass();
2317 daPtr=da.getValues();
2318 ref=meshN.getCoords().getValues()[24:];
2320 self.assertTrue(abs(ref[i]-daPtr[i])<1e-12);
2323 meshN.rotate(center,vec,pi/7.);
2324 meshN.translate(vec);
2325 da=meshN.computeCellCenterOfMass();
2326 daPtr=da.getValues();
2327 ref=meshN.getCoords().getValues()[24:];
2329 self.assertTrue(abs(ref[i]-daPtr[i])<1e-12);
2332 center2=[1.12,3.45,6.78]
2334 meshN.rotate(center2,vec2,e);
2335 meshN.translate(vec2);
2336 da=meshN.computeCellCenterOfMass();
2337 daPtr=da.getValues();
2338 ref=meshN.getCoords().getValues()[24:];
2340 self.assertTrue(abs(ref[i]-daPtr[i])<1e-10);
2344 def testNormL12Integ1D(self):
2345 m1=MEDCouplingDataForTest.build1DTargetMesh_3();
2346 f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2348 array=DataArrayDouble.New();
2349 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]
2350 array.setValues(arr,m1.getNumberOfCells(),3);
2353 f3=m1.computeCellCenterOfMass();
2354 self.assertEqual(4,f3.getNumberOfTuples());
2355 self.assertEqual(1,f3.getNumberOfComponents());
2356 expected9=[0.75,5.105,0.8,5.155]
2359 self.assertTrue(abs(expected9[i]-ptr[i])<1e-12);
2362 f2=m1.getMeasureField(False);
2363 self.assertEqual(4,f2.getArray().getNumberOfTuples());
2364 self.assertEqual(1,f2.getNumberOfComponents());
2365 expected1=[0.5,0.21,-0.6,-0.31]
2366 ptr=f2.getArray().getValues();
2368 self.assertTrue(abs(expected1[i]-ptr[i])<1e-12);
2370 expected2=[0.5,0.21,0.6,0.31]
2371 f2=m1.getMeasureField(True);
2372 ptr=f2.getArray().getValues();
2374 self.assertTrue(abs(expected2[i]-ptr[i])<1e-12);
2377 self.assertTrue(4,f1.getNumberOfTuples())
2378 res=f1.integral(False);
2379 self.assertTrue(3,len(res))
2380 expected3=[0.9866,-0.3615,0.4217]
2382 self.assertTrue(abs(expected3[i]-res[i])<1e-12);
2384 self.assertTrue(abs(expected3[0]-f1.integral(0,False))<1e-12);
2385 self.assertTrue(abs(expected3[1]-f1.integral(1,False))<1e-12);
2386 self.assertTrue(abs(expected3[2]-f1.integral(2,False))<1e-12);
2387 res=f1.integral(True);
2388 expected4=[-3.4152,8.7639,-14.6879]
2390 self.assertTrue(abs(expected4[i]-res[i])<1e-12);
2394 self.assertTrue(3,len(res))
2395 expected5=[6.979506172839505, 16.89018518518518, 27.02969135802469]
2397 self.assertTrue(abs(expected5[i]-res[i])<1e-12);
2399 self.assertTrue(abs(expected5[0]-f1.normL1(0))<1e-12);
2400 self.assertTrue(abs(expected5[1]-f1.normL1(1))<1e-12);
2401 self.assertTrue(abs(expected5[2]-f1.normL1(2))<1e-12);
2404 self.assertTrue(3,len(res))
2405 expected7=[7.090910979452395, 16.9275542960123, 27.053271464160858]
2407 self.assertTrue(abs(expected7[i]-res[i])<1e-9);
2409 self.assertTrue(abs(expected7[0]-f1.normL2(0))<1e-9);
2410 self.assertTrue(abs(expected7[1]-f1.normL2(1))<1e-9);
2411 self.assertTrue(abs(expected7[2]-f1.normL2(2))<1e-9);
2413 f4=f1.buildMeasureField(False);
2414 self.assertTrue(abs(-0.2-f4.accumulate(0))<1e-12);
2415 f4=f1.buildMeasureField(True);
2416 self.assertTrue(abs(1.62-f4.accumulate(0))<1e-12);
2417 # Testing with 2D Curve
2418 m1=MEDCouplingDataForTest.build2DCurveTargetMesh_3();
2419 f2=m1.getMeasureField(False);
2420 self.assertEqual(4,f2.getArray().getNumberOfTuples());
2421 self.assertEqual(1,f2.getNumberOfComponents());
2422 ptr=f2.getArray().getValues();
2424 self.assertTrue(abs(sqrt(2.)*expected2[i]-ptr[i])<1e-12);
2426 f2=m1.getMeasureField(True);
2427 self.assertEqual(4,f2.getArray().getNumberOfTuples());
2428 self.assertEqual(1,f2.getNumberOfComponents());
2429 ptr=f2.getArray().getValues();
2431 self.assertTrue(abs(expected2[i]*sqrt(2.)-ptr[i])<1e-12);
2434 f3=m1.computeCellCenterOfMass();
2435 self.assertEqual(4,f3.getNumberOfTuples());
2436 self.assertEqual(2,f3.getNumberOfComponents());
2437 expected10=[0.75,0.75,5.105,5.105,0.8,0.8,5.155,5.155]
2440 self.assertTrue(abs(expected10[i]-ptr[i])<1e-12);
2443 f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2445 array=DataArrayDouble.New();
2446 array.setValues(arr,m1.getNumberOfCells(),3);
2448 res=f1.integral(False);
2450 self.assertTrue(abs(sqrt(2.)*expected4[i]-res[i])<1e-12);
2452 res=f1.integral(True);
2454 self.assertTrue(abs(sqrt(2.)*expected4[i]-res[i])<1e-12);
2458 self.assertTrue(abs(expected5[i]-res[i])<1e-12);
2462 self.assertTrue(abs(expected7[i]-res[i])<1e-12);
2466 def testAreaBary2D(self):
2467 m1=MEDCouplingDataForTest.build2DTargetMesh_3();
2468 f1=m1.getMeasureField(False);
2469 self.assertEqual(10,f1.getArray().getNumberOfTuples());
2470 self.assertEqual(1,f1.getNumberOfComponents());
2471 expected1=[-0.5,-1,-1.5,-0.5,-1, 0.5,1,1.5,0.5,1]
2472 ptr=f1.getArray().getValues();
2474 self.assertTrue(abs(expected1[i]-ptr[i])<1e-12);
2476 f1=m1.getMeasureField(True);
2477 ptr=f1.getArray().getValues();
2479 self.assertTrue(abs(abs(expected1[i])-ptr[i])<1e-12);
2481 f2=m1.computeCellCenterOfMass();
2482 self.assertEqual(10,f2.getNumberOfTuples());
2483 self.assertEqual(2,f2.getNumberOfComponents());
2484 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]
2487 self.assertTrue(abs(expected2[i]-ptr[i])<1e-12);
2489 m1.changeSpaceDimension(3);
2490 f1=m1.getMeasureField(False);
2491 self.assertEqual(10,f1.getArray().getNumberOfTuples());
2492 self.assertEqual(1,f1.getNumberOfComponents());
2493 ptr=f1.getArray().getValues();
2495 self.assertTrue(abs(abs(expected1[i])-ptr[i])<1e-12);
2497 f2=m1.computeCellCenterOfMass();
2498 self.assertEqual(10,f2.getNumberOfTuples());
2499 self.assertEqual(3,f2.getNumberOfComponents());
2501 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.]
2503 self.assertTrue(abs(expected3[i]-ptr[i])<1e-12);
2507 def testAreaBary3D(self):
2508 coords=[ 0.241310763507 , 0.0504777305619 , 0.0682283524903 , 0.252501053866 , -0.0625176732937 , 0.137272639894 ,
2509 0.152262663601 , 0.241816569527 , 0.133812556197 , 0.18047750211 , -0.0789949051358 , 0.339098173401 ,
2510 0.151741971857 , 0.238885278571 , 0.137715037333 , 0.242532155481 , -0.0928169086456 , 0.0678043417367 ,
2511 0.240941965335 , -0.015461491464 , 0.0617186345825 , 0.24127650112 , 0.0499427876717 , 0.0679634099148 ,
2512 -0.145828917428 , 0.206291632565 , 0.0310071927543 , 0.0125651775307 , 0.266262085828 , 0.105228430543 ,
2513 -0.0994066533286 , 0.233224271238 , 0.0572213839567 , -0.0951345338317 , 0.234819509426 , 0.0592126284538 ,
2514 0.136580574205 , -0.205486212579 , 0.0572866072014 , 0.0637270784978 , -0.168886355238 , 0.446614057077 ,
2515 0.041337157151 , -0.213402568198 , 0.372407095999 , 0.0411601970268 , -0.202387875756 , 0.411334979491 ,
2516 -0.108355701857 , 0.193636239335 , 0.204886756738 , 0.00639779029829 , 0.155296981517 , 0.252585892979 ,
2517 0.0262473111702 , -0.112919732543 , 0.424286639249 ,-0.224103052733 , -0.139430015438 , -0.0122352295701 ,
2518 -0.0312760589481 , -0.274272003594 , 0.0323959636568 , -0.166663422532 , -0.217754445175 , 0.00392109070364 ,
2519 -0.30586619777 , -0.0475168041091 , -0.0144585228182 , -0.280881480586 , 0.135571293538 , 0.00623923647986 ,
2520 -0.25548538234 , 0.156819217766 , 0.0645277879769 , -0.131567009284 , 0.184133752309 , 0.206021802753 ,
2521 -0.196204010965 , 0.151602971681 , 0.212974777736 , -0.183713879463 , 0.0802946639531 , 0.260115662599 ,
2522 -0.244241178767 , -0.0738873389604 , 0.144590565817 , -0.155804057829 , -0.164892720025 , 0.210613950558 ,
2523 -0.170950800428 , -0.215099334026 , 0.00610122860092 , -0.30552634869 , -0.0490020791904 , -0.0132786533145 ,
2524 0.271831011884 , 0.15105657296 , 0.0230534827908 , 0.281919192283 , 0.0898544306288 , -0.0625201489143 ,
2525 0.260240727276 , -0.0120688706637 , -0.0532316588626 , 0.244947737722 , 0.0197984684293 , 0.0309341209233 ,
2526 0.23439631578 , 0.229825279875 , 0.0508520585381 , 0.160921316875 , 0.265078502128 , 0.121716560626 ,
2527 -0.315088694175 , 0.0747700471918 , -0.245836615071 , -0.327728781776 , 0.0857114674649 , -0.239431905957 ,
2528 -0.308385460634 , 0.145142997084 , -0.149886828433 , 0.0488236045164 , 0.309462801914 , 0.0849169148265 ,
2529 -0.0244964803395 , 0.33145611751 , -0.0476415818061 , 0.0060567994229 , 0.32418412014 , 0.0367779543812 ,
2530 -0.0950221448063 , 0.236675326003 , 0.0572594453983 , 0.248723023186 , 0.0886648784791 , -0.176629430538 ,
2531 0.116796984 , 0.256596599567 , -0.292863523603 , 0.118024552914 , 0.229154257843 , -0.34233232501 ,
2532 0.217507892549 , -0.0417822335742 , -0.176771782888 , -0.224429321304 , 0.0125595300114 , -0.362064725588 ,
2533 0.0937301100955 , -0.0500824832657 , -0.299713548444 , -0.244162220397 , 0.0383853931293 , -0.389856984411 ,
2534 -0.0281989366102 , 0.097392811563 , -0.458244577284 , -0.385010847162 , 0.10122766194 , -0.140052859922 ,
2535 -0.377936358012 , 0.110875172128 , -0.176207095463 , 0.244483045556 , -0.0991073977045 , 0.0575134372934 ,
2536 0.262605120167 , -0.100243191645 , -0.0495620806935 , 0.240306880972 , -0.136153701579 , -0.114745281696 ,
2537 0.215763176129 , -0.0836766059189 , -0.183249640616 , 0.237870396603 , -0.132449578286 , -0.121598854639 ,
2538 -0.0637683083097 , -0.27921020214 , -0.149112321992 , -0.0856211014977 , -0.2973233473 , -0.0446878139589 ,
2539 0.104675342288 , -0.0625908305324 , -0.290346256534 , 0.0248264249186 , -0.247797708548 , -0.165830884019 ,
2540 0.0719302438309 , -0.178468260473 , -0.211432157345 , 0.142871843159 , -0.208769948542 , 0.0454101128246 ,
2541 0.167803379307 , -0.207851396623 , -0.088802726124 , 0.12868717152 , -0.230920439715 , 0.00760508389036 ,
2542 -0.0372812069535 , -0.286740286332 , 0.00963701291166 ]
2544 connN = [ #polyhedron 0
2545 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
2546 , 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
2547 , 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
2548 , 22 , 19 , 21 , 30 , 31 , -1 , 22 , 31 , 28 , 27 , 26 , 24 , 23 , -1 , 31 , 30 , 29 , 28,
2550 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
2551 , 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
2552 , 33 , 34 , 48 , 45 , -1 , 35 , 34 , 48 , 50 , 49 , 38 , -1 , 41 , 43 , 42 , 46 , 36 , 37 , -1 , 38 , 39 , 51 , 49 , -1
2553 , 39 , 40 , 42 , 46 , 47 , 52 , 51 , -1 , 45 , 47 , 52 , 50 , 48 , -1 , 52 , 51 , 49 , 50,
2555 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
2556 , 23 , 53 , 54 , 40 , 8 , -1 , 53 , 22 , 23 , -1 , 39 , 54 , 40,
2558 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
2559 , 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
2560 , 55 , 5 , 12 , 65 , -1 , 66 , 67 , 65 , 55 , 56 , 57 , -1 , 63 , 66 , 57 , 59 , 64 , -1 , 64 , 62 , 58 , 59 , -1
2561 , 60 , 63 , 66 , 67 , 68 , 61 , -1 , 61 , 68 , 20 , 21 , -1 , 67 , 68 , 20 , 12 , 65]
2563 barys = [ -0.0165220465527 , -0.0190922868195 , 0.158882733414 ,
2564 0.0287618656076 , 0.135874379934 , -0.14601588119 ,
2565 -0.147128055553 , 0.0465995097041 , -0.049391174453 ,
2566 -0.00142506732317 , -0.0996953090351 , -0.115159183132 ]
2567 meshN=MEDCouplingUMesh.New();
2568 meshN.setName("ForBary");
2569 meshN.setMeshDimension(3);
2570 meshN.allocateCells(4);
2571 meshN.insertNextCell(NORM_POLYHED,113,connN);
2572 meshN.insertNextCell(NORM_POLYHED,99,connN[113:]);
2573 meshN.insertNextCell(NORM_POLYHED,43,connN[212:]);
2574 meshN.insertNextCell(NORM_POLYHED,92,connN[255:]);
2575 meshN.finishInsertingCells();
2576 myCoords=DataArrayDouble.New();
2577 myCoords.setValues(coords,69,3);
2578 meshN.setCoords(myCoords);
2579 meshN.checkConsistencyLight();
2580 res1=meshN.arePolyhedronsNotCorrectlyOriented();
2581 meshN.orientCorrectlyPolyhedrons();
2582 res1=meshN.arePolyhedronsNotCorrectlyOriented();
2583 self.assertTrue(len(res1)==0);
2585 da=meshN.computeCellCenterOfMass();
2586 self.assertEqual(4,da.getNumberOfTuples());
2587 self.assertEqual(3,da.getNumberOfComponents());
2588 daPtr=da.getValues();
2590 self.assertTrue(abs(barys[i]-daPtr[i])<1e-12);
2594 def testRenumberCellsForFields(self):
2595 m=MEDCouplingDataForTest.build2DTargetMesh_1();
2596 f=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2598 arr=DataArrayDouble.New();
2599 nbOfCells=m.getNumberOfCells();
2600 values1=[7.,107.,10007.,8.,108.,10008.,9.,109.,10009.,10.,110.,10010.,11.,111.,10011.]
2601 arr.setValues(values1,nbOfCells,3);
2603 renumber1=[3,1,0,4,2]
2604 loc=[-0.05,-0.05, 0.55,-0.25, 0.55,0.15, -0.05,0.45, 0.45,0.45]
2606 res=f.getValueOn(loc[2*j:2*j+2]);
2608 self.assertTrue(abs(values1[i+3*j]-res[i])<1e-12);
2611 f.renumberCells(renumber1,False);
2612 ptr=f.getArray().getValues();
2613 expected1=[9.,109.,10009.,8.,108.,10008.,11.,111.,10011.,7.,107.,10007.,10.,110.,10010.]
2615 self.assertTrue(abs(expected1[i]-ptr[i])<1e-12);
2617 #check that fields remains the same geometrically
2619 res=f.getValueOn(loc[2*j:2*(j+1)]);
2621 self.assertTrue(abs(values1[i+3*j]-res[i])<1e-12);
2625 f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,NO_TIME);
2627 _a=0.446948490915965;
2628 _b=0.091576213509771;
2629 _p1=0.11169079483905;
2630 _p2=0.0549758718227661;
2631 refCoo1=[ 0.,0., 1.,0., 0.,1. ]
2632 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 ];
2633 wg1=[ 4*_p2, 4*_p2, 4*_p2, 4*_p1, 4*_p1, 4*_p1 ]
2634 _refCoo1=refCoo1[0:6];
2635 _gsCoo1=gsCoo1[0:12];
2637 f.setGaussLocalizationOnType(NORM_TRI3,_refCoo1,_gsCoo1,_wg1);
2638 refCoo2=[ 0.,0., 1.,0., 1.,1., 0.,1. ]
2639 _refCoo2=refCoo2[0:8];
2640 _gsCoo1=_gsCoo1[0:4]
2642 f.setGaussLocalizationOnType(NORM_QUAD4,_refCoo2,_gsCoo1,_wg1);
2643 arr=DataArrayDouble.New();
2644 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.]
2645 arr.setValues(values2,18,2);
2647 f.checkConsistencyLight();
2649 self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2650 f.renumberCells(renumber1,False);
2651 self.assertTrue(not f.isEqual(fCpy,1e-12,1e-12));
2652 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.]
2653 ptr=f.getArray().getValues();
2655 self.assertTrue(abs(expected2[i]-ptr[i])<1e-12);
2657 renumber2=[2,1,4,0,3]
2658 f.renumberCells(renumber2,False);
2659 self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2661 f=MEDCouplingFieldDouble.New(ON_GAUSS_NE,NO_TIME);
2663 arr=DataArrayDouble.New();
2664 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.]
2665 arr.setValues(values3,18,2);
2667 f.checkConsistencyLight();
2669 self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2670 f.renumberCells(renumber1,False);
2671 self.assertTrue(not f.isEqual(fCpy,1e-12,1e-12));
2672 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.]
2673 ptr=f.getArray().getValues();
2675 self.assertTrue(abs(expected3[i]-ptr[i])<1e-12);
2677 f.renumberCells(renumber2,False);#perform reverse operation of renumbering to check that the resulting field is equal.
2678 self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2682 def testRenumberNodesForFields(self):
2683 m=MEDCouplingDataForTest.build2DTargetMesh_1();
2684 f=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
2686 self.assertEqual(9,f.getNumberOfMeshPlacesExpected());
2687 arr=DataArrayDouble.New();
2688 nbOfNodes=m.getNumberOfNodes();
2689 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.]
2690 arr.setValues(values1,nbOfNodes,3);
2692 f.checkConsistencyLight();
2693 renumber1=[0,4,1,3,5,2,6,7,8]
2694 loc=[0.5432,-0.2432, 0.5478,0.1528]
2695 expected1=[9.0272, 109.0272, 10009.0272, 11.4124,111.4124,10011.4124]
2697 res=f.getValueOn(loc[2*j:2*j+2]);
2699 self.assertTrue(abs(expected1[i+3*j]-res[i])<1e-12);
2703 self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2704 f.renumberNodes(renumber1);
2705 self.assertTrue(not f.isEqual(fCpy,1e-12,1e-12));
2707 res=f.getValueOn(loc[2*j:2*j+2]);
2709 self.assertTrue(abs(expected1[i+3*j]-res[i])<1e-12);
2712 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.]
2714 self.assertTrue(abs(expected2[i]-f.getArray().getValues()[i])<1e-12);
2716 renumber2=[0,2,5,3,1,4,6,7,8]
2717 f.renumberNodes(renumber2);
2718 self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2721 def testConvertQuadraticCellsToLinear(self):
2722 mesh=MEDCouplingDataForTest.build2DTargetMesh_3();
2723 mesh.checkConsistencyLight();
2724 types=mesh.getAllGeoTypes();
2726 self.assertEqual(5,len(types));
2727 expected1 = [NORM_POLYGON, NORM_TRI3, NORM_QUAD4, NORM_TRI6, NORM_QUAD8]
2729 self.assertEqual(expected1,types);
2730 self.assertTrue(mesh.isPresenceOfQuadratic());
2731 self.assertEqual(62,mesh.getNodalConnectivityArrayLen());
2732 f1=mesh.getMeasureField(False);
2734 mesh.convertQuadraticCellsToLinear();
2735 self.assertTrue(not mesh.isPresenceOfQuadratic());
2737 mesh.checkConsistencyLight();
2738 f2=mesh.getMeasureField(False);
2739 self.assertTrue(f1.getArray().isEqual(f2.getArray(),1e-12));
2740 self.assertEqual(48,mesh.getNodalConnectivityArrayLen());
2741 types2=mesh.getAllGeoTypes();
2743 self.assertEqual(3,len(types2));
2744 expected2=[NORM_POLYGON, NORM_TRI3, NORM_QUAD4]
2746 self.assertEqual(expected2,types2);
2749 def testCheckGeoEquivalWith(self):
2750 mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2751 mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2753 cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh1,0,1e-12);#deepEqual
2754 self.assertTrue(cellCor==None);
2755 self.assertTrue(nodeCor==None);
2756 cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh1,1,1e-12);#fastEqual
2757 self.assertTrue(cellCor==None);
2758 self.assertTrue(nodeCor==None);
2759 cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh1,10,1e-12);#deepEqual with geo permutations
2760 self.assertTrue(cellCor==None);
2761 self.assertTrue(nodeCor==None);
2762 #Second test mesh1 and mesh2 are 2 different meshes instance
2763 cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,0,1e-12);#deepEqual
2764 self.assertTrue(cellCor==None);
2765 self.assertTrue(nodeCor==None);
2766 cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,1,1e-12);#fastEqual
2767 self.assertTrue(cellCor==None);
2768 self.assertTrue(nodeCor==None);
2769 cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);#deepEqual with geo permutations
2770 self.assertTrue(cellCor==None);
2771 self.assertTrue(nodeCor==None);
2772 #Third test : cell permutation by keeping the first the middle and the last as it is.
2773 renum=[0,2,1,3,4,5,6,8,7,9]
2774 mesh2.renumberCells(renum,False);
2775 self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12);#deepEqual fails
2776 self.assertTrue(cellCor==None);
2777 self.assertTrue(nodeCor==None);
2778 cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,1,1e-12);#fastEqual do not see anything
2779 self.assertTrue(cellCor==None);
2780 self.assertTrue(nodeCor==None);
2781 cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);#deepEqual with geo permutations
2782 self.assertTrue(cellCor);
2783 self.assertEqual(10,cellCor.getNumberOfTuples());
2784 self.assertEqual(1,cellCor.getNumberOfComponents());
2785 self.assertEqual(renum,list(cellCor.getValues()))
2786 self.assertTrue(nodeCor==None);
2788 self.assertTrue(nodeCor==None);
2789 a,b=mesh1.checkDeepEquivalWith(mesh2,0,1e-12);
2790 self.assertEqual(renum,list(a.getValues()))
2791 self.assertTrue(b==None);
2792 mesh2.setCoords(mesh1.getCoords())
2793 a=mesh1.checkDeepEquivalOnSameNodesWith(mesh2,0,1e-12);
2794 self.assertEqual(renum,list(a.getValues()))
2795 #4th test : cell and node permutation by keeping the first the middle and the last as it is.
2796 mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2797 renum2=[0,2,1,3,4,5,6,8,7,9,10]
2798 mesh2.renumberCells(renum,False);
2799 mesh2.renumberNodes(renum2,11);
2802 self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12);#deepEqual fails
2803 self.assertTrue(cellCor==None);
2804 self.assertTrue(nodeCor==None);
2805 cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,1,1e-12);#fastEqual do not see anything
2806 self.assertTrue(cellCor==None);
2807 self.assertTrue(nodeCor==None);
2808 cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);#deepEqual with geo permutations
2809 self.assertTrue(cellCor);
2810 self.assertEqual(10,cellCor.getNumberOfTuples());
2811 self.assertEqual(1,cellCor.getNumberOfComponents());
2812 self.assertEqual(renum,list(cellCor.getValues()))
2813 self.assertTrue(nodeCor);
2814 self.assertEqual(11,nodeCor.getNumberOfTuples());
2815 self.assertEqual(1,nodeCor.getNumberOfComponents());
2816 self.assertEqual(renum2,list(nodeCor.getValues()))
2819 #5th test : modification of the last cell to check fastCheck detection.
2820 mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2821 renum3=[0,2,1,3,4,5,6,8,9,7]
2822 mesh2.renumberCells(renum3,False);
2823 mesh2.renumberNodes(renum2,11);
2826 self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12)
2827 self.assertTrue(cellCor==None);
2828 self.assertTrue(nodeCor==None);
2829 self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,1,1e-12)
2830 self.assertTrue(cellCor==None);
2831 self.assertTrue(nodeCor==None);
2832 cellCor,nodeCor=mesh2.checkGeoEquivalWith(mesh1,10,1e-12);#deepEqual with geo permutations
2833 self.assertTrue(cellCor!=None);
2834 self.assertEqual(10,cellCor.getNumberOfTuples());
2835 self.assertEqual(1,cellCor.getNumberOfComponents());
2836 self.assertEqual(renum3,list(cellCor.getValues()))
2837 self.assertTrue(nodeCor!=None);
2838 self.assertEqual(11,nodeCor.getNumberOfTuples());
2839 self.assertEqual(1,nodeCor.getNumberOfComponents());
2840 self.assertEqual(renum2,list(nodeCor.getValues()));
2843 def testCheckGeoEquivalWith2(self):
2844 mesh1=MEDCouplingDataForTest.build2DTargetMesh_4();
2845 mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
2846 cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);
2847 self.assertEqual(None,cellCor);
2848 self.assertNotEqual(None,nodeCor);
2849 expected1=[0, 1, 3, 4, 5, 6, 7, 8, 9]
2851 self.assertEqual(expected1[i],nodeCor.getIJ(i,0));
2855 def testSwig2CheckDeepEquivalWith1(self):
2857 mcart = MEDCouplingCMesh()
2858 mcart.setCoordsAt(0, DataArrayDouble([0.0,1.5,2.0]))
2859 mcart.setCoordsAt(1, DataArrayDouble([1.0,2.5,3.0,4.0]))
2860 m = mcart.buildUnstructured()
2861 m2 = m[1:m.getNumberOfCells()]
2862 self.assertRaises(InterpKernelException, m.checkDeepEquivalWith, m2, 0, eps)
2863 self.assertRaises(InterpKernelException, m.checkDeepEquivalWith, m2, 1, eps)
2864 self.assertRaises(InterpKernelException, m.checkDeepEquivalWith, m2, 2, eps)
2867 def testSwig2CheckDeepEquivalWith2(self):
2869 m = MEDCouplingUMesh("tst", 2)
2870 m.setCoords(DataArrayDouble([], 0,2))
2871 m.setConnectivity(DataArrayInt([]), DataArrayInt([0]))
2873 m.checkDeepEquivalWith(m2, 0, eps) # Should not raise!
2876 def testCopyTinyStringsFromOnFields(self):
2877 m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2878 nbOfCells=m.getNumberOfCells();
2879 f=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
2881 self.assertEqual(5,f.getNumberOfMeshPlacesExpected());
2883 f.setDescription("b");
2884 a1=DataArrayDouble.New();
2885 a1.alloc(nbOfCells,2);
2887 a1.setInfoOnComponent(0,"c");
2888 a1.setInfoOnComponent(1,"d");
2890 a2.setInfoOnComponent(0,"e");
2891 a2.setInfoOnComponent(1,"f");
2894 f.setEndTime(3.,3,4);
2896 m.getCoords().setInfoOnComponent(0,"h");
2897 m.getCoords().setInfoOnComponent(1,"i");
2898 m.getCoords().setInfoOnComponent(2,"j");
2900 f.checkConsistencyLight();
2902 self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2904 self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2905 f2.copyTinyStringsFrom(f);
2906 self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2907 f2.setDescription("GGG");
2908 self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2909 f2.copyTinyStringsFrom(f);
2910 self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2911 f2.getArray().setInfoOnComponent(0,"mmmm");
2912 self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2913 f2.copyTinyStringsFrom(f);
2914 self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2915 f2.getEndArray().setInfoOnComponent(1,"mmmm");
2916 self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2917 f2.copyTinyStringsFrom(f);
2918 self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2920 self.assertTrue(m2.isEqual(m,1e-12));
2922 self.assertTrue(not m2.isEqual(m,1e-12));
2923 m2.copyTinyStringsFrom(m);
2924 self.assertTrue(m2.isEqual(m,1e-12));
2925 m2.getCoords().setInfoOnComponent(1,"eee");
2926 self.assertTrue(not m2.isEqual(m,1e-12));
2927 m2.copyTinyStringsFrom(m);
2928 self.assertTrue(m2.isEqual(m,1e-12));
2931 def testTryToShareSameCoordsPermute(self):
2932 m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2933 m2=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2934 #self.assertTrue(m.getCoords()!=m2.getCoords());
2935 m.tryToShareSameCoordsPermute(m2,1e-12);
2936 #self.assertTrue(m.getCoords()==m2.getCoords());
2937 self.assertTrue(m2.isEqual(m,1e-12));
2938 renum1=[1,2,0,5,8,7,4,3,6]
2939 r1=DataArrayInt.New()
2940 r1.setValues(renum1,len(renum1),1)
2941 m.renumberNodes(r1,9);
2942 #self.assertTrue(m.getCoords()!=m2.getCoords());
2943 self.assertTrue(not m2.isEqual(m,1e-12));
2944 m.tryToShareSameCoordsPermute(m2,1e-12);
2945 #self.assertTrue(m.getCoords()==m2.getCoords());
2946 self.assertTrue(m2.isEqual(m,1e-12));
2949 def testTryToShareSameCoordsPermute2(self):
2950 m1=MEDCouplingDataForTest.build2DTargetMesh_4();
2951 targetCoords=[-0.3,-0.3, 0.2,-0.3, -0.3,0.2, 0.2,0.2 ]
2952 targetConn=[0,2,3,1]
2953 m2=MEDCouplingUMesh.New();
2954 m2.setMeshDimension(2);
2955 m2.allocateCells(1);
2956 m2.insertNextCell(NORM_QUAD4,targetConn[0:4])
2957 m2.finishInsertingCells();
2958 myCoords=DataArrayDouble.New();
2959 myCoords.setValues(targetCoords,4,2);
2960 m2.setCoords(myCoords);
2961 m2.checkConsistencyLight();
2962 m1.checkConsistencyLight();
2964 expected1=[0.25,0.125,0.125,0.25,0.25]
2965 f1=m1.getMeasureField(False);
2966 f2=m2.getMeasureField(False);
2967 self.assertEqual(5,f1.getArray().getNumberOfTuples());
2968 self.assertEqual(1,f2.getArray().getNumberOfTuples());
2970 self.assertAlmostEqual(expected1[i],f1.getIJ(i,0),12);
2972 self.assertAlmostEqual(expected1[0],f2.getIJ(0,0),12);
2973 self.assertRaises(InterpKernelException,m1.tryToShareSameCoordsPermute,m2,1e-12);# <- here in this order the sharing is impossible.
2974 # Let's go for deeper test of tryToShareSameCoordsPermute
2975 m2.tryToShareSameCoordsPermute(m1,1e-12);
2976 f1=m1.getMeasureField(False);
2977 f2=m2.getMeasureField(False);
2978 self.assertEqual(5,f1.getArray().getNumberOfTuples());
2979 self.assertEqual(1,f2.getArray().getNumberOfTuples());
2981 self.assertAlmostEqual(expected1[i],f1.getIJ(i,0),12);
2983 self.assertAlmostEqual(expected1[0],f2.getIJ(0,0),12);
2986 def testChangeUnderlyingMesh1(self):
2987 mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2988 mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2989 f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2991 array=DataArrayDouble.New();
2992 arr=[7., 107., 8., 108., 9., 109., 10., 110., 11., 111., 12., 112., 13., 113., 14., 114., 15., 115., 16., 116.]
2993 array.setValues(arr,mesh1.getNumberOfCells(),2);
2996 renum=[0,2,1,3,4,5,6,8,7,9]
2997 mesh2.renumberCells(renum,False);
2998 #self.assertTrue(f1.getMesh()==mesh1);
2999 f1.changeUnderlyingMesh(mesh1,10,1e-12);# nothing done only to check that nothing done.
3000 #self.assertTrue(f1.getMesh()==mesh1);
3001 f1.changeUnderlyingMesh(mesh2,10,1e-12);
3002 #self.assertTrue(f1.getMesh()==mesh2);
3003 expected1=[7.,107.,9.,109.,8.,108.,10.,110.,11.,111.,12.,112.,13.,113.,15.,115.,14.,114.,16.,116.]
3005 self.assertAlmostEqual(expected1[i],f1.getArray().getIJ(0,i),12);
3008 f1=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
3010 array=DataArrayDouble.New();
3011 arr2=[7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.,17.,117.]
3012 array.setValues(arr2,mesh1.getNumberOfNodes(),2);
3015 renum2=[0,2,10,3,4,5,6,8,7,9,1]
3016 mesh2.renumberNodes(renum2,11);
3017 #self.assertTrue(f1.getMesh()==mesh1);
3018 f1.changeUnderlyingMesh(mesh2,10,1e-12);
3019 #self.assertTrue(f1.getMesh()==mesh2);
3020 expected2=[7.,107.,17.,117.,8.,108.,10.,110.,11.,111.,12.,112.,13.,113.,15.,115.,14.,114.,16.,116.,9.,109.]
3022 self.assertAlmostEqual(expected2[i],f1.getArray().getIJ(0,i),12);
3026 def testGetMaxValue1(self):
3027 m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
3028 nbOfCells=m.getNumberOfCells();
3029 f=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
3031 a1=DataArrayDouble.New();
3032 val1=[3.,4.,5.,6.,7.]
3033 a1.setValues(val1,nbOfCells,1);
3034 a2=DataArrayDouble.New();
3035 val2=[0.,1.,2.,8.,7.]
3036 a2.setValues(val2,nbOfCells,1);
3039 f.setEndTime(3.,3,4);
3040 f.checkConsistencyLight();
3042 self.assertAlmostEqual(8.,f.getMaxValue(),14);
3043 self.assertAlmostEqual(0.,f.getMinValue(),14);
3044 self.assertAlmostEqual(5.,f.getAverageValue(),14);
3045 self.assertAlmostEqual(5.125,f.getWeightedAverageValue(0,True),14);
3047 self.assertAlmostEqual(9.5,f.getMaxValue(),14);
3048 self.assertAlmostEqual(0.,f.getMinValue(),14);
3050 self.assertAlmostEqual(9.5,f.getMaxValue(),14);
3051 self.assertAlmostEqual(1.,f.getMinValue(),14);
3054 def testSubstractInPlaceDM1(self):
3055 mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
3056 mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
3057 f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3059 array=DataArrayDouble.New();
3060 arr=[7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.]
3061 array.setValues(arr,mesh1.getNumberOfCells(),2);
3064 self.assertEqual(10,f1.getNumberOfTuples());
3065 self.assertEqual(2,f1.getNumberOfComponents());
3066 self.assertEqual(20,f1.getNumberOfValues());
3068 renum=[0,2,3,1,4,5,6,8,7,9]
3069 mesh2.renumberCells(renum,False);
3071 f2=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3073 array=DataArrayDouble.New();
3074 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]
3075 array.setValues(arr2,mesh2.getNumberOfCells(),2);
3078 f1.substractInPlaceDM(f2,10,1e-12);
3079 f1.applyFunc(1,"abs(x+y+0.2)");
3080 self.assertAlmostEqual(0.,f1.getMaxValue(),13);
3083 def testDotCrossProduct1(self):
3084 mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
3085 f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3086 f1.setTime(2.3,5,6);
3088 array=DataArrayDouble.New();
3089 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.]
3090 array.setValues(arr1,mesh1.getNumberOfCells(),3);
3092 f2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3093 f2.setTime(7.8,4,5);
3095 array=DataArrayDouble.New();
3096 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.]
3097 array.setValues(arr2,mesh1.getNumberOfCells(),3);
3101 expected1=[842.,1820.,2816.,3830.,4862.,5912.,6980.,8066.,9170.,10292.]
3103 self.assertAlmostEqual(expected1[i],f3.getIJ(i,0),9);
3106 f4=f1.crossProduct(f2);
3107 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.]
3109 self.assertAlmostEqual(expected2[i],f4.getIJ(0,i),9);
3115 if __name__ == '__main__':