1 # -*- coding: utf-8 -*-
2 # Copyright (C) 2007-2015 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
21 from MEDCoupling import *
23 from math import pi,e,sqrt,cos,sin
24 from datetime import datetime
25 from MEDCouplingDataForTest import MEDCouplingDataForTest
26 import rlcompleter,readline # this line has to be here, to ensure a usability of MEDCoupling/MEDLoader. B4 removing it please notify to anthony.geay@cea.fr
28 class MEDCouplingBasicsTest1(unittest.TestCase):
30 arr=DataArrayDouble.New()
31 arr.setValues([12.,11.,10.,9.,8.,7.,6.,5.,4.,3.,2.,1.],3,4)
32 arr.setInfoOnComponent(0,"ggg");
33 arr.setInfoOnComponent(1,"hhhh");
34 arr.setInfoOnComponent(2,"jj");
35 arr.setInfoOnComponent(3,"kkkkkk");
36 arr2=arr.convertToIntArr();
37 arr3=arr2.convertToDblArr();
38 self.assertTrue(arr.isEqual(arr3,1e-14))
42 arr1=DataArrayInt.New();
43 arr1Ref=[0,10,1,11,2,12,3,13,4,14,5,15,6,16]
44 arr1.setValues(arr1Ref,7,2);
45 self.assertEqual(7,arr1.getNumberOfTuples());
46 self.assertEqual(2,arr1.getNumberOfComponents());
47 self.assertEqual(arr1Ref,list(arr1.getValues()));
49 self.assertEqual(4,arr2.getNumberOfTuples());
50 self.assertEqual(2,arr2.getNumberOfComponents());
51 self.assertEqual(arr1Ref[6:],list(arr2.getValues()));
52 arr3=arr1.substr(2,5);
53 self.assertEqual(3,arr3.getNumberOfTuples());
54 self.assertEqual(2,arr3.getNumberOfComponents());
55 self.assertEqual(arr1Ref[4:10],list(arr3.getValues()));
57 arr4=DataArrayDouble.New();
58 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]
59 arr4.setValues(arr4Ref,7,2);
60 self.assertEqual(7,arr4.getNumberOfTuples());
61 self.assertEqual(2,arr4.getNumberOfComponents());
64 self.assertTrue(abs(arr4Ref[i]-tmp[i])<1e-14);
67 self.assertEqual(4,arr5.getNumberOfTuples());
68 self.assertEqual(2,arr5.getNumberOfComponents());
71 self.assertTrue(abs(arr4Ref[6+i]-tmp[i])<1e-14);
73 arr6=arr4.substr(2,5);
74 self.assertEqual(3,arr6.getNumberOfTuples());
75 self.assertEqual(2,arr6.getNumberOfComponents());
78 self.assertTrue(abs(arr4Ref[4+i]-tmp[i])<1e-14);
83 tab4=[1, 2, 8, 7, 2, 3, 9, 8, 3,
84 4, 10, 9, 4, 5, 11, 10, 5,
85 0, 6, 11, 0, 1, 7, 6 ]
88 coords=[ 0.024155, 0.04183768725682622, -0.305, 0.04831000000000001, -1.015761910347357e-17,
89 -0.305, 0.09662000000000001, -1.832979297858306e-18, -0.305, 0.120775, 0.04183768725682623,
90 -0.305, 0.09662000000000001, 0.08367537451365245, -0.305, 0.04831000000000001, 0.08367537451365246,
91 -0.305, 0.024155, 0.04183768725682622, -0.2863, 0.04831000000000001, -1.015761910347357e-17, -0.2863,
92 0.09662000000000001, -1.832979297858306e-18, -0.2863, 0.120775, 0.04183768725682623, -0.2863, 0.09662000000000001,
93 0.08367537451365245, -0.2863, 0.04831000000000001, 0.08367537451365246, -0.2863 ]
94 self.assertEqual(MEDCouplingMesh.GetNumberOfNodesOfGeometricType(NORM_TRI3),3)
95 self.assertTrue(MEDCouplingMesh.IsStaticGeometricType(NORM_TRI3))
96 self.assertTrue(MEDCouplingMesh.IsLinearGeometricType(NORM_TRI3))
97 self.assertEqual(MEDCouplingMesh.GetDimensionOfGeometricType(NORM_TRI3),2)
98 self.assertEqual(MEDCouplingMesh.GetReprOfGeometricType(NORM_TRI3),"NORM_TRI3")
99 self.assertRaises(InterpKernelException,MEDCouplingMesh.GetNumberOfNodesOfGeometricType,NORM_POLYGON)
100 self.assertTrue(not MEDCouplingMesh.IsStaticGeometricType(NORM_POLYGON))
101 self.assertTrue(MEDCouplingMesh.IsLinearGeometricType(NORM_POLYGON))
102 self.assertEqual(MEDCouplingMesh.GetDimensionOfGeometricType(NORM_POLYGON),2)
103 self.assertEqual(MEDCouplingMesh.GetReprOfGeometricType(NORM_POLYGON),"NORM_POLYGON")
104 self.assertEqual(MEDCouplingMesh.GetNumberOfNodesOfGeometricType(NORM_TRI6),6)
105 self.assertTrue(MEDCouplingMesh.IsStaticGeometricType(NORM_TRI6))
106 self.assertTrue(not MEDCouplingMesh.IsLinearGeometricType(NORM_TRI6))
107 self.assertEqual(MEDCouplingMesh.GetDimensionOfGeometricType(NORM_TRI6),2)
108 self.assertEqual(MEDCouplingMesh.GetReprOfGeometricType(NORM_TRI6),"NORM_TRI6")
109 mesh=MEDCouplingUMesh.New()
110 mesh.setMeshDimension(2)
111 mesh.allocateCells(8);
112 mesh.setName("mesh1")
113 self.assertTrue(mesh.getName()=="mesh1")
114 for i in range(nbOfCells):
115 mesh.insertNextCell(NORM_QUAD4,4,tab4[4*i:4*(i+1)]);
117 mesh.finishInsertingCells()
118 self.assertTrue(mesh.getNumberOfCells()==nbOfCells)
119 self.assertTrue(mesh.getNodalConnectivity().getNbOfElems()==30)
120 self.assertTrue(mesh.getNodalConnectivityIndex().getNbOfElems()==nbOfCells+1)
121 myCoords=DataArrayDouble.New()
122 myCoords.setValues(coords,nbOfNodes,3);
123 self.assertTrue(myCoords.getIJ(3,2)==-0.305)
124 mesh.setCoords(myCoords);
125 mesh.checkCoherency();
126 self.assertTrue(mesh.getAllGeoTypes()==[4])
127 myFalseConn=DataArrayInt.New()
128 myFalseConn.setValues(tab4,6,4)
129 self.assertTrue(myFalseConn.getIJ(1,1)==3)
131 field=MEDCouplingFieldDouble.New(ON_CELLS)
133 field.setNature(Integral)
134 myCoords=DataArrayDouble.New()
136 for i in range(nbOfCells*9):
137 sampleTab.append(float(i))
138 myCoords.setValues(sampleTab,nbOfCells,9);
139 field.setArray(myCoords)
140 self.assertTrue(3==mesh.getSpaceDimension())
141 field.checkCoherency()
142 mesh2=mesh.clone(False)
143 mesh3=mesh.clone(True)
146 ## deep full recursively copy of field -> both field and mesh underneath copied
147 field2=field.clone(True)
148 field2.setMesh(field.getMesh().clone(True))
149 mesh3=mesh.clone(True)
150 field3=mesh3.fillFromAnalytic(ON_CELLS,2,"x*IVec+(y+z)*JVec")
151 field3.applyFunc("u*u*u+cos(u)")
154 def testMeshPointsCloud(self):
155 targetCoords=[-0.3,-0.3,0.5, 0.2,-0.3,1., 0.7,-0.3,1.5,
156 -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]
157 targetMesh=MEDCouplingUMesh.New();
158 targetMesh.setMeshDimension(0);
159 targetMesh.allocateCells(8);
160 targetMesh.insertNextCell(NORM_POINT1,1,[0]);
161 targetMesh.insertNextCell(NORM_POINT1,1,[1]);
162 targetMesh.insertNextCell(NORM_POINT1,1,[2]);
163 targetMesh.insertNextCell(NORM_POINT1,1,[3]);
164 targetMesh.insertNextCell(NORM_POINT1,1,[4]);
165 targetMesh.insertNextCell(NORM_POINT1,1,[5]);
166 targetMesh.insertNextCell(NORM_POINT1,1,[7]);
167 targetMesh.insertNextCell(NORM_POINT1,1,[6]);
168 targetMesh.finishInsertingCells();
169 self.assertRaises(InterpKernelException,targetMesh.checkCoherency);
170 myCoords=DataArrayDouble.New();
171 myCoords.setValues(targetCoords,9,3);
172 targetMesh.setCoords(myCoords);
173 self.assertEqual(targetMesh.getSpaceDimension(),3)
174 self.assertEqual(targetMesh.getNumberOfCells(),8)
175 self.assertEqual(targetMesh.getNumberOfNodes(),9)
176 self.assertEqual(targetMesh.getMeshDimension(),0)
179 def testMeshM1D(self):
180 meshM1D=MEDCouplingUMesh.New();
181 self.assertRaises(InterpKernelException,meshM1D.getMeshDimension);
182 self.assertRaises(InterpKernelException,meshM1D.getNumberOfNodes);
183 self.assertRaises(InterpKernelException,meshM1D.getNumberOfCells);
184 self.assertRaises(InterpKernelException,meshM1D.setMeshDimension,-2)
185 self.assertRaises(InterpKernelException,meshM1D.setMeshDimension,-10)
186 meshM1D.setMeshDimension(-1);
187 meshM1D.checkCoherency();
188 self.assertEqual(meshM1D.getMeshDimension(),-1);
189 self.assertEqual(meshM1D.getNumberOfCells(),1);
190 self.assertRaises(InterpKernelException,meshM1D.getNumberOfNodes);
191 self.assertRaises(InterpKernelException,meshM1D.getSpaceDimension);
192 cpy=meshM1D.clone(True);
193 self.assertTrue(cpy.isEqual(meshM1D,1e-12));
194 fieldOnCells=MEDCouplingFieldDouble.New(ON_CELLS);
195 fieldOnCells.setMesh(meshM1D);
196 array=DataArrayDouble.New();
197 array.setValues(6*[7.],1,6);
198 fieldOnCells.setArray(array);
199 fieldOnCells.checkCoherency();
202 def testDeepCopy(self):
203 array=DataArrayDouble.New();
204 array.setValues(5*3*[7.],5,3);
205 self.assertEqual(array.getIJ(3,2),7.);
206 array2=array.deepCpy();
207 self.assertEqual(array2.getIJ(3,2),7.)
209 array3=DataArrayInt.New();
210 array3.setValues(5*3*[17],5,3);
211 self.assertEqual(array3.getIJ(3,2),17);
212 array4=array3.deepCpy();
213 self.assertEqual(array4.getIJ(3,2),17);
216 def testRevNodal(self):
217 mesh=MEDCouplingDataForTest.build2DTargetMesh_1()
218 revNodal,revNodalIndx=mesh.getReverseNodalConnectivity();
219 revNodalExpected=[0,0,1,1,2,0,3,0,1,2,3,4,2,4,3,3,4,4];
220 revNodalIndexExpected=[0,1,3,5,7,12,14,15,17,18];
221 self.assertEqual(revNodal.getNbOfElems(),18)
222 self.assertEqual(revNodalIndx.getNbOfElems(),10)
223 self.assertEqual(list(revNodal.getValues()),revNodalExpected)
224 self.assertEqual(list(revNodalIndx.getValues()),revNodalIndexExpected)
227 def testConvertToPolyTypes(self):
228 mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
230 mesh.convertToPolyTypes(elts);
231 mesh.checkCoherency();
232 self.assertEqual(5,mesh.getNumberOfCells());
233 self.assertEqual(23,mesh.getNodalConnectivity().getNumberOfTuples());
234 expected1=[4, 0, 3, 4, 1, 5, 1, 4, 2, 3, 4, 5, 2, 5, 6, 7, 4, 3, 4, 7, 8, 5, 4]
235 self.assertEqual(expected1,list(mesh.getNodalConnectivity().getValues()));
237 mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
238 mesh.convertToPolyTypes(elts);
239 mesh.checkCoherency();
240 self.assertEqual(8,mesh.getNumberOfCells());
241 self.assertEqual(114,mesh.getNodalConnectivity().getNumberOfTuples());
242 mesh.convertToPolyTypes(elts);
243 mesh.checkCoherency();
244 self.assertEqual(8,mesh.getNumberOfCells());
245 self.assertEqual(114,mesh.getNodalConnectivity().getNumberOfTuples());
248 def testDescConn2D(self):
249 mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
250 desc=DataArrayInt.New();
251 descIndx=DataArrayInt.New();
252 revDesc=DataArrayInt.New();
253 revDescIndx=DataArrayInt.New();
254 mesh2=mesh.buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
255 mesh2.checkCoherency();
256 self.assertEqual(1,mesh2.getMeshDimension());
257 self.assertEqual(13,mesh2.getNumberOfCells());
258 self.assertEqual(14,revDescIndx.getNbOfElems()); self.assertEqual(14,revDescIndx.getNumberOfTuples());
259 self.assertEqual(6,descIndx.getNbOfElems()); self.assertEqual(6,descIndx.getNumberOfTuples());
260 self.assertEqual(18,desc.getNbOfElems()); self.assertEqual(18,desc.getNumberOfTuples());
261 self.assertEqual(18,revDesc.getNbOfElems()); self.assertEqual(18,revDesc.getNumberOfTuples());
262 expected1=[0,1,2,3, 2,4,5, 6,7,4, 8,9,1,10, 11,12,6,9];
263 self.assertEqual(expected1,list(desc.getValues()));
264 expected2=[0,4,7,10,14,18];
265 self.assertEqual(expected2,list(descIndx.getValues()));
266 expected3=[0,1,3,5,6,8,9,11,12,13,15,16,17,18];
267 self.assertEqual(expected3,list(revDescIndx.getValues()));
268 expected4=[0, 0,3, 0,1, 0, 1,2, 1, 2,4, 2, 3, 3,4, 3, 4, 4];
269 self.assertEqual(expected4,list(revDesc.getValues()));
270 conn=mesh2.getNodalConnectivity();
271 connIndex=mesh2.getNodalConnectivityIndex();
272 expected5=[0,3,6,9,12,15,18,21,24,27,30,33,36,39];
273 self.assertEqual(expected5,list(connIndex.getValues()));
274 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];
275 self.assertEqual(expected6,list(conn.getValues()));
278 mesh.convertToPolyTypes(eltsV);
279 mesh.checkCoherency();
281 desc=DataArrayInt.New();
282 descIndx=DataArrayInt.New();
283 revDesc=DataArrayInt.New();
284 revDescIndx=DataArrayInt.New();
286 mesh2=mesh.buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
287 mesh2.checkCoherency();
288 self.assertEqual(1,mesh2.getMeshDimension());
289 self.assertEqual(13,mesh2.getNumberOfCells());
290 self.assertEqual(14,revDescIndx.getNbOfElems()); self.assertEqual(14,revDescIndx.getNumberOfTuples());
291 self.assertEqual(6,descIndx.getNbOfElems()); self.assertEqual(6,descIndx.getNumberOfTuples());
292 self.assertEqual(18,desc.getNbOfElems()); self.assertEqual(18,desc.getNumberOfTuples());
293 self.assertEqual(18,revDesc.getNbOfElems()); self.assertEqual(18,revDesc.getNumberOfTuples());
294 self.assertEqual(expected1,list(desc.getValues()));
295 self.assertEqual(expected2,list(descIndx.getValues()));
296 self.assertEqual(expected3,list(revDescIndx.getValues()));
297 self.assertEqual(expected4,list(revDesc.getValues()));
298 conn=mesh2.getNodalConnectivity();
299 connIndex=mesh2.getNodalConnectivityIndex();
300 self.assertEqual(expected5,list(connIndex.getValues()));
301 self.assertEqual(expected6,list(conn.getValues()));
304 def testDescConn3D(self):
305 mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
306 desc=DataArrayInt.New();
307 descIndx=DataArrayInt.New();
308 revDesc=DataArrayInt.New();
309 revDescIndx=DataArrayInt.New();
311 mesh2=mesh.buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
312 mesh2.checkCoherency();
313 self.assertEqual(2,mesh2.getMeshDimension());
314 self.assertEqual(36,mesh2.getNumberOfCells());
315 self.assertEqual(37,revDescIndx.getNbOfElems()); self.assertEqual(37,revDescIndx.getNumberOfTuples());
316 self.assertEqual(9,descIndx.getNbOfElems()); self.assertEqual(9,descIndx.getNumberOfTuples());
317 self.assertEqual(48,desc.getNbOfElems()); self.assertEqual(48,desc.getNumberOfTuples());
318 self.assertEqual(48,revDesc.getNbOfElems()); self.assertEqual(48,revDesc.getNumberOfTuples());
319 expected1=[0, 6, 12, 18, 24, 30, 36, 42, 48]
320 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]
321 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]
322 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]
323 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]
324 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,
325 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,
326 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,
327 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]
328 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,
329 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,
330 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,
331 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 self.assertEqual(expected1,list(descIndx.getValues()));
334 self.assertEqual(expected2,list(desc.getValues()));
335 self.assertEqual(expected3,list(revDescIndx.getValues()));
336 self.assertEqual(expected4,list(revDesc.getValues()));
337 self.assertEqual(expected5,list(mesh2.getNodalConnectivityIndex().getValues()));
338 self.assertEqual(expected6,list(mesh2.getNodalConnectivity().getValues()));
341 mesh.convertToPolyTypes(eltsV);
342 mesh.checkCoherency();
343 desc=DataArrayInt.New();
344 descIndx=DataArrayInt.New();
345 revDesc=DataArrayInt.New();
346 revDescIndx=DataArrayInt.New();
347 mesh2=mesh.buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
348 mesh2.checkCoherency();
349 self.assertEqual(2,mesh2.getMeshDimension());
350 self.assertEqual(36,mesh2.getNumberOfCells());
351 self.assertEqual(37,revDescIndx.getNbOfElems()); self.assertEqual(37,revDescIndx.getNumberOfTuples());
352 self.assertEqual(9,descIndx.getNbOfElems()); self.assertEqual(9,descIndx.getNumberOfTuples());
353 self.assertEqual(48,desc.getNbOfElems()); self.assertEqual(48,desc.getNumberOfTuples());
354 self.assertEqual(48,revDesc.getNbOfElems()); self.assertEqual(48,revDesc.getNumberOfTuples());
355 self.assertEqual(expected1,list(descIndx.getValues()));
356 self.assertEqual(expected2,list(desc.getValues()));
357 self.assertEqual(expected3,list(revDescIndx.getValues()));
358 self.assertEqual(expected4,list(revDesc.getValues()));
359 self.assertEqual(expected5,list(mesh2.getNodalConnectivityIndex().getValues()));
360 self.assertEqual(expected7,list(mesh2.getNodalConnectivity().getValues()));
363 def testFindBoundaryNodes(self):
364 mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
365 boundaryNodes=mesh.findBoundaryNodes();
366 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];
367 self.assertEqual(expected1,boundaryNodes.getValues());
370 def testBoundaryMesh(self):
371 mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
372 mesh2=mesh.buildBoundaryMesh(False);
373 self.assertEqual(24,mesh2.getNumberOfCells());
374 self.assertEqual(26,mesh2.getNumberOfNodes());
377 def testBuildPartOfMySelf(self):
378 mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
379 mesh.setName("Toto");
383 subMesh=mesh.buildPart(tab1)
384 self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
385 subMesh=mesh.buildPartOfMySelf(tab1,True);
386 self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
387 name=subMesh.getName();
388 self.assertEqual(2,len(mesh.getAllGeoTypes()));
389 self.assertEqual(NORM_TRI3,mesh.getAllGeoTypes()[0]);
390 self.assertEqual(NORM_QUAD4,mesh.getAllGeoTypes()[1]);
391 self.assertEqual(1,len(subMesh.getAllGeoTypes()));
392 self.assertEqual(NORM_QUAD4,subMesh.getAllGeoTypes()[0]);
393 self.assertEqual(name,"Toto");
394 self.assertEqual(2,subMesh.getNumberOfCells());
395 subConn=[4,0,3,4,1,4,7,8,5,4];
396 subConnIndex=[0,5,10];
397 self.assertEqual(10,subMesh.getNodalConnectivity().getNbOfElems());
398 self.assertEqual(3,subMesh.getNodalConnectivityIndex().getNbOfElems());
399 self.assertEqual(subConn[0:10],list(subMesh.getNodalConnectivity().getValues()));
400 self.assertEqual(subConnIndex[0:3],list(subMesh.getNodalConnectivityIndex().getValues()));
402 subMesh=mesh.buildPartOfMySelf(tab2[0:3],True);
403 self.assertTrue(isinstance(subMesh,MEDCouplingUMesh));
404 name=subMesh.getName();
405 self.assertEqual(2,len(subMesh.getAllGeoTypes()));
406 self.assertEqual(NORM_TRI3,subMesh.getAllGeoTypes()[0]);
407 self.assertEqual(NORM_QUAD4,subMesh.getAllGeoTypes()[1]);
408 self.assertEqual(name,"Toto");
409 self.assertEqual(3,subMesh.getNumberOfCells());
410 subConn2=[4,0,3,4,1,3,4,5,2,4,6,7,4,3]
411 subConnIndex2=[0,5,9,14]
412 self.assertEqual(14,subMesh.getNodalConnectivity().getNbOfElems());
413 self.assertEqual(4,subMesh.getNodalConnectivityIndex().getNbOfElems());
414 self.assertEqual(subConn2[0:14],list(subMesh.getNodalConnectivity().getValues()));
415 self.assertEqual(subConnIndex2[0:4],list(subMesh.getNodalConnectivityIndex().getValues()));
416 dd=DataArrayInt.New()
420 subMesh=subMesh.buildPartOfMySelf(dd,True);
421 self.assertEqual("coucou",subMesh.getName());
424 def testBuildPartOfMySelfNode(self):
425 mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
427 subMesh=mesh.buildPartOfMySelfNode(tab1[0:4],True);
428 self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
429 self.assertEqual(1,len(subMesh.getAllGeoTypes()));
430 self.assertEqual(NORM_QUAD4,subMesh.getAllGeoTypes()[0]);
431 self.assertEqual(1,subMesh.getNumberOfCells());
432 self.assertEqual(5,subMesh.getNodalConnectivity().getNbOfElems());
433 self.assertEqual(2,subMesh.getNodalConnectivityIndex().getNbOfElems());
436 self.assertEqual(subConn[0:5],list(subMesh.getNodalConnectivity().getValues()));
437 self.assertEqual(subConnIndex[0:2],list(subMesh.getNodalConnectivityIndex().getValues()));
439 ddd=DataArrayInt.New()
440 ddd.setValues(tab1[0:2],2,1)
442 subMesh=mesh.buildPartOfMySelfNode(ddd,False);
443 self.assertEqual("ddd",subMesh.getName())
444 self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
445 self.assertEqual(2,len(subMesh.getAllGeoTypes()));
446 self.assertEqual(NORM_TRI3,subMesh.getAllGeoTypes()[0]);
447 self.assertEqual(NORM_QUAD4,subMesh.getAllGeoTypes()[1]);
448 self.assertEqual(3,subMesh.getNumberOfCells());
449 self.assertEqual(14,subMesh.getNodalConnectivity().getNbOfElems());
450 self.assertEqual(4,subMesh.getNodalConnectivityIndex().getNbOfElems());
451 subConn2=[3,4,5,2,4,6,7,4,3,4,7,8,5,4]
452 subConnIndex2=[0,4,9,14]
453 self.assertEqual(subConn2[0:14],list(subMesh.getNodalConnectivity().getValues()));
454 self.assertEqual(subConnIndex2[0:4],list(subMesh.getNodalConnectivityIndex().getValues()));
455 #testing the case where length of tab2 is greater than max number of node per cell.
457 subMesh=mesh.buildPartOfMySelfNode(tab2[0:7],True);
458 self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
459 self.assertEqual(2,len(subMesh.getAllGeoTypes()));
460 self.assertEqual(NORM_TRI3,subMesh.getAllGeoTypes()[0]);
461 self.assertEqual(NORM_QUAD4,subMesh.getAllGeoTypes()[1]);
462 self.assertEqual(3,subMesh.getNumberOfCells());
465 def testZipCoords(self):
466 mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
467 self.assertEqual(2,len(mesh.getAllGeoTypes()));
468 self.assertEqual(2,mesh.getSpaceDimension());
469 self.assertEqual(9,mesh.getNumberOfNodes());
470 self.assertEqual(5,mesh.getNumberOfCells());
471 oldConn=mesh.getNodalConnectivity().getValues()[0:mesh.getNodalConnectivity().getNbOfElems()];
472 oldConnIndex=mesh.getNodalConnectivityIndex().getValues()[0:mesh.getNumberOfCells()+1]
473 oldCoords=mesh.getCoords();
475 self.assertEqual(2,len(mesh.getAllGeoTypes()));
476 self.assertEqual(2,mesh.getSpaceDimension());
477 self.assertEqual(9,mesh.getNumberOfNodes());
478 self.assertEqual(5,mesh.getNumberOfCells());
479 self.assertEqual(mesh.getCoords().getValues()[0:2*9],oldCoords.getValues());
480 self.assertEqual(list(oldConn),list(mesh.getNodalConnectivity().getValues()));
481 self.assertEqual(list(oldConnIndex),list(mesh.getNodalConnectivityIndex().getValues()));
484 subMesh=mesh.buildPartOfMySelf(tab1,True);
485 self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
486 traducer=subMesh.zipCoordsTraducer();
487 expectedTraducer=[0, 1, -1, 2, 3, 4, -1, 5, 6]
488 self.assertEqual(expectedTraducer,list(traducer.getValues()));
489 self.assertEqual(NORM_QUAD4,subMesh.getAllGeoTypes()[0]);
490 self.assertEqual(2,subMesh.getNumberOfCells());
491 subConn=[4,0,2,3,1,4,5,6,4,3]
492 subConnIndex=[0,5,10]
493 self.assertEqual(7,subMesh.getNumberOfNodes());
494 self.assertEqual(10,subMesh.getNodalConnectivity().getNbOfElems());
495 self.assertEqual(3,subMesh.getNodalConnectivityIndex().getNbOfElems());
496 self.assertEqual(subConn,list(subMesh.getNodalConnectivity().getValues()));
497 self.assertEqual(subConnIndex,list(subMesh.getNodalConnectivityIndex().getValues()));
499 subMesh=mesh.buildPartOfMySelf(tab1,False);
500 self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
501 self.assertEqual(NORM_QUAD4,subMesh.getAllGeoTypes()[0]);
502 self.assertEqual(2,subMesh.getNumberOfCells());
503 self.assertEqual(7,subMesh.getNumberOfNodes());
504 self.assertEqual(10,subMesh.getNodalConnectivity().getNbOfElems());
505 self.assertEqual(3,subMesh.getNodalConnectivityIndex().getNbOfElems());
506 self.assertEqual(subConn,list(subMesh.getNodalConnectivity().getValues()));
507 self.assertEqual(subConnIndex,list(subMesh.getNodalConnectivityIndex().getValues()));
510 def testZipConnectivity(self):
511 m1=MEDCouplingDataForTest.build2DTargetMesh_1();
512 m2=MEDCouplingDataForTest.build2DTargetMesh_1();
514 m3=m2.buildPartOfMySelf(cells1,True);
515 self.assertTrue(isinstance(m3,MEDCouplingUMesh))
516 m4=MEDCouplingDataForTest.build2DSourceMesh_1();
517 m5=MEDCouplingUMesh.MergeUMeshes(m1,m3);
518 m6=MEDCouplingUMesh.MergeUMeshes(m5,m4);
520 self.assertEqual(10,m6.getNumberOfCells());
521 self.assertEqual(22,m6.getNumberOfNodes());
522 (arr,areNodesMerged,newNbOfNodes)=m6.mergeNodes(1e-13);
523 self.assertTrue(areNodesMerged);
524 self.assertEqual(10,m6.getNumberOfCells());
525 self.assertEqual(9,m6.getNumberOfNodes());
527 arr=m6.zipConnectivityTraducer(0);
528 self.assertEqual(7,m6.getNumberOfCells());
530 arr=m6.zipConnectivityTraducer(0);
531 self.assertTrue(m7.isEqual(m6,1e-12));
532 self.assertEqual(7,m6.getNumberOfCells());
535 def testEqualMesh(self):
536 mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
537 mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
539 self.assertTrue(mesh1.isEqual(mesh1,1e-12));
541 self.assertTrue(mesh1.isEqual(mesh2,1e-12));
542 self.assertTrue(mesh2.isEqual(mesh1,1e-12));
543 pt=mesh2.getCoords().getValues();
545 mesh2.getCoords().setIJ(0,1,5.999);
546 self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
547 self.assertTrue(not mesh2.isEqual(mesh1,1e-12));
548 mesh2.getCoords().setIJ(0,1,tmp);
549 self.assertTrue(mesh1.isEqual(mesh2,1e-12));
550 self.assertTrue(mesh2.isEqual(mesh1,1e-12));
552 pt2=mesh1.getNodalConnectivity().getValues();
553 mesh1.getNodalConnectivity().setIJ(5,0,int(pt2[5])+1);
554 self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
555 self.assertTrue(not mesh2.isEqual(mesh1,1e-12));
556 mesh1.getNodalConnectivity().setIJ(5,0,int(pt2[5]));
557 self.assertTrue(mesh1.isEqual(mesh2,1e-12));
558 self.assertTrue(mesh2.isEqual(mesh1,1e-12));
560 pt2=mesh1.getNodalConnectivityIndex().getValues();
561 mesh1.getNodalConnectivityIndex().setIJ(1,0,int(pt2[1]+1));
562 self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
563 self.assertTrue(not mesh2.isEqual(mesh1,1e-12));
564 mesh1.getNodalConnectivityIndex().setIJ(1,0,int(pt2[1]));
565 self.assertTrue(mesh1.isEqual(mesh2,1e-12));
566 self.assertTrue(mesh2.isEqual(mesh1,1e-12));
568 tmp3=mesh1.getName();
569 mesh1.setName("lllll");
570 self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
571 self.assertTrue(not mesh2.isEqual(mesh1,1e-12));
573 self.assertTrue(mesh1.isEqual(mesh2,1e-12));
574 self.assertTrue(mesh2.isEqual(mesh1,1e-12));
576 tmp3=mesh2.getCoords().getInfoOnComponent(1);
577 mesh2.getCoords().setInfoOnComponent(1,"kkkkkk");
578 self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
579 self.assertTrue(not mesh2.isEqual(mesh1,1e-12));
580 mesh2.getCoords().setInfoOnComponent(1,tmp3);
581 self.assertTrue(mesh1.isEqual(mesh2,1e-12));
582 self.assertTrue(mesh2.isEqual(mesh1,1e-12));
585 def testEqualFieldDouble(self):
586 mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
587 mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
589 fieldOnCells1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
590 fieldOnCells1.setMesh(mesh1);
591 fieldOnCells2=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
592 fieldOnCells2.setMesh(mesh2);
594 self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
595 self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
597 fieldOnNodes1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
598 self.assertTrue(not fieldOnCells1.isEqual(fieldOnNodes1,1e-12,1e-15));
599 self.assertTrue(not fieldOnNodes1.isEqual(fieldOnCells1,1e-12,1e-15));
601 fieldOnCells2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
602 self.assertEqual(fieldOnCells2.getMesh(),None) # to check that convertMesh wrapping do not raise but return Py_None
603 self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
604 self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
605 fieldOnCells1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
606 self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
607 self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
608 fieldOnCells1.setTime(4.,6,7);
609 self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
610 self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
611 fieldOnCells2.setTime(4.,6,7);
612 self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
613 self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
614 fieldOnCells1.setName("Power");
615 self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
616 self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
617 fieldOnCells2.setName("Power");
618 self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
619 self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
621 fieldOnCells1.setMesh(mesh1);
622 self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
623 self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
624 fieldOnCells2.setMesh(mesh1);
625 self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
626 self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
627 arr=DataArrayDouble.New();
629 arr.setValues(mesh1.getNumberOfCells()*3*[6.],mesh1.getNumberOfCells(),3);
630 fieldOnCells1.setArray(arr);
631 self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
632 self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
633 fieldOnCells2.setArray(arr);
634 self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
635 self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
638 fieldOnCells2.setArray(arr2);
639 self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
640 self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
642 self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
643 self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
645 self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
646 self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
647 arr2.setName("popo2");
648 self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
649 self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
651 arr2.setName("popo");
652 self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
653 self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
655 arr2.setInfoOnComponent(2,"jjj");
656 self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
657 self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
658 arr.setInfoOnComponent(2,"jjj");
659 self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
660 self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
663 def testNatureChecking(self):
664 field=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
665 field.setNature(Integral);
666 field.setNature(ConservativeVolumic);
667 field.setNature(IntegralGlobConstraint);
668 field=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
669 field.setNature(ConservativeVolumic);
670 self.assertRaises(InterpKernelException,field.setNature,Integral);
671 self.assertRaises(InterpKernelException,field.setNature,IntegralGlobConstraint);
674 def testNatureOperations(self):
675 """ Check nature constraints on field operations """
676 m = MEDCouplingCMesh()
677 m.setCoordsAt(0, DataArrayDouble([1.0,2.0,3.0]))
678 m.setCoordsAt(1, DataArrayDouble([1.0,2.0,3.0]))
679 m = m.buildUnstructured()
680 f1, f2 = MEDCouplingFieldDouble.New(ON_CELLS, NO_TIME), MEDCouplingFieldDouble.New(ON_CELLS, NO_TIME)
681 f1.setNature(Integral)
682 f2.setNature(ConservativeVolumic)
683 self.assertEqual(Integral, f1.getNature())
684 self.assertEqual(ConservativeVolumic, f2.getNature())
686 da = DataArrayDouble([1.0,2.0,3.0,4.0])
687 f1.setMesh(m); f2.setMesh(m)
688 f1.setArray(da); f2.setArray(da.deepCpy())
689 # All this should complain about nature:
690 self.assertRaises(InterpKernelException, f1.__add__, f2)
691 self.assertRaises(InterpKernelException, f1.__iadd__, f2)
692 self.assertRaises(InterpKernelException, f1.__sub__, f2)
693 self.assertRaises(InterpKernelException, f1.__isub__, f2)
694 self.assertRaises(InterpKernelException, f1.__radd__, f2)
695 self.assertRaises(InterpKernelException, f1.__rsub__, f2)
696 self.assertRaises(InterpKernelException, MEDCouplingFieldDouble.AddFields, f1, f2)
697 self.assertRaises(InterpKernelException, MEDCouplingFieldDouble.SubstractFields, f1, f2)
698 self.assertRaises(InterpKernelException, MEDCouplingFieldDouble.MaxFields, f1, f2)
699 self.assertRaises(InterpKernelException, MEDCouplingFieldDouble.MinFields, f1, f2)
701 f3 = MEDCouplingFieldDouble.MultiplyFields(f1,f2)
702 self.assertEqual(NoNature, f3.getNature())
704 self.assertEqual(NoNature, f3.getNature())
705 f1Tmp = f1.deepCpy(); f1Tmp.setMesh(m); f1Tmp *= f2
706 self.assertEqual(NoNature, f1Tmp.getNature())
707 f3 = MEDCouplingFieldDouble.DivideFields(f1,f2)
708 self.assertEqual(NoNature, f3.getNature())
710 self.assertEqual(NoNature, f3.getNature())
711 f1Tmp = f1.deepCpy(); f1Tmp.setMesh(m); f1Tmp /= f2
712 self.assertEqual(NoNature, f1Tmp.getNature())
713 # f3 = MEDCouplingFieldDouble.PowFields(f1,f2)
714 # self.assertEqual(NoNature, f3.getNature())
716 self.assertEqual(NoNature, f3.getNature())
717 f1Tmp = f1.deepCpy(); f1Tmp.setMesh(m); f1Tmp **= f2
718 self.assertEqual(NoNature, f1Tmp.getNature())
719 f3 = MEDCouplingFieldDouble.DotFields(f1,f2)
720 self.assertEqual(NoNature, f3.getNature())
722 self.assertEqual(NoNature, f3.getNature())
724 da = DataArrayDouble.Meld([da, da, da])
725 f1.setArray(da); f2.setArray(da.deepCpy())
726 f3 = MEDCouplingFieldDouble.CrossProductFields(f1,f2)
727 self.assertEqual(NoNature, f3.getNature())
728 f3 = f1.crossProduct(f2)
730 def testBuildSubMeshData(self):
731 targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1()
732 #check buildSubMesh on field on cells
733 fieldCells=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
734 fieldCells.setMesh(targetMesh);
736 ret1,di=fieldCells.buildSubMeshData(elts);
737 self.assertTrue(isinstance(ret1,MEDCouplingUMesh))
738 self.assertEqual(3,ret1.getNumberOfCells());
739 self.assertEqual(9,ret1.getNumberOfNodes());
740 self.assertEqual(3,di.getNumberOfTuples());
741 self.assertEqual(1,di.getNumberOfComponents());
742 toCheck=di.getValues();
743 self.assertTrue(elts,toCheck);
744 #check buildSubMesh on field on nodes
745 fieldNodes=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
746 fieldNodes.setMesh(targetMesh);
747 ret2,di=fieldNodes.buildSubMeshData(elts);
748 self.assertTrue(isinstance(ret2,MEDCouplingUMesh))
749 self.assertEqual(3,ret2.getNumberOfCells());
750 self.assertEqual(6,ret2.getNumberOfNodes());
751 self.assertEqual(6,di.getNumberOfTuples());
752 self.assertEqual(1,di.getNumberOfComponents());
753 toCheck=di.getValues();
754 expected=[1,2,4,5,7,8]
755 self.assertEqual(expected,list(toCheck));
758 def testExtrudedMesh1(self):
759 mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
760 ext=MEDCouplingExtrudedMesh.New(mesh3D,mesh2D,1);
761 self.assertEqual(18,ext.getNumberOfCells());
762 self.assertEqual(60,ext.getNumberOfNodes());
763 ids3D=ext.getMesh3DIds();
764 ids3DExpected=[5,4,3,2,1,0, 11,10,9,8,7,6, 17,16,15,14,13,12]
765 self.assertEqual(18,ids3D.getNumberOfTuples());
766 self.assertEqual(1,ids3D.getNumberOfComponents());
767 self.assertEqual(ids3DExpected,list(ids3D.getValues()));
768 mesh1D=ext.getMesh1D();
769 self.assertEqual(4,mesh1D.getNumberOfNodes());
770 self.assertEqual(3,mesh1D.getNumberOfCells());
771 mesh1DExpected=[0.66666666666666663, 1.4583333333333333, 0, 0.66666666666666663,
772 1.4583333333333333, 1, 0.66666666666666663, 1.4583333333333333,
773 2, 0.66666666666666663, 1.4583333333333333, 3]
774 mesh1DCoords=mesh1D.getCoords();
775 self.assertEqual(4,mesh1DCoords.getNumberOfTuples());
776 self.assertEqual(3,mesh1DCoords.getNumberOfComponents());
777 self.assertEqual(mesh1DExpected,mesh1DCoords.getValues());
778 conn1D=mesh1D.getNodalConnectivity();
779 self.assertEqual(9,conn1D.getNumberOfTuples());
780 self.assertEqual(1,conn1D.getNumberOfComponents());
781 conn1DExpected=[1,0,1,1,1,2,1,2,3]
782 self.assertEqual(conn1DExpected,list(conn1D.getValues()));
785 def testExtrudedMesh3(self):
786 m1=MEDCouplingDataForTest.build2DTargetMesh_1();
787 m1.changeSpaceDimension(3);
788 m2=MEDCouplingDataForTest.buildCU1DMesh_U();
789 m2.changeSpaceDimension(3);
792 m2.rotate(center,vector,-pi/2.);
793 m3=m1.buildExtrudedMesh(m2,0);
795 m4=MEDCouplingExtrudedMesh.New(m3,m1,0);
796 self.assertEqual(15,m4.getNumberOfCells());
797 self.assertEqual(5,m4.getMesh2D().getNumberOfCells());
798 self.assertEqual(3,m4.getMesh1D().getNumberOfCells());
799 m3DIds=m4.getMesh3DIds().getValues();
800 self.assertEqual(range(15),list(m3DIds));
801 #some random in cells to check that extrusion alg find it correctly
802 expected1=[1,3,2,0,6,5,7,10,11,8,12,9,14,13,4]
803 m3.renumberCells(expected1,False);
804 m4=MEDCouplingExtrudedMesh.New(m3,m1,0);
805 self.assertEqual(15,m4.getNumberOfCells());
806 self.assertEqual(5,m4.getMesh2D().getNumberOfCells());
807 self.assertEqual(3,m4.getMesh1D().getNumberOfCells());
808 m3DIds=m4.getMesh3DIds().getValues();
809 self.assertEqual(expected1,list(m3DIds));
810 #play with polygons and polyedrons
812 m1.convertToPolyTypes(cells);
813 m3=m1.buildExtrudedMesh(m2,0);
814 self.assertEqual(NORM_HEXA8,m3.getTypeOfCell(0));
815 self.assertEqual(NORM_PENTA6,m3.getTypeOfCell(1));
816 self.assertEqual(NORM_POLYHED,m3.getTypeOfCell(2));
817 self.assertEqual(NORM_POLYHED,m3.getTypeOfCell(3));
818 self.assertEqual(NORM_HEXA8,m3.getTypeOfCell(4));
819 m3.renumberCells(expected1,False);
820 m4=MEDCouplingExtrudedMesh.New(m3,m1,0);
821 self.assertEqual(15,m4.getNumberOfCells());
822 self.assertEqual(5,m4.getMesh2D().getNumberOfCells());
823 self.assertEqual(3,m4.getMesh1D().getNumberOfCells());
824 m3DIds=m4.getMesh3DIds().getValues();
825 self.assertEqual(expected1,list(m3DIds));
828 def testExtrudedMesh4(self):
829 m1=MEDCouplingDataForTest.build2DTargetMesh_1();
831 m1.convertToPolyTypes(cells);
832 m1.changeSpaceDimension(3);
833 m2=MEDCouplingDataForTest.buildCU1DMesh_U();
834 m2.changeSpaceDimension(3);
837 m2.rotate(center,vector,-pi/2.);
839 m3=m1.buildExtrudedMesh(m2,0);
840 expected1=[1,3,2,0,6,5,7,10,11,8,12,9,14,13,4]
841 rexpected1=[3, 0, 2, 1, 14, 5, 4, 6, 9, 11, 7, 8, 10, 13, 12]
842 m3.renumberCells(expected1,False);
843 m4=MEDCouplingExtrudedMesh.New(m3,m1,0);
844 self.assertEqual(NORM_HEXA8,m4.getTypeOfCell(0));
845 self.assertEqual(NORM_HEXA8,m4.getTypeOfCell(1));
846 self.assertEqual(NORM_POLYHED,m4.getTypeOfCell(2));
847 self.assertEqual(NORM_PENTA6,m4.getTypeOfCell(7));
848 f=m4.getMeasureField(True);
850 self.assertEqual(15,arr.getNumberOfTuples());
851 self.assertEqual(1,arr.getNumberOfComponents());
852 arrPtr=arr.getValues();
853 expected2=[0.075,0.0375,0.0375,0.075,0.075,
854 0.1125,0.05625,0.05625,0.1125,0.1125,
855 0.0625,0.03125,0.03125,0.0625,0.0625]
857 self.assertAlmostEqual(expected2[rexpected1[i]],arrPtr[i],16);
859 m5=m4.build3DUnstructuredMesh();
861 self.assertTrue(m5.isEqual(m3,1e-12));
862 f=m5.getMeasureField(True);
864 self.assertTrue(isinstance(f.getMesh(),MEDCouplingExtrudedMesh))
866 arrPtr=arr.getValues();
868 self.assertAlmostEqual(expected2[rexpected1[i]],arrPtr[i],15);
872 def testFindCommonNodes(self):
873 targetMesh=MEDCouplingDataForTest.build3DTargetMesh_1();
874 comm,commI=targetMesh.findCommonNodes(1e-10,-1);
875 self.assertEqual(1,commI.getNumberOfTuples());
876 self.assertEqual(0,comm.getNumberOfTuples());
877 o2n,newNbOfNodes=targetMesh.buildNewNumberingFromCommonNodesFormat(comm,commI);
878 self.assertEqual(27,newNbOfNodes);
879 self.assertEqual(27,o2n.getNumberOfTuples());
881 self.assertEqual(o2nExp1,list(o2n.getValues()));
883 targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
884 self.assertEqual(31,targetMesh.getNumberOfNodes());
885 comm,commI=targetMesh.findCommonNodes(1e-10);# testing default parameter
886 self.assertEqual(3,commI.getNumberOfTuples());
887 self.assertEqual(6,comm.getNumberOfTuples());
888 commExpected=[1,27,28,29,23,30]
889 commIExpected=[0,4,6]
890 self.assertEqual(commExpected,list(comm.getValues()));
891 self.assertEqual(commIExpected,list(commI.getValues()));
892 o2n,newNbOfNodes=targetMesh.buildNewNumberingFromCommonNodesFormat(comm,commI);
893 self.assertEqual(31,o2n.getNumberOfTuples());
894 self.assertEqual(27,newNbOfNodes);
895 o2nExp2=[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,
896 21,22,23,24,25,26,1,1,1,23]
897 self.assertEqual(o2nExp2,list(o2n.getValues()));
899 targetMesh=MEDCouplingDataForTest.build3DTargetMesh_1();
900 time=targetMesh.getTimeOfThis();
901 o2n,areNodesMerged,newNbOfNodes=targetMesh.mergeNodes(1e-10);
902 targetMesh.updateTime();
903 self.assertEqual(time,targetMesh.getTimeOfThis());
904 self.assertTrue(not areNodesMerged);
906 targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
907 time=targetMesh.getTimeOfThis();
908 o2n,areNodesMerged,newNbOfNodes=targetMesh.mergeNodes(1e-10);
909 targetMesh.updateTime();
910 self.assertTrue(time!=targetMesh.getTimeOfThis());
911 self.assertTrue(areNodesMerged);
912 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,
913 18,4,5,8,7,13,14,17,16,
914 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,
915 18,13,14,17,16,22,23,26,25]
916 self.assertEqual(72,targetMesh.getNodalConnectivity().getNumberOfTuples());
917 self.assertEqual(connExp,list(targetMesh.getNodalConnectivity().getValues()));
918 self.assertEqual(27,targetMesh.getCoords().getNumberOfTuples());
919 coordsExp=[ 0., 0., 0., 50., 0., 0. , 200., 0., 0. , 0., 50., 0., 50., 50., 0. ,
920 200., 50., 0., 0., 200., 0., 50., 200., 0. , 200., 200., 0. ,
921 0., 0., 50., 50., 0., 50. , 200., 0., 50. , 0., 50., 50., 50.,
922 50., 50. , 200., 50., 50., 0., 200., 50., 50., 200., 50. ,
923 200., 200., 50. , 0., 0., 200., 50., 0., 200. , 200., 0., 200.
924 , 0., 50., 200., 50., 50., 200. , 200., 50., 200.,
925 0., 200., 200., 50., 200., 200. , 200., 200., 200. ]
926 self.assertEqual(coordsExp,targetMesh.getCoords().getValues());
928 targetMesh=MEDCouplingDataForTest.build2DTargetMeshMergeNode_1();
929 self.assertEqual(18,targetMesh.getNumberOfNodes());
930 time=targetMesh.getTimeOfThis();
931 o2n,areNodesMerged,newNbOfNodes=targetMesh.mergeNodes(1e-10);
932 self.assertTrue(time!=targetMesh.getTimeOfThis());
933 self.assertTrue(areNodesMerged);
934 self.assertEqual(9,targetMesh.getNumberOfNodes());
935 connExp2=[4,0,4,3,1, 3,1,3,2, 3,3,5,2, 4,4,6,7,3, 4,7,8,5,3]
936 self.assertEqual(23,targetMesh.getNodalConnectivity().getNumberOfTuples());
937 self.assertEqual(connExp2,list(targetMesh.getNodalConnectivity().getValues()));
938 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]
939 self.assertEqual(9,targetMesh.getCoords().getNumberOfTuples());
940 self.assertEqual(coordsExp2,targetMesh.getCoords().getValues());
943 def testCheckButterflyCells(self):
944 sourceMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
945 cells=sourceMesh.checkButterflyCells();
946 self.assertEqual(0,len(cells));
947 conn=sourceMesh.getNodalConnectivity()
949 conn.setIJ(15,0,conn.getIJ(16,0))
951 cells=sourceMesh.checkButterflyCells();
952 self.assertEqual(1,len(cells));
953 self.assertEqual([3],cells.getValues());
955 conn.setIJ(15,0,conn.getIJ(16,0))
957 cells=sourceMesh.checkButterflyCells();
958 self.assertEqual(0,len(cells));
960 sourceMesh=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
961 cells=sourceMesh.checkButterflyCells();
962 self.assertEqual(0,len(cells));
963 conn=sourceMesh.getNodalConnectivity()
965 conn.setIJ(15,0,conn.getIJ(16,0))
967 cells=sourceMesh.checkButterflyCells();
968 self.assertEqual(1,len(cells));
969 self.assertEqual([3],cells.getValues());
971 conn.setIJ(15,0,conn.getIJ(16,0))
973 cells=sourceMesh.checkButterflyCells();
974 self.assertEqual(0,len(cells));
977 def testMergeMesh1(self):
978 m1=MEDCouplingDataForTest.build2DTargetMesh_1();
979 m2=MEDCouplingDataForTest.build2DSourceMesh_1();
982 m3=m1.mergeMyselfWith(m2);
983 self.assertTrue(isinstance(m3,MEDCouplingUMesh));
985 m4=MEDCouplingDataForTest.build2DTargetMeshMerged_1();
986 self.assertTrue(m3.isEqual(m4,1.e-12));
987 da,isMerged,newNbOfNodes=m3.mergeNodes(1.e-12);
988 self.assertEqual(11,m3.getNumberOfNodes());
989 self.assertTrue(isMerged);
992 def testMergeMeshOnSameCoords1(self):
993 m1=MEDCouplingDataForTest.build2DTargetMesh_1();
994 m2=MEDCouplingDataForTest.build2DTargetMesh_1();
996 m2.convertToPolyTypes(cells);
997 m1.tryToShareSameCoords(m2,1e-12);
998 m3=MEDCouplingDataForTest.build2DTargetMesh_1();
999 m3.tryToShareSameCoords(m2,1e-12);
1001 m4=MEDCouplingUMesh.MergeUMeshesOnSameCoords(meshes);
1002 m4.checkCoherency();
1003 self.assertEqual(15,m4.getNumberOfCells());
1005 m1_1=m4.buildPartOfMySelf(cells1,True);
1006 m1_1.setName(m1.getName());
1007 self.assertTrue(m1.isEqual(m1_1,1e-12));
1009 m2_1=m4.buildPartOfMySelf(cells2,True);
1010 m2_1.setName(m2.getName());
1011 self.assertTrue(m2.isEqual(m2_1,1e-12));
1012 cells3=[10,11,12,13,14]
1013 m3_1=m4.buildPartOfMySelf(cells3,True);
1014 m3_1.setName(m3.getName());
1015 self.assertTrue(m3.isEqual(m3_1,1e-12));
1018 def testMergeField1(self):
1019 m1=MEDCouplingDataForTest.build2DTargetMesh_1();
1020 m2=MEDCouplingDataForTest.build2DSourceMesh_1();
1023 f1=m1.getMeasureField(True);
1024 f2=m2.getMeasureField(True);
1025 f3=MEDCouplingFieldDouble.MergeFields(f1,f2);
1026 f3.checkCoherency();
1027 m4=MEDCouplingDataForTest.build2DTargetMeshMerged_1();
1028 self.assertTrue(f3.getMesh().isEqual(m4,1.e-12));
1030 self.assertEqual(name,"MeasureOfMesh_");
1031 self.assertEqual(f3.getTypeOfField(),ON_CELLS);
1032 self.assertEqual(f3.getTimeDiscretization(),ONE_TIME);
1033 self.assertEqual(1,f3.getNumberOfComponents());
1034 self.assertEqual(7,f3.getNumberOfTuples());
1035 values=[0.25,0.125,0.125,0.25,0.25,0.5,0.5]
1036 tmp=f3.getArray().getValues();
1037 self.assertEqual(len(values),len(tmp))
1039 self.assertTrue(abs(values[i]-tmp[i])<1e-12)
1043 def testFillFromAnalytic(self):
1044 m=MEDCouplingDataForTest.build2DTargetMesh_1();
1045 m.setTime(3.4,5,6); m.setTimeUnit("us");
1046 f1=m.fillFromAnalytic(ON_CELLS,1,"x+y");
1047 self.assertAlmostEqual(3.4,f1.getTime()[0],12) ; self.assertEqual(5,f1.getTime()[1]) ; self.assertEqual(6,f1.getTime()[2])
1048 self.assertEqual("us",f1.getTimeUnit())
1049 f1.checkCoherency();
1050 self.assertEqual(f1.getTypeOfField(),ON_CELLS);
1051 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1052 self.assertEqual(1,f1.getNumberOfComponents());
1053 self.assertEqual(5,f1.getNumberOfTuples());
1054 values1=[-0.1,0.23333333333333336,0.56666666666666665,0.4,0.9]
1055 tmp=f1.getArray().getValues();
1056 self.assertEqual(len(values1),len(tmp))
1057 for i in xrange(len(tmp)):
1058 self.assertTrue(abs(tmp[i]-values1[i])<1.e-12)
1061 f1=m.fillFromAnalytic(ON_NODES,1,"x+y");
1062 f1.checkCoherency();
1063 self.assertEqual(f1.getTypeOfField(),ON_NODES);
1064 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1065 self.assertEqual(1,f1.getNumberOfComponents());
1066 self.assertEqual(9,f1.getNumberOfTuples());
1067 values2=[-0.6,-0.1,0.4,-0.1,0.4,0.9,0.4,0.9,1.4]
1068 tmp=f1.getArray().getValues();
1069 self.assertEqual(len(values2),len(tmp))
1070 for i in xrange(len(tmp)):
1071 self.assertTrue(abs(tmp[i]-values2[i])<1.e-12)
1074 f1=m.fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+(2*(x+y))*JVec");
1075 f1.checkCoherency();
1076 self.assertEqual(f1.getTypeOfField(),ON_NODES);
1077 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1078 self.assertEqual(2,f1.getNumberOfComponents());
1079 self.assertEqual(9,f1.getNumberOfTuples());
1080 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]
1081 tmp=f1.getArray().getValues();
1082 self.assertEqual(len(values3),len(tmp))
1083 for i in xrange(len(tmp)):
1084 self.assertTrue(abs(tmp[i]-values3[i])<1.e-12)
1086 values4=f1.accumulate();
1087 self.assertEqual(2,len(values4))
1088 self.assertTrue(abs(3.6-values4[0])<1.e-12);
1089 self.assertTrue(abs(7.2-values4[1])<1.e-12);
1090 values4=f1.integral(True);
1091 self.assertEqual(2,len(values4))
1092 self.assertTrue(abs(0.5-values4[0])<1.e-12);
1093 self.assertTrue(abs(1.-values4[1])<1.e-12);
1095 self.assertRaises(InterpKernelException,m.fillFromAnalytic,ON_NODES,1,"1./(x-0.2)");
1098 def testFillFromAnalytic2(self):
1099 m=MEDCouplingDataForTest.build2DTargetMesh_1();
1100 f1=m.fillFromAnalytic(ON_CELLS,1,"y+x");
1101 f1.checkCoherency();
1102 self.assertEqual(f1.getTypeOfField(),ON_CELLS);
1103 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1104 self.assertEqual(1,f1.getNumberOfComponents());
1105 self.assertEqual(5,f1.getNumberOfTuples());
1106 values1=[-0.1,0.23333333333333336,0.56666666666666665,0.4,0.9]
1107 tmp=f1.getArray().getValues();
1108 self.assertEqual(len(values1),len(tmp))
1109 for i in xrange(len(values1)):
1110 self.assertTrue(abs(values1[i]-tmp[i])<1.e-12);
1113 f1=m.fillFromAnalytic(ON_NODES,1,"y+2*x");
1114 f1.checkCoherency();
1115 self.assertEqual(f1.getTypeOfField(),ON_NODES);
1116 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1117 self.assertEqual(1,f1.getNumberOfComponents());
1118 self.assertEqual(9,f1.getNumberOfTuples());
1119 values2=[-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1]
1120 tmp=f1.getArray().getValues();
1121 self.assertEqual(len(values2),len(tmp))
1122 for i in xrange(len(values2)):
1123 self.assertTrue(abs(values2[i]-tmp[i])<1.e-12);
1125 f1=m.fillFromAnalytic(ON_NODES,1,"2.*x+y");
1126 f1.checkCoherency();
1127 self.assertEqual(f1.getTypeOfField(),ON_NODES);
1128 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1129 self.assertEqual(1,f1.getNumberOfComponents());
1130 self.assertEqual(9,f1.getNumberOfTuples());
1131 tmp=f1.getArray().getValues();
1132 values2Bis=[-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1]
1133 self.assertEqual(len(values2Bis),len(tmp))
1134 for i in xrange(len(values2Bis)):
1135 self.assertTrue(abs(values2Bis[i]-tmp[i])<1.e-12);
1138 f1=m.fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+2*(x+y)*JVec");
1139 f1.checkCoherency();
1140 self.assertEqual(f1.getTypeOfField(),ON_NODES);
1141 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1142 self.assertEqual(2,f1.getNumberOfComponents());
1143 self.assertEqual(9,f1.getNumberOfTuples());
1144 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]
1145 tmp=f1.getArray().getValues();
1146 self.assertEqual(len(values3),len(tmp))
1147 for i in xrange(len(values3)):
1148 self.assertTrue(abs(values3[i]-tmp[i])<1.e-12);
1150 values4=f1.accumulate();
1151 self.assertTrue(abs(3.6-values4[0])<1.e-12);
1152 self.assertTrue(abs(7.2-values4[1])<1.e-12);
1153 values4=f1.integral(True);
1154 self.assertTrue(abs(0.5-values4[0])<1.e-12);
1155 self.assertTrue(abs(1.-values4[1])<1.e-12);
1158 def testApplyFunc(self):
1159 m=MEDCouplingDataForTest.build2DTargetMesh_1();
1160 f1=m.fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+(2*(x+y))*JVec");
1161 f1.checkCoherency();
1162 self.assertEqual(f1.getTypeOfField(),ON_NODES);
1163 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1164 self.assertEqual(2,f1.getNumberOfComponents());
1165 self.assertEqual(9,f1.getNumberOfTuples());
1166 f1.applyFunc(1,"x+y");
1167 self.assertEqual(f1.getTypeOfField(),ON_NODES);
1168 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1169 self.assertEqual(1,f1.getNumberOfComponents());
1170 self.assertEqual(9,f1.getNumberOfTuples());
1171 values1=[-1.8,-0.3,1.2,-0.3,1.2,2.7,1.2,2.7,4.2]
1172 tmp=f1.getArray().getValues();
1173 self.assertEqual(len(values1),len(tmp))
1174 for i in xrange(len(tmp)):
1175 self.assertTrue(abs(tmp[i]-values1[i])<1.e-12)
1179 def testApplyFunc2(self):
1180 m=MEDCouplingDataForTest.build2DTargetMesh_1();
1181 f1=m.fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+2*(x+y)*JVec");
1182 f1.checkCoherency();
1183 self.assertEqual(f1.getTypeOfField(),ON_NODES);
1184 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1185 self.assertEqual(2,f1.getNumberOfComponents());
1186 self.assertEqual(9,f1.getNumberOfTuples());
1189 self.assertRaises(InterpKernelException, f2.applyFunc, 1, "a+b+c+d");
1190 self.assertRaises(InterpKernelException, f2.applyFunc, 1, "a/0");
1191 self.assertRaises(InterpKernelException, f2.applyFunc, "a/0");
1192 f2.applyFunc("abs(u)^2.4+2*u");
1193 self.assertEqual(f1.getTypeOfField(),ON_NODES);
1194 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1195 self.assertEqual(2,f1.getNumberOfComponents());
1196 self.assertEqual(9,f1.getNumberOfTuples());
1197 values2=[-0.9065304805418678, -0.85105859001709905, -0.19601892829446504, -0.37898777756476987,
1198 0.91090317490482353, 2.1853504664669781, -0.19601892829446504, -0.37898777756476987,
1199 0.91090317490482353, 2.1853504664669781, 2.5765725275664879, 7.6987743736515295,
1200 0.91090317490482353, 2.1853504664669781, 2.5765725275664879, 7.6987743736515295,
1201 5.0423700574830965, 17.435300118916864]
1202 tmp=f2.getArray().getValues();
1203 self.assertEqual(len(tmp),len(values2))
1204 for i in xrange(len(tmp)):
1205 self.assertTrue(abs(tmp[i]-values2[i])<1.e-12)
1208 f1.applyFunc(1,"x+y");
1209 self.assertEqual(f1.getTypeOfField(),ON_NODES);
1210 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1211 self.assertEqual(1,f1.getNumberOfComponents());
1212 self.assertEqual(9,f1.getNumberOfTuples());
1213 values1=[-1.8,-0.3,1.2,-0.3,1.2,2.7,1.2,2.7,4.2]
1214 tmp=f1.getArray().getValues();
1215 self.assertEqual(len(tmp),len(values1))
1216 for i in xrange(len(tmp)):
1217 self.assertTrue(abs(tmp[i]-values1[i])<1.e-12)
1221 def testOperationsOnFields(self):
1222 m=MEDCouplingDataForTest.build2DTargetMesh_1();
1223 f1=m.fillFromAnalytic(ON_NODES,1,"x+y");
1224 f2=m.fillFromAnalytic(ON_NODES,1,"x+y");
1225 f1.checkCoherency();
1226 f2.checkCoherency();
1228 f3.checkCoherency();
1229 self.assertEqual(f3.getTypeOfField(),ON_NODES);
1230 self.assertEqual(f3.getTimeDiscretization(),ONE_TIME);
1231 values1=[-1.2,-0.2,0.8,-0.2,0.8,1.8,0.8,1.8,2.8]
1232 tmp=f3.getArray().getValues();
1233 self.assertEqual(len(values1),len(tmp))
1234 for i in xrange(len(tmp)):
1235 self.assertTrue(abs(tmp[i]-values1[i])<1.e-12)
1239 f3.checkCoherency();
1240 self.assertEqual(f3.getTypeOfField(),ON_NODES);
1241 self.assertEqual(f3.getTimeDiscretization(),ONE_TIME);
1242 values2=[0.36,0.01,0.16,0.01,0.16,0.81,0.16,0.81,1.96]
1243 tmp=f3.getArray().getValues();
1244 self.assertEqual(len(values2),len(tmp))
1245 for i in xrange(len(tmp)):
1246 self.assertTrue(abs(tmp[i]-values2[i])<1.e-12)
1251 f4.checkCoherency();
1252 self.assertEqual(f4.getTypeOfField(),ON_NODES);
1253 self.assertEqual(f4.getTimeDiscretization(),ONE_TIME);
1254 values3=[0.6,0.1,-0.4,0.1,-0.4,-0.9,-0.4,-0.9,-1.4]
1255 tmp=f4.getArray().getValues();
1256 self.assertEqual(len(values3),len(tmp))
1257 for i in xrange(len(tmp)):
1258 self.assertTrue(abs(tmp[i]-values3[i])<1.e-12)
1263 f4.checkCoherency();
1264 self.assertEqual(f4.getTypeOfField(),ON_NODES);
1265 self.assertEqual(f4.getTimeDiscretization(),ONE_TIME);
1266 tmp=f4.getArray().getValues();
1267 for i in xrange(len(tmp)):
1268 self.assertTrue(abs(tmp[i]-2.)<1.e-12)
1271 f4=f2.buildNewTimeReprFromThis(NO_TIME,False);
1272 f4.checkCoherency();
1273 self.assertEqual(f4.getTypeOfField(),ON_NODES);
1274 self.assertEqual(f4.getTimeDiscretization(),NO_TIME);
1275 self.assertRaises(InterpKernelException,f1.__add__,f4);
1276 f5=f4.buildNewTimeReprFromThis(ONE_TIME,False);
1277 self.assertEqual(f5.getTypeOfField(),ON_NODES);
1278 self.assertEqual(f5.getTimeDiscretization(),ONE_TIME);
1280 tmp=f3.getArray().getValues();
1281 values4=[-1.2,-0.2,0.8,-0.2,0.8,1.8,0.8,1.8,2.8]
1282 self.assertEqual(len(values3),len(tmp))
1283 for i in xrange(len(tmp)):
1284 self.assertTrue(abs(tmp[i]-values4[i])<1.e-12)
1287 f4=f2.buildNewTimeReprFromThis(NO_TIME,True);
1288 f4.checkCoherency();
1289 self.assertEqual(f4.getTypeOfField(),ON_NODES);
1290 self.assertEqual(f4.getTimeDiscretization(),NO_TIME);
1291 self.assertRaises(InterpKernelException,f1.__add__,f4);
1292 f5=f4.buildNewTimeReprFromThis(ONE_TIME,True);
1293 self.assertEqual(f5.getTypeOfField(),ON_NODES);
1294 self.assertEqual(f5.getTimeDiscretization(),ONE_TIME);
1296 tmp=f3.getArray().getValues();
1297 values5=[-1.2,-0.2,0.8,-0.2,0.8,1.8,0.8,1.8,2.8]
1298 self.assertEqual(len(values5),len(tmp))
1299 for i in xrange(len(tmp)):
1300 self.assertTrue(abs(tmp[i]-values5[i])<1.e-12)
1304 def testOperationsOnFields2(self):
1305 m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1306 m.setTime(3.4,5,6); m.setTimeUnit("us");
1307 f1=m.fillFromAnalytic(ON_NODES,1,"x+y+z");
1308 f2=m.fillFromAnalytic(ON_NODES,1,"a*a+b+c*c");
1310 f3.checkCoherency();
1311 self.assertEqual(f3.getTypeOfField(),ON_NODES);
1312 self.assertEqual(f3.getTimeDiscretization(),ONE_TIME);
1313 expected1=[-2.4999999999999991, 1.2162162162162162, 0.77868852459016391,
1314 0.7407407407407407, 1.129032258064516, 0.81632653061224492,
1315 0.86538461538461531, 1.0919540229885056, 0.84302325581395343]
1316 self.assertEqual(1,f3.getNumberOfComponents());
1317 self.assertEqual(9,f3.getNumberOfTuples());
1318 val=f3.getArray().getValues();
1320 self.assertTrue(abs(expected1[i]-val[i])<1.e-12);
1322 f1=m.buildOrthogonalField();
1323 self.assertAlmostEqual(3.4,f1.getTime()[0],12) ; self.assertEqual(5,f1.getTime()[1]) ; self.assertEqual(6,f1.getTime()[2])
1324 self.assertEqual("us",f1.getTimeUnit())
1325 f2=m.fillFromAnalytic(ON_CELLS,1,"x");
1327 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]
1328 val=f3.getArray().getValues();
1329 for i in xrange(15):
1330 self.assertTrue(abs(expected2[i]-val[i])<1.e-12);
1334 val=f3.getArray().getValues();
1335 for i in xrange(15):
1336 self.assertTrue(abs(expected2[i]-val[i])<1.e-12);
1340 def testOperationsOnFields3(self):
1341 m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1342 f1=m.fillFromAnalytic(ON_NODES,1,"x+y+z");
1343 f2=m.fillFromAnalytic(ON_NODES,1,"a*a+b+c*c");
1345 f1.checkCoherency();
1346 self.assertEqual(f1.getTypeOfField(),ON_NODES);
1347 self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1348 expected1=[-2.4999999999999991, 1.2162162162162162, 0.77868852459016391,
1349 0.7407407407407407, 1.129032258064516, 0.81632653061224492,
1350 0.86538461538461531, 1.0919540229885056, 0.84302325581395343]
1351 self.assertEqual(1,f1.getNumberOfComponents());
1352 self.assertEqual(9,f1.getNumberOfTuples());
1353 val=f1.getArray().getValues();
1355 self.assertTrue(abs(expected1[i]-val[i])<1.e-12);
1358 f1=m.buildOrthogonalField();
1359 f2=m.fillFromAnalytic(ON_CELLS,1,"x");
1361 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]
1362 val=f1.getArray().getValues();
1363 for i in xrange(15):
1364 self.assertTrue(abs(expected2[i]-val[i])<1.e-12);
1367 f1=m.buildOrthogonalField();
1368 # to avoid valgrind leaks
1369 # self.assertRaises(InterpKernelException,f2.__imul__,f1);
1372 def testOperationsOnFields4(self):
1373 m=MEDCouplingDataForTest.build2DTargetMesh_1();
1374 nbOfCells=m.getNumberOfCells();
1375 f1=MEDCouplingFieldDouble.New(ON_CELLS,CONST_ON_TIME_INTERVAL);
1377 array=DataArrayDouble.New();
1379 self.assertRaises(InterpKernelException,f1.setEndArray,array);
1380 self.assertRaises(InterpKernelException,f1.getEndArray);
1381 arr1=[0.,10.,20.,1.,11.,21.,2.,12.,22.,3.,13.,23.,4.,14.,24.]
1382 arr2=[5.,15.,25.,6.,16.,26.,7.,17.,27.,8.,18.,28.,9.,19.,29.]
1383 array.setValues(arr1,nbOfCells,3);
1384 f1.setStartTime(2.,0,0);
1385 f1.setEndTime(3.,0,0);
1386 f1.checkCoherency();
1388 res=f1.getValueOn(pos);
1389 self.assertTrue(abs(arr1[3]-res[0])<1.e-12);
1390 self.assertTrue(abs(arr1[4]-res[1])<1.e-12);
1391 self.assertTrue(abs(arr1[5]-res[2])<1.e-12);
1393 res=f1.getValueOn(pos,2.2);
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 self.assertRaises(InterpKernelException,f1.getValueOn,pos,3.2)
1399 f2=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
1401 f2.setArray(f1.getArray());
1402 f2.setStartTime(2.,3,0);
1403 f2.setEndTime(4.,13,0);
1404 self.assertRaises(InterpKernelException,f2.checkCoherency)
1405 array2=DataArrayDouble.New();
1406 array2.setValues(arr2,nbOfCells,3);
1407 f2.setEndArray(array2);
1408 f2.checkCoherency();
1411 res=f2.getValueOn(pos,3.21);
1412 self.assertTrue(abs(4.025-res[0])<1.e-12);
1413 self.assertTrue(abs(14.025-res[1])<1.e-12);
1414 self.assertTrue(abs(24.025-res[2])<1.e-12);
1416 self.assertTrue(f2.isEqual(f3,1e-12,1e-12));
1417 f3.getEndArray().setIJ(0,0,5.001);
1418 self.assertTrue(not f2.isEqual(f3,1e-12,1e-12));
1419 self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1420 f3.setStartTime(2.1,3,0);
1421 self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1422 f3.setStartTime(2.,3,0);
1423 self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1424 f3.setStartTime(2.,4,0);
1425 self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1426 f3.setStartTime(2.,3,1);
1427 self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1428 f3.setStartTime(2.,3,0);
1429 self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1430 f3.setEndTime(4.1,13,0);
1431 self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1432 f3.setEndTime(4.,13,0);
1433 self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1434 f3.setEndTime(4.,14,0);
1435 self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1436 f3.setEndTime(4.,13,1);
1437 self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1438 f3.setEndTime(4.,13,0);
1439 self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1442 res=f4.getValueOn(pos,3.21);
1443 self.assertTrue(abs(8.05-res[0])<1.e-12);
1444 self.assertTrue(abs(28.05-res[1])<1.e-12);
1445 self.assertTrue(abs(48.05-res[2])<1.e-12);
1448 res=f4.getValueOn(pos,3.21);
1449 self.assertTrue(abs(12.075-res[0])<1.e-12);
1450 self.assertTrue(abs(42.075-res[1])<1.e-12);
1451 self.assertTrue(abs(72.075-res[2])<1.e-12);
1454 def testMergeNodesOnField(self):
1455 targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
1456 f1=targetMesh.fillFromAnalytic(ON_NODES,1,"x+y+z");
1457 f1.mergeNodes(1e-10);
1459 targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
1460 f1=targetMesh.fillFromAnalytic(ON_NODES,1,"x+y+z");
1462 tmp.setIJ(0,0,1000.);
1463 f1.mergeNodes(1e-10);
1465 targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
1466 f1=targetMesh.fillFromAnalytic(ON_NODES,1,"x+y+z");
1468 tmp.setIJ(1,0,1000.);
1469 self.assertRaises(InterpKernelException,f1.mergeNodes,1.e-10)
1472 def testCheckConsecutiveCellTypes(self):
1473 sourceMesh=MEDCouplingDataForTest.build2DSourceMesh_1();
1474 targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1475 self.assertTrue(sourceMesh.checkConsecutiveCellTypes());
1476 order1=[NORM_TRI3,NORM_QUAD4]
1477 order2=[NORM_QUAD4,NORM_TRI3]
1478 self.assertTrue(not targetMesh.checkConsecutiveCellTypes());
1479 self.assertTrue(not targetMesh.checkConsecutiveCellTypesAndOrder(order1));
1480 self.assertTrue(not targetMesh.checkConsecutiveCellTypesAndOrder(order2));
1481 da=targetMesh.getRenumArrForConsecutiveCellTypesSpec(order1);
1482 self.assertEqual(5,da.getNumberOfTuples());
1483 self.assertEqual(1,da.getNumberOfComponents());
1484 expected1=[2,0,1,3,4]
1485 self.assertTrue(expected1==list(da.getValues()));
1486 da=targetMesh.getRenumArrForConsecutiveCellTypesSpec(order2);
1487 self.assertEqual(5,da.getNumberOfTuples());
1488 self.assertEqual(1,da.getNumberOfComponents());
1489 expected2=[0,3,4,1,2]
1490 self.assertTrue(expected2==list(da.getValues()));
1491 renumber1=[4,0,1,2,3]
1492 targetMesh.renumberCells(renumber1,False);
1493 self.assertTrue(targetMesh.checkConsecutiveCellTypes());
1494 self.assertTrue(targetMesh.checkConsecutiveCellTypesAndOrder(order1));
1495 self.assertTrue(not targetMesh.checkConsecutiveCellTypesAndOrder(order2));
1498 def testRearrange2ConsecutiveCellTypes(self):
1499 m1_1=MEDCouplingDataForTest.build2DSourceMesh_1();
1500 m2_1=MEDCouplingDataForTest.build2DTargetMesh_1();
1501 arr1=m1_1.rearrange2ConsecutiveCellTypes();
1502 m1_2=MEDCouplingDataForTest.build2DSourceMesh_1();
1503 self.assertTrue(m1_2.isEqual(m1_1,1e-12));
1505 self.assertEqual(2,arr1.getNumberOfTuples());
1506 self.assertEqual(1,arr1.getNumberOfComponents());
1507 self.assertEqual(expected1,arr1.getValues());
1508 expected2=[0,3,4,1,2]
1509 arr1=m2_1.rearrange2ConsecutiveCellTypes();
1510 self.assertEqual(5,arr1.getNumberOfTuples());
1511 self.assertEqual(1,arr1.getNumberOfComponents());
1512 self.assertEqual(expected2,list(arr1.getValues()));
1513 m2_2=MEDCouplingDataForTest.build2DTargetMesh_1();
1514 self.assertEqual(5,arr1.getNumberOfTuples());
1515 self.assertEqual(1,arr1.getNumberOfComponents());
1516 self.assertEqual(expected2,list(arr1.getValues()));
1517 self.assertTrue(not m2_2.isEqual(m2_1,1e-12));
1518 m2_2.renumberCells(expected2,False);
1519 self.assertTrue(m2_2.isEqual(m2_1,1e-12));
1522 def testSplitByType(self):
1523 m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1525 self.assertEqual(3,len(v));
1526 m2=MEDCouplingUMesh.MergeUMeshesOnSameCoords(v);
1527 m2.setName(m1.getName());
1528 self.assertTrue(m1.isEqual(m2,1.e-12));
1531 def testFuseUMeshesOnSameCoords(self):
1532 m2=MEDCouplingDataForTest.build2DTargetMesh_1();
1534 m3=m2.buildPartOfMySelf(cells1,True);
1535 self.assertTrue(isinstance(m3,MEDCouplingUMesh))
1537 m4=m2.buildPartOfMySelf(cells2,True);
1538 self.assertTrue(isinstance(m4,MEDCouplingUMesh))
1540 m5=m2.buildPartOfMySelf(cells3,True);
1541 self.assertTrue(isinstance(m5,MEDCouplingUMesh))
1544 m7,corr=MEDCouplingUMesh.FuseUMeshesOnSameCoords(meshes,0);
1545 self.assertEqual(4,m7.getNumberOfCells());
1546 self.assertEqual(3,len(corr));
1547 expectedVals1=[3,3,2]
1548 expectedVals2=[[0,1,2],[3,0,2],[3,0]]
1551 self.assertEqual(1,arr.getNumberOfComponents());
1552 nbOfVals=expectedVals1[i];
1553 self.assertEqual(nbOfVals,arr.getNumberOfTuples());
1554 vals=arr.getValues();
1555 self.assertEqual(expectedVals2[i],list(vals));
1557 arr2,fidsOfGroups=DataArrayInt.MakePartition(corr,m7.getNumberOfCells());
1559 fidsGrp=[[1,3,5],[3,4,5],[4,5]]
1560 self.assertEqual(3,len(fidsOfGroups));
1561 self.assertEqual(1,arr2.getNumberOfComponents());
1562 self.assertEqual(4,arr2.getNumberOfTuples());
1563 self.assertEqual(fidExp,list(arr2.getValues()));
1565 nbOfVals=expectedVals1[i];
1566 self.assertEqual(list(fidsOfGroups[i]),fidsGrp[i]);
1570 def testFuseUMeshesOnSameCoords2(self):
1571 m1,m2=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
1573 m3=m1.buildPartOfMySelf(part1,True);
1575 m4=m1.buildPartOfMySelf(part2,True);
1576 meshes=[m1,m3,m3,m4]
1577 m5,corr=MEDCouplingUMesh.FuseUMeshesOnSameCoords(meshes,0);
1578 self.assertEqual(18,m5.getNumberOfCells());
1580 [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17],
1586 self.assertEqual(exp2[i],list(it.getValues()));
1591 def testBuildOrthogonalField(self):
1592 targetMesh=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1593 field=targetMesh.buildOrthogonalField();
1594 expected=[0.70710678118654746,0.,-0.70710678118654746]
1595 self.assertEqual(5,field.getNumberOfTuples());
1596 self.assertEqual(3,field.getNumberOfComponents());
1597 vals=field.getArray().getValues();
1598 for i in xrange(15):
1599 self.assertTrue(abs(expected[i%3]-vals[i])<1e-12);
1601 targetCoords=[0.,0.,0.,0.5,0.,0.5,1.,0.,1.,0.,1.,0.]
1602 targetConn=[0,1,2,3]
1603 targetMesh=MEDCouplingUMesh.New();
1604 targetMesh.setMeshDimension(2);
1605 targetMesh.allocateCells(1);
1606 targetMesh.insertNextCell(NORM_QUAD4,targetConn[0:4])
1607 targetMesh.finishInsertingCells();
1608 myCoords=DataArrayDouble.New();
1609 myCoords.setValues(targetCoords,4,3);
1610 targetMesh.setCoords(myCoords);
1611 field=targetMesh.buildOrthogonalField();
1612 self.assertEqual(1,field.getNumberOfTuples());
1613 self.assertEqual(3,field.getNumberOfComponents());
1614 vals=field.getArray().getValues();
1615 self.assertTrue(abs(-0.70710678118654746-vals[0])<1e-12);
1616 self.assertTrue(abs(0.-vals[1])<1e-12);
1617 self.assertTrue(abs(0.70710678118654746-vals[2])<1e-12);
1620 def testGetCellsContainingPoint(self):
1621 targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1622 pos=[0.,0.,0.4,0.4,0.,0.4,0.1,0.1,0.25,0.,0.65,0.]
1624 t1,t2=targetMesh.getCellsContainingPoints(pos,6,1e-12);
1625 self.assertEqual(6,t1.getNumberOfTuples());
1626 self.assertEqual(1,t1.getNumberOfComponents());
1627 self.assertEqual(7,t2.getNumberOfTuples());
1628 self.assertEqual(1,t2.getNumberOfComponents());
1629 expectedValues1=[0,4,3,0,1,2]
1630 expectedValues2=[0,1,2,3,4,5,6]
1631 self.assertEqual(list(t1.getValues()),expectedValues1);
1632 self.assertEqual(list(t2.getValues()),expectedValues2);
1633 #2D with no help of bounding box.
1635 MEDCouplingPointSet.Rotate2DAlg(center,0.78539816339744830962,6,pos);
1636 targetMesh.rotate(center,0.78539816339744830962);
1639 t1,t2=targetMesh.getCellsContainingPoints(pos,1e-12);
1640 self.assertEqual(6,t1.getNumberOfTuples());
1641 self.assertEqual(7,t2.getNumberOfTuples());
1642 self.assertEqual(list(t1.getValues()),expectedValues1);
1643 self.assertEqual(list(t2.getValues()),expectedValues2);
1644 t1,t2=targetMesh.getCellsContainingPoints(DataArrayDouble.New(pos,6,2),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 self.assertRaises(InterpKernelException,targetMesh.getCellsContainingPoints,DataArrayDouble.New(pos,4,3),1e-12);
1651 pos1bis=[-0.3303300858899107,-0.11819805153394641]
1652 self.assertEqual(-1,targetMesh.getCellContainingPoint(pos1bis,1e-12));
1654 targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1657 t1=targetMesh.getCellsContainingPoint(pos2,1e-12)
1658 self.assertEqual(2,len(t1));
1659 expectedValues3=[0,1]
1660 self.assertEqual(list(t1.getValues()),expectedValues3);
1663 t1=targetMesh.getCellsContainingPoint(pos3,1e-12);
1664 self.assertEqual(5,len(t1));
1665 expectedValues4=[0,1,2,3,4]
1666 self.assertEqual(list(t1.getValues()),expectedValues4);
1667 self.assertEqual(0,targetMesh.getCellContainingPoint(pos3,1e-12));
1669 targetMesh=MEDCouplingDataForTest.build3DTargetMesh_1();
1671 self.assertEqual(0,targetMesh.getCellContainingPoint(pos4,1e-12));
1674 t1=targetMesh.getCellsContainingPoint(pos5,1e-12);
1675 self.assertEqual(8,len(t1));
1676 expectedValues5=[0,1,2,3,4,5,6,7]
1677 self.assertEqual(list(t1.getValues()),expectedValues5);
1680 t1=targetMesh.getCellsContainingPoint(pos6,1e-12);
1681 self.assertEqual(2,len(t1));
1682 expectedValues6=[0,2]
1683 self.assertEqual(list(t1.getValues()),expectedValues6);
1686 self.assertEqual(-1,targetMesh.getCellContainingPoint(pos7,1e-12));
1690 targetMesh.rotate(center2,vec2,0.78539816339744830962);
1692 self.assertEqual(-1,targetMesh.getCellContainingPoint(pos8,1e-12));
1695 def testGetValueOn1(self):
1696 targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1697 fieldOnCells=MEDCouplingFieldDouble.New(ON_CELLS);
1698 nbOfCells=targetMesh.getNumberOfCells();
1699 fieldOnCells.setMesh(targetMesh);
1700 array=DataArrayDouble.New();
1701 tmp=2*nbOfCells*[None]
1702 for i in xrange(nbOfCells):
1703 tmp[2*i]=7.+float(i);
1704 tmp[2*i+1]=17.+float(i)
1706 array.setValues(tmp,nbOfCells,2);
1707 fieldOnCells.setArray(array);
1710 res=fieldOnCells.getValueOn(pos1);
1711 self.assertEqual(2,len(res))
1712 self.assertTrue(abs(8.-res[0])<1e-12);
1713 self.assertTrue(abs(18.-res[1])<1e-12);
1716 targetMesh=MEDCouplingDataForTest.build2DSourceMesh_1();
1717 fieldOnNodes=MEDCouplingFieldDouble.New(ON_NODES);
1718 nbOfNodes=targetMesh.getNumberOfNodes();
1719 fieldOnNodes.setMesh(targetMesh);
1720 array=DataArrayDouble.New();
1721 tmp=2*nbOfNodes*[None]
1722 for i in xrange(nbOfNodes):
1723 tmp[2*i]=17.+float(i);
1724 tmp[2*i+1]=27.+float(i)
1726 array.setValues(tmp,nbOfNodes,2);
1727 fieldOnNodes.setArray(array);
1729 pos2=[-0.13333333333333333,-0.13333333333333333]
1731 res=fieldOnNodes.getValueOn(pos2);
1732 self.assertEqual(2,len(res))
1733 self.assertTrue(abs(17.5-res[0])<1e-12);
1734 self.assertTrue(abs(27.5-res[1])<1e-12);
1735 pos3=[0.033333333333333326,0.36666666666666664]
1737 res=fieldOnNodes.getValueOn(pos3);
1738 self.assertEqual(2,len(res))
1739 self.assertTrue(abs(18.666666666666667-res[0])<1e-12);
1740 self.assertTrue(abs(28.666666666666667-res[1])<1e-12);
1743 def testCMesh0(self):
1744 mesh=MEDCouplingCMesh.New();
1745 meshEmpty=mesh.clone(True);
1746 self.assertTrue(meshEmpty.isEqual(mesh, 1e-12));
1748 coordsX=DataArrayDouble.New();
1749 arrX=[ -1., 1., 2., 4. ]
1750 coordsX.setValues(arrX, 4, 1);
1751 coordsY=DataArrayDouble.New();
1752 arrY=[ -2., 2., 4., 8. ]
1753 coordsY.setValues(arrY, 4, 1);
1754 coordsZ=DataArrayDouble.New();
1755 arrZ=[ -3., 3., 6., 12. ]
1756 coordsZ.setValues(arrZ, 4, 1);
1757 mesh.setCoords(coordsX, coordsY, coordsZ);
1759 fieldOnNodes=mesh.fillFromAnalytic(ON_NODES, 1, "x+y/2.+z/3.");
1760 self.assertEqual(1, fieldOnNodes.getNumberOfComponents());
1761 self.assertEqual(64, fieldOnNodes.getNumberOfTuples());
1762 expected1=[-3., -1., 0., 2., -1., 1., 2., 4., 0., 2., 3., 5., 2., 4., 5., 7., -1., 1., 2.,
1763 4., 1., 3., 4., 6., 2., 4., 5., 7., 4., 6., 7., 9., 0., 2., 3., 5., 2., 4., 5.,
1764 7., 3., 5., 6., 8., 5., 7., 8., 10., 2., 4., 5.,
1765 7., 4., 6., 7., 9., 5., 7., 8., 10., 7., 9., 10., 12.];
1767 val=fieldOnNodes.getArray().getValues();
1768 for i in xrange(64):
1769 self.assertAlmostEqual(expected1[i], val[i], 12)
1770 res=fieldOnNodes.getValueOnPos(1, 3, 2);
1771 self.assertAlmostEqual(7., res[0], 12);
1773 fieldOnCells=mesh.fillFromAnalytic(ON_CELLS, 1, "x+y/2.+z/3.");
1774 self.assertEqual(1, fieldOnCells.getNumberOfComponents());
1775 self.assertEqual(27, fieldOnCells.getNumberOfTuples());
1776 val=fieldOnCells.getArray().getValues();
1777 expected2=[0, 1.5, 3, 1.5, 3, 4.5, 3, 4.5, 6, 1.5, 3, 4.5, 3, 4.5,
1778 6, 4.5, 6, 7.5, 3, 4.5, 6, 4.5, 6, 7.5, 6, 7.5, 9];
1779 for i in xrange(27):
1780 self.assertAlmostEqual(expected2[i], val[i], 12);
1781 #res=fieldOnCells.getValueOnPos(1,2,1);
1782 #self.assertAlmostEqual(6.,res,12);
1784 meshDeepCopy=mesh.deepCpy();
1785 meshClone=mesh.clone(False);
1787 meshEmpty.copyTinyStringsFrom(mesh);
1788 #no data in meshEmpty, expected False
1789 self.assertTrue(not meshEmpty.isEqual(mesh, 1e-12));
1791 self.assertTrue(meshDeepCopy.isEqual(mesh, 1e-12));
1792 meshDeepCopy.copyTinyStringsFrom(mesh);
1793 self.assertTrue(meshDeepCopy.isEqual(mesh, 1e-12));
1794 self.assertTrue(meshClone.isEqual(mesh, 1e-12));
1796 self.assertEqual(CARTESIAN, mesh.getType());
1797 self.assertEqual(CARTESIAN, meshEmpty.getType());
1798 self.assertEqual(CARTESIAN, meshDeepCopy.getType());
1799 self.assertEqual(CARTESIAN, meshClone.getType());
1802 def testCMesh1(self):
1803 mesh1=MEDCouplingCMesh.New();
1804 coordsX1=DataArrayDouble.New();
1805 arrX1=[ -1., 1., 2., 4. ]
1806 coordsX1.setValues(arrX1, 4, 1);
1807 coordsY1=DataArrayDouble.New();
1808 arrY1=[ -2., 2., 4., 8. ]
1809 coordsY1.setValues(arrY1, 4, 1);
1810 coordsZ1=DataArrayDouble.New();
1811 arrZ1=[ -3., 3., 6., 12. ]
1812 coordsZ1.setValues(arrZ1, 4, 1);
1813 mesh1.setCoords(coordsX1, coordsY1, coordsZ1);
1815 mesh2=MEDCouplingCMesh.New();
1816 coordsX2=DataArrayDouble.New();
1817 arrX2=[ -1., 1., 2., 4. ]
1818 coordsX2.setValues(arrX2, 4, 1);
1819 coordsY2=DataArrayDouble.New();
1820 arrY2=[ -2., 2., 4., 8. ]
1821 coordsY2.setValues(arrY2, 4, 1);
1822 coordsZ2=DataArrayDouble.New();
1823 arrZ2=[ -3., 3., 6., 12.+1e-6 ]
1824 coordsZ2.setValues(arrZ2, 4, 1);
1825 mesh2.setCoords(coordsX2, coordsY2, coordsZ2);
1827 mesh3=MEDCouplingCMesh.New();
1828 coordsX3=DataArrayDouble.New();
1830 coordsX3.setValues(arrX3, 1, 1);
1831 coordsY3=DataArrayDouble.New();
1833 coordsY3.setValues(arrY3, 1, 1);
1834 coordsZ3=DataArrayDouble.New();
1836 coordsZ3.setValues(arrZ3, 1, 1);
1837 mesh3.setCoords(coordsX3, coordsY3, coordsZ3);
1839 self.assertEqual(3, mesh1.getSpaceDimension());
1840 self.assertEqual(3, mesh1.getMeshDimension());
1842 self.assertTrue(not mesh1.isEqual(mesh2, 1e-12));
1843 self.assertTrue(not mesh2.isEqual(mesh1, 1e-12));
1844 self.assertTrue(not mesh2.isEqualWithoutConsideringStr(mesh1, 1e-12));
1845 self.assertTrue(mesh1.isEqual(mesh2, 1e-5));
1846 self.assertTrue(not mesh1.isEqual(mesh2, 1e-7));
1848 self.assertRaises(InterpKernelException, mesh3.checkCoherency1, 1e-12);
1849 mesh1.checkCoherency1(1e-12);
1850 self.assertEqual(NORM_HEXA8, mesh1.getTypeOfCell(1));
1852 self.assertEqual(NORM_HEXA8, mesh1.getAllGeoTypes()[0]);
1853 self.assertEqual(27, mesh1.getNumberOfCellsWithType(NORM_HEXA8));
1854 self.assertRaises(InterpKernelException, mesh1.getNumberOfCellsWithType, NORM_QUAD4);
1856 coo=mesh1.getCoordinatesOfNode(0);
1857 self.assertEqual(3, len(coo));
1858 self.assertAlmostEqual(-1., coo[0], 14);
1859 self.assertAlmostEqual(-2., coo[1], 14);
1860 self.assertAlmostEqual(-3., coo[2], 14);
1861 coo=mesh1.getCoordinatesOfNode(63);
1862 self.assertEqual(3, len(coo));
1863 self.assertAlmostEqual(4., coo[0], 14);
1864 self.assertAlmostEqual(8., coo[1], 14);
1865 self.assertAlmostEqual(12., coo[2], 14);
1868 repr=mesh1.simpleRepr();
1869 repr=mesh1.advancedRepr();
1870 self.assertTrue("Cartesian" in repr);
1871 self.assertTrue("Number of components : 1" in repr);
1872 self.assertTrue("Number of tuples : 4" in repr);
1873 self.assertTrue("Z Array :" in repr);
1876 def testCMesh2(self):
1877 mesh1=MEDCouplingCMesh.New();
1878 coordsX1=DataArrayDouble.New();
1879 arrX1=[ -1., 1., 2., 4. ]
1880 coordsX1.setValues(arrX1, 4, 1);
1881 coordsY1=DataArrayDouble.New();
1882 arrY1=[ -2., 2., 4., 8. ]
1883 coordsY1.setValues(arrY1, 4, 1);
1884 coordsZ1=DataArrayDouble.New();
1885 arrZ1=[ -3., 3., 6., 12. ]
1886 coordsZ1.setValues(arrZ1, 4, 1);
1887 mesh1.setCoords(coordsX1, coordsY1, coordsZ1);
1889 dis=mesh1.getDistributionOfTypes();
1890 self.assertEqual(1, len(dis));
1891 self.assertEqual(NORM_HEXA8, dis[0][0]);
1892 self.assertEqual(27, dis[0][1]);
1893 self.assertEqual(-1, dis[0][2]);
1896 self.assertTrue(not mesh1.checkTypeConsistencyAndContig(dis, idsPerType));
1897 dis[0][0]=NORM_QUAD4;
1898 self.assertRaises(InterpKernelException, mesh1.checkTypeConsistencyAndContig, dis, idsPerType);
1899 dis[0][0]=NORM_HEXA8;
1901 ids=DataArrayInt.New();
1903 ids.fillWithValue(23);
1905 check=mesh1.checkTypeConsistencyAndContig(dis, idsPerType);
1906 self.assertTrue(check);
1907 self.assertTrue(check.isEqual(ids));
1909 code, idsInPflPerType, pfls=mesh1.splitProfilePerType(ids);
1910 self.assertEqual(1, len(code));
1911 self.assertEqual(NORM_HEXA8, code[0][0]);
1912 self.assertEqual(10, code[0][1]);
1913 self.assertEqual(0, code[0][2]);
1914 self.assertEqual(1, len(idsInPflPerType));
1915 self.assertEqual(1, len(pfls));
1916 self.assertTrue(idsInPflPerType[0].isEqual(DataArrayInt([0,1,2,3,4,5,6,7,8,9])));
1917 self.assertTrue(pfls[0].isEqual(ids));
1919 cells1=[0, 1, 25, 26]
1920 partMesh1=mesh1.buildPart(cells1)
1921 self.assertTrue(isinstance(partMesh1,MEDCouplingMesh))
1922 self.assertEqual(4, partMesh1.getNumberOfCellsWithType(NORM_HEXA8));
1923 self.assertEqual(64, mesh1.getNumberOfNodes());
1924 self.assertEqual(64, partMesh1.getNumberOfNodes());
1927 partMesh2, arr1=mesh1.buildPartAndReduceNodes(cells2)
1928 self.assertTrue(isinstance(partMesh2,MEDCouplingCMesh))
1929 self.assertEqual(2,partMesh2.getNumberOfCellsWithType(NORM_HEXA8));
1930 self.assertEqual(12,partMesh2.getNumberOfNodes());
1933 partMesh3, arr2=partMesh1.buildPartAndReduceNodes(cells3)
1934 self.assertTrue(isinstance(partMesh3,MEDCouplingUMesh))
1935 self.assertEqual(2, partMesh3.getNumberOfCellsWithType(NORM_HEXA8));
1936 self.assertEqual(12, partMesh3.getNumberOfNodes());
1938 self.assertRaises(InterpKernelException, mesh1.simplexize, 0);
1939 self.assertRaises(InterpKernelException, mesh1.getMeasureFieldOnNode, True);
1943 bbox1=mesh1.getBoundingBox(); #[(-1.0, 4.0), (-2.0, 8.0), (-3.0, 12.0)]
1944 bbox2=partMesh1.getBoundingBox();
1945 self.assertTrue(bbox1==bbox2);
1946 bbox1=partMesh3.getBoundingBox();
1947 bbox2=partMesh2.getBoundingBox();
1948 self.assertTrue(bbox1==bbox2);
1950 self.assertRaises(InterpKernelException, mesh1.buildOrthogonalField);
1951 mesh2d=MEDCouplingCMesh.New();
1952 mesh2d.setCoords(coordsX1, coordsY1);
1953 f1=mesh2d.buildOrthogonalField();
1957 def testScale(self):
1958 mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1960 mesh.scale(pos,0.5);
1961 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,
1962 -0.05,0.45, 0.2,0.45, 0.45,0.45]
1963 val=mesh.getCoords().getValues();
1964 self.assertEqual(18,len(val))
1965 for i in xrange(18):
1966 self.assertTrue(abs(expected1[i]-val[i])<1e-12);
1970 def testTryToShareSameCoords(self):
1971 m1=MEDCouplingDataForTest.build2DTargetMesh_1();
1972 m2=MEDCouplingDataForTest.build2DTargetMesh_1();
1973 self.assertTrue(m1.getCoords().getHiddenCppPointer()!=m2.getCoords().getHiddenCppPointer());
1974 m1.tryToShareSameCoords(m2,1e-12);
1975 self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1976 m1.tryToShareSameCoords(m2,1e-12);
1977 self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1978 m2.tryToShareSameCoords(m1,1e-12);
1979 self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1981 m1=MEDCouplingDataForTest.build2DTargetMesh_1();
1982 m2=MEDCouplingDataForTest.build2DTargetMesh_2();
1983 self.assertTrue(m1.getCoords().getHiddenCppPointer()!=m2.getCoords().getHiddenCppPointer());
1984 m1.tryToShareSameCoords(m2,1e-12);
1985 self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1986 m1.tryToShareSameCoords(m2,1e-12);
1987 self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1988 m2.tryToShareSameCoords(m1,1e-12);
1989 self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1991 m1=MEDCouplingDataForTest.build2DTargetMesh_1();
1992 m2=MEDCouplingDataForTest.build2DSourceMesh_1();
1993 self.assertTrue(m1.getCoords().getHiddenCppPointer()!=m2.getCoords().getHiddenCppPointer());
1994 self.assertRaises(InterpKernelException,m1.tryToShareSameCoords,m2,1e-12)
1997 def testFindNodeOnPlane(self):
1998 mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
2001 n=mesh.findNodesOnPlane(pt,v,1e-12);
2002 self.assertEqual(9,len(n));
2003 m3dSurf=mesh.buildFacePartOfMySelfNode(n,True);
2004 self.assertTrue(isinstance(m3dSurf,MEDCouplingUMesh))
2005 me=MEDCouplingExtrudedMesh.New(mesh,m3dSurf,0);
2006 da=me.getMesh3DIds();
2007 self.assertEqual(8,me.getNumberOfCells());
2008 expected=[0,1,2,3,4,5,6,7]
2010 self.assertEqual(expected,list(val));
2012 m3dSurf=mesh.buildFacePartOfMySelfNode(n,True);
2013 self.assertTrue(isinstance(m3dSurf,MEDCouplingUMesh))
2014 me=MEDCouplingExtrudedMesh.New(mesh,m3dSurf,0);
2015 da=me.getMesh3DIds();
2016 self.assertEqual(8,me.getNumberOfCells());
2017 expected=[0,1,2,3,4,5,6,7]
2019 self.assertEqual(expected,list(val));
2022 def testRenumberCells(self):
2023 m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2024 m2=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2025 self.assertTrue(m.isEqual(m2,0));
2027 m.renumberCells(arr,True);
2028 self.assertTrue(not m.isEqual(m2,0));
2029 self.assertEqual(NORM_QUAD4,m.getTypeOfCell(0));
2030 self.assertEqual(NORM_TRI3,m.getTypeOfCell(1));
2031 self.assertEqual(NORM_QUAD4,m.getTypeOfCell(2));
2032 self.assertEqual(NORM_TRI3,m.getTypeOfCell(3));
2033 self.assertEqual(NORM_QUAD4,m.getTypeOfCell(4));
2035 m.renumberCells(arr2,True);
2036 self.assertTrue(m.isEqual(m2,0));
2039 def testChangeSpaceDimension(self):
2040 m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2041 m2=MEDCouplingDataForTest.build2DTargetMesh_1();
2043 self.assertEqual(3,m1.getSpaceDimension());
2044 m1.changeSpaceDimension(2);
2045 self.assertEqual(2,m1.getSpaceDimension());
2046 m1.setName(m2.getName());
2047 self.assertTrue(m1.isEqual(m2,1e-12));
2048 m1.changeSpaceDimension(3);
2049 self.assertEqual(3,m1.getSpaceDimension());
2050 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.]
2051 val=m1.getCoords().getValues();
2052 for i in xrange(27):
2053 self.assertTrue(abs(expected[i]-val[i])<1e-14);
2057 def testGaussPointField1(self):
2058 _a=0.446948490915965;
2059 _b=0.091576213509771;
2060 _p1=0.11169079483905;
2061 _p2=0.0549758718227661;
2062 refCoo1=[ 0.,0., 1.,0., 0.,1. ]
2063 gsCoo1=[ 2*_b-1, 1-4*_b, 2*_b-1, 2.07*_b-1, 1-4*_b,
2064 2*_b-1, 1-4*_a, 2*_a-1, 2*_a-1, 1-4*_a, 2*_a-1, 2*_a-1 ]
2065 wg1=[ 4*_p2, 4*_p2, 4*_p2, 4*_p1, 4*_p1, 4*_p1 ]
2070 m=MEDCouplingDataForTest.build2DTargetMesh_1();
2071 f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,NO_TIME);
2073 self.assertEqual(5,f.getNumberOfMeshPlacesExpected());
2074 self.assertEqual(0,f.getNbOfGaussLocalization());
2075 f.setGaussLocalizationOnType(NORM_TRI3,_refCoo1,_gsCoo1,_wg1);
2076 f.setGaussLocalizationOnType(NORM_TRI3,_refCoo1,_gsCoo1,_wg1); # not a bug only to check that it works well
2077 self.assertRaises(InterpKernelException,f.setGaussLocalizationOnType,NORM_QUAD4,_refCoo1,_gsCoo1,_wg1)
2078 self.assertEqual(1,f.getNbOfGaussLocalization());
2079 refCoo2=[ 0.,0., 1.,0., 1.,1., 0.,1. ]
2081 _gsCoo1=_gsCoo1[0:4]
2083 f.setGaussLocalizationOnType(NORM_QUAD4,_refCoo2,_gsCoo1,_wg1);
2084 self.assertEqual(2,f.getNbOfGaussLocalization());
2085 array=DataArrayDouble.New();
2087 for i in xrange(18*2):
2089 array.setValues(ptr,18,2);
2090 ptr=array.getPointer();
2092 f.setName("MyFirstFieldOnGaussPoint");
2094 self.assertAlmostEqual(27.,f.getIJK(2,5,0),14);
2095 self.assertAlmostEqual(16.,f.getIJK(1,5,1),14);
2097 f.clearGaussLocalizations();
2098 self.assertEqual(0,f.getNbOfGaussLocalization());
2099 self.assertRaises(InterpKernelException,f.checkCoherency);
2101 self.assertRaises(InterpKernelException,f.setGaussLocalizationOnCells,ids1,_refCoo2,_gsCoo1,_wg1);
2102 self.assertEqual(0,f.getNbOfGaussLocalization());
2104 f.setGaussLocalizationOnCells(ids2,_refCoo2,_gsCoo1,_wg1);
2105 self.assertEqual(1,f.getNbOfGaussLocalization());
2106 self.assertEqual(0,f.getGaussLocalizationIdOfOneCell(0));
2107 self.assertRaises(InterpKernelException,f.getGaussLocalizationIdOfOneCell,1);
2109 f.setGaussLocalizationOnCells(ids3,_refCoo1,_gsCoo1,_wg1);
2110 self.assertEqual(2,f.getNbOfGaussLocalization());
2111 self.assertEqual(0,f.getGaussLocalizationIdOfOneCell(0));
2112 self.assertEqual(1,f.getGaussLocalizationIdOfOneCell(1));
2113 self.assertEqual(1,f.getGaussLocalizationIdOfOneCell(2));
2114 self.assertRaises(InterpKernelException,f.checkCoherency);#<- cell 3 has no localization
2118 _gsCoo2[0]=0.8888777776666;
2119 _wg2[0]=0.1234567892377;
2120 f.setGaussLocalizationOnCells(ids4,_refCoo2,_gsCoo2,_wg2);
2121 self.assertEqual(3,f.getNbOfGaussLocalization());
2122 tmpIds=f.getCellIdsHavingGaussLocalization(0);
2123 self.assertEqual(ids2,list(tmpIds.getValues()));
2124 self.assertRaises(InterpKernelException,f.checkCoherency);#<- it's always not ok because undelying array not with the good size.
2125 array2=f.getArray().substr(0,10);
2127 f.checkCoherency();#<- here it is OK
2129 self.assertTrue(f.isEqual(f2,1e-14,1e-14));
2130 gl1=f2.getGaussLocalization(0);
2131 tmp=gl1.getGaussCoord(1,1);
2132 self.assertAlmostEqual(2.07*_b-1,tmp,14);
2133 gl1.setGaussCoord(1,1,0.07);
2134 self.assertTrue(not f.isEqual(f2,1e-14,1e-14));
2135 gl1.setGaussCoord(1,1,tmp);
2136 self.assertTrue(f.isEqual(f2,1e-14,1e-14));
2137 f2.checkCoherency();
2140 def testGaussPointNEField1(self):
2141 m=MEDCouplingDataForTest.build2DTargetMesh_1();
2142 f=MEDCouplingFieldDouble.New(ON_GAUSS_NE,NO_TIME);
2144 self.assertEqual(5,f.getNumberOfMeshPlacesExpected());
2145 f.setName("MyFirstFieldOnNE");
2146 f.setDescription("MyDescriptionNE");
2147 array=DataArrayDouble.New();
2149 for i in xrange(18*2):
2152 array.setValues(tmp,18,2);
2153 ptr=array.getPointer();
2158 self.assertTrue(f.isEqual(f2,1e-14,1e-14));
2159 self.assertAlmostEqual(21.,f.getIJK(2,0,0),14);
2160 self.assertAlmostEqual(18.,f.getIJK(1,1,1),14);
2163 def testCellOrientation1(self):
2164 m=MEDCouplingDataForTest.build2DTargetMesh_1();
2166 self.assertRaises(InterpKernelException,m.are2DCellsNotCorrectlyOriented,vec,False);
2167 m.changeSpaceDimension(3);
2168 res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2169 self.assertTrue(len(res1)==0);
2171 res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2172 self.assertEqual(5,len(res1));
2175 # connectivity inversion
2176 conn=m.getNodalConnectivity().getValues();
2180 m.getNodalConnectivity().setValues(conn,len(conn),1)
2181 res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2182 self.assertEqual(1,len(res1));
2183 self.assertEqual(2,res1.getValues()[0]);
2184 m.orientCorrectly2DCells(vec,False);
2185 res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2186 self.assertTrue(len(res1)==0);
2187 m2=MEDCouplingDataForTest.build2DTargetMesh_1();
2188 m2.changeSpaceDimension(3);
2189 self.assertTrue(m.isEqual(m2,1e-12));
2192 def testCellOrientation2(self):
2193 m2,m1=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
2194 res1=m2.arePolyhedronsNotCorrectlyOriented();
2195 self.assertEqual(6,len(res1));
2196 m2.orientCorrectlyPolyhedrons();
2197 res1=m2.arePolyhedronsNotCorrectlyOriented();
2198 self.assertTrue(len(res1)==0);
2199 m2.checkCoherency();
2200 self.assertEqual(18,m2.getNumberOfCells());
2202 m2.convertToPolyTypes(cellIds2);
2203 m2.orientCorrectlyPolyhedrons();
2204 res1=m2.arePolyhedronsNotCorrectlyOriented();
2205 self.assertTrue(len(res1)==0);
2206 f2=m2.getMeasureField(False);
2207 f2Ptr=f2.getArray().getValues();
2208 #Test to check global reverse in MEDCouplingUMesh::tryToCorrectPolyhedronOrientation
2209 m3=MEDCouplingDataForTest.build2DTargetMesh_1();
2211 m3.changeSpaceDimension(3);
2213 m3.convertToPolyTypes(ids2);
2214 m3.orientCorrectly2DCells(vec,False);
2215 m4=MEDCouplingDataForTest.buildCU1DMesh_U();
2216 m4.changeSpaceDimension(3);
2219 m4.rotate(center,vector,-pi/2.);
2220 m5=m3.buildExtrudedMesh(m4,0);
2221 res1=m5.arePolyhedronsNotCorrectlyOriented();
2222 self.assertEqual(15,len(res1));
2223 m5.orientCorrectlyPolyhedrons();
2224 res1=m5.arePolyhedronsNotCorrectlyOriented();
2225 self.assertTrue(len(res1)==0);
2226 f3=m5.getMeasureField(False);
2227 self.assertEqual(15,f3.getArray().getNumberOfTuples());
2228 self.assertEqual(1,f3.getNumberOfComponents());
2229 f3Ptr=f3.getArray().getValues();
2230 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];
2231 for i in xrange(15):
2232 self.assertTrue(abs(expected1[i]-f3Ptr[i])<1e-12);
2234 f4=m5.getBarycenterAndOwner();
2235 self.assertEqual(15,f4.getNumberOfTuples());
2236 self.assertEqual(3,f4.getNumberOfComponents());
2237 f4Ptr=f4.getValues();
2238 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];
2239 for i in xrange(45):
2240 self.assertTrue(abs(expected2[i]-f4Ptr[i])<1e-12);
2244 def testCellOrientation3(self):
2245 from cmath import rect
2247 c = [rect(1.0, i*pi/4.0) for i in range(8)]
2248 coords = [c[-1].real,c[-1].imag, c[3].real,c[3].imag,
2249 c[5].real,c[5].imag, c[1].real,c[1].imag]
2251 baseMesh = MEDCouplingUMesh.New("circle", 2)
2252 baseMesh.allocateCells(1)
2253 meshCoords = DataArrayDouble.New(coords, 4, 2)
2254 baseMesh.setCoords(meshCoords)
2255 baseMesh.insertNextCell(NORM_QPOLYG, connec) # a circle
2256 baseMesh.finishInsertingCells()
2257 baseMesh.changeSpaceDimension(3)
2258 Oz = [0.0, 0.0, -1.0]
2259 cell_lst = baseMesh.are2DCellsNotCorrectlyOriented(Oz, False)
2260 self.assertEqual(cell_lst.getNumberOfTuples(), 0)
2262 cell_lst = baseMesh.are2DCellsNotCorrectlyOriented(Oz, False)
2263 self.assertEqual(cell_lst.getNumberOfTuples(), 1)
2265 def testPolyhedronBarycenter(self):
2266 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];
2267 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];
2268 meshN=MEDCouplingUMesh.New();
2269 meshN.setName("ForBary");
2270 meshN.setMeshDimension(3);
2271 meshN.allocateCells(4);
2272 meshN.insertNextCell(NORM_POLYHED,29,connN[0:29])
2273 meshN.finishInsertingCells();
2274 myCoords=DataArrayDouble.New();
2275 myCoords.setValues(coords,9,3);
2276 meshN.setCoords(myCoords);
2277 meshN.checkCoherency();
2279 res1=meshN.arePolyhedronsNotCorrectlyOriented();
2280 meshN.orientCorrectlyPolyhedrons();
2281 self.assertTrue(len(res1)==0);
2282 da=meshN.getBarycenterAndOwner();
2283 self.assertEqual(1,da.getNumberOfTuples());
2284 self.assertEqual(3,da.getNumberOfComponents());
2285 daPtr=da.getValues();
2286 ref=meshN.getCoords().getValues()[24:];
2288 self.assertTrue(abs(ref[i]-daPtr[i])<1e-12);
2293 da=meshN.getBarycenterAndOwner();
2294 daPtr=da.getValues();
2295 ref=meshN.getCoords().getValues()[24:];
2297 self.assertTrue(abs(ref[i]-daPtr[i])<1e-12);
2300 meshN.rotate(center,vec,pi/7.);
2301 meshN.translate(vec);
2302 da=meshN.getBarycenterAndOwner();
2303 daPtr=da.getValues();
2304 ref=meshN.getCoords().getValues()[24:];
2306 self.assertTrue(abs(ref[i]-daPtr[i])<1e-12);
2309 center2=[1.12,3.45,6.78]
2311 meshN.rotate(center2,vec2,e);
2312 meshN.translate(vec2);
2313 da=meshN.getBarycenterAndOwner();
2314 daPtr=da.getValues();
2315 ref=meshN.getCoords().getValues()[24:];
2317 self.assertTrue(abs(ref[i]-daPtr[i])<1e-10);
2321 def testNormL12Integ1D(self):
2322 m1=MEDCouplingDataForTest.build1DTargetMesh_3();
2323 f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2325 array=DataArrayDouble.New();
2326 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]
2327 array.setValues(arr,m1.getNumberOfCells(),3);
2330 f3=m1.getBarycenterAndOwner();
2331 self.assertEqual(4,f3.getNumberOfTuples());
2332 self.assertEqual(1,f3.getNumberOfComponents());
2333 expected9=[0.75,5.105,0.8,5.155]
2336 self.assertTrue(abs(expected9[i]-ptr[i])<1e-12);
2339 f2=m1.getMeasureField(False);
2340 self.assertEqual(4,f2.getArray().getNumberOfTuples());
2341 self.assertEqual(1,f2.getNumberOfComponents());
2342 expected1=[0.5,0.21,-0.6,-0.31]
2343 ptr=f2.getArray().getValues();
2345 self.assertTrue(abs(expected1[i]-ptr[i])<1e-12);
2347 expected2=[0.5,0.21,0.6,0.31]
2348 f2=m1.getMeasureField(True);
2349 ptr=f2.getArray().getValues();
2351 self.assertTrue(abs(expected2[i]-ptr[i])<1e-12);
2354 self.assertTrue(4,f1.getNumberOfTuples())
2355 res=f1.integral(False);
2356 self.assertTrue(3,len(res))
2357 expected3=[0.9866,-0.3615,0.4217]
2359 self.assertTrue(abs(expected3[i]-res[i])<1e-12);
2361 self.assertTrue(abs(expected3[0]-f1.integral(0,False))<1e-12);
2362 self.assertTrue(abs(expected3[1]-f1.integral(1,False))<1e-12);
2363 self.assertTrue(abs(expected3[2]-f1.integral(2,False))<1e-12);
2364 res=f1.integral(True);
2365 expected4=[-3.4152,8.7639,-14.6879]
2367 self.assertTrue(abs(expected4[i]-res[i])<1e-12);
2371 self.assertTrue(3,len(res))
2372 expected5=[6.979506172839505, 16.89018518518518, 27.02969135802469]
2374 self.assertTrue(abs(expected5[i]-res[i])<1e-12);
2376 self.assertTrue(abs(expected5[0]-f1.normL1(0))<1e-12);
2377 self.assertTrue(abs(expected5[1]-f1.normL1(1))<1e-12);
2378 self.assertTrue(abs(expected5[2]-f1.normL1(2))<1e-12);
2381 self.assertTrue(3,len(res))
2382 expected7=[7.090910979452395, 16.9275542960123, 27.053271464160858]
2384 self.assertTrue(abs(expected7[i]-res[i])<1e-9);
2386 self.assertTrue(abs(expected7[0]-f1.normL2(0))<1e-9);
2387 self.assertTrue(abs(expected7[1]-f1.normL2(1))<1e-9);
2388 self.assertTrue(abs(expected7[2]-f1.normL2(2))<1e-9);
2390 f4=f1.buildMeasureField(False);
2391 self.assertTrue(abs(-0.2-f4.accumulate(0))<1e-12);
2392 f4=f1.buildMeasureField(True);
2393 self.assertTrue(abs(1.62-f4.accumulate(0))<1e-12);
2394 # Testing with 2D Curve
2395 m1=MEDCouplingDataForTest.build2DCurveTargetMesh_3();
2396 f2=m1.getMeasureField(False);
2397 self.assertEqual(4,f2.getArray().getNumberOfTuples());
2398 self.assertEqual(1,f2.getNumberOfComponents());
2399 ptr=f2.getArray().getValues();
2401 self.assertTrue(abs(sqrt(2.)*expected2[i]-ptr[i])<1e-12);
2403 f2=m1.getMeasureField(True);
2404 self.assertEqual(4,f2.getArray().getNumberOfTuples());
2405 self.assertEqual(1,f2.getNumberOfComponents());
2406 ptr=f2.getArray().getValues();
2408 self.assertTrue(abs(expected2[i]*sqrt(2.)-ptr[i])<1e-12);
2411 f3=m1.getBarycenterAndOwner();
2412 self.assertEqual(4,f3.getNumberOfTuples());
2413 self.assertEqual(2,f3.getNumberOfComponents());
2414 expected10=[0.75,0.75,5.105,5.105,0.8,0.8,5.155,5.155]
2417 self.assertTrue(abs(expected10[i]-ptr[i])<1e-12);
2420 f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2422 array=DataArrayDouble.New();
2423 array.setValues(arr,m1.getNumberOfCells(),3);
2425 res=f1.integral(False);
2427 self.assertTrue(abs(sqrt(2.)*expected4[i]-res[i])<1e-12);
2429 res=f1.integral(True);
2431 self.assertTrue(abs(sqrt(2.)*expected4[i]-res[i])<1e-12);
2435 self.assertTrue(abs(expected5[i]-res[i])<1e-12);
2439 self.assertTrue(abs(expected7[i]-res[i])<1e-12);
2443 def testAreaBary2D(self):
2444 m1=MEDCouplingDataForTest.build2DTargetMesh_3();
2445 f1=m1.getMeasureField(False);
2446 self.assertEqual(10,f1.getArray().getNumberOfTuples());
2447 self.assertEqual(1,f1.getNumberOfComponents());
2448 expected1=[-0.5,-1,-1.5,-0.5,-1, 0.5,1,1.5,0.5,1]
2449 ptr=f1.getArray().getValues();
2450 for i in xrange(10):
2451 self.assertTrue(abs(expected1[i]-ptr[i])<1e-12);
2453 f1=m1.getMeasureField(True);
2454 ptr=f1.getArray().getValues();
2455 for i in xrange(10):
2456 self.assertTrue(abs(abs(expected1[i])-ptr[i])<1e-12);
2458 f2=m1.getBarycenterAndOwner();
2459 self.assertEqual(10,f2.getNumberOfTuples());
2460 self.assertEqual(2,f2.getNumberOfComponents());
2461 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]
2463 for i in xrange(20):
2464 self.assertTrue(abs(expected2[i]-ptr[i])<1e-12);
2466 m1.changeSpaceDimension(3);
2467 f1=m1.getMeasureField(False);
2468 self.assertEqual(10,f1.getArray().getNumberOfTuples());
2469 self.assertEqual(1,f1.getNumberOfComponents());
2470 ptr=f1.getArray().getValues();
2471 for i in xrange(10):
2472 self.assertTrue(abs(abs(expected1[i])-ptr[i])<1e-12);
2474 f2=m1.getBarycenterAndOwner();
2475 self.assertEqual(10,f2.getNumberOfTuples());
2476 self.assertEqual(3,f2.getNumberOfComponents());
2478 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.]
2479 for i in xrange(30):
2480 self.assertTrue(abs(expected3[i]-ptr[i])<1e-12);
2484 def testAreaBary3D(self):
2485 coords=[ 0.241310763507 , 0.0504777305619 , 0.0682283524903 , 0.252501053866 , -0.0625176732937 , 0.137272639894 ,
2486 0.152262663601 , 0.241816569527 , 0.133812556197 , 0.18047750211 , -0.0789949051358 , 0.339098173401 ,
2487 0.151741971857 , 0.238885278571 , 0.137715037333 , 0.242532155481 , -0.0928169086456 , 0.0678043417367 ,
2488 0.240941965335 , -0.015461491464 , 0.0617186345825 , 0.24127650112 , 0.0499427876717 , 0.0679634099148 ,
2489 -0.145828917428 , 0.206291632565 , 0.0310071927543 , 0.0125651775307 , 0.266262085828 , 0.105228430543 ,
2490 -0.0994066533286 , 0.233224271238 , 0.0572213839567 , -0.0951345338317 , 0.234819509426 , 0.0592126284538 ,
2491 0.136580574205 , -0.205486212579 , 0.0572866072014 , 0.0637270784978 , -0.168886355238 , 0.446614057077 ,
2492 0.041337157151 , -0.213402568198 , 0.372407095999 , 0.0411601970268 , -0.202387875756 , 0.411334979491 ,
2493 -0.108355701857 , 0.193636239335 , 0.204886756738 , 0.00639779029829 , 0.155296981517 , 0.252585892979 ,
2494 0.0262473111702 , -0.112919732543 , 0.424286639249 ,-0.224103052733 , -0.139430015438 , -0.0122352295701 ,
2495 -0.0312760589481 , -0.274272003594 , 0.0323959636568 , -0.166663422532 , -0.217754445175 , 0.00392109070364 ,
2496 -0.30586619777 , -0.0475168041091 , -0.0144585228182 , -0.280881480586 , 0.135571293538 , 0.00623923647986 ,
2497 -0.25548538234 , 0.156819217766 , 0.0645277879769 , -0.131567009284 , 0.184133752309 , 0.206021802753 ,
2498 -0.196204010965 , 0.151602971681 , 0.212974777736 , -0.183713879463 , 0.0802946639531 , 0.260115662599 ,
2499 -0.244241178767 , -0.0738873389604 , 0.144590565817 , -0.155804057829 , -0.164892720025 , 0.210613950558 ,
2500 -0.170950800428 , -0.215099334026 , 0.00610122860092 , -0.30552634869 , -0.0490020791904 , -0.0132786533145 ,
2501 0.271831011884 , 0.15105657296 , 0.0230534827908 , 0.281919192283 , 0.0898544306288 , -0.0625201489143 ,
2502 0.260240727276 , -0.0120688706637 , -0.0532316588626 , 0.244947737722 , 0.0197984684293 , 0.0309341209233 ,
2503 0.23439631578 , 0.229825279875 , 0.0508520585381 , 0.160921316875 , 0.265078502128 , 0.121716560626 ,
2504 -0.315088694175 , 0.0747700471918 , -0.245836615071 , -0.327728781776 , 0.0857114674649 , -0.239431905957 ,
2505 -0.308385460634 , 0.145142997084 , -0.149886828433 , 0.0488236045164 , 0.309462801914 , 0.0849169148265 ,
2506 -0.0244964803395 , 0.33145611751 , -0.0476415818061 , 0.0060567994229 , 0.32418412014 , 0.0367779543812 ,
2507 -0.0950221448063 , 0.236675326003 , 0.0572594453983 , 0.248723023186 , 0.0886648784791 , -0.176629430538 ,
2508 0.116796984 , 0.256596599567 , -0.292863523603 , 0.118024552914 , 0.229154257843 , -0.34233232501 ,
2509 0.217507892549 , -0.0417822335742 , -0.176771782888 , -0.224429321304 , 0.0125595300114 , -0.362064725588 ,
2510 0.0937301100955 , -0.0500824832657 , -0.299713548444 , -0.244162220397 , 0.0383853931293 , -0.389856984411 ,
2511 -0.0281989366102 , 0.097392811563 , -0.458244577284 , -0.385010847162 , 0.10122766194 , -0.140052859922 ,
2512 -0.377936358012 , 0.110875172128 , -0.176207095463 , 0.244483045556 , -0.0991073977045 , 0.0575134372934 ,
2513 0.262605120167 , -0.100243191645 , -0.0495620806935 , 0.240306880972 , -0.136153701579 , -0.114745281696 ,
2514 0.215763176129 , -0.0836766059189 , -0.183249640616 , 0.237870396603 , -0.132449578286 , -0.121598854639 ,
2515 -0.0637683083097 , -0.27921020214 , -0.149112321992 , -0.0856211014977 , -0.2973233473 , -0.0446878139589 ,
2516 0.104675342288 , -0.0625908305324 , -0.290346256534 , 0.0248264249186 , -0.247797708548 , -0.165830884019 ,
2517 0.0719302438309 , -0.178468260473 , -0.211432157345 , 0.142871843159 , -0.208769948542 , 0.0454101128246 ,
2518 0.167803379307 , -0.207851396623 , -0.088802726124 , 0.12868717152 , -0.230920439715 , 0.00760508389036 ,
2519 -0.0372812069535 , -0.286740286332 , 0.00963701291166 ]
2521 connN = [ #polyhedron 0
2522 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
2523 , 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
2524 , 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
2525 , 22 , 19 , 21 , 30 , 31 , -1 , 22 , 31 , 28 , 27 , 26 , 24 , 23 , -1 , 31 , 30 , 29 , 28,
2527 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
2528 , 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
2529 , 33 , 34 , 48 , 45 , -1 , 35 , 34 , 48 , 50 , 49 , 38 , -1 , 41 , 43 , 42 , 46 , 36 , 37 , -1 , 38 , 39 , 51 , 49 , -1
2530 , 39 , 40 , 42 , 46 , 47 , 52 , 51 , -1 , 45 , 47 , 52 , 50 , 48 , -1 , 52 , 51 , 49 , 50,
2532 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
2533 , 23 , 53 , 54 , 40 , 8 , -1 , 53 , 22 , 23 , -1 , 39 , 54 , 40,
2535 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
2536 , 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
2537 , 55 , 5 , 12 , 65 , -1 , 66 , 67 , 65 , 55 , 56 , 57 , -1 , 63 , 66 , 57 , 59 , 64 , -1 , 64 , 62 , 58 , 59 , -1
2538 , 60 , 63 , 66 , 67 , 68 , 61 , -1 , 61 , 68 , 20 , 21 , -1 , 67 , 68 , 20 , 12 , 65]
2540 barys = [ -0.0165220465527 , -0.0190922868195 , 0.158882733414 ,
2541 0.0287618656076 , 0.135874379934 , -0.14601588119 ,
2542 -0.147128055553 , 0.0465995097041 , -0.049391174453 ,
2543 -0.00142506732317 , -0.0996953090351 , -0.115159183132 ]
2544 meshN=MEDCouplingUMesh.New();
2545 meshN.setName("ForBary");
2546 meshN.setMeshDimension(3);
2547 meshN.allocateCells(4);
2548 meshN.insertNextCell(NORM_POLYHED,113,connN);
2549 meshN.insertNextCell(NORM_POLYHED,99,connN[113:]);
2550 meshN.insertNextCell(NORM_POLYHED,43,connN[212:]);
2551 meshN.insertNextCell(NORM_POLYHED,92,connN[255:]);
2552 meshN.finishInsertingCells();
2553 myCoords=DataArrayDouble.New();
2554 myCoords.setValues(coords,69,3);
2555 meshN.setCoords(myCoords);
2556 meshN.checkCoherency();
2557 res1=meshN.arePolyhedronsNotCorrectlyOriented();
2558 meshN.orientCorrectlyPolyhedrons();
2559 res1=meshN.arePolyhedronsNotCorrectlyOriented();
2560 self.assertTrue(len(res1)==0);
2562 da=meshN.getBarycenterAndOwner();
2563 self.assertEqual(4,da.getNumberOfTuples());
2564 self.assertEqual(3,da.getNumberOfComponents());
2565 daPtr=da.getValues();
2566 for i in xrange(12):
2567 self.assertTrue(abs(barys[i]-daPtr[i])<1e-12);
2571 def testRenumberCellsForFields(self):
2572 m=MEDCouplingDataForTest.build2DTargetMesh_1();
2573 f=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2575 arr=DataArrayDouble.New();
2576 nbOfCells=m.getNumberOfCells();
2577 values1=[7.,107.,10007.,8.,108.,10008.,9.,109.,10009.,10.,110.,10010.,11.,111.,10011.]
2578 arr.setValues(values1,nbOfCells,3);
2580 renumber1=[3,1,0,4,2]
2581 loc=[-0.05,-0.05, 0.55,-0.25, 0.55,0.15, -0.05,0.45, 0.45,0.45]
2583 res=f.getValueOn(loc[2*j:2*j+2]);
2585 self.assertTrue(abs(values1[i+3*j]-res[i])<1e-12);
2588 f.renumberCells(renumber1,False);
2589 ptr=f.getArray().getValues();
2590 expected1=[9.,109.,10009.,8.,108.,10008.,11.,111.,10011.,7.,107.,10007.,10.,110.,10010.]
2591 for i in xrange(15):
2592 self.assertTrue(abs(expected1[i]-ptr[i])<1e-12);
2594 #check that fields remains the same geometrically
2596 res=f.getValueOn(loc[2*j:2*(j+1)]);
2598 self.assertTrue(abs(values1[i+3*j]-res[i])<1e-12);
2602 f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,NO_TIME);
2604 _a=0.446948490915965;
2605 _b=0.091576213509771;
2606 _p1=0.11169079483905;
2607 _p2=0.0549758718227661;
2608 refCoo1=[ 0.,0., 1.,0., 0.,1. ]
2609 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 ];
2610 wg1=[ 4*_p2, 4*_p2, 4*_p2, 4*_p1, 4*_p1, 4*_p1 ]
2611 _refCoo1=refCoo1[0:6];
2612 _gsCoo1=gsCoo1[0:12];
2614 f.setGaussLocalizationOnType(NORM_TRI3,_refCoo1,_gsCoo1,_wg1);
2615 refCoo2=[ 0.,0., 1.,0., 1.,1., 0.,1. ]
2616 _refCoo2=refCoo2[0:8];
2617 _gsCoo1=_gsCoo1[0:4]
2619 f.setGaussLocalizationOnType(NORM_QUAD4,_refCoo2,_gsCoo1,_wg1);
2620 arr=DataArrayDouble.New();
2621 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.]
2622 arr.setValues(values2,18,2);
2626 self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2627 f.renumberCells(renumber1,False);
2628 self.assertTrue(not f.isEqual(fCpy,1e-12,1e-12));
2629 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.]
2630 ptr=f.getArray().getValues();
2631 for i in xrange(36):
2632 self.assertTrue(abs(expected2[i]-ptr[i])<1e-12);
2634 renumber2=[2,1,4,0,3]
2635 f.renumberCells(renumber2,False);
2636 self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2638 f=MEDCouplingFieldDouble.New(ON_GAUSS_NE,NO_TIME);
2640 arr=DataArrayDouble.New();
2641 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.]
2642 arr.setValues(values3,18,2);
2646 self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2647 f.renumberCells(renumber1,False);
2648 self.assertTrue(not f.isEqual(fCpy,1e-12,1e-12));
2649 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.]
2650 ptr=f.getArray().getValues();
2651 for i in xrange(36):
2652 self.assertTrue(abs(expected3[i]-ptr[i])<1e-12);
2654 f.renumberCells(renumber2,False);#perform reverse operation of renumbering to check that the resulting field is equal.
2655 self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2659 def testRenumberNodesForFields(self):
2660 m=MEDCouplingDataForTest.build2DTargetMesh_1();
2661 f=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
2663 self.assertEqual(9,f.getNumberOfMeshPlacesExpected());
2664 arr=DataArrayDouble.New();
2665 nbOfNodes=m.getNumberOfNodes();
2666 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.]
2667 arr.setValues(values1,nbOfNodes,3);
2670 renumber1=[0,4,1,3,5,2,6,7,8]
2671 loc=[0.5432,-0.2432, 0.5478,0.1528]
2672 expected1=[9.0272, 109.0272, 10009.0272, 11.4124,111.4124,10011.4124]
2674 res=f.getValueOn(loc[2*j:2*j+2]);
2676 self.assertTrue(abs(expected1[i+3*j]-res[i])<1e-12);
2680 self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2681 f.renumberNodes(renumber1);
2682 self.assertTrue(not f.isEqual(fCpy,1e-12,1e-12));
2684 res=f.getValueOn(loc[2*j:2*j+2]);
2686 self.assertTrue(abs(expected1[i+3*j]-res[i])<1e-12);
2689 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.]
2690 for i in xrange(27):
2691 self.assertTrue(abs(expected2[i]-f.getArray().getValues()[i])<1e-12);
2693 renumber2=[0,2,5,3,1,4,6,7,8]
2694 f.renumberNodes(renumber2);
2695 self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2698 def testConvertQuadraticCellsToLinear(self):
2699 mesh=MEDCouplingDataForTest.build2DTargetMesh_3();
2700 mesh.checkCoherency();
2701 types=mesh.getAllGeoTypes();
2703 self.assertEqual(5,len(types));
2704 expected1=[NORM_POLYGON, NORM_TRI3, NORM_QUAD4, NORM_TRI6, NORM_QUAD8]
2706 self.assertEqual(expected1,types);
2707 self.assertTrue(mesh.isPresenceOfQuadratic());
2708 self.assertEqual(62,mesh.getMeshLength());
2709 f1=mesh.getMeasureField(False);
2711 mesh.convertQuadraticCellsToLinear();
2712 self.assertTrue(not mesh.isPresenceOfQuadratic());
2714 mesh.checkCoherency();
2715 f2=mesh.getMeasureField(False);
2716 self.assertTrue(f1.getArray().isEqual(f2.getArray(),1e-12));
2717 self.assertEqual(48,mesh.getMeshLength());
2718 types2=mesh.getAllGeoTypes();
2720 self.assertEqual(3,len(types2));
2721 expected2=[NORM_POLYGON, NORM_TRI3, NORM_QUAD4]
2723 self.assertEqual(expected2,types2);
2726 def testCheckGeoEquivalWith(self):
2727 mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2728 mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2730 cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh1,0,1e-12);#deepEqual
2731 self.assertTrue(cellCor==None);
2732 self.assertTrue(nodeCor==None);
2733 cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh1,1,1e-12);#fastEqual
2734 self.assertTrue(cellCor==None);
2735 self.assertTrue(nodeCor==None);
2736 cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh1,10,1e-12);#deepEqual with geo permutations
2737 self.assertTrue(cellCor==None);
2738 self.assertTrue(nodeCor==None);
2739 #Second test mesh1 and mesh2 are 2 different meshes instance
2740 cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,0,1e-12);#deepEqual
2741 self.assertTrue(cellCor==None);
2742 self.assertTrue(nodeCor==None);
2743 cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,1,1e-12);#fastEqual
2744 self.assertTrue(cellCor==None);
2745 self.assertTrue(nodeCor==None);
2746 cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);#deepEqual with geo permutations
2747 self.assertTrue(cellCor==None);
2748 self.assertTrue(nodeCor==None);
2749 #Third test : cell permutation by keeping the first the middle and the last as it is.
2750 renum=[0,2,1,3,4,5,6,8,7,9]
2751 mesh2.renumberCells(renum,False);
2752 self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12);#deepEqual fails
2753 self.assertTrue(cellCor==None);
2754 self.assertTrue(nodeCor==None);
2755 cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,1,1e-12);#fastEqual do not see anything
2756 self.assertTrue(cellCor==None);
2757 self.assertTrue(nodeCor==None);
2758 cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);#deepEqual with geo permutations
2759 self.assertTrue(cellCor);
2760 self.assertEqual(10,cellCor.getNumberOfTuples());
2761 self.assertEqual(1,cellCor.getNumberOfComponents());
2762 self.assertEqual(renum,list(cellCor.getValues()))
2763 self.assertTrue(nodeCor==None);
2765 self.assertTrue(nodeCor==None);
2766 a,b=mesh1.checkDeepEquivalWith(mesh2,0,1e-12);
2767 self.assertEqual(renum,list(a.getValues()))
2768 self.assertTrue(b==None);
2769 mesh2.setCoords(mesh1.getCoords())
2770 a=mesh1.checkDeepEquivalOnSameNodesWith(mesh2,0,1e-12);
2771 self.assertEqual(renum,list(a.getValues()))
2772 #4th test : cell and node permutation by keeping the first the middle and the last as it is.
2773 mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2774 renum2=[0,2,1,3,4,5,6,8,7,9,10]
2775 mesh2.renumberCells(renum,False);
2776 mesh2.renumberNodes(renum2,11);
2779 self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12);#deepEqual fails
2780 self.assertTrue(cellCor==None);
2781 self.assertTrue(nodeCor==None);
2782 cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,1,1e-12);#fastEqual do not see anything
2783 self.assertTrue(cellCor==None);
2784 self.assertTrue(nodeCor==None);
2785 cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);#deepEqual with geo permutations
2786 self.assertTrue(cellCor);
2787 self.assertEqual(10,cellCor.getNumberOfTuples());
2788 self.assertEqual(1,cellCor.getNumberOfComponents());
2789 self.assertEqual(renum,list(cellCor.getValues()))
2790 self.assertTrue(nodeCor);
2791 self.assertEqual(11,nodeCor.getNumberOfTuples());
2792 self.assertEqual(1,nodeCor.getNumberOfComponents());
2793 self.assertEqual(renum2,list(nodeCor.getValues()))
2796 #5th test : modification of the last cell to check fastCheck detection.
2797 mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2798 renum3=[0,2,1,3,4,5,6,8,9,7]
2799 mesh2.renumberCells(renum3,False);
2800 mesh2.renumberNodes(renum2,11);
2803 self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12)
2804 self.assertTrue(cellCor==None);
2805 self.assertTrue(nodeCor==None);
2806 self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,1,1e-12)
2807 self.assertTrue(cellCor==None);
2808 self.assertTrue(nodeCor==None);
2809 cellCor,nodeCor=mesh2.checkGeoEquivalWith(mesh1,10,1e-12);#deepEqual with geo permutations
2810 self.assertTrue(cellCor!=None);
2811 self.assertEqual(10,cellCor.getNumberOfTuples());
2812 self.assertEqual(1,cellCor.getNumberOfComponents());
2813 self.assertEqual(renum3,list(cellCor.getValues()))
2814 self.assertTrue(nodeCor!=None);
2815 self.assertEqual(11,nodeCor.getNumberOfTuples());
2816 self.assertEqual(1,nodeCor.getNumberOfComponents());
2817 self.assertEqual(renum2,list(nodeCor.getValues()));
2820 def testCheckGeoEquivalWith2(self):
2821 mesh1=MEDCouplingDataForTest.build2DTargetMesh_4();
2822 mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
2823 cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);
2824 self.assertEqual(None,cellCor);
2825 self.assertNotEqual(None,nodeCor);
2826 expected1=[0, 1, 3, 4, 5, 6, 7, 8, 9]
2828 self.assertEqual(expected1[i],nodeCor.getIJ(i,0));
2832 def testSwig2CheckDeepEquivalWith1(self):
2834 mcart = MEDCouplingCMesh()
2835 mcart.setCoordsAt(0, DataArrayDouble([0.0,1.5,2.0]))
2836 mcart.setCoordsAt(1, DataArrayDouble([1.0,2.5,3.0,4.0]))
2837 m = mcart.buildUnstructured()
2838 m2 = m[1:m.getNumberOfCells()]
2839 self.assertRaises(InterpKernelException, m.checkDeepEquivalWith, m2, 0, eps)
2840 self.assertRaises(InterpKernelException, m.checkDeepEquivalWith, m2, 1, eps)
2841 self.assertRaises(InterpKernelException, m.checkDeepEquivalWith, m2, 2, eps)
2844 def testSwig2CheckDeepEquivalWith2(self):
2846 m = MEDCouplingUMesh("tst", 2)
2847 m.setCoords(DataArrayDouble([], 0,2))
2848 m.setConnectivity(DataArrayInt([]), DataArrayInt([0]))
2850 m.checkDeepEquivalWith(m2, 0, eps) # Should not raise!
2853 def testCopyTinyStringsFromOnFields(self):
2854 m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2855 nbOfCells=m.getNumberOfCells();
2856 f=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
2858 self.assertEqual(5,f.getNumberOfMeshPlacesExpected());
2860 f.setDescription("b");
2861 a1=DataArrayDouble.New();
2862 a1.alloc(nbOfCells,2);
2864 a1.setInfoOnComponent(0,"c");
2865 a1.setInfoOnComponent(1,"d");
2867 a2.setInfoOnComponent(0,"e");
2868 a2.setInfoOnComponent(1,"f");
2871 f.setEndTime(3.,3,4);
2873 m.getCoords().setInfoOnComponent(0,"h");
2874 m.getCoords().setInfoOnComponent(1,"i");
2875 m.getCoords().setInfoOnComponent(2,"j");
2879 self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2881 self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2882 f2.copyTinyStringsFrom(f);
2883 self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2884 f2.setDescription("GGG");
2885 self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2886 f2.copyTinyStringsFrom(f);
2887 self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2888 f2.getArray().setInfoOnComponent(0,"mmmm");
2889 self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2890 f2.copyTinyStringsFrom(f);
2891 self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2892 f2.getEndArray().setInfoOnComponent(1,"mmmm");
2893 self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2894 f2.copyTinyStringsFrom(f);
2895 self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2897 self.assertTrue(m2.isEqual(m,1e-12));
2899 self.assertTrue(not m2.isEqual(m,1e-12));
2900 m2.copyTinyStringsFrom(m);
2901 self.assertTrue(m2.isEqual(m,1e-12));
2902 m2.getCoords().setInfoOnComponent(1,"eee");
2903 self.assertTrue(not m2.isEqual(m,1e-12));
2904 m2.copyTinyStringsFrom(m);
2905 self.assertTrue(m2.isEqual(m,1e-12));
2908 def testTryToShareSameCoordsPermute(self):
2909 m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2910 m2=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2911 #self.assertTrue(m.getCoords()!=m2.getCoords());
2912 m.tryToShareSameCoordsPermute(m2,1e-12);
2913 #self.assertTrue(m.getCoords()==m2.getCoords());
2914 self.assertTrue(m2.isEqual(m,1e-12));
2915 renum1=[1,2,0,5,8,7,4,3,6]
2916 r1=DataArrayInt.New()
2917 r1.setValues(renum1,len(renum1),1)
2918 m.renumberNodes(r1,9);
2919 #self.assertTrue(m.getCoords()!=m2.getCoords());
2920 self.assertTrue(not m2.isEqual(m,1e-12));
2921 m.tryToShareSameCoordsPermute(m2,1e-12);
2922 #self.assertTrue(m.getCoords()==m2.getCoords());
2923 self.assertTrue(m2.isEqual(m,1e-12));
2926 def testTryToShareSameCoordsPermute2(self):
2927 m1=MEDCouplingDataForTest.build2DTargetMesh_4();
2928 targetCoords=[-0.3,-0.3, 0.2,-0.3, -0.3,0.2, 0.2,0.2 ]
2929 targetConn=[0,2,3,1]
2930 m2=MEDCouplingUMesh.New();
2931 m2.setMeshDimension(2);
2932 m2.allocateCells(1);
2933 m2.insertNextCell(NORM_QUAD4,targetConn[0:4])
2934 m2.finishInsertingCells();
2935 myCoords=DataArrayDouble.New();
2936 myCoords.setValues(targetCoords,4,2);
2937 m2.setCoords(myCoords);
2938 m2.checkCoherency();
2939 m1.checkCoherency();
2941 expected1=[0.25,0.125,0.125,0.25,0.25]
2942 f1=m1.getMeasureField(False);
2943 f2=m2.getMeasureField(False);
2944 self.assertEqual(5,f1.getArray().getNumberOfTuples());
2945 self.assertEqual(1,f2.getArray().getNumberOfTuples());
2947 self.assertAlmostEqual(expected1[i],f1.getIJ(i,0),12);
2949 self.assertAlmostEqual(expected1[0],f2.getIJ(0,0),12);
2950 self.assertRaises(InterpKernelException,m1.tryToShareSameCoordsPermute,m2,1e-12);# <- here in this order the sharing is impossible.
2951 # Let's go for deeper test of tryToShareSameCoordsPermute
2952 m2.tryToShareSameCoordsPermute(m1,1e-12);
2953 f1=m1.getMeasureField(False);
2954 f2=m2.getMeasureField(False);
2955 self.assertEqual(5,f1.getArray().getNumberOfTuples());
2956 self.assertEqual(1,f2.getArray().getNumberOfTuples());
2958 self.assertAlmostEqual(expected1[i],f1.getIJ(i,0),12);
2960 self.assertAlmostEqual(expected1[0],f2.getIJ(0,0),12);
2963 def testChangeUnderlyingMesh1(self):
2964 mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2965 mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2966 f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2968 array=DataArrayDouble.New();
2969 arr=[7., 107., 8., 108., 9., 109., 10., 110., 11., 111., 12., 112., 13., 113., 14., 114., 15., 115., 16., 116.]
2970 array.setValues(arr,mesh1.getNumberOfCells(),2);
2973 renum=[0,2,1,3,4,5,6,8,7,9]
2974 mesh2.renumberCells(renum,False);
2975 #self.assertTrue(f1.getMesh()==mesh1);
2976 f1.changeUnderlyingMesh(mesh1,10,1e-12);# nothing done only to check that nothing done.
2977 #self.assertTrue(f1.getMesh()==mesh1);
2978 f1.changeUnderlyingMesh(mesh2,10,1e-12);
2979 #self.assertTrue(f1.getMesh()==mesh2);
2980 expected1=[7.,107.,9.,109.,8.,108.,10.,110.,11.,111.,12.,112.,13.,113.,15.,115.,14.,114.,16.,116.]
2981 for i in xrange(20):
2982 self.assertAlmostEqual(expected1[i],f1.getArray().getIJ(0,i),12);
2985 f1=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
2987 array=DataArrayDouble.New();
2988 arr2=[7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.,17.,117.]
2989 array.setValues(arr2,mesh1.getNumberOfNodes(),2);
2992 renum2=[0,2,10,3,4,5,6,8,7,9,1]
2993 mesh2.renumberNodes(renum2,11);
2994 #self.assertTrue(f1.getMesh()==mesh1);
2995 f1.changeUnderlyingMesh(mesh2,10,1e-12);
2996 #self.assertTrue(f1.getMesh()==mesh2);
2997 expected2=[7.,107.,17.,117.,8.,108.,10.,110.,11.,111.,12.,112.,13.,113.,15.,115.,14.,114.,16.,116.,9.,109.]
2998 for i in xrange(22):
2999 self.assertAlmostEqual(expected2[i],f1.getArray().getIJ(0,i),12);
3003 def testGetMaxValue1(self):
3004 m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
3005 nbOfCells=m.getNumberOfCells();
3006 f=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
3008 a1=DataArrayDouble.New();
3009 val1=[3.,4.,5.,6.,7.]
3010 a1.setValues(val1,nbOfCells,1);
3011 a2=DataArrayDouble.New();
3012 val2=[0.,1.,2.,8.,7.]
3013 a2.setValues(val2,nbOfCells,1);
3016 f.setEndTime(3.,3,4);
3019 self.assertAlmostEqual(8.,f.getMaxValue(),14);
3020 self.assertAlmostEqual(0.,f.getMinValue(),14);
3021 self.assertAlmostEqual(5.,f.getAverageValue(),14);
3022 self.assertAlmostEqual(5.125,f.getWeightedAverageValue(0,True),14);
3024 self.assertAlmostEqual(9.5,f.getMaxValue(),14);
3025 self.assertAlmostEqual(0.,f.getMinValue(),14);
3027 self.assertAlmostEqual(9.5,f.getMaxValue(),14);
3028 self.assertAlmostEqual(1.,f.getMinValue(),14);
3031 def testSubstractInPlaceDM1(self):
3032 mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
3033 mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
3034 f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3036 array=DataArrayDouble.New();
3037 arr=[7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.]
3038 array.setValues(arr,mesh1.getNumberOfCells(),2);
3041 self.assertEqual(10,f1.getNumberOfTuples());
3042 self.assertEqual(2,f1.getNumberOfComponents());
3043 self.assertEqual(20,f1.getNumberOfValues());
3045 renum=[0,2,3,1,4,5,6,8,7,9]
3046 mesh2.renumberCells(renum,False);
3048 f2=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3050 array=DataArrayDouble.New();
3051 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]
3052 array.setValues(arr2,mesh2.getNumberOfCells(),2);
3055 f1.substractInPlaceDM(f2,10,1e-12);
3056 f1.applyFunc(1,"abs(x+y+0.2)");
3057 self.assertAlmostEqual(0.,f1.getMaxValue(),13);
3060 def testDotCrossProduct1(self):
3061 mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
3062 f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3063 f1.setTime(2.3,5,6);
3065 array=DataArrayDouble.New();
3066 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.]
3067 array.setValues(arr1,mesh1.getNumberOfCells(),3);
3069 f2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3070 f2.setTime(7.8,4,5);
3072 array=DataArrayDouble.New();
3073 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.]
3074 array.setValues(arr2,mesh1.getNumberOfCells(),3);
3078 expected1=[842.,1820.,2816.,3830.,4862.,5912.,6980.,8066.,9170.,10292.]
3079 for i in xrange(10):
3080 self.assertAlmostEqual(expected1[i],f3.getIJ(i,0),9);
3083 f4=f1.crossProduct(f2);
3084 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.]
3085 for i in xrange(30):
3086 self.assertAlmostEqual(expected2[i],f4.getIJ(0,i),9);
3092 if __name__ == '__main__':