Salome HOME
Merge from V6_main 19/03/2013
[modules/med.git] / src / MEDCoupling_Swig / MEDCouplingBasicsTest.py
1 #  -*- coding: iso-8859-1 -*-
2 # Copyright (C) 2007-2012  CEA/DEN, EDF R&D
3 #
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.
8 #
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.
13 #
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
17 #
18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
19 #
20
21 from MEDCoupling import *
22 import unittest
23 from math import pi,e,sqrt,cos,sin
24 from MEDCouplingDataForTest import MEDCouplingDataForTest
25
26 class MEDCouplingBasicsTest(unittest.TestCase):
27     def testArray2(self):
28         arr=DataArrayDouble.New()
29         arr.setValues([12.,11.,10.,9.,8.,7.,6.,5.,4.,3.,2.,1.],3,4)
30         arr.setInfoOnComponent(0,"ggg");
31         arr.setInfoOnComponent(1,"hhhh");
32         arr.setInfoOnComponent(2,"jj");
33         arr.setInfoOnComponent(3,"kkkkkk");
34         arr2=arr.convertToIntArr();
35         arr3=arr2.convertToDblArr();
36         self.assertTrue(arr.isEqual(arr3,1e-14))
37         pass
38
39     def testArray3(self):
40         arr1=DataArrayInt.New();
41         arr1Ref=[0,10,1,11,2,12,3,13,4,14,5,15,6,16]
42         arr1.setValues(arr1Ref,7,2);
43         self.assertEqual(7,arr1.getNumberOfTuples());
44         self.assertEqual(2,arr1.getNumberOfComponents());
45         self.assertEqual(arr1Ref,list(arr1.getValues()));
46         arr2=arr1.substr(3);
47         self.assertEqual(4,arr2.getNumberOfTuples());
48         self.assertEqual(2,arr2.getNumberOfComponents());
49         self.assertEqual(arr1Ref[6:],list(arr2.getValues()));
50         arr3=arr1.substr(2,5);
51         self.assertEqual(3,arr3.getNumberOfTuples());
52         self.assertEqual(2,arr3.getNumberOfComponents());
53         self.assertEqual(arr1Ref[4:10],list(arr3.getValues()));
54         #
55         arr4=DataArrayDouble.New();
56         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]
57         arr4.setValues(arr4Ref,7,2);
58         self.assertEqual(7,arr4.getNumberOfTuples());
59         self.assertEqual(2,arr4.getNumberOfComponents());
60         tmp=arr4.getValues()
61         for i in xrange(14):
62             self.assertTrue(abs(arr4Ref[i]-tmp[i])<1e-14);
63             pass
64         arr5=arr4.substr(3);
65         self.assertEqual(4,arr5.getNumberOfTuples());
66         self.assertEqual(2,arr5.getNumberOfComponents());
67         tmp=arr5.getValues()
68         for i in xrange(8):
69             self.assertTrue(abs(arr4Ref[6+i]-tmp[i])<1e-14);
70             pass
71         arr6=arr4.substr(2,5);
72         self.assertEqual(3,arr6.getNumberOfTuples());
73         self.assertEqual(2,arr6.getNumberOfComponents());
74         tmp=arr6.getValues()
75         for i in xrange(6):
76             self.assertTrue(abs(arr4Ref[4+i]-tmp[i])<1e-14);
77             pass
78         pass
79
80     def testMesh(self):
81         tab4=[1, 2, 8, 7, 2, 3, 9, 8, 3,
82               4, 10, 9, 4, 5, 11, 10, 5,
83               0, 6, 11, 0, 1, 7, 6 ]
84         nbOfNodes=12
85         nbOfCells=6
86         coords=[ 0.024155, 0.04183768725682622, -0.305, 0.04831000000000001, -1.015761910347357e-17,
87                  -0.305, 0.09662000000000001, -1.832979297858306e-18, -0.305, 0.120775, 0.04183768725682623,
88                  -0.305, 0.09662000000000001, 0.08367537451365245, -0.305, 0.04831000000000001, 0.08367537451365246,
89                  -0.305, 0.024155, 0.04183768725682622, -0.2863, 0.04831000000000001, -1.015761910347357e-17, -0.2863, 
90                  0.09662000000000001, -1.832979297858306e-18, -0.2863, 0.120775, 0.04183768725682623, -0.2863, 0.09662000000000001,
91                  0.08367537451365245, -0.2863, 0.04831000000000001, 0.08367537451365246, -0.2863 ]
92         mesh=MEDCouplingUMesh.New()
93         mesh.setMeshDimension(2)
94         mesh.allocateCells(8);
95         mesh.setName("mesh1")
96         self.assertTrue(mesh.getName()=="mesh1")
97         for i in range(nbOfCells):
98             mesh.insertNextCell(NORM_QUAD4,4,tab4[4*i:4*(i+1)]);
99             pass
100         mesh.finishInsertingCells()
101         self.assertTrue(mesh.getNumberOfCells()==nbOfCells)
102         self.assertTrue(mesh.getNodalConnectivity().getNbOfElems()==30)
103         self.assertTrue(mesh.getNodalConnectivityIndex().getNbOfElems()==nbOfCells+1)
104         myCoords=DataArrayDouble.New()
105         myCoords.setValues(coords,nbOfNodes,3);
106         self.assertTrue(myCoords.getIJ(3,2)==-0.305)
107         mesh.setCoords(myCoords);
108         mesh.checkCoherency();
109         self.assertTrue(mesh.getAllTypes()==[4])
110         myFalseConn=DataArrayInt.New()
111         myFalseConn.setValues(tab4,6,4)
112         self.assertTrue(myFalseConn.getIJ(1,1)==3)
113         #
114         field=MEDCouplingFieldDouble.New(ON_CELLS)
115         field.setMesh(mesh)
116         field.setNature(Integral)
117         myCoords=DataArrayDouble.New()
118         sampleTab=[]
119         for i in range(nbOfCells*9):
120             sampleTab.append(float(i))
121         myCoords.setValues(sampleTab,nbOfCells,9);
122         field.setArray(myCoords)
123         self.assertTrue(3==mesh.getSpaceDimension())
124         field.checkCoherency()
125         mesh2=mesh.clone(False)
126         mesh3=mesh.clone(True)
127         mesh3=0
128         mesh2=0
129         ## deep full recursively copy of field -> both field and mesh underneath copied
130         field2=field.clone(True)
131         field2.setMesh(field.getMesh().clone(True))
132         mesh3=mesh.clone(True)
133         field3=mesh3.fillFromAnalytic(ON_CELLS,2,"x*IVec+(y+z)*JVec")
134         field3.applyFunc("u*u*u+cos(u)")
135         pass
136         
137     def testMeshPointsCloud(self):
138         targetCoords=[-0.3,-0.3,0.5, 0.2,-0.3,1., 0.7,-0.3,1.5,
139                       -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]
140         targetMesh=MEDCouplingUMesh.New();
141         targetMesh.setMeshDimension(0);
142         targetMesh.allocateCells(8);
143         targetMesh.insertNextCell(NORM_POINT1,1,[0]);
144         targetMesh.insertNextCell(NORM_POINT1,1,[1]);
145         targetMesh.insertNextCell(NORM_POINT1,1,[2]);
146         targetMesh.insertNextCell(NORM_POINT1,1,[3]);
147         targetMesh.insertNextCell(NORM_POINT1,1,[4]);
148         targetMesh.insertNextCell(NORM_POINT1,1,[5]);
149         targetMesh.insertNextCell(NORM_POINT1,1,[7]);
150         targetMesh.insertNextCell(NORM_POINT1,1,[6]);
151         targetMesh.finishInsertingCells();
152         self.assertRaises(InterpKernelException,targetMesh.checkCoherency);
153         myCoords=DataArrayDouble.New();
154         myCoords.setValues(targetCoords,9,3);
155         targetMesh.setCoords(myCoords);
156         self.assertEqual(targetMesh.getSpaceDimension(),3)
157         self.assertEqual(targetMesh.getNumberOfCells(),8)
158         self.assertEqual(targetMesh.getNumberOfNodes(),9)
159         self.assertEqual(targetMesh.getMeshDimension(),0)
160         pass
161
162     def testMeshM1D(self):
163         meshM1D=MEDCouplingUMesh.New();
164         self.assertRaises(InterpKernelException,meshM1D.getMeshDimension);
165         self.assertRaises(InterpKernelException,meshM1D.getNumberOfNodes);
166         self.assertRaises(InterpKernelException,meshM1D.getNumberOfCells);
167         self.assertRaises(InterpKernelException,meshM1D.setMeshDimension,-2)
168         self.assertRaises(InterpKernelException,meshM1D.setMeshDimension,-10)
169         meshM1D.setMeshDimension(-1);
170         meshM1D.checkCoherency();
171         self.assertEqual(meshM1D.getMeshDimension(),-1);
172         self.assertEqual(meshM1D.getNumberOfCells(),1);
173         self.assertRaises(InterpKernelException,meshM1D.getNumberOfNodes);
174         self.assertRaises(InterpKernelException,meshM1D.getSpaceDimension);
175         cpy=meshM1D.clone(True);
176         self.assertTrue(cpy.isEqual(meshM1D,1e-12));
177         fieldOnCells=MEDCouplingFieldDouble.New(ON_CELLS);
178         fieldOnCells.setMesh(meshM1D);
179         array=DataArrayDouble.New();
180         array.setValues(6*[7.],1,6);
181         fieldOnCells.setArray(array);
182         fieldOnCells.checkCoherency();
183         pass
184     
185     def testDeepCopy(self):
186         array=DataArrayDouble.New();
187         array.setValues(5*3*[7.],5,3);
188         self.assertEqual(array.getIJ(3,2),7.);
189         array2=array.deepCpy();
190         self.assertEqual(array2.getIJ(3,2),7.)
191         #
192         array3=DataArrayInt.New();
193         array3.setValues(5*3*[17],5,3);
194         self.assertEqual(array3.getIJ(3,2),17);
195         array4=array3.deepCpy();
196         self.assertEqual(array4.getIJ(3,2),17);
197         pass
198     
199     def testRevNodal(self):
200         mesh=MEDCouplingDataForTest.build2DTargetMesh_1()
201         revNodal,revNodalIndx=mesh.getReverseNodalConnectivity();
202         revNodalExpected=[0,0,1,1,2,0,3,0,1,2,3,4,2,4,3,3,4,4];
203         revNodalIndexExpected=[0,1,3,5,7,12,14,15,17,18];
204         self.assertEqual(revNodal.getNbOfElems(),18)
205         self.assertEqual(revNodalIndx.getNbOfElems(),10)
206         self.assertEqual(list(revNodal.getValues()),revNodalExpected)
207         self.assertEqual(list(revNodalIndx.getValues()),revNodalIndexExpected)
208         pass
209     
210     def testConvertToPolyTypes(self):
211         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
212         elts=[1,3];
213         mesh.convertToPolyTypes(elts);
214         mesh.checkCoherency();
215         self.assertEqual(5,mesh.getNumberOfCells());
216         self.assertEqual(23,mesh.getNodalConnectivity().getNumberOfTuples());
217         expected1=[4, 0, 3, 4, 1, 5, 1, 4, 2, 3, 4, 5, 2, 5, 6, 7, 4, 3, 4, 7, 8, 5, 4]
218         self.assertEqual(expected1,list(mesh.getNodalConnectivity().getValues()));
219         #
220         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
221         mesh.convertToPolyTypes(elts);
222         mesh.checkCoherency();
223         self.assertEqual(8,mesh.getNumberOfCells());
224         self.assertEqual(114,mesh.getNodalConnectivity().getNumberOfTuples());
225         mesh.convertToPolyTypes(elts);
226         mesh.checkCoherency();
227         self.assertEqual(8,mesh.getNumberOfCells());
228         self.assertEqual(114,mesh.getNodalConnectivity().getNumberOfTuples());
229         pass
230
231     def testDescConn2D(self):
232         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
233         desc=DataArrayInt.New();
234         descIndx=DataArrayInt.New();
235         revDesc=DataArrayInt.New();
236         revDescIndx=DataArrayInt.New();
237         mesh2=mesh.buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
238         mesh2.checkCoherency();
239         self.assertEqual(1,mesh2.getMeshDimension());
240         self.assertEqual(13,mesh2.getNumberOfCells());
241         self.assertEqual(14,revDescIndx.getNbOfElems()); self.assertEqual(14,revDescIndx.getNumberOfTuples());
242         self.assertEqual(6,descIndx.getNbOfElems()); self.assertEqual(6,descIndx.getNumberOfTuples());
243         self.assertEqual(18,desc.getNbOfElems()); self.assertEqual(18,desc.getNumberOfTuples());
244         self.assertEqual(18,revDesc.getNbOfElems()); self.assertEqual(18,revDesc.getNumberOfTuples());
245         expected1=[0,1,2,3, 2,4,5, 6,7,4, 8,9,1,10, 11,12,6,9];
246         self.assertEqual(expected1,list(desc.getValues()));
247         expected2=[0,4,7,10,14,18];
248         self.assertEqual(expected2,list(descIndx.getValues()));
249         expected3=[0,1,3,5,6,8,9,11,12,13,15,16,17,18];
250         self.assertEqual(expected3,list(revDescIndx.getValues()));
251         expected4=[0, 0,3, 0,1, 0, 1,2, 1, 2,4, 2, 3, 3,4, 3, 4, 4];
252         self.assertEqual(expected4,list(revDesc.getValues()));
253         conn=mesh2.getNodalConnectivity();
254         connIndex=mesh2.getNodalConnectivityIndex();
255         expected5=[0,3,6,9,12,15,18,21,24,27,30,33,36,39];
256         self.assertEqual(expected5,list(connIndex.getValues()));
257         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];
258         self.assertEqual(expected6,list(conn.getValues()));
259         #
260         eltsV=[1,3];
261         mesh.convertToPolyTypes(eltsV);
262         mesh.checkCoherency();
263         #
264         desc=DataArrayInt.New();
265         descIndx=DataArrayInt.New();
266         revDesc=DataArrayInt.New();
267         revDescIndx=DataArrayInt.New();
268         #
269         mesh2=mesh.buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
270         mesh2.checkCoherency();
271         self.assertEqual(1,mesh2.getMeshDimension());
272         self.assertEqual(13,mesh2.getNumberOfCells());
273         self.assertEqual(14,revDescIndx.getNbOfElems()); self.assertEqual(14,revDescIndx.getNumberOfTuples());
274         self.assertEqual(6,descIndx.getNbOfElems()); self.assertEqual(6,descIndx.getNumberOfTuples());
275         self.assertEqual(18,desc.getNbOfElems()); self.assertEqual(18,desc.getNumberOfTuples());
276         self.assertEqual(18,revDesc.getNbOfElems()); self.assertEqual(18,revDesc.getNumberOfTuples());
277         self.assertEqual(expected1,list(desc.getValues()));
278         self.assertEqual(expected2,list(descIndx.getValues()));
279         self.assertEqual(expected3,list(revDescIndx.getValues()));
280         self.assertEqual(expected4,list(revDesc.getValues()));
281         conn=mesh2.getNodalConnectivity();
282         connIndex=mesh2.getNodalConnectivityIndex();
283         self.assertEqual(expected5,list(connIndex.getValues()));
284         self.assertEqual(expected6,list(conn.getValues()));
285         pass
286     
287     def testDescConn3D(self):
288         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
289         desc=DataArrayInt.New();
290         descIndx=DataArrayInt.New();
291         revDesc=DataArrayInt.New();
292         revDescIndx=DataArrayInt.New();
293         #
294         mesh2=mesh.buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
295         mesh2.checkCoherency();
296         self.assertEqual(2,mesh2.getMeshDimension());
297         self.assertEqual(36,mesh2.getNumberOfCells());
298         self.assertEqual(37,revDescIndx.getNbOfElems()); self.assertEqual(37,revDescIndx.getNumberOfTuples());
299         self.assertEqual(9,descIndx.getNbOfElems()); self.assertEqual(9,descIndx.getNumberOfTuples());
300         self.assertEqual(48,desc.getNbOfElems()); self.assertEqual(48,desc.getNumberOfTuples());
301         self.assertEqual(48,revDesc.getNbOfElems()); self.assertEqual(48,revDesc.getNumberOfTuples());
302         expected1=[0, 6, 12, 18, 24, 30, 36, 42, 48]
303         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]
304         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]
305         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]
306         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]
307         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,
308                    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,
309                    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,
310                    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]
311         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,
312                    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,
313                    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,
314                    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]
315         
316         self.assertEqual(expected1,list(descIndx.getValues()));
317         self.assertEqual(expected2,list(desc.getValues()));
318         self.assertEqual(expected3,list(revDescIndx.getValues()));
319         self.assertEqual(expected4,list(revDesc.getValues()));
320         self.assertEqual(expected5,list(mesh2.getNodalConnectivityIndex().getValues()));
321         self.assertEqual(expected6,list(mesh2.getNodalConnectivity().getValues()));
322         #
323         eltsV=[1,3]
324         mesh.convertToPolyTypes(eltsV);
325         mesh.checkCoherency();
326         desc=DataArrayInt.New();
327         descIndx=DataArrayInt.New();
328         revDesc=DataArrayInt.New();
329         revDescIndx=DataArrayInt.New();
330         mesh2=mesh.buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
331         mesh2.checkCoherency();
332         self.assertEqual(2,mesh2.getMeshDimension());
333         self.assertEqual(36,mesh2.getNumberOfCells());
334         self.assertEqual(37,revDescIndx.getNbOfElems()); self.assertEqual(37,revDescIndx.getNumberOfTuples());
335         self.assertEqual(9,descIndx.getNbOfElems()); self.assertEqual(9,descIndx.getNumberOfTuples());
336         self.assertEqual(48,desc.getNbOfElems()); self.assertEqual(48,desc.getNumberOfTuples());
337         self.assertEqual(48,revDesc.getNbOfElems()); self.assertEqual(48,revDesc.getNumberOfTuples());
338         self.assertEqual(expected1,list(descIndx.getValues()));
339         self.assertEqual(expected2,list(desc.getValues()));
340         self.assertEqual(expected3,list(revDescIndx.getValues()));
341         self.assertEqual(expected4,list(revDesc.getValues()));
342         self.assertEqual(expected5,list(mesh2.getNodalConnectivityIndex().getValues()));
343         self.assertEqual(expected7,list(mesh2.getNodalConnectivity().getValues()));
344         pass
345
346     def testFindBoundaryNodes(self):
347         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
348         boundaryNodes=mesh.findBoundaryNodes();
349         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];
350         self.assertEqual(expected1,boundaryNodes.getValues());
351         pass
352
353     def testBoundaryMesh(self):
354         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
355         mesh2=mesh.buildBoundaryMesh(False);
356         self.assertEqual(24,mesh2.getNumberOfCells());
357         self.assertEqual(26,mesh2.getNumberOfNodes());
358         pass
359
360     def testBuildPartOfMySelf(self):
361         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
362         mesh.setName("Toto");
363         tab1=[0,4]
364         tab2=[0,2,3]
365         #
366         subMesh=mesh.buildPart(tab1)
367         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
368         subMesh=mesh.buildPartOfMySelf(tab1,True);
369         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
370         name=subMesh.getName();
371         self.assertEqual(2,len(mesh.getAllTypes()));
372         self.assertEqual(NORM_TRI3,mesh.getAllTypes()[0]);
373         self.assertEqual(NORM_QUAD4,mesh.getAllTypes()[1]);
374         self.assertEqual(1,len(subMesh.getAllTypes()));
375         self.assertEqual(NORM_QUAD4,subMesh.getAllTypes()[0]);
376         self.assertEqual(name,"Toto");
377         self.assertEqual(2,subMesh.getNumberOfCells());
378         subConn=[4,0,3,4,1,4,7,8,5,4];
379         subConnIndex=[0,5,10];
380         self.assertEqual(10,subMesh.getNodalConnectivity().getNbOfElems());
381         self.assertEqual(3,subMesh.getNodalConnectivityIndex().getNbOfElems());
382         self.assertEqual(subConn[0:10],list(subMesh.getNodalConnectivity().getValues()));
383         self.assertEqual(subConnIndex[0:3],list(subMesh.getNodalConnectivityIndex().getValues()));
384         #
385         subMesh=mesh.buildPartOfMySelf(tab2[0:3],True);
386         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh));
387         name=subMesh.getName();
388         self.assertEqual(2,len(subMesh.getAllTypes()));
389         self.assertEqual(NORM_TRI3,subMesh.getAllTypes()[0]);
390         self.assertEqual(NORM_QUAD4,subMesh.getAllTypes()[1]);
391         self.assertEqual(name,"Toto");
392         self.assertEqual(3,subMesh.getNumberOfCells());
393         subConn2=[4,0,3,4,1,3,4,5,2,4,6,7,4,3]
394         subConnIndex2=[0,5,9,14]
395         self.assertEqual(14,subMesh.getNodalConnectivity().getNbOfElems());
396         self.assertEqual(4,subMesh.getNodalConnectivityIndex().getNbOfElems());
397         self.assertEqual(subConn2[0:14],list(subMesh.getNodalConnectivity().getValues()));
398         self.assertEqual(subConnIndex2[0:4],list(subMesh.getNodalConnectivityIndex().getValues()));
399         dd=DataArrayInt.New()
400         dd.alloc(3,1)
401         dd.iota(0)
402         dd.setName("coucou")
403         subMesh=subMesh.buildPartOfMySelf(dd,True);
404         self.assertEqual("coucou",subMesh.getName());
405         pass
406     
407     def testBuildPartOfMySelfNode(self):
408         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
409         tab1=[5,7,8,4]
410         subMesh=mesh.buildPartOfMySelfNode(tab1[0:4],True);
411         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
412         self.assertEqual(1,len(subMesh.getAllTypes()));
413         self.assertEqual(NORM_QUAD4,subMesh.getAllTypes()[0]);
414         self.assertEqual(1,subMesh.getNumberOfCells());
415         self.assertEqual(5,subMesh.getNodalConnectivity().getNbOfElems());
416         self.assertEqual(2,subMesh.getNodalConnectivityIndex().getNbOfElems());
417         subConn=[4,7,8,5,4]
418         subConnIndex=[0,5]
419         self.assertEqual(subConn[0:5],list(subMesh.getNodalConnectivity().getValues()));
420         self.assertEqual(subConnIndex[0:2],list(subMesh.getNodalConnectivityIndex().getValues()));
421         #
422         ddd=DataArrayInt.New()
423         ddd.setValues(tab1[0:2],2,1)
424         ddd.setName("ddd")
425         subMesh=mesh.buildPartOfMySelfNode(ddd,False);
426         self.assertEqual("ddd",subMesh.getName())
427         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
428         self.assertEqual(2,len(subMesh.getAllTypes()));
429         self.assertEqual(NORM_TRI3,subMesh.getAllTypes()[0]);
430         self.assertEqual(NORM_QUAD4,subMesh.getAllTypes()[1]);
431         self.assertEqual(3,subMesh.getNumberOfCells());
432         self.assertEqual(14,subMesh.getNodalConnectivity().getNbOfElems());
433         self.assertEqual(4,subMesh.getNodalConnectivityIndex().getNbOfElems());
434         subConn2=[3,4,5,2,4,6,7,4,3,4,7,8,5,4]
435         subConnIndex2=[0,4,9,14]
436         self.assertEqual(subConn2[0:14],list(subMesh.getNodalConnectivity().getValues()));
437         self.assertEqual(subConnIndex2[0:4],list(subMesh.getNodalConnectivityIndex().getValues()));
438         #testing the case where length of tab2 is greater than max number of node per cell.
439         tab2=[0,3,2,1,4,5,6]
440         subMesh=mesh.buildPartOfMySelfNode(tab2[0:7],True);
441         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
442         self.assertEqual(2,len(subMesh.getAllTypes()));
443         self.assertEqual(NORM_TRI3,subMesh.getAllTypes()[0]);
444         self.assertEqual(NORM_QUAD4,subMesh.getAllTypes()[1]);
445         self.assertEqual(3,subMesh.getNumberOfCells());
446         pass
447     
448     def testZipCoords(self):
449         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
450         self.assertEqual(2,len(mesh.getAllTypes()));
451         self.assertEqual(2,mesh.getSpaceDimension());
452         self.assertEqual(9,mesh.getNumberOfNodes());
453         self.assertEqual(5,mesh.getNumberOfCells());
454         oldConn=mesh.getNodalConnectivity().getValues()[0:mesh.getNodalConnectivity().getNbOfElems()];
455         oldConnIndex=mesh.getNodalConnectivityIndex().getValues()[0:mesh.getNumberOfCells()+1]
456         oldCoords=mesh.getCoords();
457         mesh.zipCoords();
458         self.assertEqual(2,len(mesh.getAllTypes()));
459         self.assertEqual(2,mesh.getSpaceDimension());
460         self.assertEqual(9,mesh.getNumberOfNodes());
461         self.assertEqual(5,mesh.getNumberOfCells());
462         self.assertEqual(mesh.getCoords().getValues()[0:2*9],oldCoords.getValues());
463         self.assertEqual(list(oldConn),list(mesh.getNodalConnectivity().getValues()));
464         self.assertEqual(list(oldConnIndex),list(mesh.getNodalConnectivityIndex().getValues()));
465         #
466         tab1=[0,4]
467         subMesh=mesh.buildPartOfMySelf(tab1,True);
468         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
469         traducer=subMesh.zipCoordsTraducer();
470         expectedTraducer=[0, 1, -1, 2, 3, 4, -1, 5, 6]
471         self.assertEqual(expectedTraducer,list(traducer.getValues()));
472         self.assertEqual(NORM_QUAD4,subMesh.getAllTypes()[0]);
473         self.assertEqual(2,subMesh.getNumberOfCells());
474         subConn=[4,0,2,3,1,4,5,6,4,3]
475         subConnIndex=[0,5,10]
476         self.assertEqual(7,subMesh.getNumberOfNodes());
477         self.assertEqual(10,subMesh.getNodalConnectivity().getNbOfElems());
478         self.assertEqual(3,subMesh.getNodalConnectivityIndex().getNbOfElems());
479         self.assertEqual(subConn,list(subMesh.getNodalConnectivity().getValues()));
480         self.assertEqual(subConnIndex,list(subMesh.getNodalConnectivityIndex().getValues()));
481         #
482         subMesh=mesh.buildPartOfMySelf(tab1,False);
483         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
484         self.assertEqual(NORM_QUAD4,subMesh.getAllTypes()[0]);
485         self.assertEqual(2,subMesh.getNumberOfCells());
486         self.assertEqual(7,subMesh.getNumberOfNodes());
487         self.assertEqual(10,subMesh.getNodalConnectivity().getNbOfElems());
488         self.assertEqual(3,subMesh.getNodalConnectivityIndex().getNbOfElems());
489         self.assertEqual(subConn,list(subMesh.getNodalConnectivity().getValues()));
490         self.assertEqual(subConnIndex,list(subMesh.getNodalConnectivityIndex().getValues()));
491         pass
492     
493     def testZipConnectivity(self):
494         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
495         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
496         cells1=[2,3,4]
497         m3=m2.buildPartOfMySelf(cells1,True);
498         self.assertTrue(isinstance(m3,MEDCouplingUMesh))
499         m4=MEDCouplingDataForTest.build2DSourceMesh_1();
500         m5=MEDCouplingUMesh.MergeUMeshes(m1,m3);
501         m6=MEDCouplingUMesh.MergeUMeshes(m5,m4);
502         #
503         self.assertEqual(10,m6.getNumberOfCells());
504         self.assertEqual(22,m6.getNumberOfNodes());
505         (arr,areNodesMerged,newNbOfNodes)=m6.mergeNodes(1e-13);
506         self.assertTrue(areNodesMerged);
507         self.assertEqual(10,m6.getNumberOfCells());
508         self.assertEqual(9,m6.getNumberOfNodes());
509         #
510         arr=m6.zipConnectivityTraducer(0);
511         self.assertEqual(7,m6.getNumberOfCells());
512         m7=m6.clone(True);
513         arr=m6.zipConnectivityTraducer(0);
514         self.assertTrue(m7.isEqual(m6,1e-12));
515         self.assertEqual(7,m6.getNumberOfCells());
516         pass
517     
518     def testEqualMesh(self):
519         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
520         mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
521         #
522         self.assertTrue(mesh1.isEqual(mesh1,1e-12));
523         #
524         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
525         self.assertTrue(mesh2.isEqual(mesh1,1e-12));
526         pt=mesh2.getCoords().getValues();
527         tmp=pt[1]
528         mesh2.getCoords().setIJ(0,1,5.999);
529         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
530         self.assertTrue(not mesh2.isEqual(mesh1,1e-12));
531         mesh2.getCoords().setIJ(0,1,tmp);
532         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
533         self.assertTrue(mesh2.isEqual(mesh1,1e-12));
534         #
535         pt2=mesh1.getNodalConnectivity().getValues();
536         mesh1.getNodalConnectivity().setIJ(5,0,int(pt2[5])+1);
537         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
538         self.assertTrue(not mesh2.isEqual(mesh1,1e-12));
539         mesh1.getNodalConnectivity().setIJ(5,0,int(pt2[5]));
540         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
541         self.assertTrue(mesh2.isEqual(mesh1,1e-12));
542         #
543         pt2=mesh1.getNodalConnectivityIndex().getValues();
544         mesh1.getNodalConnectivityIndex().setIJ(1,0,int(pt2[1]+1));
545         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
546         self.assertTrue(not mesh2.isEqual(mesh1,1e-12));
547         mesh1.getNodalConnectivityIndex().setIJ(1,0,int(pt2[1]));
548         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
549         self.assertTrue(mesh2.isEqual(mesh1,1e-12));
550         #
551         tmp3=mesh1.getName();
552         mesh1.setName("lllll");
553         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
554         self.assertTrue(not mesh2.isEqual(mesh1,1e-12));
555         mesh1.setName(tmp3);
556         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
557         self.assertTrue(mesh2.isEqual(mesh1,1e-12));
558         #
559         tmp3=mesh2.getCoords().getInfoOnComponent(1);
560         mesh2.getCoords().setInfoOnComponent(1,"kkkkkk");
561         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
562         self.assertTrue(not mesh2.isEqual(mesh1,1e-12));
563         mesh2.getCoords().setInfoOnComponent(1,tmp3);
564         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
565         self.assertTrue(mesh2.isEqual(mesh1,1e-12));
566         pass
567     
568     def testEqualFieldDouble(self):
569         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
570         mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
571         #
572         fieldOnCells1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
573         fieldOnCells1.setMesh(mesh1);
574         fieldOnCells2=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
575         fieldOnCells2.setMesh(mesh2);
576         #
577         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
578         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
579         #
580         fieldOnNodes1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
581         self.assertTrue(not fieldOnCells1.isEqual(fieldOnNodes1,1e-12,1e-15));
582         self.assertTrue(not fieldOnNodes1.isEqual(fieldOnCells1,1e-12,1e-15));
583         #
584         fieldOnCells2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
585         self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
586         self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
587         fieldOnCells1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
588         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
589         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
590         fieldOnCells1.setTime(4.,6,7);
591         self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
592         self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
593         fieldOnCells2.setTime(4.,6,7);
594         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
595         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
596         fieldOnCells1.setName("Power");
597         self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
598         self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
599         fieldOnCells2.setName("Power");
600         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
601         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
602         #
603         fieldOnCells1.setMesh(mesh1);
604         self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
605         self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
606         fieldOnCells2.setMesh(mesh1);
607         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
608         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
609         arr=DataArrayDouble.New();
610         arr.setName("popo");
611         arr.setValues(mesh1.getNumberOfCells()*3*[6.],mesh1.getNumberOfCells(),3);
612         fieldOnCells1.setArray(arr);
613         self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
614         self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
615         fieldOnCells2.setArray(arr);
616         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
617         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
618         #
619         arr2=arr.deepCpy();
620         fieldOnCells2.setArray(arr2);
621         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
622         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
623         arr.setIJ(1,2,6.1);
624         self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
625         self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
626         arr.setIJ(1,2,6.);
627         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
628         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
629         arr2.setName("popo2");
630         self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
631         self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
632         #
633         arr2.setName("popo");
634         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
635         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
636         #
637         arr2.setInfoOnComponent(2,"jjj");
638         self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
639         self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
640         arr.setInfoOnComponent(2,"jjj");
641         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
642         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
643         pass
644
645     def testNatureChecking(self):
646         field=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
647         field.setNature(Integral);
648         field.setNature(ConservativeVolumic);
649         field.setNature(IntegralGlobConstraint);
650         field=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
651         field.setNature(ConservativeVolumic);
652         self.assertRaises(InterpKernelException,field.setNature,Integral);
653         self.assertRaises(InterpKernelException,field.setNature,IntegralGlobConstraint);
654         pass
655
656     def testBuildSubMeshData(self):
657         targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1()
658         #check buildSubMesh on field on cells
659         fieldCells=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
660         fieldCells.setMesh(targetMesh);
661         elts=[1,2,4]
662         ret1,di=fieldCells.buildSubMeshData(elts);
663         self.assertTrue(isinstance(ret1,MEDCouplingUMesh))
664         self.assertEqual(3,ret1.getNumberOfCells());
665         self.assertEqual(9,ret1.getNumberOfNodes());
666         self.assertEqual(3,di.getNumberOfTuples());
667         self.assertEqual(1,di.getNumberOfComponents());
668         toCheck=di.getValues();
669         self.assertTrue(elts,toCheck);
670         #check buildSubMesh on field on nodes
671         fieldNodes=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
672         fieldNodes.setMesh(targetMesh);
673         ret2,di=fieldNodes.buildSubMeshData(elts);
674         self.assertTrue(isinstance(ret2,MEDCouplingUMesh))
675         self.assertEqual(3,ret2.getNumberOfCells());
676         self.assertEqual(6,ret2.getNumberOfNodes());
677         self.assertEqual(6,di.getNumberOfTuples());
678         self.assertEqual(1,di.getNumberOfComponents());
679         toCheck=di.getValues();
680         expected=[1,2,4,5,7,8]
681         self.assertEqual(expected,list(toCheck));
682         pass
683     
684     def testExtrudedMesh1(self):
685         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
686         ext=MEDCouplingExtrudedMesh.New(mesh3D,mesh2D,1);
687         self.assertEqual(18,ext.getNumberOfCells());
688         self.assertEqual(60,ext.getNumberOfNodes());
689         ids3D=ext.getMesh3DIds();
690         ids3DExpected=[5,4,3,2,1,0, 11,10,9,8,7,6, 17,16,15,14,13,12]
691         self.assertEqual(18,ids3D.getNumberOfTuples());
692         self.assertEqual(1,ids3D.getNumberOfComponents());
693         self.assertEqual(ids3DExpected,list(ids3D.getValues()));
694         mesh1D=ext.getMesh1D();
695         self.assertEqual(4,mesh1D.getNumberOfNodes());
696         self.assertEqual(3,mesh1D.getNumberOfCells());
697         mesh1DExpected=[0.66666666666666663, 1.4583333333333333, 0, 0.66666666666666663,
698                         1.4583333333333333, 1, 0.66666666666666663, 1.4583333333333333,
699                         2, 0.66666666666666663, 1.4583333333333333, 3]
700         mesh1DCoords=mesh1D.getCoords();
701         self.assertEqual(4,mesh1DCoords.getNumberOfTuples());
702         self.assertEqual(3,mesh1DCoords.getNumberOfComponents());
703         self.assertEqual(mesh1DExpected,mesh1DCoords.getValues());
704         conn1D=mesh1D.getNodalConnectivity();
705         self.assertEqual(9,conn1D.getNumberOfTuples());
706         self.assertEqual(1,conn1D.getNumberOfComponents());
707         conn1DExpected=[1,0,1,1,1,2,1,2,3]
708         self.assertEqual(conn1DExpected,list(conn1D.getValues()));
709         pass
710
711     def testExtrudedMesh3(self):
712         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
713         m1.changeSpaceDimension(3);
714         m2=MEDCouplingDataForTest.buildCU1DMesh_U();
715         m2.changeSpaceDimension(3);
716         center=[0.,0.,0.]
717         vector=[0.,1.,0.]
718         m2.rotate(center,vector,-pi/2.);
719         m3=m1.buildExtrudedMesh(m2,0);
720         #
721         m4=MEDCouplingExtrudedMesh.New(m3,m1,0);
722         self.assertEqual(15,m4.getNumberOfCells());
723         self.assertEqual(5,m4.getMesh2D().getNumberOfCells());
724         self.assertEqual(3,m4.getMesh1D().getNumberOfCells());
725         m3DIds=m4.getMesh3DIds().getValues();
726         self.assertEqual(range(15),list(m3DIds));
727         #some random in cells to check that extrusion alg find it correctly
728         expected1=[1,3,2,0,6,5,7,10,11,8,12,9,14,13,4]
729         m3.renumberCells(expected1,False);
730         m4=MEDCouplingExtrudedMesh.New(m3,m1,0);
731         self.assertEqual(15,m4.getNumberOfCells());
732         self.assertEqual(5,m4.getMesh2D().getNumberOfCells());
733         self.assertEqual(3,m4.getMesh1D().getNumberOfCells());
734         m3DIds=m4.getMesh3DIds().getValues();
735         self.assertEqual(expected1,list(m3DIds));
736         #play with polygons and polyedrons
737         cells=[2,3]
738         m1.convertToPolyTypes(cells);
739         m3=m1.buildExtrudedMesh(m2,0);
740         self.assertEqual(NORM_HEXA8,m3.getTypeOfCell(0));
741         self.assertEqual(NORM_PENTA6,m3.getTypeOfCell(1));
742         self.assertEqual(NORM_POLYHED,m3.getTypeOfCell(2));
743         self.assertEqual(NORM_POLYHED,m3.getTypeOfCell(3));
744         self.assertEqual(NORM_HEXA8,m3.getTypeOfCell(4));
745         m3.renumberCells(expected1,False);
746         m4=MEDCouplingExtrudedMesh.New(m3,m1,0);
747         self.assertEqual(15,m4.getNumberOfCells());
748         self.assertEqual(5,m4.getMesh2D().getNumberOfCells());
749         self.assertEqual(3,m4.getMesh1D().getNumberOfCells());
750         m3DIds=m4.getMesh3DIds().getValues();
751         self.assertEqual(expected1,list(m3DIds));
752         pass
753
754     def testExtrudedMesh4(self):
755         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
756         cells=[2,4];
757         m1.convertToPolyTypes(cells);
758         m1.changeSpaceDimension(3);
759         m2=MEDCouplingDataForTest.buildCU1DMesh_U();
760         m2.changeSpaceDimension(3);
761         center=[0.,0.,0.]
762         vector=[0.,1.,0.]
763         m2.rotate(center,vector,-pi/2.);
764         m3=m1.buildExtrudedMesh(m2,0);
765         expected1=[1,3,2,0,6,5,7,10,11,8,12,9,14,13,4]
766         rexpected1=[3, 0, 2, 1, 14, 5, 4, 6, 9, 11, 7, 8, 10, 13, 12]
767         m3.renumberCells(expected1,False);
768         m4=MEDCouplingExtrudedMesh.New(m3,m1,0);
769         self.assertEqual(NORM_HEXA8,m4.getTypeOfCell(0));
770         self.assertEqual(NORM_HEXA8,m4.getTypeOfCell(1));
771         self.assertEqual(NORM_POLYHED,m4.getTypeOfCell(2));
772         self.assertEqual(NORM_PENTA6,m4.getTypeOfCell(7));
773         f=m4.getMeasureField(True);
774         arr=f.getArray();
775         self.assertEqual(15,arr.getNumberOfTuples());
776         self.assertEqual(1,arr.getNumberOfComponents());
777         arrPtr=arr.getValues();
778         expected2=[0.075,0.0375,0.0375,0.075,0.075,
779                    0.1125,0.05625,0.05625,0.1125,0.1125,
780                    0.0625,0.03125,0.03125,0.0625,0.0625]
781         for i in xrange(15):
782             self.assertAlmostEqual(expected2[rexpected1[i]],arrPtr[i],16);
783             pass
784         m5=m4.build3DUnstructuredMesh();
785         self.assertTrue(m5.isEqual(m3,1e-12));
786         f=m5.getMeasureField(True);
787         f.setMesh(m4)
788         self.assertTrue(isinstance(f.getMesh(),MEDCouplingExtrudedMesh))
789         arr=f.getArray();
790         arrPtr=arr.getValues();
791         for i in xrange(15):
792             self.assertAlmostEqual(expected2[rexpected1[i]],arrPtr[i],15);
793             pass
794         pass
795
796     def testFindCommonNodes(self):
797         targetMesh=MEDCouplingDataForTest.build3DTargetMesh_1();
798         comm,commI=targetMesh.findCommonNodes(1e-10,-1);
799         self.assertEqual(1,commI.getNumberOfTuples());
800         self.assertEqual(0,comm.getNumberOfTuples());
801         o2n,newNbOfNodes=targetMesh.buildNewNumberingFromCommonNodesFormat(comm,commI);
802         self.assertEqual(27,newNbOfNodes);
803         self.assertEqual(27,o2n.getNumberOfTuples());
804         o2nExp1=range(27)
805         self.assertEqual(o2nExp1,list(o2n.getValues()));
806         #
807         targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
808         self.assertEqual(31,targetMesh.getNumberOfNodes());
809         comm,commI=targetMesh.findCommonNodes(1e-10);# testing default parameter
810         self.assertEqual(3,commI.getNumberOfTuples());
811         self.assertEqual(6,comm.getNumberOfTuples());
812         commExpected=[1,27,28,29,23,30]
813         commIExpected=[0,4,6]
814         self.assertEqual(commExpected,list(comm.getValues()));
815         self.assertEqual(commIExpected,list(commI.getValues()));
816         o2n,newNbOfNodes=targetMesh.buildNewNumberingFromCommonNodesFormat(comm,commI);
817         self.assertEqual(31,o2n.getNumberOfTuples());
818         self.assertEqual(27,newNbOfNodes);
819         o2nExp2=[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,
820                  21,22,23,24,25,26,1,1,1,23]
821         self.assertEqual(o2nExp2,list(o2n.getValues()));
822         #
823         targetMesh=MEDCouplingDataForTest.build3DTargetMesh_1();
824         time=targetMesh.getTimeOfThis();
825         o2n,areNodesMerged,newNbOfNodes=targetMesh.mergeNodes(1e-10);
826         targetMesh.updateTime();
827         self.assertEqual(time,targetMesh.getTimeOfThis());
828         self.assertTrue(not areNodesMerged);
829         #
830         targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
831         time=targetMesh.getTimeOfThis();
832         o2n,areNodesMerged,newNbOfNodes=targetMesh.mergeNodes(1e-10);
833         targetMesh.updateTime();
834         self.assertTrue(time!=targetMesh.getTimeOfThis());
835         self.assertTrue(areNodesMerged);
836         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,
837                  18,4,5,8,7,13,14,17,16,
838                  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,
839                  18,13,14,17,16,22,23,26,25]
840         self.assertEqual(72,targetMesh.getNodalConnectivity().getNumberOfTuples());
841         self.assertEqual(connExp,list(targetMesh.getNodalConnectivity().getValues()));
842         self.assertEqual(27,targetMesh.getCoords().getNumberOfTuples());
843         coordsExp=[ 0., 0., 0., 50., 0., 0. , 200., 0., 0.  , 0., 50., 0., 50., 50., 0. ,
844                     200., 50., 0.,   0., 200., 0., 50., 200., 0. , 200., 200., 0. ,
845                     0., 0., 50., 50., 0., 50. , 200., 0., 50.  , 0., 50., 50., 50.,
846                     50., 50. , 200., 50., 50.,   0., 200., 50., 50., 200., 50. ,
847                     200., 200., 50. , 0., 0., 200., 50., 0., 200. , 200., 0., 200.  
848                     , 0., 50., 200., 50., 50., 200. , 200., 50., 200., 
849                     0., 200., 200., 50., 200., 200. , 200., 200., 200. ]
850         self.assertEqual(coordsExp,targetMesh.getCoords().getValues());
851         # 2D
852         targetMesh=MEDCouplingDataForTest.build2DTargetMeshMergeNode_1();
853         self.assertEqual(18,targetMesh.getNumberOfNodes());
854         time=targetMesh.getTimeOfThis();
855         o2n,areNodesMerged,newNbOfNodes=targetMesh.mergeNodes(1e-10);
856         self.assertTrue(time!=targetMesh.getTimeOfThis());
857         self.assertTrue(areNodesMerged);
858         self.assertEqual(9,targetMesh.getNumberOfNodes());
859         connExp2=[4,0,4,3,1, 3,1,3,2, 3,3,5,2, 4,4,6,7,3, 4,7,8,5,3]
860         self.assertEqual(23,targetMesh.getNodalConnectivity().getNumberOfTuples());
861         self.assertEqual(connExp2,list(targetMesh.getNodalConnectivity().getValues()));
862         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]
863         self.assertEqual(9,targetMesh.getCoords().getNumberOfTuples());
864         self.assertEqual(coordsExp2,targetMesh.getCoords().getValues());
865         pass
866
867     def testCheckButterflyCells(self):
868         sourceMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
869         cells=sourceMesh.checkButterflyCells();
870         self.assertEqual(0,len(cells));
871         conn=sourceMesh.getNodalConnectivity()
872         tmp=conn.getIJ(15,0)
873         conn.setIJ(15,0,conn.getIJ(16,0))
874         conn.setIJ(16,0,tmp)
875         cells=sourceMesh.checkButterflyCells();
876         self.assertEqual(1,len(cells));
877         self.assertEqual([3],cells.getValues());
878         tmp=conn.getIJ(15,0)
879         conn.setIJ(15,0,conn.getIJ(16,0))
880         conn.setIJ(16,0,tmp)
881         cells=sourceMesh.checkButterflyCells();
882         self.assertEqual(0,len(cells));
883         # 3D surf
884         sourceMesh=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
885         cells=sourceMesh.checkButterflyCells();
886         self.assertEqual(0,len(cells));
887         conn=sourceMesh.getNodalConnectivity()
888         tmp=conn.getIJ(15,0)
889         conn.setIJ(15,0,conn.getIJ(16,0))
890         conn.setIJ(16,0,tmp)
891         cells=sourceMesh.checkButterflyCells();
892         self.assertEqual(1,len(cells));
893         self.assertEqual([3],cells.getValues());
894         tmp=conn.getIJ(15,0)
895         conn.setIJ(15,0,conn.getIJ(16,0))
896         conn.setIJ(16,0,tmp)
897         cells=sourceMesh.checkButterflyCells();
898         self.assertEqual(0,len(cells));
899         pass
900
901     def testMergeMesh1(self):
902         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
903         m2=MEDCouplingDataForTest.build2DSourceMesh_1();
904         vec=[1.,0.]
905         m2.translate(vec);
906         m3=m1.mergeMyselfWith(m2);
907         self.assertTrue(isinstance(m3,MEDCouplingUMesh));
908         m3.checkCoherency();
909         m4=MEDCouplingDataForTest.build2DTargetMeshMerged_1();
910         self.assertTrue(m3.isEqual(m4,1.e-12));
911         da,isMerged,newNbOfNodes=m3.mergeNodes(1.e-12);
912         self.assertEqual(11,m3.getNumberOfNodes());
913         self.assertTrue(isMerged);
914         pass
915
916     def testMergeMeshOnSameCoords1(self):
917         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
918         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
919         cells=range(5);
920         m2.convertToPolyTypes(cells);
921         m1.tryToShareSameCoords(m2,1e-12);
922         m3=MEDCouplingDataForTest.build2DTargetMesh_1();
923         m3.tryToShareSameCoords(m2,1e-12);
924         meshes=[m1,m2,m3]
925         m4=MEDCouplingUMesh.MergeUMeshesOnSameCoords(meshes);
926         m4.checkCoherency();
927         self.assertEqual(15,m4.getNumberOfCells());
928         cells1=[0,1,2,3,4]
929         m1_1=m4.buildPartOfMySelf(cells1,True);
930         m1_1.setName(m1.getName());
931         self.assertTrue(m1.isEqual(m1_1,1e-12));
932         cells2=[5,6,7,8,9]
933         m2_1=m4.buildPartOfMySelf(cells2,True);
934         m2_1.setName(m2.getName());
935         self.assertTrue(m2.isEqual(m2_1,1e-12));
936         cells3=[10,11,12,13,14]
937         m3_1=m4.buildPartOfMySelf(cells3,True);
938         m3_1.setName(m3.getName());
939         self.assertTrue(m3.isEqual(m3_1,1e-12));
940         pass
941
942     def testMergeField1(self):
943         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
944         m2=MEDCouplingDataForTest.build2DSourceMesh_1();
945         vec=[1.,0.]
946         m2.translate(vec);
947         f1=m1.getMeasureField(True);
948         f2=m2.getMeasureField(True);
949         f3=MEDCouplingFieldDouble.MergeFields(f1,f2);
950         f3.checkCoherency();
951         m4=MEDCouplingDataForTest.build2DTargetMeshMerged_1();
952         self.assertTrue(f3.getMesh().isEqual(m4,1.e-12));
953         name=f3.getName();
954         self.assertEqual(name,"MeasureOfMesh_");
955         self.assertEqual(f3.getTypeOfField(),ON_CELLS);
956         self.assertEqual(f3.getTimeDiscretization(),ONE_TIME);
957         self.assertEqual(1,f3.getNumberOfComponents());
958         self.assertEqual(7,f3.getNumberOfTuples());
959         values=[0.25,0.125,0.125,0.25,0.25,0.5,0.5]
960         tmp=f3.getArray().getValues();
961         self.assertEqual(len(values),len(tmp))
962         for i in xrange(7):
963             self.assertTrue(abs(values[i]-tmp[i])<1e-12)
964             pass
965         pass
966
967     def testFillFromAnalytic(self):
968         m=MEDCouplingDataForTest.build2DTargetMesh_1();
969         m.setTime(3.4,5,6); m.setTimeUnit("us");
970         f1=m.fillFromAnalytic(ON_CELLS,1,"x+y");
971         self.assertAlmostEqual(3.4,f1.getTime()[0],12) ; self.assertEqual(5,f1.getTime()[1]) ; self.assertEqual(6,f1.getTime()[2])
972         self.assertEqual("us",f1.getTimeUnit())
973         f1.checkCoherency();                    
974         self.assertEqual(f1.getTypeOfField(),ON_CELLS);
975         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
976         self.assertEqual(1,f1.getNumberOfComponents());
977         self.assertEqual(5,f1.getNumberOfTuples());
978         values1=[-0.1,0.23333333333333336,0.56666666666666665,0.4,0.9]
979         tmp=f1.getArray().getValues();
980         self.assertEqual(len(values1),len(tmp))
981         for i in xrange(len(tmp)):
982             self.assertTrue(abs(tmp[i]-values1[i])<1.e-12)
983             pass
984         #
985         f1=m.fillFromAnalytic(ON_NODES,1,"x+y");
986         f1.checkCoherency();
987         self.assertEqual(f1.getTypeOfField(),ON_NODES);
988         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
989         self.assertEqual(1,f1.getNumberOfComponents());
990         self.assertEqual(9,f1.getNumberOfTuples());
991         values2=[-0.6,-0.1,0.4,-0.1,0.4,0.9,0.4,0.9,1.4]
992         tmp=f1.getArray().getValues();
993         self.assertEqual(len(values2),len(tmp))
994         for i in xrange(len(tmp)):
995             self.assertTrue(abs(tmp[i]-values2[i])<1.e-12)
996             pass
997         #
998         f1=m.fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+(2*(x+y))*JVec");
999         f1.checkCoherency();
1000         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1001         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1002         self.assertEqual(2,f1.getNumberOfComponents());
1003         self.assertEqual(9,f1.getNumberOfTuples());
1004         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]
1005         tmp=f1.getArray().getValues();
1006         self.assertEqual(len(values3),len(tmp))
1007         for i in xrange(len(tmp)):
1008             self.assertTrue(abs(tmp[i]-values3[i])<1.e-12)
1009             pass
1010         values4=f1.accumulate();
1011         self.assertEqual(2,len(values4))
1012         self.assertTrue(abs(3.6-values4[0])<1.e-12);
1013         self.assertTrue(abs(7.2-values4[1])<1.e-12);
1014         values4=f1.integral(True);
1015         self.assertEqual(2,len(values4))
1016         self.assertTrue(abs(0.5-values4[0])<1.e-12);
1017         self.assertTrue(abs(1.-values4[1])<1.e-12);
1018         #
1019         self.assertRaises(InterpKernelException,m.fillFromAnalytic,ON_NODES,1,"1./(x-0.2)");
1020         pass
1021
1022     def testFillFromAnalytic2(self):
1023         m=MEDCouplingDataForTest.build2DTargetMesh_1();
1024         f1=m.fillFromAnalytic(ON_CELLS,1,"y+x");
1025         f1.checkCoherency();
1026         self.assertEqual(f1.getTypeOfField(),ON_CELLS);
1027         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1028         self.assertEqual(1,f1.getNumberOfComponents());
1029         self.assertEqual(5,f1.getNumberOfTuples());
1030         values1=[-0.1,0.23333333333333336,0.56666666666666665,0.4,0.9]
1031         tmp=f1.getArray().getValues();
1032         self.assertEqual(len(values1),len(tmp))
1033         for i in xrange(len(values1)):
1034             self.assertTrue(abs(values1[i]-tmp[i])<1.e-12);
1035             pass
1036         #
1037         f1=m.fillFromAnalytic(ON_NODES,1,"y+2*x");
1038         f1.checkCoherency();
1039         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1040         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1041         self.assertEqual(1,f1.getNumberOfComponents());
1042         self.assertEqual(9,f1.getNumberOfTuples());
1043         values2=[-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1]
1044         tmp=f1.getArray().getValues();
1045         self.assertEqual(len(values2),len(tmp))
1046         for i in xrange(len(values2)):
1047             self.assertTrue(abs(values2[i]-tmp[i])<1.e-12);
1048             pass
1049         f1=m.fillFromAnalytic(ON_NODES,1,"2.*x+y");
1050         f1.checkCoherency();
1051         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1052         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1053         self.assertEqual(1,f1.getNumberOfComponents());
1054         self.assertEqual(9,f1.getNumberOfTuples());
1055         tmp=f1.getArray().getValues();
1056         values2Bis=[-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1]
1057         self.assertEqual(len(values2Bis),len(tmp))
1058         for i in xrange(len(values2Bis)):
1059             self.assertTrue(abs(values2Bis[i]-tmp[i])<1.e-12);
1060             pass
1061         #
1062         f1=m.fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+2*(x+y)*JVec");
1063         f1.checkCoherency();
1064         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1065         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1066         self.assertEqual(2,f1.getNumberOfComponents());
1067         self.assertEqual(9,f1.getNumberOfTuples());
1068         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]
1069         tmp=f1.getArray().getValues();
1070         self.assertEqual(len(values3),len(tmp))
1071         for i in xrange(len(values3)):
1072             self.assertTrue(abs(values3[i]-tmp[i])<1.e-12);
1073             pass
1074         values4=f1.accumulate();
1075         self.assertTrue(abs(3.6-values4[0])<1.e-12);
1076         self.assertTrue(abs(7.2-values4[1])<1.e-12);
1077         values4=f1.integral(True);
1078         self.assertTrue(abs(0.5-values4[0])<1.e-12);
1079         self.assertTrue(abs(1.-values4[1])<1.e-12);
1080         pass
1081
1082     def testApplyFunc(self):
1083         m=MEDCouplingDataForTest.build2DTargetMesh_1();
1084         f1=m.fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+(2*(x+y))*JVec");
1085         f1.checkCoherency();
1086         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1087         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1088         self.assertEqual(2,f1.getNumberOfComponents());
1089         self.assertEqual(9,f1.getNumberOfTuples());
1090         f1.applyFunc(1,"x+y");
1091         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1092         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1093         self.assertEqual(1,f1.getNumberOfComponents());
1094         self.assertEqual(9,f1.getNumberOfTuples());
1095         values1=[-1.8,-0.3,1.2,-0.3,1.2,2.7,1.2,2.7,4.2]
1096         tmp=f1.getArray().getValues();
1097         self.assertEqual(len(values1),len(tmp))
1098         for i in xrange(len(tmp)):
1099             self.assertTrue(abs(tmp[i]-values1[i])<1.e-12)
1100             pass
1101         pass
1102
1103     def testApplyFunc2(self):
1104         m=MEDCouplingDataForTest.build2DTargetMesh_1();
1105         f1=m.fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+2*(x+y)*JVec");
1106         f1.checkCoherency();
1107         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1108         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1109         self.assertEqual(2,f1.getNumberOfComponents());
1110         self.assertEqual(9,f1.getNumberOfTuples());
1111         #
1112         f2=f1.clone(True);
1113         self.assertRaises(InterpKernelException, f2.applyFunc, 1, "a+b+c+d");
1114         self.assertRaises(InterpKernelException, f2.applyFunc, 1, "a/0");
1115         self.assertRaises(InterpKernelException, f2.applyFunc, "a/0");
1116         f2.applyFunc("abs(u)^2.4+2*u");
1117         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1118         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1119         self.assertEqual(2,f1.getNumberOfComponents());
1120         self.assertEqual(9,f1.getNumberOfTuples());
1121         values2=[-0.9065304805418678, -0.85105859001709905, -0.19601892829446504, -0.37898777756476987,
1122                  0.91090317490482353, 2.1853504664669781, -0.19601892829446504, -0.37898777756476987,
1123                  0.91090317490482353, 2.1853504664669781, 2.5765725275664879, 7.6987743736515295,
1124                  0.91090317490482353, 2.1853504664669781, 2.5765725275664879, 7.6987743736515295,
1125                  5.0423700574830965, 17.435300118916864]
1126         tmp=f2.getArray().getValues();
1127         self.assertEqual(len(tmp),len(values2))
1128         for i in xrange(len(tmp)):
1129             self.assertTrue(abs(tmp[i]-values2[i])<1.e-12)
1130             pass
1131         #
1132         f1.applyFunc(1,"x+y");
1133         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1134         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1135         self.assertEqual(1,f1.getNumberOfComponents());
1136         self.assertEqual(9,f1.getNumberOfTuples());
1137         values1=[-1.8,-0.3,1.2,-0.3,1.2,2.7,1.2,2.7,4.2]
1138         tmp=f1.getArray().getValues();
1139         self.assertEqual(len(tmp),len(values1))
1140         for i in xrange(len(tmp)):
1141             self.assertTrue(abs(tmp[i]-values1[i])<1.e-12)
1142             pass
1143         pass
1144
1145     def testOperationsOnFields(self):
1146         m=MEDCouplingDataForTest.build2DTargetMesh_1();
1147         f1=m.fillFromAnalytic(ON_NODES,1,"x+y");
1148         f2=m.fillFromAnalytic(ON_NODES,1,"x+y");
1149         f1.checkCoherency();
1150         f2.checkCoherency();
1151         f3=f1+f2;
1152         f3.checkCoherency();
1153         self.assertEqual(f3.getTypeOfField(),ON_NODES);
1154         self.assertEqual(f3.getTimeDiscretization(),ONE_TIME);
1155         values1=[-1.2,-0.2,0.8,-0.2,0.8,1.8,0.8,1.8,2.8]
1156         tmp=f3.getArray().getValues();
1157         self.assertEqual(len(values1),len(tmp))
1158         for i in xrange(len(tmp)):
1159             self.assertTrue(abs(tmp[i]-values1[i])<1.e-12)
1160             pass
1161         #
1162         f3=f1*f2;
1163         f3.checkCoherency();
1164         self.assertEqual(f3.getTypeOfField(),ON_NODES);
1165         self.assertEqual(f3.getTimeDiscretization(),ONE_TIME);
1166         values2=[0.36,0.01,0.16,0.01,0.16,0.81,0.16,0.81,1.96]
1167         tmp=f3.getArray().getValues();
1168         self.assertEqual(len(values2),len(tmp))
1169         for i in xrange(len(tmp)):
1170             self.assertTrue(abs(tmp[i]-values2[i])<1.e-12)
1171             pass
1172         #
1173         f3=f1+f2;
1174         f4=f1-f3;
1175         f4.checkCoherency();
1176         self.assertEqual(f4.getTypeOfField(),ON_NODES);
1177         self.assertEqual(f4.getTimeDiscretization(),ONE_TIME);
1178         values3=[0.6,0.1,-0.4,0.1,-0.4,-0.9,-0.4,-0.9,-1.4]
1179         tmp=f4.getArray().getValues();
1180         self.assertEqual(len(values3),len(tmp))
1181         for i in xrange(len(tmp)):
1182             self.assertTrue(abs(tmp[i]-values3[i])<1.e-12)
1183             pass
1184         #
1185         f3=f1+f2;
1186         f4=f3/f2;
1187         f4.checkCoherency();
1188         self.assertEqual(f4.getTypeOfField(),ON_NODES);
1189         self.assertEqual(f4.getTimeDiscretization(),ONE_TIME);
1190         tmp=f4.getArray().getValues();
1191         for i in xrange(len(tmp)):
1192             self.assertTrue(abs(tmp[i]-2.)<1.e-12)
1193             pass
1194         #
1195         f4=f2.buildNewTimeReprFromThis(NO_TIME,False);
1196         f4.checkCoherency();
1197         self.assertEqual(f4.getTypeOfField(),ON_NODES);
1198         self.assertEqual(f4.getTimeDiscretization(),NO_TIME);
1199         self.assertRaises(InterpKernelException,f1.__add__,f4);
1200         f5=f4.buildNewTimeReprFromThis(ONE_TIME,False);
1201         self.assertEqual(f5.getTypeOfField(),ON_NODES);
1202         self.assertEqual(f5.getTimeDiscretization(),ONE_TIME);
1203         f3=f1+f5;
1204         tmp=f3.getArray().getValues();
1205         values4=[-1.2,-0.2,0.8,-0.2,0.8,1.8,0.8,1.8,2.8]
1206         self.assertEqual(len(values3),len(tmp))
1207         for i in xrange(len(tmp)):
1208             self.assertTrue(abs(tmp[i]-values4[i])<1.e-12)
1209             pass
1210         #
1211         f4=f2.buildNewTimeReprFromThis(NO_TIME,True);
1212         f4.checkCoherency();
1213         self.assertEqual(f4.getTypeOfField(),ON_NODES);
1214         self.assertEqual(f4.getTimeDiscretization(),NO_TIME);
1215         self.assertRaises(InterpKernelException,f1.__add__,f4);
1216         f5=f4.buildNewTimeReprFromThis(ONE_TIME,True);
1217         self.assertEqual(f5.getTypeOfField(),ON_NODES);
1218         self.assertEqual(f5.getTimeDiscretization(),ONE_TIME);
1219         f3=f1+f5;
1220         tmp=f3.getArray().getValues();
1221         values5=[-1.2,-0.2,0.8,-0.2,0.8,1.8,0.8,1.8,2.8]
1222         self.assertEqual(len(values5),len(tmp))
1223         for i in xrange(len(tmp)):
1224             self.assertTrue(abs(tmp[i]-values5[i])<1.e-12)
1225             pass
1226         pass
1227
1228     def testOperationsOnFields2(self):
1229         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1230         m.setTime(3.4,5,6); m.setTimeUnit("us");
1231         f1=m.fillFromAnalytic(ON_NODES,1,"x+y+z");
1232         f2=m.fillFromAnalytic(ON_NODES,1,"a*a+b+c*c");
1233         f3=f1/f2;
1234         f3.checkCoherency();
1235         self.assertEqual(f3.getTypeOfField(),ON_NODES);
1236         self.assertEqual(f3.getTimeDiscretization(),ONE_TIME);
1237         expected1=[-2.4999999999999991, 1.2162162162162162, 0.77868852459016391,
1238                    0.7407407407407407, 1.129032258064516, 0.81632653061224492,
1239                    0.86538461538461531, 1.0919540229885056, 0.84302325581395343]
1240         self.assertEqual(1,f3.getNumberOfComponents());
1241         self.assertEqual(9,f3.getNumberOfTuples());
1242         val=f3.getArray().getValues();
1243         for i in xrange(9):
1244             self.assertTrue(abs(expected1[i]-val[i])<1.e-12);
1245         #
1246         f1=m.buildOrthogonalField();
1247         self.assertAlmostEqual(3.4,f1.getTime()[0],12) ; self.assertEqual(5,f1.getTime()[1]) ; self.assertEqual(6,f1.getTime()[2])
1248         self.assertEqual("us",f1.getTimeUnit())
1249         f2=m.fillFromAnalytic(ON_CELLS,1,"x");
1250         f3=f1*f2;
1251         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]
1252         val=f3.getArray().getValues();
1253         for i in xrange(15):
1254             self.assertTrue(abs(expected2[i]-val[i])<1.e-12);
1255             pass
1256         #
1257         f3=f2*f1;
1258         val=f3.getArray().getValues();
1259         for i in xrange(15):
1260             self.assertTrue(abs(expected2[i]-val[i])<1.e-12);
1261             pass
1262         pass
1263
1264     def testOperationsOnFields3(self):
1265         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1266         f1=m.fillFromAnalytic(ON_NODES,1,"x+y+z");
1267         f2=m.fillFromAnalytic(ON_NODES,1,"a*a+b+c*c");
1268         f1/=f2
1269         f1.checkCoherency();
1270         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1271         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1272         expected1=[-2.4999999999999991, 1.2162162162162162, 0.77868852459016391,
1273                    0.7407407407407407, 1.129032258064516, 0.81632653061224492,
1274                    0.86538461538461531, 1.0919540229885056, 0.84302325581395343]
1275         self.assertEqual(1,f1.getNumberOfComponents());
1276         self.assertEqual(9,f1.getNumberOfTuples());
1277         val=f1.getArray().getValues();
1278         for i in xrange(9):
1279             self.assertTrue(abs(expected1[i]-val[i])<1.e-12);
1280             pass
1281         #
1282         f1=m.buildOrthogonalField();
1283         f2=m.fillFromAnalytic(ON_CELLS,1,"x");
1284         f1*=f2
1285         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]
1286         val=f1.getArray().getValues();
1287         for i in xrange(15):
1288             self.assertTrue(abs(expected2[i]-val[i])<1.e-12);
1289             pass
1290         #
1291         f1=m.buildOrthogonalField();
1292         # to avoid valgrind leaks
1293         # self.assertRaises(InterpKernelException,f2.__imul__,f1);
1294         pass
1295
1296     def testOperationsOnFields4(self):
1297         m=MEDCouplingDataForTest.build2DTargetMesh_1();
1298         nbOfCells=m.getNumberOfCells();
1299         f1=MEDCouplingFieldDouble.New(ON_CELLS,CONST_ON_TIME_INTERVAL);
1300         f1.setMesh(m);
1301         array=DataArrayDouble.New();
1302         f1.setArray(array);
1303         self.assertRaises(InterpKernelException,f1.setEndArray,array);
1304         self.assertRaises(InterpKernelException,f1.getEndArray);
1305         arr1=[0.,10.,20.,1.,11.,21.,2.,12.,22.,3.,13.,23.,4.,14.,24.]
1306         arr2=[5.,15.,25.,6.,16.,26.,7.,17.,27.,8.,18.,28.,9.,19.,29.]
1307         array.setValues(arr1,nbOfCells,3);
1308         f1.setStartTime(2.,0,0);
1309         f1.setEndTime(3.,0,0);
1310         f1.checkCoherency();
1311         pos=[0.3,-0.2]
1312         res=f1.getValueOn(pos);
1313         self.assertTrue(abs(arr1[3]-res[0])<1.e-12);
1314         self.assertTrue(abs(arr1[4]-res[1])<1.e-12);
1315         self.assertTrue(abs(arr1[5]-res[2])<1.e-12);
1316         res=None
1317         res=f1.getValueOn(pos,2.2);
1318         self.assertTrue(abs(arr1[3]-res[0])<1.e-12);
1319         self.assertTrue(abs(arr1[4]-res[1])<1.e-12);
1320         self.assertTrue(abs(arr1[5]-res[2])<1.e-12);
1321         res=None
1322         self.assertRaises(InterpKernelException,f1.getValueOn,pos,3.2)
1323         f2=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
1324         f2.setMesh(m);
1325         f2.setArray(f1.getArray());
1326         f2.setStartTime(2.,3,0);
1327         f2.setEndTime(4.,13,0);
1328         self.assertRaises(InterpKernelException,f2.checkCoherency)
1329         array2=DataArrayDouble.New();
1330         array2.setValues(arr2,nbOfCells,3);
1331         f2.setEndArray(array2);
1332         f2.checkCoherency();
1333         #
1334         res=None
1335         res=f2.getValueOn(pos,3.21);
1336         self.assertTrue(abs(4.025-res[0])<1.e-12);
1337         self.assertTrue(abs(14.025-res[1])<1.e-12);
1338         self.assertTrue(abs(24.025-res[2])<1.e-12);
1339         f3=f2.clone(True);
1340         self.assertTrue(f2.isEqual(f3,1e-12,1e-12));
1341         f3.getEndArray().setIJ(0,0,5.001);
1342         self.assertTrue(not f2.isEqual(f3,1e-12,1e-12));
1343         self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1344         f3.setStartTime(2.1,3,0);
1345         self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1346         f3.setStartTime(2.,3,0);
1347         self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1348         f3.setStartTime(2.,4,0);
1349         self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1350         f3.setStartTime(2.,3,1);
1351         self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1352         f3.setStartTime(2.,3,0);
1353         self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1354         f3.setEndTime(4.1,13,0);
1355         self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1356         f3.setEndTime(4.,13,0);
1357         self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1358         f3.setEndTime(4.,14,0);
1359         self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1360         f3.setEndTime(4.,13,1);
1361         self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1362         f3.setEndTime(4.,13,0);
1363         self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1364         f4=f2+f2
1365         res=None
1366         res=f4.getValueOn(pos,3.21);
1367         self.assertTrue(abs(8.05-res[0])<1.e-12);
1368         self.assertTrue(abs(28.05-res[1])<1.e-12);
1369         self.assertTrue(abs(48.05-res[2])<1.e-12);
1370         f4+=f2;
1371         res=None
1372         res=f4.getValueOn(pos,3.21);
1373         self.assertTrue(abs(12.075-res[0])<1.e-12);
1374         self.assertTrue(abs(42.075-res[1])<1.e-12);
1375         self.assertTrue(abs(72.075-res[2])<1.e-12);
1376         pass
1377     
1378     def testMergeNodesOnField(self):
1379         targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
1380         f1=targetMesh.fillFromAnalytic(ON_NODES,1,"x+y+z");
1381         f1.mergeNodes(1e-10);
1382         #
1383         targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
1384         f1=targetMesh.fillFromAnalytic(ON_NODES,1,"x+y+z");
1385         tmp=f1.getArray()
1386         tmp.setIJ(0,0,1000.);
1387         f1.mergeNodes(1e-10);
1388         #
1389         targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
1390         f1=targetMesh.fillFromAnalytic(ON_NODES,1,"x+y+z");
1391         tmp=f1.getArray()
1392         tmp.setIJ(1,0,1000.);
1393         self.assertRaises(InterpKernelException,f1.mergeNodes,1.e-10)
1394         pass
1395
1396     def testCheckConsecutiveCellTypes(self):
1397         sourceMesh=MEDCouplingDataForTest.build2DSourceMesh_1();
1398         targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1399         self.assertTrue(sourceMesh.checkConsecutiveCellTypes());
1400         order1=[NORM_TRI3,NORM_QUAD4]
1401         order2=[NORM_QUAD4,NORM_TRI3]
1402         self.assertTrue(not targetMesh.checkConsecutiveCellTypes());
1403         self.assertTrue(not targetMesh.checkConsecutiveCellTypesAndOrder(order1));
1404         self.assertTrue(not targetMesh.checkConsecutiveCellTypesAndOrder(order2));
1405         da=targetMesh.getRenumArrForConsecutiveCellTypesSpec(order1);
1406         self.assertEqual(5,da.getNumberOfTuples());
1407         self.assertEqual(1,da.getNumberOfComponents());
1408         expected1=[2,0,1,3,4]
1409         self.assertTrue(expected1==list(da.getValues()));
1410         da=targetMesh.getRenumArrForConsecutiveCellTypesSpec(order2);
1411         self.assertEqual(5,da.getNumberOfTuples());
1412         self.assertEqual(1,da.getNumberOfComponents());
1413         expected2=[0,3,4,1,2]
1414         self.assertTrue(expected2==list(da.getValues()));
1415         renumber1=[4,0,1,2,3]
1416         targetMesh.renumberCells(renumber1,False);
1417         self.assertTrue(targetMesh.checkConsecutiveCellTypes());
1418         self.assertTrue(targetMesh.checkConsecutiveCellTypesAndOrder(order1));
1419         self.assertTrue(not targetMesh.checkConsecutiveCellTypesAndOrder(order2));
1420         pass
1421
1422     def testRearrange2ConsecutiveCellTypes(self):
1423         m1_1=MEDCouplingDataForTest.build2DSourceMesh_1();
1424         m2_1=MEDCouplingDataForTest.build2DTargetMesh_1();
1425         arr1=m1_1.rearrange2ConsecutiveCellTypes();
1426         m1_2=MEDCouplingDataForTest.build2DSourceMesh_1();
1427         self.assertTrue(m1_2.isEqual(m1_1,1e-12));
1428         expected1=[0,1]
1429         self.assertEqual(2,arr1.getNumberOfTuples());
1430         self.assertEqual(1,arr1.getNumberOfComponents());
1431         self.assertEqual(expected1,arr1.getValues());
1432         expected2=[0,3,4,1,2]
1433         arr1=m2_1.rearrange2ConsecutiveCellTypes();
1434         self.assertEqual(5,arr1.getNumberOfTuples());
1435         self.assertEqual(1,arr1.getNumberOfComponents());
1436         self.assertEqual(expected2,list(arr1.getValues()));
1437         m2_2=MEDCouplingDataForTest.build2DTargetMesh_1();
1438         self.assertEqual(5,arr1.getNumberOfTuples());
1439         self.assertEqual(1,arr1.getNumberOfComponents());
1440         self.assertEqual(expected2,list(arr1.getValues()));
1441         self.assertTrue(not m2_2.isEqual(m2_1,1e-12));
1442         m2_2.renumberCells(expected2,False);
1443         self.assertTrue(m2_2.isEqual(m2_1,1e-12));
1444         pass
1445
1446     def testSplitByType(self):
1447         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1448         v=m1.splitByType();
1449         self.assertEqual(3,len(v));
1450         m2=MEDCouplingUMesh.MergeUMeshesOnSameCoords(v);
1451         m2.setName(m1.getName());
1452         self.assertTrue(m1.isEqual(m2,1.e-12));
1453         pass
1454
1455     def testFuseUMeshesOnSameCoords(self):
1456         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
1457         cells1=[2,3,4]
1458         m3=m2.buildPartOfMySelf(cells1,True);
1459         self.assertTrue(isinstance(m3,MEDCouplingUMesh))
1460         cells2=[1,2,4]
1461         m4=m2.buildPartOfMySelf(cells2,True);
1462         self.assertTrue(isinstance(m4,MEDCouplingUMesh))
1463         cells3=[1,2]
1464         m5=m2.buildPartOfMySelf(cells3,True);
1465         self.assertTrue(isinstance(m5,MEDCouplingUMesh))
1466         meshes=[m3,m4,m5]
1467         #
1468         m7,corr=MEDCouplingUMesh.FuseUMeshesOnSameCoords(meshes,0);
1469         self.assertEqual(4,m7.getNumberOfCells());
1470         self.assertEqual(3,len(corr));
1471         expectedVals1=[3,3,2]
1472         expectedVals2=[[0,1,2],[3,0,2],[3,0]]
1473         for i in xrange(3):
1474             arr=corr[i];
1475             self.assertEqual(1,arr.getNumberOfComponents());
1476             nbOfVals=expectedVals1[i];
1477             self.assertEqual(nbOfVals,arr.getNumberOfTuples());
1478             vals=arr.getValues();
1479             self.assertEqual(expectedVals2[i],list(vals));
1480             pass
1481         arr2,fidsOfGroups=DataArrayInt.MakePartition(corr,m7.getNumberOfCells());
1482         fidExp=[5,1,3,4]
1483         fidsGrp=[[1,3,5],[3,4,5],[4,5]]
1484         self.assertEqual(3,len(fidsOfGroups));
1485         self.assertEqual(1,arr2.getNumberOfComponents());
1486         self.assertEqual(4,arr2.getNumberOfTuples());
1487         self.assertEqual(fidExp,list(arr2.getValues()));
1488         for i in xrange(3):
1489             nbOfVals=expectedVals1[i];
1490             self.assertEqual(list(fidsOfGroups[i]),fidsGrp[i]);
1491             pass
1492         pass
1493
1494     def testFuseUMeshesOnSameCoords2(self):
1495         m1,m2=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
1496         part1=[2,3,6,4,10]
1497         m3=m1.buildPartOfMySelf(part1,True);
1498         part2=[5,6,4,7]
1499         m4=m1.buildPartOfMySelf(part2,True);
1500         meshes=[m1,m3,m3,m4]
1501         m5,corr=MEDCouplingUMesh.FuseUMeshesOnSameCoords(meshes,0);
1502         self.assertEqual(18,m5.getNumberOfCells());
1503         exp2=[
1504             [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17],
1505             [2,3,6,4,10],
1506             [2,3,6,4,10],
1507             [5,6,4,7]]
1508         i=0;
1509         for it in corr:
1510             self.assertEqual(exp2[i],list(it.getValues()));
1511             i+=1
1512             pass
1513         pass
1514
1515     def testBuildOrthogonalField(self):
1516         targetMesh=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1517         field=targetMesh.buildOrthogonalField();
1518         expected=[0.70710678118654746,0.,-0.70710678118654746]
1519         self.assertEqual(5,field.getNumberOfTuples());
1520         self.assertEqual(3,field.getNumberOfComponents());
1521         vals=field.getArray().getValues();
1522         for i in xrange(15):
1523             self.assertTrue(abs(expected[i%3]-vals[i])<1e-12);
1524         # testing
1525         targetCoords=[0.,0.,0.,0.5,0.,0.5,1.,0.,1.,0.,1.,0.]
1526         targetConn=[0,1,2,3]
1527         targetMesh=MEDCouplingUMesh.New();
1528         targetMesh.setMeshDimension(2);
1529         targetMesh.allocateCells(1);
1530         targetMesh.insertNextCell(NORM_QUAD4,targetConn[0:4])
1531         targetMesh.finishInsertingCells();
1532         myCoords=DataArrayDouble.New();
1533         myCoords.setValues(targetCoords,4,3);
1534         targetMesh.setCoords(myCoords);
1535         field=targetMesh.buildOrthogonalField();
1536         self.assertEqual(1,field.getNumberOfTuples());
1537         self.assertEqual(3,field.getNumberOfComponents());
1538         vals=field.getArray().getValues();
1539         self.assertTrue(abs(-0.70710678118654746-vals[0])<1e-12);
1540         self.assertTrue(abs(0.-vals[1])<1e-12);
1541         self.assertTrue(abs(0.70710678118654746-vals[2])<1e-12);
1542         pass
1543
1544     def testGetCellsContainingPoint(self):
1545         targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1546         pos=[0.,0.,0.4,0.4,0.,0.4,0.1,0.1,0.25,0.,0.65,0.]
1547         #2D basic
1548         t1,t2=targetMesh.getCellsContainingPoints(pos,6,1e-12);
1549         self.assertEqual(6,t1.getNumberOfTuples());
1550         self.assertEqual(1,t1.getNumberOfComponents());
1551         self.assertEqual(7,t2.getNumberOfTuples());
1552         self.assertEqual(1,t2.getNumberOfComponents());
1553         expectedValues1=[0,4,3,0,1,2]
1554         expectedValues2=[0,1,2,3,4,5,6]
1555         self.assertEqual(list(t1.getValues()),expectedValues1);
1556         self.assertEqual(list(t2.getValues()),expectedValues2);
1557         #2D with no help of bounding box.
1558         center=[0.2,0.2]
1559         MEDCouplingPointSet.Rotate2DAlg(center,0.78539816339744830962,6,pos);
1560         targetMesh.rotate(center,0.78539816339744830962);
1561         t1=None
1562         t2=None
1563         t1,t2=targetMesh.getCellsContainingPoints(pos,1e-12);
1564         self.assertEqual(6,t1.getNumberOfTuples());
1565         self.assertEqual(7,t2.getNumberOfTuples());
1566         self.assertEqual(list(t1.getValues()),expectedValues1);
1567         self.assertEqual(list(t2.getValues()),expectedValues2);
1568         t1,t2=targetMesh.getCellsContainingPoints(DataArrayDouble.New(pos,6,2),1e-12);
1569         self.assertEqual(6,t1.getNumberOfTuples());
1570         self.assertEqual(7,t2.getNumberOfTuples());
1571         self.assertEqual(list(t1.getValues()),expectedValues1);
1572         self.assertEqual(list(t2.getValues()),expectedValues2);
1573         self.assertRaises(InterpKernelException,targetMesh.getCellsContainingPoints,DataArrayDouble.New(pos,4,3),1e-12);
1574         #2D outside
1575         pos1bis=[-0.3303300858899107,-0.11819805153394641]
1576         self.assertEqual(-1,targetMesh.getCellContainingPoint(pos1bis,1e-12));
1577         #test limits 2D
1578         targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1579         pos2=[0.2,-0.05]
1580         t1=None
1581         t1=targetMesh.getCellsContainingPoint(pos2,1e-12)
1582         self.assertEqual(2,len(t1));
1583         expectedValues3=[0,1]
1584         self.assertEqual(list(t1.getValues()),expectedValues3);
1585         pos3=[0.2,0.2]
1586         t1=None
1587         t1=targetMesh.getCellsContainingPoint(pos3,1e-12);
1588         self.assertEqual(5,len(t1));
1589         expectedValues4=[0,1,2,3,4]
1590         self.assertEqual(list(t1.getValues()),expectedValues4);
1591         self.assertEqual(0,targetMesh.getCellContainingPoint(pos3,1e-12));
1592         #3D
1593         targetMesh=MEDCouplingDataForTest.build3DTargetMesh_1();
1594         pos4=[25.,25.,25.]
1595         self.assertEqual(0,targetMesh.getCellContainingPoint(pos4,1e-12));
1596         pos5=[50.,50.,50.]
1597         t1=None
1598         t1=targetMesh.getCellsContainingPoint(pos5,1e-12);
1599         self.assertEqual(8,len(t1));
1600         expectedValues5=[0,1,2,3,4,5,6,7]
1601         self.assertEqual(list(t1.getValues()),expectedValues5);
1602         pos6=[0., 50., 0.]
1603         t1=None
1604         t1=targetMesh.getCellsContainingPoint(pos6,1e-12);
1605         self.assertEqual(2,len(t1));
1606         expectedValues6=[0,2]
1607         self.assertEqual(list(t1.getValues()),expectedValues6);
1608         #3D outside
1609         pos7=[-1.0,-1.0,0.]
1610         self.assertEqual(-1,targetMesh.getCellContainingPoint(pos7,1e-12));
1611         #3D outside 2
1612         center2=[0.,0.,0.]
1613         vec2=[0.,-1.,0.]
1614         targetMesh.rotate(center2,vec2,0.78539816339744830962);
1615         pos8=[-25.,25.,12.]
1616         self.assertEqual(-1,targetMesh.getCellContainingPoint(pos8,1e-12));
1617         pass
1618
1619     def testGetValueOn1(self):
1620         targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1621         fieldOnCells=MEDCouplingFieldDouble.New(ON_CELLS);
1622         nbOfCells=targetMesh.getNumberOfCells();
1623         fieldOnCells.setMesh(targetMesh);
1624         array=DataArrayDouble.New();
1625         tmp=2*nbOfCells*[None]
1626         for i in xrange(nbOfCells):
1627             tmp[2*i]=7.+float(i);
1628             tmp[2*i+1]=17.+float(i)
1629             pass
1630         array.setValues(tmp,nbOfCells,2);
1631         fieldOnCells.setArray(array);
1632         #
1633         pos1=[0.25,0.]
1634         res=fieldOnCells.getValueOn(pos1);
1635         self.assertEqual(2,len(res))
1636         self.assertTrue(abs(8.-res[0])<1e-12);
1637         self.assertTrue(abs(18.-res[1])<1e-12);
1638         #
1639         #
1640         targetMesh=MEDCouplingDataForTest.build2DSourceMesh_1();
1641         fieldOnNodes=MEDCouplingFieldDouble.New(ON_NODES);
1642         nbOfNodes=targetMesh.getNumberOfNodes();
1643         fieldOnNodes.setMesh(targetMesh);
1644         array=DataArrayDouble.New();
1645         tmp=2*nbOfNodes*[None]
1646         for i in xrange(nbOfNodes):
1647             tmp[2*i]=17.+float(i);
1648             tmp[2*i+1]=27.+float(i)
1649             pass
1650         array.setValues(tmp,nbOfNodes,2);
1651         fieldOnNodes.setArray(array);
1652         #
1653         pos2=[-0.13333333333333333,-0.13333333333333333]
1654         res=None
1655         res=fieldOnNodes.getValueOn(pos2);
1656         self.assertEqual(2,len(res))
1657         self.assertTrue(abs(17.5-res[0])<1e-12);
1658         self.assertTrue(abs(27.5-res[1])<1e-12);
1659         pos3=[0.033333333333333326,0.36666666666666664]
1660         res=None
1661         res=fieldOnNodes.getValueOn(pos3);
1662         self.assertEqual(2,len(res))
1663         self.assertTrue(abs(18.666666666666667-res[0])<1e-12);
1664         self.assertTrue(abs(28.666666666666667-res[1])<1e-12);
1665         pass
1666
1667     def testCMesh0(self):
1668         mesh=MEDCouplingCMesh.New();
1669         meshEmpty=mesh.clone(True);
1670         self.assertTrue(meshEmpty.isEqual(mesh, 1e-12));
1671         
1672         coordsX=DataArrayDouble.New();
1673         arrX=[ -1., 1., 2., 4. ]
1674         coordsX.setValues(arrX, 4, 1);
1675         coordsY=DataArrayDouble.New();
1676         arrY=[ -2., 2., 4., 8. ]
1677         coordsY.setValues(arrY, 4, 1);
1678         coordsZ=DataArrayDouble.New();
1679         arrZ=[ -3., 3., 6., 12. ]
1680         coordsZ.setValues(arrZ, 4, 1);
1681         mesh.setCoords(coordsX, coordsY, coordsZ);
1682         #
1683         fieldOnNodes=mesh.fillFromAnalytic(ON_NODES, 1, "x+y/2.+z/3.");
1684         self.assertEqual(1, fieldOnNodes.getNumberOfComponents());
1685         self.assertEqual(64, fieldOnNodes.getNumberOfTuples());
1686         expected1=[-3., -1., 0., 2., -1., 1., 2., 4., 0., 2., 3., 5., 2., 4., 5., 7., -1., 1., 2.,
1687                     4., 1., 3., 4., 6., 2., 4., 5., 7., 4., 6., 7., 9., 0., 2., 3., 5., 2., 4., 5.,
1688                     7., 3., 5., 6., 8., 5., 7., 8., 10., 2., 4., 5.,
1689                     7., 4., 6., 7., 9., 5., 7., 8., 10., 7., 9., 10., 12.];
1690         
1691         val=fieldOnNodes.getArray().getValues();
1692         for i in xrange(64):
1693           self.assertAlmostEqual(expected1[i], val[i], 12)
1694         res=fieldOnNodes.getValueOnPos(1, 3, 2);
1695         self.assertAlmostEqual(7., res[0], 12);
1696         #
1697         fieldOnCells=mesh.fillFromAnalytic(ON_CELLS, 1, "x+y/2.+z/3.");
1698         self.assertEqual(1, fieldOnCells.getNumberOfComponents());
1699         self.assertEqual(27, fieldOnCells.getNumberOfTuples());
1700         val=fieldOnCells.getArray().getValues();
1701         expected2=[0, 1.5, 3, 1.5, 3, 4.5, 3, 4.5, 6, 1.5, 3, 4.5, 3, 4.5,
1702                     6, 4.5, 6, 7.5, 3, 4.5, 6, 4.5, 6, 7.5, 6, 7.5, 9];
1703         for i in xrange(27):
1704           self.assertAlmostEqual(expected2[i], val[i], 12);
1705         #res=fieldOnCells.getValueOnPos(1,2,1);
1706         #self.assertAlmostEqual(6.,res,12);
1707         #
1708         meshDeepCopy=mesh.deepCpy();
1709         meshClone=mesh.clone(False);
1710         
1711         meshEmpty.copyTinyStringsFrom(mesh);
1712         #no data in meshEmpty, expected False
1713         self.assertTrue(not meshEmpty.isEqual(mesh, 1e-12));
1714         
1715         self.assertTrue(meshDeepCopy.isEqual(mesh, 1e-12));
1716         meshDeepCopy.copyTinyStringsFrom(mesh);
1717         self.assertTrue(meshDeepCopy.isEqual(mesh, 1e-12));
1718         self.assertTrue(meshClone.isEqual(mesh, 1e-12));
1719         
1720         self.assertEqual(CARTESIAN, mesh.getType());
1721         self.assertEqual(CARTESIAN, meshEmpty.getType());
1722         self.assertEqual(CARTESIAN, meshDeepCopy.getType());
1723         self.assertEqual(CARTESIAN, meshClone.getType());
1724         pass
1725
1726     def testCMesh1(self):
1727         mesh1=MEDCouplingCMesh.New();
1728         coordsX1=DataArrayDouble.New();
1729         arrX1=[ -1., 1., 2., 4. ]
1730         coordsX1.setValues(arrX1, 4, 1);
1731         coordsY1=DataArrayDouble.New();
1732         arrY1=[ -2., 2., 4., 8. ]
1733         coordsY1.setValues(arrY1, 4, 1);
1734         coordsZ1=DataArrayDouble.New();
1735         arrZ1=[ -3., 3., 6., 12. ]
1736         coordsZ1.setValues(arrZ1, 4, 1);
1737         mesh1.setCoords(coordsX1, coordsY1, coordsZ1);
1738         
1739         mesh2=MEDCouplingCMesh.New();
1740         coordsX2=DataArrayDouble.New();
1741         arrX2=[ -1., 1., 2., 4. ]
1742         coordsX2.setValues(arrX2, 4, 1);
1743         coordsY2=DataArrayDouble.New();
1744         arrY2=[ -2., 2., 4., 8. ]
1745         coordsY2.setValues(arrY2, 4, 1);
1746         coordsZ2=DataArrayDouble.New();
1747         arrZ2=[ -3., 3., 6., 12.+1e-6 ]
1748         coordsZ2.setValues(arrZ2, 4, 1);
1749         mesh2.setCoords(coordsX2, coordsY2, coordsZ2);
1750         
1751         mesh3=MEDCouplingCMesh.New();
1752         coordsX3=DataArrayDouble.New();
1753         arrX3=[-1.]
1754         coordsX3.setValues(arrX3, 1, 1);
1755         coordsY3=DataArrayDouble.New();
1756         arrY3=[-2.]
1757         coordsY3.setValues(arrY3, 1, 1);
1758         coordsZ3=DataArrayDouble.New();
1759         arrZ3=[-3.]
1760         coordsZ3.setValues(arrZ3, 1, 1);
1761         mesh3.setCoords(coordsX3, coordsY3, coordsZ3);
1762         
1763         self.assertEqual(3, mesh1.getSpaceDimension());
1764         self.assertEqual(3, mesh1.getMeshDimension());
1765         
1766         self.assertTrue(not mesh1.isEqual(mesh2, 1e-12));
1767         self.assertTrue(not mesh2.isEqual(mesh1, 1e-12));
1768         self.assertTrue(not mesh2.isEqualWithoutConsideringStr(mesh1, 1e-12));
1769         self.assertTrue(mesh1.isEqual(mesh2, 1e-5));
1770         self.assertTrue(not mesh1.isEqual(mesh2, 1e-7));
1771         
1772         self.assertRaises(InterpKernelException, mesh3.checkCoherency1, 1e-12);
1773         mesh1.checkCoherency2(1e-12);
1774         self.assertEqual(NORM_HEXA8, mesh1.getTypeOfCell(1));
1775         
1776         self.assertEqual(NORM_HEXA8, mesh1.getAllGeoTypes()[0]);
1777         self.assertEqual(27, mesh1.getNumberOfCellsWithType(NORM_HEXA8));
1778         self.assertRaises(InterpKernelException, mesh1.getNumberOfCellsWithType, NORM_QUAD4);
1779         
1780         coo=mesh1.getCoordinatesOfNode(0);
1781         self.assertEqual(3, len(coo));
1782         self.assertAlmostEqual(-1., coo[0], 14);
1783         self.assertAlmostEqual(-2., coo[1], 14);
1784         self.assertAlmostEqual(-3., coo[2], 14);
1785         coo=mesh1.getCoordinatesOfNode(63);
1786         self.assertEqual(3, len(coo));
1787         self.assertAlmostEqual(4., coo[0], 14);
1788         self.assertAlmostEqual(8., coo[1], 14);
1789         self.assertAlmostEqual(12., coo[2], 14);
1790         
1791         a=str(mesh1)
1792         repr=mesh1.simpleRepr();
1793         repr=mesh1.advancedRepr();
1794         self.assertTrue("Cartesian" in repr);
1795         self.assertTrue("Number of components : 1" in repr);
1796         self.assertTrue("Number of tuples : 4" in repr);
1797         self.assertTrue("Z Array :" in repr);
1798         pass
1799
1800     def testCMesh2(self):
1801         mesh1=MEDCouplingCMesh.New();
1802         coordsX1=DataArrayDouble.New();
1803         arrX1=[ -1., 1., 2., 4. ]
1804         coordsX1.setValues(arrX1, 4, 1);
1805         coordsY1=DataArrayDouble.New();
1806         arrY1=[ -2., 2., 4., 8. ]
1807         coordsY1.setValues(arrY1, 4, 1);
1808         coordsZ1=DataArrayDouble.New();
1809         arrZ1=[ -3., 3., 6., 12. ]
1810         coordsZ1.setValues(arrZ1, 4, 1);
1811         mesh1.setCoords(coordsX1, coordsY1, coordsZ1);
1812         
1813         dis=mesh1.getDistributionOfTypes();
1814         self.assertEqual(1, len(dis));
1815         self.assertEqual(NORM_HEXA8, dis[0][0]);
1816         self.assertEqual(27, dis[0][1]);
1817         self.assertEqual(0, dis[0][2]);
1818         
1819         idsPerType=[]
1820         self.assertRaises(InterpKernelException, mesh1.checkTypeConsistencyAndContig, dis, idsPerType);
1821         dis[0][2]=-1;
1822         idsPerType=[]
1823         self.assertTrue(not mesh1.checkTypeConsistencyAndContig(dis, idsPerType));
1824         dis[0][0]=NORM_QUAD4;
1825         self.assertRaises(InterpKernelException, mesh1.checkTypeConsistencyAndContig, dis, idsPerType);
1826         dis[0][0]=NORM_HEXA8;
1827         dis[0][2]=0;
1828         ids=DataArrayInt.New();
1829         ids.alloc(10, 1);
1830         ids.fillWithValue(111);
1831         idsPerType=[ids];
1832         check=mesh1.checkTypeConsistencyAndContig(dis, idsPerType);
1833         self.assertTrue(check);
1834         self.assertTrue(check.isEqual(ids));
1835         
1836         code, idsInPflPerType, pfls=mesh1.splitProfilePerType(ids);
1837         self.assertEqual(3, len(code));
1838         self.assertEqual(NORM_HEXA8, code[0]);
1839         self.assertEqual(27, code[1]);
1840         self.assertEqual(0, code[2]);
1841         self.assertEqual(1, len(idsInPflPerType));
1842         self.assertEqual(1, len(pfls));
1843         self.assertTrue(idsInPflPerType[0].isEqual(ids));
1844         self.assertTrue(pfls[0].isEqual(ids));
1845         
1846         cells1=[0, 1, 25, 26]
1847         partMesh1=mesh1.buildPart(cells1)
1848         self.assertTrue(isinstance(partMesh1,MEDCouplingMesh))
1849         self.assertEqual(4, partMesh1.getNumberOfCellsWithType(NORM_HEXA8));
1850         self.assertEqual(64, mesh1.getNumberOfNodes());
1851         self.assertEqual(64, partMesh1.getNumberOfNodes());
1852         
1853         cells2=[25, 26]
1854         partMesh2, arr1=mesh1.buildPartAndReduceNodes(cells2)
1855         self.assertTrue(isinstance(partMesh2,MEDCouplingUMesh))
1856         self.assertEqual(2,partMesh2.getNumberOfCellsWithType(NORM_HEXA8));
1857         self.assertEqual(12,partMesh2.getNumberOfNodes());
1858         
1859         cells3=[2, 3]
1860         partMesh3, arr2=partMesh1.buildPartAndReduceNodes(cells3)
1861         self.assertTrue(isinstance(partMesh3,MEDCouplingUMesh))
1862         self.assertEqual(2, partMesh3.getNumberOfCellsWithType(NORM_HEXA8));
1863         self.assertEqual(12, partMesh3.getNumberOfNodes());
1864         
1865         self.assertRaises(InterpKernelException, mesh1.simplexize, 0);
1866         self.assertRaises(InterpKernelException, mesh1.getMeasureFieldOnNode, True);
1867         
1868         #double bbox1[6];
1869         #double bbox2[6];
1870         bbox1=mesh1.getBoundingBox(); #[(-1.0, 4.0), (-2.0, 8.0), (-3.0, 12.0)]
1871         bbox2=partMesh1.getBoundingBox();
1872         self.assertTrue(bbox1==bbox2);
1873         bbox1=partMesh3.getBoundingBox();
1874         bbox2=partMesh2.getBoundingBox();
1875         self.assertTrue(bbox1==bbox2);
1876         
1877         self.assertRaises(InterpKernelException, mesh1.buildOrthogonalField);
1878         mesh2d=MEDCouplingCMesh.New();
1879         mesh2d.setCoords(coordsX1, coordsY1);
1880         f1=mesh2d.buildOrthogonalField();
1881         
1882         pass
1883
1884     def testScale(self):
1885         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1886         pos=[0.2,0.2]
1887         mesh.scale(pos,0.5);
1888         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,
1889                    -0.05,0.45, 0.2,0.45, 0.45,0.45]
1890         val=mesh.getCoords().getValues();
1891         self.assertEqual(18,len(val))
1892         for i in xrange(18):
1893             self.assertTrue(abs(expected1[i]-val[i])<1e-12);
1894             pass
1895         pass
1896
1897     def testTryToShareSameCoords(self):
1898         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
1899         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
1900         self.assertTrue(m1.getCoords().getHiddenCppPointer()!=m2.getCoords().getHiddenCppPointer());
1901         m1.tryToShareSameCoords(m2,1e-12);
1902         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1903         m1.tryToShareSameCoords(m2,1e-12);
1904         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1905         m2.tryToShareSameCoords(m1,1e-12);
1906         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1907         #
1908         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
1909         m2=MEDCouplingDataForTest.build2DTargetMesh_2();
1910         self.assertTrue(m1.getCoords().getHiddenCppPointer()!=m2.getCoords().getHiddenCppPointer());
1911         m1.tryToShareSameCoords(m2,1e-12);
1912         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1913         m1.tryToShareSameCoords(m2,1e-12);
1914         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1915         m2.tryToShareSameCoords(m1,1e-12);
1916         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1917         #
1918         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
1919         m2=MEDCouplingDataForTest.build2DSourceMesh_1();
1920         self.assertTrue(m1.getCoords().getHiddenCppPointer()!=m2.getCoords().getHiddenCppPointer());
1921         self.assertRaises(InterpKernelException,m1.tryToShareSameCoords,m2,1e-12)
1922         pass
1923
1924     def testFindNodeOnPlane(self):
1925         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
1926         pt=[300.,300.,0.]
1927         v=[0.,0.,2.]
1928         n=mesh.findNodesOnPlane(pt,v,1e-12);
1929         self.assertEqual(9,len(n));
1930         m3dSurf=mesh.buildFacePartOfMySelfNode(n,True);
1931         self.assertTrue(isinstance(m3dSurf,MEDCouplingUMesh))
1932         me=MEDCouplingExtrudedMesh.New(mesh,m3dSurf,0);
1933         da=me.getMesh3DIds();
1934         self.assertEqual(8,me.getNumberOfCells());
1935         expected=[0,1,2,3,4,5,6,7]
1936         val=da.getValues();
1937         self.assertEqual(expected,list(val));
1938         #
1939         m3dSurf=mesh.buildFacePartOfMySelfNode(n,True);
1940         self.assertTrue(isinstance(m3dSurf,MEDCouplingUMesh))
1941         me=MEDCouplingExtrudedMesh.New(mesh,m3dSurf,0);
1942         da=me.getMesh3DIds();
1943         self.assertEqual(8,me.getNumberOfCells());
1944         expected=[0,1,2,3,4,5,6,7]
1945         val=da.getValues();
1946         self.assertEqual(expected,list(val));
1947         pass
1948
1949     def testRenumberCells(self):
1950         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1951         m2=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1952         self.assertTrue(m.isEqual(m2,0));
1953         arr=[12,3,25,2,26]
1954         m.renumberCells(arr,True);
1955         self.assertTrue(not m.isEqual(m2,0));
1956         self.assertEqual(NORM_QUAD4,m.getTypeOfCell(0));
1957         self.assertEqual(NORM_TRI3,m.getTypeOfCell(1));
1958         self.assertEqual(NORM_QUAD4,m.getTypeOfCell(2));
1959         self.assertEqual(NORM_TRI3,m.getTypeOfCell(3));
1960         self.assertEqual(NORM_QUAD4,m.getTypeOfCell(4));
1961         arr2=[5,-1,-5,4,8]
1962         m.renumberCells(arr2,True);
1963         self.assertTrue(m.isEqual(m2,0));
1964         pass
1965
1966     def testChangeSpaceDimension(self):
1967         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1968         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
1969         #
1970         self.assertEqual(3,m1.getSpaceDimension());
1971         m1.changeSpaceDimension(2);
1972         self.assertEqual(2,m1.getSpaceDimension());
1973         m1.setName(m2.getName());
1974         self.assertTrue(m1.isEqual(m2,1e-12));
1975         m1.changeSpaceDimension(3);
1976         self.assertEqual(3,m1.getSpaceDimension());
1977         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.]
1978         val=m1.getCoords().getValues();
1979         for i in xrange(27):
1980             self.assertTrue(abs(expected[i]-val[i])<1e-14);
1981             pass
1982         pass
1983
1984     def testGaussPointField1(self):
1985         _a=0.446948490915965;
1986         _b=0.091576213509771;
1987         _p1=0.11169079483905;
1988         _p2=0.0549758718227661;
1989         refCoo1=[ 0.,0., 1.,0., 0.,1. ]
1990         gsCoo1=[ 2*_b-1, 1-4*_b, 2*_b-1, 2.07*_b-1, 1-4*_b,
1991                  2*_b-1, 1-4*_a, 2*_a-1, 2*_a-1, 1-4*_a, 2*_a-1, 2*_a-1 ]
1992         wg1=[ 4*_p2, 4*_p2, 4*_p2, 4*_p1, 4*_p1, 4*_p1 ]
1993         _refCoo1=refCoo1
1994         _gsCoo1=gsCoo1
1995         _wg1=wg1
1996         #
1997         m=MEDCouplingDataForTest.build2DTargetMesh_1();
1998         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,NO_TIME);
1999         f.setMesh(m);
2000         self.assertEqual(5,f.getNumberOfMeshPlacesExpected());
2001         self.assertEqual(0,f.getNbOfGaussLocalization());
2002         f.setGaussLocalizationOnType(NORM_TRI3,_refCoo1,_gsCoo1,_wg1);
2003         f.setGaussLocalizationOnType(NORM_TRI3,_refCoo1,_gsCoo1,_wg1); # not a bug only to check that it works well
2004         self.assertRaises(InterpKernelException,f.setGaussLocalizationOnType,NORM_QUAD4,_refCoo1,_gsCoo1,_wg1)
2005         self.assertEqual(1,f.getNbOfGaussLocalization());
2006         refCoo2=[ 0.,0., 1.,0., 1.,1., 0.,1. ]
2007         _refCoo2=refCoo2
2008         _gsCoo1=_gsCoo1[0:4]
2009         _wg1=_wg1[0:2]
2010         f.setGaussLocalizationOnType(NORM_QUAD4,_refCoo2,_gsCoo1,_wg1);
2011         self.assertEqual(2,f.getNbOfGaussLocalization());
2012         array=DataArrayDouble.New();
2013         ptr=18*2*[None]
2014         for i in xrange(18*2):
2015             ptr[i]=float(i+1)
2016         array.setValues(ptr,18,2);
2017         ptr=array.getPointer();
2018         f.setArray(array);
2019         f.setName("MyFirstFieldOnGaussPoint");
2020         f.checkCoherency();
2021         self.assertAlmostEqual(27.,f.getIJK(2,5,0),14);
2022         self.assertAlmostEqual(16.,f.getIJK(1,5,1),14);
2023         #
2024         f.clearGaussLocalizations();
2025         self.assertEqual(0,f.getNbOfGaussLocalization());
2026         self.assertRaises(InterpKernelException,f.checkCoherency);
2027         ids1=[0,1,3,4]
2028         self.assertRaises(InterpKernelException,f.setGaussLocalizationOnCells,ids1,_refCoo2,_gsCoo1,_wg1);
2029         self.assertEqual(0,f.getNbOfGaussLocalization());
2030         ids2=[0,4]
2031         f.setGaussLocalizationOnCells(ids2,_refCoo2,_gsCoo1,_wg1);
2032         self.assertEqual(1,f.getNbOfGaussLocalization());
2033         self.assertEqual(0,f.getGaussLocalizationIdOfOneCell(0));
2034         self.assertRaises(InterpKernelException,f.getGaussLocalizationIdOfOneCell,1);
2035         ids3=[1,2]
2036         f.setGaussLocalizationOnCells(ids3,_refCoo1,_gsCoo1,_wg1);
2037         self.assertEqual(2,f.getNbOfGaussLocalization());
2038         self.assertEqual(0,f.getGaussLocalizationIdOfOneCell(0));
2039         self.assertEqual(1,f.getGaussLocalizationIdOfOneCell(1));
2040         self.assertEqual(1,f.getGaussLocalizationIdOfOneCell(2));
2041         self.assertRaises(InterpKernelException,f.checkCoherency);#<- cell 3 has no localization
2042         ids4=[3]
2043         _gsCoo2=_gsCoo1;
2044         _wg2=_wg1;
2045         _gsCoo2[0]=0.8888777776666;
2046         _wg2[0]=0.1234567892377;
2047         f.setGaussLocalizationOnCells(ids4,_refCoo2,_gsCoo2,_wg2);
2048         self.assertEqual(3,f.getNbOfGaussLocalization());
2049         tmpIds=f.getCellIdsHavingGaussLocalization(0);
2050         self.assertEqual(ids2,list(tmpIds.getValues()));
2051         self.assertRaises(InterpKernelException,f.checkCoherency);#<- it's always not ok because undelying array not with the good size.
2052         array2=f.getArray().substr(0,10);
2053         f.setArray(array2);
2054         f.checkCoherency();#<- here it is OK
2055         f2=f.clone(True);
2056         self.assertTrue(f.isEqual(f2,1e-14,1e-14));
2057         gl1=f2.getGaussLocalization(0);
2058         tmp=gl1.getGaussCoord(1,1);
2059         self.assertAlmostEqual(2.07*_b-1,tmp,14);
2060         gl1.setGaussCoord(1,1,0.07);
2061         self.assertTrue(not f.isEqual(f2,1e-14,1e-14));
2062         gl1.setGaussCoord(1,1,tmp);
2063         self.assertTrue(f.isEqual(f2,1e-14,1e-14));
2064         f2.checkCoherency();
2065         pass
2066
2067     def testGaussPointNEField1(self):
2068         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2069         f=MEDCouplingFieldDouble.New(ON_GAUSS_NE,NO_TIME);
2070         f.setMesh(m);
2071         self.assertEqual(5,f.getNumberOfMeshPlacesExpected());
2072         f.setName("MyFirstFieldOnNE");
2073         f.setDescription("MyDescriptionNE");
2074         array=DataArrayDouble.New();
2075         tmp=18*2*[None]
2076         for i in xrange(18*2):
2077             tmp[i]=float(i+7)
2078             pass
2079         array.setValues(tmp,18,2);
2080         ptr=array.getPointer();
2081         f.setArray(array);
2082         #
2083         f.checkCoherency();
2084         f2=f.clone(True);
2085         self.assertTrue(f.isEqual(f2,1e-14,1e-14));
2086         self.assertAlmostEqual(21.,f.getIJK(2,0,0),14);
2087         self.assertAlmostEqual(18.,f.getIJK(1,1,1),14);
2088         pass
2089
2090     def testCellOrientation1(self):
2091         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2092         vec=[0.,0.,-1.]
2093         self.assertRaises(InterpKernelException,m.are2DCellsNotCorrectlyOriented,vec,False);
2094         m.changeSpaceDimension(3);
2095         res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2096         self.assertTrue(len(res1)==0);
2097         vec[2]=1.;
2098         res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2099         self.assertEqual(5,len(res1));
2100         #
2101         vec[2]=-1.;
2102         # connectivity inversion
2103         conn=m.getNodalConnectivity().getValues();
2104         tmp=conn[11];
2105         conn[11]=conn[12];
2106         conn[12]=tmp;
2107         m.getNodalConnectivity().setValues(conn,len(conn),1)
2108         res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2109         self.assertEqual(1,len(res1));
2110         self.assertEqual(2,res1.getValues()[0]);
2111         m.orientCorrectly2DCells(vec,False);
2112         res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2113         self.assertTrue(len(res1)==0);
2114         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
2115         m2.changeSpaceDimension(3);
2116         self.assertTrue(m.isEqual(m2,1e-12));
2117         pass
2118
2119     def testCellOrientation2(self):
2120         m2,m1=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
2121         res1=m2.arePolyhedronsNotCorrectlyOriented();
2122         self.assertEqual(6,len(res1));
2123         m2.orientCorrectlyPolyhedrons();
2124         res1=m2.arePolyhedronsNotCorrectlyOriented();
2125         self.assertTrue(len(res1)==0);
2126         m2.checkCoherency();
2127         self.assertEqual(18,m2.getNumberOfCells());
2128         cellIds2=[0,6,12]
2129         m2.convertToPolyTypes(cellIds2);
2130         m2.orientCorrectlyPolyhedrons();
2131         res1=m2.arePolyhedronsNotCorrectlyOriented();
2132         self.assertTrue(len(res1)==0);
2133         f2=m2.getMeasureField(False);
2134         f2Ptr=f2.getArray().getValues();
2135         #Test to check global reverse in MEDCouplingUMesh::tryToCorrectPolyhedronOrientation
2136         m3=MEDCouplingDataForTest.build2DTargetMesh_1();
2137         vec=[0.,0.,1.]
2138         m3.changeSpaceDimension(3);
2139         ids2=[0,1,2,3,4]
2140         m3.convertToPolyTypes(ids2);
2141         m3.orientCorrectly2DCells(vec,False);
2142         m4=MEDCouplingDataForTest.buildCU1DMesh_U();
2143         m4.changeSpaceDimension(3);
2144         center=[0.,0.,0.]
2145         vector=[0.,1.,0.]
2146         m4.rotate(center,vector,-pi/2.);
2147         m5=m3.buildExtrudedMesh(m4,0);
2148         res1=m5.arePolyhedronsNotCorrectlyOriented();
2149         self.assertEqual(15,len(res1));
2150         m5.orientCorrectlyPolyhedrons();
2151         res1=m5.arePolyhedronsNotCorrectlyOriented();
2152         self.assertTrue(len(res1)==0);
2153         f3=m5.getMeasureField(False);
2154         self.assertEqual(15,f3.getArray().getNumberOfTuples());
2155         self.assertEqual(1,f3.getNumberOfComponents());
2156         f3Ptr=f3.getArray().getValues();
2157         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];
2158         for i in xrange(15):
2159             self.assertTrue(abs(expected1[i]-f3Ptr[i])<1e-12);
2160             pass
2161         f4=m5.getBarycenterAndOwner();
2162         self.assertEqual(15,f4.getNumberOfTuples());
2163         self.assertEqual(3,f4.getNumberOfComponents());
2164         f4Ptr=f4.getValues();
2165         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];
2166         for i in xrange(45):
2167             self.assertTrue(abs(expected2[i]-f4Ptr[i])<1e-12);
2168             pass
2169         pass
2170
2171     def testPolyhedronBarycenter(self):
2172         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];
2173         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];
2174         meshN=MEDCouplingUMesh.New();
2175         meshN.setName("ForBary");
2176         meshN.setMeshDimension(3);
2177         meshN.allocateCells(4);
2178         meshN.insertNextCell(NORM_POLYHED,29,connN[0:29])
2179         meshN.finishInsertingCells();
2180         myCoords=DataArrayDouble.New();
2181         myCoords.setValues(coords,9,3);
2182         meshN.setCoords(myCoords);
2183         meshN.checkCoherency();
2184         #
2185         res1=meshN.arePolyhedronsNotCorrectlyOriented();
2186         meshN.orientCorrectlyPolyhedrons();
2187         self.assertTrue(len(res1)==0);
2188         da=meshN.getBarycenterAndOwner();
2189         self.assertEqual(1,da.getNumberOfTuples());
2190         self.assertEqual(3,da.getNumberOfComponents());
2191         daPtr=da.getValues();
2192         ref=meshN.getCoords().getValues()[24:];
2193         for i in xrange(3):
2194             self.assertTrue(abs(ref[i]-daPtr[i])<1e-12);
2195             pass
2196         #
2197         center=[0.,0.,0.]
2198         vec=[0.,2.78,0.]
2199         da=meshN.getBarycenterAndOwner();
2200         daPtr=da.getValues();
2201         ref=meshN.getCoords().getValues()[24:];
2202         for i in xrange(3):
2203             self.assertTrue(abs(ref[i]-daPtr[i])<1e-12);
2204             pass
2205         #
2206         meshN.rotate(center,vec,pi/7.);
2207         meshN.translate(vec);
2208         da=meshN.getBarycenterAndOwner();
2209         daPtr=da.getValues();
2210         ref=meshN.getCoords().getValues()[24:];
2211         for i in xrange(3):
2212             self.assertTrue(abs(ref[i]-daPtr[i])<1e-12);
2213             pass
2214         #
2215         center2=[1.12,3.45,6.78]
2216         vec2=[4.5,9.3,2.8]
2217         meshN.rotate(center2,vec2,e);
2218         meshN.translate(vec2);
2219         da=meshN.getBarycenterAndOwner();
2220         daPtr=da.getValues();
2221         ref=meshN.getCoords().getValues()[24:];
2222         for i in xrange(3):
2223             self.assertTrue(abs(ref[i]-daPtr[i])<1e-10);
2224             pass
2225         pass
2226
2227     def testNormL12Integ1D(self):
2228         m1=MEDCouplingDataForTest.build1DTargetMesh_3();
2229         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2230         f1.setMesh(m1);
2231         array=DataArrayDouble.New();
2232         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]
2233         array.setValues(arr,m1.getNumberOfCells(),3);
2234         f1.setArray(array);
2235         #
2236         f3=m1.getBarycenterAndOwner();
2237         self.assertEqual(4,f3.getNumberOfTuples());
2238         self.assertEqual(1,f3.getNumberOfComponents());
2239         expected9=[0.75,5.105,0.8,5.155]
2240         ptr=f3.getValues();
2241         for i in xrange(4):
2242             self.assertTrue(abs(expected9[i]-ptr[i])<1e-12);
2243             pass
2244         #
2245         f2=m1.getMeasureField(False);
2246         self.assertEqual(4,f2.getArray().getNumberOfTuples());
2247         self.assertEqual(1,f2.getNumberOfComponents());
2248         expected1=[0.5,0.21,-0.6,-0.31]
2249         ptr=f2.getArray().getValues();
2250         for i in xrange(4):
2251             self.assertTrue(abs(expected1[i]-ptr[i])<1e-12);
2252             pass
2253         expected2=[0.5,0.21,0.6,0.31]
2254         f2=m1.getMeasureField(True);
2255         ptr=f2.getArray().getValues();
2256         for i in xrange(4):
2257             self.assertTrue(abs(expected2[i]-ptr[i])<1e-12);
2258             pass
2259         #integral
2260         self.assertTrue(4,f1.getNumberOfTuples())
2261         res=f1.integral(False);
2262         self.assertTrue(3,len(res))
2263         expected3=[0.9866,-0.3615,0.4217]
2264         for i in xrange(3):
2265             self.assertTrue(abs(expected3[i]-res[i])<1e-12);
2266             pass
2267         self.assertTrue(abs(expected3[0]-f1.integral(0,False))<1e-12);
2268         self.assertTrue(abs(expected3[1]-f1.integral(1,False))<1e-12);
2269         self.assertTrue(abs(expected3[2]-f1.integral(2,False))<1e-12);
2270         res=f1.integral(True);
2271         expected4=[-3.4152,8.7639,-14.6879]
2272         for i in xrange(3):
2273             self.assertTrue(abs(expected4[i]-res[i])<1e-12);
2274             pass
2275         #normL1
2276         res=f1.normL1();
2277         self.assertTrue(3,len(res))
2278         expected5=[6.979506172839505, 16.89018518518518, 27.02969135802469]
2279         for i in xrange(3):
2280             self.assertTrue(abs(expected5[i]-res[i])<1e-12);
2281             pass
2282         self.assertTrue(abs(expected5[0]-f1.normL1(0))<1e-12);
2283         self.assertTrue(abs(expected5[1]-f1.normL1(1))<1e-12);
2284         self.assertTrue(abs(expected5[2]-f1.normL1(2))<1e-12);
2285         #normL2
2286         res=f1.normL2();
2287         self.assertTrue(3,len(res))
2288         expected7=[7.090910979452395, 16.9275542960123, 27.053271464160858]
2289         for i in xrange(3):
2290             self.assertTrue(abs(expected7[i]-res[i])<1e-9);
2291             pass
2292         self.assertTrue(abs(expected7[0]-f1.normL2(0))<1e-9);
2293         self.assertTrue(abs(expected7[1]-f1.normL2(1))<1e-9);
2294         self.assertTrue(abs(expected7[2]-f1.normL2(2))<1e-9);
2295         #buildMeasureField
2296         f4=f1.buildMeasureField(False);
2297         self.assertTrue(abs(-0.2-f4.accumulate(0))<1e-12);
2298         f4=f1.buildMeasureField(True);
2299         self.assertTrue(abs(1.62-f4.accumulate(0))<1e-12);
2300         # Testing with 2D Curve
2301         m1=MEDCouplingDataForTest.build2DCurveTargetMesh_3();
2302         f2=m1.getMeasureField(False);
2303         self.assertEqual(4,f2.getArray().getNumberOfTuples());
2304         self.assertEqual(1,f2.getNumberOfComponents());
2305         ptr=f2.getArray().getValues();
2306         for i in xrange(4):
2307             self.assertTrue(abs(sqrt(2.)*expected2[i]-ptr[i])<1e-12);
2308             pass
2309         f2=m1.getMeasureField(True);
2310         self.assertEqual(4,f2.getArray().getNumberOfTuples());
2311         self.assertEqual(1,f2.getNumberOfComponents());
2312         ptr=f2.getArray().getValues();
2313         for i in xrange(4):
2314             self.assertTrue(abs(expected2[i]*sqrt(2.)-ptr[i])<1e-12);
2315             pass
2316         #bary
2317         f3=m1.getBarycenterAndOwner();
2318         self.assertEqual(4,f3.getNumberOfTuples());
2319         self.assertEqual(2,f3.getNumberOfComponents());
2320         expected10=[0.75,0.75,5.105,5.105,0.8,0.8,5.155,5.155]
2321         ptr=f3.getValues();
2322         for i in xrange(8):
2323             self.assertTrue(abs(expected10[i]-ptr[i])<1e-12);
2324             pass
2325         #
2326         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2327         f1.setMesh(m1);
2328         array=DataArrayDouble.New();
2329         array.setValues(arr,m1.getNumberOfCells(),3);
2330         f1.setArray(array);
2331         res=f1.integral(False);
2332         for i in xrange(3):
2333             self.assertTrue(abs(sqrt(2.)*expected4[i]-res[i])<1e-12);
2334             pass
2335         res=f1.integral(True);
2336         for i in xrange(3):
2337             self.assertTrue(abs(sqrt(2.)*expected4[i]-res[i])<1e-12);
2338             pass
2339         res=f1.normL1();
2340         for i in xrange(3):
2341             self.assertTrue(abs(expected5[i]-res[i])<1e-12);
2342             pass
2343         res=f1.normL2();
2344         for i in xrange(3):
2345             self.assertTrue(abs(expected7[i]-res[i])<1e-12);
2346             pass
2347         pass
2348
2349     def testAreaBary2D(self):
2350         m1=MEDCouplingDataForTest.build2DTargetMesh_3();
2351         f1=m1.getMeasureField(False);
2352         self.assertEqual(10,f1.getArray().getNumberOfTuples());
2353         self.assertEqual(1,f1.getNumberOfComponents());
2354         expected1=[-0.5,-1,-1.5,-0.5,-1,  0.5,1,1.5,0.5,1]
2355         ptr=f1.getArray().getValues();
2356         for i in xrange(10):
2357             self.assertTrue(abs(expected1[i]-ptr[i])<1e-12);
2358             pass
2359         f1=m1.getMeasureField(True);
2360         ptr=f1.getArray().getValues();
2361         for i in xrange(10):
2362             self.assertTrue(abs(abs(expected1[i])-ptr[i])<1e-12);
2363             pass
2364         f2=m1.getBarycenterAndOwner();
2365         self.assertEqual(10,f2.getNumberOfTuples());
2366         self.assertEqual(2,f2.getNumberOfComponents());
2367         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]
2368         ptr=f2.getValues();
2369         for i in xrange(20):
2370             self.assertTrue(abs(expected2[i]-ptr[i])<1e-12);
2371             pass
2372         m1.changeSpaceDimension(3);
2373         f1=m1.getMeasureField(False);
2374         self.assertEqual(10,f1.getArray().getNumberOfTuples());
2375         self.assertEqual(1,f1.getNumberOfComponents());
2376         ptr=f1.getArray().getValues();
2377         for i in xrange(10):
2378             self.assertTrue(abs(abs(expected1[i])-ptr[i])<1e-12);
2379             pass
2380         f2=m1.getBarycenterAndOwner();
2381         self.assertEqual(10,f2.getNumberOfTuples());
2382         self.assertEqual(3,f2.getNumberOfComponents());
2383         ptr=f2.getValues();
2384         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.]
2385         for i in xrange(30):
2386             self.assertTrue(abs(expected3[i]-ptr[i])<1e-12);
2387             pass
2388         pass
2389
2390     def testAreaBary3D(self):
2391         coords=[ 0.241310763507 , 0.0504777305619 , 0.0682283524903 , 0.252501053866 , -0.0625176732937 , 0.137272639894 ,
2392                  0.152262663601 , 0.241816569527 , 0.133812556197 , 0.18047750211 , -0.0789949051358 , 0.339098173401 ,
2393                  0.151741971857 , 0.238885278571 , 0.137715037333 , 0.242532155481 , -0.0928169086456 , 0.0678043417367 ,
2394                  0.240941965335 , -0.015461491464 , 0.0617186345825 , 0.24127650112 , 0.0499427876717 , 0.0679634099148 ,
2395                  -0.145828917428 , 0.206291632565 , 0.0310071927543 , 0.0125651775307 , 0.266262085828 , 0.105228430543 ,
2396                  -0.0994066533286 , 0.233224271238 , 0.0572213839567 , -0.0951345338317 , 0.234819509426 , 0.0592126284538 ,
2397                  0.136580574205 , -0.205486212579 , 0.0572866072014 , 0.0637270784978 , -0.168886355238 , 0.446614057077 ,
2398                  0.041337157151 , -0.213402568198 , 0.372407095999 , 0.0411601970268 , -0.202387875756 , 0.411334979491 ,
2399                  -0.108355701857 , 0.193636239335 , 0.204886756738 , 0.00639779029829 , 0.155296981517 , 0.252585892979 ,
2400                  0.0262473111702 , -0.112919732543 , 0.424286639249 ,-0.224103052733 , -0.139430015438 , -0.0122352295701 ,
2401                 -0.0312760589481 , -0.274272003594 , 0.0323959636568 , -0.166663422532 , -0.217754445175 , 0.00392109070364 ,
2402                  -0.30586619777 , -0.0475168041091 , -0.0144585228182 , -0.280881480586 , 0.135571293538 , 0.00623923647986 ,
2403                  -0.25548538234 , 0.156819217766 , 0.0645277879769 , -0.131567009284 , 0.184133752309 , 0.206021802753 ,
2404                  -0.196204010965 , 0.151602971681 , 0.212974777736 , -0.183713879463 , 0.0802946639531 , 0.260115662599 ,
2405                  -0.244241178767 , -0.0738873389604 , 0.144590565817 , -0.155804057829 , -0.164892720025 , 0.210613950558 ,
2406                  -0.170950800428 , -0.215099334026 , 0.00610122860092 , -0.30552634869 , -0.0490020791904 , -0.0132786533145 ,
2407                  0.271831011884 , 0.15105657296 , 0.0230534827908 , 0.281919192283 , 0.0898544306288 , -0.0625201489143 ,
2408                  0.260240727276 , -0.0120688706637 , -0.0532316588626 , 0.244947737722 , 0.0197984684293 , 0.0309341209233 ,
2409                  0.23439631578 , 0.229825279875 , 0.0508520585381 , 0.160921316875 , 0.265078502128 , 0.121716560626 ,
2410                  -0.315088694175 , 0.0747700471918 , -0.245836615071 , -0.327728781776 , 0.0857114674649 , -0.239431905957 ,
2411                  -0.308385460634 , 0.145142997084 , -0.149886828433 , 0.0488236045164 , 0.309462801914 , 0.0849169148265 ,
2412                 -0.0244964803395 , 0.33145611751 , -0.0476415818061 , 0.0060567994229 , 0.32418412014 , 0.0367779543812 ,
2413                  -0.0950221448063 , 0.236675326003 , 0.0572594453983 , 0.248723023186 , 0.0886648784791 , -0.176629430538 ,
2414                  0.116796984 , 0.256596599567 , -0.292863523603 , 0.118024552914 , 0.229154257843 , -0.34233232501 ,
2415                  0.217507892549 , -0.0417822335742 , -0.176771782888 , -0.224429321304 , 0.0125595300114 , -0.362064725588 ,
2416                  0.0937301100955 , -0.0500824832657 , -0.299713548444 , -0.244162220397 , 0.0383853931293 , -0.389856984411 ,
2417                  -0.0281989366102 , 0.097392811563 , -0.458244577284 , -0.385010847162 , 0.10122766194 , -0.140052859922 ,
2418                  -0.377936358012 , 0.110875172128 , -0.176207095463 , 0.244483045556 , -0.0991073977045 , 0.0575134372934 ,
2419                 0.262605120167 , -0.100243191645 , -0.0495620806935 , 0.240306880972 , -0.136153701579 , -0.114745281696 ,
2420                  0.215763176129 , -0.0836766059189 , -0.183249640616 , 0.237870396603 , -0.132449578286 , -0.121598854639 ,
2421                  -0.0637683083097 , -0.27921020214 , -0.149112321992 , -0.0856211014977 , -0.2973233473 , -0.0446878139589 ,
2422                  0.104675342288 , -0.0625908305324 , -0.290346256534 , 0.0248264249186 , -0.247797708548 , -0.165830884019 ,
2423                  0.0719302438309 , -0.178468260473 , -0.211432157345 , 0.142871843159 , -0.208769948542 , 0.0454101128246 ,
2424                  0.167803379307 , -0.207851396623 , -0.088802726124 , 0.12868717152 , -0.230920439715 , 0.00760508389036 ,
2425                  -0.0372812069535 , -0.286740286332 , 0.00963701291166 ]
2426         
2427         connN = [ #polyhedron 0
2428             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
2429             , 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
2430             , 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
2431             , 22 , 19 , 21 , 30 , 31 , -1 , 22 , 31 , 28 , 27 , 26 , 24 , 23 , -1 , 31 , 30 , 29 , 28,
2432             # polyhedron 1
2433             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
2434             , 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
2435             , 33 , 34 , 48 , 45 , -1 , 35 , 34 , 48 , 50 , 49 , 38 , -1 , 41 , 43 , 42 , 46 , 36 , 37 , -1 , 38 , 39 , 51 , 49 , -1
2436             , 39 , 40 , 42 , 46 , 47 , 52 , 51 , -1 , 45 , 47 , 52 , 50 , 48 , -1 , 52 , 51 , 49 , 50,
2437             # polyhedron 2
2438             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
2439             , 23 , 53 , 54 , 40 , 8 , -1 , 53 , 22 , 23 , -1 , 39 , 54 , 40,
2440             # polyhedron 3
2441             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
2442             , 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
2443             , 55 , 5 , 12 , 65 , -1 , 66 , 67 , 65 , 55 , 56 , 57 , -1 , 63 , 66 , 57 , 59 , 64 , -1 , 64 , 62 , 58 , 59 , -1
2444             , 60 , 63 , 66 , 67 , 68 , 61 , -1 , 61 , 68 , 20 , 21 , -1 , 67 , 68 , 20 , 12 , 65]
2445         
2446         barys = [ -0.0165220465527 , -0.0190922868195 , 0.158882733414 ,
2447                   0.0287618656076 , 0.135874379934 , -0.14601588119 ,
2448                   -0.147128055553 , 0.0465995097041 , -0.049391174453 ,
2449                   -0.00142506732317 , -0.0996953090351 , -0.115159183132 ]
2450         meshN=MEDCouplingUMesh.New();
2451         meshN.setName("ForBary");
2452         meshN.setMeshDimension(3);
2453         meshN.allocateCells(4);
2454         meshN.insertNextCell(NORM_POLYHED,113,connN);
2455         meshN.insertNextCell(NORM_POLYHED,99,connN[113:]);
2456         meshN.insertNextCell(NORM_POLYHED,43,connN[212:]);
2457         meshN.insertNextCell(NORM_POLYHED,92,connN[255:]);
2458         meshN.finishInsertingCells();
2459         myCoords=DataArrayDouble.New();
2460         myCoords.setValues(coords,69,3);
2461         meshN.setCoords(myCoords);
2462         meshN.checkCoherency();
2463         res1=meshN.arePolyhedronsNotCorrectlyOriented();
2464         meshN.orientCorrectlyPolyhedrons();
2465         res1=meshN.arePolyhedronsNotCorrectlyOriented();
2466         self.assertTrue(len(res1)==0);
2467         #
2468         da=meshN.getBarycenterAndOwner();
2469         self.assertEqual(4,da.getNumberOfTuples());
2470         self.assertEqual(3,da.getNumberOfComponents());
2471         daPtr=da.getValues();
2472         for i in xrange(12):
2473             self.assertTrue(abs(barys[i]-daPtr[i])<1e-12);
2474             pass
2475         pass
2476
2477     def testRenumberCellsForFields(self):
2478         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2479         f=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2480         f.setMesh(m);
2481         arr=DataArrayDouble.New();
2482         nbOfCells=m.getNumberOfCells();
2483         values1=[7.,107.,10007.,8.,108.,10008.,9.,109.,10009.,10.,110.,10010.,11.,111.,10011.]
2484         arr.setValues(values1,nbOfCells,3);
2485         f.setArray(arr);
2486         renumber1=[3,1,0,4,2]
2487         loc=[-0.05,-0.05, 0.55,-0.25, 0.55,0.15, -0.05,0.45, 0.45,0.45]
2488         for j in xrange(5):
2489             res=f.getValueOn(loc[2*j:2*j+2]);
2490             for i in xrange(3):
2491                 self.assertTrue(abs(values1[i+3*j]-res[i])<1e-12);
2492                 pass
2493             pass
2494         f.renumberCells(renumber1,False);
2495         ptr=f.getArray().getValues();
2496         expected1=[9.,109.,10009.,8.,108.,10008.,11.,111.,10011.,7.,107.,10007.,10.,110.,10010.]
2497         for i in xrange(15):
2498             self.assertTrue(abs(expected1[i]-ptr[i])<1e-12);
2499             pass
2500         #check that fields remains the same geometrically
2501         for j in xrange(5):
2502             res=f.getValueOn(loc[2*j:2*(j+1)]);
2503             for i in xrange(3):
2504                 self.assertTrue(abs(values1[i+3*j]-res[i])<1e-12);
2505                 pass
2506             pass
2507         #On gauss
2508         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,NO_TIME);
2509         f.setMesh(m);
2510         _a=0.446948490915965;
2511         _b=0.091576213509771;
2512         _p1=0.11169079483905;
2513         _p2=0.0549758718227661;
2514         refCoo1=[ 0.,0., 1.,0., 0.,1. ]
2515         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 ];
2516         wg1=[ 4*_p2, 4*_p2, 4*_p2, 4*_p1, 4*_p1, 4*_p1 ]
2517         _refCoo1=refCoo1[0:6];
2518         _gsCoo1=gsCoo1[0:12];
2519         _wg1=wg1[0:6];
2520         f.setGaussLocalizationOnType(NORM_TRI3,_refCoo1,_gsCoo1,_wg1);
2521         refCoo2=[ 0.,0., 1.,0., 1.,1., 0.,1. ]
2522         _refCoo2=refCoo2[0:8];
2523         _gsCoo1=_gsCoo1[0:4]
2524         _wg1=_wg1[0:2]
2525         f.setGaussLocalizationOnType(NORM_QUAD4,_refCoo2,_gsCoo1,_wg1);
2526         arr=DataArrayDouble.New();
2527         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.]
2528         arr.setValues(values2,18,2);
2529         f.setArray(arr);
2530         f.checkCoherency();
2531         fCpy=f.clone(True);
2532         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2533         f.renumberCells(renumber1,False);
2534         self.assertTrue(not f.isEqual(fCpy,1e-12,1e-12));
2535         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.]
2536         ptr=f.getArray().getValues();
2537         for i in xrange(36):
2538             self.assertTrue(abs(expected2[i]-ptr[i])<1e-12);
2539             pass
2540         renumber2=[2,1,4,0,3]
2541         f.renumberCells(renumber2,False);
2542         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2543         #GaussNE
2544         f=MEDCouplingFieldDouble.New(ON_GAUSS_NE,NO_TIME);
2545         f.setMesh(m);
2546         arr=DataArrayDouble.New();
2547         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.]
2548         arr.setValues(values3,18,2);
2549         f.setArray(arr);
2550         f.checkCoherency();
2551         fCpy=f.clone(True);
2552         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2553         f.renumberCells(renumber1,False);
2554         self.assertTrue(not f.isEqual(fCpy,1e-12,1e-12));
2555         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.]
2556         ptr=f.getArray().getValues();
2557         for i in xrange(36):
2558             self.assertTrue(abs(expected3[i]-ptr[i])<1e-12);
2559             pass
2560         f.renumberCells(renumber2,False);#perform reverse operation of renumbering to check that the resulting field is equal.
2561         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2562         #
2563         pass
2564
2565     def testRenumberNodesForFields(self):
2566         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2567         f=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
2568         f.setMesh(m);
2569         self.assertEqual(9,f.getNumberOfMeshPlacesExpected());
2570         arr=DataArrayDouble.New();
2571         nbOfNodes=m.getNumberOfNodes();
2572         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.]
2573         arr.setValues(values1,nbOfNodes,3);
2574         f.setArray(arr);
2575         f.checkCoherency();
2576         renumber1=[0,4,1,3,5,2,6,7,8]
2577         loc=[0.5432,-0.2432, 0.5478,0.1528]
2578         expected1=[9.0272, 109.0272, 10009.0272, 11.4124,111.4124,10011.4124]
2579         for j in xrange(2):
2580             res=f.getValueOn(loc[2*j:2*j+2]);
2581             for i in xrange(3):
2582                 self.assertTrue(abs(expected1[i+3*j]-res[i])<1e-12);
2583                 pass
2584             pass
2585         fCpy=f.clone(True);
2586         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2587         f.renumberNodes(renumber1);
2588         self.assertTrue(not f.isEqual(fCpy,1e-12,1e-12));
2589         for j in xrange(2):
2590             res=f.getValueOn(loc[2*j:2*j+2]);
2591             for i in xrange(3):
2592                 self.assertTrue(abs(expected1[i+3*j]-res[i])<1e-12);
2593                 pass
2594             pass
2595         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.]
2596         for i in xrange(27):
2597             self.assertTrue(abs(expected2[i]-f.getArray().getValues()[i])<1e-12);
2598             pass
2599         renumber2=[0,2,5,3,1,4,6,7,8]
2600         f.renumberNodes(renumber2);
2601         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2602         pass
2603
2604     def testConvertQuadraticCellsToLinear(self):
2605         mesh=MEDCouplingDataForTest.build2DTargetMesh_3();
2606         mesh.checkCoherency();
2607         types=mesh.getAllTypes();
2608         types.sort()
2609         self.assertEqual(5,len(types));
2610         expected1=[NORM_POLYGON, NORM_TRI3, NORM_QUAD4, NORM_TRI6, NORM_QUAD8]
2611         expected1.sort()
2612         self.assertEqual(expected1,types);
2613         self.assertTrue(mesh.isPresenceOfQuadratic());
2614         self.assertEqual(62,mesh.getMeshLength());
2615         f1=mesh.getMeasureField(False);
2616         #
2617         mesh.convertQuadraticCellsToLinear();
2618         self.assertTrue(not mesh.isPresenceOfQuadratic());
2619         #
2620         mesh.checkCoherency();
2621         f2=mesh.getMeasureField(False);
2622         self.assertTrue(f1.getArray().isEqual(f2.getArray(),1e-12));
2623         self.assertEqual(48,mesh.getMeshLength());
2624         types2=mesh.getAllTypes();
2625         types2.sort()
2626         self.assertEqual(3,len(types2));
2627         expected2=[NORM_POLYGON, NORM_TRI3, NORM_QUAD4]
2628         expected2.sort()
2629         self.assertEqual(expected2,types2);
2630         pass
2631
2632     def testCheckGeoEquivalWith(self):
2633         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2634         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2635         #First test mesh1
2636         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh1,0,1e-12);#deepEqual
2637         self.assertTrue(cellCor==None);
2638         self.assertTrue(nodeCor==None);
2639         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh1,1,1e-12);#fastEqual
2640         self.assertTrue(cellCor==None);
2641         self.assertTrue(nodeCor==None);
2642         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh1,10,1e-12);#deepEqual with geo permutations
2643         self.assertTrue(cellCor==None);
2644         self.assertTrue(nodeCor==None);
2645         #Second test mesh1 and mesh2 are 2 different meshes instance
2646         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,0,1e-12);#deepEqual
2647         self.assertTrue(cellCor==None);
2648         self.assertTrue(nodeCor==None);
2649         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,1,1e-12);#fastEqual
2650         self.assertTrue(cellCor==None);
2651         self.assertTrue(nodeCor==None);
2652         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);#deepEqual with geo permutations
2653         self.assertTrue(cellCor==None);
2654         self.assertTrue(nodeCor==None);
2655         #Third test : cell permutation by keeping the first the middle and the last as it is.
2656         renum=[0,2,1,3,4,5,6,8,7,9]
2657         mesh2.renumberCells(renum,False);
2658         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12);#deepEqual fails
2659         self.assertTrue(cellCor==None);
2660         self.assertTrue(nodeCor==None);
2661         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,1,1e-12);#fastEqual do not see anything
2662         self.assertTrue(cellCor==None);
2663         self.assertTrue(nodeCor==None);
2664         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);#deepEqual with geo permutations
2665         self.assertTrue(cellCor);
2666         self.assertEqual(10,cellCor.getNumberOfTuples());
2667         self.assertEqual(1,cellCor.getNumberOfComponents());
2668         self.assertEqual(renum,list(cellCor.getValues()))
2669         self.assertTrue(nodeCor==None);
2670         cellCor=0;
2671         self.assertTrue(nodeCor==None);
2672         a,b=mesh1.checkDeepEquivalWith(mesh2,0,1e-12);
2673         self.assertEqual(renum,list(a.getValues()))
2674         self.assertTrue(b==None);
2675         mesh2.setCoords(mesh1.getCoords())
2676         a=mesh1.checkDeepEquivalOnSameNodesWith(mesh2,0,1e-12);
2677         self.assertEqual(renum,list(a.getValues()))
2678         #4th test : cell and node permutation by keeping the first the middle and the last as it is.
2679         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2680         renum2=[0,2,1,3,4,5,6,8,7,9,10]
2681         mesh2.renumberCells(renum,False);
2682         mesh2.renumberNodes(renum2,11);
2683         cellCor=None
2684         nodeCor=None
2685         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12);#deepEqual fails
2686         self.assertTrue(cellCor==None);
2687         self.assertTrue(nodeCor==None);
2688         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,1,1e-12);#fastEqual do not see anything
2689         self.assertTrue(cellCor==None);
2690         self.assertTrue(nodeCor==None);
2691         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);#deepEqual with geo permutations
2692         self.assertTrue(cellCor);
2693         self.assertEqual(10,cellCor.getNumberOfTuples());
2694         self.assertEqual(1,cellCor.getNumberOfComponents());
2695         self.assertEqual(renum,list(cellCor.getValues()))
2696         self.assertTrue(nodeCor);
2697         self.assertEqual(11,nodeCor.getNumberOfTuples());
2698         self.assertEqual(1,nodeCor.getNumberOfComponents());
2699         self.assertEqual(renum2,list(nodeCor.getValues()))
2700         cellCor=0;
2701         nodeCor=0;
2702         #5th test : modification of the last cell to check fastCheck detection.
2703         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2704         renum3=[0,2,1,3,4,5,6,8,9,7]
2705         mesh2.renumberCells(renum3,False);
2706         mesh2.renumberNodes(renum2,11);
2707         cellCor=None
2708         nodeCor=None
2709         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12)
2710         self.assertTrue(cellCor==None);
2711         self.assertTrue(nodeCor==None);
2712         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,1,1e-12)
2713         self.assertTrue(cellCor==None);
2714         self.assertTrue(nodeCor==None);
2715         cellCor,nodeCor=mesh2.checkGeoEquivalWith(mesh1,10,1e-12);#deepEqual with geo permutations
2716         self.assertTrue(cellCor!=None);
2717         self.assertEqual(10,cellCor.getNumberOfTuples());
2718         self.assertEqual(1,cellCor.getNumberOfComponents());
2719         self.assertEqual(renum3,list(cellCor.getValues()))
2720         self.assertTrue(nodeCor!=None);
2721         self.assertEqual(11,nodeCor.getNumberOfTuples());
2722         self.assertEqual(1,nodeCor.getNumberOfComponents());
2723         self.assertEqual(renum2,list(nodeCor.getValues()));
2724         pass
2725
2726     def testCheckGeoEquivalWith2(self):
2727         mesh1=MEDCouplingDataForTest.build2DTargetMesh_4();
2728         mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
2729         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);
2730         self.assertEqual(None,cellCor);
2731         self.assertNotEqual(None,nodeCor);
2732         expected1=[0, 1, 3, 4, 5, 6, 7, 8, 9]
2733         for i in xrange(9):
2734             self.assertEqual(expected1[i],nodeCor.getIJ(i,0));
2735             pass
2736         pass
2737
2738     def testCopyTinyStringsFromOnFields(self):
2739         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2740         nbOfCells=m.getNumberOfCells();
2741         f=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
2742         f.setMesh(m);
2743         self.assertEqual(5,f.getNumberOfMeshPlacesExpected());
2744         f.setName("a");
2745         f.setDescription("b");
2746         a1=DataArrayDouble.New();
2747         a1.alloc(nbOfCells,2);
2748         a1.fillWithZero();
2749         a1.setInfoOnComponent(0,"c");
2750         a1.setInfoOnComponent(1,"d");
2751         a2=a1.deepCpy();
2752         a2.setInfoOnComponent(0,"e");
2753         a2.setInfoOnComponent(1,"f");
2754         f.setArray(a1);
2755         f.setEndArray(a2);
2756         f.setEndTime(3.,3,4);
2757         m.setName("g");
2758         m.getCoords().setInfoOnComponent(0,"h");
2759         m.getCoords().setInfoOnComponent(1,"i");
2760         m.getCoords().setInfoOnComponent(2,"j");
2761         #
2762         f.checkCoherency();
2763         f2=f.clone(True);
2764         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2765         f2.setName("smth");
2766         self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2767         f2.copyTinyStringsFrom(f);
2768         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2769         f2.setDescription("GGG");
2770         self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2771         f2.copyTinyStringsFrom(f);
2772         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2773         f2.getArray().setInfoOnComponent(0,"mmmm");
2774         self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2775         f2.copyTinyStringsFrom(f);
2776         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2777         f2.getEndArray().setInfoOnComponent(1,"mmmm");
2778         self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2779         f2.copyTinyStringsFrom(f);
2780         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2781         m2=m.clone(True);
2782         self.assertTrue(m2.isEqual(m,1e-12));
2783         m2.setName("123");
2784         self.assertTrue(not m2.isEqual(m,1e-12));
2785         m2.copyTinyStringsFrom(m);
2786         self.assertTrue(m2.isEqual(m,1e-12));
2787         m2.getCoords().setInfoOnComponent(1,"eee");
2788         self.assertTrue(not m2.isEqual(m,1e-12));
2789         m2.copyTinyStringsFrom(m);
2790         self.assertTrue(m2.isEqual(m,1e-12));
2791         pass
2792
2793     def testTryToShareSameCoordsPermute(self):
2794         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2795         m2=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2796         #self.assertTrue(m.getCoords()!=m2.getCoords());
2797         m.tryToShareSameCoordsPermute(m2,1e-12);
2798         #self.assertTrue(m.getCoords()==m2.getCoords());
2799         self.assertTrue(m2.isEqual(m,1e-12));
2800         renum1=[1,2,0,5,8,7,4,3,6]
2801         r1=DataArrayInt.New()
2802         r1.setValues(renum1,len(renum1),1)
2803         m.renumberNodes(r1,9);
2804         #self.assertTrue(m.getCoords()!=m2.getCoords());
2805         self.assertTrue(not m2.isEqual(m,1e-12));
2806         m.tryToShareSameCoordsPermute(m2,1e-12);
2807         #self.assertTrue(m.getCoords()==m2.getCoords());
2808         self.assertTrue(m2.isEqual(m,1e-12));
2809         pass
2810
2811     def testTryToShareSameCoordsPermute2(self):
2812         m1=MEDCouplingDataForTest.build2DTargetMesh_4();
2813         targetCoords=[-0.3,-0.3, 0.2,-0.3, -0.3,0.2, 0.2,0.2 ]
2814         targetConn=[0,2,3,1]
2815         m2=MEDCouplingUMesh.New();
2816         m2.setMeshDimension(2);
2817         m2.allocateCells(1);
2818         m2.insertNextCell(NORM_QUAD4,targetConn[0:4])
2819         m2.finishInsertingCells();
2820         myCoords=DataArrayDouble.New();
2821         myCoords.setValues(targetCoords,4,2);
2822         m2.setCoords(myCoords);
2823         m2.checkCoherency();
2824         m1.checkCoherency();
2825         #
2826         expected1=[0.25,0.125,0.125,0.25,0.25]
2827         f1=m1.getMeasureField(False);
2828         f2=m2.getMeasureField(False);
2829         self.assertEqual(5,f1.getArray().getNumberOfTuples());
2830         self.assertEqual(1,f2.getArray().getNumberOfTuples());
2831         for i in xrange(5):
2832             self.assertAlmostEqual(expected1[i],f1.getIJ(i,0),12);
2833             pass
2834         self.assertAlmostEqual(expected1[0],f2.getIJ(0,0),12);
2835         self.assertRaises(InterpKernelException,m1.tryToShareSameCoordsPermute,m2,1e-12);# <- here in this order the sharing is impossible.
2836         # Let's go for deeper test of tryToShareSameCoordsPermute
2837         m2.tryToShareSameCoordsPermute(m1,1e-12);
2838         f1=m1.getMeasureField(False);
2839         f2=m2.getMeasureField(False);
2840         self.assertEqual(5,f1.getArray().getNumberOfTuples());
2841         self.assertEqual(1,f2.getArray().getNumberOfTuples());
2842         for i in xrange(5):
2843             self.assertAlmostEqual(expected1[i],f1.getIJ(i,0),12);
2844             pass
2845         self.assertAlmostEqual(expected1[0],f2.getIJ(0,0),12);
2846         pass
2847
2848     def testChangeUnderlyingMesh1(self):
2849         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2850         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2851         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2852         f1.setMesh(mesh1);
2853         array=DataArrayDouble.New();
2854         arr=[7., 107., 8., 108., 9., 109., 10., 110., 11., 111., 12., 112., 13., 113., 14., 114., 15., 115., 16., 116.]
2855         array.setValues(arr,mesh1.getNumberOfCells(),2);
2856         f1.setArray(array);
2857         #
2858         renum=[0,2,1,3,4,5,6,8,7,9]
2859         mesh2.renumberCells(renum,False);
2860         #self.assertTrue(f1.getMesh()==mesh1);
2861         f1.changeUnderlyingMesh(mesh1,10,1e-12);# nothing done only to check that nothing done.
2862         #self.assertTrue(f1.getMesh()==mesh1);
2863         f1.changeUnderlyingMesh(mesh2,10,1e-12);
2864         #self.assertTrue(f1.getMesh()==mesh2);
2865         expected1=[7.,107.,9.,109.,8.,108.,10.,110.,11.,111.,12.,112.,13.,113.,15.,115.,14.,114.,16.,116.]
2866         for i in xrange(20):
2867             self.assertAlmostEqual(expected1[i],f1.getArray().getIJ(0,i),12);
2868             pass
2869         #
2870         f1=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
2871         f1.setMesh(mesh1);
2872         array=DataArrayDouble.New();
2873         arr2=[7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.,17.,117.]
2874         array.setValues(arr2,mesh1.getNumberOfNodes(),2);
2875         f1.setArray(array);
2876         #
2877         renum2=[0,2,10,3,4,5,6,8,7,9,1]
2878         mesh2.renumberNodes(renum2,11);
2879         #self.assertTrue(f1.getMesh()==mesh1);
2880         f1.changeUnderlyingMesh(mesh2,10,1e-12);
2881         #self.assertTrue(f1.getMesh()==mesh2);
2882         expected2=[7.,107.,17.,117.,8.,108.,10.,110.,11.,111.,12.,112.,13.,113.,15.,115.,14.,114.,16.,116.,9.,109.]
2883         for i in xrange(22):
2884             self.assertAlmostEqual(expected2[i],f1.getArray().getIJ(0,i),12);
2885             pass
2886         pass
2887
2888     def testGetMaxValue1(self):
2889         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2890         nbOfCells=m.getNumberOfCells();
2891         f=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
2892         f.setMesh(m);
2893         a1=DataArrayDouble.New();
2894         val1=[3.,4.,5.,6.,7.]
2895         a1.setValues(val1,nbOfCells,1);
2896         a2=DataArrayDouble.New();
2897         val2=[0.,1.,2.,8.,7.]
2898         a2.setValues(val2,nbOfCells,1);
2899         f.setArray(a1);
2900         f.setEndArray(a2);
2901         f.setEndTime(3.,3,4);
2902         f.checkCoherency();
2903         #
2904         self.assertAlmostEqual(8.,f.getMaxValue(),14);
2905         self.assertAlmostEqual(0.,f.getMinValue(),14);
2906         self.assertAlmostEqual(5.,f.getAverageValue(),14);
2907         self.assertAlmostEqual(5.125,f.getWeightedAverageValue(0,True),14);
2908         a1.setIJ(0,2,9.5);
2909         self.assertAlmostEqual(9.5,f.getMaxValue(),14);
2910         self.assertAlmostEqual(0.,f.getMinValue(),14);
2911         a2.setIJ(0,0,9.);
2912         self.assertAlmostEqual(9.5,f.getMaxValue(),14);
2913         self.assertAlmostEqual(1.,f.getMinValue(),14);
2914         pass
2915
2916     def testSubstractInPlaceDM1(self):
2917         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2918         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2919         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2920         f1.setMesh(mesh1);
2921         array=DataArrayDouble.New();
2922         arr=[7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.]
2923         array.setValues(arr,mesh1.getNumberOfCells(),2);
2924         f1.setArray(array);
2925         #
2926         self.assertEqual(10,f1.getNumberOfTuples());
2927         self.assertEqual(2,f1.getNumberOfComponents());
2928         self.assertEqual(20,f1.getNumberOfValues());
2929         #
2930         renum=[0,2,3,1,4,5,6,8,7,9]
2931         mesh2.renumberCells(renum,False);
2932         #
2933         f2=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2934         f2.setMesh(mesh2);
2935         array=DataArrayDouble.New();
2936         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]
2937         array.setValues(arr2,mesh2.getNumberOfCells(),2);
2938         f2.setArray(array);
2939         #
2940         f1.substractInPlaceDM(f2,10,1e-12);
2941         f1.applyFunc(1,"abs(x+y+0.2)");
2942         self.assertAlmostEqual(0.,f1.getMaxValue(),13);
2943         pass
2944
2945     def testDotCrossProduct1(self):
2946         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2947         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
2948         f1.setTime(2.3,5,6);
2949         f1.setMesh(mesh1);
2950         array=DataArrayDouble.New();
2951         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.]
2952         array.setValues(arr1,mesh1.getNumberOfCells(),3);
2953         f1.setArray(array);
2954         f2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
2955         f2.setTime(7.8,4,5);
2956         f2.setMesh(mesh1);
2957         array=DataArrayDouble.New();
2958         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.]
2959         array.setValues(arr2,mesh1.getNumberOfCells(),3);
2960         f2.setArray(array);
2961         #
2962         f3=f1.dot(f2);
2963         expected1=[842.,1820.,2816.,3830.,4862.,5912.,6980.,8066.,9170.,10292.]
2964         for i in xrange(10):
2965             self.assertAlmostEqual(expected1[i],f3.getIJ(i,0),9);
2966             pass
2967         #
2968         f4=f1.crossProduct(f2);
2969         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.]
2970         for i in xrange(30):
2971             self.assertAlmostEqual(expected2[i],f4.getIJ(0,i),9);
2972             pass
2973         pass
2974
2975     def testMinMaxFields1(self):
2976         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2977         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
2978         f1.setTime(2.3,5,6);
2979         f1.setMesh(mesh1);
2980         array=DataArrayDouble.New();
2981         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.]
2982         array.setValues(arr1,mesh1.getNumberOfCells(),3);
2983         f1.setArray(array);
2984         f2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
2985         f2.setTime(7.8,4,5);
2986         f2.setMesh(mesh1);
2987         array=DataArrayDouble.New();
2988         arr2=[6.,108.,206.,9.,107.,209.,8.,110.,208.,11.,109.,211.,10.,112.,210.,13.,111.,213.,12.,114.,212.,15.,113.,215.,14.,116.,214.,17.,115.,217.]
2989         array.setValues(arr2,mesh1.getNumberOfCells(),3);
2990         f2.setArray(array);
2991         #
2992         f3=f1.max(f2);
2993         expected1=[7.,108.,207.,9.,108.,209.,9.,110.,209.,11.,110.,211.,11.,112.,211.,13.,112.,213.,13.,114.,213.,15.,114.,215.,15.,116.,215.,17.,116.,217.]
2994         for i in xrange(30):
2995             self.assertAlmostEqual(expected1[i],f3.getIJ(0,i),9);
2996             pass
2997         #
2998         f4=f1.min(f2);
2999         expected2=[6.,107.,206.,8.,107.,208.,8.,109.,208.,10.,109.,210.,10.,111.,210.,12.,111.,212.,12.,113.,212.,14.,113.,214.,14.,115.,214.,16.,115.,216.]
3000         for i in xrange(30):
3001             self.assertAlmostEqual(expected2[i],f4.getIJ(0,i),9);
3002             pass
3003         #
3004         pass
3005
3006     def testApplyLin1(self):
3007         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
3008         f1=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
3009         f1.setMesh(mesh1);
3010         array=DataArrayDouble.New();
3011         arr=[7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.]
3012         array.setValues(arr,mesh1.getNumberOfCells(),2);
3013         f1.setArray(array);
3014         #
3015         f1.applyLin(2.,3.,0);
3016         expected1=[17.,107.,19.,108.,21.,109.,23.,110.,25.,111.,27.,112.,29.,113.,31.,114.,33.,115.,35.,116.]
3017         for i in xrange(20):
3018             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),9);
3019             pass
3020         #
3021         arr2=[2.,102.,3.,103.,4.,104.,5.,105.,6.,106.,7.,107.,8.,108.,9.,109.,10.,110.,11.,111.]
3022         array=DataArrayDouble.New();
3023         array.setValues(arr2,mesh1.getNumberOfCells(),2);
3024         f1.setEndArray(array);
3025         #
3026         f1.applyLin(4.,5.,1);
3027         #
3028         expected2=[17.,433.,19.,437.,21.,441.,23.,445.,25.,449.,27.,453.,29.,457.,31.,461.,33.,465.,35.,469.]
3029         for i in xrange(20):
3030             self.assertAlmostEqual(expected2[i],f1.getIJ(0,i),9);
3031             pass
3032         expected3=[2.,413.,3.,417.,4.,421.,5.,425.,6.,429.,7.,433.,8.,437.,9.,441.,10.,445.,11.,449.]
3033         for i in xrange(20):
3034             self.assertAlmostEqual(expected3[i],f1.getEndArray().getIJ(0,i),9);
3035             pass
3036         #
3037         pass
3038
3039     def testGetIdsInRange1(self):
3040         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
3041         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3042         f1.setTime(2.3,5,6);
3043         f1.setMesh(mesh1);
3044         array=DataArrayDouble.New();
3045         arr1=[2.,8.,6.,5.,11.,7.,9.,3.,10.,4.]
3046         array.setValues(arr1,mesh1.getNumberOfCells(),1);
3047         f1.setArray(array);
3048         #
3049         f1.checkCoherency();
3050         da=f1.getIdsInRange(2.9,7.1);
3051         self.failUnlessEqual(5,da.getNbOfElems());
3052         expected1=[2,3,5,7,9]
3053         self.failUnlessEqual(expected1,list(da.getValues()));
3054         da=f1.getIdsInRange(8.,12.);
3055         self.failUnlessEqual(4,da.getNbOfElems());
3056         expected2=[1,4,6,8]
3057         self.failUnlessEqual(expected2,list(da.getValues()));
3058         #
3059         pass
3060
3061     def testBuildSubPart1(self):
3062         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3063         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3064         f1.setTime(2.3,5,6);
3065         f1.setMesh(mesh1);
3066         array=DataArrayDouble.New();
3067         arr1=[3.,103.,4.,104.,5.,105.,6.,106.,7.,107.]
3068         array.setValues(arr1,mesh1.getNumberOfCells(),2);
3069         f1.setArray(array);
3070         #
3071         part1=[2,1,4]
3072         f2=f1[part1];
3073         f2.zipCoords()
3074         self.failUnlessEqual(3,f2.getNumberOfTuples());
3075         self.failUnlessEqual(2,f2.getNumberOfComponents());
3076         expected1=[5.,105.,4.,104.,7.,107.]
3077         for i in xrange(6):
3078             self.assertAlmostEqual(f2.getIJ(0,i),expected1[i],12);
3079             pass
3080         self.failUnlessEqual(3,f2.getMesh().getNumberOfCells());
3081         self.failUnlessEqual(6,f2.getMesh().getNumberOfNodes());
3082         self.failUnlessEqual(2,f2.getMesh().getSpaceDimension());
3083         self.failUnlessEqual(2,f2.getMesh().getMeshDimension());
3084         m2C=f2.getMesh();
3085         self.failUnlessEqual(13,m2C.getMeshLength());
3086         expected2=[0.2, -0.3, 0.7, -0.3, 0.2, 0.2, 0.7, 0.2, 0.2, 0.7, 0.7, 0.7]
3087         for i in xrange(12):
3088             self.assertAlmostEqual(expected2[i],m2C.getCoords().getIJ(0,i),12);
3089             pass
3090         expected3=[3,2,3,1,3,0,2,1,4,4,5,3,2]
3091         self.failUnlessEqual(expected3,list(m2C.getNodalConnectivity().getValues()));
3092         expected4=[0,4,8,13]
3093         self.failUnlessEqual(expected4,list(m2C.getNodalConnectivityIndex().getValues()));
3094         # Test with field on nodes.
3095         f1=MEDCouplingFieldDouble.New(ON_NODES,ONE_TIME);
3096         f1.setTime(2.3,5,6);
3097         f1.setMesh(mesh1);
3098         array=DataArrayDouble.New();
3099         arr2=[3.,103.,4.,104.,5.,105.,6.,106.,7.,107.,8.,108.,9.,109.,10.,110.,11.,111.]
3100         array.setValues(arr2,mesh1.getNumberOfNodes(),2);
3101         f1.setArray(array);
3102         part2=[1,2]
3103         f2=f1.buildSubPart(part2);
3104         self.failUnlessEqual(4,f2.getNumberOfTuples());
3105         self.failUnlessEqual(2,f2.getNumberOfComponents());
3106         expected5=[4.,104.,5.,105.,7.,107.,8.,108.]
3107         for i in xrange(8):
3108             self.assertAlmostEqual(f2.getIJ(0,i),expected5[i],12);
3109             pass
3110         self.failUnlessEqual(2,f2.getMesh().getNumberOfCells());
3111         self.failUnlessEqual(4,f2.getMesh().getNumberOfNodes());
3112         self.failUnlessEqual(2,f2.getMesh().getSpaceDimension());
3113         self.failUnlessEqual(2,f2.getMesh().getMeshDimension());
3114         m2C=f2.getMesh();
3115         self.failUnlessEqual(8,m2C.getMeshLength());
3116         for i in xrange(8):#8 is not an error
3117             self.assertAlmostEqual(expected2[i],m2C.getCoords().getIJ(0,i),12);
3118             pass
3119         self.failUnlessEqual(expected3[:4],list(m2C.getNodalConnectivity().getValues())[4:]);
3120         self.failUnlessEqual(expected3[4:8],list(m2C.getNodalConnectivity().getValues())[:4]);
3121         self.failUnlessEqual(expected4[:3],list(m2C.getNodalConnectivityIndex().getValues()));
3122         #idem previous because nodes of cell#4 are not fully present in part3
3123         part3=[1,2]
3124         arrr=DataArrayInt.New();
3125         arrr.setValues(part3,2,1);
3126         f2=f1.buildSubPart(arrr);
3127         self.failUnlessEqual(4,f2.getNumberOfTuples());
3128         self.failUnlessEqual(2,f2.getNumberOfComponents());
3129         for i in xrange(8):
3130             self.assertAlmostEqual(f2.getIJ(0,i),expected5[i],12);
3131             pass
3132         self.failUnlessEqual(2,f2.getMesh().getNumberOfCells());
3133         self.failUnlessEqual(4,f2.getMesh().getNumberOfNodes());
3134         self.failUnlessEqual(2,f2.getMesh().getSpaceDimension());
3135         self.failUnlessEqual(2,f2.getMesh().getMeshDimension());
3136         m2C=f2.getMesh();
3137         self.failUnlessEqual(8,m2C.getMeshLength());
3138         for i in xrange(8):#8 is not an error
3139             self.assertAlmostEqual(expected2[i],m2C.getCoords().getIJ(0,i),12);
3140             pass
3141         self.failUnlessEqual(expected3[:4],list(m2C.getNodalConnectivity().getValues())[4:8]);
3142         self.failUnlessEqual(expected3[4:8],list(m2C.getNodalConnectivity().getValues())[:4]);
3143         self.failUnlessEqual(expected4[:3],list(m2C.getNodalConnectivityIndex().getValues()));
3144         #
3145         part4=[1,2,4]
3146         f2=f1.buildSubPart(part4);
3147         self.failUnlessEqual(6,f2.getNumberOfTuples());
3148         self.failUnlessEqual(2,f2.getNumberOfComponents());
3149         expected6=[4.,104.,5.,105.,7.,107.,8.,108.,10.,110.,11.,111.]
3150         for i in xrange(12):
3151             self.assertAlmostEqual(f2.getIJ(0,i),expected6[i],12);
3152             pass
3153         self.failUnlessEqual(3,f2.getMesh().getNumberOfCells());
3154         self.failUnlessEqual(6,f2.getMesh().getNumberOfNodes());
3155         self.failUnlessEqual(2,f2.getMesh().getSpaceDimension());
3156         self.failUnlessEqual(2,f2.getMesh().getMeshDimension());
3157         m2C=f2.getMesh();
3158         self.failUnlessEqual(13,m2C.getMeshLength());
3159         for i in xrange(12):
3160             self.assertAlmostEqual(expected2[i],m2C.getCoords().getIJ(0,i),12);
3161             pass
3162         self.failUnlessEqual(expected3[0:4],list(m2C.getNodalConnectivity().getValues())[4:8]);
3163         self.failUnlessEqual(expected3[4:8],list(m2C.getNodalConnectivity().getValues())[0:4]);
3164         self.failUnlessEqual(expected3[8:13],list(m2C.getNodalConnectivity().getValues())[8:13]);
3165         self.failUnlessEqual(expected4,list(m2C.getNodalConnectivityIndex().getValues()));
3166         pass
3167
3168     def testDoublyContractedProduct1(self):
3169         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3170         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3171         f1.setMesh(mesh1);
3172         array=DataArrayDouble.New();
3173         arr1=[7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5]
3174         array.setValues(arr1,mesh1.getNumberOfCells(),6);
3175         f1.setArray(array);
3176         f1.checkCoherency();
3177         #
3178         f2=f1.doublyContractedProduct();
3179         f2.checkCoherency();
3180         self.assertEqual(1,f2.getNumberOfComponents());
3181         self.assertEqual(5,f2.getNumberOfTuples());
3182         for i in xrange(5):
3183             self.assertAlmostEqual(3906.56,f2.getIJ(i,0),9);
3184             pass
3185         #
3186         pass
3187
3188     def testDeterminant1(self):
3189         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3190         f1=MEDCouplingFieldDouble.New(ON_CELLS,CONST_ON_TIME_INTERVAL);
3191         f1.setTime(2.3,5,6);
3192         f1.setEndTime(3.8,7,3);
3193         f1.setMesh(mesh1);
3194         array=DataArrayDouble.New();
3195         arr1=[1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5]
3196         array.setValues(arr1,mesh1.getNumberOfCells(),4);
3197         f1.setArray(array);
3198         #4 components
3199         f1.checkCoherency();
3200         f2=f1.determinant();
3201         f2.checkCoherency();
3202         self.assertEqual(CONST_ON_TIME_INTERVAL,f2.getTimeDiscretization());
3203         self.assertEqual(1,f2.getNumberOfComponents());
3204         self.assertEqual(5,f2.getNumberOfValues());
3205         for i in xrange(5):
3206             self.assertAlmostEqual(-2.42,f2.getIJ(i,0),13);
3207             pass
3208         #6 components multi arrays with end array not defined
3209         f1=MEDCouplingFieldDouble.New(ON_NODES,LINEAR_TIME);
3210         f1.setTime(2.3,5,6);
3211         f1.setEndTime(3.8,7,3);
3212         f1.setMesh(mesh1);
3213         array=DataArrayDouble.New();
3214         arr2=[1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7,
3215               1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7]
3216         array.setValues(arr2,mesh1.getNumberOfNodes(),6);
3217         f1.setArray(array);
3218         self.assertRaises(InterpKernelException,f1.checkCoherency);#no end array specified !
3219         #
3220         f2=f1.determinant();
3221         self.assertEqual(LINEAR_TIME,f2.getTimeDiscretization());
3222         self.assertEqual(1,f2.getArray().getNumberOfComponents());
3223         self.assertEqual(9,f2.getNumberOfTuples());
3224         for i in xrange(9):
3225             self.assertAlmostEqual(137.335,f2.getIJ(i,0),10);
3226             pass
3227         #6 components multi arrays with end array defined
3228         array=DataArrayDouble.New();
3229         arr3=[7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5,
3230               7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5]
3231         array.setValues(arr3,mesh1.getNumberOfNodes(),6);
3232         f1.setEndArray(array);
3233         f1.checkCoherency();
3234         f2=f1.determinant();
3235         f2.checkCoherency();
3236         self.assertEqual(LINEAR_TIME,f2.getTimeDiscretization());
3237         self.assertEqual(1,f2.getNumberOfComponents());
3238         self.assertEqual(9,f2.getNumberOfTuples());
3239         time2,it,order=f2.getTime()
3240         self.assertAlmostEqual(2.3,time2,12);
3241         self.assertEqual(5,it);
3242         self.assertEqual(6,order);
3243         time2,it,order=f2.getEndTime()
3244         self.assertAlmostEqual(3.8,time2,12);
3245         self.assertEqual(7,it);
3246         self.assertEqual(3,order);
3247         for i in xrange(9):
3248             self.assertAlmostEqual(137.335,f2.getIJ(i,0),10);
3249             self.assertAlmostEqual(1289.685,f2.getEndArray().getIJ(i,0),9);
3250             pass
3251         #9 components
3252         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3253         f1.setTime(7.8,10,2);
3254         f1.setMesh(mesh1);
3255         array=DataArrayDouble.New();
3256         arr4=[1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1]
3257         array.setValues(arr4,mesh1.getNumberOfCells(),9);
3258         f1.setArray(array);
3259         #
3260         f1.checkCoherency();
3261         f2=f1.determinant();
3262         f2.checkCoherency();
3263         self.assertEqual(ONE_TIME,f2.getTimeDiscretization());
3264         self.assertEqual(1,f2.getNumberOfComponents());
3265         self.assertEqual(5,f2.getNumberOfTuples());
3266         time2,it,order=f2.getTime()
3267         self.assertAlmostEqual(7.8,time2,12);
3268         self.assertEqual(10,it);
3269         self.assertEqual(2,order);
3270         for i in xrange(5):
3271             self.assertAlmostEqual(3.267,f2.getIJ(i,0),13);
3272             pass
3273         pass
3274
3275     def testEigenValues1(self):
3276         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3277         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3278         f1.setMesh(mesh1);
3279         array=DataArrayDouble.New();
3280         arr1=[1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7]
3281         array.setValues(arr1,mesh1.getNumberOfCells(),6);
3282         f1.setArray(array);
3283         f1.checkCoherency();
3284         #
3285         f2=f1.eigenValues();
3286         f2.checkCoherency();
3287         self.assertEqual(3,f2.getNumberOfComponents());
3288         self.assertEqual(5,f2.getNumberOfTuples());
3289         expected1=[13.638813677891717,-4.502313844635971,-2.2364998332557486]
3290         for i in xrange(5):
3291             self.assertAlmostEqual(expected1[0],f2.getIJ(i,0),13);
3292             self.assertAlmostEqual(expected1[1],f2.getIJ(i,1),13);
3293             self.assertAlmostEqual(expected1[2],f2.getIJ(i,2),13);
3294             pass
3295         pass
3296
3297     def testEigenVectors1(self):
3298         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3299         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3300         f1.setMesh(mesh1);
3301         array=DataArrayDouble.New();
3302         arr1=[1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7]
3303         array.setValues(arr1,mesh1.getNumberOfCells(),6);
3304         f1.setArray(array);
3305         f1.checkCoherency();
3306         #
3307         f2=f1.eigenVectors();
3308         f2.checkCoherency();
3309         self.assertEqual(9,f2.getNumberOfComponents());
3310         self.assertEqual(5,f2.getNumberOfTuples());
3311         expected1=[0.5424262364180696, 0.5351201064614425, 0.6476266283176001,#eigenvect 0
3312                    0.7381111277307373, 0.06458838384003074, -0.6715804522117897,#eigenvect 1
3313                    -0.4012053603397987, 0.8423032781211455, -0.3599436712889738#eigenvect 2
3314                    ]
3315         for i in xrange(5):
3316             self.assertAlmostEqual(expected1[0],f2.getIJ(i,0),13);
3317             self.assertAlmostEqual(expected1[1],f2.getIJ(i,1),13);
3318             self.assertAlmostEqual(expected1[2],f2.getIJ(i,2),13);
3319             self.assertAlmostEqual(expected1[3],f2.getIJ(i,3),13);
3320             self.assertAlmostEqual(expected1[4],f2.getIJ(i,4),13);
3321             self.assertAlmostEqual(expected1[5],f2.getIJ(i,5),13);
3322             self.assertAlmostEqual(expected1[6],f2.getIJ(i,6),13);
3323             self.assertAlmostEqual(expected1[7],f2.getIJ(i,7),13);
3324             self.assertAlmostEqual(expected1[8],f2.getIJ(i,8),13);
3325             pass
3326         #
3327         pass
3328
3329     def testInverse1(self):
3330         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3331         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3332         f1.setMesh(mesh1);
3333         array=DataArrayDouble.New();
3334         arr1=[1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1]
3335         array.setValues(arr1,mesh1.getNumberOfCells(),9);
3336         f1.setArray(array);
3337         f1.checkCoherency();
3338         #
3339         f2=f1.inverse();
3340         f2.checkCoherency();
3341         self.assertEqual(9,f2.getNumberOfComponents());
3342         self.assertEqual(5,f2.getNumberOfTuples());
3343         expected1=[-2.6538108356290113, 2.855831037649208, -1.1111111111111067, 3.461891643709813, -4.775022956841121, 2.2222222222222143, -1.1111111111111054, 2.222222222222214, -1.1111111111111072]
3344         for i in xrange(5):
3345             self.assertAlmostEqual(expected1[0],f2.getIJ(i,0),13);
3346             self.assertAlmostEqual(expected1[1],f2.getIJ(i,1),13);
3347             self.assertAlmostEqual(expected1[2],f2.getIJ(i,2),13);
3348             self.assertAlmostEqual(expected1[3],f2.getIJ(i,3),13);
3349             self.assertAlmostEqual(expected1[4],f2.getIJ(i,4),13);
3350             self.assertAlmostEqual(expected1[5],f2.getIJ(i,5),13);
3351             self.assertAlmostEqual(expected1[6],f2.getIJ(i,6),13);
3352             self.assertAlmostEqual(expected1[7],f2.getIJ(i,7),13);
3353             self.assertAlmostEqual(expected1[8],f2.getIJ(i,8),13);
3354             pass
3355         #
3356         array=DataArrayDouble.New();
3357         arr3=[7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5]
3358         array.setValues(arr3,mesh1.getNumberOfCells(),6);
3359         f1.setArray(array);
3360         f1.checkCoherency();
3361         #
3362         f2=f1.inverse();
3363         f2.checkCoherency();
3364         self.assertEqual(6,f2.getNumberOfComponents());
3365         self.assertEqual(5,f2.getNumberOfTuples());
3366         expected3=[-0.3617705098531818, -0.8678630828458127, -0.026843764174972983, 0.5539957431465833, 0.13133439560823013, -0.05301294502145887]
3367         for i in xrange(5):
3368             self.assertAlmostEqual(expected3[0],f2.getIJ(i,0),13);
3369             self.assertAlmostEqual(expected3[1],f2.getIJ(i,1),13);
3370             self.assertAlmostEqual(expected3[2],f2.getIJ(i,2),13);
3371             self.assertAlmostEqual(expected3[3],f2.getIJ(i,3),13);
3372             self.assertAlmostEqual(expected3[4],f2.getIJ(i,4),13);
3373             self.assertAlmostEqual(expected3[5],f2.getIJ(i,5),13);
3374             pass
3375         #
3376         array=DataArrayDouble.New();
3377         arr2=[1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5]
3378         array.setValues(arr2,mesh1.getNumberOfCells(),4);
3379         f1.setArray(array);
3380         f1.checkCoherency();
3381         #
3382         f2=f1.inverse();
3383         f2.checkCoherency();
3384         self.assertEqual(4,f2.getNumberOfComponents());
3385         self.assertEqual(5,f2.getNumberOfTuples());
3386         expected2=[-1.8595041322314059, 0.9504132231404963, 1.404958677685951, -0.49586776859504156]
3387         for i in xrange(5):
3388             self.assertAlmostEqual(expected2[0],f2.getIJ(i,0),13);
3389             self.assertAlmostEqual(expected2[1],f2.getIJ(i,1),13);
3390             self.assertAlmostEqual(expected2[2],f2.getIJ(i,2),13);
3391             self.assertAlmostEqual(expected2[3],f2.getIJ(i,3),13);
3392             pass
3393         #
3394         pass
3395
3396     def testTrace1(self):
3397         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3398         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3399         f1.setMesh(mesh1);
3400         array=DataArrayDouble.New();
3401         arr1=[1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1]
3402         array.setValues(arr1,mesh1.getNumberOfCells(),9);
3403         f1.setArray(array);
3404         f1.checkCoherency();
3405         #
3406         f2=f1.trace();
3407         f2.checkCoherency();
3408         self.assertEqual(1,f2.getNumberOfComponents());
3409         self.assertEqual(5,f2.getNumberOfTuples());
3410         for i in xrange(5):
3411             self.assertAlmostEqual(15.9,f2.getIJ(i,0),13);
3412             pass
3413         #
3414         array=DataArrayDouble.New();
3415         arr3=[7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5]
3416         array.setValues(arr3,mesh1.getNumberOfCells(),6);
3417         f1.setArray(array);
3418         f1.checkCoherency();
3419         #
3420         f2=f1.trace();
3421         f2.checkCoherency();
3422         self.assertEqual(1,f2.getNumberOfComponents());
3423         self.assertEqual(5,f2.getNumberOfTuples());
3424         for i in xrange(5):
3425             self.assertAlmostEqual(25.8,f2.getIJ(i,0),13);
3426             pass
3427         #
3428         array=DataArrayDouble.New();
3429         arr2=[1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5]
3430         array.setValues(arr2,mesh1.getNumberOfCells(),4);
3431         f1.setArray(array);
3432         f1.checkCoherency();
3433         #
3434         f2=f1.trace();
3435         f2.checkCoherency();
3436         self.assertEqual(1,f2.getNumberOfComponents());
3437         self.assertEqual(5,f2.getNumberOfTuples());
3438         for i in xrange(5):
3439             self.assertAlmostEqual(5.7,f2.getIJ(i,0),13);
3440             pass
3441         #
3442         pass
3443
3444     def testDeviator1(self):
3445         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3446         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3447         f1.setMesh(mesh1);
3448         array=DataArrayDouble.New();
3449         arr1=[1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7]
3450         array.setValues(arr1,mesh1.getNumberOfCells(),6);
3451         f1.setArray(array);
3452         f1.checkCoherency();
3453         #
3454         f2=f1.deviator();
3455         f2.checkCoherency();
3456         self.assertEqual(6,f2.getNumberOfComponents());
3457         self.assertEqual(5,f2.getNumberOfTuples());
3458         expected1=[-1.1,0.,1.1,4.5,5.6,6.7]
3459         for i in xrange(5):
3460             self.assertAlmostEqual(expected1[0],f2.getIJ(i,0),13);
3461             self.assertAlmostEqual(expected1[1],f2.getIJ(i,1),13);
3462             self.assertAlmostEqual(expected1[2],f2.getIJ(i,2),13);
3463             self.assertAlmostEqual(expected1[3],f2.getIJ(i,3),13);
3464             self.assertAlmostEqual(expected1[4],f2.getIJ(i,4),13);
3465             self.assertAlmostEqual(expected1[5],f2.getIJ(i,5),13);
3466             pass
3467         #
3468         pass
3469
3470     def testMagnitude1(self):
3471         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3472         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3473         f1.setMesh(mesh1);
3474         array=DataArrayDouble.New();
3475         arr1=[1.2,2.3,3.4,4.5,5.6, 1.2,2.3,3.4,4.5,5.6, 1.2,2.3,3.4,4.5,5.6, 1.2,2.3,3.4,4.5,5.6, 1.2,2.3,3.4,4.5,5.6]
3476         array.setValues(arr1,mesh1.getNumberOfCells(),5);
3477         f1.setArray(array);
3478         f1.checkCoherency();
3479         #
3480         f2=f1.magnitude();
3481         f2.checkCoherency();
3482         self.assertEqual(1,f2.getNumberOfComponents());
3483         self.assertEqual(5,f2.getNumberOfTuples());
3484         for i in xrange(5):
3485             self.assertAlmostEqual(8.3606219864313918,f2.getIJ(i,0),13);
3486             pass
3487         #
3488         pass
3489
3490     def testMaxPerTuple1(self):
3491         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3492         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3493         f1.setMesh(mesh1);
3494         array=DataArrayDouble.New();
3495         arr1=[1.2,2.3,3.4,4.5,5.6, 1.2,3.4,4.5,5.6,2.3, 3.4,4.5,5.6,1.2,2.3, 5.6,1.2,2.3,3.4,4.5, 4.5,5.6,1.2,2.3,3.4]
3496         array.setValues(arr1,mesh1.getNumberOfCells(),5);
3497         f1.setArray(array);
3498         f1.checkCoherency();
3499         #
3500         f2=f1.maxPerTuple();
3501         f2.checkCoherency();
3502         self.assertEqual(1,f2.getNumberOfComponents());
3503         self.assertEqual(5,f2.getNumberOfTuples());
3504         for i in xrange(5):
3505             self.assertAlmostEqual(5.6,f2.getIJ(i,0),13);
3506             pass
3507         #
3508         pass
3509
3510     def testChangeNbOfComponents(self):
3511         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3512         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3513         f1.setMesh(mesh1);
3514         array=DataArrayDouble.New();
3515         arr1=[1.2,2.3,3.4,4.5,5.6, 1.2,3.4,4.5,5.6,2.3, 3.4,4.5,5.6,1.2,2.3, 5.6,1.2,2.3,3.4,4.5, 4.5,5.6,1.2,2.3,3.4]
3516         array.setValues(arr1,mesh1.getNumberOfCells(),5);
3517         f1.setArray(array);
3518         f1.checkCoherency();
3519         #
3520         f1.changeNbOfComponents(3,7.77);
3521         f1.checkCoherency();
3522         self.assertEqual(3,f1.getNumberOfComponents());
3523         self.assertEqual(5,f1.getNumberOfTuples());
3524         expected1=[1.2,2.3,3.4, 1.2,3.4,4.5, 3.4,4.5,5.6, 5.6,1.2,2.3, 4.5,5.6,1.2]
3525         for i in xrange(15):
3526             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),13);
3527             pass
3528         f1.changeNbOfComponents(4,7.77);
3529         f1.checkCoherency();
3530         self.assertEqual(4,f1.getNumberOfComponents());
3531         self.assertEqual(5,f1.getNumberOfTuples());
3532         expected2=[1.2,2.3,3.4,7.77, 1.2,3.4,4.5,7.77, 3.4,4.5,5.6,7.77, 5.6,1.2,2.3,7.77, 4.5,5.6,1.2,7.77]
3533         for i in xrange(20):
3534             self.assertAlmostEqual(expected2[i],f1.getIJ(0,i),13);
3535             pass
3536         #
3537         pass
3538
3539     def testSortPerTuple1(self):
3540         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3541         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3542         f1.setMesh(mesh1);
3543         array=DataArrayDouble.New();
3544         arr1=[1.2,2.3,3.4,4.5,5.6, 1.2,3.4,4.5,5.6,2.3, 3.4,4.5,5.6,1.2,2.3, 5.6,1.2,2.3,3.4,4.5, 4.5,5.6,1.2,2.3,3.4]
3545         array.setValues(arr1,mesh1.getNumberOfCells(),5);
3546         f1.setArray(array);
3547         f1.checkCoherency();
3548         #
3549         f1.sortPerTuple(True);
3550         f1.checkCoherency();
3551         self.assertEqual(5,f1.getNumberOfComponents());
3552         self.assertEqual(5,f1.getNumberOfTuples());
3553         for i in xrange(5):
3554             self.assertAlmostEqual(arr1[0],f1.getIJ(i,0),13);
3555             self.assertAlmostEqual(arr1[1],f1.getIJ(i,1),13);
3556             self.assertAlmostEqual(arr1[2],f1.getIJ(i,2),13);
3557             self.assertAlmostEqual(arr1[3],f1.getIJ(i,3),13);
3558             self.assertAlmostEqual(arr1[4],f1.getIJ(i,4),13);
3559             pass
3560         #
3561         f1.sortPerTuple(False);
3562         f1.checkCoherency();
3563         self.assertEqual(5,f1.getNumberOfComponents());
3564         self.assertEqual(5,f1.getNumberOfTuples());
3565         for i in xrange(5):
3566             self.assertAlmostEqual(arr1[4],f1.getIJ(i,0),13);
3567             self.assertAlmostEqual(arr1[3],f1.getIJ(i,1),13);
3568             self.assertAlmostEqual(arr1[2],f1.getIJ(i,2),13);
3569             self.assertAlmostEqual(arr1[1],f1.getIJ(i,3),13);
3570             self.assertAlmostEqual(arr1[0],f1.getIJ(i,4),13);
3571             pass
3572         #
3573         pass
3574
3575     def testIsEqualWithoutConsideringStr1(self):
3576         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3577         mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
3578         #
3579         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3580         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3581         mesh2.setName("rr");
3582         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
3583         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3584         da1,da2=mesh1.checkGeoEquivalWith(mesh2,2,1e-12);
3585         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12);
3586         mesh2.setName("");
3587         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3588         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3589         mesh2.getCoords().setInfoOnComponent(0,"tty");
3590         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
3591         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3592         mesh2.getCoords().setInfoOnComponent(0,"");
3593         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3594         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3595         mesh2.getCoords().setInfoOnComponent(1,"tty");
3596         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
3597         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3598         mesh2.getCoords().setInfoOnComponent(1,"");
3599         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3600         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3601         tmp=mesh2.getCoords().getIJ(0,3);
3602         mesh2.getCoords().setIJ(0,3,9999.);
3603         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
3604         self.assertTrue(not mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3605         mesh2.getCoords().setIJ(0,3,tmp);
3606         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3607         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3608         tmp2=mesh2.getNodalConnectivity().getIJ(0,4);
3609         mesh2.getNodalConnectivity().setIJ(0,4,0);
3610         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
3611         self.assertTrue(not mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3612         mesh2.getNodalConnectivity().setIJ(0,4,tmp2);
3613         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3614         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3615         #
3616         f1=mesh1.getMeasureField(True);
3617         f2=mesh2.getMeasureField(True);
3618         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
3619         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3620         f2.setName("ftest");
3621         self.assertTrue(not f1.isEqual(f2,1e-12,1e-12));
3622         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3623         f1.setName("ftest");
3624         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
3625         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3626         #
3627         f2.getArray().setInfoOnComponent(0,"eee");
3628         self.assertTrue(not f1.isEqual(f2,1e-12,1e-12));
3629         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3630         f2.getArray().setInfoOnComponent(0,"");
3631         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
3632         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3633         #
3634         f2.getArray().setIJ(1,0,0.123);
3635         self.assertTrue(not f1.isEqual(f2,1e-12,1e-12));
3636         self.assertTrue(not f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3637         f2.getArray().setIJ(1,0,0.125);
3638         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
3639         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3640         #
3641         pass
3642     
3643     def testGetNodeIdsOfCell1(self):
3644         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3645         li=mesh1.getNodeIdsOfCell(1)
3646         expected1=[1, 4, 2]
3647         self.assertEqual(expected1,list(li))
3648         li=mesh1.getCoordinatesOfNode(4)
3649         self.assertEqual(2,len(li))
3650         self.assertAlmostEqual(0.2,li[0],13);
3651         self.assertAlmostEqual(0.2,li[1],13);
3652         li=mesh1.getCoords().getValuesAsTuple()
3653         self.assertEqual(9,len(li))
3654         li2=mesh1.getNodalConnectivityIndex().getValuesAsTuple()
3655         self.assertEqual(6,len(li2))
3656         pass
3657
3658     def testGetEdgeRatioField1(self):
3659         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
3660         m1.setTime(3.4,5,6); m1.setTimeUnit("us");
3661         f1=m1.getEdgeRatioField();
3662         self.assertAlmostEqual(3.4,f1.getTime()[0],12) ; self.assertEqual(5,f1.getTime()[1]) ; self.assertEqual(6,f1.getTime()[2])
3663         self.assertEqual("us",f1.getTimeUnit())
3664         self.assertEqual(m1.getNumberOfCells(),f1.getNumberOfTuples());
3665         self.assertEqual(5,f1.getNumberOfTuples());
3666         self.assertEqual(1,f1.getNumberOfComponents());
3667         expected1=[1.,1.4142135623730951, 1.4142135623730951,1.,1.]
3668         for i in xrange(5):
3669             self.assertAlmostEqual(expected1[i],f1.getIJ(i,0),14);
3670             pass
3671         #
3672         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
3673         f1=m1.getEdgeRatioField();
3674         self.assertEqual(m1.getNumberOfCells(),f1.getNumberOfTuples());
3675         self.assertEqual(5,f1.getNumberOfTuples());
3676         self.assertEqual(1,f1.getNumberOfComponents());
3677         expected2=[1.4142135623730951, 1.7320508075688772, 1.7320508075688772, 1.4142135623730951, 1.4142135623730951]
3678         for i in xrange(5):
3679             self.assertAlmostEqual(expected2[i],f1.getIJ(i,0),14);
3680             pass
3681         pass
3682
3683     def testFillFromAnalytic3(self):
3684         m=MEDCouplingDataForTest.build2DTargetMesh_1()
3685         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME)
3686         self.assertRaises(InterpKernelException,f1.fillFromAnalytic,1,"y+x");
3687         f1.setMesh(m)
3688         f1.setName("myField");
3689         f1.fillFromAnalytic(1,"y+x");
3690         f1.checkCoherency();
3691         self.assertEqual(f1.getName(),"myField");
3692         self.assertEqual(f1.getTypeOfField(),ON_CELLS);
3693         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
3694         self.assertEqual(1,f1.getNumberOfComponents());
3695         self.assertEqual(5,f1.getNumberOfTuples());
3696         values1=[-0.1,0.23333333333333336,0.56666666666666665,0.4,0.9]
3697         tmp=f1.getArray().getValues();
3698         self.assertEqual(len(values1),len(tmp))
3699         for i in xrange(len(values1)):
3700             self.assertTrue(abs(values1[i]-tmp[i])<1.e-12);
3701             pass
3702         #
3703         f1=MEDCouplingFieldDouble.New(ON_NODES,CONST_ON_TIME_INTERVAL)
3704         f1.setMesh(m)
3705         f1.fillFromAnalytic(1,"y+2*x");
3706         f1.setEndTime(1.2,3,4);
3707         f1.checkCoherency();
3708         self.assertEqual(f1.getTypeOfField(),ON_NODES);
3709         self.assertEqual(f1.getTimeDiscretization(),CONST_ON_TIME_INTERVAL);
3710         self.assertEqual(1,f1.getNumberOfComponents());
3711         self.assertEqual(9,f1.getNumberOfTuples());
3712         values2=[-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1]
3713         tmp=f1.getArray().getValues();
3714         self.assertEqual(len(values2),len(tmp))
3715         for i in xrange(len(values2)):
3716             self.assertTrue(abs(values2[i]-tmp[i])<1.e-12);
3717             pass
3718         f1=MEDCouplingFieldDouble.New(ON_NODES,LINEAR_TIME);
3719         f1.setMesh(m)
3720         f1.fillFromAnalytic(1,"2.*x+y");
3721         f1.setEndTime(1.2,3,4);
3722         f1.checkCoherency();
3723         self.assertEqual(f1.getTypeOfField(),ON_NODES);
3724         self.assertEqual(f1.getTimeDiscretization(),LINEAR_TIME);
3725         self.assertEqual(1,f1.getNumberOfComponents());
3726         self.assertEqual(9,f1.getNumberOfTuples());
3727         tmp=f1.getArray().getValues();
3728         values2Bis=[-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1]
3729         self.assertEqual(len(values2Bis),len(tmp))
3730         for i in xrange(len(values2Bis)):
3731             self.assertTrue(abs(values2Bis[i]-tmp[i])<1.e-12);
3732             pass
3733         tmp=f1.getEndArray().getValues();
3734         self.assertEqual(len(values2Bis),len(tmp))
3735         for i in xrange(len(values2Bis)):
3736             self.assertTrue(abs(values2Bis[i]-tmp[i])<1.e-12);
3737             pass
3738         #
3739         f1=MEDCouplingFieldDouble.New(ON_NODES,ONE_TIME);
3740         f1.setMesh(m)
3741         f1.fillFromAnalytic(2,"(x+y)*IVec+2*(x+y)*JVec");
3742         f1.checkCoherency();
3743         self.assertEqual(f1.getTypeOfField(),ON_NODES);
3744         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
3745         self.assertEqual(2,f1.getNumberOfComponents());
3746         self.assertEqual(9,f1.getNumberOfTuples());
3747         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]
3748         tmp=f1.getArray().getValues();
3749         self.assertEqual(len(values3),len(tmp))
3750         for i in xrange(len(values3)):
3751             self.assertTrue(abs(values3[i]-tmp[i])<1.e-12);
3752             pass
3753         values4=f1.accumulate();
3754         self.assertTrue(abs(3.6-values4[0])<1.e-12);
3755         self.assertTrue(abs(7.2-values4[1])<1.e-12);
3756         values4=f1.integral(True);
3757         self.assertTrue(abs(0.5-values4[0])<1.e-12);
3758         self.assertTrue(abs(1.-values4[1])<1.e-12);
3759         #
3760         f1=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
3761         f1.setMesh(m);
3762         self.assertRaises(InterpKernelException,f1.fillFromAnalytic,1,"1./(x-0.2)");
3763         pass
3764
3765     def testFieldDoubleOpEqual1(self):
3766         m=MEDCouplingDataForTest.build2DTargetMesh_1();
3767         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3768         self.assertRaises(InterpKernelException,f1.assign,0.07);
3769         f1.setMesh(m);
3770         f1.assign(0.07);
3771         f1.checkCoherency();
3772         self.assertEqual(1,f1.getNumberOfComponents());
3773         self.assertEqual(5,f1.getNumberOfTuples());
3774         for i in xrange(5):
3775             self.assertAlmostEqual(0.07,f1.getIJ(i,0),16);
3776             pass
3777         f1.assign(0.09);
3778         f1.checkCoherency();
3779         self.assertEqual(1,f1.getNumberOfComponents());
3780         self.assertEqual(5,f1.getNumberOfTuples());
3781         for i in xrange(5):
3782             self.assertAlmostEqual(0.09,f1.getIJ(i,0),16);
3783             pass
3784         #
3785         f1=MEDCouplingFieldDouble.New(ON_NODES,LINEAR_TIME);
3786         f1.setEndTime(4.5,2,3);
3787         f1.setMesh(m);
3788         f1.assign(0.08);
3789         f1.checkCoherency();
3790         self.assertEqual(1,f1.getNumberOfComponents());
3791         self.assertEqual(9,f1.getNumberOfTuples());
3792         for i in xrange(9):
3793             self.assertAlmostEqual(0.08,f1.getIJ(i,0),16);
3794             pass
3795         self.assertEqual(1,f1.getEndArray().getNumberOfComponents());
3796         self.assertEqual(9,f1.getEndArray().getNumberOfTuples());
3797         for i in xrange(9):
3798             self.assertAlmostEqual(0.08,f1.getEndArray().getIJ(i,0),16);
3799             pass
3800         pass
3801
3802     def testAreaBary3D2(self):
3803         coordsForHexa8=[-75.45749305371, 180.95495078401, 39.515472018008,
3804                         -9.755591679144, 23.394927935279, 5.108794294848,
3805                         14.337630157832, 61.705351002702, 160.42422501908,
3806                         -27.273893776752, 167.567731083961, 192.830034145464,
3807                         99.857193154796,264.499264735586,-8.287335493412,
3808                         144.939882761126,156.38626563134,-31.896173894226,
3809                         161.34096835726,182.4654895809,73.832387065572,
3810                         132.680430393685,255.37973247196,96.15235602819];
3811         volHexa8=3258520.29637466;
3812         baryHexa8=[43.925705821778, 155.31893955289, 65.874418109644]
3813         
3814         coordsForPenta6=[-68.199829618726,178.938498373416,62.608505919588,
3815                          8.461744647847,76.653979804423,165.00018874933,
3816                          -27.273893776752,167.567731083961,192.830034145464,
3817                          106.586501038965,262.629609408327,13.124533008813,
3818                          155.465082847275,197.414118382622,78.408350795821,
3819                          132.680430393685,255.37973247196,96.15235602819];
3820         volPenta6=944849.868507338;
3821         baryPenta6=[39.631002313543,182.692711783428,106.98540473964]
3822         
3823         coordsForPyra5=[132.680430393685,255.37973247196,96.15235602819,
3824                         -27.273893776752,167.567731083961,192.830034145464,
3825                         8.461744647847,76.653979804423,165.00018874933,
3826                         155.465082847275,197.414118382622,78.408350795821,
3827                         -68.199829618726,178.938498373416,62.608505919588];
3828         volPyra5=756943.92980254;
3829         baryPyra5=[29.204294116618,172.540129749156,118.01035951483]
3830         mesh=MEDCouplingUMesh.New("Bary3D2",3);
3831         coo=DataArrayDouble.New();
3832         tmp=coordsForHexa8+coordsForPenta6+coordsForPyra5
3833         coo.setValues(tmp,19,3);
3834         mesh.setCoords(coo);
3835         #
3836         tmpConn=[0,1,2,3,4,5,6,7]
3837         mesh.allocateCells(3);
3838         self.assertRaises(InterpKernelException,mesh.insertNextCell,NORM_HEXA8,9,tmpConn[0:8])
3839         mesh.insertNextCell(NORM_HEXA8,tmpConn[0:8])
3840         mesh.insertNextCell(NORM_PENTA6,6,[i+8 for i in tmpConn])
3841         mesh.insertNextCell(NORM_PYRA5,5,[i+14 for i in tmpConn])
3842         mesh.finishInsertingCells();
3843         mesh.checkCoherency();
3844         mesh.mergeNodes(1e-7)
3845         self.assertEqual(12,mesh.getNumberOfNodes());
3846         vols=mesh.getMeasureField(True);
3847         self.assertEqual(3,vols.getNumberOfTuples());
3848         self.assertEqual(1,vols.getNumberOfComponents());
3849         self.assertAlmostEqual(volHexa8,vols.getIJ(0,0),6);
3850         self.assertAlmostEqual(volPenta6,vols.getIJ(1,0),7);
3851         self.assertAlmostEqual(volPyra5,vols.getIJ(2,0),7);
3852         bary=mesh.getBarycenterAndOwner();
3853         self.assertEqual(3,bary.getNumberOfTuples());
3854         self.assertEqual(3,bary.getNumberOfComponents());
3855         self.assertAlmostEqual(baryHexa8[0],bary.getIJ(0,0),11);
3856         self.assertAlmostEqual(baryHexa8[1],bary.getIJ(0,1),11);
3857         self.assertAlmostEqual(baryHexa8[2],bary.getIJ(0,2),11);
3858         self.assertAlmostEqual(baryPenta6[0],bary.getIJ(1,0),11);
3859         self.assertAlmostEqual(baryPenta6[1],bary.getIJ(1,1),11);
3860         self.assertAlmostEqual(baryPenta6[2],bary.getIJ(1,2),11);
3861         self.assertAlmostEqual(baryPyra5[0],bary.getIJ(2,0),11);
3862         self.assertAlmostEqual(baryPyra5[1],bary.getIJ(2,1),11);
3863         self.assertAlmostEqual(baryPyra5[2],bary.getIJ(2,2),11);
3864         pass
3865
3866     def testGetMeasureFieldCMesh1(self):
3867         m=MEDCouplingCMesh.New();
3868         da=DataArrayDouble.New();
3869         discX=[2.3,3.4,5.8,10.2]
3870         discY=[12.3,23.4,45.8]
3871         discZ=[-0.7,1.2,1.25,2.13,2.67]
3872         da.setValues(discX,4,1);
3873         m.setCoordsAt(0,da);
3874         m.checkCoherency();
3875         self.assertEqual(4,m.getNumberOfNodes());
3876         self.assertEqual(3,m.getNumberOfCells());
3877         self.assertEqual(1,m.getSpaceDimension());
3878         f=m.getMeasureField(True);
3879         self.assertEqual(3,f.getNumberOfTuples());
3880         self.assertEqual(1,f.getNumberOfComponents());
3881         expected1=[1.1,2.4,4.4]
3882         for i in xrange(3):
3883             self.assertAlmostEqual(expected1[i],f.getIJ(i,0),12);
3884             pass
3885         coords=m.getCoordinatesAndOwner();
3886         self.assertEqual(4,coords.getNumberOfTuples());
3887         self.assertEqual(1,coords.getNumberOfComponents());
3888         for i in xrange(4):
3889             self.assertAlmostEqual(discX[i],coords.getIJ(i,0),12);
3890             pass
3891         coords=m.getBarycenterAndOwner();
3892         self.assertEqual(3,coords.getNumberOfTuples());
3893         self.assertEqual(1,coords.getNumberOfComponents());
3894         expected1_3=[2.85,4.6,8.]
3895         for i in xrange(3):
3896             self.assertAlmostEqual(expected1_3[i],coords.getIJ(i,0),12);
3897             pass
3898         #
3899         da=DataArrayDouble.New();
3900         da.setValues(discY,3,1);
3901         m.setCoordsAt(1,da);
3902         m.checkCoherency();
3903         self.assertEqual(12,m.getNumberOfNodes());
3904         self.assertEqual(6,m.getNumberOfCells());
3905         self.assertEqual(2,m.getSpaceDimension());
3906         f=m.getMeasureField(True);
3907         self.assertEqual(6,f.getNumberOfTuples());
3908         self.assertEqual(1,f.getNumberOfComponents());
3909         expected2=[12.21,26.64,48.84,24.64,53.76,98.56]
3910         for i in xrange(6):
3911             self.assertAlmostEqual(expected2[i],f.getIJ(i,0),12);
3912             pass
3913         coords=m.getCoordinatesAndOwner();
3914         self.assertEqual(12,coords.getNumberOfTuples());
3915         self.assertEqual(2,coords.getNumberOfComponents());
3916         expected2_2=[2.3,12.3,3.4,12.3,5.8,12.3,10.2,12.3, 2.3,23.4,3.4,23.4,5.8,23.4,10.2,23.4, 2.3,45.8,3.4,45.8,5.8,45.8,10.2,45.8]
3917         for i in xrange(24):
3918             self.assertAlmostEqual(expected2_2[i],coords.getIJ(0,i),12);
3919             pass
3920         coords=m.getBarycenterAndOwner();
3921         self.assertEqual(6,coords.getNumberOfTuples());
3922         self.assertEqual(2,coords.getNumberOfComponents());
3923         expected2_3=[2.85,17.85,4.6,17.85,8.,17.85, 2.85,34.6,4.6,34.6,8.,34.6]
3924         for i in xrange(12):
3925             self.assertAlmostEqual(expected2_3[i],coords.getIJ(0,i),12);
3926             pass
3927         #
3928         da=DataArrayDouble.New();
3929         da.setValues(discZ,5,1);
3930         m.setCoordsAt(2,da);
3931         m.checkCoherency();
3932         self.assertEqual(60,m.getNumberOfNodes());
3933         self.assertEqual(24,m.getNumberOfCells());
3934         self.assertEqual(3,m.getSpaceDimension());
3935         f=m.getMeasureField(True);
3936         self.assertEqual(24,f.getNumberOfTuples());
3937         self.assertEqual(1,f.getNumberOfComponents());
3938         expected3=[23.199, 50.616, 92.796, 46.816, 102.144, 187.264, 0.6105, 1.332, 2.442, 1.232, 2.688, 4.928, 10.7448, 23.4432, 42.9792, 21.6832, 47.3088, 86.7328, 6.5934, 14.3856, 26.3736, 13.3056, 29.0304, 53.2224]
3939         for i in xrange(24):
3940             self.assertAlmostEqual(expected3[i],f.getIJ(i,0),12);
3941             pass
3942         coords=m.getCoordinatesAndOwner();
3943         self.assertEqual(60,coords.getNumberOfTuples());
3944         self.assertEqual(3,coords.getNumberOfComponents());
3945         expected3_2=[
3946             2.3,12.3,-0.7, 3.4,12.3,-0.7, 5.8,12.3,-0.7, 10.2,12.3,-0.7, 2.3,23.4,-0.7, 3.4,23.4,-0.7, 5.8,23.4,-0.7, 10.2,23.4,-0.7, 2.3,45.8,-0.7, 3.4,45.8,-0.7, 5.8,45.8,-0.7, 10.2,45.8,-0.7,
3947             2.3,12.3,1.2, 3.4,12.3,1.2, 5.8,12.3,1.2, 10.2,12.3,1.2, 2.3,23.4,1.2, 3.4,23.4,1.2, 5.8,23.4,1.2, 10.2,23.4,1.2, 2.3,45.8,1.2, 3.4,45.8,1.2, 5.8,45.8,1.2, 10.2,45.8,1.2,
3948             2.3,12.3,1.25, 3.4,12.3,1.25, 5.8,12.3,1.25, 10.2,12.3,1.25, 2.3,23.4,1.25, 3.4,23.4,1.25, 5.8,23.4,1.25, 10.2,23.4,1.25, 2.3,45.8,1.25, 3.4,45.8,1.25, 5.8,45.8,1.25, 10.2,45.8,1.25,
3949             2.3,12.3,2.13, 3.4,12.3,2.13, 5.8,12.3,2.13, 10.2,12.3,2.13, 2.3,23.4,2.13, 3.4,23.4,2.13, 5.8,23.4,2.13, 10.2,23.4,2.13, 2.3,45.8,2.13, 3.4,45.8,2.13, 5.8,45.8,2.13, 10.2,45.8,2.13,
3950             2.3,12.3,2.67, 3.4,12.3,2.67, 5.8,12.3,2.67, 10.2,12.3,2.67, 2.3,23.4,2.67, 3.4,23.4,2.67, 5.8,23.4,2.67, 10.2,23.4,2.67, 2.3,45.8,2.67, 3.4,45.8,2.67, 5.8,45.8,2.67, 10.2,45.8,2.67];
3951         for i in xrange(180):
3952             self.assertAlmostEqual(expected3_2[i],coords.getIJ(0,i),12);
3953             pass
3954         coords=m.getBarycenterAndOwner();
3955         self.assertEqual(24,coords.getNumberOfTuples());
3956         self.assertEqual(3,coords.getNumberOfComponents());
3957         expected3_3=[
3958             2.85,17.85,0.25,4.6,17.85,0.25,8.,17.85,0.25, 2.85,34.6,0.25,4.6,34.6,0.25,8.,34.6,0.25,
3959             2.85,17.85,1.225,4.6,17.85,1.225,8.,17.85,1.225, 2.85,34.6,1.225,4.6,34.6,1.225,8.,34.6,1.225,
3960             2.85,17.85,1.69,4.6,17.85,1.69,8.,17.85,1.69, 2.85,34.6,1.69,4.6,34.6,1.69,8.,34.6,1.69,
3961             2.85,17.85,2.4,4.6,17.85,2.4,8.,17.85,2.4, 2.85,34.6,2.4,4.6,34.6,2.4,8.,34.6,2.4];
3962         for i in xrange(72):
3963             self.assertAlmostEqual(expected3_3[i],coords.getIJ(0,i),12);
3964             pass
3965         pass
3966
3967     def testFieldDoubleZipCoords1(self):
3968         m=MEDCouplingDataForTest.build2DTargetMeshMergeNode_1();
3969         f=m.fillFromAnalytic(ON_NODES,2,"x*2.");
3970         f.getArray().setInfoOnComponent(0,"titi");
3971         f.getArray().setInfoOnComponent(1,"tutu");
3972         f.checkCoherency();
3973         self.assertEqual(18,f.getNumberOfTuples());
3974         self.assertEqual(2,f.getNumberOfComponents());
3975         expected1=[-0.6, -0.6, 0.4, 0.4, 1.4, 1.4, -0.6, -0.6, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 1.4, 1.4, -0.6, -0.6, 0.4, 0.4, 1.4, 1.4, -0.6, -0.6, 1.4, 1.4, -0.6, -0.6, 0.4, 0.4, 1.4, 1.4, 0.4, 0.4]
3976         for i in xrange(36):
3977             self.assertAlmostEqual(expected1[i],f.getIJ(0,i),12);
3978             pass
3979         self.assertTrue(f.zipCoords());
3980         f.checkCoherency();
3981         expected2=[-0.6, -0.6, 1.4, 1.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 1.4, 1.4, -0.6, -0.6, 0.4, 0.4, 1.4, 1.4, 1.4, 1.4, -0.6, -0.6, 0.4, 0.4, 1.4, 1.4, 0.4, 0.4]
3982         for i in xrange(30):
3983             self.assertAlmostEqual(expected2[i],f.getIJ(0,i),12);
3984             pass
3985         self.assertTrue(not f.zipCoords());
3986         f.checkCoherency();
3987         for i in xrange(30):
3988             self.assertAlmostEqual(expected2[i],f.getIJ(0,i),12);
3989             pass
3990         self.assertTrue(f.getArray().getInfoOnComponent(0)=="titi");
3991         self.assertTrue(f.getArray().getInfoOnComponent(1)=="tutu");
3992         pass
3993
3994     def testFieldDoubleZipConnectivity1(self):
3995         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
3996         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
3997         cells1=[2,3,4]
3998         m3_1=m2.buildPartOfMySelf(cells1,True);
3999         m3=m3_1;
4000         m4=MEDCouplingDataForTest.build2DSourceMesh_1();
4001         m5=MEDCouplingUMesh.MergeUMeshes(m1,m3);
4002         m6=MEDCouplingUMesh.MergeUMeshes(m5,m4);
4003         #
4004         self.assertEqual(10,m6.getNumberOfCells());
4005         self.assertEqual(22,m6.getNumberOfNodes());
4006         arr,areNodesMerged,newNbOfNodes=m6.mergeNodes(1e-13);
4007         self.assertEqual(9,m6.getNumberOfNodes());
4008         f=m6.fillFromAnalytic(ON_CELLS,2,"x");
4009         f2=m6.fillFromAnalytic(ON_NODES,2,"x");
4010         self.assertEqual(10,f.getNumberOfTuples());
4011         self.assertEqual(2,f.getNumberOfComponents());
4012         expected1=[-0.05, -0.05, 0.3666666666666667, 0.3666666666666667, 0.53333333333333321, 0.53333333333333321,
4013                    -0.05, -0.05, 0.45, 0.45, 0.53333333333333321, 0.53333333333333321, -0.05, -0.05, 0.45, 0.45,
4014                    0.36666666666666659, 0.36666666666666659, 0.033333333333333326, 0.033333333333333326];
4015         for i in xrange(20):
4016             self.assertAlmostEqual(expected1[i],f.getIJ(0,i),12);
4017             pass
4018         f.getArray().setInfoOnComponent(0,"titi");
4019         f.getArray().setInfoOnComponent(1,"tutu");
4020         f.checkCoherency();
4021         self.assertTrue(f.zipConnectivity(0));
4022         expected2=[-0.05, -0.05, 0.3666666666666667, 0.3666666666666667, 0.53333333333333321, 0.53333333333333321,
4023                    -0.05, -0.05, 0.45, 0.45, 0.36666666666666659, 0.36666666666666659, 0.033333333333333326, 0.033333333333333326];
4024         self.assertEqual(7,f.getNumberOfTuples());
4025         self.assertEqual(2,f.getNumberOfComponents());
4026         for i in xrange(14):
4027             self.assertAlmostEqual(expected2[i],f.getIJ(0,i),12);
4028             pass
4029         self.assertTrue(f.getArray().getInfoOnComponent(0)=="titi");
4030         self.assertTrue(f.getArray().getInfoOnComponent(1)=="tutu");
4031         self.assertTrue(not f.zipConnectivity(0));
4032         #
4033         expected3=[-0.3, -0.3, 0.2, 0.2, 0.7, 0.7, -0.3, -0.3, 0.2, 0.2, 0.7, 0.7,
4034                    -0.3, -0.3, 0.2, 0.2, 0.7, 0.7];
4035         self.assertEqual(9,f2.getNumberOfTuples());
4036         self.assertEqual(2,f2.getNumberOfComponents());
4037         for i in xrange(18):
4038             self.assertAlmostEqual(expected3[i],f2.getIJ(0,i),12);
4039             pass
4040         self.assertTrue(f2.zipConnectivity(0));
4041         self.assertEqual(9,f2.getNumberOfTuples());
4042         self.assertEqual(2,f2.getNumberOfComponents());
4043         for i in xrange(18):
4044             self.assertAlmostEqual(expected3[i],f2.getIJ(0,i),12);
4045             pass
4046         pass
4047
4048     def testDaDoubleRenumber1(self):
4049         a=DataArrayDouble.New();
4050         arr1=[1.1,11.1,2.1,12.1,3.1,13.1,4.1,14.1,5.1,15.1,6.1,16.1,7.1,17.1]
4051         a.setValues(arr1,7,2);
4052         a.setInfoOnComponent(0,"toto");
4053         a.setInfoOnComponent(1,"tata");
4054         #
4055         arr2=[3,1,0,6,5,4,2]
4056         b=a.renumber(arr2);
4057         self.assertEqual(7,b.getNumberOfTuples());
4058         self.assertEqual(2,b.getNumberOfComponents());
4059         self.assertTrue(b.getInfoOnComponent(0)=="toto");
4060         self.assertTrue(b.getInfoOnComponent(1)=="tata");
4061         expected1=[3.1, 13.1, 2.1, 12.1, 7.1, 17.1, 1.1, 11.1, 6.1, 16.1, 5.1, 15.1, 4.1, 14.1]
4062         for i in xrange(14):
4063             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
4064             pass
4065         #
4066         c=DataArrayInt.New();
4067         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4068         c.setValues(arr3,7,2);
4069         c.setInfoOnComponent(0,"toto");
4070         c.setInfoOnComponent(1,"tata");
4071         d=c.renumber(arr2);
4072         self.assertEqual(7,d.getNumberOfTuples());
4073         self.assertEqual(2,d.getNumberOfComponents());
4074         self.assertTrue(d.getInfoOnComponent(0)=="toto");
4075         self.assertTrue(d.getInfoOnComponent(1)=="tata");
4076         expected2=[3, 13, 2, 12, 7, 17, 1, 11, 6, 16, 5, 15, 4, 14]
4077         for i in xrange(14):
4078             self.assertEqual(expected2[i],d.getIJ(0,i));
4079             pass
4080         pass
4081
4082     def testDaDoubleRenumberAndReduce1(self):
4083         a=DataArrayDouble.New();
4084         arr1=[1.1,11.1,2.1,12.1,3.1,13.1,4.1,14.1,5.1,15.1,6.1,16.1,7.1,17.1]
4085         a.setValues(arr1,7,2);
4086         a.setInfoOnComponent(0,"toto");
4087         a.setInfoOnComponent(1,"tata");
4088         #
4089         arr2=[2,-1,1,-1,0,4,3]
4090         b=a.renumberAndReduce(arr2,5);
4091         self.assertEqual(5,b.getNumberOfTuples());
4092         self.assertEqual(2,b.getNumberOfComponents());
4093         self.assertTrue(b.getInfoOnComponent(0)=="toto");
4094         self.assertTrue(b.getInfoOnComponent(1)=="tata");
4095         expected1=[5.1,15.1,3.1,13.1,1.1,11.1,7.1,17.1,6.1,16.1]
4096         for i in xrange(10):
4097             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
4098             pass
4099         #
4100         c=DataArrayInt.New();
4101         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4102         c.setValues(arr3,7,2);
4103         c.setInfoOnComponent(0,"toto");
4104         c.setInfoOnComponent(1,"tata");
4105         d=c.renumberAndReduce(arr2,5);
4106         self.assertEqual(5,d.getNumberOfTuples());
4107         self.assertEqual(2,d.getNumberOfComponents());
4108         self.assertTrue(d.getInfoOnComponent(0)=="toto");
4109         self.assertTrue(d.getInfoOnComponent(1)=="tata");
4110         expected2=[5,15,3,13,1,11,7,17,6,16]
4111         for i in xrange(10):
4112             self.assertEqual(expected2[i],d.getIJ(0,i));
4113             pass
4114         pass
4115
4116     def testDaDoubleRenumberInPlace1(self):
4117         a=DataArrayDouble.New();
4118         arr1=[1.1,11.1,2.1,12.1,3.1,13.1,4.1,14.1,5.1,15.1,6.1,16.1,7.1,17.1]
4119         a.setValues(arr1,7,2);
4120         #
4121         arr2=[3,1,0,6,5,4,2]
4122         a.renumberInPlace(arr2);
4123         self.assertEqual(7,a.getNumberOfTuples());
4124         self.assertEqual(2,a.getNumberOfComponents());
4125         expected1=[3.1, 13.1, 2.1, 12.1, 7.1, 17.1, 1.1, 11.1, 6.1, 16.1, 5.1, 15.1, 4.1, 14.1]
4126         for i in xrange(14):
4127             self.assertAlmostEqual(expected1[i],a.getIJ(0,i),14);
4128             pass
4129         #
4130         c=DataArrayInt.New();
4131         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4132         c.setValues(arr3,7,2);
4133         c.renumberInPlace(arr2);
4134         self.assertEqual(7,c.getNumberOfTuples());
4135         self.assertEqual(2,c.getNumberOfComponents());
4136         expected2=[3, 13, 2, 12, 7, 17, 1, 11, 6, 16, 5, 15, 4, 14]
4137         for i in xrange(14):
4138             self.assertEqual(expected2[i],c.getIJ(0,i));
4139             pass
4140         pass
4141
4142     def testDaDoubleRenumberR1(self):
4143         a=DataArrayDouble.New();
4144         arr1=[1.1,11.1,2.1,12.1,3.1,13.1,4.1,14.1,5.1,15.1,6.1,16.1,7.1,17.1]
4145         a.setValues(arr1,7,2);
4146         a.setInfoOnComponent(0,"toto");
4147         a.setInfoOnComponent(1,"tata");
4148         #
4149         arr2=[3,1,0,6,5,4,2]
4150         b=a.renumberR(arr2);
4151         self.assertEqual(7,b.getNumberOfTuples());
4152         self.assertEqual(2,b.getNumberOfComponents());
4153         self.assertTrue(b.getInfoOnComponent(0)=="toto");
4154         self.assertTrue(b.getInfoOnComponent(1)=="tata");
4155         expected1=[4.1, 14.1, 2.1, 12.1, 1.1, 11.1, 7.1, 17.1, 6.1, 16.1, 5.1, 15.1, 3.1, 13.1]
4156         for i in xrange(14):
4157             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
4158             pass
4159         #
4160         c=DataArrayInt.New();
4161         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4162         c.setValues(arr3,7,2);
4163         c.setInfoOnComponent(0,"toto");
4164         c.setInfoOnComponent(1,"tata");
4165         d=c.renumberR(arr2);
4166         self.assertEqual(7,d.getNumberOfTuples());
4167         self.assertEqual(2,d.getNumberOfComponents());
4168         self.assertTrue(d.getInfoOnComponent(0)=="toto");
4169         self.assertTrue(d.getInfoOnComponent(1)=="tata");
4170         expected2=[4, 14, 2, 12, 1, 11, 7, 17, 6, 16, 5, 15, 3, 13]
4171         for i in xrange(14):
4172             self.assertEqual(expected2[i],d.getIJ(0,i));
4173             pass
4174         pass
4175
4176     def testDaDoubleRenumberInPlaceR1(self):
4177         a=DataArrayDouble.New();
4178         arr1=[1.1,11.1,2.1,12.1,3.1,13.1,4.1,14.1,5.1,15.1,6.1,16.1,7.1,17.1]
4179         a.setValues(arr1,7,2);
4180         #
4181         arr2=[3,1,0,6,5,4,2]
4182         a.renumberInPlaceR(arr2);
4183         self.assertEqual(7,a.getNumberOfTuples());
4184         self.assertEqual(2,a.getNumberOfComponents());
4185         expected1=[4.1, 14.1, 2.1, 12.1, 1.1, 11.1, 7.1, 17.1, 6.1, 16.1, 5.1, 15.1, 3.1, 13.1]
4186         for i in xrange(14):
4187             self.assertAlmostEqual(expected1[i],a.getIJ(0,i),14);
4188             pass
4189         #
4190         c=DataArrayInt.New();
4191         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4192         c.setValues(arr3,7,2);
4193         c.renumberInPlaceR(arr2);
4194         self.assertEqual(7,c.getNumberOfTuples());
4195         self.assertEqual(2,c.getNumberOfComponents());
4196         expected2=[4, 14, 2, 12, 1, 11, 7, 17, 6, 16, 5, 15, 3, 13]
4197         for i in xrange(14):
4198             self.assertEqual(expected2[i],c.getIJ(0,i));
4199             pass
4200         pass
4201
4202     def testDaDoubleSelectByTupleId1(self):
4203         a=DataArrayDouble.New();
4204         arr1=[1.1,11.1,2.1,12.1,3.1,13.1,4.1,14.1,5.1,15.1,6.1,16.1,7.1,17.1]
4205         a.setValues(arr1,7,2);
4206         a.setInfoOnComponent(0,"toto");
4207         a.setInfoOnComponent(1,"tata");
4208         #
4209         arr2=[4,2,0,6,5]
4210         b=a.selectByTupleId(arr2);
4211         self.assertEqual(5,b.getNumberOfTuples());
4212         self.assertEqual(2,b.getNumberOfComponents());
4213         self.assertTrue(b.getInfoOnComponent(0)=="toto");
4214         self.assertTrue(b.getInfoOnComponent(1)=="tata");
4215         expected1=[5.1,15.1,3.1,13.1,1.1,11.1,7.1,17.1,6.1,16.1]
4216         for i in xrange(10):
4217             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
4218             pass
4219         #
4220         c=DataArrayInt.New();
4221         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4222         c.setValues(arr3,7,2);
4223         c.setInfoOnComponent(0,"toto");
4224         c.setInfoOnComponent(1,"tata");
4225         d=c.selectByTupleId(arr2);
4226         self.assertEqual(5,d.getNumberOfTuples());
4227         self.assertEqual(2,d.getNumberOfComponents());
4228         self.assertTrue(d.getInfoOnComponent(0)=="toto");
4229         self.assertTrue(d.getInfoOnComponent(1)=="tata");
4230         expected2=[5,15,3,13,1,11,7,17,6,16]
4231         for i in xrange(10):
4232             self.assertEqual(expected2[i],d.getIJ(0,i));
4233             pass
4234         pass
4235
4236     def testDaDoubleGetMinMaxValues1(self):
4237         a=DataArrayDouble.New();
4238         arr1=[2.34,4.56,-6.77,4.55,4.56,2.24,2.34,1.02,4.56]
4239         a.setValues(arr1,9,1);
4240         m,where=a.getMaxValue();
4241         self.assertEqual(1,where);
4242         self.assertAlmostEqual(4.56,m,12);
4243         m,ws=a.getMaxValue2();
4244         self.assertAlmostEqual(4.56,m,12);
4245         self.assertEqual(3,ws.getNumberOfTuples());
4246         self.assertEqual(1,ws.getNumberOfComponents());
4247         expected1=[1,4,8]
4248         for i in xrange(3):
4249             self.assertEqual(expected1[i],ws.getIJ(i,0));
4250             pass
4251         a=DataArrayDouble.New();
4252         arr2=[-2.34,-4.56,6.77,-4.55,-4.56,-2.24,-2.34,-1.02,-4.56]
4253         a.setValues(arr2,9,1);
4254         m,where=a.getMinValue();
4255         self.assertEqual(1,where);
4256         self.assertAlmostEqual(-4.56,m,12);
4257         m,ws=a.getMinValue2();
4258         self.assertAlmostEqual(-4.56,m,12);
4259         self.assertEqual(3,ws.getNumberOfTuples());
4260         self.assertEqual(1,ws.getNumberOfComponents());
4261         for i in xrange(3):
4262             self.assertEqual(expected1[i],ws.getIJ(i,0));
4263             pass
4264         pass
4265
4266     def testFieldDoubleGetMinMaxValues2(self):
4267         m2,m1=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
4268         self.assertEqual(18,m2.getNumberOfCells());
4269         arr1=[8.71,4.53,-12.41,8.71,-8.71,8.7099,4.55,8.71,5.55,6.77,-1e-200,4.55,8.7099,0.,1.23,0.,2.22,8.71]
4270         f=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
4271         a=DataArrayDouble.New();
4272         a.setValues(arr1,18,1);
4273         f.setArray(a);
4274         f.setMesh(m2);
4275         #
4276         f.checkCoherency();
4277         m=f.getMaxValue();
4278         self.assertAlmostEqual(8.71,m,12);
4279         m,ws=f.getMaxValue2();
4280         self.assertAlmostEqual(8.71,m,12);
4281         self.assertEqual(4,ws.getNumberOfTuples());
4282         self.assertEqual(1,ws.getNumberOfComponents());
4283         expected1=[0,3,7,17]
4284         for i in xrange(4):
4285             self.assertEqual(expected1[i],ws.getIJ(i,0));
4286             pass
4287         #
4288         arr2=[-8.71,-4.53,12.41,-8.71,8.71,-8.7099,-4.55,-8.71,-5.55,-6.77,1e-200,-4.55,-8.7099,0.,-1.23,0.,-2.22,-8.71]
4289         a.setValues(arr2,18,1);
4290         f.checkCoherency();
4291         m=f.getMinValue();
4292         self.assertAlmostEqual(-8.71,m,12);
4293         m,ws=f.getMinValue2();
4294         self.assertAlmostEqual(-8.71,m,12);
4295         self.assertEqual(4,ws.getNumberOfTuples());
4296         self.assertEqual(1,ws.getNumberOfComponents());
4297         for i in xrange(4):
4298             self.assertEqual(expected1[i],ws.getIJ(i,0));
4299             pass
4300         pass
4301
4302     def testBuildUnstructuredCMesh1(self):
4303         m=MEDCouplingCMesh.New();
4304         da=DataArrayDouble.New();
4305         discX=[2.3,3.4,5.8,10.2]
4306         discY=[12.3,23.4,45.8]
4307         discZ=[-0.7,1.2,1.25,2.13,2.67]
4308         da.setValues(discX,4,1);
4309         m.setCoordsAt(0,da);
4310         m.checkCoherency();
4311         self.assertEqual(0,m.getCellContainingPoint([2.4],1e-12));
4312         self.assertEqual(1,m.getCellContainingPoint([3.7],1e-12));
4313         self.assertEqual(2,m.getCellContainingPoint([5.9],1e-12));
4314         self.assertEqual(-1,m.getCellContainingPoint([10.3],1e-12));
4315         self.assertEqual(-1,m.getCellContainingPoint([1.3],1e-12));
4316         #
4317         m2=m.buildUnstructured();
4318         m2.checkCoherency();
4319         f1=m.getMeasureField(False);
4320         f2=m2.getMeasureField(False);
4321         self.assertTrue(isinstance(f1.getMesh(),MEDCouplingCMesh))
4322         self.assertEqual(f1.getNumberOfTuples(),3);
4323         self.assertEqual(f2.getNumberOfTuples(),3);
4324         self.assertEqual(1,m2.getMeshDimension());
4325         self.assertEqual(1,m2.getSpaceDimension());
4326         for i in xrange(3):
4327             self.assertAlmostEqual(f1.getIJ(i,0),f2.getIJ(i,0),10);
4328             pass
4329         da=DataArrayDouble.New();
4330         da.setValues(discY,3,1);
4331         m.setCoordsAt(1,da);
4332         #
4333         m2=m.buildUnstructured();
4334         m2.checkCoherency();
4335         f1=m.getMeasureField(False);
4336         f2=m2.getMeasureField(False);
4337         self.assertEqual(f1.getNumberOfTuples(),6);
4338         self.assertEqual(f2.getNumberOfTuples(),6);
4339         self.assertEqual(2,m2.getMeshDimension());
4340         self.assertEqual(2,m2.getSpaceDimension());
4341         for i in xrange(6):
4342             self.assertAlmostEqual(f1.getIJ(i,0),f2.getIJ(i,0),10);
4343             pass
4344         #
4345         da=DataArrayDouble.New();
4346         da.setValues(discZ,5,1);
4347         m.setCoordsAt(2,da);
4348         m2=m.buildUnstructured();
4349         m2.checkCoherency();
4350         f1=m.getMeasureField(False);
4351         f2=m2.getMeasureField(False);
4352         self.assertEqual(f1.getNumberOfTuples(),24);
4353         self.assertEqual(f2.getNumberOfTuples(),24);
4354         self.assertEqual(3,m2.getMeshDimension());
4355         self.assertEqual(3,m2.getSpaceDimension());
4356         for i in xrange(24):
4357             self.assertAlmostEqual(f1.getIJ(i,0),f2.getIJ(i,0),10);
4358             pass
4359         #
4360         pos1=[5.,30.,2.]
4361         self.assertEqual(16,m.getCellContainingPoint(pos1,1e-12));
4362         #
4363         elems=m2.getCellsInBoundingBox([3.5,6.,12.2,25.,0.,1.5],1e-7)
4364         self.assertEqual([1, 2, 4, 5, 7, 8, 10, 11, 13, 14, 16, 17],elems.getValues())
4365         #
4366         pt=[2.4,12.7,-3.4]
4367         m.scale(pt,3.7);
4368         m3=m.buildUnstructured();
4369         m2.scale(pt,3.7);
4370         self.assertTrue(m3.isEqual(m2,1e-12));
4371         pass
4372
4373     def testDataArrayIntInvertO2NNO21(self):
4374         arr1=[2,0,4,1,5,3]
4375         da=DataArrayInt.New();
4376         da.setValues(arr1,6,1);
4377         da2=da.invertArrayO2N2N2O(6);
4378         self.assertEqual(6,da2.getNumberOfTuples());
4379         self.assertEqual(1,da2.getNumberOfComponents());
4380         expected1=[1,3,0,5,2,4]
4381         for i in xrange(6):
4382             self.assertEqual(expected1[i],da2.getIJ(i,0));
4383             pass
4384         da3=da2.invertArrayN2O2O2N(6);
4385         for i in xrange(6):
4386             self.assertEqual(arr1[i],da3.getIJ(i,0));
4387             pass
4388         #
4389         arr2=[3,-1,5,4,-1,0,-1,1,2,-1]
4390         da=DataArrayInt.New();
4391         da.setValues(arr2,10,1);
4392         da2=da.invertArrayO2N2N2O(6);
4393         self.assertEqual(6,da2.getNumberOfTuples());
4394         self.assertEqual(1,da2.getNumberOfComponents());
4395         expected2=[5,7,8,0,3,2]
4396         for i in xrange(6):
4397             self.assertEqual(expected2[i],da2.getIJ(i,0));
4398             pass
4399         da3=da2.invertArrayN2O2O2N(10);
4400         for i in xrange(10):
4401             self.assertEqual(arr2[i],da3.getIJ(i,0));
4402             pass
4403         pass
4404     
4405     def testKeepSetSelectedComponent1(self):
4406         arr1=[1.,2.,3.,4., 11.,12.,13.,14., 21.,22.,23.,24., 31.,32.,33.,34., 41.,42.,43.,44.]
4407         a1=DataArrayDouble.New();
4408         a1.setValues(arr1,5,4);
4409         expp=[21.,22.,23.,24.]
4410         self.assertEqual(4,len(a1.getTuple(2)));
4411         for i in xrange(4):
4412             self.assertAlmostEqual(expp[i],a1.getTuple(2)[i],12)
4413             pass
4414         a1.setInfoOnComponent(0,"aaaa");
4415         a1.setInfoOnComponent(1,"bbbb");
4416         a1.setInfoOnComponent(2,"cccc");
4417         a1.setInfoOnComponent(3,"dddd");
4418         arr2V=[1,2,1,2,0,0]
4419         a2=a1.keepSelectedComponents(arr2V);
4420         self.assertEqual(6,a2.getNumberOfComponents());
4421         self.assertEqual(5,a2.getNumberOfTuples());
4422         self.assertTrue(a2.getInfoOnComponent(0)=="bbbb");
4423         self.assertTrue(a2.getInfoOnComponent(1)=="cccc");
4424         self.assertTrue(a2.getInfoOnComponent(2)=="bbbb");
4425         self.assertTrue(a2.getInfoOnComponent(3)=="cccc");
4426         self.assertTrue(a2.getInfoOnComponent(4)=="aaaa");
4427         self.assertTrue(a2.getInfoOnComponent(5)=="aaaa");
4428         expected1=[2.,3.,2.,3.,1.,1., 12.,13.,12.,13.,11.,11., 22.,23.,22.,23.,21.,21., 32.,33.,32.,33.,31.,31., 42.,43.,42.,43.,41.,41.]
4429         for i in xrange(30):
4430             self.assertAlmostEqual(expected1[i],a2.getIJ(0,i),14);
4431             pass
4432         a3=a1.convertToIntArr();
4433         self.assertEqual([21,22,23,24],a3.getTuple(2))
4434         a4=a3.keepSelectedComponents(arr2V);
4435         self.assertEqual(6,a4.getNumberOfComponents());
4436         self.assertEqual(5,a4.getNumberOfTuples());
4437         self.assertTrue(a4.getInfoOnComponent(0)=="bbbb");
4438         self.assertTrue(a4.getInfoOnComponent(1)=="cccc");
4439         self.assertTrue(a4.getInfoOnComponent(2)=="bbbb");
4440         self.assertTrue(a4.getInfoOnComponent(3)=="cccc");
4441         self.assertTrue(a4.getInfoOnComponent(4)=="aaaa");
4442         self.assertTrue(a4.getInfoOnComponent(5)=="aaaa");
4443         for i in xrange(30):
4444             self.assertEqual(int(expected1[i]),a4.getIJ(0,i));
4445             pass
4446         # setSelectedComponents
4447         arr3V=[3,2]
4448         a5=a1.keepSelectedComponents(arr3V);
4449         a5.setInfoOnComponent(0,"eeee");
4450         a5.setInfoOnComponent(1,"ffff");
4451         arr4V=[1,2]
4452         a2.setSelectedComponents(a5,arr4V);
4453         self.assertEqual(6,a2.getNumberOfComponents());
4454         self.assertEqual(5,a2.getNumberOfTuples());
4455         self.assertTrue(a2.getInfoOnComponent(0)=="bbbb");
4456         self.assertTrue(a2.getInfoOnComponent(1)=="eeee");
4457         self.assertTrue(a2.getInfoOnComponent(2)=="ffff");
4458         self.assertTrue(a2.getInfoOnComponent(3)=="cccc");
4459         self.assertTrue(a2.getInfoOnComponent(4)=="aaaa");
4460         self.assertTrue(a2.getInfoOnComponent(5)=="aaaa");
4461         expected2=[2.,4.,3.,3.,1.,1., 12.,14.,13.,13.,11.,11., 22.,24.,23.,23.,21.,21., 32.,34.,33.,33.,31.,31., 42.,44.,43.,43.,41.,41.]
4462         for i in xrange(30):
4463             self.assertAlmostEqual(expected2[i],a2.getIJ(0,i),14);
4464             pass
4465         a6=a5.convertToIntArr();
4466         a6.setInfoOnComponent(0,"eeee");
4467         a6.setInfoOnComponent(1,"ffff");
4468         a4.setSelectedComponents(a6,arr4V);
4469         self.assertEqual(6,a4.getNumberOfComponents());
4470         self.assertEqual(5,a4.getNumberOfTuples());
4471         self.assertTrue(a4.getInfoOnComponent(0)=="bbbb");
4472         self.assertTrue(a4.getInfoOnComponent(1)=="eeee");
4473         self.assertTrue(a4.getInfoOnComponent(2)=="ffff");
4474         self.assertTrue(a4.getInfoOnComponent(3)=="cccc");
4475         self.assertTrue(a4.getInfoOnComponent(4)=="aaaa");
4476         self.assertTrue(a4.getInfoOnComponent(5)=="aaaa");
4477         for i in xrange(30):
4478             self.assertEqual(int(expected2[i]),a4.getIJ(0,i));
4479             pass
4480         # test of throw
4481         arr5V=[2,3,6]
4482         arr6V=[2,7,5]
4483         arr7V=[2,1,4,6]
4484         self.assertRaises(InterpKernelException,a2.keepSelectedComponents,arr5V);
4485         self.assertRaises(InterpKernelException,a2.keepSelectedComponents,arr6V);
4486         self.assertRaises(InterpKernelException,a2.setSelectedComponents,a1,arr7V);
4487         arr7V=arr7V[0:3]
4488         self.assertRaises(InterpKernelException,a2.setSelectedComponents,a1,arr7V);
4489         #
4490         pass
4491
4492     def testKeepSetSelectedComponent2(self):
4493         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
4494         arr1=[1.,2.,3.,4., 11.,12.,13.,14., 21.,22.,23.,24., 31.,32.,33.,34., 41.,42.,43.,44.]
4495         a1=DataArrayDouble.New();
4496         a1.setValues(arr1,5,4);
4497         a1.setInfoOnComponent(0,"aaaa");
4498         a1.setInfoOnComponent(1,"bbbb");
4499         a1.setInfoOnComponent(2,"cccc");
4500         a1.setInfoOnComponent(3,"dddd");
4501         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
4502         f1.setTime(2.3,4,5);
4503         f1.setMesh(m1);
4504         f1.setName("f1");
4505         f1.setArray(a1);
4506         f1.checkCoherency();
4507         #
4508         arr2V=[1,2,1,2,0,0]
4509         f2=f1.keepSelectedComponents(arr2V);
4510         self.assertTrue(f2.getTimeDiscretization()==ONE_TIME);
4511         t,dt,it=f2.getTime()
4512         self.assertAlmostEqual(2.3,t,13);
4513         self.assertEqual(4,dt);
4514         self.assertEqual(5,it);
4515         f2.checkCoherency();
4516         self.assertEqual(6,f2.getNumberOfComponents());
4517         self.assertEqual(5,f2.getNumberOfTuples());
4518         self.assertTrue(f2.getArray().getInfoOnComponent(0)=="bbbb");
4519         self.assertTrue(f2.getArray().getInfoOnComponent(1)=="cccc");
4520         self.assertTrue(f2.getArray().getInfoOnComponent(2)=="bbbb");
4521         self.assertTrue(f2.getArray().getInfoOnComponent(3)=="cccc");
4522         self.assertTrue(f2.getArray().getInfoOnComponent(4)=="aaaa");
4523         self.assertTrue(f2.getArray().getInfoOnComponent(5)=="aaaa");
4524         expected1=[2.,3.,2.,3.,1.,1., 12.,13.,12.,13.,11.,11., 22.,23.,22.,23.,21.,21., 32.,33.,32.,33.,31.,31., 42.,43.,42.,43.,41.,41.]
4525         for i in xrange(30):
4526             self.assertAlmostEqual(expected1[i],f2.getIJ(0,i),14);
4527             pass
4528         #setSelectedComponents
4529         arr3V=[3,2]
4530         f5=f1.keepSelectedComponents(arr3V);
4531         f5.setTime(6.7,8,9);
4532         f5.getArray().setInfoOnComponent(0,"eeee");
4533         f5.getArray().setInfoOnComponent(1,"ffff");
4534         f5.checkCoherency();
4535         arr4V=[1,2]
4536         f2.setSelectedComponents(f5,arr4V);
4537         self.assertEqual(6,f2.getNumberOfComponents());
4538         self.assertEqual(5,f2.getNumberOfTuples());
4539         f2.checkCoherency();
4540         t,dt,it=f2.getTime()
4541         self.assertAlmostEqual(2.3,t,13);
4542         self.assertEqual(4,dt);
4543         self.assertEqual(5,it);
4544         self.assertTrue(f2.getArray().getInfoOnComponent(0)=="bbbb");
4545         self.assertTrue(f2.getArray().getInfoOnComponent(1)=="eeee");
4546         self.assertTrue(f2.getArray().getInfoOnComponent(2)=="ffff");
4547         self.assertTrue(f2.getArray().getInfoOnComponent(3)=="cccc");
4548         self.assertTrue(f2.getArray().getInfoOnComponent(4)=="aaaa");
4549         self.assertTrue(f2.getArray().getInfoOnComponent(5)=="aaaa");
4550         expected2=[2.,4.,3.,3.,1.,1., 12.,14.,13.,13.,11.,11., 22.,24.,23.,23.,21.,21., 32.,34.,33.,33.,31.,31., 42.,44.,43.,43.,41.,41.]
4551         for i in xrange(30):
4552             self.assertAlmostEqual(expected2[i],f2.getIJ(0,i),14);
4553             pass
4554         #
4555         pass
4556     
4557     def testElementaryDAThrowAndSpecialCases(self):
4558         da=DataArrayInt.New();
4559         self.assertRaises(InterpKernelException, da.checkAllocated);
4560         self.assertRaises(InterpKernelException, da.fillWithValue, 1);
4561         self.assertRaises(InterpKernelException, da.iota, 1);
4562         da.alloc(7,1);
4563         da.fillWithValue(11); #11,11,11,11...
4564         da.iota(10); #10,11,12,13...
4565         
4566         db=DataArrayInt.New();
4567         db.alloc(7,2);
4568         
4569         dbl2=DataArrayDouble.New();
4570         dbl2.alloc(7,2);
4571         self.assertRaises(InterpKernelException, dbl2.isUniform, 10., 1e-15);
4572         self.assertRaises(InterpKernelException, dbl2.sort);
4573         self.assertRaises(InterpKernelException, dbl2.reverse);
4574         self.assertRaises(InterpKernelException, dbl2.iota, 10.);
4575         
4576         dbl=DataArrayDouble.New();
4577         #DataArrayDouble not allocated yet
4578         self.assertRaises(InterpKernelException, dbl.iota, 10.);
4579         self.assertRaises(InterpKernelException, dbl.isUniform, 10., 1e-15);
4580         self.assertRaises(InterpKernelException, dbl.sort);
4581         self.assertRaises(InterpKernelException, dbl.reverse);
4582         self.assertRaises(InterpKernelException, dbl.fromNoInterlace);
4583         self.assertRaises(InterpKernelException, dbl.toNoInterlace);
4584         
4585         dbl.alloc(7,1);
4586         dbl.iota(10.);
4587         self.assertTrue(not dbl.isUniform(10.,1e-15));
4588         dbl.sort();
4589         self.assertTrue(dbl.isMonotonic(True, .99));
4590         self.assertTrue(dbl.isMonotonic(True, -.99));
4591         self.assertTrue(not dbl.isMonotonic(True, 1.1));
4592         self.assertTrue(not dbl.isMonotonic(True, -1.1));
4593         dbl.reverse();
4594         self.assertTrue(dbl.isMonotonic(False, .99));
4595         self.assertTrue(not dbl.isMonotonic(False, 1.1));
4596         self.assertTrue(not dbl.isMonotonic(False, -1.1));
4597         
4598         dc=DataArrayInt.New();
4599         dc.alloc(14,1);
4600         
4601         dd=DataArrayDouble.New();
4602         self.assertRaises(InterpKernelException, dd.checkAllocated);
4603         self.assertRaises(InterpKernelException, dd.fillWithValue, 1.);
4604         self.assertRaises(InterpKernelException, dd.iota, 1.);
4605         self.assertTrue(not ((dd.repr().find("No data"))==-1));
4606         
4607         dd.alloc(0,1); #Allocated but nbOfElements==0!
4608         self.assertTrue(not ((dd.repr().find("Number of tuples : 0"))==-1));
4609         self.assertTrue(not ((dd.repr().find("Empty Data"))==-1));
4610         dd.fillWithValue(11); #?!...ok
4611         dd.iota(10); #?!...ok
4612         self.assertTrue(dd.isMonotonic(True, 1.));  #nothing is monotonic
4613         self.assertTrue(dd.isMonotonic(False, 1.));
4614         
4615         self.assertRaises(InterpKernelException, db.copyStringInfoFrom, da);
4616         self.assertRaises(InterpKernelException, db.copyStringInfoFrom, da);
4617         cIds=[2,2]
4618         self.assertRaises(InterpKernelException, da.copyPartOfStringInfoFrom, db, cIds);
4619         cIds[0]=1;
4620         cIds[0]=-1;
4621         self.assertRaises(InterpKernelException, da.copyPartOfStringInfoFrom, db, cIds);
4622         
4623         info=["infoOfOneComponent"]*2;
4624         self.assertRaises(InterpKernelException, da.setInfoOnComponents, info);
4625         self.assertRaises(InterpKernelException, da.setInfoOnComponent, 1, info[0]);
4626         db.setInfoOnComponents(info);
4627         
4628         self.assertRaises(InterpKernelException, da.getInfoOnComponent, -1);
4629         self.assertRaises(InterpKernelException, da.getInfoOnComponent, 2);
4630         self.assertTrue(db.getInfoOnComponent(1)==db.getInfoOnComponent(0));
4631         self.assertRaises(InterpKernelException, db.getVarOnComponent, -1);
4632         self.assertRaises(InterpKernelException, db.getVarOnComponent, 2);
4633         self.assertRaises(InterpKernelException, db.getUnitOnComponent, -1);
4634         self.assertRaises(InterpKernelException, db.getUnitOnComponent, 2);
4635         
4636         self.assertTrue(da.GetVarNameFromInfo("varname unit ")=="varname unit ");
4637         self.assertTrue(da.GetVarNameFromInfo("varname]unit[")=="varname]unit[");
4638         self.assertTrue(da.GetVarNameFromInfo("[unit]")=="");
4639         self.assertTrue(da.GetVarNameFromInfo("varname [unit]")=="varname");
4640         
4641         self.assertTrue(da.GetUnitFromInfo("varname unit ")=="");
4642         self.assertTrue(da.GetUnitFromInfo("varname]unit[")=="");
4643         self.assertTrue(da.GetUnitFromInfo("[unit]")=="unit");
4644         self.assertTrue(da.GetUnitFromInfo("varname [unit]")=="unit");
4645         
4646         self.assertRaises(InterpKernelException, da.checkNbOfTuplesAndComp, db, "theMessageInThrow");
4647         self.assertRaises(InterpKernelException, da.checkNbOfTuplesAndComp, dc, "theMessageInThrow");
4648         self.assertRaises(InterpKernelException, db.checkNbOfTuplesAndComp, dc, "theMessageInThrow");
4649         
4650         self.assertRaises(InterpKernelException, da.checkNbOfTuplesAndComp, 7, 2, "theMessageInThrow");
4651         da.checkNbOfTuplesAndComp(7,1,"theMessageInThrow");
4652         
4653         self.assertRaises(InterpKernelException, db.checkNbOfElems, 7*2+1, "theMessageInThrow");
4654         db.checkNbOfElems(7*2,"theMessageInThrow");
4655         
4656         self.assertRaises(InterpKernelException, db.GetNumberOfItemGivenBES, 10, 9, 1, "theMessageInThrow");
4657         self.assertRaises(InterpKernelException, db.GetNumberOfItemGivenBES, 0, 1, -1, "theMessageInThrow");
4658         self.assertEqual(10,db.GetNumberOfItemGivenBES(0,10,1,"theMessageInThrow"));
4659         self.assertEqual(5,db.GetNumberOfItemGivenBES(0,10,2,"theMessageInThrow"));
4660         self.assertEqual(6,db.GetNumberOfItemGivenBES(0,11,2,"theMessageInThrow"));
4661         
4662         self.assertTrue(not ((da.repr().find("Number of components : 1"))==-1));
4663         self.assertTrue(not ((dd.repr().find("Number of components : 1"))==-1));
4664         self.assertTrue(not ((dbl.repr().find("Number of components : 1"))==-1));
4665         
4666         self.assertTrue(not ((da.reprZip().find("Number of components : 1"))==-1));
4667         self.assertTrue(not ((dd.reprZip().find("Number of components : 1"))==-1));
4668         self.assertTrue(not ((dbl.reprZip().find("Number of components : 1"))==-1));
4669         
4670         self.assertRaises(InterpKernelException, dbl.selectByTupleId2, 0, 1, -1);
4671         self.assertRaises(InterpKernelException, dbl.substr, -1, 1);
4672         self.assertRaises(InterpKernelException, dbl.substr, 8, 1);
4673         self.assertRaises(InterpKernelException, dbl.substr, 0, 8);
4674         self.assertRaises(InterpKernelException, dbl.meldWith, dd);
4675         
4676         self.assertRaises(InterpKernelException, dbl.setPartOfValuesAdv, dbl2, da); #dbl dbl2 not have the same number of components
4677         self.assertRaises(InterpKernelException, dbl.setPartOfValuesAdv, dd, da);  #da tuple selector DataArrayInt instance not have exactly 2 components
4678         
4679         dbl3=DataArrayDouble.New();
4680         dbl3.alloc(6,2);
4681         dbl3.fillWithValue(11.);
4682         #bad number of components
4683         self.assertRaises(InterpKernelException, dbl3.getMaxValue);
4684         self.assertRaises(InterpKernelException, dd.getMaxValue);
4685         self.assertRaises(InterpKernelException, dbl3.getMinValue);
4686         self.assertRaises(InterpKernelException, dd.getMinValue);
4687         self.assertRaises(InterpKernelException, dbl3.getAverageValue);
4688         self.assertRaises(InterpKernelException, dd.getAverageValue);
4689         self.assertRaises(InterpKernelException, dd.accumulate, 100);
4690         self.assertRaises(InterpKernelException, dbl.fromPolarToCart);
4691         self.assertRaises(InterpKernelException, dbl3.fromCylToCart);
4692         self.assertRaises(InterpKernelException, dbl3.fromSpherToCart);
4693         self.assertRaises(InterpKernelException, dbl3.doublyContractedProduct);
4694         self.assertRaises(InterpKernelException, dbl3.determinant);
4695         self.assertRaises(InterpKernelException, dbl3.eigenValues);
4696         self.assertRaises(InterpKernelException, dbl3.eigenVectors);
4697         self.assertRaises(InterpKernelException, dbl3.inverse);
4698         self.assertRaises(InterpKernelException, dbl3.trace);
4699         self.assertRaises(InterpKernelException, dbl3.deviator);
4700         
4701         dbl3.setIJ(5,1,12.);
4702         self.assertTrue(dbl3.getMaxValueInArray()==12.);
4703         self.assertTrue(dbl3.getMinValueInArray()==11.);
4704         
4705         db.fillWithValue(100); #bad Ids
4706         self.assertRaises(InterpKernelException, dbl3.setPartOfValuesAdv, dbl2, db);
4707         db.fillWithValue(-1); #bad Ids
4708         self.assertRaises(InterpKernelException, dbl3.setPartOfValuesAdv, dbl2, db);
4709         db.fillWithValue(6); #bad Ids for dbl3
4710         self.assertRaises(InterpKernelException, dbl3.setPartOfValuesAdv, dbl2, db);
4711         
4712         dbl3.checkNoNullValues();
4713         dbl3.setIJ(5,0,0.);
4714         self.assertRaises(InterpKernelException, dbl3.checkNoNullValues);
4715         self.assertRaises(InterpKernelException, dbl3.applyInv, 1.);  #div by zero
4716         self.assertRaises(InterpKernelException, dbl2.getIdsInRange, 1., 2.);
4717         a=[]
4718         self.assertRaises(InterpKernelException, DataArrayDouble_Aggregate, a);
4719         self.assertRaises(InterpKernelException, DataArrayDouble_Meld, a);
4720         
4721         a=[dbl2,dbl]; #Nb of components mismatch
4722         self.assertRaises(InterpKernelException, DataArrayDouble_Aggregate, a);
4723         
4724         self.assertRaises(InterpKernelException, DataArrayDouble_Dot, dbl2, dbl);
4725         
4726         self.assertRaises(InterpKernelException, DataArrayDouble_CrossProduct, dbl2, dbl); #Nb of components mismatch
4727         self.assertRaises(InterpKernelException, DataArrayDouble_CrossProduct, dbl2, dbl2); #Nb of components must be equal to 3
4728         dbl4=DataArrayDouble.New();
4729         dbl4.alloc(6,3);
4730         dbl5=DataArrayDouble.New();
4731         dbl5.alloc(7,3);
4732         self.assertRaises(InterpKernelException, DataArrayDouble_CrossProduct, dbl4, dbl5); #Nb of tuples mismatch
4733         
4734         a[0]=dbl4; #Nb of tuple mismatch
4735         a[1]=dbl5; #Nb of tuple mismatch
4736         self.assertRaises(InterpKernelException, DataArrayDouble_Meld, a);
4737         self.assertRaises(InterpKernelException, DataArrayDouble_Dot, dbl4, dbl5);
4738         pass
4739
4740     def testDAIGetIdsEqual1(self):
4741         tab1=[5,-2,-4,-2,3,2,-2];
4742         da=DataArrayInt.New();
4743         da.setValues(tab1,7,1);
4744         da2=da.getIdsEqual(-2);
4745         self.assertEqual(3,da2.getNumberOfTuples());
4746         self.assertEqual(1,da2.getNumberOfComponents());
4747         expected1=[1,3,6];
4748         self.assertEqual(expected1,da2.getValues());
4749         pass
4750
4751     def testDAIGetIdsEqualList1(self):
4752         tab1=[5,-2,-4,-2,3,2,-2];
4753         da=DataArrayInt.New();
4754         da.setValues(tab1,7,1);
4755         da2=da.getIdsEqualList([3,-2,0]);
4756         self.assertEqual(4,da2.getNumberOfTuples());
4757         self.assertEqual(1,da2.getNumberOfComponents());
4758         expected1=[1,3,4,6];
4759         self.assertEqual(expected1,da2.getValues());
4760         pass
4761
4762     def testDAFromNoInterlace1(self):
4763         tab1=[1,11,21,31,41,2,12,22,32,42,3,13,23,33,43]
4764         da=DataArrayInt.New();
4765         da.setValues(tab1,5,3);
4766         da2=da.fromNoInterlace();
4767         expected1=[1,2,3,11,12,13,21,22,23,31,32,33,41,42,43]
4768         self.assertEqual(5,da2.getNumberOfTuples());
4769         self.assertEqual(3,da2.getNumberOfComponents());# it's not a bug. Avoid to have 1 million components !
4770         self.assertEqual(expected1,da2.getValues());
4771         da3=da.convertToDblArr();
4772         da4=da3.fromNoInterlace();
4773         self.assertEqual(5,da4.getNumberOfTuples());
4774         self.assertEqual(3,da4.getNumberOfComponents());# it's not a bug. Avoid to have 1 million components !
4775         for i in xrange(15):
4776             self.assertAlmostEqual(expected1[i],da4.getIJ(0,i),14);
4777             pass
4778         pass
4779     
4780     def testDAToNoInterlace1(self):
4781         tab1=[1,2,3,11,12,13,21,22,23,31,32,33,41,42,43]
4782         da=DataArrayInt.New();
4783         da.setValues(tab1,5,3);
4784         da2=da.toNoInterlace();
4785         expected1=[1,11,21,31,41,2,12,22,32,42,3,13,23,33,43]
4786         self.assertEqual(5,da2.getNumberOfTuples());
4787         self.assertEqual(3,da2.getNumberOfComponents());# it's not a bug. Avoid to have 1 million components !
4788         self.assertEqual(expected1,da2.getValues());
4789         da3=da.convertToDblArr();
4790         da4=da3.toNoInterlace();
4791         self.assertEqual(5,da4.getNumberOfTuples());
4792         self.assertEqual(3,da4.getNumberOfComponents());# it's not a bug. Avoid to have 1 million components !
4793         for i in xrange(15):
4794             self.assertAlmostEqual(expected1[i],da4.getIJ(0,i),14);
4795             pass
4796         pass
4797     
4798     def testDAIsUniform1(self):
4799         tab1=[1,1,1,1,1]
4800         da=DataArrayInt.New();
4801         da.setValues(tab1,5,1);
4802         self.assertTrue(da.isUniform(1));
4803         da.setIJ(2,0,2);
4804         self.assertTrue(not da.isUniform(1));
4805         da.setIJ(2,0,1);
4806         self.assertTrue(da.isUniform(1));
4807         da2=da.convertToDblArr();
4808         self.assertTrue(da2.isUniform(1.,1.e-12));
4809         da2.setIJ(1,0,1.+1.e-13);
4810         self.assertTrue(da2.isUniform(1.,1.e-12));
4811         da2.setIJ(1,0,1.+1.e-11);
4812         self.assertTrue(not da2.isUniform(1.,1.e-12));
4813         pass
4814     
4815     def testDADFromPolarToCart1(self):
4816         tab1=[2.,0.2,2.5,0.7]
4817         da=DataArrayDouble.New();
4818         da.setValues(tab1,2,2);
4819         da2=da.fromPolarToCart();
4820         expected1=[1.9601331556824833,0.39733866159012243, 1.9121054682112213,1.6105442180942275]
4821         for i in xrange(4):
4822             self.assertAlmostEqual(expected1[i],da2.getIJ(0,i),13);
4823             pass
4824         pass
4825     
4826     def testDADFromCylToCart1(self):
4827         tab1=[2.,0.2,4.,2.5,0.7,9.]
4828         da=DataArrayDouble.New();
4829         da.setValues(tab1,2,3);
4830         da2=da.fromCylToCart();
4831         expected1=[1.9601331556824833,0.39733866159012243,4., 1.9121054682112213,1.6105442180942275,9.]
4832         for i in xrange(6):
4833             self.assertAlmostEqual(expected1[i],da2.getIJ(0,i),13);
4834             pass
4835         pass
4836     
4837     def testDADFromSpherToCart1(self):
4838         tab1=[2.,0.2,0.3,2.5,0.7,0.8]
4839         da=DataArrayDouble.New();
4840         da.setValues(tab1,2,3);
4841         da2=da.fromSpherToCart();
4842         expected1=[0.37959212195737485,0.11742160338765303,1.9601331556824833, 1.1220769624465328,1.1553337045129035,1.9121054682112213]
4843         for i in xrange(6):
4844             self.assertAlmostEqual(expected1[i],da2.getIJ(0,i),13);
4845             pass
4846         pass
4847
4848     def testUnPolyze1(self):
4849         elts=[0,1,2,3,4,5,6,7]
4850         eltsV=elts;
4851         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
4852         mesh.convertToPolyTypes(eltsV);
4853         mesh.unPolyze();
4854         mesh2=MEDCouplingDataForTest.build3DTargetMesh_1();
4855         mesh.checkCoherency();
4856         self.assertTrue(mesh.isEqual(mesh2,1e-12));
4857         mesh.convertToPolyTypes(eltsV);
4858         self.assertTrue(not mesh.isEqual(mesh2,1e-12));
4859         mesh.getNodalConnectivity().setIJ(0,6,10);
4860         mesh.getNodalConnectivity().setIJ(0,7,9);
4861         mesh.getNodalConnectivity().setIJ(0,8,12);
4862         mesh.getNodalConnectivity().setIJ(0,9,13);
4863         mesh.unPolyze();
4864         self.assertTrue(mesh.isEqual(mesh2,1e-12));
4865         mesh.convertToPolyTypes(eltsV);
4866         mesh.getNodalConnectivity().setIJ(0,6,12);
4867         mesh.getNodalConnectivity().setIJ(0,7,13);
4868         mesh.getNodalConnectivity().setIJ(0,8,10);
4869         mesh.getNodalConnectivity().setIJ(0,9,9);
4870         mesh.unPolyze();
4871         self.assertTrue(mesh.isEqual(mesh2,1e-12));
4872         mesh.convertToPolyTypes(eltsV);
4873         mesh.getNodalConnectivity().setIJ(0,6,12);
4874         mesh.getNodalConnectivity().setIJ(0,7,10);
4875         mesh.getNodalConnectivity().setIJ(0,8,13);
4876         mesh.getNodalConnectivity().setIJ(0,9,9);
4877         mesh.unPolyze();
4878         self.assertTrue(not mesh.isEqual(mesh2,1e-12));
4879         # Test for 2D mesh
4880         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
4881         mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
4882         eltsV=eltsV[:5];
4883         mesh.convertToPolyTypes(eltsV);
4884         self.assertTrue(not mesh.isEqual(mesh2,1e-12));
4885         mesh.unPolyze();
4886         self.assertTrue(mesh.isEqual(mesh2,1e-12));
4887         pass
4888
4889     def testConvertDegeneratedCells1(self):
4890         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
4891         conn=[0,1,3,3,9,10,12,12, 0,1,3,4,9,9,9,9, 1,1,1,1,10,12,9,10, 10,11,12,9,1,1,1,1]
4892         mesh.allocateCells(4);
4893         mesh.insertNextCell(NORM_HEXA8,8,conn[0:8])
4894         mesh.insertNextCell(NORM_HEXA8,8,conn[8:16])
4895         mesh.insertNextCell(NORM_HEXA8,8,conn[16:24])
4896         mesh.insertNextCell(NORM_HEXA8,8,conn[24:32])
4897         mesh.finishInsertingCells();
4898         mesh.checkCoherency();
4899         self.assertEqual(4,mesh.getNumberOfCells());
4900         self.assertEqual(NORM_HEXA8,mesh.getTypeOfCell(0));
4901         self.assertEqual(NORM_HEXA8,mesh.getTypeOfCell(1));
4902         self.assertEqual(NORM_HEXA8,mesh.getTypeOfCell(2));
4903         self.assertEqual(NORM_HEXA8,mesh.getTypeOfCell(3));
4904         f1=mesh.getMeasureField(True);
4905         mesh.convertDegeneratedCells();
4906         mesh.checkCoherency();
4907         f2=mesh.getMeasureField(True);
4908         self.assertEqual(4,mesh.getNumberOfCells());
4909         self.assertEqual(NORM_PENTA6,mesh.getTypeOfCell(0));
4910         self.assertEqual(NORM_PYRA5,mesh.getTypeOfCell(1));
4911         self.assertEqual(NORM_TETRA4,mesh.getTypeOfCell(2));
4912         self.assertEqual(NORM_PYRA5,mesh.getTypeOfCell(3));
4913         for i in xrange(4):
4914             self.assertAlmostEqual(f1.getArray().getIJ(0,i),f2.getArray().getIJ(0,i),5);
4915             pass
4916         pass
4917
4918     def testGetNodeIdsNearPoints1(self):
4919         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
4920         coords=mesh.getCoords();
4921         tmp=DataArrayDouble.New();
4922         vals=[0.2,0.2,0.1,0.2,0.2,0.2]
4923         tmp.setValues(vals,3,2);
4924         tmp2=DataArrayDouble.Aggregate(coords,tmp);
4925         mesh.setCoords(tmp2);
4926         pts=[0.2,0.2,0.1,0.3,-0.3,0.7]
4927         c=mesh.getNodeIdsNearPoint(pts[:2],1e-7);
4928         self.assertEqual([4,9,11],c.getValues());
4929         c,cI=mesh.getNodeIdsNearPoints(pts,3,1e-7);
4930         self.assertEqual([0,3,3,4],cI.getValues());
4931         self.assertEqual([4,9,11,6],c.getValues());
4932         c,cI=mesh.getNodeIdsNearPoints(pts,1e-7);
4933         self.assertEqual([0,3,3,4],cI.getValues());
4934         self.assertEqual([4,9,11,6],c.getValues());
4935         c,cI=mesh.getNodeIdsNearPoints(DataArrayDouble.New(pts,3,2),1e-7);
4936         self.assertEqual([0,3,3,4],cI.getValues());
4937         self.assertEqual([4,9,11,6],c.getValues());
4938         self.assertRaises(InterpKernelException,mesh.getNodeIdsNearPoints,DataArrayDouble.New(pts,2,3),1e-7);
4939         pass
4940
4941     def testFieldCopyTinyAttrFrom1(self):
4942         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
4943         f1.setName("f1");
4944         f1.setTimeTolerance(1.e-5);
4945         f1.setDescription("f1Desc");
4946         f1.setTime(1.23,4,5);
4947         f2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
4948         f2.setName("f2");
4949         f2.setDescription("f2Desc");
4950         f2.setTime(6.78,9,10);
4951         f2.setTimeTolerance(4.556e-12);
4952         #
4953         f1.copyTinyAttrFrom(f2);
4954         self.assertAlmostEqual(4.556e-12,f1.getTimeTolerance(),24);
4955         t,dt,it=f1.getTime()
4956         self.assertAlmostEqual(6.78,t,12);
4957         self.assertEqual(9,dt);
4958         self.assertEqual(10,it);
4959         self.assertTrue(f1.getName()=="f1");#name unchanged
4960         self.assertTrue(f1.getDescription()=="f1Desc");#description unchanged
4961         #
4962         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
4963         f1.setName("f1");
4964         f1.setTimeTolerance(1.e-5);
4965         f1.setDescription("f1Desc");
4966         f2=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
4967         f2.setName("f2");
4968         f2.setDescription("f2Desc");
4969         f2.setTimeTolerance(4.556e-12);
4970         #
4971         f1.copyTinyAttrFrom(f2);
4972         self.assertAlmostEqual(4.556e-12,f1.getTimeTolerance(),24);
4973         self.assertTrue(f1.getName()=="f1");#name unchanged
4974         self.assertTrue(f1.getDescription()=="f1Desc");#description unchanged
4975         #
4976         f1=MEDCouplingFieldDouble.New(ON_CELLS,CONST_ON_TIME_INTERVAL);
4977         f1.setName("f1");
4978         f1.setTimeTolerance(1.e-5);
4979         f1.setDescription("f1Desc");
4980         f1.setTime(1.23,4,5);
4981         f1.setEndTime(5.43,2,1);
4982         f2=MEDCouplingFieldDouble.New(ON_CELLS,CONST_ON_TIME_INTERVAL);
4983         f2.setName("f2");
4984         f2.setDescription("f2Desc");
4985         f2.setTimeTolerance(4.556e-12);
4986         f2.setTime(6.78,9,10);
4987         f2.setEndTime(10.98,7,6);
4988         #
4989         f1.copyTinyAttrFrom(f2);
4990         self.assertAlmostEqual(4.556e-12,f1.getTimeTolerance(),24);
4991         self.assertTrue(f1.getName()=="f1");#name unchanged
4992         self.assertTrue(f1.getDescription()=="f1Desc");#description unchanged
4993         t,dt,it=f1.getTime()
4994         self.assertAlmostEqual(6.78,t,12);
4995         self.assertEqual(9,dt);
4996         self.assertEqual(10,it);
4997         t,dt,it=f1.getEndTime()
4998         self.assertAlmostEqual(10.98,t,12);
4999         self.assertEqual(7,dt);
5000         self.assertEqual(6,it);
5001         #
5002         f1=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
5003         f1.setName("f1");
5004         f1.setTimeTolerance(1.e-5);
5005         f1.setDescription("f1Desc");
5006         f1.setTime(1.23,4,5);
5007         f1.setEndTime(5.43,2,1);
5008         f2=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
5009         f2.setName("f2");
5010         f2.setDescription("f2Desc");
5011         f2.setTimeTolerance(4.556e-12);
5012         f2.setTime(6.78,9,10);
5013         f2.setEndTime(10.98,7,6);
5014         #
5015         f1.copyTinyAttrFrom(f2);
5016         self.assertAlmostEqual(4.556e-12,f1.getTimeTolerance(),24);
5017         self.assertTrue(f1.getName()=="f1");#name unchanged
5018         self.assertTrue(f1.getDescription()=="f1Desc");#description unchanged
5019         t,dt,it=f1.getTime()
5020         self.assertAlmostEqual(6.78,t,12);
5021         self.assertEqual(9,dt);
5022         self.assertEqual(10,it);
5023         t,dt,it=f1.getEndTime()
5024         self.assertAlmostEqual(10.98,t,12);
5025         self.assertEqual(7,dt);
5026         self.assertEqual(6,it);
5027         pass
5028
5029     def testExtrudedMesh5(self):
5030         coo1=[0.,1.,2.,3.5]
5031         a=DataArrayDouble.New();
5032         a.setValues(coo1,4,1);
5033         b=MEDCouplingCMesh.New();
5034         b.setCoordsAt(0,a);
5035         c=b.buildUnstructured();
5036         self.assertEqual(1,c.getSpaceDimension());
5037         c.changeSpaceDimension(2);
5038         #
5039         d=DataArrayDouble.New();
5040         d.alloc(13,1);
5041         d.iota();
5042         e=MEDCouplingCMesh.New();
5043         e.setCoordsAt(0,d);
5044         f=e.buildUnstructured();
5045         g=f.getCoords().applyFunc(2,"3.5*IVec+x/6*3.14159265359*JVec");
5046         self.assertRaises(InterpKernelException,f.getCoords().applyFunc,2,"3.5*IVec+x/6*3.14159265359*KVec"); # KVec refers to component #2 and there is only 2 components !
5047         h=g.fromPolarToCart();
5048         f.setCoords(h);
5049         i=c.buildExtrudedMesh(f,1);
5050         self.assertEqual(52,i.getNumberOfNodes());
5051         tmp,tmp2,tmp3=i.mergeNodes(1e-9);
5052         self.assertTrue(tmp2);
5053         self.assertEqual(37,tmp3);
5054         i.convertDegeneratedCells();
5055         i.checkCoherency();
5056         self.assertEqual(36,i.getNumberOfCells());
5057         self.assertEqual(37,i.getNumberOfNodes());
5058         self.assertEqual(12,i.getNumberOfCellsWithType(NORM_TRI3));
5059         self.assertEqual(24,i.getNumberOfCellsWithType(NORM_QUAD4));
5060         expected1=[0.25,0.75,2.0625]
5061         j=i.getMeasureField(True);
5062         for ii in xrange(12):
5063             for k in xrange(3):
5064                 self.assertAlmostEqual(expected1[k],j.getIJ(0,ii*3+k),10);
5065                 pass
5066             pass
5067         expected2=[0.62200846792814113, 0.16666666666681595, 1.4513530918323276, 0.38888888888923495, 2.6293994326053212, 0.7045454545460802, 0.45534180126145435, 0.45534180126150181, 1.0624642029433926, 1.0624642029435025, 1.9248539780597826, 1.9248539780599816, 0.16666666666661334, 0.62200846792815856, 0.38888888888876294, 1.4513530918323678, 0.70454545454522521, 2.629399432605394, -0.16666666666674007, 0.62200846792812436, -0.38888888888906142, 1.4513530918322881, -0.70454545454576778, 2.6293994326052488, -0.45534180126154766, 0.45534180126140844, -1.0624642029436118, 1.0624642029432834, -1.9248539780601803, 1.9248539780595841, -0.62200846792817499, 0.1666666666665495, -1.451353091832408, 0.388888888888613, -2.6293994326054668, 0.70454545454495332, -0.62200846792810593, -0.16666666666680507, -1.451353091832247, -0.38888888888921297, -2.6293994326051746, -0.70454545454604123, -0.45534180126135926, -0.45534180126159562, -1.0624642029431723, -1.0624642029437235, -1.9248539780593836, -1.9248539780603811, -0.1666666666664828, -0.62200846792819242, -0.38888888888846079, -1.4513530918324489, -0.70454545454467987, -2.6293994326055397, 0.16666666666687083, -0.62200846792808862, 0.38888888888936374, -1.4513530918322073, 0.70454545454631357, -2.6293994326051022, 0.45534180126164348, -0.45534180126131207, 1.0624642029438327, -1.0624642029430627, 1.9248539780605791, -1.9248539780591853, 0.62200846792821063, -0.16666666666641802, 1.4513530918324888, -0.38888888888831086, 2.6293994326056125, -0.70454545454440853]
5068         m=i.getBarycenterAndOwner();
5069         for i in xrange(72):
5070             self.assertAlmostEqual(expected2[i],m.getIJ(0,i),10);
5071             pass
5072         #
5073         pass
5074
5075     def testExtrudedMesh6(self):
5076         coo1=[0.,1.,2.,3.5]
5077         a=DataArrayDouble.New();
5078         a.setValues(coo1,4,1);
5079         b=MEDCouplingCMesh.New();
5080         b.setCoordsAt(0,a);
5081         c=b.buildUnstructured();
5082         self.assertEqual(1,c.getSpaceDimension());
5083         c.changeSpaceDimension(2);
5084         #
5085         d=DataArrayDouble.New();
5086         d.alloc(5,1);
5087         d.iota();
5088         e=MEDCouplingCMesh.New();
5089         e.setCoordsAt(0,d);
5090         f=e.buildUnstructured();
5091         d2=f.getCoords().applyFunc("x*x/2");
5092         f.setCoords(d2);
5093         f.changeSpaceDimension(2);
5094         #
5095         center=[0.,0.]
5096         f.rotate(center,None,pi/3);
5097         g=c.buildExtrudedMesh(f,0);
5098         g.checkCoherency();
5099         expected1=[ 0.4330127018922193, 0.4330127018922193, 0.649519052838329, 1.2990381056766578, 1.299038105676658, 1.948557158514987, 2.1650635094610955, 2.1650635094610964, 3.2475952641916446, 3.031088913245533, 3.0310889132455352, 4.546633369868303 ]
5100         f1=g.getMeasureField(True);
5101         for i in xrange(12):
5102             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),12);
5103             pass
5104         expected2=[0.625, 0.21650635094610962, 1.625, 0.21650635094610959, 2.8750000000000004, 0.21650635094610965, 1.1250000000000002, 1.0825317547305482, 2.125, 1.0825317547305482, 3.3750000000000004, 1.0825317547305484, 2.125, 2.8145825622994254, 3.125, 2.8145825622994254, 4.375, 2.8145825622994254, 3.6250000000000009, 5.4126587736527414, 4.625, 5.4126587736527414, 5.875, 5.4126587736527414]
5105         f2=g.getBarycenterAndOwner();
5106         for i in xrange(24):
5107             self.assertAlmostEqual(expected2[i],f2.getIJ(0,i),12);
5108             pass
5109         pass
5110
5111     def testExtrudedMesh7(self):
5112         coo1=[0.,1.,2.,3.5]
5113         a=DataArrayDouble.New();
5114         a.setValues(coo1,4,1);
5115         b=MEDCouplingCMesh.New();
5116         b.setCoordsAt(0,a);
5117         c=b.buildUnstructured();
5118         self.assertEqual(1,c.getSpaceDimension());
5119         c.changeSpaceDimension(2);
5120         #
5121         d=DataArrayDouble.New();
5122         d.alloc(13,1);
5123         d.iota();
5124         e=MEDCouplingCMesh.New();
5125         e.setCoordsAt(0,d);
5126         f=e.buildUnstructured();
5127         g=f.getCoords().applyFunc(2,"3.5*IVec+x/6*3.14159265359*JVec");
5128         h=g.fromPolarToCart();
5129         f.setCoords(h);
5130         i=c.buildExtrudedMesh(f,1);
5131         self.assertEqual(52,i.getNumberOfNodes());
5132         tmp,tmp2,tmp3=i.mergeNodes(1e-9);
5133         self.assertTrue(tmp2);
5134         self.assertEqual(37,tmp3);
5135         i.convertDegeneratedCells();
5136         vec1=[10.,0]
5137         i.translate(vec1);
5138         g2=h.applyFunc(3,"13.5/3.5*x*IVec+0*JVec+13.5/3.5*y*KVec");
5139         f.setCoords(g2);
5140         i.changeSpaceDimension(3);
5141         i3=i.buildExtrudedMesh(f,1);
5142         f2=i3.getMeasureField(True);
5143         tmp,tmp2,tmp3=i.mergeNodes(1e-9);
5144         self.assertTrue(tmp2);
5145         self.assertEqual(444,tmp3);
5146         expected1=[1.327751058489274, 4.2942574094314701, 13.024068164857139, 1.3069177251569044, 4.1484240761012954, 12.297505664866796, 1.270833333332571, 3.8958333333309674, 11.039062499993179, 1.2291666666659207, 3.6041666666644425, 9.585937499993932, 1.1930822748415895, 3.3515759238941376, 8.3274943351204556, 1.1722489415082769, 3.2057425905609289, 7.6009318351210622, 1.1722489415082862, 3.2057425905609884, 7.6009318351213713, 1.1930822748416161, 3.3515759238943001, 8.3274943351212727, 1.2291666666659564, 3.6041666666646734, 9.5859374999950777, 1.2708333333326081, 3.8958333333311868, 11.039062499994293, 1.3069177251569224, 4.1484240761014384, 12.297505664867627, 1.3277510584902354, 4.2942574094346071, 13.024068164866796]
5147         for ii in xrange(12):
5148             for jj in xrange(36):
5149                 self.assertAlmostEqual(expected1[jj],f2.getIJ(0,ii*36+jj),9);
5150                 pass
5151         #
5152         pass
5153
5154     def testSimplexize1(self):
5155         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5156         m.convertToPolyTypes([3]);
5157         da=m.simplexize(0);
5158         self.assertEqual(7,da.getNumberOfTuples());
5159         self.assertEqual(1,da.getNumberOfComponents());
5160         expected2=[0,0,1,2,3,4,4]
5161         for i in xrange(7):
5162             self.assertEqual(expected2[i],da.getIJ(i,0));
5163             pass
5164         m.checkCoherency();
5165         self.assertEqual(7,m.getNumberOfCells());
5166         self.assertEqual(NORM_TRI3,m.getTypeOfCell(0));
5167         self.assertEqual(NORM_TRI3,m.getTypeOfCell(1));
5168         self.assertEqual(NORM_TRI3,m.getTypeOfCell(2));
5169         self.assertEqual(NORM_TRI3,m.getTypeOfCell(3));
5170         self.assertEqual(NORM_POLYGON,m.getTypeOfCell(4));
5171         self.assertEqual(NORM_TRI3,m.getTypeOfCell(5));
5172         self.assertEqual(NORM_TRI3,m.getTypeOfCell(6));
5173         expected1=[0.125,0.125,0.125,0.125,0.25,0.125,0.125]
5174         f=m.getMeasureField(False);
5175         for i in xrange(7):
5176             self.assertAlmostEqual(expected1[i]*sqrt(2.),f.getIJ(i,0),10);
5177             pass
5178         types=m.getAllTypes();
5179         self.assertEqual([NORM_TRI3,NORM_POLYGON],types);
5180         #
5181         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5182         m.convertToPolyTypes([3]);
5183         da=m.simplexize(1);
5184         self.assertEqual(7,da.getNumberOfTuples());
5185         self.assertEqual(1,da.getNumberOfComponents());
5186         for i in xrange(7):
5187             self.assertEqual(expected2[i],da.getIJ(i,0));
5188             pass
5189         m.checkCoherency();
5190         types=m.getAllTypes();
5191         self.assertEqual([NORM_TRI3,NORM_POLYGON],types);
5192         self.assertEqual(7,m.getNumberOfCells());
5193         self.assertEqual(NORM_TRI3,m.getTypeOfCell(0));
5194         self.assertEqual(NORM_TRI3,m.getTypeOfCell(1));
5195         self.assertEqual(NORM_TRI3,m.getTypeOfCell(2));
5196         self.assertEqual(NORM_TRI3,m.getTypeOfCell(3));
5197         self.assertEqual(NORM_POLYGON,m.getTypeOfCell(4));
5198         self.assertEqual(NORM_TRI3,m.getTypeOfCell(5));
5199         self.assertEqual(NORM_TRI3,m.getTypeOfCell(6));
5200         f=m.getMeasureField(False);
5201         for i in xrange(7):
5202             self.assertAlmostEqual(expected1[i]*sqrt(2.),f.getIJ(i,0),10);
5203             pass
5204         pass
5205
5206     def testSimplexize2(self):
5207         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5208         m.convertToPolyTypes([3]);
5209         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
5210         f1.setMesh(m);
5211         arr=DataArrayDouble.New();
5212         arr1=[10.,110.,20.,120.,30.,130.,40.,140.,50.,150.]
5213         arr.setValues(arr1,5,2);
5214         f1.setArray(arr);
5215         #
5216         f1.checkCoherency();
5217         self.assertTrue(f1.simplexize(0));
5218         f1.checkCoherency();
5219         expected1=[10.,110.,10.,110.,20.,120.,30.,130.,40.,140.,50.,150.,50.,150.]
5220         for i in xrange(14):
5221             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),10);
5222             pass
5223         self.assertTrue(not f1.simplexize(0));
5224         for i in xrange(14):
5225             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),10);
5226             pass
5227         #
5228         pass
5229
5230     def testDAMeld1(self):
5231         da1=DataArrayDouble.New();
5232         da1.alloc(7,2);
5233         da2=DataArrayDouble.New();
5234         da2.alloc(7,1);
5235         #
5236         da1.fillWithValue(7.);
5237         da2.iota(0.);
5238         da3=da2.applyFunc(3,"10*x*IVec+100*x*JVec+1000*x*KVec");
5239         #
5240         da1.setInfoOnComponent(0,"c0da1");
5241         da1.setInfoOnComponent(1,"c1da1");
5242         da3.setInfoOnComponent(0,"c0da3");
5243         da3.setInfoOnComponent(1,"c1da3");
5244         da3.setInfoOnComponent(2,"c2da3");
5245         #
5246         da1C=da1.deepCpy();
5247         da1.meldWith(da3);
5248         self.assertEqual(5,da1.getNumberOfComponents());
5249         self.assertEqual(7,da1.getNumberOfTuples());
5250         self.assertTrue(da1.getInfoOnComponent(0)=="c0da1");
5251         self.assertTrue(da1.getInfoOnComponent(1)=="c1da1");
5252         self.assertTrue(da1.getInfoOnComponent(2)=="c0da3");
5253         self.assertTrue(da1.getInfoOnComponent(3)=="c1da3");
5254         self.assertTrue(da1.getInfoOnComponent(4)=="c2da3");
5255         #
5256         expected1=[7.,7.,0.,0.,0., 7.,7.,10.,100.,1000., 7.,7.,20.,200.,2000., 7.,7.,30.,300.,3000., 7.,7.,40.,400.,4000.,7.,7.,50.,500.,5000.,7.,7.,60.,600.,6000.]
5257         for i in xrange(35):
5258             self.assertAlmostEqual(expected1[i],da1.getIJ(0,i),10);
5259             pass
5260         #
5261         dai1=da1C.convertToIntArr();
5262         dai3=da3.convertToIntArr();
5263         dai1.meldWith(dai3);
5264         self.assertEqual(5,dai1.getNumberOfComponents());
5265         self.assertEqual(7,dai1.getNumberOfTuples());
5266         self.assertTrue(dai1.getInfoOnComponent(0)=="c0da1");
5267         self.assertTrue(dai1.getInfoOnComponent(1)=="c1da1");
5268         self.assertTrue(dai1.getInfoOnComponent(2)=="c0da3");
5269         self.assertTrue(dai1.getInfoOnComponent(3)=="c1da3");
5270         self.assertTrue(dai1.getInfoOnComponent(4)=="c2da3");
5271         for i in xrange(35):
5272             self.assertEqual(int(expected1[i]),dai1.getIJ(0,i));
5273             pass
5274         # test of static method DataArrayDouble::meld
5275         da4=DataArrayDouble.Meld(da1C,da3);
5276         tmp=DataArrayDouble.Meld([da1C,da3]);
5277         self.assertTrue(da4.isEqual(tmp,1e-10))
5278         self.assertEqual(5,da4.getNumberOfComponents());
5279         self.assertEqual(7,da4.getNumberOfTuples());
5280         self.assertTrue(da4.getInfoOnComponent(0)=="c0da1");
5281         self.assertTrue(da4.getInfoOnComponent(1)=="c1da1");
5282         self.assertTrue(da4.getInfoOnComponent(2)=="c0da3");
5283         self.assertTrue(da4.getInfoOnComponent(3)=="c1da3");
5284         self.assertTrue(da4.getInfoOnComponent(4)=="c2da3");
5285         for i in xrange(35):
5286             self.assertAlmostEqual(expected1[i],da4.getIJ(0,i),10);
5287             pass
5288         # test of static method DataArrayInt::meld
5289         dai1=da1C.convertToIntArr();
5290         dai4=DataArrayInt.Meld(dai1,dai3);
5291         tmp=DataArrayInt.Meld([dai1,dai3]);
5292         self.assertTrue(dai4.isEqual(tmp))
5293         self.assertEqual(5,dai4.getNumberOfComponents());
5294         self.assertEqual(7,dai4.getNumberOfTuples());
5295         self.assertTrue(dai4.getInfoOnComponent(0)=="c0da1");
5296         self.assertTrue(dai4.getInfoOnComponent(1)=="c1da1");
5297         self.assertTrue(dai4.getInfoOnComponent(2)=="c0da3");
5298         self.assertTrue(dai4.getInfoOnComponent(3)=="c1da3");
5299         self.assertTrue(dai4.getInfoOnComponent(4)=="c2da3");
5300         for i in xrange(35):
5301             self.assertEqual(int(expected1[i]),dai4.getIJ(0,i));
5302             pass
5303         pass
5304
5305     def testFieldMeld1(self):
5306         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5307         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
5308         f1.setMesh(m);
5309         da1=DataArrayDouble.New();
5310         arr1=[12.,23.,34.,45.,56.]
5311         da1.setValues(arr1,5,1);
5312         da1.setInfoOnComponent(0,"aaa");
5313         f1.setArray(da1);
5314         f1.setTime(3.4,2,1);
5315         f1.checkCoherency();
5316         #
5317         f2=f1.deepCpy();
5318         f2.setMesh(f1.getMesh());
5319         f2.checkCoherency();
5320         f2.changeNbOfComponents(2,5.);
5321         f2.assign(5.);
5322         f2.getArray().setInfoOnComponent(0,"bbb");
5323         f2.getArray().setInfoOnComponent(1,"ccc");
5324         f2.checkCoherency();
5325         #
5326         f3=MEDCouplingFieldDouble.MeldFields(f2,f1);
5327         f3.checkCoherency();
5328         self.assertEqual(5,f3.getNumberOfTuples());
5329         self.assertEqual(3,f3.getNumberOfComponents());
5330         self.assertTrue(f3.getArray().getInfoOnComponent(0)=="bbb");
5331         self.assertTrue(f3.getArray().getInfoOnComponent(1)=="ccc");
5332         self.assertTrue(f3.getArray().getInfoOnComponent(2)=="aaa");
5333         expected1=[5.,5.,12.,5.,5.,23.,5.,5.,34.,5.,5.,45.,5.,5.,56.]
5334         for i in xrange(15):
5335             self.assertAlmostEqual(expected1[i],f3.getIJ(0,i),12);
5336             pass
5337         time,dt,it=f3.getTime();
5338         self.assertAlmostEqual(3.4,time,14);
5339         self.assertEqual(2,dt);
5340         self.assertEqual(1,it);
5341         #
5342         f4=f2.buildNewTimeReprFromThis(NO_TIME,False);
5343         f5=f1.buildNewTimeReprFromThis(NO_TIME,False);
5344         f6=MEDCouplingFieldDouble.MeldFields(f4,f5);
5345         f6.checkCoherency();
5346         self.assertEqual(5,f6.getNumberOfTuples());
5347         self.assertEqual(3,f6.getNumberOfComponents());
5348         self.assertTrue(f6.getArray().getInfoOnComponent(0)=="bbb");
5349         self.assertTrue(f6.getArray().getInfoOnComponent(1)=="ccc");
5350         self.assertTrue(f6.getArray().getInfoOnComponent(2)=="aaa");
5351         for i in xrange(15):
5352             self.assertAlmostEqual(expected1[i],f6.getIJ(0,i),12);
5353             pass
5354         #
5355         pass
5356
5357     def testMergeNodes2(self):
5358         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5359         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
5360         vec=[0.002,0.]
5361         m2.translate(vec);
5362         #
5363         m3=MEDCouplingUMesh.MergeUMeshes([m1,m2]);
5364         da,b,newNbOfNodes=m3.mergeNodes2(0.01);
5365         self.assertEqual(9,m3.getNumberOfNodes());
5366         expected1=[-0.299,-0.3, 0.201,-0.3, 0.701,-0.3, -0.299,0.2, 0.201,0.2, 0.701,0.2, -0.299,0.7, 0.201,0.7, 0.701,0.7]
5367         for i in xrange(18):
5368             self.assertAlmostEqual(expected1[i],m3.getCoords().getIJ(0,i),13);
5369             pass
5370         #
5371         pass
5372
5373     def testMergeField2(self):
5374         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5375         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
5376         f1.setMesh(m);
5377         arr=DataArrayDouble.New();
5378         arr.alloc(5,2);
5379         arr.fillWithValue(2.);
5380         f1.setArray(arr);
5381         f2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
5382         f2.setMesh(m);
5383         arr=DataArrayDouble.New();
5384         arr.alloc(5,2);
5385         arr.fillWithValue(5.);
5386         f2.setArray(arr);
5387         f3=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
5388         f3.setMesh(m);
5389         arr=DataArrayDouble.New();
5390         arr.alloc(5,2);
5391         arr.fillWithValue(7.);
5392         f3.setArray(arr);
5393         #
5394         f4=MEDCouplingFieldDouble.MergeFields([f1,f2,f3]);
5395         self.assertEqual(15,f4.getMesh().getNumberOfCells());
5396         expected1=[2.,2.,2.,2.,2.,2.,2.,2.,2.,2., 5.,5.,5.,5.,5.,5.,5.,5.,5.,5., 7.,7.,7.,7.,7.,7.,7.,7.,7.,7.]
5397         for i in xrange(30):
5398             self.assertAlmostEqual(expected1[i],f4.getIJ(0,i),13);
5399             pass
5400         #
5401         pass
5402
5403     def testDAIBuildComplement1(self):
5404         a=DataArrayInt.New();
5405         tab=[3,1,7,8]
5406         a.setValues(tab,4,1);
5407         b=a.buildComplement(12);
5408         self.assertEqual(8,b.getNumberOfTuples());
5409         self.assertEqual(1,b.getNumberOfComponents());
5410         expected1=[0,2,4,5,6,9,10,11]
5411         for i in xrange(8):
5412             self.assertEqual(expected1[i],b.getIJ(0,i));
5413             pass
5414         pass
5415
5416     def testDAIBuildUnion1(self):
5417         a=DataArrayInt.New();
5418         tab1=[3,1,7,8]
5419         a.setValues(tab1,4,1);
5420         c=DataArrayInt.New();
5421         tab2=[5,3,0,18,8]
5422         c.setValues(tab2,5,1);
5423         b=a.buildUnion(c);
5424         self.assertEqual(7,b.getNumberOfTuples());
5425         self.assertEqual(1,b.getNumberOfComponents());
5426         expected1=[0,1,3,5,7,8,18]
5427         for i in xrange(7):
5428             self.assertEqual(expected1[i],b.getIJ(0,i));
5429             pass
5430         b=DataArrayInt.BuildUnion([a,c]);
5431         self.assertEqual(7,b.getNumberOfTuples());
5432         self.assertEqual(1,b.getNumberOfComponents());
5433         expected1=[0,1,3,5,7,8,18]
5434         for i in xrange(7):
5435             self.assertEqual(expected1[i],b.getIJ(0,i));
5436             pass
5437         pass
5438
5439     def testDAIBuildIntersection1(self):
5440         a=DataArrayInt.New();
5441         tab1=[3,1,7,8]
5442         a.setValues(tab1,4,1);
5443         c=DataArrayInt.New();
5444         tab2=[5,3,0,18,8]
5445         c.setValues(tab2,5,1);
5446         b=a.buildIntersection(c);
5447         self.assertEqual(2,b.getNumberOfTuples());
5448         self.assertEqual(1,b.getNumberOfComponents());
5449         expected1=[3,8]
5450         for i in xrange(2):
5451             self.assertEqual(expected1[i],b.getIJ(0,i));
5452             pass
5453         b=DataArrayInt.BuildIntersection([a,c]);
5454         self.assertEqual(2,b.getNumberOfTuples());
5455         self.assertEqual(1,b.getNumberOfComponents());
5456         expected1=[3,8]
5457         for i in xrange(2):
5458             self.assertEqual(expected1[i],b.getIJ(0,i));
5459             pass
5460         pass
5461
5462     def testDAIDeltaShiftIndex1(self):
5463         a=DataArrayInt.New();
5464         tab=[1,3,6,7,7,9,15]
5465         a.setValues(tab,7,1);
5466         b=a.deltaShiftIndex();
5467         self.assertEqual(6,b.getNumberOfTuples());
5468         self.assertEqual(1,b.getNumberOfComponents());
5469         expected1=[2,3,1,0,2,6]
5470         for i in xrange(6):
5471             self.assertEqual(expected1[i],b.getIJ(0,i));
5472             pass
5473         pass
5474
5475     def testDaDoubleSelectByTupleIdSafe1(self):
5476         a=DataArrayDouble.New();
5477         arr1=[1.1,11.1,2.1,12.1,3.1,13.1,4.1,14.1,5.1,15.1,6.1,16.1,7.1,17.1]
5478         a.setValues(arr1,7,2);
5479         a.setInfoOnComponent(0,"toto");
5480         a.setInfoOnComponent(1,"tata");
5481         #
5482         arr2=[4,2,0,6,5]
5483         b=a.selectByTupleIdSafe(arr2);
5484         self.assertEqual(5,b.getNumberOfTuples());
5485         self.assertEqual(2,b.getNumberOfComponents());
5486         self.assertTrue(b.getInfoOnComponent(0)=="toto");
5487         self.assertTrue(b.getInfoOnComponent(1)=="tata");
5488         expected1=[5.1,15.1,3.1,13.1,1.1,11.1,7.1,17.1,6.1,16.1]
5489         for i in xrange(10):
5490             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
5491             pass
5492         arr4=[4,-1,0,6,5]
5493         self.assertRaises(InterpKernelException,a.selectByTupleIdSafe,arr4);
5494         arr5=[4,2,0,6,7]
5495         self.assertRaises(InterpKernelException,a.selectByTupleIdSafe,arr5);
5496         #
5497         c=DataArrayInt.New();
5498         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
5499         c.setValues(arr3,7,2);
5500         c.setInfoOnComponent(0,"toto");
5501         c.setInfoOnComponent(1,"tata");
5502         d=c.selectByTupleIdSafe(arr2);
5503         self.assertEqual(5,d.getNumberOfTuples());
5504         self.assertEqual(2,d.getNumberOfComponents());
5505         self.assertTrue(d.getInfoOnComponent(0)=="toto");
5506         self.assertTrue(d.getInfoOnComponent(1)=="tata");
5507         expected2=[5,15,3,13,1,11,7,17,6,16]
5508         for i in xrange(10):
5509             self.assertEqual(expected2[i],d.getIJ(0,i));
5510             pass
5511         self.assertRaises(InterpKernelException,c.selectByTupleIdSafe,arr4);
5512         self.assertRaises(InterpKernelException,c.selectByTupleIdSafe,arr5);
5513         pass
5514
5515     def testAreCellsIncludedIn1(self):
5516         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5517         pt=[1,3]
5518         m2=m.buildPartOfMySelf(pt,True);
5519         ret,tmp=m.areCellsIncludedIn(m2,0)
5520         self.assertTrue(ret);
5521         self.assertEqual(2,tmp.getNumberOfTuples());
5522         self.assertEqual(1,tmp.getNumberOfComponents());
5523         self.assertEqual(pt[0],tmp.getIJ(0,0));
5524         self.assertEqual(pt[1],tmp.getIJ(0,1));
5525         ret,tmp=m2.areCellsIncludedIn(m,0)
5526         self.assertTrue(not ret);
5527         m3=MEDCouplingUMesh.MergeUMeshesOnSameCoords(m,m2)
5528         c,cI=m3.findCommonCells(2,m.getNumberOfCells())
5529         self.assertTrue(c.isEqual(DataArrayInt([1,5,3,6])))
5530         self.assertTrue(cI.isEqual(DataArrayInt([0,2,4])))
5531         pass
5532
5533     def testSwigErrorProtection1(self):
5534         m=MEDCouplingDataForTest.build3DTargetMesh_1();
5535         m.rotate([0.,0.,0.],[0.3,0.6,1.2],0.37)
5536         m.rotate([0.,0.,0.],[0.3,6,1.2],0.37)
5537         self.assertRaises(InterpKernelException,m.rotate,[0.,0.,0.],(0.3,6,"1.2"),0.37)
5538         self.assertRaises(InterpKernelException,m.rotate,[0.,"0.",0.],[0.3,0.6,1.2],0.37)
5539         self.assertRaises(InterpKernelException,m.rotate,[0.,0.,0.],[0.3,'0.6',1.2],0.37)
5540         m2=m.buildPartOfMySelf([2,5],True)
5541         m3=m.buildPartOfMySelf((2,5),True)
5542         self.assertTrue(m2.isEqual(m3,1e-12))
5543         self.assertRaises(InterpKernelException,m.buildPartOfMySelf,[2,5.],True)
5544         da1=m.getCoords().keepSelectedComponents([1])
5545         da2=m.getCoords().keepSelectedComponents((1,))
5546         self.assertTrue(da1.isEqual(da2,1e-12))
5547         self.assertRaises(InterpKernelException,m.getCoords().keepSelectedComponents,["1"])
5548         pass
5549
5550     def testDAIBuildSubstraction1(self):
5551         a=DataArrayInt.New()
5552         aa=[2,3,6,8,9]
5553         a.setValues(aa,5,1)
5554         b=DataArrayInt.New()
5555         bb=[1,3,5,9,11]
5556         b.setValues(bb,5,1)
5557         self.assertEqual([2,6,8],a.buildSubstraction(b).getValues())
5558         pass
5559
5560     def testBuildOrthogonalField2(self):
5561         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5562         d1=DataArrayInt.New();
5563         d2=DataArrayInt.New();
5564         d3=DataArrayInt.New();
5565         d4=DataArrayInt.New();
5566         m1=m.buildDescendingConnectivity(d1,d2,d3,d4);
5567         #
5568         f1=m1.buildOrthogonalField();
5569         da1=f1.getArray();
5570         self.assertEqual(2,da1.getNumberOfComponents());
5571         self.assertEqual(13,da1.getNumberOfTuples());
5572         #
5573         expected1=[-1.,0.,0.,1.,1.,0.,0.,-1.,0.707106781186548,0.707106781186548,0.,-1.,0.,1.,1.,0.,0.,1.,1.,0.,-1.,0.,0.,1.,1.,0.];
5574         for i in xrange(26):
5575             self.assertAlmostEqual(expected1[i],da1.getIJ(0,i),14);
5576             pass
5577         pass
5578
5579     def testSwigErrorProtection2(self):
5580         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5581         coo=m.getCoords()
5582         c=m.getNodalConnectivity()
5583         ci=m.getNodalConnectivityIndex()
5584         del m
5585         self.assertEqual(2,coo.getNumberOfComponents());
5586         self.assertEqual(6,ci.getNumberOfTuples());
5587         self.assertEqual(23,c.getNumberOfTuples());
5588         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5589         f=m.getMeasureField(True)
5590         c=f.getArray()
5591         del f
5592         self.assertEqual(1,c.getNumberOfComponents());
5593         m=MEDCouplingCMesh.New()
5594         x=DataArrayDouble.New()
5595         x.setValues([1.,2.,4.],3,1)
5596         m.setCoordsAt(0,x)
5597         del x
5598         xx=m.getCoordsAt(0)
5599         del m
5600         self.assertEqual(3,xx.getNumberOfTuples());
5601         #
5602         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5603         f=m.getMeasureField(True)
5604         m2=f.getMesh()
5605         del m
5606         del f
5607         self.assertEqual(5,m2.getNumberOfCells());
5608         pass
5609
5610     def testUMInsertNextCell1(self):
5611         targetCoords=[-0.3,-0.3, 0.2,-0.3, 0.7,-0.3, -0.3,0.2, 0.2,0.2, 0.7,0.2, -0.3,0.7, 0.2,0.7, 0.7,0.7 ]
5612         targetConn=[0,3,4,1, 1,4,2, 4,5,2, 6,7,4,3, 7,8,5,4]
5613         targetMesh=MEDCouplingUMesh.New();
5614         targetMesh.allocateCells(5);
5615         self.assertRaises(InterpKernelException,targetMesh.insertNextCell,NORM_QUAD4,4,targetConn[0:4])
5616         targetMesh.setMeshDimension(2);
5617         targetMesh.insertNextCell(NORM_QUAD4,4,targetConn[0:4])
5618         self.assertRaises(InterpKernelException,targetMesh.insertNextCell,NORM_TETRA4,4,targetConn[0:4])
5619         self.assertRaises(InterpKernelException,targetMesh.insertNextCell,NORM_SEG2,2,targetConn[0:2])
5620         self.assertRaises(InterpKernelException,targetMesh.insertNextCell,NORM_POINT1,1,targetConn[0:1])
5621         targetMesh.insertNextCell(NORM_TRI3,3,targetConn[4:7])
5622         targetMesh.insertNextCell(NORM_TRI3,3,targetConn[7:10])
5623         targetMesh.insertNextCell(NORM_QUAD4,4,targetConn[10:14])
5624         targetMesh.insertNextCell(NORM_QUAD4,4,targetConn[14:18])
5625         targetMesh.finishInsertingCells();
5626         myCoords=DataArrayDouble.New();
5627         myCoords.setValues(targetCoords,9,2);
5628         targetMesh.setCoords(myCoords);
5629         targetMesh.checkCoherency();
5630         pass
5631
5632     def testFieldOperatorDivDiffComp1(self):
5633         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5634         m1,d0,d1,d2,d3=m.buildDescendingConnectivity();
5635         #
5636         f1=m1.buildOrthogonalField();
5637         arr1=[2.,3.,4.,5.,6.,7.,8.,9.,10.,11.,12.,13.,14.]
5638         arr=DataArrayDouble.New();
5639         arr.setValues(arr1,13,1);
5640         f2=MEDCouplingFieldDouble.New(ON_CELLS);
5641         f2.setArray(arr);
5642         f2.setMesh(m1);
5643         f2.checkCoherency();
5644         #
5645         f3=f1/f2;
5646         self.assertRaises(InterpKernelException,f2.__div__,f1)
5647         f3.checkCoherency();
5648         f1/=f2;
5649         #self.assertRaises(InterpKernelException,f2.__idiv__,f1) # mem leaks
5650         self.assertTrue(f1.isEqual(f3,1e-10,1e-10));
5651         expected1=[-0.5, 0.0, 0.0, 0.33333333333333331, 0.25, 0.0, 0.0, -0.20000000000000001, 0.117851130197758, 0.117851130197758, 0.0, -0.14285714285714285, 0.0, 0.125, 0.1111111111111111, 0.0, 0.0, 0.10000000000000001, 0.090909090909090912, 0.0, -0.083333333333333329, 0.0, 0.0, 0.076923076923076927, 0.071428571428571425, 0.0]
5652         for i in xrange(26):
5653             self.assertAlmostEqual(expected1[i],f3.getIJ(0,i),10);
5654             pass
5655         pass
5656
5657     def testDARearrange1(self):
5658         da1=DataArrayInt.New();
5659         da1.alloc(12,1);
5660         da1.iota(0);
5661         #
5662         self.assertEqual(12,da1.getNbOfElems());
5663         self.assertEqual(1,da1.getNumberOfComponents());
5664         self.assertEqual(12,da1.getNumberOfTuples());
5665         da1.rearrange(4);
5666         self.assertEqual(12,da1.getNbOfElems());
5667         self.assertEqual(4,da1.getNumberOfComponents());
5668         self.assertEqual(3,da1.getNumberOfTuples());
5669         for i in xrange(12):
5670             self.assertEqual(i,da1.getIJ(0,i));
5671         #
5672         da1.rearrange(6);
5673         self.assertEqual(12,da1.getNbOfElems());
5674         self.assertEqual(6,da1.getNumberOfComponents());
5675         self.assertEqual(2,da1.getNumberOfTuples());
5676         for i in xrange(12):
5677             self.assertEqual(i,da1.getIJ(0,i));
5678         #
5679         self.assertRaises(InterpKernelException,da1.rearrange,7);
5680         #
5681         da1.rearrange(12);
5682         self.assertEqual(12,da1.getNbOfElems());
5683         self.assertEqual(12,da1.getNumberOfComponents());
5684         self.assertEqual(1,da1.getNumberOfTuples());
5685         for i in xrange(12):
5686             self.assertEqual(i,da1.getIJ(0,i));
5687         #
5688         da1.rearrange(3);
5689         self.assertEqual(12,da1.getNbOfElems());
5690         self.assertEqual(3,da1.getNumberOfComponents());
5691         self.assertEqual(4,da1.getNumberOfTuples());
5692         for i in xrange(12):
5693             self.assertEqual(i,da1.getIJ(0,i));
5694         #double
5695         da2=da1.convertToDblArr();
5696         st=da2.getHiddenCppPointer()
5697         #
5698         self.assertEqual(12,da2.getNbOfElems());
5699         self.assertEqual(3,da2.getNumberOfComponents());
5700         self.assertEqual(4,da2.getNumberOfTuples());
5701         da2.rearrange(4);
5702         self.assertEqual(12,da2.getNbOfElems());
5703         self.assertEqual(4,da2.getNumberOfComponents());
5704         self.assertEqual(3,da2.getNumberOfTuples());
5705         for i in xrange(12):
5706             self.assertAlmostEqual(float(i),da2.getIJ(0,i),14);
5707         #
5708         da2.rearrange(6);
5709         self.assertEqual(12,da2.getNbOfElems());
5710         self.assertEqual(6,da2.getNumberOfComponents());
5711         self.assertEqual(2,da2.getNumberOfTuples());
5712         for i in xrange(12):
5713             self.assertAlmostEqual(float(i),da2.getIJ(0,i),14);
5714         #
5715         self.assertRaises(InterpKernelException,da2.rearrange,7);
5716         #
5717         da2.rearrange(1);
5718         self.assertEqual(st,da2.getHiddenCppPointer())
5719         self.assertEqual(12,da2.getNbOfElems());
5720         self.assertEqual(1,da2.getNumberOfComponents());
5721         self.assertEqual(12,da2.getNumberOfTuples());
5722         for i in xrange(12):
5723             self.assertAlmostEqual(float(i),da2.getIJ(0,i),14);
5724         #
5725         da2.rearrange(3);
5726         self.assertEqual(12,da2.getNbOfElems());
5727         self.assertEqual(3,da2.getNumberOfComponents());
5728         self.assertEqual(4,da2.getNumberOfTuples());
5729         for i in xrange(12):
5730             self.assertAlmostEqual(float(i),da2.getIJ(0,i),14);
5731         pass
5732
5733     def testDARearrange2(self):
5734         da1=DataArrayInt.New();
5735         arr=[1,2,3,2,2,3,5,1,5,5,2,2]
5736         da1.setValues(arr,4,3);
5737         s=da1.getDifferentValues();
5738         expected1=DataArrayInt([1,2,3,5])
5739         self.assertTrue(expected1.isEqual(s));
5740         pass
5741
5742     def testSwigErrorProtection3(self):
5743         da=DataArrayInt.New()
5744         da.setValues([1,2,3,4,0,0,0,0,0,0,0,0],4,3)
5745         self.assertEqual([1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0],da.getValues())
5746         self.assertEqual(3,da.getNumberOfComponents());
5747         self.assertEqual(4,da.getNumberOfTuples());
5748         da=DataArrayInt.New()
5749         da.setValues(((1,2,3),(4,4,3),(0,0,0),(0,0,0)),4,3)
5750         self.assertEqual([1, 2, 3, 4, 4, 3, 0, 0, 0, 0, 0, 0],da.getValues())
5751         self.assertEqual(3,da.getNumberOfComponents());
5752         self.assertEqual(4,da.getNumberOfTuples());
5753         da.setValues((10*[1]+290*[2])[:12],4,3)
5754         self.assertEqual(10*[1]+[2,2],da.getValues())
5755         self.assertEqual(3,da.getNumberOfComponents());
5756         self.assertEqual(4,da.getNumberOfTuples());
5757         #
5758         da=DataArrayDouble.New()
5759         da.setValues([1,2,3.,4,0,0,0,0,0,0,0,0],4,3)
5760         self.assertEqual([1., 2., 3., 4., 0., 0., 0., 0., 0., 0., 0., 0.],da.getValues())
5761         self.assertEqual(3,da.getNumberOfComponents());
5762         self.assertEqual(4,da.getNumberOfTuples());
5763         da=DataArrayDouble.New()
5764         da.setValues(((1,2,3),(4.,4,3),(0,0,0),(0,0,0)),4,3)
5765         self.assertEqual([1., 2., 3., 4., 4., 3., 0., 0., 0., 0., 0., 0.],da.getValues())
5766         self.assertEqual(3,da.getNumberOfComponents());
5767         self.assertEqual(4,da.getNumberOfTuples());
5768         da.setValues((10*[1]+290*[2])[:12],4,3)
5769         self.assertEqual(10*[1.]+[2.,2.],da.getValues())
5770         self.assertEqual(3,da.getNumberOfComponents());
5771         self.assertEqual(4,da.getNumberOfTuples());
5772         pass
5773
5774     def testDAIBuildPermutationArr1(self):
5775         a=DataArrayInt.New()
5776         a.setValues([4,5,6,7,8],5,1)
5777         b=DataArrayInt.New()
5778         b.setValues([5,4,8,6,7],5,1)
5779         c=a.buildPermutationArr(b)
5780         self.assertEqual([1,0,4,2,3],c.getValues())
5781         self.assertTrue(a.isEqualWithoutConsideringStrAndOrder(b))
5782         b.setIJ(0,0,9)
5783         self.assertTrue(not a.isEqualWithoutConsideringStrAndOrder(b))
5784         self.assertRaises(InterpKernelException,a.buildPermutationArr,b)
5785         a.setIJ(3,0,4)
5786         b.setIJ(0,0,5)
5787         b.setIJ(4,0,4)#a==[4,5,6,4,8] and b==[5,4,8,6,4]
5788         self.assertTrue(a.isEqualWithoutConsideringStrAndOrder(b))
5789         c=a.buildPermutationArr(b)
5790         self.assertEqual([1,3,4,2,3],c.getValues())
5791         d=b.convertToDblArr()
5792         expect3=[4,4,5,6,8]
5793         b.sort()
5794         self.assertEqual(expect3,b.getValues())
5795         d.sort()
5796         self.assertEqual(5,d.getNumberOfTuples());
5797         self.assertEqual(1,d.getNumberOfComponents());
5798         for i in xrange(5):
5799             self.assertAlmostEqual(float(expect3[i]),d.getIJ(i,0),14);
5800             pass
5801         pass
5802
5803     def testAreCellsIncludedIn2(self):
5804         myName="Vitoo";
5805         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5806         m2=m.buildPartOfMySelf([],True);
5807         self.assertEqual(0,m2.getNumberOfCells());
5808         self.assertEqual(3,m2.getSpaceDimension());
5809         self.assertEqual(2,m2.getMeshDimension());
5810         m2.setName(myName);
5811         test,tmp=m.areCellsIncludedIn(m2,0)
5812         self.assertTrue(test);
5813         self.assertEqual(myName,tmp.getName());
5814         self.assertEqual(0,tmp.getNumberOfTuples())
5815         self.assertEqual(1,tmp.getNumberOfComponents())
5816         pass
5817
5818     def testUMeshGetPartBarycenterAndOwner1(self):
5819         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5820         part1=[1,0,4];
5821         part=DataArrayInt.New();
5822         part.setValues(part1,3,1);
5823         b=m1.getPartBarycenterAndOwner(part);
5824         self.assertEqual(2,b.getNumberOfComponents());
5825         self.assertEqual(3,b.getNumberOfTuples());
5826         expected1=[0.36666666666666665,-0.13333333333333333,-0.05,-0.05,0.45,0.45];
5827         for i in xrange(6):
5828             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
5829             pass
5830         pass
5831
5832     def testUMeshGetPartMeasureField1(self):
5833         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5834         part1=[1,0,4];
5835         part=DataArrayInt.New();
5836         part.setValues(part1,3,1);
5837         b=m1.getPartMeasureField(True,part);
5838         self.assertEqual(1,b.getNumberOfComponents());
5839         self.assertEqual(3,b.getNumberOfTuples());
5840         expected1=[0.125,0.25,0.25];
5841         for i in xrange(3):
5842             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
5843             pass
5844         pass
5845
5846     def testUMeshBuildPartOrthogonalField1(self):
5847         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5848         m1.changeSpaceDimension(3);
5849         part1=[1,0,4];
5850         part=DataArrayInt.New();
5851         part.setValues(part1,3,1);
5852         b=m1.buildPartOrthogonalField(part);
5853         self.assertEqual(3,b.getArray().getNumberOfComponents());
5854         self.assertEqual(3,b.getArray().getNumberOfTuples());
5855         expected1=[0.,0.,-1.,0.,0.,-1.,0.,0.,-1.];
5856         for i in xrange(9):
5857             self.assertAlmostEqual(expected1[i],b.getArray().getIJ(0,i),14);
5858             pass
5859         pass
5860
5861     def testUMeshGetTypesOfPart1(self):
5862         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5863         part1=[0,3,4];
5864         p1=DataArrayInt.New()
5865         p1.setValues(part1,3,1)
5866         s=m1.getTypesOfPart(p1);
5867         self.assertEqual([NORM_QUAD4],s);
5868         part2=[2,2,2,1];
5869         p2=DataArrayInt.New()
5870         p2.setValues(part2,4,1)
5871         s=m1.getTypesOfPart(p2);
5872         self.assertEqual([NORM_TRI3],s);
5873         part3=[3,2,1];
5874         p3=DataArrayInt.New()
5875         p3.setValues(part3,3,1)
5876         s=m1.getTypesOfPart(p3);
5877         self.assertEqual(s,[NORM_TRI3,NORM_QUAD4]);
5878         pass
5879
5880     def testUMeshKeepCellIdsByType1(self):
5881         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5882         part1=[0,3,4]
5883         p1=DataArrayInt.New()
5884         p1.setValues(part1,3,1)
5885         p1.setName("p1")
5886         a=m1.keepCellIdsByType(NORM_TRI3,p1);
5887         self.assertEqual("p1",a.getName())
5888         self.assertEqual(1,a.getNumberOfComponents());
5889         self.assertEqual(0,a.getNumberOfTuples());
5890         #
5891         part2=[3,2,0,2,4]
5892         p2=DataArrayInt.New()
5893         p2.setValues(part2,5,1)
5894         p2.setName("p2")
5895         a=m1.keepCellIdsByType(NORM_TRI3,p2);
5896         self.assertEqual("p2",a.getName())
5897         self.assertEqual(1,a.getNumberOfComponents());
5898         self.assertEqual(2,a.getNumberOfTuples());
5899         self.assertEqual(2,a.getIJ(0,0));
5900         self.assertEqual(2,a.getIJ(1,0));
5901         #
5902         a=m1.keepCellIdsByType(NORM_QUAD4,p2);
5903         self.assertEqual("p2",a.getName())
5904         self.assertEqual(1,a.getNumberOfComponents());
5905         self.assertEqual(3,a.getNumberOfTuples());
5906         self.assertEqual(3,a.getIJ(0,0));
5907         self.assertEqual(0,a.getIJ(1,0));
5908         self.assertEqual(4,a.getIJ(2,0));
5909         pass
5910     
5911     def testSwigErrorDaIntSelectByTupleId1(self):
5912         a=DataArrayInt.New();
5913         arr1=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
5914         a.setValues(arr1,7,2);
5915         a.setInfoOnComponent(0,"toto");
5916         a.setInfoOnComponent(1,"tata");
5917         #
5918         arr2=[4,2,0,6,5]
5919         b=a.selectByTupleId(arr2);
5920         self.assertEqual(5,b.getNumberOfTuples());
5921         self.assertEqual(2,b.getNumberOfComponents());
5922         self.assertTrue(b.getInfoOnComponent(0)=="toto");
5923         self.assertTrue(b.getInfoOnComponent(1)=="tata");
5924         expected1=[5,15,3,13,1,11,7,17,6,16]
5925         self.assertEqual(expected1,b.getValues())
5926         #
5927         a2=DataArrayInt.New()
5928         a2.setValues(arr2,5,1)
5929         b=a.selectByTupleId(a2);
5930         self.assertEqual(5,b.getNumberOfTuples());
5931         self.assertEqual(2,b.getNumberOfComponents());
5932         self.assertTrue(b.getInfoOnComponent(0)=="toto");
5933         self.assertTrue(b.getInfoOnComponent(1)=="tata");
5934         expected1=[5,15,3,13,1,11,7,17,6,16]
5935         self.assertEqual(expected1,b.getValues())
5936         pass
5937
5938     def testSwigErrorRenum(self):
5939         da=DataArrayDouble.New()
5940         da.setValues([7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.],10,2)
5941         d=DataArrayInt.New()
5942         d.setValues([0,2,3,1,4,5,6,8,7,9],10,1)
5943         da.renumberInPlace(d)
5944         da.renumber(d)
5945         pass
5946
5947     def testSwigGetItem1(self):
5948         da=DataArrayInt.New()
5949         da.alloc(16,3)
5950         da.rearrange(1)
5951         da.iota(7)
5952         da.rearrange(3)
5953         da.setInfoOnComponent(0,"X [m]")
5954         da.setInfoOnComponent(1,"Y [m]")
5955         da.setInfoOnComponent(2,"Z [km]")
5956         da2=da[5:-1]
5957         self.assertEqual([22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51],da2.getValues())
5958         da2=da[4]
5959         self.assertEqual([19, 20, 21],da2.getValues())
5960         try:
5961             da2=da[4:17]
5962         except InterpKernelException as e:
5963             self.assertTrue(True)
5964         else:
5965             self.assertTrue(False)
5966             pass
5967         da2=da[5:-2,2]
5968         self.assertEqual([24, 27, 30, 33, 36, 39, 42, 45, 48],da2.getValues())
5969         da2=da[5:8,:]
5970         self.assertEqual([22, 23, 24, 25, 26, 27, 28, 29, 30],da2.getValues())
5971         da2=da[:]
5972         self.assertTrue(da2.isEqual(da))
5973         da2=da[:,:]
5974         self.assertTrue(da2.isEqual(da))
5975         try:
5976             da2=da[:,:,:]
5977         except InterpKernelException as e:
5978             self.assertTrue(True)
5979         else:
5980             self.assertTrue(False)
5981             pass
5982         try:
5983             da2=da[5:8,-2]
5984         except InterpKernelException as e:
5985             self.assertTrue(True)
5986         else:
5987             self.assertTrue(False)
5988             pass
5989         da2=da[5:8,:-2]
5990         self.assertEqual([22, 25, 28],da2.getValues())
5991         try:
5992             da2=da[5:-18,2]
5993         except InterpKernelException as e:
5994             self.assertTrue(True)
5995         else:
5996             self.assertTrue(False)
5997             pass
5998         da2=da[5:5,2]
5999         self.assertEqual([],da2.getValues())
6000         pass
6001
6002     def testSwigGetItem2(self):
6003         da=DataArrayDouble.New()
6004         da.alloc(16,3)
6005         da.rearrange(1)
6006         da.iota(7)
6007         da.rearrange(3)
6008         da.setInfoOnComponent(0,"X [m]")
6009         da.setInfoOnComponent(1,"Y [m]")
6010         da.setInfoOnComponent(2,"Z [km]")
6011         da2=da[5:-1]
6012         self.assertEqual([22., 23., 24., 25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36., 37., 38., 39., 40., 41., 42., 43., 44., 45., 46., 47., 48., 49., 50., 51.],da2.getValues())
6013         da2=da[4]
6014         self.assertEqual([19., 20., 21],da2.getValues())
6015         try:
6016             da2=da[4:17]
6017         except InterpKernelException as e:
6018             self.assertTrue(True)
6019         else:
6020             self.assertTrue(False)
6021             pass
6022         da2=da[5:-2,2]
6023         self.assertEqual([24., 27., 30., 33., 36., 39., 42., 45., 48.],da2.getValues())
6024         da2=da[5:8,:]
6025         self.assertEqual([22., 23., 24., 25., 26., 27., 28., 29., 30.],da2.getValues())
6026         da2=da[:]
6027         self.assertTrue(da2.isEqual(da,1e-12))
6028         da2=da[:,:]
6029         self.assertTrue(da2.isEqual(da,1e-12))
6030         try:
6031             da2=da[:,:,:]
6032         except InterpKernelException as e:
6033             self.assertTrue(True)
6034         else:
6035             self.assertTrue(False)
6036             pass
6037         try:
6038             da2=da[5:8,-2]
6039         except InterpKernelException as e:
6040             self.assertTrue(True)
6041         else:
6042             self.assertTrue(False)
6043             pass
6044         da2=da[5:8,:-2]
6045         self.assertEqual([22., 25., 28.],da2.getValues())
6046         try:
6047             da2=da[5:-18,2]
6048         except InterpKernelException as e:
6049             self.assertTrue(True)
6050         else:
6051             self.assertTrue(False)
6052             pass
6053         da2=da[5:5,2]
6054         self.assertEqual([],da2.getValues())
6055         pass
6056
6057     def testSwigSetItem1(self):
6058         da=DataArrayInt.New()
6059         da.alloc(20,1)
6060         da.iota(7)
6061         da.rearrange(5)
6062         da.setInfoOnComponent(0,"X [m]") ; da.setInfoOnComponent(1,"Y [km]") ; da.setInfoOnComponent(2,"Y [m]")
6063         da.setInfoOnComponent(3,"Z [W]") ; da.setInfoOnComponent(4,"ZZ [km]") ; 
6064         da[:,2]=3
6065         self.assertEqual([7, 8, 3, 10, 11, 12, 13, 3, 15, 16, 17, 18, 3, 20, 21, 22, 23, 3, 25, 26],da.getValues())
6066         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6067         da[2]=3
6068         self.assertEqual([7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 3, 3, 3, 3, 3, 22, 23, 24, 25, 26],da.getValues())
6069         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6070         da[[0,3]]=-1
6071         self.assertEqual([-1, -1, -1, -1, -1, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, -1, -1, -1, -1, -1],da.getValues())
6072         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6073         da[:,[1,3,4]]=-3
6074         self.assertEqual([7, -3, 9, -3, -3, 12, -3, 14, -3, -3, 17, -3, 19, -3, -3, 22, -3, 24, -3, -3],da.getValues())
6075         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6076         da2=DataArrayInt.New() ; da2.setValues([0,2,3],3,1)
6077         da[da2]=-7
6078         self.assertEqual([-7, -7, -7, -7, -7, 12, 13, 14, 15, 16, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7],da.getValues())
6079         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6080         da[da2,-2:]=-7
6081         self.assertEqual([7, 8, 9, -7, -7, 12, 13, 14, 15, 16, 17, 18, 19, -7, -7, 22, 23, 24, -7, -7],da.getValues())
6082         # Let's test with DAI right hand side
6083         da1=DataArrayInt.New()
6084         da1.setValues([25,26,27,125,126,127],2,3)
6085         #
6086         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6087         da[-2:,1:4]=da1
6088         self.assertEqual([7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 25, 26, 27, 21, 22, 125, 126, 127, 26],da.getValues())
6089         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6090         da[1:,3]=[225,226,227]
6091         self.assertEqual([7, 8, 9, 10, 11, 12, 13, 14, 225, 16, 17, 18, 19, 226, 21, 22, 23, 24, 227, 26],da.getValues())
6092         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6093         da[1,2:]=[225,226,227]
6094         self.assertEqual([7, 8, 9, 10, 11, 12, 13, 225, 226, 227, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26],da.getValues())
6095         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6096         da[da2,-2:]=[88,99,1010,1111,1212,1313]
6097         self.assertEqual([7, 8, 9, 88, 99, 12, 13, 14, 15, 16, 17, 18, 19, 1010, 1111, 22, 23, 24, 1212, 1313],da.getValues())
6098         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6099         da3=DataArrayInt.New(); da3.setValues([88,99,1010,1111,1212,1313],3,2)
6100         da[da2,-2:]=da3
6101         self.assertEqual([7, 8, 9, 88, 99, 12, 13, 14, 15, 16, 17, 18, 19, 1010, 1111, 22, 23, 24, 1212, 1313],da.getValues())
6102         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6103         da[da2,[0,2]]=da3
6104         self.assertEqual([88, 8, 99, 10, 11, 12, 13, 14, 15, 16, 1010, 18, 1111, 20, 21, 1212, 23, 1313, 25, 26],da.getValues())
6105         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6106         da[da2,0:3:2]=da3
6107         self.assertEqual([88, 8, 99, 10, 11, 12, 13, 14, 15, 16, 1010, 18, 1111, 20, 21, 1212, 23, 1313, 25, 26],da.getValues())
6108         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6109         da[da2,0:3:2]=-8
6110         self.assertEqual([-8, 8, -8, 10, 11, 12, 13, 14, 15, 16, -8, 18, -8, 20, 21, -8, 23, -8, 25, 26],da.getValues())
6111         pass
6112
6113     def testSwigSetItem2(self):
6114         da=DataArrayDouble.New()
6115         da.alloc(20,1)
6116         da.iota(7)
6117         da.rearrange(5)
6118         da.setInfoOnComponent(0,"X [m]") ; da.setInfoOnComponent(1,"Y [km]") ; da.setInfoOnComponent(2,"Y [m]")
6119         da.setInfoOnComponent(3,"Z [W]") ; da.setInfoOnComponent(4,"ZZ [km]") ; 
6120         da[:,2]=3.
6121         self.assertEqual([7., 8., 3., 10., 11., 12., 13., 3., 15., 16., 17., 18., 3., 20., 21., 22., 23., 3., 25., 26.],da.getValues())
6122         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6123         da[2]=3.
6124         self.assertEqual([7., 8., 9., 10., 11., 12., 13., 14., 15., 16., 3., 3., 3., 3., 3., 22., 23., 24., 25., 26.],da.getValues())
6125         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6126         da[[0,3]]=-1.
6127         self.assertEqual([-1., -1., -1., -1., -1., 12., 13., 14., 15., 16., 17., 18., 19., 20., 21., -1., -1., -1., -1., -1.],da.getValues())
6128         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6129         da[:,[1,3,4]]=-3.
6130         self.assertEqual([7., -3., 9., -3., -3., 12., -3., 14., -3., -3., 17., -3., 19., -3., -3., 22., -3., 24., -3., -3.],da.getValues())
6131         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6132         da2=DataArrayInt.New() ; da2.setValues([0,2,3],3,1)
6133         da[da2]=-7.
6134         self.assertEqual([-7., -7., -7., -7., -7., 12., 13., 14., 15., 16., -7., -7., -7., -7., -7., -7., -7., -7., -7., -7.],da.getValues())
6135         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6136         da[da2,-2:]=-7
6137         self.assertEqual([7., 8., 9., -7., -7., 12., 13., 14., 15., 16., 17., 18., 19., -7., -7., 22., 23., 24., -7., -7.],da.getValues())
6138         # Let's test with DAI right hand side
6139         da1=DataArrayDouble.New()
6140         da1.setValues([25,26,27,125,126,127],2,3)
6141         #
6142         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6143         da[-2:,1:4]=da1
6144         self.assertEqual([7., 8., 9., 10., 11., 12., 13., 14., 15., 16., 17., 25., 26., 27., 21., 22., 125., 126., 127., 26.],da.getValues())
6145         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6146         da[1:,3]=[225.,226.,227.]
6147         self.assertEqual([7., 8., 9., 10., 11., 12., 13., 14., 225., 16., 17., 18., 19., 226., 21., 22., 23., 24., 227., 26.],da.getValues())
6148         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6149         da[1,2:]=[225,226,227]
6150         self.assertEqual([7., 8., 9., 10., 11., 12., 13., 225., 226., 227., 17., 18., 19., 20., 21., 22., 23., 24., 25., 26.],da.getValues())
6151         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6152         da[da2,-2:]=[88,99,1010,1111,1212,1313]
6153         self.assertEqual([7., 8., 9., 88., 99., 12., 13., 14., 15., 16., 17., 18., 19., 1010., 1111., 22., 23., 24., 1212., 1313.],da.getValues())
6154         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6155         da3=DataArrayDouble.New(); da3.setValues([88,99,1010,1111,1212,1313],3,2)
6156         da[da2,-2:]=da3
6157         self.assertEqual([7., 8., 9., 88., 99., 12., 13., 14., 15., 16., 17., 18., 19., 1010., 1111., 22., 23., 24., 1212., 1313.],da.getValues())
6158         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6159         da[da2,[0,2]]=da3
6160         self.assertEqual([88., 8., 99., 10., 11., 12., 13., 14., 15., 16., 1010., 18., 1111., 20., 21., 1212., 23., 1313., 25., 26.],da.getValues())
6161         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6162         da[da2,0:3:2]=da3
6163         self.assertEqual([88., 8., 99., 10., 11., 12., 13., 14., 15., 16., 1010., 18., 1111., 20., 21., 1212., 23., 1313., 25., 26.],da.getValues())
6164         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6165         da[da2,0:3:2]=-8.
6166         self.assertEqual([-8., 8., -8., 10., 11., 12., 13., 14., 15., 16., -8., 18., -8., 20., 21., -8., 23., -8., 25., 26.],da.getValues())
6167         pass
6168
6169     def testSwigDADOp(self):
6170         da=DataArrayDouble.New()
6171         da.alloc(12,1)
6172         da.iota(7.)
6173         da1=DataArrayDouble.New()
6174         da1.alloc(12,1)
6175         da1.iota(8.)
6176         da2=da+da1
6177         self.assertEqual([15., 17., 19., 21., 23., 25., 27., 29., 31., 33., 35., 37.],da2.getValues())
6178         da2=da+3
6179         da3=3+da
6180         self.assertTrue(da2.isEqual(da3,1e-12))
6181         da2=da-1.
6182         self.assertEqual([6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0],da2.getValues())
6183         da2=1-da
6184         self.assertEqual([-6.0, -7.0, -8.0, -9.0, -10.0, -11.0, -12.0, -13.0, -14.0, -15.0, -16.0, -17.0],da2.getValues())
6185         da2=da*3
6186         self.assertEqual([21.0, 24.0, 27.0, 30.0, 33.0, 36.0, 39.0, 42.0, 45.0, 48.0, 51.0, 54.0],da2.getValues())
6187         da2=3.*da
6188         self.assertEqual([21.0, 24.0, 27.0, 30.0, 33.0, 36.0, 39.0, 42.0, 45.0, 48.0, 51.0, 54.0],da2.getValues())
6189         da2=da*da1
6190         self.assertEqual([56.0, 72.0, 90.0, 110.0, 132.0, 156.0, 182.0, 210.0, 240.0, 272.0, 306.0, 342.0],da2.getValues())
6191         da2=da/4.
6192         self.assertEqual([1.75, 2.0, 2.25, 2.5, 2.75, 3.0, 3.25, 3.5, 3.75, 4.0, 4.25, 4.5],da2.getValues())
6193         da3=4./da
6194         da4=da3*da2
6195         self.assertTrue(da4.isUniform(1.,1e-12))
6196         st1=da.getHiddenCppPointer()
6197         da+=1
6198         st2=da.getHiddenCppPointer()
6199         self.assertEqual(st1,st2)
6200         self.assertTrue(da.isEqual(da1,1e-12))
6201         da-=8
6202         st2=da.getHiddenCppPointer()
6203         self.assertEqual(st1,st2)
6204         self.assertEqual(range(12),da.getValues())
6205         da+=da1
6206         st2=da.getHiddenCppPointer()
6207         self.assertEqual(st1,st2)
6208         self.assertEqual([8.0, 10.0, 12.0, 14.0, 16.0, 18.0, 20.0, 22.0, 24.0, 26.0, 28.0, 30.0],da.getValues())
6209         da*=0.5
6210         st2=da.getHiddenCppPointer()
6211         self.assertEqual(st1,st2)
6212         self.assertEqual([4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0],da.getValues())
6213         da*=da1
6214         st2=da.getHiddenCppPointer()
6215         self.assertEqual(st1,st2)
6216         self.assertEqual([32.0, 45.0, 60.0, 77.0, 96.0, 117.0, 140.0, 165.0, 192.0, 221.0, 252.0, 285.0],da.getValues())
6217         da/=da1
6218         self.assertEqual(st1,st2)
6219         self.assertEqual([4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0],da.getValues())
6220         da/=2
6221         st2=da.getHiddenCppPointer()
6222         self.assertEqual(st1,st2)
6223         self.assertEqual([2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5.0, 5.5, 6.0, 6.5, 7.0, 7.5],da.getValues())
6224         da.rearrange(3)
6225         da5=DataArrayDouble.New()
6226         da5.setValues([5.,4.,3.,2.],4,1)
6227         da*=da5 # it works with unmathing number of compo
6228         st2=da.getHiddenCppPointer()
6229         self.assertEqual(st1,st2)
6230         self.assertEqual([10.0, 12.5, 15.0, 14.0, 16.0, 18.0, 15.0, 16.5, 18.0, 13.0, 14.0, 15.0],da.getValues())
6231         #
6232         da.alloc(30,1)
6233         da.iota(7.)
6234         da.rearrange(3)
6235         ids=DataArrayInt.New()
6236         ids.setValues([3,4,7],3,1)
6237         da[ids,:]=[5.,8.,9.]
6238         self.assertEqual([7.,8.,9.,10.,11.,12.,13.,14.,15.,5.,8.,9.,5.,8.,9.,22.,23.,24.,25.,26.,27.,5.,8.,9.,31.,32.,33.,34.,35.,36.0],da.getValues())
6239         #
6240         da.rearrange(1) ; da.iota(7) ; da.rearrange(3)
6241         da[ids,[1,2]]=[5,8]
6242         self.assertEqual([7.,8.,9.,10.,11.,12.,13.,14.,15.,16.,5.,8.,19.,5.,8.,22.,23.,24.,25.,26.,27.,28.,5.,8.,31.,32.,33.,34.,35.,36.],da.getValues())
6243         pass
6244
6245     def testSwigDAIOp(self):
6246         da=DataArrayInt.New()
6247         da.alloc(12,1)
6248         da.iota(7)
6249         da1=DataArrayInt.New()
6250         da1.alloc(12,1)
6251         da1.iota(8)
6252         da2=da+da1
6253         self.assertEqual([15,17,19,21,23,25,27,29,31,33,35,37],da2.getValues())
6254         da2=da+3
6255         da3=3+da
6256         self.assertTrue(da2.isEqual(da3))
6257         da2=da-1
6258         self.assertEqual([6,7,8,9,10,11,12,13,14,15,16,17],da2.getValues())
6259         da2=1-da
6260         self.assertEqual([-6,-7,-8,-9,-10,-11,-12,-13,-14,-15,-16,-17],da2.getValues())
6261         da2=da*3
6262         self.assertEqual([21,24,27,30,33,36,39,42,45,48,51,54.0],da2.getValues())
6263         da2=3*da
6264         self.assertEqual([21,24,27,30,33,36,39,42,45,48,51,54.0],da2.getValues())
6265         da2=da*da1
6266         self.assertEqual([56,72,90,110,132,156,182,210,240,272,306,342.0],da2.getValues())
6267         da2=da/4
6268         self.assertEqual([1,2,2,2,2,3,3,3,3,4,4,4],da2.getValues())
6269         da3=4/da
6270         da4=da3*da2
6271         self.assertTrue(da4.isUniform(0))
6272         st1=da.getHiddenCppPointer()
6273         da+=1
6274         st2=da.getHiddenCppPointer()
6275         self.assertEqual(st1,st2)
6276         self.assertTrue(da.isEqual(da1))
6277         da-=8
6278         st2=da.getHiddenCppPointer()
6279         self.assertEqual(st1,st2)
6280         self.assertEqual(range(12),da.getValues())
6281         da+=da1
6282         st2=da.getHiddenCppPointer()
6283         self.assertEqual(st1,st2)
6284         self.assertEqual([8,10,12,14,16,18,20,22,24,26,28,30],da.getValues())
6285         da/=2
6286         st2=da.getHiddenCppPointer()
6287         self.assertEqual(st1,st2)
6288         self.assertEqual([4,5,6,7,8,9,10,11,12,13,14,15],da.getValues())
6289         da*=da1
6290         st2=da.getHiddenCppPointer()
6291         self.assertEqual(st1,st2)
6292         self.assertEqual([32,45,60,77,96,117,140,165,192,221,252,285],da.getValues())
6293         da/=da1
6294         self.assertEqual(st1,st2)
6295         self.assertEqual([4,5,6,7,8,9,10,11,12,13,14,15],da.getValues())
6296         da/=2
6297         st2=da.getHiddenCppPointer()
6298         self.assertEqual(st1,st2)
6299         self.assertEqual([2,2, 3,3, 4,4, 5,5, 6,6, 7,7],da.getValues())
6300         da.rearrange(3)
6301         da5=DataArrayInt.New()
6302         da5.setValues([5,4,3,2],4,1)
6303         da*=da5 # it works with unmathing number of compo
6304         st2=da.getHiddenCppPointer()
6305         self.assertEqual(st1,st2)
6306         self.assertEqual([10,10, 15,12,16,16,15,15, 18,12,14,14],da.getValues())
6307         da%=6
6308         st2=da.getHiddenCppPointer()
6309         self.assertEqual(st1,st2)
6310         self.assertEqual([4,4,3,0,4,4,3,3,0,0,2,2],da.getValues())
6311         #
6312         da.alloc(30,1)
6313         da.iota(7)
6314         da.rearrange(3)
6315         ids=DataArrayInt.New()
6316         ids.setValues([3,4,7],3,1)
6317         da[ids,:]=[5,8,9]
6318         self.assertEqual([7,8,9,10,11,12,13,14,15,5,8,9,5,8,9,22,23,24,25,26,27,5,8,9,31,32,33,34,35,36],da.getValues())
6319         #
6320         da.rearrange(1) ; da.iota(7) ; da.rearrange(3)
6321         da[ids,[1,2]]=[5,8]
6322         self.assertEqual([7,8,9,10,11,12,13,14,15,16,5,8,19,5,8,22,23,24,25,26,27,28,5,8,31,32,33,34,35,36],da.getValues())
6323         pass
6324
6325     def testSwigDAIOp2(self):
6326         da=DataArrayInt.New()
6327         st=da.getHiddenCppPointer()
6328         da.alloc(10,3)
6329         da.rearrange(1)
6330         da.iota(0)
6331         da.rearrange(3)
6332         da[:,1]+=4
6333         da[-2:,2]+=10
6334         da[-2:,2]+=10
6335         da[:,2]+=da[:,0]
6336         da[da[0],:]=7
6337         self.assertEqual(st,da.getHiddenCppPointer())
6338         self.assertEqual(da.getValues(),[7,7,7,3,8,8,7,7,7,9,14,20,12,17,26,7,7,7,18,23,38,21,26,44,24,29,70,27,32,76])
6339         pass
6340
6341     def testSwigDAIOp3(self):
6342         da=DataArrayInt.New()
6343         self.assertRaises(InterpKernelException,da.__len__)
6344         self.assertRaises(InterpKernelException,da.__int__)
6345         for elt in da:
6346             self.assertTrue(False)
6347             pass
6348         da.alloc(12,3)
6349         da.rearrange(1) ; da.fillWithZero()
6350         l1=list(da)
6351         self.assertEqual(36,len(da));
6352         da.rearrange(3)
6353         tmp=da[0]
6354         self.assertRaises(InterpKernelException,tmp.__int__)
6355         self.assertEqual(12,len(da));
6356         l=list(da)
6357         for elt in enumerate(l):
6358             elt[1][2]=elt[0]
6359             pass
6360         ref=[0,0,0,0,0,1,0,0,2,0,0,3,0,0,4,0,0,5,0,0,6,0,0,7,0,0,8,0,0,9,0,0,10,0,0,11]
6361         self.assertEqual(ref,da.getValues());
6362         da.rearrange(1)
6363         l=[int(elt) for elt in l1]
6364         self.assertEqual(ref,da.getValues());
6365         self.assertEqual(11,int(da[-1:]))
6366         pass
6367
6368     def testSwigDADOp3(self):
6369         da=DataArrayDouble.New()
6370         self.assertRaises(InterpKernelException,da.__len__)
6371         self.assertRaises(InterpKernelException,da.__float__)
6372         for elt in da:
6373             self.assertTrue(False)
6374             pass
6375         da.alloc(12,3)
6376         da.rearrange(1) ; da.fillWithZero()
6377         l1=list(da)
6378         self.assertEqual(36,len(da));
6379         da.rearrange(3)
6380         tmp=da[0]
6381         self.assertRaises(InterpKernelException,tmp.__float__)
6382         self.assertEqual(12,len(da));
6383         l=list(da)
6384         for elt in enumerate(l):
6385             elt[1][2]=elt[0]
6386             pass
6387         ref=[0.,0.,0.,0.,0.,1.,0.,0.,2.,0.,0.,3.,0.,0.,4.,0.,0.,5.,0.,0.,6.,0.,0.,7.,0.,0.,8.,0.,0.,9.,0.,0.,10.,0.,0.,11.]
6388         self.assertEqual(ref,da.getValues());
6389         da.rearrange(1)
6390         l=[float(elt) for elt in l1]
6391         self.assertEqual(ref,da.getValues());
6392         self.assertEqual(11.,float(da[-1:]))
6393         pass
6394
6395     def testSwigDataArrayIntIterator1(self):
6396         da=DataArrayInt.New()
6397         da.alloc(12,1)
6398         da.iota(2)
6399         da.rearrange(3)
6400         # __getitem__ testing
6401         li=[]
6402         for it in da:
6403             li+=it[1:]
6404             pass
6405         self.assertEqual([3, 4, 6, 7, 9, 10, 12, 13],li)
6406         li=[]
6407         for it in da:
6408             li+=[it[-1]]
6409             pass
6410         self.assertEqual([4, 7, 10, 13],li)
6411         li=[]
6412         for it in da:
6413             li+=it[[2,1,0]]
6414             pass
6415         self.assertEqual([4, 3, 2, 7, 6, 5, 10, 9, 8, 13, 12, 11],li)
6416         # __setitem__ testing
6417         da3=da.deepCpy()
6418         da2=DataArrayInt.New()
6419         da2.alloc(12,1)
6420         da2.iota(2002)
6421         da2.rearrange(3)
6422         it2=da2.__iter__()
6423         i=0
6424         for it in da:
6425             pt=it2.next()
6426             it[:]=pt
6427             pass
6428         self.assertTrue(da.isEqual(da2))
6429         da=da3
6430         da3=da.deepCpy()
6431         #
6432         for it in da:
6433             it[:]=5
6434             pass
6435         da.rearrange(1)
6436         self.assertTrue(da.isUniform(5))
6437         da=da3
6438         da3=da.deepCpy()
6439         #
6440         for it in da:
6441             it[:]=[8,9,12]
6442             pass
6443         self.assertEqual([8, 9, 12, 8, 9, 12, 8, 9, 12, 8, 9, 12],da.getValues())
6444         da=da3
6445         da3=da.deepCpy()
6446         #
6447         for it in da:
6448             it[2]=[7]
6449             pass
6450         self.assertEqual([2, 3, 7, 5, 6, 7, 8, 9, 7, 11, 12, 7],da.getValues())
6451         pass
6452
6453     def testSwigDataArrayDoubleIterator1(self):
6454         da=DataArrayDouble.New()
6455         da.alloc(12,1)
6456         da.iota(2)
6457         da.rearrange(3)
6458         # __getitem__ testing
6459         li=[]
6460         for it in da:
6461             li+=it[1:]
6462             pass
6463         self.assertEqual([3, 4, 6, 7, 9, 10, 12, 13],li)
6464         li=[]
6465         for it in da:
6466             li+=[it[-1]]
6467             pass
6468         self.assertEqual([4, 7, 10, 13],li)
6469         li=[]
6470         for it in da:
6471             li+=it[[2,1,0]]
6472             pass
6473         self.assertEqual([4, 3, 2, 7, 6, 5, 10, 9, 8, 13, 12, 11],li)
6474         # __setitem__ testing
6475         da3=da.deepCpy()
6476         da2=DataArrayDouble.New()
6477         da2.alloc(12,1)
6478         da2.iota(2002)
6479         da2.rearrange(3)
6480         it2=da2.__iter__()
6481         i=0
6482         for it in da:
6483             pt=it2.next()
6484             it[:]=pt
6485             pass
6486         self.assertTrue(da.isEqual(da2,1e-12))
6487         da=da3
6488         da3=da.deepCpy()
6489         #
6490         for it in da:
6491             it[:]=5
6492             pass
6493         da.rearrange(1)
6494         self.assertTrue(da.isUniform(5,1e-12))
6495         da=da3
6496         da3=da.deepCpy()
6497         #
6498         for it in da:
6499             it[:]=[8,9,12]
6500             pass
6501         self.assertEqual([8, 9, 12, 8, 9, 12, 8, 9, 12, 8, 9, 12],da.getValues())
6502         da=da3
6503         da3=da.deepCpy()
6504         #
6505         for it in da:
6506             it[2]=[7]
6507             pass
6508         self.assertEqual([2, 3, 7, 5, 6, 7, 8, 9, 7, 11, 12, 7],da.getValues())
6509         pass
6510
6511     def testSwigUMeshIterator1(self):
6512         m=MEDCouplingDataForTest.build2DTargetMesh_1()
6513         li1=[]
6514         li2=[]
6515         for cell in m:
6516             li1+=cell.getAllConn()[1:]
6517             li2+=[cell.getType()]
6518             pass
6519         self.assertEqual(li1,[0, 3, 4, 1, 1, 4, 2, 4, 5, 2, 6, 7, 4, 3, 7, 8, 5, 4])
6520         self.assertEqual(li2,[4, 3, 3, 4, 4])
6521         pass
6522
6523     def testSwigUMeshIterator2(self):
6524         m=MEDCouplingDataForTest.build2DTargetMesh_1()
6525         self.assertRaises(InterpKernelException,m.cellsByType);
6526         m.rearrange2ConsecutiveCellTypes()
6527         li1=[]
6528         li2=[]
6529         li3=[]
6530         for cellsByType in m.cellsByType():
6531             li1.append(cellsByType.getType())
6532             li2.append(cellsByType.getNumberOfElems())
6533             temp=[]
6534             for cell in cellsByType:
6535                 t=[None,None]
6536                 t[0]=cell.getType()
6537                 t[1]=cell.getAllConn()[1:]
6538                 temp.append(t)
6539                 pass
6540             li3.append(temp)
6541             pass
6542         self.assertEqual(li1,[4, 3])
6543         self.assertEqual(li2,[3, 2])
6544         self.assertEqual(li3,[[[4, (0, 3, 4, 1)], [4, (6, 7, 4, 3)], [4, (7, 8, 5, 4)]], [[3, (1, 4, 2)], [3, (4, 5, 2)]]])
6545         pass
6546
6547     def testDAIAggregateMulti1(self):
6548         a=DataArrayInt.New()
6549         a.setValues(range(4),2,2)
6550         a.setName("aa")
6551         b=DataArrayInt.New()
6552         b.setValues(range(6),3,2)
6553         c=DataArrayInt.Aggregate([a,b])
6554         self.assertEqual(range(4)+range(6),c.getValues())
6555         self.assertEqual("aa",c.getName())
6556         self.assertEqual(5,c.getNumberOfTuples())
6557         self.assertEqual(2,c.getNumberOfComponents())
6558         pass
6559
6560     def testMergeUMeshes2(self):
6561         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6562         m2=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6563         m3=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6564         #
6565         vec1=[0,2,3]
6566         m2_2=m2.buildPartOfMySelf(vec1,False);
6567         vec2=[1,1]
6568         m3_2=m3.buildPartOfMySelf(vec2,False);
6569         #
6570         ms=[m1,m2_2,m3_2];
6571         #
6572         self.assertRaises(InterpKernelException,MEDCouplingUMesh.MergeUMeshes,ms+[None]);
6573         self.assertRaises(InterpKernelException,MEDCouplingUMesh.MergeUMeshes,ms+[3.4])
6574         m4=MEDCouplingUMesh.MergeUMeshes(ms);
6575         m4.checkCoherency();
6576         self.assertEqual(10,m4.getNumberOfCells());
6577         self.assertEqual(20,m4.getNumberOfNodes());
6578         self.assertEqual(45,m4.getMeshLength());
6579         m4bis=MEDCouplingMesh.MergeMeshes(ms);
6580         self.assertTrue(m4.isEqual(m4bis,1e-12))
6581         del m4bis
6582         #
6583         vec3=[0,1,2,3,4]
6584         m4_1=m4.buildPartOfMySelf(vec3,False);
6585         m4_1.setName(m1.getName());
6586         self.assertTrue(m4_1.isEqual(m1,1e-12));
6587         #
6588         vec4=[5,6,7]
6589         m4_2=m4.buildPartOfMySelf(vec4,False);
6590         cellCor,nodeCor=m4_2.checkGeoEquivalWith(m2_2,10,1e-12);
6591         #
6592         vec5=[8,9]
6593         m4_3=m4.buildPartOfMySelf(vec5,False);
6594         self.assertEqual(2,m4_3.getNumberOfCells());
6595         self.assertEqual(3,m4_3.getNumberOfNodes());
6596         m3_2.zipCoords();
6597         m4_3.setName(m3_2.getName());
6598         self.assertTrue(m4_3.isEqual(m3_2,1e-12));
6599         #
6600         pass
6601
6602     def testBuild0DMeshFromCoords1(self):
6603         sourceCoords=[-0.3,-0.3,0., 0.7,-0.3,0., -0.3,0.7,0., 0.7,0.7,0.]
6604         coo=DataArrayDouble.New();
6605         coo.setValues(sourceCoords,4,3);
6606         coo.setName("My0D");
6607         m=MEDCouplingUMesh.Build0DMeshFromCoords(coo);
6608         m.checkCoherency();
6609         self.assertEqual(4,m.getNumberOfNodes());
6610         self.assertEqual(4,m.getNumberOfCells());
6611         self.assertEqual(3,m.getSpaceDimension());
6612         self.assertEqual(0,m.getMeshDimension());
6613         types1=m.getAllTypes();
6614         self.assertEqual([NORM_POINT1],types1);
6615         for i in xrange(4):
6616             conn=m.getNodeIdsOfCell(i);
6617             self.assertEqual([i],conn);
6618             self.assertTrue(NORM_POINT1==m.getTypeOfCell(i));
6619             pass
6620         self.assertEqual(m.getName(),"My0D");
6621         pass
6622
6623     def testDescriptionInMeshTimeUnit1(self):
6624         text1="totoTTEDD";
6625         m=MEDCouplingDataForTest.build2DTargetMesh_1();
6626         m.setDescription(text1);
6627         self.assertEqual(m.getDescription(),text1);
6628         m2=m.deepCpy();
6629         self.assertTrue(m.isEqual(m2,1e-12));
6630         self.assertEqual(m2.getDescription(),text1);
6631         m2.setDescription("ggg");
6632         self.assertTrue(not m.isEqual(m2,1e-12));
6633         #
6634         f=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
6635         f.setTimeUnit(text1);
6636         self.assertEqual(f.getTimeUnit(),text1);
6637         f2=f.deepCpy();
6638         self.assertEqual(f2.getTimeUnit(),text1);
6639         #
6640         pass
6641
6642     def testMultiFields1(self):
6643         mfs=MEDCouplingDataForTest.buildMultiFields_1();
6644         ms=mfs.getMeshes();
6645         dms,refs=mfs.getDifferentMeshes()
6646         das=mfs.getArrays();
6647         das2,refs2=mfs.getDifferentArrays()
6648         self.assertEqual(5,len(mfs.getFields()))
6649         self.assertEqual(1,len(mfs.getFields()[0].getArrays()));
6650         self.assertEqual(2,len(mfs.getFields()[1].getArrays()));
6651         self.assertEqual(1,len(mfs.getFields()[2].getArrays()));
6652         self.assertEqual(1,len(mfs.getFields()[3].getArrays()));
6653         self.assertEqual(1,len(mfs.getFields()[4].getArrays()));
6654         self.assertEqual(5,len(ms));
6655         self.assertEqual(2,len(dms));
6656         self.assertEqual(6,len(das));
6657         self.assertEqual(5,len(das2));
6658         mfs2=mfs.deepCpy();
6659         self.assertTrue(mfs.isEqual(mfs2,1e-12,1e-12))
6660         pass
6661
6662     def testFieldOverTime1(self):
6663         fs=MEDCouplingDataForTest.buildMultiFields_2();
6664         self.assertRaises(InterpKernelException,MEDCouplingFieldOverTime.New,fs);
6665         f4bis=fs[4].buildNewTimeReprFromThis(ONE_TIME,False);
6666         fs[4]=f4bis;
6667         self.assertRaises(InterpKernelException,MEDCouplingFieldOverTime.New,fs);
6668         f4bis.setTime(2.7,20,21);
6669         fot=MEDCouplingFieldOverTime.New(fs);
6670         dt=fot.getDefinitionTimeZone();
6671         hs=dt.getHotSpotsTime();
6672         self.assertEqual(6,len(hs));
6673         expected1=[0.2,0.7,1.2,1.35,1.7,2.7]
6674         for i in xrange(6):
6675             self.assertAlmostEqual(expected1[i],hs[i],12);
6676             pass
6677         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(0.2);
6678         self.assertEqual(0,meshId);
6679         self.assertEqual(0,arrId);
6680         self.assertEqual(0,arrIdInField);
6681         self.assertEqual(0,fieldId);
6682         #
6683         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(0.7);
6684         self.assertEqual(0,meshId);
6685         self.assertEqual(1,arrId);
6686         self.assertEqual(0,arrIdInField);
6687         self.assertEqual(1,fieldId);
6688         #
6689         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeLeft(1.2);#**** WARNING left here
6690         self.assertEqual(0,meshId);
6691         self.assertEqual(2,arrId);
6692         self.assertEqual(1,arrIdInField);
6693         self.assertEqual(1,fieldId);
6694         #
6695         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(1.2);#**** WARNING right again here
6696         self.assertEqual(1,meshId);
6697         self.assertEqual(3,arrId);
6698         self.assertEqual(0,arrIdInField);
6699         self.assertEqual(2,fieldId);
6700         #
6701         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(1.35);
6702         self.assertEqual(1,meshId);
6703         self.assertEqual(3,arrId);
6704         self.assertEqual(0,arrIdInField);
6705         self.assertEqual(2,fieldId);
6706         #
6707         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(1.7);
6708         self.assertEqual(0,meshId);
6709         self.assertEqual(3,arrId);
6710         self.assertEqual(0,arrIdInField);
6711         self.assertEqual(3,fieldId);
6712         #
6713         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(2.7);
6714         self.assertEqual(1,meshId);
6715         self.assertEqual(4,arrId);
6716         self.assertEqual(0,arrIdInField);
6717         self.assertEqual(4,fieldId);
6718         #
6719         dt2=MEDCouplingDefinitionTime();
6720         self.assertTrue(not dt2.isEqual(dt));
6721         dt2.assign(dt);
6722         dt2.assign(dt);#to check memory management
6723         self.assertTrue(dt2.isEqual(dt));
6724         #
6725         dt3=MEDCouplingDefinitionTime();
6726         #
6727         pass
6728
6729     def testDAICheckAndPreparePermutation1(self):
6730         vals1=[9,10,0,6,4,11,3,7];
6731         expect1=[5,6,0,3,2,7,1,4];
6732         vals2=[9,10,0,6,10,11,3,7];
6733         da=DataArrayInt.New();
6734         da.setValues(vals1,8,1);
6735         da2=da.checkAndPreparePermutation();
6736         self.assertEqual(8,da2.getNumberOfTuples());
6737         self.assertEqual(1,da2.getNumberOfComponents());
6738         for i in xrange(8):
6739             self.assertEqual(expect1[i],da2.getIJ(i,0));
6740             pass
6741         #
6742         da=DataArrayInt.New();
6743         da.alloc(8,1);
6744         da.iota(0);
6745         da2=da.checkAndPreparePermutation();
6746         self.assertEqual(8,da2.getNumberOfTuples());
6747         self.assertEqual(1,da2.getNumberOfComponents());
6748         self.assertTrue(da2.isIdentity());
6749         #
6750         da=DataArrayInt.New();
6751         da.alloc(8,1);
6752         da.setValues(vals2,8,1);
6753         self.assertRaises(InterpKernelException,da.checkAndPreparePermutation);
6754         pass
6755
6756     def testDAIChangeSurjectiveFormat1(self):
6757         vals1=[0,3,2,3,2,2,1,2]
6758         expected1=[0,1,2,6,8]
6759         expected2=[0,  6,  2,4,5,7,  1,3]
6760         da=DataArrayInt.New();
6761         da.setValues(vals1,8,1);
6762         #
6763         da2,da2I=da.changeSurjectiveFormat(4);
6764         self.assertEqual(5,da2I.getNumberOfTuples());
6765         self.assertEqual(8,da2.getNumberOfTuples());
6766         self.assertEqual(expected1,da2I.getValues());
6767         self.assertEqual(expected2,da2.getValues());
6768         #
6769         self.assertRaises(InterpKernelException,da.changeSurjectiveFormat,3);
6770         #
6771         pass
6772
6773     def testUMeshGetCellIdsLyingOnNodes1(self):
6774         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6775         nodeIds1=[1,2,3,4,6]
6776         nodeIds2=[6,7]
6777         da=m.getCellIdsLyingOnNodes(nodeIds1,True);
6778         self.assertEqual(1,da.getNumberOfTuples());
6779         self.assertEqual(1,da.getNumberOfComponents());
6780         self.assertEqual(1,da.getIJ(0,0));
6781         da2=DataArrayInt.New()
6782         da2.setValues(nodeIds2,2,1)
6783         da=m.getCellIdsLyingOnNodes(da2,False);
6784         self.assertEqual(2,da.getNumberOfTuples());
6785         self.assertEqual(1,da.getNumberOfComponents());
6786         self.assertEqual(3,da.getIJ(0,0));
6787         self.assertEqual(4,da.getIJ(1,0));
6788         pass
6789
6790     def testUMeshFindCellIdsOnBoundary1(self):
6791         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6792         da5=m.findCellIdsOnBoundary();
6793         self.assertEqual(5,da5.getNumberOfTuples());
6794         self.assertTrue(da5.isIdentity());
6795         pass
6796
6797     def testMeshSetTime1(self):
6798         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6799         m2=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6800         #
6801         self.assertTrue(m1.isEqual(m2,1e-12));
6802         m1.setTime(3.14,6,7);
6803         tmp3,tmp1,tmp2=m1.getTime();
6804         self.assertEqual(6,tmp1);
6805         self.assertEqual(7,tmp2);
6806         self.assertAlmostEqual(3.14,tmp3,12);
6807         self.assertTrue(not m1.isEqual(m2,1e-12));
6808         m2.setTime(3.14,6,7);
6809         self.assertTrue(m1.isEqual(m2,1e-12));
6810         m1.setTimeUnit("ms");
6811         self.assertTrue(m1.getTimeUnit()=="ms");
6812         m1.setTimeUnit("us");
6813         self.assertTrue(m1.getTimeUnit()=="us");
6814         self.assertTrue(not m1.isEqual(m2,1e-12));
6815         m2.setTimeUnit("us");
6816         self.assertTrue(m1.isEqual(m2,1e-12));
6817         m2.setTime(3.14,6,8);
6818         self.assertTrue(not m1.isEqual(m2,1e-12));
6819         m2.setTime(3.14,7,7);
6820         self.assertTrue(not m1.isEqual(m2,1e-12));
6821         m2.setTime(3.15,6,7);
6822         self.assertTrue(not m1.isEqual(m2,1e-12));
6823         #
6824         m1.setTime(10.34,55,12);
6825         m3=m1.deepCpy();
6826         self.assertTrue(m1.isEqual(m3,1e-12));
6827         tmp3,tmp1,tmp2=m3.getTime();
6828         self.assertEqual(55,tmp1);
6829         self.assertEqual(12,tmp2);
6830         self.assertAlmostEqual(10.34,tmp3,12);
6831         #
6832         # testing CMesh
6833         coo1=[0.,1.,2.,3.5]
6834         a=DataArrayDouble.New();
6835         a.setValues(coo1,4,1);
6836         b=MEDCouplingCMesh.New();
6837         b.setCoordsAt(0,a);
6838         #
6839         b.setTime(5.67,8,100);
6840         tmp3,tmp1,tmp2=b.getTime();
6841         self.assertEqual(8,tmp1);
6842         self.assertEqual(100,tmp2);
6843         self.assertAlmostEqual(5.67,tmp3,12);
6844         c=b.deepCpy();
6845         self.assertTrue(c.isEqual(b,1e-12));
6846         tmp3,tmp1,tmp2=c.getTime();
6847         self.assertEqual(8,tmp1);
6848         self.assertEqual(100,tmp2);
6849         self.assertAlmostEqual(5.67,tmp3,12);
6850         pass
6851
6852     def testApplyFuncTwo1(self):
6853         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6854         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
6855         f1.setMesh(m1);
6856         #
6857         vals=[1.,11.,21.,2.,12.,22.,3.,13.,23.,4.,14.,24.,5.,15.,25.]
6858         da=DataArrayDouble.New();
6859         da.setValues(vals,5,3);
6860         f1.setArray(da);
6861         #
6862         self.assertRaises(InterpKernelException,da.applyFunc2,1,"y+z");
6863         da.setInfoOnComponent(0,"x [m]");
6864         da.setInfoOnComponent(1,"y [mm]");
6865         da.setInfoOnComponent(2,"z [km]");
6866         
6867         self.assertRaises(InterpKernelException, da.applyFunc2, 1, "x+y+zz+zzz");
6868         self.assertRaises(InterpKernelException, da.applyFunc2, 1, "toto(x+y)");
6869         self.assertRaises(InterpKernelException, da.applyFunc2, 1, "x/0");
6870         
6871         da2=da.applyFunc2(1,"y+z");
6872         self.assertEqual(1,da2.getNumberOfComponents());
6873         self.assertEqual(5,da2.getNumberOfTuples());
6874         expected1=[32.,34.,36.,38.,40.]
6875         for i in xrange(5):
6876             self.assertAlmostEqual(expected1[i],da2.getIJ(0,i),12);
6877             pass
6878         da2=da.applyFunc(1,"y+z");
6879         expected2=[12.,14.,16.,18.,20.]
6880         for i in xrange(5):
6881             self.assertAlmostEqual(expected2[i],da2.getIJ(0,i),12);
6882             pass
6883         #
6884         self.assertEqual(3,f1.getNumberOfComponents());
6885         self.assertEqual(5,f1.getNumberOfTuples());
6886         f1.applyFunc2(1,"y+z");
6887         self.assertEqual(1,f1.getNumberOfComponents());
6888         self.assertEqual(5,f1.getNumberOfTuples());
6889         for i in xrange(5):
6890             self.assertAlmostEqual(expected1[i],f1.getArray().getIJ(0,i),12);
6891             pass
6892         #
6893         pass
6894
6895     def testApplyFuncThree1(self):
6896         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6897         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
6898         f1.setMesh(m1);
6899         #
6900         vals=[1.,11.,21.,2.,12.,22.,3.,13.,23.,4.,14.,24.,5.,15.,25.]
6901         da=DataArrayDouble.New();
6902         da.setValues(vals,5,3);
6903         f1.setArray(da);
6904         #
6905         vs=3*[None];
6906         vs[0]="x"; vs[1]="Y"; vs[2]="z";
6907         self.assertRaises(InterpKernelException, da.applyFunc3, 1, vs, "y+z");
6908         self.assertRaises(InterpKernelException, da.applyFunc3, 1, vs, "x+Y+z+zz+zzz");
6909         self.assertRaises(InterpKernelException, da.applyFunc3, 1, vs, "x/0");
6910         vs[1]="y";
6911         da2=da.applyFunc3(1,vs,"y+z");
6912         expected1=[32.,34.,36.,38.,40.]
6913         for i in xrange(5):
6914             self.assertAlmostEqual(expected1[i],da2.getIJ(0,i),12);
6915             pass
6916         self.assertRaises(InterpKernelException, da.applyFunc3, 1, ["x","y","z","a"],"x+a")
6917         f1.setArray(da);
6918         self.assertEqual(3,f1.getNumberOfComponents());
6919         self.assertEqual(5,f1.getNumberOfTuples());
6920         f1.applyFunc3(1,vs,"y+z");
6921         self.assertEqual(1,f1.getNumberOfComponents());
6922         self.assertEqual(5,f1.getNumberOfTuples());
6923         for i in xrange(5):
6924             self.assertAlmostEqual(expected1[i],f1.getArray().getIJ(0,i),12);
6925             pass
6926         pass
6927
6928     def testFillFromAnalyticTwo1(self):
6929         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6930         m1.setTime(3.4,5,6); m1.setTimeUnit("us");
6931         self.assertRaises(InterpKernelException,m1.fillFromAnalytic2,ON_NODES,1,"y+z");
6932         m1.getCoords().setInfoOnComponent(0,"x [m]");
6933         m1.getCoords().setInfoOnComponent(1,"y");
6934         m1.getCoords().setInfoOnComponent(2,"z");
6935         f1=m1.fillFromAnalytic2(ON_NODES,1,"y+z");
6936         self.assertAlmostEqual(3.4,f1.getTime()[0],12) ; self.assertEqual(5,f1.getTime()[1]) ; self.assertEqual(6,f1.getTime()[2])
6937         self.assertEqual("us",f1.getTimeUnit())
6938         self.assertEqual(1,f1.getNumberOfComponents());
6939         self.assertEqual(9,f1.getNumberOfTuples());
6940         expected1=[0.2, 0.7, 1.2, 0.7, 1.2, 1.7, 1.2, 1.7, 2.2]
6941         for i in xrange(9):
6942             self.assertAlmostEqual(expected1[i],f1.getArray().getIJ(0,i),12);
6943             pass
6944         pass
6945
6946     def testFillFromAnalyticThree1(self):
6947         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6948         m1.setTime(3.4,5,6); m1.setTimeUnit("us");
6949         vs=3*[None];
6950         vs[0]="x"; vs[1]="Y"; vs[2]="z";
6951         self.assertRaises(InterpKernelException,m1.fillFromAnalytic3,ON_NODES,1,vs,"y+z");
6952         vs[1]="y";
6953         f1=m1.fillFromAnalytic3(ON_NODES,1,vs,"y+z");
6954         self.assertAlmostEqual(3.4,f1.getTime()[0],12) ; self.assertEqual(5,f1.getTime()[1]) ; self.assertEqual(6,f1.getTime()[2])
6955         self.assertEqual("us",f1.getTimeUnit())
6956         self.assertEqual(1,f1.getNumberOfComponents());
6957         self.assertEqual(9,f1.getNumberOfTuples());
6958         expected1=[0.2, 0.7, 1.2, 0.7, 1.2, 1.7, 1.2, 1.7, 2.2]
6959         for i in xrange(9):
6960             self.assertAlmostEqual(expected1[i],f1.getArray().getIJ(0,i),12);
6961             pass
6962         pass
6963
6964     def testDAUnitVar1(self):
6965         da=DataArrayDouble.New();
6966         da.alloc(1,3);
6967         da.setInfoOnComponent(0,"XPS [m]");
6968         st1=da.getVarOnComponent(0);
6969         self.assertTrue(st1=="XPS");
6970         st2=da.getUnitOnComponent(0);
6971         self.assertTrue(st2=="m");
6972         #
6973         da.setInfoOnComponent(0,"XPS         [m]");
6974         st1=da.getVarOnComponent(0);
6975         self.assertTrue(st1=="XPS");
6976         st2=da.getUnitOnComponent(0);
6977         self.assertTrue(st2=="m");
6978         #
6979         da.setInfoOnComponent(0,"XPP         [m]");
6980         st1=da.getVarOnComponent(0);
6981         self.assertTrue(st1=="XPP");
6982         st2=da.getUnitOnComponent(0);
6983         self.assertTrue(st2=="m");
6984         #
6985         da.setInfoOnComponent(0,"XPP kdep  kefer   [ m  ]");
6986         st1=da.getVarOnComponent(0);
6987         self.assertTrue(st1=="XPP kdep  kefer");
6988         st2=da.getUnitOnComponent(0);
6989         self.assertTrue(st2==" m  ");
6990         #
6991         da.setInfoOnComponent(0,"     XPP k[  dep  k]efer   [ m^ 2/s^3*kJ  ]");
6992         st1=da.getVarOnComponent(0);
6993         self.assertTrue(st1=="     XPP k[  dep  k]efer");
6994         st2=da.getUnitOnComponent(0);
6995         self.assertTrue(st2==" m^ 2/s^3*kJ  ");
6996         #
6997         da.setInfoOnComponent(0,"     XPP kefer   ");
6998         st1=da.getVarOnComponent(0);
6999         self.assertTrue(st1=="     XPP kefer   ");
7000         st2=da.getUnitOnComponent(0);
7001         self.assertTrue(st2=="");
7002         #
7003         da.setInfoOnComponent(0,"temperature( bof)");
7004         st1=da.getVarOnComponent(0);
7005         self.assertTrue(st1=="temperature( bof)");
7006         st2=da.getUnitOnComponent(0);
7007         self.assertTrue(st2=="");
7008         #
7009         da.setInfoOnComponent(0,"kkk [m]");
7010         da.setInfoOnComponent(1,"ppp   [m^2/kJ]");
7011         da.setInfoOnComponent(2,"abcde   [MW/s]");
7012         #
7013         vs=da.getVarsOnComponent();
7014         self.assertEqual(3,len(vs));
7015         self.assertTrue(vs[0]=="kkk");
7016         self.assertTrue(vs[1]=="ppp");
7017         self.assertTrue(vs[2]=="abcde");
7018         vs=da.getUnitsOnComponent();
7019         self.assertEqual(3,len(vs));
7020         self.assertTrue(vs[0]=="m");
7021         self.assertTrue(vs[1]=="m^2/kJ");
7022         self.assertTrue(vs[2]=="MW/s");
7023         pass
7024
7025     def testGaussCoordinates1(self):
7026         #Testing 1D cell types
7027         m1=MEDCouplingDataForTest.build1DMultiTypes_1();
7028         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,ONE_TIME);
7029         f.setMesh(m1);
7030         wg1=[0.3];
7031         gsCoo1=[0.2];
7032         refCoo1=[-1.0,1.0];
7033         f.setGaussLocalizationOnType(NORM_SEG2,refCoo1,gsCoo1,wg1);
7034         wg2=wg1;
7035         gsCoo2=[0.2];
7036         refCoo2=[-1.0,1.0,0.0];
7037         f.setGaussLocalizationOnType(NORM_SEG3,refCoo2,gsCoo2,wg2);
7038         #
7039         resToTest=f.getLocalizationOfDiscr();
7040         self.assertEqual(3,resToTest.getNumberOfComponents());
7041         self.assertEqual(2,resToTest.getNumberOfTuples());
7042         expected1=[0.6,0.6,0.6, 0.6,0.6,0.6]
7043         for i in xrange(6):
7044             self.assertAlmostEqual(expected1[i],resToTest.getIJ(0,i),14);
7045             pass
7046         #
7047         #Testing 2D cell types
7048         m2=MEDCouplingDataForTest.build2DMultiTypes_1();
7049         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,ONE_TIME);
7050         f.setMesh(m2);
7051         wg3=[0.3,0.3];
7052         tria3CooGauss=[ 0.1, 0.8, 0.2, 0.7 ]
7053         gsCoo3=tria3CooGauss
7054         tria3CooRef=[ 0.0, 0.0, 1.0 , 0.0, 0.0, 1.0 ]
7055         refCoo3=tria3CooRef;
7056         f.setGaussLocalizationOnType(NORM_TRI3,refCoo3,gsCoo3,wg3);
7057         wg4=[0.3,0.3,0.3];
7058         tria6CooGauss=[ 0.3, 0.2, 0.2, 0.1, 0.2, 0.4 ]
7059         gsCoo4=tria6CooGauss;
7060         tria6CooRef=[0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.5, 0.0, 0.5, 0.5, 0.0, 0.5]
7061         refCoo4=tria6CooRef;
7062         f.setGaussLocalizationOnType(NORM_TRI6,refCoo4,gsCoo4,wg4);
7063         wg5=[0.3,0.3,0.3,0.3];
7064         quad4CooGauss=[ 0.3, 0.2, 0.2, 0.1, 0.2, 0.4, 0.15, 0.27 ]
7065         gsCoo5=quad4CooGauss;
7066         quad4CooRef=[-1.0, 1.0, -1.0, -1.0, 1.0, -1.0, 1.0, 1.0]
7067         refCoo5=quad4CooRef;
7068         f.setGaussLocalizationOnType(NORM_QUAD4,refCoo5,gsCoo5,wg5);
7069         wg6=[0.3,0.3,0.3,0.3];
7070         quad8CooGauss=[ 0.34, 0.16, 0.21, 0.3, 0.23, 0.4, 0.14, 0.37 ]
7071         gsCoo6=quad8CooGauss;
7072         quad8CooRef=[ -1.0, -1.0, 1.0, -1.0, 1.0,  1.0, -1.0,  1.0, 0.0, -1.0, 1.0,  0.0, 0.0,  1.0, -1.0,  0.0]
7073         refCoo6=quad8CooRef;
7074         f.setGaussLocalizationOnType(NORM_QUAD8,refCoo6,gsCoo6,wg6);
7075         #
7076         resToTest=f.getLocalizationOfDiscr();
7077         self.assertEqual(3,resToTest.getNumberOfComponents());
7078         self.assertEqual(13,resToTest.getNumberOfTuples());#2+3+4+4 gauss points for resp TRI3,TRI6,QUAD4,QUAD8
7079         expected2=[5.1,1.55,0.0, 4.7,1.65,0.0,
7080                    2.32,1.52,0.0, 1.6,1.32,0.0, 3.52,1.26,0.0,#TRI6
7081                    2.6,1.6,0.0, 2.4,1.8,0.0, 2.4,1.2,0.0, 2.3,1.46,0.0,#QUAD4
7082                    2.32,2.68,0.0, 2.6,2.42,0.0, 2.8,2.46,0.0, 2.74,2.28,0.0 ];#QUAD8
7083         for i in xrange(39):
7084             self.assertAlmostEqual(expected2[i],resToTest.getIJ(0,i),14);
7085             pass
7086         #
7087         #Testing 3D cell types
7088         m3=MEDCouplingDataForTest.build3DMultiTypes_1();
7089         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,ONE_TIME);
7090         f.setMesh(m3);
7091         #
7092         wg7=[0.3];
7093         tetra4CooGauss=[0.34, 0.16, 0.21]
7094         gsCoo7=tetra4CooGauss;
7095         tetra4CooRef=[0.0,1.0,0.0, 0.0,0.0,1.0, 0.0,0.0,0.0, 1.0,0.0,0.0]
7096         refCoo7=tetra4CooRef;
7097         f.setGaussLocalizationOnType(NORM_TETRA4,refCoo7,gsCoo7,wg7);
7098         wg8=[0.3];
7099         tetra10CooGauss=[0.2, 0.3, 0.1]
7100         gsCoo8=tetra10CooGauss;
7101         tetra10CooRef=[0.0,1.0,0.0, 0.0,0.0,0.0, 0.0,0.0,1.0, 1.0,0.0,0.0, 0.0,0.5,0.0, 0.0,0.0,0.5, 0.0,0.5,0.5, 0.5,0.5,0.0, 0.5,0.0,0.0, 0.5,0.0,0.5]
7102         refCoo8=tetra10CooRef;
7103         f.setGaussLocalizationOnType(NORM_TETRA10,refCoo8,gsCoo8,wg8);
7104         wg9=[0.3];
7105         pyra5CooGauss=[0.2, 0.3, 0.1]
7106         gsCoo9=pyra5CooGauss;
7107         pyra5CooRef=[1.0,0.0,0.0, 0.0,1.0,0.0, -1.0,0.0,0.0, 0.0,-1.0,0.0, 0.0,0.0,1.0]
7108         refCoo9=pyra5CooRef;
7109         f.setGaussLocalizationOnType(NORM_PYRA5,refCoo9,gsCoo9,wg9);
7110         wg10=[0.3];
7111         pyra13CooGauss=[0.1, 0.2, 0.7]
7112         gsCoo10=pyra13CooGauss;
7113         pyra13CooRef=[1.0,0.0,0.0, 0.0,1.0,0.0,-1.0,0.0,0.0,0.0,-1.0,0.0,0.0,0.0,1.0,0.5,0.5,0.0,-0.5,0.5,0.0,-0.5,-0.5,0.0,0.5,-0.5,0.0,0.5,0.0,0.5,0.0,0.5,0.5,-0.5,0.0,0.5,0.0,-0.5,0.5]
7114         refCoo10=pyra13CooRef;
7115         f.setGaussLocalizationOnType(NORM_PYRA13,refCoo10,gsCoo10,wg10);
7116         wg11=[0.3];
7117         penta6CooGauss=[0.2, 0.3, 0.1]
7118         gsCoo11=penta6CooGauss;
7119         penta6CooRef=[-1.0,1.0,0.0,-1.0,-0.0,1.0,-1.0,0.0,0.0,1.0,1.0,0.0,1.0,0.0,1.0,1.0,0.0,0.0]
7120         refCoo11=penta6CooRef;
7121         f.setGaussLocalizationOnType(NORM_PENTA6,refCoo11,gsCoo11,wg11);
7122         wg12=[0.3];
7123         penta15CooGauss=[0.2, 0.3,0.15]
7124         gsCoo12=penta15CooGauss;
7125         penta15CooRef=[-1.0,1.0,0.0,-1.0,0.0,1.0,-1.0,0.0,0.0,1.0,1.0,0.0,1.0,0.0,1.0,1.0,0.0,0.0,-1.0,0.5,0.5,-1.0,0.0,0.5,-1.0,0.5,0.0,0.0,1.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,0.5,0.5,1.0,0.0, 0.5,1.0,0.5,0.0]
7126         refCoo12=penta15CooRef;
7127         f.setGaussLocalizationOnType(NORM_PENTA15,refCoo12,gsCoo12,wg12);
7128         wg13=[0.3];
7129         hexa8CooGauss=[0.2,0.3,0.15]
7130         gsCoo13=hexa8CooGauss;
7131         hexa8CooRef=[-1.0,-1.0,-1.0,1.0,-1.0,-1.0,1.0,1.0,-1.0,-1.0,1.0,-1.0,-1.0,-1.0,1.0,1.0,-1.0,1.0,1.0,1.0,1.0,-1.0,1.0,1.0]
7132         refCoo13=hexa8CooRef;
7133         f.setGaussLocalizationOnType(NORM_HEXA8,refCoo13,gsCoo13,wg13);
7134         wg14=[0.3];
7135         hexa20CooGauss=[0.11,0.3,0.55]
7136         gsCoo14=hexa20CooGauss;
7137         hexa20CooRef=[-1.0,-1.0,-1.0,1.0,-1.0,-1.0,1.0,1.0,-1.0,-1.0,1.0,-1.0,-1.0,-1.0,1.0,1.0,-1.0,1.0,1.0,1.0,1.0,-1.0,1.0,1.0,0.0,-1.0,-1.0,1.0,0.0,-1.0,0.0,1.0,-1.0,-1.0,0.0,-1.0,-1.0,-1.0,0.0,1.0,-1.0,0.0,1.0,1.0,0.0,-1.0,1.0,0.0,0.0,-1.0,1.0,1.0,0.0,1.0,0.0,1.0,1.0,-1.0,0.0,1.0]
7138         refCoo14=hexa20CooRef;
7139         f.setGaussLocalizationOnType(NORM_HEXA20,refCoo14,gsCoo14,wg14);
7140         #
7141         resToTest=f.getLocalizationOfDiscr();
7142         self.assertEqual(3,resToTest.getNumberOfComponents());
7143         self.assertEqual(8,resToTest.getNumberOfTuples());#2+3+4+4 gauss points for resp TRI3,TRI6,QUAD4,QUAD8
7144         expected3=[1.312,3.15,1.02, 0.56,3.3,0.6, 2.18,1.1,0.2, 1.18,1.54,0.98, 1.56,0.3,3.6, 1.613,0.801,4.374, 2.6,2.4,2.3, 2.31232,2.3933985,1.553255]
7145         for i in xrange(24):
7146             self.assertAlmostEqual(expected3[i],resToTest.getIJ(0,i),14);
7147             pass
7148         #
7149         pass
7150
7151     def testP2Localization1(self):
7152         m=MEDCouplingUMesh.New("testP2",2);
7153         coords=[0.,2.,3.5,0.,4.5,1.5,1.2,0.32,3.4,1.,2.1,2.4]
7154         conn=[0,1,2,3,4,5]
7155         coo=DataArrayDouble.New();
7156         coo.setValues(coords,6,2);
7157         m.setCoords(coo);
7158         m.allocateCells(1);
7159         m.insertNextCell(NORM_TRI6,6,conn[0:6])
7160         m.finishInsertingCells();
7161         #
7162         f=MEDCouplingFieldDouble.New(ON_NODES,ONE_TIME);
7163         f.setMesh(m);
7164         da=DataArrayDouble.New();
7165         vals1=[1.2,2.3,3.4, 2.2,3.3,4.4, 3.2,4.3,5.4, 4.2,5.3,6.4, 5.2,6.3,7.4, 6.2,7.3,8.4]
7166         da.setValues(vals1,6,3);
7167         f.setArray(da);
7168         #
7169         loc=[2.27,1.3]
7170         locs=f.getValueOnMulti(loc);
7171         expected1=[6.0921164547752236, 7.1921164547752232, 8.2921164547752255]
7172         for i in xrange(3):
7173             self.assertAlmostEqual(expected1[i],locs.getIJ(0,i),12);
7174             pass
7175         pass
7176
7177     def testP2Localization2(self):
7178         m=MEDCouplingUMesh.New("testP2_2",3);
7179         coords=[0.33312787792955395, -0.35155740179580952, -0.03567564825034563, 1.307146326477638, -0.57234557776250305, -0.08608044208272235, 0.5551834466499993, 0.62324964668794192, -0.014638951108536295, 0.37761817224442129, -0.38324019806913578, 0.96283164472856886, 0.79494856035658679, -0.40628057809270046, 0.0021004190225864614, 1.023740446371799, 0.07665912970471335, -0.072889657161871096, 0.54564584619517376, 0.11132872093429744, 0.039647326652013051, 0.27164784387819052, -0.42018012100866675, 0.46563376500745146, 0.89501965094896418, -0.56148455362735061, 0.43337469695473035, 0.49118025152924394, 0.093884938060727313, 0.47216346905220891]
7180         conn=[0,1,2,3,4,5,6,7,8,9]
7181         coo=DataArrayDouble.New();
7182         coo.setValues(coords,10,3);
7183         m.setCoords(coo);
7184         m.allocateCells(1);
7185         m.insertNextCell(NORM_TETRA10,10,conn[0:10])
7186         m.finishInsertingCells();
7187         #
7188         f=MEDCouplingFieldDouble.New(ON_NODES,ONE_TIME);
7189         f.setMesh(m);
7190         da=DataArrayDouble.New();
7191         vals1=[1.1,2.1,3.1,4.1,5.2,6.2,7.2,8.2,9.2,10.2]
7192         da.setValues(vals1,10,1);
7193         f.setArray(da);
7194         #
7195         loc=[0.64637931739890486, -0.16185896817550552, 0.22678966365273748]
7196         locs=f.getValueOnMulti(loc);
7197         expected1=[10.0844021968047]
7198         for i in xrange(1):
7199             self.assertAlmostEqual(expected1[i],locs.getIJ(0,i),12);
7200             pass
7201         pass
7202
7203     def testGetValueOn2(self):
7204         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7205         f=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
7206         f.setMesh(m);
7207         arr=DataArrayDouble.New();
7208         nbOfCells=m.getNumberOfCells();
7209         f.setArray(arr);
7210         values1=[7.,107.,10007.,8.,108.,10008.,9.,109.,10009.,10.,110.,10010.,11.,111.,10011.]
7211         arr.setValues(values1,nbOfCells,3);
7212         loc=[-0.05,-0.05, 0.55,-0.25, 0.55,0.15, -0.05,0.45, 0.45,0.45]
7213         f.checkCoherency();
7214         locs=f.getValueOnMulti(loc);
7215         self.assertEqual(5,locs.getNumberOfTuples());
7216         self.assertEqual(3,locs.getNumberOfComponents());
7217         for j in xrange(15):
7218             self.assertAlmostEqual(values1[j],locs.getIJ(0,j),12);
7219             pass
7220         # Testing ON_NODES
7221         f=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
7222         f.setMesh(m);
7223         arr=DataArrayDouble.New();
7224         nbOfNodes=m.getNumberOfNodes();
7225         f.setArray(arr);
7226         values2=[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.]
7227         arr.setValues(values2,nbOfNodes,3);
7228         loc2=[0.5432,-0.2432, 0.5478,0.1528, 0.5432,-0.2432, 0.5432,-0.2432]
7229         expected2=[9.0272, 109.0272, 10009.0272, 11.4124,111.4124,10011.4124, 9.0272, 109.0272, 10009.0272, 9.0272, 109.0272, 10009.0272]
7230         f.checkCoherency();
7231         loc3=DataArrayDouble.New()
7232         loc3.setValues(loc2,4,2);
7233         locs=f.getValueOnMulti(loc3);
7234         self.assertEqual(4,locs.getNumberOfTuples());
7235         self.assertEqual(3,locs.getNumberOfComponents());
7236         for i in xrange(12):
7237             self.assertAlmostEqual(expected2[i],locs.getIJ(0,i),12);
7238             pass
7239         #
7240         pass
7241
7242     def testDAIGetIdsNotEqual1(self):
7243         d=DataArrayInt.New();
7244         vals1=[2,3,5,6,8,5,5,6,1,-5]
7245         d.setValues(vals1,10,1);
7246         d2=d.getIdsNotEqual(5);
7247         self.assertEqual(7,d2.getNumberOfTuples());
7248         self.assertEqual(1,d2.getNumberOfComponents());
7249         expected1=[0,1,3,4,7,8,9]
7250         for i in xrange(7):
7251             self.assertEqual(expected1[i],d2.getIJ(0,i));
7252             pass
7253         d.rearrange(2);
7254         self.assertRaises(InterpKernelException,d.getIdsNotEqual,5);
7255         vals2=[-4,5,6]
7256         vals3=vals2;
7257         d.rearrange(1);
7258         d3=d.getIdsNotEqualList(vals3);
7259         self.assertEqual(5,d3.getNumberOfTuples());
7260         self.assertEqual(1,d3.getNumberOfComponents());
7261         expected2=[0,1,4,8,9]
7262         for i in xrange(5):
7263             self.assertEqual(expected2[i],d3.getIJ(0,i));
7264             pass
7265         pass
7266
7267     def testDAIComputeOffsets1(self):
7268         d=DataArrayInt.New();
7269         vals1=[3,5,1,2,0,8]
7270         expected1=[0,3,8,9,11,11]
7271         d.setValues(vals1,6,1);
7272         d.computeOffsets();
7273         self.assertEqual(6,d.getNumberOfTuples());
7274         self.assertEqual(1,d.getNumberOfComponents());
7275         for i in xrange(6):
7276             self.assertEqual(expected1[i],d.getIJ(0,i));
7277             pass
7278         pass
7279
7280     def testUMeshHexagonPrism1(self):
7281         coords=[0.8660254037844386, 0.5, 0.0, 0.0, 1.0, 0.0, -0.8660254037844386, 0.5, 0.0, -0.8660254037844386, -0.5, 0.0, 0.0, -1.0, 0.0, 0.8660254037844386, -0.5, 0.0,
7282                 0.8660254037844386, 0.5, 2.0, 0.0, 1.0, 2.0, -0.8660254037844386, 0.5, 2.0, -0.8660254037844386, -0.5, 2.0, 0.0, -1.0, 2.0, 0.8660254037844386, -0.5, 2.0];
7283         conn=[1,2,3,4,5,0,7,8,9,10,11,6]
7284         mesh=MEDCouplingUMesh.New("MyFirstHexagonalPrism",3);
7285         coo=DataArrayDouble.New();
7286         coo.setValues(coords,12,3);
7287         mesh.setCoords(coo);
7288         mesh.allocateCells(1);
7289         mesh.insertNextCell(NORM_HEXGP12,12,conn[0:12])
7290         mesh.finishInsertingCells();
7291         #
7292         mesh.checkCoherency();
7293         vols=mesh.getMeasureField(False);
7294         self.assertEqual(1,vols.getNumberOfTuples());
7295         self.assertEqual(1,vols.getNumberOfComponents());
7296         self.assertAlmostEqual(-5.196152422706632,vols.getIJ(0,0),12);
7297         bary=mesh.getBarycenterAndOwner();
7298         self.assertEqual(1,bary.getNumberOfTuples());
7299         self.assertEqual(3,bary.getNumberOfComponents());
7300         expected1=[0.,0.,1.]
7301         for i in xrange(3):
7302             self.assertAlmostEqual(expected1[i],bary.getIJ(0,i),12);
7303             pass
7304         d1=DataArrayInt.New();
7305         d2=DataArrayInt.New();
7306         d3=DataArrayInt.New();
7307         d4=DataArrayInt.New();
7308         m2=mesh.buildDescendingConnectivity(d1,d2,d3,d4);
7309         self.assertEqual(8,m2.getNumberOfCells());
7310         expected4=[[1,2,3,4,5,0],[7,6,11,10,9,8],[1,7,8,2],[2,8,9,3],[3,9,10,4],[4,10,11,5],[5,11,6,0],[0,6,7,1]];
7311         expected2=[NORM_POLYGON, NORM_POLYGON, NORM_QUAD4, NORM_QUAD4, NORM_QUAD4, NORM_QUAD4, NORM_QUAD4, NORM_QUAD4];
7312         expected3=[6,6,4,4,4,4,4,4]
7313         for i in xrange(8):
7314             self.assertTrue(m2.getTypeOfCell(i)==expected2[i]);
7315             v=m2.getNodeIdsOfCell(i);
7316             self.assertTrue(len(v)==expected3[i]);
7317             self.assertEqual(expected4[i],v);
7318         #
7319         mesh.convertAllToPoly();
7320         self.assertTrue(NORM_POLYHED==mesh.getTypeOfCell(0));
7321         mesh.unPolyze();
7322         self.assertTrue(NORM_HEXGP12==mesh.getTypeOfCell(0));
7323         self.assertEqual(13,mesh.getMeshLength());
7324         #
7325         pass
7326
7327     def testDADCheckIsMonotonic(self):
7328         da=DataArrayDouble.New();
7329         da.setValues([-1.,1.01,2.03,6.],2,2);
7330         self.assertRaises(InterpKernelException,da.isMonotonic,True,1e-12);
7331         da.rearrange(1);
7332         self.assertTrue(da.isMonotonic(True,1e-12));
7333         da.checkMonotonic(True,1e-12);
7334         da.setIJ(2,0,6.1);
7335         self.assertTrue(not da.isMonotonic(True,1e-12));
7336         self.assertRaises(InterpKernelException,da.checkMonotonic,True,1e-12);
7337         da.setIJ(2,0,5.99);
7338         self.assertTrue(da.isMonotonic(True,1e-12));
7339         self.assertTrue(not da.isMonotonic(True,1e-1));
7340         pass
7341
7342     def testCheckCoherencyDeeper1(self):
7343         m=MEDCouplingDataForTest.build3DSourceMesh_1();
7344         m.checkCoherency();
7345         m.checkCoherency1();
7346         m.getNodalConnectivity().setIJ(8,0,-1);
7347         m.checkCoherency();
7348         self.assertRaises(InterpKernelException,m.checkCoherency1);
7349         m.getNodalConnectivity().setIJ(8,0,-6);
7350         m.checkCoherency();
7351         self.assertRaises(InterpKernelException,m.checkCoherency1);
7352         m.getNodalConnectivity().setIJ(8,0,9);#9>=NbOfNodes
7353         m.checkCoherency();
7354         self.assertRaises(InterpKernelException,m.checkCoherency1);
7355         m.getNodalConnectivity().setIJ(8,0,8);#OK
7356         m.checkCoherency();
7357         m.checkCoherency1();
7358         elts=[1,5]
7359         m.convertToPolyTypes(elts);
7360         m.checkCoherency();
7361         m.checkCoherency1();
7362         m.getNodalConnectivity().setIJ(2,0,9);#9>=NbOfNodes
7363         m.checkCoherency();
7364         self.assertRaises(InterpKernelException,m.checkCoherency1);
7365         m.getNodalConnectivity().setIJ(2,0,-3);
7366         m.checkCoherency();
7367         self.assertRaises(InterpKernelException,m.checkCoherency1);
7368         m.getNodalConnectivity().setIJ(2,0,-1);
7369         m.checkCoherency();
7370         self.assertRaises(InterpKernelException,m.checkCoherency1);#Throw because cell#0 is not a polyhedron
7371         m.getNodalConnectivity().setIJ(2,0,4);
7372         m.checkCoherency();
7373         m.checkCoherency1();
7374         m.getNodalConnectivity().setIJ(7,0,-1);
7375         m.checkCoherency();
7376         m.checkCoherency1();#OK because we are in polyhedron connec
7377         m.getNodalConnectivity().setIJ(36,0,14);
7378         m.checkCoherency();
7379         self.assertRaises(InterpKernelException,m.checkCoherency1);#Throw beacause now cell 5 is a TETRA4 (14) so mimatch of number index and static type.
7380         pass
7381
7382     def testUnPolyze2(self):
7383         m=MEDCouplingUMesh.New("jjj",3);
7384         coo=DataArrayDouble.New();
7385         coo.alloc(4,3);
7386         coo.rearrange(1);
7387         coo.iota(0);
7388         coo.rearrange(3);
7389         m.setCoords(coo);
7390         m.allocateCells(2);
7391         m.insertNextCell(NORM_TETRA4,4,[0,1,2,3]);
7392         m.insertNextCell(NORM_TETRA4,4,[0,1,2,3]);
7393         m.finishInsertingCells();
7394         m2=MEDCouplingUMesh.MergeUMeshesOnSameCoords(4*[m]);
7395         m2.convertToPolyTypes([2]);
7396         m2.unPolyze();
7397         self.assertEqual(NORM_TETRA4,m2.getTypeOfCell(2));
7398         self.assertEqual(40,m2.getMeshLength());
7399         temp2=m2.getNodeIdsOfCell(2);
7400         self.assertEqual(temp2,[0,1,2,3]);
7401         m2.checkCoherency1();
7402         m3=m2.deepCpy();
7403         m2.unPolyze();
7404         self.assertTrue(m3.isEqual(m2,1e-12));
7405         pass
7406
7407     def testDACpyFrom1(self):
7408         d=DataArrayDouble.New();
7409         d.alloc(12,1);
7410         d.iota(14.);
7411         d.rearrange(3);
7412         d.setName("Toto");
7413         d.setInfoOnComponent(0,"X [m]");
7414         d.setInfoOnComponent(1,"Y [m]");
7415         d.setInfoOnComponent(2,"Z [m]");
7416         #
7417         d1=DataArrayDouble.New();
7418         self.assertTrue(not d.isEqual(d1,1e-12));
7419         d1.cpyFrom(d);
7420         self.assertTrue(d.isEqual(d1,1e-12));
7421         d1.cpyFrom(d);
7422         self.assertTrue(d.isEqual(d1,1e-12));
7423         d1.rearrange(2);
7424         self.assertTrue(not d.isEqual(d1,1e-12));
7425         d1.cpyFrom(d);
7426         self.assertTrue(d.isEqual(d1,1e-12));
7427         #
7428         d2=d.convertToIntArr();
7429         d4=DataArrayInt.New();
7430         self.assertTrue(not d2.isEqual(d4));
7431         d4.cpyFrom(d2);
7432         self.assertTrue(d2.isEqual(d4));
7433         d4.cpyFrom(d2);
7434         self.assertTrue(d2.isEqual(d4));
7435         d4.rearrange(2);
7436         self.assertTrue(not d2.isEqual(d4));
7437         d4.cpyFrom(d2);
7438         self.assertTrue(d2.isEqual(d4));
7439         pass
7440
7441     def testDAITransformWithIndArr1(self):
7442         tab1=[17,18,22,19]
7443         tab2=[0,1,1,3,3,0,1,3,2,2,3,0]
7444         expected=[17,18,18,19,19,17,18,19,22,22,19,17]
7445         d=DataArrayInt.New();
7446         d.setValues(tab1,4,1);
7447         d1=DataArrayInt.New();
7448         d1.setValues(tab2,12,1);
7449         d2=d1[:]
7450         #
7451         d1.transformWithIndArr(d);
7452         self.assertEqual(12,d1.getNumberOfTuples());
7453         self.assertEqual(1,d1.getNumberOfComponents());
7454         for i in xrange(12):
7455             self.assertEqual(expected[i],d1.getIJ(i,0));
7456             pass
7457         #
7458         d1=d2
7459         d1.transformWithIndArr(tab1)
7460         self.assertEqual(12,d1.getNumberOfTuples());
7461         self.assertEqual(1,d1.getNumberOfComponents());
7462         for i in xrange(12):
7463             self.assertEqual(expected[i],d1.getIJ(i,0));
7464             pass
7465         pass
7466
7467     def testDAIBuildPermArrPerLevel1(self):
7468         arr=[2,0,1,1,0,1,2,0,1,1,0,0]
7469         expected1=[10,0,5,6,1,7,11,2,8,9,3,4]
7470         da=DataArrayInt.New();
7471         da.setValues(arr,12,1);
7472         da2=da.buildPermArrPerLevel();
7473         self.assertEqual(12,da2.getNumberOfTuples());
7474         self.assertEqual(1,da2.getNumberOfComponents());
7475         for i in xrange(12):
7476             self.assertEqual(expected1[i],da2.getIJ(i,0));
7477             pass
7478         pass
7479
7480     def testDAIOperations1(self):
7481         arr1=[-1,-2,4,7,3,2,6,6,4,3,0,1]
7482         da=DataArrayInt.New();
7483         da.setValues(arr1,4,3);
7484         da1=DataArrayInt.New();
7485         da1.alloc(12,1);
7486         da1.iota(2);
7487         self.assertRaises(InterpKernelException,DataArrayInt.Add,da,da1);#not same number of tuples/Components
7488         da1.rearrange(3);
7489         da2=DataArrayInt.Add(da,da1);
7490         self.assertEqual(4,da2.getNumberOfTuples());
7491         self.assertEqual(3,da2.getNumberOfComponents());
7492         expected1=[1,1,8,12,9,9,14,15,14,14,12,14]
7493         for i in xrange(12):
7494             self.assertEqual(expected1[i],da2.getIJ(0,i));
7495             pass
7496         da1.substractEqual(da);
7497         expected2=[3,5,0,-2,3,5,2,3,6,8,12,12]
7498         for i in xrange(12):
7499             self.assertEqual(expected2[i],da1.getIJ(0,i));
7500             pass
7501         da1.rearrange(1); da1.iota(2); da1.rearrange(3);
7502         da1.addEqual(da);
7503         for i in xrange(12):
7504             self.assertEqual(expected1[i],da1.getIJ(0,i));
7505             pass
7506         da1.rearrange(1); da1.iota(2); da1.rearrange(3);
7507         da2=DataArrayInt.Multiply(da,da1);
7508         self.assertEqual(4,da2.getNumberOfTuples());
7509         self.assertEqual(3,da2.getNumberOfComponents());
7510         expected3=[-2,-6,16,35,18,14,48,54,40,33,0,13]
7511         for i in xrange(12):
7512             self.assertEqual(expected3[i],da2.getIJ(0,i));
7513             pass
7514         da.divideEqual(da1);
7515         self.assertEqual(4,da.getNumberOfTuples());
7516         self.assertEqual(3,da.getNumberOfComponents());
7517         expected4=[0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0]
7518         for i in xrange(12):
7519             self.assertEqual(expected4[i],da.getIJ(0,i));
7520             pass
7521         da.setValues(arr1,4,3);
7522         da1.multiplyEqual(da);
7523         self.assertEqual(4,da1.getNumberOfTuples());
7524         self.assertEqual(3,da1.getNumberOfComponents());
7525         for i in xrange(12):
7526             self.assertEqual(expected3[i],da1.getIJ(0,i));
7527             pass
7528         da1.rearrange(1); da1.iota(2); da1.rearrange(3);
7529         da2=DataArrayInt.Divide(da,da1);
7530         self.assertEqual(4,da2.getNumberOfTuples());
7531         self.assertEqual(3,da2.getNumberOfComponents());
7532         for i in xrange(12):
7533             self.assertEqual(expected4[i],da2.getIJ(0,i));
7534             pass
7535         da1.applyInv(321);
7536         self.assertEqual(4,da1.getNumberOfTuples());
7537         self.assertEqual(3,da1.getNumberOfComponents());
7538         expected5=[160,107,80,64,53,45,40,35,32,29,26,24]
7539         for i in xrange(12):
7540             self.assertEqual(expected5[i],da1.getIJ(0,i));
7541             pass
7542         da1.applyDivideBy(2);
7543         self.assertEqual(4,da1.getNumberOfTuples());
7544         self.assertEqual(3,da1.getNumberOfComponents());
7545         expected6=[80,53,40,32,26,22,20,17,16,14,13,12]
7546         for i in xrange(12):
7547             self.assertEqual(expected6[i],da1.getIJ(0,i));
7548             pass
7549         expected7=[3,4,5,4,5,1,6,3,2,0,6,5]
7550         da1.applyModulus(7);
7551         for i in xrange(12):
7552             self.assertEqual(expected7[i],da1.getIJ(0,i));
7553             pass
7554         da1.applyLin(1,1);
7555         expected8=[3,3,3,3,3,1,3,3,0,0,3,3]
7556         da1.applyRModulus(3);
7557         for i in xrange(12):
7558             self.assertEqual(expected8[i],da1.getIJ(0,i));
7559             pass
7560         pass
7561
7562     def testEmulateMEDMEMBDC1(self):
7563         m,m1=MEDCouplingDataForTest.buildPointe_1();
7564         m2,da1,da2,da3,da4,da5,da0=m.emulateMEDMEMBDC(m1)
7565         expected0=[0,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,31,36,37,32,33,34,35,38,39,40,41,42,43,44,45,46]
7566         expected1=[1,32,29,23,41,36]
7567         self.assertEqual(47,da0.getNumberOfTuples());
7568         self.assertEqual(1,da0.getNumberOfComponents());
7569         for i in xrange(47):
7570             self.assertEqual(expected0[i],da0.getIJ(0,i));
7571             pass
7572         self.assertEqual(6,da5.getNumberOfTuples());
7573         self.assertEqual(1,da5.getNumberOfComponents());
7574         for i in xrange(6):
7575             self.assertEqual(expected1[i],da5.getIJ(0,i));
7576             pass
7577         expected2=[0,1,2,3,4,0,5,6,7,4,8,9,1,7,10,11,12,13,14,5,15,16,17,8,18,19,20,10,21,22,23,2,13,24,25,21,16,26,27,12,19,28,29,15,22,30,31,18,36,26,28,30,24,37,32,33,34,35,38,36,39,40,41,42,37,38,43,44,45,46]
7578         self.assertEqual(70,da1.getNumberOfTuples());
7579         self.assertEqual(1,da1.getNumberOfComponents());
7580         for i in xrange(70):
7581             self.assertEqual(expected2[i],da1.getIJ(0,i));
7582             pass
7583         expected3=[0,4,8,12,16,20,24,28,32,36,40,44,48,53,58,64,70]
7584         self.assertEqual(17,da2.getNumberOfTuples());
7585         self.assertEqual(1,da2.getNumberOfComponents());
7586         for i in xrange(17):
7587             self.assertEqual(expected3[i],da2.getIJ(0,i));
7588             pass
7589         expected4=[0,2,4,6,7,9,11,12,14,16,17,19,20,22,24,25,27,29,30,32,34,35,37,39,40,42,43,45,46,48,49,51,52,53,54,55,56,58,60,62,63,64,65,66,67,68,69,70]
7590         #expected4=[0,2,4,6,7,9,11,12,14,16,17,19,20,22,24,25,27,29,30,32,34,35,37,39,40,42,43,45,46,48,49,51,52,54,56,57,58,59,60,62,63,64,65,66,67,68,69,70];
7591         self.assertEqual(48,da4.getNumberOfTuples());
7592         self.assertEqual(1,da4.getNumberOfComponents());
7593         for i in xrange(48):
7594             self.assertEqual(expected4[i],da4.getIJ(0,i));
7595             pass
7596         expected5=[0,1,0,3,0,7,0,1,2,1,4,1,2,3,2,5,2,3,6,3,4,9,4,8,4,5,10,5,9,5,6,11,6,10,6,7,8,7,11,7,8,12,8,9,12,9,10,12,10,11,12,11,13,13,13,13,12,14,13,15,14,15,14,14,14,14,15,15,15,15]
7597         self.assertEqual(70,da3.getNumberOfTuples());
7598         self.assertEqual(1,da3.getNumberOfComponents());
7599         for i in xrange(70):
7600             self.assertEqual(expected5[i],da3.getIJ(0,i));
7601             pass
7602         pass
7603
7604     def testGetLevArrPerCellTypes1(self):
7605         m,m1=MEDCouplingDataForTest.buildPointe_1();
7606         m1,d0,d1,d2,d3=m.buildDescendingConnectivity();
7607         order=[NORM_TRI3,NORM_QUAD4];
7608         da0,da1=m1.getLevArrPerCellTypes(order);
7609         expected0=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,1,1,1,1,1,1,1,1,1]
7610         expected1=[0,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,31,36,37,32,33,34,35,38,39,40,41,42,43,44,45,46]
7611         self.assertEqual(47,da0.getNumberOfTuples());
7612         self.assertEqual(1,da0.getNumberOfComponents());
7613         for i in xrange(47):
7614             self.assertEqual(expected0[i],da0.getIJ(0,i));
7615             pass
7616         self.assertEqual(2,da1.getNumberOfTuples());
7617         self.assertEqual(1,da1.getNumberOfComponents());
7618         self.assertEqual(36,da1.getIJ(0,0));#36 TRI3
7619         self.assertEqual(11,da1.getIJ(1,0));#11 QUAD4
7620         #
7621         da2=da0.buildPermArrPerLevel();
7622         #
7623         self.assertEqual(47,da2.getNumberOfTuples());
7624         self.assertEqual(1,da2.getNumberOfComponents());
7625         for i in xrange(47):
7626             self.assertEqual(expected1[i],da2.getIJ(0,i));
7627             pass
7628         pass
7629
7630     def testSortCellsInMEDFileFrmt1(self):
7631         m,m1=MEDCouplingDataForTest.buildPointe_1();
7632         m2=m.deepCpy()
7633         da=DataArrayInt.New()
7634         da.setValues([0,1,2,14,3,12,4,5,15,6,7,8,9,10,11,13],16,1)
7635         daa=da.invertArrayN2O2O2N(16)
7636         m.renumberCells(daa,False)
7637         da2=m.sortCellsInMEDFileFrmt()
7638         self.assertEqual(da2.getValues(),[0,1,2,14,3,12,4,5,15,6,7,8,9,10,11,13])
7639         self.assertTrue(m.isEqual(m2,1e-12))
7640         self.assertTrue(da.isEqual(da2))
7641         pass
7642
7643     def testBuildPartAndReduceNodes1(self):
7644         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7645         arr=[1,0]
7646         m2,da=m.buildPartAndReduceNodes(arr);
7647         self.assertEqual(5,m2.getNumberOfNodes());
7648         self.assertEqual(2,m2.getNumberOfCells());
7649         f=m2.getMeasureField(True);
7650         self.assertAlmostEqual(0.125,f.getArray().getIJ(0,0),12);
7651         self.assertAlmostEqual(0.25,f.getArray().getIJ(1,0),12);
7652         #
7653         arr2=DataArrayInt.New()
7654         arr2.setValues(arr,2,1)
7655         m2,da=m.buildPartAndReduceNodes(arr2);
7656         self.assertEqual(5,m2.getNumberOfNodes());
7657         self.assertEqual(2,m2.getNumberOfCells());
7658         f=m2.getMeasureField(True);
7659         self.assertAlmostEqual(0.125,f.getArray().getIJ(0,0),12);
7660         self.assertAlmostEqual(0.25,f.getArray().getIJ(1,0),12);
7661         pass
7662
7663     def testDAITransformWithIndArrR1(self):
7664         tab1=[2,4,5,3,6,7]
7665         tab2=[-1,-1,0,1,2,3,4,5,-1,-1,-1,-1]
7666         expected=[0,3,1,2,4,5]
7667         d=DataArrayInt.New();
7668         d.setValues(tab1,6,1);
7669         d1=DataArrayInt.New();
7670         d1.setValues(tab2,12,1);
7671         d2=d1[:]
7672         #
7673         d3=d.transformWithIndArrR(d1);
7674         self.assertEqual(6,d3.getNumberOfTuples());
7675         self.assertEqual(1,d3.getNumberOfComponents());
7676         for i in xrange(6):
7677             self.assertEqual(expected[i],d3.getIJ(i,0));
7678             pass
7679         #
7680         d1=d2
7681         d3=d.transformWithIndArrR(tab2)
7682         self.assertEqual(6,d3.getNumberOfTuples());
7683         self.assertEqual(1,d3.getNumberOfComponents());
7684         for i in xrange(6):
7685             self.assertEqual(expected[i],d3.getIJ(i,0));
7686             pass
7687         pass
7688
7689     def testDAISplitByValueRange1(self):
7690         val1=[6,5,0,3,2,7,8,1,4]
7691         val2=[0,4,9]
7692         d=DataArrayInt.New();
7693         d.setValues(val1,9,1);
7694         e,f,g=d.splitByValueRange(val2);
7695         self.assertEqual(9,e.getNumberOfTuples());
7696         self.assertEqual(1,e.getNumberOfComponents());
7697         self.assertEqual(9,f.getNumberOfTuples());
7698         self.assertEqual(1,f.getNumberOfComponents());
7699         self.assertEqual(2,g.getNumberOfTuples());
7700         self.assertEqual(1,g.getNumberOfComponents());
7701         #
7702         expected1=[1,1,0,0,0,1,1,0,1]
7703         expected2=[2,1,0,3,2,3,4,1,0]
7704         for i in xrange(9):
7705             self.assertEqual(expected1[i],e.getIJ(i,0));
7706             self.assertEqual(expected2[i],f.getIJ(i,0));
7707             pass
7708         self.assertEqual(0,g.getIJ(0,0));
7709         self.assertEqual(1,g.getIJ(1,0));
7710         #
7711         d.setIJ(6,0,9);
7712         self.assertRaises(InterpKernelException,d.splitByValueRange,val2);
7713         pass
7714
7715     def testUMeshSplitProfilePerType1(self):
7716         val0=[2,0,1,3,4]
7717         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7718         m.renumberCells(val0,False);
7719         #
7720         val1=[0,2,3]
7721         d=DataArrayInt.New();
7722         d.setValues(val1,3,1);
7723         d.setName("sup")
7724         code,idsInPflPerType,pfls=m.splitProfilePerType(d);
7725         self.assertEqual(6,len(code));
7726         self.assertEqual(2,len(idsInPflPerType));
7727         expected1=[3,1,0, 4,2,1]
7728         for i in xrange(6):
7729             self.assertEqual(expected1[i],code[i]);
7730             pass
7731         self.assertEqual(2,len(idsInPflPerType));
7732         self.assertEqual(1,idsInPflPerType[0].getNumberOfTuples());
7733         self.assertEqual(0,idsInPflPerType[0].getIJ(0,0));
7734         self.assertEqual(2,idsInPflPerType[1].getNumberOfTuples());
7735         self.assertEqual(1,idsInPflPerType[1].getIJ(0,0));
7736         self.assertEqual(2,idsInPflPerType[1].getIJ(1,0));
7737         #
7738         self.assertEqual(2,len(pfls));
7739         self.assertEqual("sup",pfls[0].getName())
7740         self.assertEqual(1,pfls[0].getNumberOfTuples());
7741         self.assertEqual(0,pfls[0].getIJ(0,0));
7742         self.assertEqual("sup",pfls[1].getName())
7743         self.assertEqual(2,pfls[1].getNumberOfTuples());
7744         self.assertEqual(0,pfls[1].getIJ(0,0));
7745         self.assertEqual(1,pfls[1].getIJ(1,0));
7746         #
7747         val2=[0,2,3,4]
7748         d=DataArrayInt.New();
7749         d.setValues(val2,4,1);
7750         code,idsInPflPerType,pfls=m.splitProfilePerType(d);
7751         self.assertEqual(6,len(code));
7752         self.assertEqual(2,len(idsInPflPerType));
7753         expected2=[3,1,0, 4,3,-1]
7754         for i in xrange(6):
7755             self.assertEqual(expected2[i],code[i]);
7756             pass
7757         self.assertEqual(2,len(idsInPflPerType));
7758         self.assertEqual(1,idsInPflPerType[0].getNumberOfTuples());
7759         self.assertEqual(0,idsInPflPerType[0].getIJ(0,0));
7760         self.assertEqual(3,idsInPflPerType[1].getNumberOfTuples());
7761         self.assertEqual(1,idsInPflPerType[1].getIJ(0,0));
7762         self.assertEqual(2,idsInPflPerType[1].getIJ(1,0));
7763         self.assertEqual(3,idsInPflPerType[1].getIJ(2,0));
7764         #
7765         self.assertEqual(1,len(pfls));
7766         self.assertEqual(1,pfls[0].getNumberOfTuples());
7767         self.assertEqual(0,pfls[0].getIJ(0,0));
7768         #
7769         val3=[1,0,2]
7770         d=DataArrayInt.New();
7771         d.setValues(val3,3,1);
7772         code,idsInPflPerType,pfls=m.splitProfilePerType(d);
7773         self.assertEqual(6,len(code));
7774         self.assertEqual(2,len(idsInPflPerType));
7775         expected3=[3,2,0, 4,1,1]
7776         for i in xrange(6):
7777             self.assertEqual(expected3[i],code[i]);
7778             pass
7779         self.assertEqual(2,len(idsInPflPerType));
7780         self.assertEqual(2,idsInPflPerType[0].getNumberOfTuples());
7781         self.assertEqual(0,idsInPflPerType[0].getIJ(0,0));
7782         self.assertEqual(1,idsInPflPerType[0].getIJ(1,0));
7783         self.assertEqual(1,idsInPflPerType[1].getNumberOfTuples());
7784         self.assertEqual(2,idsInPflPerType[1].getIJ(0,0));
7785         #
7786         self.assertEqual(2,len(pfls));
7787         self.assertEqual(2,pfls[0].getNumberOfTuples());
7788         self.assertEqual(1,pfls[0].getIJ(0,0));
7789         self.assertEqual(0,pfls[0].getIJ(1,0));
7790         self.assertEqual(0,pfls[1].getIJ(0,0));
7791         #
7792         val4=[3,4]
7793         d=DataArrayInt.New();
7794         d.setValues(val4,2,1);
7795         code,idsInPflPerType,pfls=m.splitProfilePerType(d);
7796         self.assertEqual(3,len(code));
7797         self.assertEqual(1,len(idsInPflPerType));
7798         expected4=[4,2,0]
7799         for i in xrange(3):
7800             self.assertEqual(expected4[i],code[i]);
7801             pass
7802         self.assertEqual(1,len(idsInPflPerType));
7803         self.assertEqual(2,idsInPflPerType[0].getNumberOfTuples());
7804         self.assertEqual(0,idsInPflPerType[0].getIJ(0,0));
7805         self.assertEqual(1,idsInPflPerType[0].getIJ(1,0));
7806         #
7807         self.assertEqual(1,len(pfls));
7808         self.assertEqual(2,pfls[0].getNumberOfTuples());
7809         self.assertEqual(1,pfls[0].getIJ(0,0));
7810         self.assertEqual(2,pfls[0].getIJ(1,0));
7811         pass
7812
7813     def testDAIBuildExplicitArrByRanges1(self):
7814         d=DataArrayInt.New();
7815         vals1=[0,2,3]
7816         d.setValues(vals1,3,1);
7817         e=DataArrayInt.New();
7818         vals2=[0,3,6,10,14,20]
7819         e.setValues(vals2,6,1);
7820         #
7821         f=d.buildExplicitArrByRanges(e);
7822         self.assertEqual(11,f.getNumberOfTuples());
7823         self.assertEqual(1,f.getNumberOfComponents());
7824         expected1=[0,1,2,6,7,8,9,10,11,12,13]
7825         for i in xrange(11):
7826             self.assertEqual(expected1[i],f.getIJ(i,0));
7827             pass
7828         pass
7829
7830     def testDAIComputeOffsets2(self):
7831         d=DataArrayInt.New();
7832         vals1=[3,5,1,2,0,8]
7833         expected1=[0,3,8,9,11,11,19]
7834         d.setValues(vals1,6,1);
7835         d.computeOffsets2();
7836         self.assertEqual(7,d.getNumberOfTuples());
7837         self.assertEqual(1,d.getNumberOfComponents());
7838         for i in xrange(7):
7839             self.assertEqual(expected1[i],d.getIJ(0,i));
7840             pass
7841         pass
7842
7843     def testMergeField3(self):
7844         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7845         m.getCoords().setInfoOnComponent(0,"x [m]");
7846         m.getCoords().setInfoOnComponent(1,"z [km]");
7847         m.setName("m");
7848         m.setDescription("desc");
7849         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
7850         f1.setName("f1");
7851         f1.setMesh(m);
7852         arr=DataArrayDouble.New();
7853         arr.alloc(5,2);
7854         arr.setInfoOnComponent(0,"X [m]");
7855         arr.setInfoOnComponent(1,"YY [mm]");
7856         arr.fillWithValue(2.);
7857         f1.setArray(arr);
7858         #
7859         f2=MEDCouplingFieldDouble.MergeFields([f1]);
7860         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
7861         #
7862         pass
7863     
7864     def testGetDistributionOfTypes1(self):
7865         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7866         tab1=[2,0,1,3,4]
7867         self.assertRaises(InterpKernelException,m.getDistributionOfTypes);
7868         m.renumberCells(tab1,False);
7869         code=m.getDistributionOfTypes();
7870         self.assertEqual(2,len(code));
7871         self.assertEqual(3,code[0][0]);
7872         self.assertEqual(2,code[0][1]);
7873         self.assertEqual(0,code[0][2]);
7874         self.assertEqual(4,code[1][0]);
7875         self.assertEqual(3,code[1][1]);
7876         self.assertEqual(0,code[1][2]);
7877         pass
7878
7879     def testNorm2_1(self):
7880         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7881         f=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
7882         f.setMesh(m);
7883         #
7884         d=DataArrayDouble.New();
7885         tab=[1.2,1.3,2.2,2.3,3.2,3.3,4.2,4.3,5.2,5.3]
7886         d.setValues(tab,5,2);
7887         f.setArray(d);
7888         f.checkCoherency();
7889         #
7890         self.assertAlmostEqual(11.209371079592289,f.norm2(),14);
7891         #
7892         pass
7893
7894     def testNormMax1(self):
7895         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7896         f=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
7897         f.setMesh(m);
7898         #
7899         d=DataArrayDouble.New();
7900         tab=[2.3,-1.2,6.3,-7.8,2.9,7.7,2.1,0.,3.6,-7.6]
7901         d.setValues(tab,5,2);
7902         f.setArray(d);
7903         f.checkCoherency();
7904         #
7905         self.assertAlmostEqual(7.8,f.normMax(),14);
7906         #
7907         pass
7908
7909     def testFindAndCorrectBadOriented3DExtrudedCells1(self):
7910         coords=[0.0011180339887498999, -0.0011755705045849499, 0.0, -0.0012331070204200001, -0.0011755705045849499, 0.0, -0.00067557050458494599, -0.00145964954842536, 0.0, -0.00050000000000000001, -0.00086602540378443902, 0.0, 0.00140211303259031, -0.00061803398874989504, 0.0, 0.00086602540378443902, -0.00050000000000000001, 0.0, 0.001, 0.0, 0.0, 0.00034561537182258202, 0.000269164072574575, 0.0, 0.0, 0.001, 0.0, -0.00050000000000000001, 0.00086602540378443902, 0.0, -0.000269164072574575, 0.00034561537182258202, 0.0, -0.001, 0.0, 0.0, -0.00086602540378443902, -0.00050000000000000001, 0.0, -0.00034561537182258202, -0.000269164072574575, 0.0, 0.0, -0.001, 0.0, 0.00050000000000000001, -0.00086602540378443902, 0.0, 0.000269164072574575, -0.00034561537182258202, 0.0, 0.0015, -6.01853107621011e-36, 0.0, 0.00056049747291484397, -0.00145964954842536, 0.0, 0.0011180339887498999, -0.0011755705045849499, 0.00050000000000000001, -0.0012331070204200001, -0.0011755705045849499, 0.00050000000000000001, -0.00067557050458494599, -0.00145964954842536, 0.00050000000000000001, -0.00050000000000000001, -0.00086602540378443902, 0.00050000000000000001, 0.00140211303259031, -0.00061803398874989504, 0.00050000000000000001, 0.00086602540378443902, -0.00050000000000000001, 0.00050000000000000001, 0.001, 0.0, 0.00050000000000000001, 0.00034561537182258202, 0.000269164072574575, 0.00050000000000000001, 0.0, 0.001, 0.00050000000000000001, -0.00050000000000000001, 0.00086602540378443902, 0.00050000000000000001, -0.000269164072574575, 0.00034561537182258202, 0.00050000000000000001, -0.001, 0.0, 0.00050000000000000001, -0.00086602540378443902, -0.00050000000000000001, 0.00050000000000000001, -0.00034561537182258202, -0.000269164072574575, 0.00050000000000000001, 0.0, -0.001, 0.00050000000000000001, 0.00050000000000000001, -0.00086602540378443902, 0.00050000000000000001, 0.000269164072574575, -0.00034561537182258202, 0.00050000000000000001, 0.0015, -6.01853107621011e-36, 0.00050000000000000001, 0.00056049747291484397, -0.00145964954842536, 0.00050000000000000001];
7911         conn=[2, 1, 3, 21, 20, 22, 4, 0, 5, 23, 19, 24, 8, 9, 10, 27, 28, 29, 11, 12, 13, 30, 31, 32, 0, 18, 15, 5, 19, 37, 34, 24, 6, 17, 4, 5, 25, 36, 23, 24, 3, 14, 16, 13, 22, 33, 35, 32, 13, 16, 7, 10, 32, 35, 26, 29]
7912         connExp=[16, 2, 1, 3, 21, 20, 22, 16, 4, 0, 5, 23, 19, 24, 16, 8, 10, 9, 27, 29, 28, 16, 11, 13, 12, 30, 32, 31, 18, 0, 18, 15, 5, 19, 37, 34, 24,18, 6, 17, 4, 5, 25, 36, 23, 24, 18, 3, 13, 16, 14, 22, 32, 35, 33, 18, 13, 10, 7, 16, 32, 29, 26, 35]
7913         invalidCells=[2,3,6,7]
7914         m=MEDCouplingUMesh.New("Example",3);
7915         coo=DataArrayDouble.New();
7916         coo.setValues(coords,38,3);
7917         m.setCoords(coo);
7918         m.allocateCells(8);
7919         m.insertNextCell(NORM_PENTA6,6,conn[0:6])
7920         m.insertNextCell(NORM_PENTA6,6,conn[6:12])
7921         m.insertNextCell(NORM_PENTA6,6,conn[12:18])
7922         m.insertNextCell(NORM_PENTA6,6,conn[18:24])
7923         m.insertNextCell(NORM_HEXA8,8,conn[24:32])
7924         m.insertNextCell(NORM_HEXA8,8,conn[32:40])
7925         m.insertNextCell(NORM_HEXA8,8,conn[40:48])
7926         m.insertNextCell(NORM_HEXA8,8,conn[48:56])
7927         m.finishInsertingCells();
7928         #
7929         v=m.findAndCorrectBadOriented3DExtrudedCells();
7930         self.assertEqual(4,len(v));
7931         self.assertEqual(v.getValues(),invalidCells);
7932         self.assertEqual(connExp,m.getNodalConnectivity().getValues());
7933         self.assertTrue(m.findAndCorrectBadOriented3DExtrudedCells().empty())
7934         #
7935         pass
7936
7937     def testConvertExtrudedPolyhedra1(self):
7938         conn=[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,31,32,33,34,35,36,37,38, 39,40,41,42,43,44,45,46, 47,48,49,50,51,52,53,54,55,56,57,58, 59,60,61,62,63,64,65,66,67,68,69,70,71,72]
7939         m=MEDCouplingUMesh.New("Example",3);
7940         coo=DataArrayDouble.New();
7941         coo.alloc(73,3);
7942         coo.rearrange(1); coo.iota(0); coo.rearrange(3);
7943         m.setCoords(coo);
7944         m.allocateCells(9);
7945         m.insertNextCell(NORM_TETRA4,4,conn[0:4])
7946         m.insertNextCell(NORM_HEXA8,8,conn[4:12])
7947         m.insertNextCell(NORM_TETRA4,4,conn[12:16])
7948         m.insertNextCell(NORM_POLYHED,6,conn[16:22])
7949         m.insertNextCell(NORM_PENTA6,6,conn[22:28])
7950         m.insertNextCell(NORM_POLYHED,10,conn[28:38])
7951         m.insertNextCell(NORM_HEXA8,8,conn[38:46])
7952         m.insertNextCell(NORM_HEXGP12,12,conn[46:58])
7953         m.insertNextCell(NORM_POLYHED,14,conn[58:72])
7954         m.finishInsertingCells();
7955         #
7956         m.convertExtrudedPolyhedra();
7957         da=m.getNodalConnectivity();
7958         dai=m.getNodalConnectivityIndex();
7959         self.assertEqual(10,dai.getNbOfElems());
7960         self.assertEqual(159,da.getNbOfElems());
7961         #
7962         expected1=[14, 1, 2, 3, 4,
7963                    18, 5, 6, 7, 8, 9, 10, 11, 12,
7964                    14, 13, 14, 15, 16,
7965                    31, 17, 18, 19, -1, 20, 22, 21, -1, 17, 18, 21, 20, -1, 18, 19, 22, 21, -1, 19, 17, 20, 22,
7966                    16, 23, 24, 25, 26, 27, 28,
7967                    31, 29, 30, 31, 32, 33, -1, 34, 38, 37, 36, 35, -1, 29, 30, 35, 34, -1, 30, 31, 36, 35, -1, 31, 32, 37, 36, -1, 32, 33, 38, 37, -1, 33, 29, 34, 38,
7968                    18, 39, 40, 41, 42, 43, 44, 45, 46,
7969                    22, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
7970                    31, 59, 60, 61, 62, 63, 64, 65, -1, 66, 72, 71, 70, 69, 68, 67, -1, 59, 60, 67, 66, -1, 60, 61, 68, 67, -1, 61, 62, 69, 68, -1, 62, 63, 70, 69, -1, 63, 64, 71, 70, -1, 64, 65, 72, 71, -1, 65, 59, 66, 72];
7971         expected2=[0,5,14,19,42,49,86,95,108,159]
7972         self.assertEqual(expected1,da.getValues());
7973         self.assertEqual(expected2,dai.getValues());
7974         m.checkCoherency2()
7975         pass
7976
7977     def testNonRegressionCopyTinyStrings(self):
7978         m=MEDCouplingDataForTest.build2DTargetMesh_1()
7979         f1=m.getMeasureField(True)
7980         f1.getArray().setInfoOnComponent(0,"P [N/m^2]")
7981         bary=m.getBarycenterAndOwner()
7982         f2=f1.buildNewTimeReprFromThis(NO_TIME,False)
7983         f2.setArray(bary)
7984         self.assertRaises(InterpKernelException,f1.copyTinyAttrFrom,f2)
7985         pass
7986
7987     def testDaDSetPartOfValuesAdv1(self):
7988         tab1=[3.,4.,5., 13.,14.,15., 23.,24.,25., 33.,34.,35., 43.,44.,45., 53.,54.,55.]
7989         tab2=[6.,7.,8., 16.,17.,18., 26.,27.,28.]
7990         tab3=[4,1, 2,2, 3,0]
7991         a=DataArrayDouble.New();
7992         a.setValues(tab1,6,3);
7993         b=DataArrayDouble.New();
7994         b.setValues(tab2,3,3);
7995         c=DataArrayInt.New();
7996         c.setValues(tab3,3,2);
7997         #
7998         a.setPartOfValuesAdv(b,c);
7999         expected1=[3.,4.,5., 13.,14.,15., 26.,27.,28., 6.,7.,8., 16.,17.,18., 53.,54.,55.]
8000         self.assertEqual(expected1,a.getValues());
8001         pass
8002
8003     def testUMeshBuildSetInstanceFromThis1(self):
8004         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
8005         m2=m.buildSetInstanceFromThis(3);
8006         self.assertTrue(m.isEqual(m2,1e-12));
8007         #
8008         m=MEDCouplingUMesh.New("toto",2);
8009         m2=m.buildSetInstanceFromThis(3);
8010         self.assertEqual(0,m2.getNumberOfNodes());
8011         self.assertEqual(0,m2.getNumberOfCells());
8012         pass
8013
8014     def testUMeshMergeMeshesCVW1(self):
8015         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
8016         m2=MEDCouplingUMesh.New("toto",2);
8017         m3=MEDCouplingUMesh.MergeUMeshes([m,m2]);
8018         m3.setName(m.getName());
8019         self.assertTrue(m.isEqual(m3,1e-12));
8020         pass
8021     
8022     def testChangeUnderlyingMeshWithCMesh1(self):
8023         mesh=MEDCouplingCMesh.New();
8024         coordsX=DataArrayDouble.New();
8025         arrX=[ -1., 1., 2., 4. ]
8026         coordsX.setValues(arrX,4,1);
8027         coordsY=DataArrayDouble.New();
8028         arrY=[ -2., 2., 4., 8. ]
8029         coordsY.setValues(arrY,4,1);
8030         coordsZ=DataArrayDouble.New();
8031         arrZ=[ -3., 3., 6., 12. ]
8032         coordsZ.setValues(arrZ,4,1);
8033         mesh.setCoords(coordsX,coordsY,coordsZ);
8034         f=mesh.getMeasureField(True)
8035         mesh2=mesh.deepCpy()
8036         for myId in [0,1,2,10,11,12,20,21,22]:
8037             f=mesh.getMeasureField(True)
8038             f.changeUnderlyingMesh(mesh2,myId,1e-12);
8039             pass
8040         mesh2.setName("uuuu")
8041         for myId in [1,2,10,11,12,20,21,22]:
8042             f=mesh.getMeasureField(True)
8043             f.changeUnderlyingMesh(mesh2,myId,1e-12);
8044             pass
8045         pass
8046
8047     def testDADFindCommonTuples1(self):
8048         da=DataArrayDouble.New();
8049         # nbOftuples=1
8050         array1=[2.3,1.2,1.3,2.3,2.301,0.8]
8051         da.setValues(array1,6,1)
8052         c,cI=da.findCommonTuples(1e-2);
8053         expected1=[0,3,4]
8054         expected2=[0,3]
8055         self.assertEqual(3,c.getNbOfElems());
8056         self.assertEqual(2,cI.getNbOfElems());
8057         self.assertEqual(expected1,c.getValues())
8058         self.assertEqual(expected2,cI.getValues())
8059         c,cI=da.findCommonTuples(2e-1)
8060         expected3=[0,3,4,1,2]
8061         expected4=[0,3,5]
8062         self.assertEqual(5,c.getNbOfElems());
8063         self.assertEqual(3,cI.getNbOfElems());
8064         self.assertEqual(expected3,c.getValues())
8065         self.assertEqual(expected4,cI.getValues())
8066         # nbOftuples=2
8067         array2=[2.3,2.3,1.2,1.2,1.3,1.3,2.3,2.3,2.301,2.301,0.8,0.8]
8068         da.setValues(array2,6,2)
8069         c,cI=da.findCommonTuples(1e-2);
8070         self.assertEqual(3,c.getNbOfElems());
8071         self.assertEqual(2,cI.getNbOfElems());
8072         self.assertEqual(expected1,c.getValues())
8073         self.assertEqual(expected2,cI.getValues())
8074         c,cI=da.findCommonTuples(2e-1)
8075         self.assertEqual(5,c.getNbOfElems());
8076         self.assertEqual(3,cI.getNbOfElems());
8077         self.assertEqual(expected3,c.getValues())
8078         self.assertEqual(expected4,cI.getValues())
8079         # nbOftuples=3
8080         array3=[2.3,2.3,2.3,1.2,1.2,1.2,1.3,1.3,1.3,2.3,2.3,2.3,2.301,2.301,2.301,0.8,0.8,0.8]
8081         da.setValues(array3,6,3)
8082         c,cI=da.findCommonTuples(1e-2);
8083         self.assertEqual(3,c.getNbOfElems());
8084         self.assertEqual(2,cI.getNbOfElems());
8085         self.assertEqual(expected1,c.getValues())
8086         self.assertEqual(expected2,cI.getValues())
8087         c,cI=da.findCommonTuples(2e-1)
8088         self.assertEqual(5,c.getNbOfElems());
8089         self.assertEqual(3,cI.getNbOfElems());
8090         self.assertEqual(expected3,c.getValues())
8091         self.assertEqual(expected4,cI.getValues())
8092         # nbOftuples=1, no common groups
8093         array11=[2.3,1.2,1.3,2.4,2.5,0.8]
8094         da.setValues(array11,6,1)
8095         c,cI=da.findCommonTuples(1e-2);
8096         self.assertEqual(0,c.getNbOfElems());
8097         self.assertEqual(1,cI.getNbOfElems());
8098         self.assertEqual([0],cI.getValues())
8099         
8100         array12=[0.]*(6*4)
8101         da.setValues(array12,6,4) #bad NumberOfComponents
8102         self.assertRaises(InterpKernelException, da.findCommonTuples, 1e-2);
8103         pass
8104
8105     def testDABack1(self):
8106         da=DataArrayDouble.New();
8107         array1=[2.3,1.2,1.3,2.3,2.301,0.8]
8108         da.setValues(array1,6,1);
8109         self.assertAlmostEqual(0.8,da.back(),14);
8110         da.rearrange(2);
8111         self.assertRaises(InterpKernelException,da.back);
8112         da.alloc(0,1);
8113         self.assertRaises(InterpKernelException,da.back);
8114         #
8115         da=DataArrayInt.New();
8116         array2=[4,7,8,2]
8117         da.setValues(array2,4,1);
8118         self.assertEqual(2,da.back());
8119         da.rearrange(2);
8120         self.assertRaises(InterpKernelException,da.back);
8121         da.alloc(0,1);
8122         self.assertRaises(InterpKernelException,da.back);
8123         pass
8124
8125     def testDADGetDifferentValues1(self):
8126         da=DataArrayDouble.New();
8127         array1=[2.3,1.2,1.3,2.3,2.301,0.8]
8128         da.setValues(array1,6,1)
8129         #
8130         expected1=[2.301,1.2,1.3,0.8]
8131         dv=da.getDifferentValues(1e-2);
8132         self.assertEqual(4,dv.getNbOfElems());
8133         for i in xrange(4):
8134             self.assertAlmostEqual(expected1[i],dv.getIJ(i,0),14);
8135             pass
8136         #
8137         dv=da.getDifferentValues(2e-1);
8138         expected2=[2.301,1.3,0.8]
8139         self.assertEqual(3,dv.getNbOfElems());
8140         for i in xrange(3):
8141             self.assertAlmostEqual(expected2[i],dv.getIJ(i,0),14);
8142             pass
8143         pass
8144
8145     def testDAIBuildOld2NewArrayFromSurjectiveFormat2(self):
8146         arr=[0,3, 5,7,9]
8147         arrI=[0,2,5]
8148         a=DataArrayInt.New();
8149         a.setValues(arr,5,1);
8150         b=DataArrayInt.New();
8151         b.setValues(arrI,3,1);
8152         ret,newNbTuple=DataArrayInt.BuildOld2NewArrayFromSurjectiveFormat2(10,a,b);
8153         expected=[0,1,2,0,3,4,5,4,6,4]
8154         self.assertEqual(10,ret.getNbOfElems());
8155         self.assertEqual(7,newNbTuple);
8156         self.assertEqual(1,ret.getNumberOfComponents());
8157         self.assertEqual(expected,ret.getValues());
8158         self.assertRaises(InterpKernelException,DataArrayInt.BuildOld2NewArrayFromSurjectiveFormat2,9,a,b);
8159         pass
8160
8161     def testDADIReverse1(self):
8162         arr=[0,3,5,7,9,2]
8163         a=DataArrayInt.New();
8164         a.setValues(arr,6,1);
8165         self.assertEqual(2,a.back());
8166         a.reverse();
8167         for i in xrange(6):
8168             self.assertEqual(arr[5-i],a.getIJ(i,0));
8169             pass
8170         a.setValues(arr[:-1],5,1);
8171         a.reverse();
8172         for i in xrange(5):
8173             self.assertEqual(arr[4-i],a.getIJ(i,0));
8174             pass
8175         #
8176         arr2=[0.,3.,5.,7.,9.,2.]
8177         b=DataArrayDouble.New();
8178         b.setValues(arr2,6,1);
8179         b.reverse();
8180         for i in xrange(6):
8181             self.assertAlmostEqual(arr2[5-i],b.getIJ(i,0),14);
8182             pass
8183         b.setValues(arr2[:5],5,1);
8184         self.assertAlmostEqual(9.,b.back(),14)
8185         b.reverse();
8186         for i in xrange(5):
8187             self.assertAlmostEqual(arr2[4-i],b.getIJ(i,0),14);
8188             pass
8189         pass
8190
8191     def testGetNodeIdsInUse1(self):
8192         m0=MEDCouplingDataForTest.build2DTargetMesh_1();
8193         CellIds=[1,2]
8194         m1=m0.buildPartOfMySelf(CellIds,True);
8195         arr,newNbOfNodes=m1.getNodeIdsInUse();
8196         expected=[-1,0,1,-1,2,3,-1,-1,-1]
8197         self.assertEqual(4,newNbOfNodes);
8198         self.assertEqual(9,arr.getNbOfElems());
8199         self.assertEqual(expected,arr.getValues());
8200         arr2=arr.invertArrayO2N2N2O(newNbOfNodes);
8201         self.assertEqual(4,arr2.getNbOfElems());
8202         expected2=[1,2,4,5]
8203         self.assertEqual(expected2,arr2.getValues());
8204         pass
8205
8206     def testBuildDescendingConnec2(self):
8207         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
8208         #
8209         mesh2,desc,descIndx,revDesc,revDescIndx=mesh.buildDescendingConnectivity2();
8210         mesh2.checkCoherency();
8211         self.assertEqual(1,mesh2.getMeshDimension());
8212         self.assertEqual(13,mesh2.getNumberOfCells());
8213         self.assertEqual(14,revDescIndx.getNbOfElems()); self.assertEqual(14,revDescIndx.getNumberOfTuples());
8214         self.assertEqual(6,descIndx.getNbOfElems()); self.assertEqual(6,descIndx.getNumberOfTuples());
8215         self.assertEqual(18,desc.getNbOfElems()); self.assertEqual(18,desc.getNumberOfTuples());
8216         self.assertEqual(18,revDesc.getNbOfElems()); self.assertEqual(18,revDesc.getNumberOfTuples());
8217         expected1=[1,2,3,4,-3,5,6, 7,8,-5,9,10,-2,11, 12,13,-7,-10]
8218         self.assertEqual(expected1,desc.getValues());
8219         expected2=[0,4,7,10,14,18]
8220         self.assertEqual(expected2,descIndx.getValues());
8221         expected3=[0,1,3,5,6,8,9,11,12,13,15,16,17,18]
8222         self.assertEqual(expected3,revDescIndx.getValues());
8223         expected4=[0, 0,3, 0,1, 0, 1,2, 1, 2,4, 2, 3, 3,4, 3, 4, 4]
8224         self.assertEqual(expected4,revDesc.getValues());
8225         conn=mesh2.getNodalConnectivity();
8226         connIndex=mesh2.getNodalConnectivityIndex();
8227         expected5=[0,3,6,9,12,15,18,21,24,27,30,33,36,39]
8228         self.assertEqual(expected5,connIndex.getValues());
8229         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]
8230         self.assertEqual(expected6,conn.getValues());
8231         pass
8232
8233     def testIntersect2DMeshesTmp1(self):
8234         m1c=MEDCouplingCMesh.New();
8235         coordsX=DataArrayDouble.New();
8236         arrX=[ -1., 1., 2., 4. ]
8237         coordsX.setValues(arrX,4,1);
8238         m1c.setCoordsAt(0,coordsX);
8239         coordsY=DataArrayDouble.New();
8240         arrY=[ -2., 2., 4., 8. ]
8241         coordsY.setValues(arrY,4,1);
8242         m1c.setCoordsAt(1,coordsY);
8243         m1=m1c.buildUnstructured()
8244         m1bis=m1.buildPartOfMySelf([3,4,5],False)
8245         m2=m1.deepCpy()
8246         m2=m2.buildPartOfMySelf([0,1,2],False)
8247         m2.translate([0.5,0.5])
8248         #
8249         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m1bis,m2,1e-10)
8250         expected1=[0,0,1,1,1,2,2,2]
8251         expected2=[0,-1,0,1,-1,1,2,-1]
8252         self.assertEqual(8,d1.getNumberOfTuples());
8253         self.assertEqual(8,d2.getNumberOfTuples());
8254         self.assertEqual(8,m3.getNumberOfCells());
8255         self.assertEqual(22,m3.getNumberOfNodes());
8256         self.assertEqual(2,m3.getSpaceDimension());
8257         self.assertEqual(expected1,d1.getValues());
8258         self.assertEqual(expected2,d2.getValues());
8259         expected3=[5,17,1,16,12,5,16,0,4,5,17,12,5,18,1,17,13,5,19,2,18,13,5,17,5,6,19,13,5,20,2,19,14,5,21,3,20,14,5,19,6,7,21,14]
8260         expected4=[0,5,12,17,22,28,33,38,44]
8261         expected5=[-1.0,2.0,1.0,2.0,2.0,2.0,4.0,2.0,-1.0,4.0,1.0,4.0,2.0,4.0,4.0,4.0,-0.5,-1.5,1.5,-1.5,2.5,-1.5,4.5,-1.5,-0.5,2.5,1.5,2.5,2.5,2.5,4.5,2.5,-0.5,2.0,1.0,2.5,1.5,2.0,2.0,2.5,2.5,2.0,4.0,2.5]
8262         self.assertEqual(44,m3.getNodalConnectivity().getNumberOfTuples());
8263         self.assertEqual(9,m3.getNodalConnectivityIndex().getNumberOfTuples());
8264         self.assertEqual(expected3,m3.getNodalConnectivity().getValues());
8265         self.assertEqual(expected4,m3.getNodalConnectivityIndex().getValues());
8266         for i in xrange(44):
8267             self.assertAlmostEqual(expected5[i],m3.getCoords().getIJ(0,i),12);
8268             pass
8269         pass
8270
8271     def testFindNodesOnLine1(self):
8272         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
8273         pt=[-0.3,-0.3]
8274         pt2=[0.,0.,0.]
8275         pt3=[-0.3,0.,0.]
8276         vec=[0.,1.]
8277         vec2=[1.,0.,0.]
8278         vec3=[0.,1.,1.]
8279         expected1=[0,3,6]
8280         res=mesh.findNodesOnLine(pt,vec,1e-12);
8281         self.assertEqual(3,len(res));
8282         self.assertEqual(expected1,res.getValues());
8283         #
8284         mesh.changeSpaceDimension(3);
8285         mesh.rotate(pt2,vec2,pi/4.);
8286         res=mesh.findNodesOnLine(pt3,vec3,1e-12);
8287         self.assertEqual(3,len(res));
8288         self.assertEqual(expected1,res.getValues());
8289         pass
8290
8291     def testIntersect2DMeshesTmp2(self):
8292         m1c=MEDCouplingCMesh.New();
8293         coordsX1=DataArrayDouble.New();
8294         arrX1=[ 0., 1., 1.5, 2. ]
8295         coordsX1.setValues(arrX1,4,1);
8296         m1c.setCoordsAt(0,coordsX1);
8297         coordsY1=DataArrayDouble.New();
8298         arrY1=[ 0., 1.5, 3.]
8299         coordsY1.setValues(arrY1,3,1);
8300         m1c.setCoordsAt(1,coordsY1);
8301         m1=m1c.buildUnstructured();
8302         m2c=MEDCouplingCMesh.New();
8303         coordsX2=DataArrayDouble.New();
8304         arrX2=[ 0., 1., 2. ]
8305         coordsX2.setValues(arrX2,3,1);
8306         m2c.setCoordsAt(0,coordsX2);
8307         coordsY2=DataArrayDouble.New();
8308         arrY2=[ 0., 1., 3.]
8309         coordsY2.setValues(arrY2,3,1);
8310         m2c.setCoordsAt(1,coordsY2);
8311         m2=m2c.buildUnstructured();
8312         #
8313         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m1,m2,1e-10)
8314         #
8315         expected1=[0,0,1,1,2,2,3,4,5]
8316         expected2=[0,2,1,3,1,3,2,3,3]
8317         self.assertEqual(9,d1.getNumberOfTuples());
8318         self.assertEqual(9,d2.getNumberOfTuples());
8319         self.assertEqual(9,m3.getNumberOfCells());
8320         self.assertEqual(22,m3.getNumberOfNodes());
8321         self.assertEqual(2,m3.getSpaceDimension());
8322         self.assertEqual(expected1,d1.getValues());
8323         self.assertEqual(expected2,d2.getValues());
8324         expected3=[5,16,13,12,15,5,15,4,5,16,5,21,2,13,16,5,16,5,6,21,5,17,14,2,21,5,21,6,7,17,5,4,18,19,5,5,5,19,10,6,5,6,10,20,7]
8325         expected4=[0,5,10,15,20,25,30,35,40,45]
8326         expected5=[0.0,0.0,1.0,0.0,1.5,0.0,2.0,0.0,0.0,1.5,1.0,1.5,1.5,1.5,2.0,1.5,0.0,3.0,1.0,3.0,1.5,3.0,2.0,3.0,0.0,0.0,1.0,0.0,2.0,0.0,0.0,1.0,1.0,1.0,2.0,1.0,0.0,3.0,1.0,3.0,2.0,3.0,1.5,1.0]
8327         self.assertEqual(45,m3.getNodalConnectivity().getNumberOfTuples());
8328         self.assertEqual(10,m3.getNodalConnectivityIndex().getNumberOfTuples());
8329         self.assertEqual(expected3,m3.getNodalConnectivity().getValues());
8330         self.assertEqual(expected4,m3.getNodalConnectivityIndex().getValues());
8331         for i in xrange(44):
8332             self.assertAlmostEqual(expected5[i],m3.getCoords().getIJ(0,i),12);
8333             pass
8334         pass
8335     
8336     def testBuildPartOfMySelfSafe1(self):
8337         mesh=MEDCouplingDataForTest.build2DTargetMesh_1()
8338         self.assertRaises(InterpKernelException,mesh.buildPartOfMySelf,[0,-1,4,2],True)
8339         self.assertRaises(InterpKernelException,mesh.buildPartOfMySelf,[0,4,5,4],True)
8340         pass
8341
8342     def testIntersect2DMeshesTmp3(self):
8343         m1Coords=[0.,0.,1.,0.,1.5,0.,0.,1.,0.,1.5,-1.,0.,-1.5,0.,0.,-1,0.,-1.5,0.5,0.,1.25,0.,0.70710678118654757,0.70710678118654757,1.0606601717798214,1.0606601717798214,0.,0.5,0.,1.25,-0.70710678118654757,0.70710678118654757,-1.0606601717798214,1.0606601717798214,-0.5,0.,-1.25,0.,-0.70710678118654757,-0.70710678118654757,-1.0606601717798214,-1.0606601717798214,0.,-0.5,0.,-1.25,0.70710678118654757,-0.70710678118654757,1.0606601717798214,-1.0606601717798214];
8344         m1Conn=[0,3,1,13,11,9, 3,4,2,1,14,12,10,11, 5,3,0,15,13,17, 6,4,3,5,16,14,15,18, 5,0,7,17,21,19, 6,5,7,8,18,19,22,20, 0,1,7,9,23,21, 1,2,8,7,10,24,22,23];
8345         m1=MEDCouplingUMesh.New();
8346         m1.setMeshDimension(2);
8347         m1.allocateCells(8);
8348         m1.insertNextCell(NORM_TRI6,6,m1Conn[0:6]);
8349         m1.insertNextCell(NORM_QUAD8,8,m1Conn[6:14]);
8350         m1.insertNextCell(NORM_TRI6,6,m1Conn[14:20]);
8351         m1.insertNextCell(NORM_QUAD8,8,m1Conn[20:28]);
8352         m1.insertNextCell(NORM_TRI6,6,m1Conn[28:34]);
8353         m1.insertNextCell(NORM_QUAD8,8,m1Conn[34:42]);
8354         m1.insertNextCell(NORM_TRI6,6,m1Conn[42:48]);
8355         m1.insertNextCell(NORM_QUAD8,8,m1Conn[48:56]);
8356         m1.finishInsertingCells();
8357         myCoords1=DataArrayDouble.New();
8358         myCoords1.setValues(m1Coords,25,2);
8359         m1.setCoords(myCoords1);
8360         #
8361         m2Coords=[0.,0.,1.1,0.,1.1,1.,0.,1.,1.7,0.,1.7,1.,-1.1,1.,-1.1,0.,-1.7,0.,-1.7,1.,-1.7,-1,-1.1,-1.,0.,-1.,1.1,-1,1.7,-1.]
8362         m2Conn=[0,3,2,1, 1,2,5,4, 7,6,3,0, 8,9,6,7, 7,0,12,11, 8,7,11,10, 0,1,13,12, 1,4,14,13]
8363         m2=MEDCouplingUMesh.New();
8364         m2.setMeshDimension(2);
8365         m2.allocateCells(8);
8366         for i in xrange(8):
8367             m2.insertNextCell(NORM_QUAD4,4,m2Conn[4*i:4*(i+1)])
8368             pass
8369         m2.finishInsertingCells();
8370         myCoords2=DataArrayDouble.New();
8371         myCoords2.setValues(m2Coords,15,2);
8372         m2.setCoords(myCoords2);
8373         #
8374         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m1,m2,1e-10)
8375         m3.unPolyze()
8376         #
8377         expected1=[0,1,1,1,2,3,3,3,4,5,5,5,6,7,7,7]
8378         expected2=[0,0,1,-1,2,2,3,-1,4,4,5,-1,6,6,7,-1]
8379         self.assertEqual(16,d1.getNumberOfTuples());
8380         self.assertEqual(16,d2.getNumberOfTuples());
8381         self.assertEqual(16,m3.getNumberOfCells());
8382         self.assertEqual(104,m3.getNumberOfNodes());
8383         self.assertEqual(2,m3.getSpaceDimension());
8384         self.assertEqual(expected1,d1.getValues());
8385         self.assertEqual(expected2,d2.getValues());
8386         expected3=[6,28,1,25,44,45,46,8,26,1,28,27,47,48,49,50,8,40,2,26,27,51,52,53,54,8,28,4,40,27,55,56,57,58,6,28,25,5,59,60,61,8,28,5,32,31,62,63,64,65,8,32,6,41,31,66,67,68,69,8,41,4,28,31,70,71,72,73,6,25,37,5,74,75,76,8,32,5,37,36,77,78,79,80,8,42,6,32,36,81,82,83,84,8,37,8,42,36,85,86,87,88,6,1,37,25,89,90,91,8,37,1,26,38,92,93,94,95,8,26,2,43,38,96,97,98,99,8,43,8,37,38,100,101,102,103]
8387         expected4=[0,7,16,25,34,41,50,59,68,75,84,93,102,109,118,127,136]
8388         expected5=[0.,0.,1.,0.,1.5,0.,0.,1.,0.,1.5,-1.,0.,-1.5,0.,0.,-1.,0.,-1.5,0.5,0.,1.25,0.,0.7071067811865476,0.7071067811865476,1.0606601717798214,1.0606601717798214,0.,0.5,0.,1.25,-0.7071067811865476,0.7071067811865476,-1.0606601717798214,1.0606601717798214,-0.5,0.,-1.25,0.,-0.7071067811865476,-0.7071067811865476,-1.0606601717798214,-1.0606601717798214,0.,-0.5,0.,-1.25,0.7071067811865476,-0.7071067811865476,1.0606601717798214,-1.0606601717798214,0.,0.,1.1,0.,1.1,1.,0.,1.,1.7,0.,1.7,1.,-1.1,1.,-1.1,0.,-1.7,0.,-1.7,1.,-1.7,-1.,-1.1,-1.,0.,-1.,1.1,-1.,1.7,-1.,1.118033988749895,1.,-1.118033988749895,1.,-1.118033988749895,-1.,1.118033988749895,-1.,0.7071067811865477,0.7071067811865476,0.5,0.,0.,0.5,1.05,0.,0.7071067811865475,0.7071067811865477,0.55,1.,1.1,0.5,1.4012585384440737,0.535233134659635,1.3,0.,1.1,0.5,1.1090169943749475,1.,0.,1.25,0.6123724356957946,1.369306393762915,1.1090169943749475,1.,0.55,1.,0.,0.5,-0.5,0.,-0.7071067811865477,0.7071067811865476,-0.7071067811865475,0.7071067811865477,-1.05,0.,-1.1,0.5,-0.55,1.,-1.3,0.,-1.4012585384440737,0.5352331346596344,-1.1090169943749475,1.,-1.1,0.5,-0.6123724356957941,1.3693063937629155,0.,1.25,-0.55,1.,-1.1090169943749475,1.,0.,-0.5,-0.7071067811865475,-0.7071067811865477,-0.5,0.,-1.05,0.,-0.7071067811865478,-0.7071067811865475,-0.55,-1.,-1.1,-0.5,-1.4012585384440734,-0.5352331346596354,-1.3,0.,-1.1,-0.5,-1.1090169943749475,-1.,0.,-1.25,-0.6123724356957945,-1.369306393762915,-1.1090169943749475,-1.,-0.55,-1.,0.7071067811865475,-0.7071067811865477,0.,-0.5,0.5,0.,0.7071067811865477,-0.7071067811865475,1.05,0.,1.1,-0.5,0.55,-1.,1.3,0.,1.4012585384440737,-0.535233134659635,1.1090169943749475,-1.,1.1,-0.5,0.6123724356957946,-1.369306393762915,0.,-1.25,0.55,-1.,1.1090169943749475,-1.0]
8389         self.assertEqual(136,m3.getNodalConnectivity().getNumberOfTuples());
8390         self.assertEqual(17,m3.getNodalConnectivityIndex().getNumberOfTuples());
8391         self.assertEqual(expected3,m3.getNodalConnectivity().getValues());
8392         self.assertEqual(expected4,m3.getNodalConnectivityIndex().getValues());
8393         for i in xrange(208):
8394             self.assertAlmostEqual(expected5[i],m3.getCoords().getIJ(0,i),12);
8395             pass
8396         pass
8397
8398     def testUMeshTessellate2D1(self):
8399         m1Coords=[0.,0.,1.,0.,1.5,0.,0.,1.,0.,1.5,-1.,0.,-1.5,0.,0.,-1,0.,-1.5,0.5,0.,1.25,0.,0.70710678118654757,0.70710678118654757,1.0606601717798214,1.0606601717798214,0.,0.5,0.,1.25,-0.70710678118654757,0.70710678118654757,-1.0606601717798214,1.0606601717798214,-0.5,0.,-1.25,0.,-0.70710678118654757,-0.70710678118654757,-1.0606601717798214,-1.0606601717798214,0.,-0.5,0.,-1.25,0.70710678118654757,-0.70710678118654757,1.0606601717798214,-1.0606601717798214];
8400         m1Conn=[0,3,1,13,11,9, 3,4,2,1,14,12,10,11, 5,3,0,15,13,17, 6,4,3,5,16,14,15,18, 5,0,7,17,21,19, 6,5,7,8,18,19,22,20, 0,1,7,9,23,21, 1,2,8,7,10,24,22,23];
8401         m1=MEDCouplingUMesh.New();
8402         m1.setMeshDimension(2);
8403         m1.allocateCells(8);
8404         m1.insertNextCell(NORM_TRI6,6,m1Conn[0:6]);
8405         m1.insertNextCell(NORM_QUAD8,8,m1Conn[6:14]);
8406         m1.insertNextCell(NORM_TRI6,6,m1Conn[14:20]);
8407         m1.insertNextCell(NORM_QUAD8,8,m1Conn[20:28]);
8408         m1.insertNextCell(NORM_TRI6,6,m1Conn[28:34]);
8409         m1.insertNextCell(NORM_QUAD8,8,m1Conn[34:42]);
8410         m1.insertNextCell(NORM_TRI6,6,m1Conn[42:48]);
8411         m1.insertNextCell(NORM_QUAD8,8,m1Conn[48:56]);
8412         m1.finishInsertingCells();
8413         myCoords1=DataArrayDouble.New();
8414         myCoords1.setValues(m1Coords,25,2);
8415         m1.setCoords(myCoords1);
8416         #
8417         m11=m1.deepCpy();
8418         m11.tessellate2D(1.);
8419         self.assertTrue(m11.getCoords().isEqual(m11.getCoords(),1e-12));
8420         expected1=[5,0,3,11,1,5,3,4,12,2,1,11,5,5,15,3,0,5,6,16,4,3,15,5,5,5,0,7,19,5,6,5,19,7,8,20,5,0,1,23,7,5,1,2,24,8,7,23]
8421         expected2=[0,5,12,17,24,29,36,41,48]
8422         self.assertEqual(48,m11.getNodalConnectivity().getNumberOfTuples());
8423         self.assertEqual(9,m11.getNodalConnectivityIndex().getNumberOfTuples());
8424         self.assertEqual(expected1,m11.getNodalConnectivity().getValues());
8425         self.assertEqual(expected2,m11.getNodalConnectivityIndex().getValues());
8426         #
8427         m12=m1.deepCpy();
8428         m12.tessellate2D(0.5);
8429         self.assertEqual(41,m12.getNumberOfNodes());
8430         expected3=[5,0,3,25,26,1,5,3,4,27,28,2,1,26,25,5,5,29,30,3,0,5,6,31,32,4,3,30,29,5,5,5,0,7,33,34,5,6,5,34,33,7,8,35,36,5,0,1,37,38,7,5,1,2,39,40,8,7,38,37]
8431         expected4=[0,6,15,21,30,36,45,51,60]
8432         expected5=[0.,0.,1.,0.,1.5,0.,0.,1.,0.,1.5,-1.,0.,-1.5,0.,0.,-1.,0.,-1.5,0.5,0.,1.25,0.,0.7071067811865476,0.7071067811865476,1.0606601717798214,1.0606601717798214,0.,0.5,0.,1.25,-0.7071067811865476,0.7071067811865476,-1.0606601717798214,1.0606601717798214,-0.5,0.,-1.25,0.,-0.7071067811865476,-0.7071067811865476,-1.0606601717798214,-1.0606601717798214,0.,-0.5,0.,-1.25,0.7071067811865476,-0.7071067811865476,1.0606601717798214,-1.0606601717798214,0.479425538604203,0.8775825618903728,0.8414709848078964,0.54030230586814,0.7191383079063044,1.3163738428355591,1.2622064772118446,0.8104534588022099,-0.877582561890373,0.4794255386042027,-0.5403023058681399,0.8414709848078964,-1.3163738428355596,0.7191383079063038,-0.8104534588022098,1.2622064772118446,-0.4794255386042031,-0.8775825618903728,-0.8414709848078965,-0.5403023058681399,-0.7191383079063045,-1.3163738428355591,-1.2622064772118449,-0.8104534588022098,0.8775825618903729,-0.47942553860420295,0.54030230586814,-0.8414709848078964,1.3163738428355594,-0.7191383079063043,0.8104534588022099,-1.2622064772118446]
8433         for i in xrange(82):
8434             self.assertAlmostEqual(expected5[i],m12.getCoords().getIJ(0,i),12);
8435             pass
8436         self.assertEqual(60,m12.getNodalConnectivity().getNumberOfTuples());
8437         self.assertEqual(9,m12.getNodalConnectivityIndex().getNumberOfTuples());
8438         self.assertEqual(expected3,m12.getNodalConnectivity().getValues());
8439         self.assertEqual(expected4,m12.getNodalConnectivityIndex().getValues());
8440         pass
8441
8442     def testIntersect2DMeshesTmp4(self):
8443         m1Coords=[0.,0.,1.,0.,1.5,0.,0.,1.,0.,1.5,-1.,0.,-1.5,0.,0.,-1,0.,-1.5,0.5,0.,1.25,0.,0.70710678118654757,0.70710678118654757,1.0606601717798214,1.0606601717798214,0.,0.5,0.,1.25,-0.70710678118654757,0.70710678118654757,-1.0606601717798214,1.0606601717798214,-0.5,0.,-1.25,0.,-0.70710678118654757,-0.70710678118654757,-1.0606601717798214,-1.0606601717798214,0.,-0.5,0.,-1.25,0.70710678118654757,-0.70710678118654757,1.0606601717798214,-1.0606601717798214];
8444         m1Conn=[0,3,1,13,11,9, 3,4,2,1,14,12,10,11, 5,3,0,15,13,17, 6,4,3,5,16,14,15,18, 5,0,7,17,21,19, 6,5,7,8,18,19,22,20, 0,1,7,9,23,21, 1,2,8,7,10,24,22,23];
8445         m1=MEDCouplingUMesh.New();
8446         m1.setMeshDimension(2);
8447         m1.allocateCells(8);
8448         m1.insertNextCell(NORM_TRI6,6,m1Conn[0:6]);
8449         m1.insertNextCell(NORM_QUAD8,8,m1Conn[6:14]);
8450         m1.insertNextCell(NORM_TRI6,6,m1Conn[14:20]);
8451         m1.insertNextCell(NORM_QUAD8,8,m1Conn[20:28]);
8452         m1.insertNextCell(NORM_TRI6,6,m1Conn[28:34]);
8453         m1.insertNextCell(NORM_QUAD8,8,m1Conn[34:42]);
8454         m1.insertNextCell(NORM_TRI6,6,m1Conn[42:48]);
8455         m1.insertNextCell(NORM_QUAD8,8,m1Conn[48:56]);
8456         m1.finishInsertingCells();
8457         myCoords1=DataArrayDouble.New();
8458         myCoords1.setValues(m1Coords,25,2);
8459         m1.setCoords(myCoords1);
8460         #
8461         m2Coords=[0.,0.,1.1,0.,1.1,1.,0.,1.,1.7,0.,1.7,1.,-1.1,1.,-1.1,0.,-1.7,0.,-1.7,1.,-1.7,-1,-1.1,-1.,0.,-1.,1.1,-1,1.7,-1.]
8462         m2Conn=[0,3,2,1, 1,2,5,4, 7,6,3,0, 8,9,6,7, 7,0,12,11, 8,7,11,10, 0,1,13,12, 1,4,14,13]
8463         m2=MEDCouplingUMesh.New();
8464         m2.setMeshDimension(2);
8465         m2.allocateCells(8);
8466         for i in xrange(8):
8467             m2.insertNextCell(NORM_QUAD4,4,m2Conn[4*i:4*(i+1)])
8468             pass
8469         m2.finishInsertingCells();
8470         myCoords2=DataArrayDouble.New();
8471         myCoords2.setValues(m2Coords,15,2);
8472         m2.setCoords(myCoords2);
8473         #
8474         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m2,m1,1e-10)
8475         m3.unPolyze()
8476         #
8477         expected1=[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
8478         expected2=[0,1,1,-1,2,3,3,-1,4,5,5,-1,6,7,7,-1]
8479         self.assertEqual(16,d1.getNumberOfTuples());
8480         self.assertEqual(16,d2.getNumberOfTuples());
8481         self.assertEqual(16,m3.getNumberOfCells());
8482         self.assertEqual(104,m3.getNumberOfNodes());
8483         self.assertEqual(2,m3.getSpaceDimension());
8484         self.assertEqual(expected1,d1.getValues());
8485         self.assertEqual(expected2,d2.getValues());
8486         expected3=[6,16,15,18,44,45,46,8,18,2,1,16,47,48,49,50,8,17,1,2,40,51,52,53,54,8,40,5,4,17,55,56,57,58,6,18,15,20,59,60,61,8,20,7,6,18,62,63,64,65,8,41,6,7,21,66,67,68,69,8,21,8,9,41,70,71,72,73,6,20,15,22,74,75,76,8,22,11,7,20,77,78,79,80,8,21,7,11,42,81,82,83,84,8,42,10,8,21,85,86,87,88,6,22,15,16,89,90,91,8,16,1,13,22,92,93,94,95,8,43,13,1,17,96,97,98,99,8,17,4,14,43,100,101,102,103]
8487         expected4=[0,7,16,25,34,41,50,59,68,75,84,93,102,109,118,127,136]
8488         expected5=[0.,0.,1.1, 0.,1.1,1.,0.,1.,1.7,0.,1.7,1.,-1.1,1.,-1.1,0.,-1.7,0.,-1.7,1.,-1.7,-1.,-1.1,-1.,0.,-1.,1.1,-1.,1.7,-1.,0.,0.,1.,0.,1.5,0.,0.,1.,0.,1.5,-1.,0.,-1.5,0.,0.,-1.,0.,-1.5,0.5,0.,1.25,0.,0.7071067811865476,0.7071067811865476,1.0606601717798214,1.0606601717798214,0.,0.5,0.,1.25,-0.7071067811865476,0.7071067811865476,-1.0606601717798214,1.0606601717798214,-0.5,0.,-1.25,0.,-0.7071067811865476,-0.7071067811865476,-1.0606601717798214,-1.0606601717798214,0.,-0.5,0.,-1.25,0.7071067811865476,-0.7071067811865476,1.0606601717798214,-1.0606601717798214,1.1180339887498951,1.,-1.1180339887498951,1.,-1.1180339887498951,-1.,1.1180339887498951,-1.,0.5,0.,0.,0.5,0.7071067811865477,0.7071067811865476,0.55,1.,1.1,0.5,1.05,0.,0.7071067811865477,0.7071067811865475,1.3,0.,1.1,0.5,1.1090169943749475,1.,1.4012585384440737,0.535233134659635,1.4090169943749475,1.,1.7,0.5,1.6,0.,1.4012585384440737,0.535233134659635,0.,0.5,-0.5,0.,-0.7071067811865477,0.7071067811865476,-1.05,0.,-1.1,0.5,-0.55,1.,-0.7071067811865478,0.7071067811865475,-1.1090169943749475,1.,-1.1,0.5,-1.3,0.,-1.4012585384440737,0.5352331346596344,-1.6,0.,-1.7,0.5,-1.4090169943749475,1.,-1.4012585384440737,0.5352331346596344,-0.5,0.,0.,-0.5,-0.7071067811865475,-0.7071067811865477,-0.55,-1.,-1.1,-0.5,-1.05,0.,-0.7071067811865475,-0.7071067811865477,-1.3,0.,-1.1,-0.5,-1.1090169943749475,-1.,-1.4012585384440734,-0.5352331346596354,-1.4090169943749475,-1.,-1.7,-0.5,-1.6,0.,-1.4012585384440732,-0.5352331346596354,0.,-0.5,0.5,0.,0.7071067811865475,-0.7071067811865477,1.05,0.,1.1,-0.5,0.55,-1.,0.7071067811865475,-0.7071067811865477,1.1090169943749475,-1.,1.1,-0.5,1.3,0.,1.4012585384440737,-0.535233134659635,1.6,0.,1.7,-0.5,1.4090169943749475,-1.,1.4012585384440737,-0.535233134659635]
8489         self.assertEqual(136,m3.getNodalConnectivity().getNumberOfTuples());
8490         self.assertEqual(17,m3.getNodalConnectivityIndex().getNumberOfTuples());
8491         self.assertEqual(expected3,m3.getNodalConnectivity().getValues());
8492         self.assertEqual(expected4,m3.getNodalConnectivityIndex().getValues());
8493         for i in xrange(208):
8494             self.assertAlmostEqual(expected5[i],m3.getCoords().getIJ(0,i),12);
8495             pass
8496         pass
8497
8498     def testGetCellIdsCrossingPlane1(self):
8499         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
8500         vec=[-0.07,1.,0.07]
8501         origin=[1.524,1.4552,1.74768]
8502         ids1=mesh3D.getCellIdsCrossingPlane(origin,vec,1e-10)
8503         self.assertEqual([1,3,4,7,9,10,13,15,16],ids1.getValues())
8504         vec2=[0.,0.,1.]
8505         ids2=mesh3D.getCellIdsCrossingPlane(origin,vec2,1e-10)
8506         self.assertEqual([6,7,8,9,10,11],ids2.getValues())
8507         pass
8508
8509     def testBuildSlice3D1(self):
8510         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
8511         vec1=[-0.07,1.,0.07]
8512         origin1=[1.524,1.4552,1.74768]
8513         slice1,ids=mesh3D.buildSlice3D(origin1,vec1,1e-10);
8514         expected1=[1,3,4,7,9,10,13,15,16]
8515         expected2=[5,42,41,40,43,44,5,42,46,45,41,5,44,43,40,47,48,5,49,42,44,50,5,49,51,46,42,5,50,44,48,52,5,53,49,50,54,5,53,55,51,49,5,54,50,52,56]
8516         expected3=[0,6,11,17,22,27,32,37,42,47]
8517         expected4=[1.,1.,0.,1.,1.25,0.,1.,1.5,0.,2.,1.,0.,1.,2.,0.,0.,2.,0.,3.,1.,0.,3.,2.,0.,0.,1.,0.,2.,2.,0.,1.,1.,1.,1.,1.25,1.,1.,1.5,1.,2.,1.,1.,1.,2.,1.,0.,2.,1.,3.,1.,1.,3.,2.,1.,0.,1.,1.,2.,2.,1.,1.,1.,2.,1.,1.25,2.,1.,1.5,2.,2.,1.,2.,1.,2.,2.,0.,2.,2.,3.,1.,2.,3.,2.,2.,0.,1.,2.,2.,2.,2.,1.,1.,3.,1.,1.25,3.,1.,1.5,3.,2.,1.,3.,1.,2.,3.,0.,2.,3.,3.,1.,3.,3.,2.,3.,0.,1.,3.,2.,2.,3.,1.,1.5408576,0.,2.,1.6108576000000001,0.,2.,1.5408576,1.,1.,1.5,0.5836800000000008,1.,1.4708576,1.,3.,1.6808576,0.,3.,1.6108576000000001,1.,0.,1.4708576,0.,0.,1.4008576,1.,2.,1.4708576,2.,1.,1.4008576000000001,2.,3.,1.5408575999999998,2.,0.,1.3308575999999999,2.,2.,1.4008576,3.,1.,1.3308576,3.,3.,1.4708576,3.,0.,1.2608576,3.]
8518         self.assertEqual(2,slice1.getMeshDimension());
8519         self.assertEqual(3,slice1.getSpaceDimension());
8520         self.assertEqual(57,slice1.getNumberOfNodes());
8521         self.assertEqual(9,slice1.getNumberOfCells());
8522         self.assertEqual(9,ids.getNumberOfTuples());
8523         self.assertEqual(47,slice1.getNodalConnectivity().getNumberOfTuples());
8524         self.assertEqual(10,slice1.getNodalConnectivityIndex().getNumberOfTuples());
8525         self.assertEqual(expected1,ids.getValues());
8526         self.assertEqual(expected2,slice1.getNodalConnectivity().getValues());
8527         self.assertEqual(expected3,slice1.getNodalConnectivityIndex().getValues());
8528         for i in xrange(171):
8529             self.assertAlmostEqual(expected4[i],slice1.getCoords().getIJ(0,i),12);
8530             pass
8531         # 2nd slice based on already existing nodes of mesh3D.
8532         vec2=[0.,3.,1.]
8533         origin2=[2.5,1.,3.]
8534         slice1,ids=mesh3D.buildSlice3D(origin2,vec2,1e-10);
8535         expected5=[5,50,10,4,51,5,50,52,7,10,5,51,4,5,53,5,54,50,51,55,56,5,54,57,52,50,5,56,55,51,53,58,5,38,59,56,54,43,5,54,57,46,43,5,38,59,56,58,48]
8536         expected6=[0,5,10,15,21,26,32,38,43,49]
8537         expected7=[1.,1.,0.,1.,1.25,0.,1.,1.5,0.,2.,1.,0.,1.,2.,0.,0.,2.,0.,3.,1.,0.,3.,2.,0.,0.,1.,0.,1.,3.,0.,2.,2.,0.,2.,3.,0.,1.,1.,1.,1.,1.25,1.,1.,1.5,1.,2.,1.,1.,1.,2.,1.,0.,2.,1.,3.,1.,1.,3.,2.,1.,0.,1.,1.,1.,3.,1.,2.,2.,1.,2.,3.,1.,0.,0.,2.,1.,1.,2.,1.,1.25,2.,1.,0.,2.,1.,1.5,2.,2.,0.,2.,2.,1.,2.,1.,2.,2.,0.,2.,2.,3.,1.,2.,3.,2.,2.,0.,1.,2.,2.,2.,2.,0.,0.,3.,1.,1.,3.,1.,1.25,3.,1.,0.,3.,1.,1.5,3.,2.,0.,3.,2.,1.,3.,1.,2.,3.,0.,2.,3.,3.,1.,3.,3.,2.,3.,0.,1.,3.,2.,2.,3.,2.,1.6666666666666667,1.,1.,1.6666666666666667,1.,3.,1.6666666666666667,1.,0.,1.6666666666666667,1.,2.,1.3333333333333335,2.,1.,1.5,1.5,1.,1.3333333333333333,2.,3.,1.3333333333333335,2.,0.,1.3333333333333335,2.,1.,1.25,2.25]
8538         self.assertEqual(2,slice1.getMeshDimension());
8539         self.assertEqual(3,slice1.getSpaceDimension());
8540         self.assertEqual(60,slice1.getNumberOfNodes());
8541         self.assertEqual(9,slice1.getNumberOfCells());
8542         self.assertEqual(9,ids.getNumberOfTuples());
8543         self.assertEqual(49,slice1.getNodalConnectivity().getNumberOfTuples());
8544         self.assertEqual(10,slice1.getNodalConnectivityIndex().getNumberOfTuples());
8545         self.assertEqual(expected1,ids.getValues());
8546         self.assertEqual(expected5,slice1.getNodalConnectivity().getValues());
8547         self.assertEqual(expected6,slice1.getNodalConnectivityIndex().getValues());
8548         for i in xrange(180):
8549             self.assertAlmostEqual(expected7[i],slice1.getCoords().getIJ(0,i),12);
8550             pass
8551         # 3rd slice based on shared face of mesh3D.
8552         vec3=[0.,0.,1.]
8553         origin3=[2.5,1.,2.]
8554         slice1,ids=mesh3D.buildSlice3D(origin3,vec3,1e-10);
8555         expected8=[6,7,8,9,10,11,12,13,14,15,16,17]
8556         expected9=[5,15,26,16,18,5,16,21,28,22,19,17,5,18,20,21,16,5,21,24,25,28,5,26,16,17,19,22,23,5,22,27,29,28,5,15,26,16,18,5,16,21,28,22,19,17,5,18,20,21,16,5,21,24,25,28,5,26,16,17,19,22,23,5,22,27,29,28]
8557         expected10=[0,5,12,17,22,29,34,39,46,51,56,63,68]
8558         expected11=[0.,0.,1.,1.,1.,1.,1.,1.25,1.,1.,0.,1.,1.,1.5,1.,2.,0.,1.,2.,1.,1.,1.,2.,1.,0.,2.,1.,3.,1.,1.,3.,2.,1.,0.,1.,1.,1.,3.,1.,2.,2.,1.,2.,3.,1.,0.,0.,2.,1.,1.,2.,1.,1.25,2.,1.,0.,2.,1.,1.5,2.,2.,0.,2.,2.,1.,2.,1.,2.,2.,0.,2.,2.,3.,1.,2.,3.,2.,2.,0.,1.,2.,1.,3.,2.,2.,2.,2.,2.,3.,2.,0.,0.,3.,1.,1.,3.,1.,1.25,3.,1.,0.,3.,1.,1.5,3.,2.,0.,3.,2.,1.,3.,1.,2.,3.,0.,2.,3.,3.,1.,3.,3.,2.,3.,0.,1.,3.,1.,3.,3.,2.,2.,3.,2.,3.,3.]
8559         self.assertEqual(2,slice1.getMeshDimension());
8560         self.assertEqual(3,slice1.getSpaceDimension());
8561         self.assertEqual(45,slice1.getNumberOfNodes());
8562         self.assertEqual(12,slice1.getNumberOfCells());
8563         self.assertEqual(12,ids.getNumberOfTuples());
8564         self.assertEqual(68,slice1.getNodalConnectivity().getNumberOfTuples());
8565         self.assertEqual(13,slice1.getNodalConnectivityIndex().getNumberOfTuples());
8566         self.assertEqual(expected8,ids.getValues());
8567         self.assertEqual(expected9,slice1.getNodalConnectivity().getValues());
8568         self.assertEqual(expected10,slice1.getNodalConnectivityIndex().getValues());
8569         for i in xrange(135):
8570             self.assertAlmostEqual(expected11[i],slice1.getCoords().getIJ(0,i),12);
8571             pass
8572         pass
8573
8574     def testBuildSlice3DSurf1(self):
8575         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
8576         mesh2D=mesh3D.buildDescendingConnectivity()[0];
8577         vec1=[-0.07,1.,0.07]
8578         origin1=[1.524,1.4552,1.74768]
8579         slice1,ids=mesh2D.buildSlice3DSurf(origin1,vec1,1e-10);
8580         expected1=[6,8,10,11,13,18,19,21,23,25,26,38,41,43,47,49,52,53,64,67,69,73,75,78,79]
8581         expected2=[1,40,41,1,42,41,1,40,43,1,44,43,1,42,44,1,45,41,1,42,46,1,46,45,1,47,40,1,47,48,1,44,48,1,49,42,1,44,50,1,49,50,1,49,51,1,51,46,1,48,52,1,50,52,1,53,49,1,50,54,1,53,54,1,53,55,1,55,51,1,52,56,1,54,56]
8582         expected3=[0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48,51,54,57,60,63,66,69,72,75];
8583         expected4=[1.,1.,0.,1.,1.25,0.,1.,1.5,0.,2.,1.,0.,1.,2.,0.,0.,2.,0.,3.,1.,0.,3.,2.,0.,0.,1.,0.,2.,2.,0.,1.,1.,1.,1.,1.25,1.,1.,1.5,1.,2.,1.,1.,1.,2.,1.,0.,2.,1.,3.,1.,1.,3.,2.,1.,0.,1.,1.,2.,2.,1.,1.,1.,2.,1.,1.25,2.,1.,1.5,2.,2.,1.,2.,1.,2.,2.,0.,2.,2.,3.,1.,2.,3.,2.,2.,0.,1.,2.,2.,2.,2.,1.,1.,3.,1.,1.25,3.,1.,1.5,3.,2.,1.,3.,1.,2.,3.,0.,2.,3.,3.,1.,3.,3.,2.,3.,0.,1.,3.,2.,2.,3.,1.,1.5408576,0.,2.,1.6108576000000001,0.,2.,1.5408576,1.,1.,1.5,0.5836800000000008,1.,1.4708576,1.,3.,1.6808576,0.,3.,1.6108576000000001,1.,0.,1.4708576,0.,0.,1.4008576,1.,2.,1.4708576,2.,1.,1.4008576000000001,2.,3.,1.5408575999999998,2.,0.,1.3308575999999999,2.,2.,1.4008576,3.,1.,1.3308576,3.,3.,1.4708576,3.,0.,1.2608576,3.]
8584         self.assertEqual(1,slice1.getMeshDimension());
8585         self.assertEqual(3,slice1.getSpaceDimension());
8586         self.assertEqual(57,slice1.getNumberOfNodes());
8587         self.assertEqual(25,slice1.getNumberOfCells());
8588         self.assertEqual(25,ids.getNumberOfTuples());
8589         self.assertEqual(75,slice1.getNodalConnectivity().getNumberOfTuples());
8590         self.assertEqual(26,slice1.getNodalConnectivityIndex().getNumberOfTuples());
8591         self.assertEqual(expected1,ids.getValues());
8592         self.assertEqual(expected2,slice1.getNodalConnectivity().getValues());
8593         self.assertEqual(expected3,slice1.getNodalConnectivityIndex().getValues());
8594         for i in xrange(171):
8595             self.assertAlmostEqual(expected4[i],slice1.getCoords().getIJ(0,i),12);
8596             pass
8597         #
8598         vec2=[0.,0.,1.]
8599         origin2=[2.5,1.,2.]
8600         slice1,ids=mesh2D.buildSlice3DSurf(origin2,vec2,1e-10);
8601         expected5=[32,32,32,32,33,34,35,36,37,38,39,40,41,42,43,43,43,43,43,43,44,44,44,44,45,46,47,47,47,47,48,49,50,51,52,53,53,53,53,53,53,54,54,54,54,55,56,57,59,60,61,62,63,64,65,66,67,68,71,72,74,75,76,77,78,81,82,83]
8602         expected6=[1,15,18,1,18,16,1,16,26,1,26,15,1,26,15,1,16,26,1,18,16,1,15,18,1,16,21,1,21,28,1,22,28,1,19,22,1,17,19,1,16,17,1,16,21,1,21,28,1,28,22,1,22,19,1,19,17,1,17,16,1,16,18,1,18,20,1,20,21,1,21,16,1,20,21,1,18,20,1,28,21,1,21,24,1,24,25,1,25,28,1,25,28,1,24,25,1,21,24,1,23,22,1,26,23,1,26,16,1,16,17,1,17,19,1,19,22,1,22,23,1,23,26,1,22,28,1,28,29,1,29,27,1,27,22,1,27,22,1,29,27,1,28,29,1,26,15,1,16,26,1,18,16,1,15,18,1,16,21,1,21,28,1,22,28,1,19,22,1,17,19,1,16,17,1,20,21,1,18,20,1,25,28,1,24,25,1,21,24,1,23,22,1,26,23,1,27,22,1,29,27,1,28,29]
8603         expected7=[0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48,51,54,57,60,63,66,69,72,75,78,81,84,87,90,93,96,99,102,105,108,111,114,117,120,123,126,129,132,135,138,141,144,147,150,153,156,159,162,165,168,171,174,177,180,183,186,189,192,195,198,201,204];
8604         expected8=[0.,0.,1.,1.,1.,1.,1.,1.25, 1.,1.,0.,1.,1.,1.5, 1.,2.,0.,1.,2.,1.,1.,1.,2.,1.,0.,2.,1.,3.,1.,1.,3.,2.,1.,0.,1.,1.,1.,3.,1.,2.,2.,1.,2.,3.,1.,0.,0.,2.,1.,1.,2.,1.,1.25, 2.,1.,0.,2.,1.,1.5, 2.,2.,0.,2.,2.,1.,2.,1.,2.,2.,0.,2.,2.,3.,1.,2.,3.,2.,2.,0.,1.,2.,1.,3.,2.,2.,2.,2.,2.,3.,2.,0.,0.,3.,1.,1.,3.,1.,1.25, 3.,1.,0.,3.,1.,1.5, 3.,2.,0.,3.,2.,1.,3.,1.,2.,3.,0.,2.,3.,3.,1.,3.,3.,2.,3.,0.,1.,3.,1.,3.,3.,2.,2.,3.,2.,3.,3.]
8605         self.assertEqual(1,slice1.getMeshDimension());
8606         self.assertEqual(3,slice1.getSpaceDimension());
8607         self.assertEqual(45,slice1.getNumberOfNodes());
8608         self.assertEqual(68,slice1.getNumberOfCells());
8609         self.assertEqual(68,ids.getNumberOfTuples());
8610         self.assertEqual(204,slice1.getNodalConnectivity().getNumberOfTuples());
8611         self.assertEqual(69,slice1.getNodalConnectivityIndex().getNumberOfTuples());
8612         self.assertEqual(expected5,ids.getValues());
8613         self.assertEqual(expected6,slice1.getNodalConnectivity().getValues());
8614         self.assertEqual(expected7,slice1.getNodalConnectivityIndex().getValues());
8615         for i in xrange(135):
8616             self.assertAlmostEqual(expected8[i],slice1.getCoords().getIJ(0,i),12);
8617             pass
8618         pass
8619
8620     def testDataArrayDoubleAdvSetting1(self):
8621         data1=[1.,11.,2.,12.,3.,13.,4.,14.,5.,15.,6.,16.,7.,17.]
8622         data2=[8.,38.,9.,39.,0.,30.,11.,41.,12.,42.]
8623         compsCpp=["comp1","comp2"]
8624         da=DataArrayDouble.New();
8625         da.setInfoAndChangeNbOfCompo(compsCpp);
8626         da.setName("da");
8627         da.alloc(7,2);
8628         compsCpp=compsCpp[:-1]
8629         self.assertRaises(InterpKernelException,da.setInfoAndChangeNbOfCompo,compsCpp);
8630         da.setValues(data1,7,2)
8631         #
8632         p=[(0,3),(3,5),(5,7)]
8633         tmp=da.selectByTupleRanges(p);
8634         self.assertTrue(tmp.isEqual(da,1e-14));
8635         p=[(0,2),(3,4),(5,7)]
8636         tmp=da.selectByTupleRanges(p);
8637         expected1=[1.,11.,2.,12.,4.,14.,6.,16.,7.,17.]
8638         self.assertEqual(5,tmp.getNumberOfTuples());
8639         self.assertEqual(2,tmp.getNumberOfComponents());
8640         for i in xrange(10):
8641             self.assertAlmostEqual(expected1[i],tmp.getIJ(0,i),14);
8642             pass
8643         p=[(0,2),(0,2),(5,6)]
8644         tmp=da.selectByTupleRanges(p);
8645         expected2=[1.,11.,2.,12.,1.,11.,2.,12.,6.,16.]
8646         self.assertEqual(5,tmp.getNumberOfTuples());
8647         self.assertEqual(2,tmp.getNumberOfComponents());
8648         for i in xrange(10):
8649             self.assertAlmostEqual(expected2[i],tmp.getIJ(0,i),14);
8650             pass
8651         p=[(0,2),(-1,2),(5,6)]
8652         self.assertRaises(InterpKernelException,da.selectByTupleRanges,p);
8653         p=[(0,2),(0,2),(5,8)]
8654         self.assertRaises(InterpKernelException,da.selectByTupleRanges,p);
8655         #
8656         da2=DataArrayDouble.New();
8657         da2.setValues(data2,5,2);
8658         #
8659         dac=da.deepCpy();
8660         dac.setContigPartOfSelectedValues2(1,da2,2,4,1);
8661         expected3=[1.,11.,0.,30.,11.,41.,4.,14.,5.,15.,6.,16.,7.,17.]
8662         for i in xrange(14):
8663             self.assertAlmostEqual(expected3[i],dac.getIJ(0,i),14);
8664             pass
8665         #
8666         dac=da.deepCpy();
8667         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,3,da2,0,5,1);
8668         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,0,da2,4,6,1);
8669         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,3,da2,5,0,1);
8670         dac.setContigPartOfSelectedValues2(3,da2,1,5,1);
8671         expected4=[1.,11.,2.,12.,3.,13.,9.,39.,0.,30.,11.,41.,12.,42.]
8672         for i in xrange(14):
8673             self.assertAlmostEqual(expected4[i],dac.getIJ(0,i),14);
8674             pass
8675         #
8676         ids=DataArrayInt.New();
8677         ids.alloc(3,1);
8678         dac=da.deepCpy();
8679         ids.setIJ(0,0,2); ids.setIJ(1,0,0); ids.setIJ(2,0,4);
8680         dac.setContigPartOfSelectedValues(2,da2,ids);
8681         expected5=[1.,11.,2.,12.,0.,30.,8.,38.,12.,42.,6.,16.,7.,17.]
8682         for i in xrange(14):
8683             self.assertAlmostEqual(expected5[i],dac.getIJ(0,i),14);
8684             pass
8685         #
8686         dac=da.deepCpy();
8687         ids.setIJ(0,0,2); ids.setIJ(1,0,5); ids.setIJ(2,0,4);
8688         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,1,da2,ids);
8689         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,-1);
8690         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,1,da2,ids);
8691         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,1);
8692         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,5,da2,ids);
8693         #
8694         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,1);
8695         dac=da.deepCpy();
8696         dac.setContigPartOfSelectedValues(4,da2,ids);
8697         expected6=[1.,11.,2.,12.,3.,13.,4.,14.,0.,30.,0.,30.,9.,39.]
8698         for i in xrange(14):
8699             self.assertAlmostEqual(expected6[i],dac.getIJ(0,i),14);
8700             pass
8701         pass
8702
8703     def testDataArrayIntAdvSetting1(self):
8704         data1=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
8705         data2=[8,38,9,39,0,30,11,41,12,42]
8706         compsCpp=["comp1","comp2"]
8707         da=DataArrayInt.New();
8708         da.setInfoAndChangeNbOfCompo(compsCpp);
8709         da.setName("da");
8710         da.alloc(7,2);
8711         compsCpp=compsCpp[:-1]
8712         self.assertRaises(InterpKernelException,da.setInfoAndChangeNbOfCompo,compsCpp);
8713         da.setValues(data1,7,2)
8714         #
8715         p=[(0,3),(3,5),(5,7)]
8716         tmp=da.selectByTupleRanges(p);
8717         self.assertTrue(tmp.isEqual(da));
8718         p=[(0,2),(3,4),(5,7)]
8719         tmp=da.selectByTupleRanges(p);
8720         expected1=[1,11,2,12,4,14,6,16,7,17]
8721         self.assertEqual(5,tmp.getNumberOfTuples());
8722         self.assertEqual(2,tmp.getNumberOfComponents());
8723         for i in xrange(10):
8724             self.assertEqual(expected1[i],tmp.getIJ(0,i));
8725             pass
8726         p=[(0,2),(0,2),(5,6)]
8727         tmp=da.selectByTupleRanges(p);
8728         expected2=[1,11,2,12,1,11,2,12,6,16]
8729         self.assertEqual(5,tmp.getNumberOfTuples());
8730         self.assertEqual(2,tmp.getNumberOfComponents());
8731         for i in xrange(10):
8732             self.assertEqual(expected2[i],tmp.getIJ(0,i));
8733             pass
8734         p=[(0,2),(-1,2),(5,6)]
8735         self.assertRaises(InterpKernelException,da.selectByTupleRanges,p);
8736         p=[(0,2),(0,2),(5,8)]
8737         self.assertRaises(InterpKernelException,da.selectByTupleRanges,p);
8738         #
8739         da2=DataArrayInt.New();
8740         da2.setValues(data2,5,2);
8741         #
8742         dac=da.deepCpy();
8743         dac.setContigPartOfSelectedValues2(1,da2,2,4,1);
8744         expected3=[1,11,0,30,11,41,4,14,5,15,6,16,7,17]
8745         for i in xrange(14):
8746             self.assertEqual(expected3[i],dac.getIJ(0,i));
8747             pass
8748         #
8749         dac=da.deepCpy();
8750         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,3,da2,0,5,1);
8751         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,0,da2,4,6,1);
8752         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,3,da2,5,0,1);
8753         dac.setContigPartOfSelectedValues2(3,da2,1,5,1);
8754         expected4=[1,11,2,12,3,13,9,39,0,30,11,41,12,42]
8755         for i in xrange(14):
8756             self.assertEqual(expected4[i],dac.getIJ(0,i));
8757             pass
8758         #
8759         ids=DataArrayInt.New();
8760         ids.alloc(3,1);
8761         dac=da.deepCpy();
8762         ids.setIJ(0,0,2); ids.setIJ(1,0,0); ids.setIJ(2,0,4);
8763         dac.setContigPartOfSelectedValues(2,da2,ids);
8764         expected5=[1,11,2,12,0,30,8,38,12,42,6,16,7,17]
8765         for i in xrange(14):
8766             self.assertEqual(expected5[i],dac.getIJ(0,i));
8767             pass
8768         #
8769         dac=da.deepCpy();
8770         ids.setIJ(0,0,2); ids.setIJ(1,0,5); ids.setIJ(2,0,4);
8771         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,1,da2,ids);
8772         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,-1);
8773         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,1,da2,ids);
8774         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,1);
8775         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,5,da2,ids);
8776         #
8777         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,1);
8778         dac=da.deepCpy();
8779         dac.setContigPartOfSelectedValues(4,da2,ids);
8780         expected6=[1,11,2,12,3,13,4,14,0,30,0,30,9,39]
8781         for i in xrange(14):
8782             self.assertEqual(expected6[i],dac.getIJ(0,i));
8783             pass
8784         pass
8785
8786     def testBuildDescendingConnec2Of3DMesh1(self):
8787         mesh=MEDCouplingDataForTest.build3DSourceMesh_1();
8788         #
8789         mesh2,desc,descIndx,revDesc,revDescIndx=mesh.buildDescendingConnectivity2();
8790         mesh2.checkCoherency();
8791         self.assertEqual(2,mesh2.getMeshDimension());
8792         self.assertEqual(30,mesh2.getNumberOfCells());
8793         self.assertEqual(31,revDescIndx.getNbOfElems()); self.assertEqual(31,revDescIndx.getNumberOfTuples());
8794         self.assertEqual(13,descIndx.getNbOfElems()); self.assertEqual(13,descIndx.getNumberOfTuples());
8795         self.assertEqual(48,desc.getNbOfElems()); self.assertEqual(48,desc.getNumberOfTuples());
8796         self.assertEqual(48,revDesc.getNbOfElems()); self.assertEqual(48,revDesc.getNumberOfTuples());
8797         expected1=[1,2,3,4,5,6,7,8,9,10,11,12,13,14,-10,15,-5,-13,16,17,-14,18,-4,19,-2,20,21,22,23,24,25,-11,26,-1,-12,-25,-22,27,28,-7,-20,-24,29,-16,-18,30,-8,-28]
8798         self.assertEqual(expected1,desc.getValues());
8799         expected2=[0,4,8,12,16,20,24,28,32,36,40,44,48]
8800         self.assertEqual(expected2,descIndx.getValues());
8801         expected3=[0,2,4,5,7,9,10,12,14,15,17,19,21,23,25,26,28,29,31,32,34,35,37,38,40,42,43,44,46,47,48]
8802         self.assertEqual(expected3,revDescIndx.getValues());
8803         expected4=[0,8,0,6,0,0,5,1,4,1,1,9,1,11,2,2,3,2,7,2,8,3,4,3,5,3,4,10,4,5,11,5,6,10,6,6,9,7,7,10,7,8,8,9,9,11,10,11]
8804         self.assertEqual(expected4,revDesc.getValues());
8805         conn=mesh2.getNodalConnectivity();
8806         connIndex=mesh2.getNodalConnectivityIndex();
8807         expected5=[0,4,8,12,16,20,24,28,32,36,40,44,48,52,56,60,64,68,72,76,80,84,88,92,96,100,104,108,112,116,120]
8808         self.assertEqual(expected5,connIndex.getValues());
8809         expected6=[3,8,1,7,3,8,3,1,3,1,3,7,3,7,3,8,3,6,0,8,3,6,2,0,3,0,2,8,3,8,2,6,3,7,4,5,3,7,8,4,3,4,8,5,3,5,8,7,3,6,8,4,3,6,7,8,3,4,7,6,3,8,4,0,3,0,4,6,3,6,3,8,3,7,3,6,3,8,0,1,3,1,0,3,3,3,0,8,3,4,1,5,3,4,8,1,3,1,8,5,3,1,7,5,3,0,2,3,3,3,2,8,3,1,4,0,3,3,2,6]
8810         self.assertEqual(expected6,conn.getValues());
8811         pass
8812
8813     def testAre2DCellsNotCorrectlyOriented1(self):
8814         m1Coords=[1.,1.,-1.,-1.,-1.,-1.,1.,-1.]
8815         m1Conn=[0,3,1,2]
8816         m1=MEDCouplingUMesh.New();
8817         m1.setMeshDimension(2);
8818         m1.allocateCells(1);
8819         m1.insertNextCell(NORM_QUAD4,4,m1Conn[0:4])
8820         m1.finishInsertingCells();
8821         myCoords1=DataArrayDouble.New();
8822         myCoords1.setValues(m1Coords,4,2);
8823         m1.setCoords(myCoords1);
8824         #
8825         vec1=[0.,0.,1.]
8826         for i in xrange(18):
8827             vec2=[3.*cos(pi/9.*i),3.*sin(pi/9.*i)];
8828             m1Cpy=m1.deepCpy();
8829             m1Cpy.translate(vec2);
8830             self.assertRaises(InterpKernelException,m1Cpy.are2DCellsNotCorrectlyOriented,vec1,False);
8831             m1Cpy.changeSpaceDimension(3);
8832             res=m1Cpy.are2DCellsNotCorrectlyOriented(vec1,False)
8833             self.assertEqual([0],res.getValues());
8834             pass
8835         pass
8836
8837     def testDataArrayAbs1(self):
8838         d1=DataArrayDouble.New();
8839         val1=[2.,-3.,-5.,6.,-7.,-8.,9.,10.,-11.,-12.,-13.,-15.]
8840         expected1=[2.,3.,5.,6.,7.,8.,9.,10.,11.,12.,13.,15.]
8841         d1.setValues(val1,6,2);
8842         d2=d1.convertToIntArr();
8843         #
8844         d1.abs();
8845         for i in xrange(12):
8846             self.assertAlmostEqual(expected1[i],d1.getIJ(0,i),14);
8847             pass
8848         #
8849         expected2=[2,3,5,6,7,8,9,10,11,12,13,15]
8850         d2.abs();
8851         for i in xrange(12):
8852             self.assertEqual(expected2[i],d2.getIJ(0,i));
8853             pass
8854         #
8855         pass
8856
8857     # test on 1D
8858     def testGetValueOn3(self):
8859         v=[0.,1.,1.5,2.]
8860         v2=[0.7,1.25,0.,2.,1.5]
8861         disp=[5.,50.,500.,6.,60.,600.,7.,70.,700.,8.,80.,800.]
8862         m=MEDCouplingUMesh.New("myMesh",1)
8863         nbNodes=len(v)
8864         nbCells=nbNodes-1
8865         m.allocateCells(nbCells)
8866         coords=DataArrayDouble.New() ; coords.setValues(v,nbNodes,1)
8867         m.setCoords(coords)
8868         m.insertNextCell(NORM_SEG2,2,[0,1])
8869         m.insertNextCell(NORM_SEG2,2,[2,1])
8870         m.insertNextCell(NORM_SEG2,2,[2,3])
8871         m.finishInsertingCells()
8872         f=MEDCouplingFieldDouble.New(ON_NODES)
8873         f.setMesh(m)
8874         array=DataArrayDouble.New(); array.setValues(disp,m.getNumberOfNodes(),3)
8875         f.setArray(array)
8876         arr1=f.getValueOnMulti(v2)
8877         self.assertEqual(5,arr1.getNumberOfTuples());
8878         self.assertEqual(3,arr1.getNumberOfComponents());
8879         expected1=[5.7,57.,570.,6.5,65.,650.,5.,50.,500.,8.,80.,800.,7.,70.,700.]
8880         for i in xrange(15):
8881             self.assertAlmostEqual(expected1[i],arr1.getIJ(0,i),14);
8882             pass
8883         pass
8884
8885     def testGetNodeIdsOfCell2(self):
8886         m1c=MEDCouplingCMesh.New();
8887         coordsX=DataArrayDouble.New();
8888         arrX=[ -1., 1., 2., 4., 4.5 ]
8889         coordsX.setValues(arrX,5,1);
8890         coordsY=DataArrayDouble.New();
8891         arrY=[ -2., 2., 4., 8.]
8892         coordsY.setValues(arrY,4,1);
8893         coordsZ=DataArrayDouble.New();
8894         arrZ=[ -2., 2., 4.]
8895         coordsZ.setValues(arrZ,3,1);
8896         # test in 1D
8897         m1c.setCoordsAt(0,coordsX);
8898         expected1=[[0,1],[1,2],[2,3],[3,4]]
8899         self.assertEqual(4,m1c.getNumberOfCells())
8900         for i in xrange(m1c.getNumberOfCells()):
8901             self.assertEqual(expected1[i],m1c.getNodeIdsOfCell(i))
8902             pass
8903         # test in 2D
8904         m1c.setCoordsAt(1,coordsY);
8905         self.assertEqual(12,m1c.getNumberOfCells())
8906         expected2=[[0,1,6,5],[1,2,7,6],[2,3,8,7],[3,4,9,8],[4,5,11,10],[5,6,12,11],[6,7,13,12],[7,8,14,13],[8,9,16,15],[9,10,17,16],[10,11,18,17],[11,12,19,18]]
8907         for i in xrange(m1c.getNumberOfCells()):
8908             self.assertEqual(expected2[i],m1c.getNodeIdsOfCell(i))
8909             pass
8910         # test in 3D
8911         m1c.setCoordsAt(2,coordsZ);
8912         expected3=[[0,1,6,5,20,21,26,25],[1,2,7,6,21,22,27,26],[2,3,8,7,22,23,28,27],[3,4,9,8,23,24,29,28],[4,5,11,10,24,25,31,30],[5,6,12,11,25,26,32,31],[6,7,13,12,26,27,33,32],[7,8,14,13,27,28,34,33],[8,9,16,15,28,29,36,35],[9,10,17,16,29,30,37,36],[10,11,18,17,30,31,38,37],[11,12,19,18,31,32,39,38],[20,21,26,25,40,41,46,45],[21,22,27,26,41,42,47,46],[22,23,28,27,42,43,48,47],[23,24,29,28,43,44,49,48],[24,25,31,30,44,45,51,50],[25,26,32,31,45,46,52,51],[26,27,33,32,46,47,53,52],[27,28,34,33,47,48,54,53],[28,29,36,35,48,49,56,55],[29,30,37,36,49,50,57,56],[30,31,38,37,50,51,58,57],[31,32,39,38,51,52,59,58]]
8913         self.assertEqual(24,m1c.getNumberOfCells())
8914         for i in xrange(m1c.getNumberOfCells()):
8915             self.assertEqual(expected3[i],m1c.getNodeIdsOfCell(i))
8916             pass
8917         pass
8918     
8919     def testSwigDADOp4(self):
8920         da=DataArrayDouble.New(range(6,30),12,2)
8921         self.assertEqual(12,da.getNumberOfTuples());
8922         self.assertEqual(2,da.getNumberOfComponents());
8923         for i in xrange(24):
8924             self.assertAlmostEqual(da.getIJ(0,i),float(i+6),13)
8925             pass
8926         # operator transpose
8927         da.transpose()
8928         self.assertEqual(2,da.getNumberOfTuples());
8929         self.assertEqual(12,da.getNumberOfComponents());
8930         for i in xrange(24):
8931             self.assertAlmostEqual(da.getIJ(0,i),float(i+6),13)
8932             pass
8933         da.transpose()
8934         # operator __neg__
8935         da2=DataArrayDouble.New(12,1)
8936         da2.iota(0.)
8937         dabis=-da
8938         for i in xrange(24):
8939             self.assertAlmostEqual(dabis.getIJ(0,i),-float(i+6),13)
8940             pass
8941         # operator+=
8942         da+=da2
8943         expected1=[6.,7.,9.,10.,12.,13.,15.,16.,18.,19.,21.,22.,24.,25.,27.,28.,30.,31.,33.,34.,36.,37.,39.,40.]
8944         for i in xrange(24):
8945             self.assertAlmostEqual(da.getIJ(0,i),expected1[i],13)
8946             pass
8947         da=-dabis
8948         da+=[100.,101.]
8949         expected2=[106.,108.,108.,110.,110.,112.,112.,114.,114.,116.,116.,118.,118.,120.,120.,122.,122.,124.,124.,126.,126.,128.,128.,130.]
8950         self.assertEqual(12,da.getNumberOfTuples());
8951         self.assertEqual(2,da.getNumberOfComponents());
8952         for i in xrange(24):
8953             self.assertAlmostEqual(da.getIJ(0,i),expected2[i],13)
8954             pass
8955         for pos,elt in enumerate(dabis):
8956             da[pos]+=elt
8957             pass
8958         self.assertEqual(12,da.getNumberOfTuples());
8959         self.assertEqual(2,da.getNumberOfComponents());
8960         for elt in da:
8961             li=elt[:]
8962             self.assertAlmostEqual(li[0],100.,13) ; self.assertAlmostEqual(li[1],101.,13)
8963             pass
8964         # operator-=
8965         da=DataArrayDouble.New(range(6,30),12,2)
8966         da2=DataArrayDouble.New(range(12),12,1)
8967         dabis=-da
8968         da-=da2
8969         expected1=[6.,7.,7.,8.,8.,9.,9.,10.,10.,11.,11.,12.,12.,13.,13.,14.,14.,15.,15.,16.,16.,17.,17.,18.]
8970         for i in xrange(24):
8971             self.assertAlmostEqual(da.getIJ(0,i),expected1[i],13)
8972             pass
8973         da=-dabis
8974         da-=[100.,101.]
8975         expected2=[-94.,-94.,-92.,-92.,-90.,-90.,-88.,-88.,-86.,-86.,-84.,-84.,-82.,-82.,-80.,-80.,-78.,-78.,-76.,-76.,-74.,-74.,-72.,-72.]
8976         self.assertEqual(12,da.getNumberOfTuples());
8977         self.assertEqual(2,da.getNumberOfComponents());
8978         for i in xrange(24):
8979             self.assertAlmostEqual(da.getIJ(0,i),expected2[i],13)
8980             pass
8981         for pos,elt in enumerate(dabis):
8982             da[pos]-=elt
8983             pass
8984         self.assertEqual(12,da.getNumberOfTuples());
8985         self.assertEqual(2,da.getNumberOfComponents());
8986         expected3=[-88.,-87.,-84.,-83.,-80.,-79.,-76.,-75.,-72.,-71.,-68.,-67.,-64.,-63.,-60.,-59.,-56.,-55.,-52.,-51.,-48.,-47.,-44.,-43.]
8987         for i in xrange(24):
8988             self.assertAlmostEqual(da.getIJ(0,i),expected3[i],13)
8989             pass
8990         # operator*=
8991         da=DataArrayDouble.New(range(6,30),12,2)
8992         da2=DataArrayDouble.New(range(12),12,1)
8993         dabis=-da
8994         da*=da2
8995         expected1=[0.,0.,8.,9.,20.,22.,36.,39.,56.,60.,80.,85.,108.,114.,140.,147.,176.,184.,216.,225.,260.,270.,308.,319.]
8996         for i in xrange(24):
8997             self.assertAlmostEqual(da.getIJ(0,i),expected1[i],13)
8998             pass
8999         da=-dabis
9000         da*=[100.,101.]
9001         expected2=[600.,707.,800.,909.,1000.,1111.,1200.,1313.,1400.,1515.,1600.,1717.,1800.,1919.,2000.,2121.,2200.,2323.,2400.,2525.,2600.,2727.,2800.,2929.]
9002         self.assertEqual(12,da.getNumberOfTuples());
9003         self.assertEqual(2,da.getNumberOfComponents());
9004         for i in xrange(24):
9005             self.assertAlmostEqual(da.getIJ(0,i),expected2[i],13)
9006             pass
9007         for pos,elt in enumerate(dabis):
9008             da[pos]*=elt
9009             pass
9010         self.assertEqual(12,da.getNumberOfTuples());
9011         self.assertEqual(2,da.getNumberOfComponents());
9012         expected3=[-3600.,-4949.,-6400.,-8181.,-10000.,-12221.,-14400.,-17069.,-19600.,-22725.,-25600.,-29189.,-32400.,-36461.,-40000.,-44541.,-48400.,-53429.,-57600.,-63125.,-67600.,-73629.,-78400.,-84941.0]
9013         for i in xrange(24):
9014             self.assertAlmostEqual(da.getIJ(0,i),expected3[i],13)
9015             pass
9016         # operator/=
9017         da=DataArrayDouble.New(range(6,30),12,2)
9018         da2=DataArrayDouble.New(range(1,13),12,1)
9019         dabis=-da
9020         da/=da2
9021         expected1=[6.0,7.0,4.0,4.5,3.3333333333333335,3.6666666666666665,3.0,3.25,2.8,3.0,2.6666666666666665,2.8333333333333335,2.5714285714285716,2.7142857142857144,2.5,2.625,2.4444444444444446,2.5555555555555554,2.4,2.5,2.3636363636363638,2.4545454545454546,2.3333333333333335,2.4166666666666665]
9022         for i in xrange(24):
9023             self.assertAlmostEqual(da.getIJ(0,i),expected1[i],13)
9024             pass
9025         da=-dabis
9026         da/=[100.,101.]
9027         expected2=[0.06,0.06930693069306931,0.08,0.0891089108910891,0.1,0.10891089108910891,0.12,0.12871287128712872,0.14,0.1485148514851485,0.16,0.16831683168316833,0.18,0.18811881188118812,0.2,0.2079207920792079,0.22,0.22772277227722773,0.24,0.24752475247524752,0.26,0.26732673267326734,0.28,0.2871287128712871]
9028         self.assertEqual(12,da.getNumberOfTuples());
9029         self.assertEqual(2,da.getNumberOfComponents());
9030         for i in xrange(24):
9031             self.assertAlmostEqual(da.getIJ(0,i),expected2[i],13)
9032             pass
9033         for pos,elt in enumerate(dabis):
9034             da[pos]/=elt
9035             pass
9036         self.assertEqual(12,da.getNumberOfTuples());
9037         self.assertEqual(2,da.getNumberOfComponents());
9038         expected3=[-0.01, -0.009900990099009901, -0.01, -0.009900990099009901, -0.01, -0.009900990099009901, -0.01, -0.009900990099009901, -0.01, -0.009900990099009901, -0.01, -0.009900990099009901, -0.01, -0.009900990099009901, -0.01, -0.009900990099009901, -0.01, -0.009900990099009901, -0.01, -0.009900990099009901, -0.01, -0.009900990099009901, -0.01, -0.0099009900990099]
9039         for i in xrange(24):
9040             self.assertAlmostEqual(da.getIJ(0,i),expected3[i],13)
9041             pass
9042         pass
9043
9044     def testSwigDAIOp4(self):
9045         da=DataArrayInt.New(range(6,30),12,2)
9046         self.assertEqual(12,da.getNumberOfTuples());
9047         self.assertEqual(2,da.getNumberOfComponents());
9048         for i in xrange(24):
9049             self.assertEqual(da.getIJ(0,i),i+6)
9050             pass
9051         # operator transpose
9052         da.transpose()
9053         self.assertEqual(2,da.getNumberOfTuples());
9054         self.assertEqual(12,da.getNumberOfComponents());
9055         for i in xrange(24):
9056             self.assertEqual(da.getIJ(0,i),i+6)
9057             pass
9058         da.transpose()
9059         # operator __neg__
9060         da2=DataArrayInt.New(12,1)
9061         da2.iota(0)
9062         dabis=-da
9063         for i in xrange(24):
9064             self.assertEqual(dabis.getIJ(0,i),-(i+6))
9065             pass
9066         # operator+=
9067         da+=da2
9068         expected1=[6,7,9,10,12,13,15,16,18,19,21,22,24,25,27,28,30,31,33,34,36,37,39,40]
9069         for i in xrange(24):
9070             self.assertEqual(da.getIJ(0,i),expected1[i])
9071             pass
9072         da=-dabis
9073         da+=[100,101]
9074         expected2=[106,108,108,110,110,112,112,114,114,116,116,118,118,120,120,122,122,124,124,126,126,128,128,130]
9075         self.assertEqual(12,da.getNumberOfTuples());
9076         self.assertEqual(2,da.getNumberOfComponents());
9077         for i in xrange(24):
9078             self.assertEqual(da.getIJ(0,i),expected2[i])
9079             pass
9080         for pos,elt in enumerate(dabis):
9081             da[pos]+=elt
9082             pass
9083         self.assertEqual(12,da.getNumberOfTuples());
9084         self.assertEqual(2,da.getNumberOfComponents());
9085         for elt in da:
9086             li=elt[:]
9087             self.assertEqual(li[0],100) ; self.assertEqual(li[1],101)
9088             pass
9089         # operator-=
9090         da=DataArrayInt.New(range(6,30),12,2)
9091         da2=DataArrayInt.New(range(12),12,1)
9092         dabis=-da
9093         da-=da2
9094         expected1=[6,7,7,8,8,9,9,10,10,11,11,12,12,13,13,14,14,15,15,16,16,17,17,18]
9095         for i in xrange(24):
9096             self.assertEqual(da.getIJ(0,i),expected1[i])
9097             pass
9098         da=-dabis
9099         da-=[100,101]
9100         expected2=[-94,-94,-92,-92,-90,-90,-88,-88,-86,-86,-84,-84,-82,-82,-80,-80,-78,-78,-76,-76,-74,-74,-72,-72]
9101         self.assertEqual(12,da.getNumberOfTuples());
9102         self.assertEqual(2,da.getNumberOfComponents());
9103         for i in xrange(24):
9104             self.assertEqual(da.getIJ(0,i),expected2[i])
9105             pass
9106         for pos,elt in enumerate(dabis):
9107             da[pos]-=elt
9108             pass
9109         self.assertEqual(12,da.getNumberOfTuples());
9110         self.assertEqual(2,da.getNumberOfComponents());
9111         expected3=[-88,-87,-84,-83,-80,-79,-76,-75,-72,-71,-68,-67,-64,-63,-60,-59,-56,-55,-52,-51,-48,-47,-44,-43]
9112         for i in xrange(24):
9113             self.assertEqual(da.getIJ(0,i),expected3[i])
9114             pass
9115         # operator*=
9116         da=DataArrayInt.New(range(6,30),12,2)
9117         da2=DataArrayInt.New(range(12),12,1)
9118         dabis=-da
9119         da*=da2
9120         expected1=[0,0,8,9,20,22,36,39,56,60,80,85,108,114,140,147,176,184,216,225,260,270,308,319]
9121         for i in xrange(24):
9122             self.assertEqual(da.getIJ(0,i),expected1[i])
9123             pass
9124         da=-dabis
9125         da*=[100,101]
9126         expected2=[600,707,800,909,1000,1111,1200,1313,1400,1515,1600,1717,1800,1919,2000,2121,2200,2323,2400,2525,2600,2727,2800,2929]
9127         self.assertEqual(12,da.getNumberOfTuples());
9128         self.assertEqual(2,da.getNumberOfComponents());
9129         for i in xrange(24):
9130             self.assertEqual(da.getIJ(0,i),expected2[i])
9131             pass
9132         for pos,elt in enumerate(dabis):
9133             da[pos]*=elt
9134             pass
9135         self.assertEqual(12,da.getNumberOfTuples());
9136         self.assertEqual(2,da.getNumberOfComponents());
9137         expected3=[-3600,-4949,-6400,-8181,-10000,-12221,-14400,-17069,-19600,-22725,-25600,-29189,-32400,-36461,-40000,-44541,-48400,-53429,-57600,-63125,-67600,-73629,-78400,-84941.0]
9138         for i in xrange(24):
9139             self.assertEqual(da.getIJ(0,i),expected3[i])
9140             pass
9141         # operator/=
9142         da=DataArrayInt.New(range(6,30),12,2)
9143         da2=DataArrayInt.New(range(1,13),12,1)
9144         dabis=-da
9145         da/=da2
9146         expected1=[6,7,4,4,3,3,3,3,2,3,2,2,2,2,2,2,2,2,2,2,2,2,2,2]
9147         for i in xrange(24):
9148             self.assertEqual(da.getIJ(0,i),expected1[i])
9149             pass
9150         da=-dabis
9151         da/=DataArrayInt.New([2,3],1,2)
9152         self.assertEqual(12,da.getNumberOfTuples());
9153         self.assertEqual(2,da.getNumberOfComponents());
9154         expected2=[3,2,4,3,5,3,6,4,7,5,8,5,9,6,10,7,11,7,12,8,13,9,14,9]
9155         for i in xrange(24):
9156             self.assertEqual(da.getIJ(0,i),expected2[i])
9157             pass
9158         pass
9159
9160     def testSwigDADOp5(self):
9161         da=DataArrayDouble.New([5,6,7,8,9,6,7,-2,3,9,8,10])
9162         da.rearrange(3)
9163         da2=DataArrayDouble.New([5.,8.,10.,12])
9164         self.assertEqual(4,da2.getNumberOfTuples());
9165         self.assertEqual(1,da2.getNumberOfComponents());
9166         da3=da+da2
9167         self.assertEqual(4,da3.getNumberOfTuples());
9168         self.assertEqual(3,da3.getNumberOfComponents());
9169         expected1=[10.,11.,12.,16.,17.,14.,17.,8.,13.,21.,20.,22.]
9170         for i in xrange(12):
9171             self.assertAlmostEqual(da3.getIJ(0,i),expected1[i],13)
9172             pass
9173         da3=da2+da
9174         self.assertEqual(4,da3.getNumberOfTuples());
9175         self.assertEqual(3,da3.getNumberOfComponents());
9176         for i in xrange(12):
9177             self.assertAlmostEqual(da3.getIJ(0,i),expected1[i],13)
9178             pass
9179         # Test new API of classmethod DataArrayDouble.New
9180         vals=[5,6,7,8,9,6,7,-2,3,9,8,10]
9181         da=DataArrayDouble.New(vals)
9182         self.assertEqual(12,da.getNumberOfTuples());
9183         self.assertEqual(1,da.getNumberOfComponents());
9184         for i in xrange(12):
9185             self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
9186             pass
9187         da=DataArrayDouble.New(vals,12)
9188         self.assertEqual(12,da.getNumberOfTuples());
9189         self.assertEqual(1,da.getNumberOfComponents());
9190         for i in xrange(12):
9191             self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
9192             pass
9193         da=DataArrayDouble.New(vals,1,12)
9194         self.assertEqual(1,da.getNumberOfTuples());
9195         self.assertEqual(12,da.getNumberOfComponents());
9196         for i in xrange(12):
9197             self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
9198             pass
9199         da=DataArrayDouble.New(vals,6,2)
9200         self.assertEqual(6,da.getNumberOfTuples());
9201         self.assertEqual(2,da.getNumberOfComponents());
9202         for i in xrange(12):
9203             self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
9204             pass
9205         da=DataArrayDouble.New(vals,4,3)
9206         self.assertEqual(4,da.getNumberOfTuples());
9207         self.assertEqual(3,da.getNumberOfComponents());
9208         for i in xrange(12):
9209             self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
9210             pass
9211         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,11);
9212         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,13);
9213         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,5,2);
9214         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,7,2);
9215         pass
9216
9217     def testSwigDADOp6(self):
9218         da=DataArrayInt.New([5,6,7,8,9,6,7,-2,3,9,8,10])
9219         da.rearrange(3)
9220         da2=DataArrayInt.New([5,8,10,12])
9221         self.assertEqual(4,da2.getNumberOfTuples());
9222         self.assertEqual(1,da2.getNumberOfComponents());
9223         da3=da+da2
9224         self.assertEqual(4,da3.getNumberOfTuples());
9225         self.assertEqual(3,da3.getNumberOfComponents());
9226         expected1=[10,11,12,16,17,14,17,8,13,21,20,22]
9227         for i in xrange(12):
9228             self.assertEqual(da3.getIJ(0,i),expected1[i])
9229             pass
9230         da3=da2+da
9231         self.assertEqual(4,da3.getNumberOfTuples());
9232         self.assertEqual(3,da3.getNumberOfComponents());
9233         for i in xrange(12):
9234             self.assertEqual(da3.getIJ(0,i),expected1[i])
9235             pass
9236         da3=da+DataArrayInt.New(da2.getValues())
9237         # Test new API of classmethod DataArrayInt.New
9238         vals=[5,6,7,8,9,6,7,-2,3,9,8,10]
9239         da=DataArrayDouble.New(vals)
9240         self.assertEqual(12,da.getNumberOfTuples());
9241         self.assertEqual(1,da.getNumberOfComponents());
9242         for i in xrange(12):
9243             self.assertEqual(da.getIJ(0,i),vals[i])
9244             pass
9245         da=DataArrayDouble.New(vals,12)
9246         self.assertEqual(12,da.getNumberOfTuples());
9247         self.assertEqual(1,da.getNumberOfComponents());
9248         for i in xrange(12):
9249             self.assertEqual(da.getIJ(0,i),vals[i])
9250             pass
9251         da=DataArrayDouble.New(vals,1,12)
9252         self.assertEqual(1,da.getNumberOfTuples());
9253         self.assertEqual(12,da.getNumberOfComponents());
9254         for i in xrange(12):
9255             self.assertEqual(da.getIJ(0,i),vals[i])
9256             pass
9257         da=DataArrayDouble.New(vals,6,2)
9258         self.assertEqual(6,da.getNumberOfTuples());
9259         self.assertEqual(2,da.getNumberOfComponents());
9260         for i in xrange(12):
9261             self.assertEqual(da.getIJ(0,i),vals[i])
9262             pass
9263         da=DataArrayDouble.New(vals,4,3)
9264         self.assertEqual(4,da.getNumberOfTuples());
9265         self.assertEqual(3,da.getNumberOfComponents());
9266         for i in xrange(12):
9267             self.assertEqual(da.getIJ(0,i),vals[i])
9268             pass
9269         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,11);
9270         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,13);
9271         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,5,2);
9272         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,7,2);
9273         pass
9274
9275     def testSwigDADOp9(self):
9276         l1=[(1.,2.,3),(4.,5.,6.),(7.,8.,9.),[10.,11.,12.]]
9277         da1=DataArrayDouble(l1,4,3)
9278         self.assertEqual(4,da1.getNumberOfTuples());
9279         self.assertEqual(3,da1.getNumberOfComponents());
9280         da2=DataArrayDouble(12) ; da2.iota(1.) ; da2.rearrange(3)
9281         self.assertTrue(da2.isEqual(da1,1e-12))
9282         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,3,4);
9283         da3=DataArrayDouble(l1,4)
9284         self.assertTrue(da3.isEqual(da1,1e-12))
9285         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,3);
9286         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,5);
9287         l1=[(1.,2.,3),(4.,(5.),((6.))),(7.,8.,9.),[10.,11.,12.]]
9288         da1=DataArrayDouble(l1,4,3)
9289         self.assertEqual(4,da1.getNumberOfTuples());
9290         self.assertEqual(3,da1.getNumberOfComponents());
9291         da2=DataArrayDouble(12) ; da2.iota(1.) ; da2.rearrange(3)
9292         self.assertTrue(da2.isEqual(da1,1e-12))
9293         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,3,4);
9294         da3=DataArrayDouble(l1,4)
9295         self.assertTrue(da3.isEqual(da1,1e-12))
9296         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,3);
9297         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,5);
9298         #
9299         l1=[(1,2,3),(4,5,6),(7,8,9),[10,11,12]]
9300         da1=DataArrayInt(l1,4,3)
9301         self.assertEqual(4,da1.getNumberOfTuples());
9302         self.assertEqual(3,da1.getNumberOfComponents());
9303         da2=DataArrayInt(12) ; da2.iota(1) ; da2.rearrange(3)
9304         self.assertTrue(da2.isEqual(da1))
9305         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,3,4);
9306         da3=DataArrayInt(l1,4)
9307         self.assertTrue(da3.isEqual(da1))
9308         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,3);
9309         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,5);
9310         l1=[(1,[2],3),(4,[(5)],6),((([7])),8,9),[10,11,12]]
9311         da1=DataArrayInt(l1,4,3)
9312         self.assertEqual(4,da1.getNumberOfTuples());
9313         self.assertEqual(3,da1.getNumberOfComponents());
9314         da2=DataArrayInt(12) ; da2.iota(1) ; da2.rearrange(3)
9315         self.assertTrue(da2.isEqual(da1))
9316         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,3,4);
9317         da3=DataArrayInt(l1,4)
9318         self.assertTrue(da3.isEqual(da1))
9319         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,3);
9320         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,5);
9321         pass
9322
9323     def testRenumberNodesInConn1(self):
9324         mesh2DCoords=[-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. ]
9325         mesh2DConn=[1,4,2, 4,5,2, 0,3,4,1, 6,7,4,3, 7,8,5,4]
9326         mesh2D=MEDCouplingUMesh.New("mesh",2);
9327         mesh2D.allocateCells(5);
9328         mesh2D.insertNextCell(NORM_TRI3,3,mesh2DConn[0:3])
9329         mesh2D.insertNextCell(NORM_TRI3,3,mesh2DConn[3:6])
9330         mesh2D.insertNextCell(NORM_QUAD4,4,mesh2DConn[6:10])
9331         mesh2D.insertNextCell(NORM_QUAD4,4,mesh2DConn[10:14])
9332         mesh2D.insertNextCell(NORM_QUAD4,4,mesh2DConn[14:18])
9333         mesh2D.finishInsertingCells();
9334         myCoords=DataArrayDouble.New(mesh2DCoords,9,3);
9335         mesh2D.setCoords(myCoords);
9336         mesh2D.checkCoherency();
9337         #
9338         mesh3DCoords=[-0.3,-0.3,0., -0.3,0.2,0., 0.2,0.2,0., 0.2,-0.3,0., -0.3,-0.3,1., -0.3,0.2,1., 0.2,0.2,1., 0.2,-0.3,1. ]
9339         mesh3DConn=[0,1,2,3,4,5,6,7]
9340         mesh3D=MEDCouplingUMesh.New("mesh",3);
9341         mesh3D.allocateCells(1);
9342         mesh3D.insertNextCell(NORM_HEXA8,8,mesh3DConn[:])
9343         mesh3D.finishInsertingCells();
9344         myCoords3D=DataArrayDouble.New(mesh3DCoords,8,3);
9345         mesh3D.setCoords(myCoords3D);
9346         mesh3D.checkCoherency();
9347         #
9348         mesh3D_2=mesh3D.deepCpy();
9349         mesh2D_2=mesh2D.deepCpy();
9350         mesh3D_4=mesh3D.deepCpy();
9351         mesh2D_4=mesh2D.deepCpy();
9352         oldNbOf3DNodes=mesh3D.getNumberOfNodes();
9353         renumNodes=DataArrayInt.New();
9354         renumNodes.alloc(mesh2D.getNumberOfNodes(),1);
9355         renumNodes.iota(oldNbOf3DNodes);
9356         coo=DataArrayDouble.Aggregate(mesh3D.getCoords(),mesh2D.getCoords());
9357         mesh3D.setCoords(coo);
9358         mesh2D.setCoords(coo);
9359         mesh2DCpy=mesh2D.deepCpy()
9360         mesh2D_3=mesh2D.deepCpy();
9361         mesh2D_3.shiftNodeNumbersInConn(oldNbOf3DNodes);
9362         mesh2D.renumberNodesInConn(renumNodes);
9363         mesh2DCpy.renumberNodesInConn(renumNodes.getValues());
9364         self.assertTrue(mesh2D.isEqual(mesh2DCpy,1e-12))
9365         self.assertTrue(mesh2D.isEqual(mesh2D_3,1e-12))
9366         #
9367         da1,da2=mesh3D.checkGeoEquivalWith(mesh3D_2,10,1e-12);
9368         self.assertTrue(da1==None);
9369         self.assertEqual(8,da2.getNumberOfTuples());
9370         self.assertEqual(1,da2.getNumberOfComponents());
9371         expected1=[8,11,12,9,4,5,6,7]
9372         for i in xrange(8):
9373             self.assertEqual(expected1[i],da2.getIJ(i,0));
9374             pass
9375         #
9376         da1,da2=mesh2D.checkGeoEquivalWith(mesh2D_2,10,1e-12);
9377         self.assertTrue(da1==None);
9378         self.assertEqual(9,da2.getNumberOfTuples());
9379         self.assertEqual(1,da2.getNumberOfComponents());
9380         for i in xrange(9):
9381             self.assertEqual(8+i,da2.getIJ(i,0));
9382             pass
9383         #
9384         mesh2D_5=mesh2D_4.deepCpy();
9385         mesh2D_5.translate([1.,0.,0.]);
9386         meshes=[mesh3D_4,mesh2D_4,mesh2D_5];
9387         MEDCouplingUMesh.PutUMeshesOnSameAggregatedCoords(meshes);
9388         self.assertTrue(mesh3D_4.getCoords().getHiddenCppPointer()==mesh2D_4.getCoords().getHiddenCppPointer());
9389         self.assertTrue(mesh2D_4.getCoords().getHiddenCppPointer()==mesh2D_5.getCoords().getHiddenCppPointer());
9390         mesh3D_4.checkCoherency(); mesh2D_4.checkCoherency(); mesh2D_5.checkCoherency();
9391         self.assertEqual(26,mesh3D_4.getNumberOfNodes());
9392         self.assertEqual(3,mesh3D_4.getSpaceDimension());
9393         self.assertEqual(9,mesh3D_4.getNodalConnectivity().getNumberOfTuples());
9394         self.assertEqual(23,mesh2D_4.getNodalConnectivity().getNumberOfTuples());
9395         self.assertEqual(23,mesh2D_5.getNodalConnectivity().getNumberOfTuples());
9396         expected2=[18,0,1,2,3,4,5,6,7]
9397         expected3=[3,9,12,10, 3,12,13,10, 4,8,11,12,9, 4,14,15,12,11, 4,15,16,13,12]
9398         expected4=[3,18,21,19, 3,21,22,19, 4,17,20,21,18, 4,23,24,21,20, 4,24,25,22,21]
9399         expected5=[-0.3,-0.3,0., -0.3,0.2,0., 0.2,0.2,0., 0.2,-0.3,0., -0.3,-0.3,1., -0.3,0.2,1., 0.2,0.2,1., 0.2,-0.3,1., -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., 0.7, -0.3, 0.0, 1.2, -0.3, 0.0, 1.7, -0.3, 0.0, 0.7, 0.2, 0.0, 1.2, 0.2, 0.0, 1.7, 0.2, 0.0, 0.7, 0.7, 0.0, 1.2, 0.7, 0.0, 1.7, 0.7, 0.0]
9400         self.assertEqual(expected2,mesh3D_4.getNodalConnectivity().getValues());
9401         self.assertEqual(expected3,mesh2D_4.getNodalConnectivity().getValues());
9402         self.assertEqual(expected4,mesh2D_5.getNodalConnectivity().getValues());
9403         for i in xrange(78):
9404             self.assertAlmostEqual(expected5[i],mesh3D_4.getCoords().getIJ(0,i),12);
9405             pass
9406         #
9407         MEDCouplingUMesh.MergeNodesOnUMeshesSharingSameCoords(meshes,1e-12);
9408         mesh3D_4.checkCoherency(); mesh2D_4.checkCoherency(); mesh2D_5.checkCoherency();
9409         self.assertTrue(mesh3D_4.getCoords().getHiddenCppPointer()==mesh2D_4.getCoords().getHiddenCppPointer());
9410         self.assertTrue(mesh2D_4.getCoords().getHiddenCppPointer()==mesh2D_5.getCoords().getHiddenCppPointer());
9411         self.assertEqual(19,mesh3D_4.getNumberOfNodes());
9412         self.assertEqual(3,mesh3D_4.getSpaceDimension());
9413         self.assertEqual(9,mesh3D_4.getNodalConnectivity().getNumberOfTuples());
9414         self.assertEqual(23,mesh2D_4.getNodalConnectivity().getNumberOfTuples());
9415         self.assertEqual(23,mesh2D_5.getNodalConnectivity().getNumberOfTuples());
9416         expected6=[18,0,1,2,3,4,5,6,7]
9417         expected7=[3,3,2,8, 3,2,9,8, 4,0,1,2,3, 4,10,11,2,1, 4,11,12,9,2]
9418         expected8=[3,13,15,14, 3,15,16,14, 4,8,9,15,13, 4,12,17,15,9, 4,17,18,16,15]
9419         expected9=[-0.3, -0.3, 0., -0.3, 0.2, 0., 0.2, 0.2, 0., 0.2, -0.3, 0., -0.3, -0.3, 1., -0.3, 0.2, 1.,
9420                     0.2, 0.2, 1., 0.2, -0.3, 1., 0.7, -0.3, 0., 0.7, 0.2, 0., -0.3, 0.7, 0., 0.2, 0.7, 0.,
9421                     0.7, 0.7, 0., 1.2, -0.3, 0., 1.7, -0.3, 0., 1.2, 0.2, 0., 1.7, 0.2, 0., 1.2, 0.7, 0., 1.7, 0.7, 0.]
9422         self.assertEqual(expected6,mesh3D_4.getNodalConnectivity().getValues());
9423         self.assertEqual(expected7,mesh2D_4.getNodalConnectivity().getValues());
9424         self.assertEqual(expected8,mesh2D_5.getNodalConnectivity().getValues());
9425         for i in xrange(57):
9426             self.assertAlmostEqual(expected9[i],mesh3D_4.getCoords().getIJ(0,i),12);
9427             pass
9428         #
9429         pass
9430     
9431     def testComputeNeighborsOfCells1(self):
9432         m=MEDCouplingDataForTest.build2DTargetMesh_1();
9433         d1,d2=m.computeNeighborsOfCells();
9434         self.assertEqual(6,d2.getNumberOfTuples());
9435         self.assertEqual(10,d1.getNumberOfTuples());
9436         expected1=[0,2,4,6,8,10]
9437         expected2=[3,1,0,2,4,1,4,0,2,3]
9438         self.assertEqual(expected1,d2.getValues());
9439         self.assertEqual(expected2,d1.getValues());
9440         pass
9441
9442     def testCheckButterflyCellsBug1(self):
9443         mesh2DCoords=[323.85,120.983748908684,317.5,131.982271536747,336.55,120.983748908686,330.2,131.982271536751,323.85,142.98079416481]
9444         mesh2DConn=[4,1,0,2,3]
9445         mesh2D=MEDCouplingUMesh.New("mesh",2);
9446         mesh2D.allocateCells(1);
9447         mesh2D.insertNextCell(NORM_POLYGON,5,mesh2DConn[0:5])
9448         mesh2D.finishInsertingCells();
9449         myCoords=DataArrayDouble.New(mesh2DCoords,5,2);
9450         mesh2D.setCoords(myCoords);
9451         mesh2D.checkCoherency();
9452         #
9453         v=mesh2D.checkButterflyCells();
9454         self.assertTrue(v.empty());
9455         pass
9456
9457     def testDataArrayIntRange1(self):
9458         d=DataArrayInt.Range(2,17,7);
9459         expected1=[2,9,16]
9460         self.assertEqual(3,d.getNumberOfTuples());
9461         self.assertEqual(1,d.getNumberOfComponents());
9462         self.assertEqual(expected1,d.getValues());
9463         #
9464         d=DataArrayInt.Range(2,23,7);
9465         self.assertEqual(3,d.getNumberOfTuples());
9466         self.assertEqual(1,d.getNumberOfComponents());
9467         self.assertEqual(expected1,d.getValues());
9468         #
9469         d=DataArrayInt.Range(2,24,7);
9470         expected2=[2,9,16,23]
9471         self.assertEqual(4,d.getNumberOfTuples());
9472         self.assertEqual(1,d.getNumberOfComponents());
9473         self.assertEqual(expected2,d.getValues());
9474         #
9475         d=DataArrayInt.Range(24,2,-7);
9476         expected3=[24,17,10,3]
9477         self.assertEqual(4,d.getNumberOfTuples());
9478         self.assertEqual(1,d.getNumberOfComponents());
9479         self.assertEqual(expected3,d.getValues());
9480         #
9481         d=DataArrayInt.Range(23,2,-7);
9482         expected4=[23,16,9]
9483         self.assertEqual(3,d.getNumberOfTuples());
9484         self.assertEqual(1,d.getNumberOfComponents());
9485         self.assertEqual(expected4,d.getValues());
9486         #
9487         d=DataArrayInt.Range(23,22,-7);
9488         self.assertEqual(1,d.getNumberOfTuples());
9489         self.assertEqual(1,d.getNumberOfComponents());
9490         self.assertEqual(23,d.getIJ(0,0));
9491         #
9492         d=DataArrayInt.Range(22,23,7);
9493         self.assertEqual(1,d.getNumberOfTuples());
9494         self.assertEqual(1,d.getNumberOfComponents());
9495         self.assertEqual(22,d.getIJ(0,0));
9496         #
9497         d=DataArrayInt.Range(22,22,7);
9498         self.assertEqual(0,d.getNumberOfTuples());
9499         self.assertEqual(1,d.getNumberOfComponents());
9500         #
9501         d=DataArrayInt.Range(22,22,-7);
9502         self.assertEqual(0,d.getNumberOfTuples());
9503         self.assertEqual(1,d.getNumberOfComponents());
9504         #
9505         self.assertRaises(InterpKernelException,DataArrayInt.Range,22,23,-7);
9506         self.assertRaises(InterpKernelException,DataArrayInt.Range,23,22,7);
9507         self.assertRaises(InterpKernelException,DataArrayInt.Range,23,22,0);
9508         self.assertRaises(InterpKernelException,DataArrayInt.Range,22,23,0);
9509         pass
9510
9511     def testSwigUMeshGetItem1(self):
9512         m=MEDCouplingDataForTest.build2DTargetMesh_1();
9513         subMesh=m.buildPartOfMySelf([1,3],True);
9514         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
9515         m1=m[[1,3]]
9516         self.assertTrue(isinstance(m1,MEDCouplingUMesh))
9517         m2=m[(1,3)]
9518         self.assertTrue(isinstance(m2,MEDCouplingUMesh))
9519         m3=m[1::2]
9520         self.assertTrue(isinstance(m3,MEDCouplingUMesh))
9521         m4=m[DataArrayInt.New([1,3])]
9522         m5_1=m[1]
9523         self.assertTrue(isinstance(m5_1,MEDCouplingUMesh))
9524         m5_2=m[3]
9525         self.assertTrue(isinstance(m5_2,MEDCouplingUMesh))
9526         m5=MEDCouplingUMesh.MergeUMeshesOnSameCoords([m5_1,m5_2]);
9527         m5.setName(subMesh.getName())
9528         self.assertTrue(isinstance(m4,MEDCouplingUMesh))
9529         self.assertTrue(subMesh.isEqual(m1,1e-12))
9530         self.assertTrue(subMesh.isEqual(m2,1e-12))
9531         self.assertTrue(subMesh.isEqual(m3,1e-12))
9532         self.assertTrue(subMesh.isEqual(m4,1e-12))
9533         self.assertTrue(subMesh.isEqual(m5,1e-12))
9534         self.assertRaises(InterpKernelException,m.buildPartOfMySelf,[1,5],True);
9535         pass
9536     
9537     def testSwigGetItem3(self):
9538         da=DataArrayInt.New([4,5,6])
9539         self.assertEqual(5,da[1])
9540         self.assertRaises(InterpKernelException,da.__getitem__,-1)
9541         self.assertRaises(InterpKernelException,da.__getitem__,3)
9542         da=DataArrayInt.New([4,5,6,7,8,9],2,3)
9543         self.assertEqual(9,da[1,2])
9544         da=DataArrayDouble.New([4.1,5.2,6.3])
9545         self.assertAlmostEqual(5.2,da[1],12)
9546         self.assertRaises(InterpKernelException,da.__getitem__,-1)
9547         self.assertRaises(InterpKernelException,da.__getitem__,3)
9548         da=DataArrayDouble.New([4.12,5.12,6.12,7.12,8.12,9.12],2,3)
9549         self.assertAlmostEqual(9.12,da[1,2],12)
9550         pass
9551
9552     def testSwigDADISub1(self):
9553         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
9554         bary=mesh3D.getBarycenterAndOwner()
9555         bary=bary[:,:2]
9556         pts=bary.getDifferentValues(1e-12)
9557         expected=[[0,6,12],[1,7,13],[2,8,14],[3,9,15],[4,10,16],[5,11,17]]
9558         for pos,pt in enumerate(pts):
9559             bary2=bary[:,:2]
9560             bary2[:]-=pt
9561             norm=bary2.magnitude()
9562             self.assertEqual(expected[pos],norm.getIdsInRange(-1.,1e-5).getValues())
9563             pass
9564         expected2=[[3.,54.],[-141.,180.],[21.,54.],[39.,72.],[-15.,90.],[21.,90.]]
9565         for pos,pt in enumerate(pts):
9566             bary2=bary[:,:2]
9567             bary2[:]+=pt
9568             self.assertAlmostEqual(expected2[pos][0],bary2.accumulate()[0],12);
9569             self.assertAlmostEqual(expected2[pos][1],bary2.accumulate()[1],12);
9570             pass
9571         expected3=[[-3.,22.5],[45.,337.5],[-9., 22.5],[-15.,67.5],[3.,112.5],[-9.,112.5]]
9572         for pos,pt in enumerate(pts):
9573             bary2=bary[:,:2]
9574             bary2[:]*=pt
9575             self.assertAlmostEqual(expected3[pos][0],bary2.accumulate()[0],12);
9576             self.assertAlmostEqual(expected3[pos][1],bary2.accumulate()[1],12);
9577             pass
9578         expected4=[[-12.,90.],[0.8,6.],[-4,90.],[-2.4,30.],[12.,18],[-4,18.]]
9579         for pos,pt in enumerate(pts):
9580             bary2=bary[:,:2]
9581             bary2[:]/=pt
9582             self.assertAlmostEqual(expected4[pos][0],bary2.accumulate()[0],12);
9583             self.assertAlmostEqual(expected4[pos][1],bary2.accumulate()[1],12);
9584             pass
9585         #
9586         d=DataArrayInt.New([1,2,0,1,0,2],3,2)
9587         e=DataArrayInt.New([1,11,101,2,12,102,3,13,103,4,14,104],4,3)
9588         expected5=[[1,11,101,77,77,77,77,77,77,4,14,104],[77,77,77,77,77,77,3,13,103,4,14,104],[77,77,77,2,12,102,77,77,77,4,14,104]]
9589         expected6=[[1,77,77,2,77,77,3,77,77,4,77,77],[77,77,101,77,77,102,77,77,103,77,77,104],[77,11,77,77,12,77,77,13,77,77,14,77]]
9590         for pos,tup in enumerate(d):
9591             f=e[:]
9592             self.assertTrue(isinstance(f,DataArrayInt))
9593             f[tup]=77
9594             self.assertEqual(expected5[pos],f.getValues())
9595             self.assertEqual(6*[77],f[tup].getValues())
9596             f=e[:]
9597             f[:,tup]=77
9598             self.assertEqual(expected6[pos],f.getValues())
9599             self.assertEqual(8*[77],f[:,tup].getValues())
9600             pass
9601         #
9602         e=e.convertToDblArr()
9603         for pos,tup in enumerate(d):
9604             f=e[:]
9605             self.assertTrue(isinstance(f,DataArrayDouble))
9606             f[tup]=77.
9607             self.assertEqual(expected5[pos],f.convertToIntArr().getValues())
9608             self.assertEqual(6*[77],f[tup].convertToIntArr().getValues())
9609             f=e[:]
9610             f[:,tup]=77.
9611             self.assertEqual(expected6[pos],f.convertToIntArr().getValues())
9612             self.assertEqual(8*[77],f[:,tup].convertToIntArr().getValues())
9613             pass
9614         pass
9615
9616     def testDataArrayDoubleGetMinMaxPerComponent1(self):
9617         values1=[1.,2.,3.,-0.9,2.1,3.,1.3,1.7,3.,1.,1.8,3.]
9618         d1=DataArrayDouble.New();
9619         self.assertRaises(InterpKernelException,d1.getMinMaxPerComponent)
9620         d1=DataArrayDouble.New(values1,4,3);
9621         res=d1.getMinMaxPerComponent();
9622         self.assertTrue(isinstance(res,list))
9623         self.assertEqual(3,len(res))
9624         for i in xrange(3):
9625             self.assertTrue(isinstance(res[i],tuple))
9626             self.assertEqual(2,len(res[i]))
9627             pass
9628         expected1=[-0.9,1.3,1.7,2.1,3.,3.]
9629         for i in xrange(6):
9630             self.assertAlmostEqual(expected1[i],res[i/2][i%2],14)
9631             pass
9632         #
9633         d1.rearrange(2);
9634         res=d1.getMinMaxPerComponent();
9635         self.assertTrue(isinstance(res,list))
9636         self.assertEqual(2,len(res))
9637         for i in xrange(2):
9638             self.assertTrue(isinstance(res[i],tuple))
9639             self.assertEqual(2,len(res[i]))
9640             pass
9641         expected2=[1.,3.,-0.9,3.]
9642         for i in xrange(4):
9643             self.assertAlmostEqual(expected2[i],res[i/2][i%2],14)
9644             pass
9645         #
9646         d1.rearrange(1);
9647         res=d1.getMinMaxPerComponent();
9648         self.assertTrue(isinstance(res,list))
9649         self.assertEqual(1,len(res))
9650         for i in xrange(1):
9651             self.assertTrue(isinstance(res[i],tuple))
9652             self.assertEqual(2,len(res[i]))
9653             pass
9654         expected3=[-0.9,3.]
9655         for i in xrange(2):
9656             self.assertAlmostEqual(expected3[i],res[i/2][i%2],14)
9657             pass
9658         pass
9659
9660     def testDataArrayIntGetHashCode1(self):
9661         d1=DataArrayInt.New(range(3545))
9662         d2=DataArrayInt.New(range(3545))
9663         self.assertEqual(d2.getHashCode(),d1.getHashCode())
9664         self.assertEqual(232341068,d1.getHashCode())
9665         d1[886]=6
9666         self.assertEqual(232340188,d1.getHashCode())
9667         pass
9668
9669     def testZipConnectivityPol1(self):
9670         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
9671         cells1=[2,3,4]
9672         m2_1=m1.buildPartOfMySelf(cells1,True);
9673         m2=m2_1
9674         self.assertTrue(isinstance(m2,MEDCouplingUMesh))
9675         # no permutation policy 0
9676         isOk,arr=m1.areCellsIncludedIn(m2,0)
9677         self.assertTrue(isOk);
9678         self.assertEqual(3,arr.getNumberOfTuples());
9679         self.assertEqual(1,arr.getNumberOfComponents());
9680         self.assertEqual(cells1,arr.getValues())
9681         # no permutation policy 1
9682         isOk,arr=m1.areCellsIncludedIn(m2,1)
9683         self.assertTrue(isOk);
9684         self.assertEqual(3,arr.getNumberOfTuples());
9685         self.assertEqual(1,arr.getNumberOfComponents());
9686         self.assertEqual(cells1,arr.getValues())
9687         # no permutation policy 2
9688         isOk,arr=m1.areCellsIncludedIn(m2,2)
9689         self.assertTrue(isOk);
9690         self.assertEqual(3,arr.getNumberOfTuples());
9691         self.assertEqual(1,arr.getNumberOfComponents());
9692         self.assertEqual(cells1,arr.getValues())
9693         # some modification into m2
9694         modif1=[2,4,5]
9695         m2.getNodalConnectivity()[1:4]=modif1
9696         #policy 0 fails because cell0 in m2 has same orientation be not same connectivity
9697         expected1=[5,3,4]
9698         isOk,arr=m1.areCellsIncludedIn(m2,0)
9699         self.assertTrue(not isOk);
9700         self.assertEqual(3,arr.getNumberOfTuples());
9701         self.assertEqual(1,arr.getNumberOfComponents());
9702         self.assertEqual(expected1,arr.getValues())
9703         #policy 1 succeeds because cell0 in m2 has not exactly the same conn
9704         isOk,arr=m1.areCellsIncludedIn(m2,1)
9705         self.assertTrue(isOk);
9706         self.assertEqual(3,arr.getNumberOfTuples());
9707         self.assertEqual(1,arr.getNumberOfComponents());
9708         self.assertEqual(cells1,arr.getValues())
9709         #policy 2 succeeds because cell0 in m2 has same nodes in connectivity
9710         isOk,arr=m1.areCellsIncludedIn(m2,2)
9711         self.assertTrue(isOk);
9712         self.assertEqual(3,arr.getNumberOfTuples());
9713         self.assertEqual(1,arr.getNumberOfComponents());
9714         self.assertEqual(cells1,arr.getValues())
9715         #some new modification into m2
9716         modif2=[2,5,4]
9717         m2.getNodalConnectivity()[1:4]=modif2
9718         #policy 0 fails because cell0 in m2 has not exactly the same conn
9719         isOk,arr=m1.areCellsIncludedIn(m2,0)
9720         self.assertTrue(not isOk);
9721         self.assertEqual(3,arr.getNumberOfTuples());
9722         self.assertEqual(1,arr.getNumberOfComponents());
9723         self.assertEqual(expected1,arr.getValues())
9724         #policy 1 fails too because cell0 in m2 has not same orientation
9725         isOk,arr=m1.areCellsIncludedIn(m2,1)
9726         self.assertTrue(not isOk);
9727         self.assertEqual(3,arr.getNumberOfTuples());
9728         self.assertEqual(1,arr.getNumberOfComponents());
9729         self.assertEqual(expected1,arr.getValues())
9730         #policy 2 succeeds because cell0 in m2 has same nodes in connectivity
9731         isOk,arr=m1.areCellsIncludedIn(m2,2)
9732         self.assertTrue(isOk);
9733         self.assertEqual(3,arr.getNumberOfTuples());
9734         self.assertEqual(1,arr.getNumberOfComponents());
9735         self.assertEqual(cells1,arr.getValues())
9736         # Now 1D
9737         cells2=[3,2]
9738         m1=MEDCouplingDataForTest.build1DSourceMesh_2();
9739         m2_1=m1.buildPartOfMySelf(cells2,True);
9740         m2=m2_1
9741         self.assertTrue(isinstance(m2,MEDCouplingUMesh))
9742         # no permutation policy 0
9743         isOk,arr=m1.areCellsIncludedIn(m2,0)
9744         self.assertTrue(isOk);
9745         self.assertEqual(2,arr.getNumberOfTuples());
9746         self.assertEqual(1,arr.getNumberOfComponents());
9747         self.assertEqual(cells2,arr.getValues())
9748         # no permutation policy 1
9749         isOk,arr=m1.areCellsIncludedIn(m2,1)
9750         self.assertTrue(isOk);
9751         self.assertEqual(2,arr.getNumberOfTuples());
9752         self.assertEqual(1,arr.getNumberOfComponents());
9753         self.assertEqual(cells2,arr.getValues())
9754         # no permutation policy 2
9755         isOk,arr=m1.areCellsIncludedIn(m2,2)
9756         self.assertTrue(isOk);
9757         self.assertEqual(2,arr.getNumberOfTuples());
9758         self.assertEqual(1,arr.getNumberOfComponents());
9759         self.assertEqual(cells2,arr.getValues())
9760         # some modification into m2
9761         modif3=[4,3]
9762         m2.getNodalConnectivity()[1:3]=modif3
9763         #policy 0 fails because cell0 in m2 has not exactly the same conn
9764         expected2=[4,2]
9765         isOk,arr=m1.areCellsIncludedIn(m2,0)
9766         self.assertTrue(not isOk);
9767         self.assertEqual(2,arr.getNumberOfTuples());
9768         self.assertEqual(1,arr.getNumberOfComponents());
9769         self.assertEqual(expected2,arr.getValues())
9770         #policy 1 fails too because cell0 in m2 has not same orientation
9771         isOk,arr=m1.areCellsIncludedIn(m2,1)
9772         self.assertTrue(not isOk);
9773         self.assertEqual(2,arr.getNumberOfTuples());
9774         self.assertEqual(1,arr.getNumberOfComponents());
9775         self.assertEqual(expected2,arr.getValues())
9776         #policy 2 succeeds because cell0 in m2 has same nodes in connectivity
9777         isOk,arr=m1.areCellsIncludedIn(m2,2)
9778         self.assertTrue(isOk);
9779         self.assertEqual(2,arr.getNumberOfTuples());
9780         self.assertEqual(1,arr.getNumberOfComponents());
9781         self.assertEqual(cells2,arr.getValues())
9782         pass
9783
9784     def toSeeIfDaIIopsAreOK(self,d):
9785         d+=5
9786         d*=6
9787         d/=3
9788         d-=2
9789         d%=7
9790         pass
9791         
9792     def testSwigDAIOp5(self):
9793         d=DataArrayInt.New([4,5,6,10,3,-1],2,3)
9794         self.toSeeIfDaIIopsAreOK(d)
9795         dExp=DataArrayInt.New([2,4,6,0,0,6],2,3)
9796         self.assertTrue(d.isEqual(dExp));
9797         pass
9798     
9799     def toSeeIfDaDIopsAreOK(self,d):
9800         d+=5
9801         d*=6
9802         d/=3
9803         d-=2
9804         pass
9805
9806     def testSwigDADOp7(self):
9807         d=DataArrayDouble.New([4.,5.,6.,10.,3.,-1.],2,3)
9808         self.toSeeIfDaDIopsAreOK(d)
9809         dExp=DataArrayDouble.New([16.,18.,20.,28.,14.,6.],2,3)
9810         self.assertTrue(d.isEqual(dExp,1e-14));
9811         pass
9812
9813     def testConvexEnvelop2D1(self):
9814         coords=[7.54758495819e-14,-1.12270326253e-12,8.43143594193,-1.02835845055e-12,4.21571797096,7.30183771609,-4.21571797097,7.30183771609,-8.43143594193,-1.09439981894e-12,-4.21571797097,-7.30183771609,4.21571797097,-7.30183771609,16.8628718839,-1.02835845055e-12,12.6471539129,7.30183771609,8.43143594193,14.6036754322,2.26427548746e-13,14.6036754322,-8.43143594193,14.6036754322,-12.6471539129,7.30183771609,-16.8628718839,-1.39630321727e-12,-12.6471539129,-7.30183771609,-8.43143594193,-14.6036754322,3.7737924791e-14,-14.6036754322,8.43143594193,-14.6036754322,12.6471539129,-7.30183771609,25.2943078258,-1.07553085654e-12,21.0785898548,7.30183771609,16.8628718839,14.6036754322,12.6471539129,21.9055131483,4.21571797096,21.9055131483,-4.21571797097,21.9055131483,-12.6471539129,21.9055131483,-16.8628718839,14.6036754322,-21.0785898548,7.30183771609,-25.2943078258,-1.02835845055e-12,-21.0785898548,-7.30183771609,-16.8628718839,-14.6036754322,-12.6471539129,-21.9055131483,-4.21571797097,-21.9055131483,4.21571797097,-21.9055131483,12.6471539129,-21.9055131483,16.8628718839,-14.6036754322,21.0785898548,-7.30183771609,33.7257437677,-7.45324014622e-13,29.5100257968,7.30183771609,25.2943078258,14.6036754322,21.0785898548,21.9055131483,16.8628718839,29.2073508644,8.43143594193,29.2073508644,-1.20761359331e-12,29.2073508644,-8.43143594193,29.2073508644,-16.8628718839,29.2073508644,-21.0785898548,21.9055131483,-25.2943078258,14.6036754322,-29.5100257968,7.30183771609,-33.7257437677,-7.26455052226e-13,-29.5100257968,-7.30183771609,-25.2943078258,-14.6036754322,-21.0785898548,-21.9055131483,-16.8628718839,-29.2073508644,-8.43143594193,-29.2073508644,4.15117172701e-13,-29.2073508644,8.43143594193,-29.2073508644,16.8628718839,-29.2073508644,21.0785898548,-21.9055131483,25.2943078258,-14.6036754322,29.5100257968,-7.30183771609,42.1571797097,-1.86802727715e-12,37.9414617387,7.30183771609,33.7257437677,14.6036754322,29.5100257968,21.9055131483,25.2943078258,29.2073508644,21.0785898548,36.5091885805,12.6471539129,36.5091885805,4.21571797096,36.5091885805,-4.21571797096,36.5091885805,-12.6471539129,36.5091885805,-21.0785898548,36.5091885805,-25.2943078258,29.2073508644,-29.5100257968,21.9055131483,-33.7257437677,14.6036754322,-37.9414617387,7.30183771609,-42.1571797097,-9.81186044565e-13,-37.9414617387,-7.30183771609,-33.7257437677,-14.6036754322,-29.5100257968,-21.9055131483,-25.2943078258,-29.2073508644,-21.0785898548,-36.5091885805,-12.6471539129,-36.5091885805,-4.21571797097,-36.5091885805,4.21571797097,-36.5091885805,12.6471539129,-36.5091885805,21.0785898548,-36.5091885805,25.2943078258,-29.2073508644,29.5100257968,-21.9055131483,33.7257437677,-14.6036754322,37.9414617387,-7.30183771609,50.5886156516,-6.98151608633e-13,46.3728976806,7.30183771609,42.1571797097,14.6036754322,37.9414617387,21.9055131483,33.7257437677,29.2073508644,29.5100257968,36.5091885805,25.2943078258,43.8110262966,16.8628718839,43.8110262966,8.43143594193,43.8110262966,-1.84915831476e-12,43.8110262966,-8.43143594193,43.8110262966,-16.8628718839,43.8110262966,-25.2943078258,43.8110262966,-29.5100257968,36.5091885805,-33.7257437677,29.2073508644,-37.9414617387,21.9055131483,-42.1571797097,14.6036754322,-46.3728976806,7.30183771609,-50.5886156516,-1.47177906685e-12,-46.3728976806,-7.30183771609,-42.1571797097,-14.6036754322,-37.9414617387,-21.9055131483,-33.7257437677,-29.2073508644,-29.5100257968,-36.5091885805,-25.2943078258,-43.8110262966,-16.8628718839,-43.8110262966,-8.43143594193,-43.8110262966,7.54758495819e-14,-43.8110262966,8.43143594193,-43.8110262966,16.8628718839,-43.8110262966,25.2943078258,-43.8110262966,29.5100257968,-36.5091885805,33.7257437677,-29.2073508644,37.9414617387,-21.9055131483,42.1571797097,-14.6036754322,46.3728976806,-7.30183771609,59.0200515935,-7.9249642061e-13,54.8043336225,7.30183771609,50.5886156516,14.6036754322,46.3728976806,21.9055131483,42.1571797097,29.2073508644,37.9414617387,36.5091885805,33.7257437677,43.8110262966,29.5100257968,51.1128640127,21.0785898548,51.1128640127,12.6471539129,51.1128640127,4.21571797096,51.1128640127,-4.21571797096,51.1128640127,-12.6471539129,51.1128640127,-21.0785898548,51.1128640127,-29.5100257968,51.1128640127,-33.7257437677,43.8110262966,-37.9414617387,36.5091885805,-42.1571797097,29.2073508644,-46.3728976806,21.9055131483,-50.5886156516,14.6036754322,-54.8043336226,7.30183771609,-59.0200515935,-1.31139288649e-12,-54.8043336226,-7.30183771609,-50.5886156516,-14.6036754322,-46.3728976806,-21.9055131483,-42.1571797097,-29.2073508644,-37.9414617387,-36.5091885805,-33.7257437677,-43.8110262966,-29.5100257968,-51.1128640127,-21.0785898548,-51.1128640127,-12.6471539129,-51.1128640127,-4.21571797097,-51.1128640127,4.21571797097,-51.1128640127,12.6471539129,-51.1128640127,21.0785898548,-51.1128640127,29.5100257968,-51.1128640127,33.7257437677,-43.8110262966,37.9414617387,-36.5091885805,42.1571797097,-29.2073508644,46.3728976806,-21.9055131483,50.5886156516,-14.6036754322,54.8043336225,-7.30183771609,67.4514875354,-2.14162723189e-12,63.2357695645,7.30183771609,59.0200515935,14.6036754322,54.8043336226,21.9055131483,50.5886156516,29.2073508644,46.3728976806,36.5091885805,42.1571797097,43.8110262966,37.9414617387,51.1128640127,33.7257437677,58.4147017287,25.2943078258,58.4147017287,16.8628718839,58.4147017287,8.43143594193,58.4147017287,6.79282646237e-13,58.4147017287,-8.43143594193,58.4147017287,-16.8628718839,58.4147017287,-25.2943078258,58.4147017287,-33.7257437677,58.4147017287,-37.9414617387,51.1128640127,-42.1571797097,43.8110262966,-46.3728976806,36.5091885805,-50.5886156516,29.2073508644,-54.8043336226,21.9055131483,-59.0200515935,14.6036754322,-63.2357695645,7.30183771609,-67.4514875354,-1.16044118732e-12,-63.2357695645,-7.30183771609,-59.0200515935,-14.6036754322,-54.8043336226,-21.9055131483,-50.5886156516,-29.2073508644,-46.3728976806,-36.5091885805,-42.1571797097,-43.8110262966,-37.9414617387,-51.1128640127,-33.7257437677,-58.4147017287,-25.2943078258,-58.4147017287,-16.8628718839,-58.4147017287,-8.43143594193,-58.4147017287,-5.66068871864e-14,-58.4147017287,8.43143594193,-58.4147017287,16.8628718839,-58.4147017287,25.2943078258,-58.4147017287,33.7257437677,-58.4147017287,37.9414617387,-51.1128640127,42.1571797097,-43.8110262966,46.3728976806,-36.5091885805,50.5886156516,-29.2073508644,54.8043336226,-21.9055131483,59.0200515935,-14.6036754322,63.2357695645,-7.30183771609,75.8829234774,-2.29257893105e-12,71.6672055064,7.30183771609,67.4514875354,14.6036754322,63.2357695645,21.9055131483,59.0200515935,29.2073508644,54.8043336226,36.5091885805,50.5886156516,43.8110262966,46.3728976806,51.1128640127,42.1571797097,58.4147017287,37.9414617387,65.7165394448,29.5100257968,65.7165394448,21.0785898548,65.7165394448,12.6471539129,65.7165394448,4.21571797097,65.7165394448,-4.21571797096,65.7165394448,-12.6471539129,65.7165394448,-21.0785898548,65.7165394448,-29.5100257968,65.7165394448,-37.9414617387,65.7165394448,-42.1571797097,58.4147017287,-46.3728976806,51.1128640127,-50.5886156516,43.8110262966,-54.8043336226,36.5091885805,-59.0200515935,29.2073508644,-63.2357695645,21.9055131483,-67.4514875354,14.6036754322,-71.6672055064,7.30183771609,-75.8829234774,-1.31139288649e-12,-71.6672055064,-7.30183771609,-67.4514875354,-14.6036754322,-63.2357695645,-21.9055131483,-59.0200515935,-29.2073508644,-54.8043336226,-36.5091885805,-50.5886156516,-43.8110262966,-46.3728976806,-51.1128640127,-42.1571797097,-58.4147017287,-37.9414617387,-65.7165394448,-29.5100257968,-65.7165394448,-21.0785898548,-65.7165394448,-12.6471539129,-65.7165394448,-4.21571797097,-65.7165394448,4.21571797097,-65.7165394448,12.6471539129,-65.7165394448,21.0785898548,-65.7165394448,29.5100257968,-65.7165394448,37.9414617387,-65.7165394448,42.1571797097,-58.4147017287,46.3728976806,-51.1128640127,50.5886156516,-43.8110262966,54.8043336226,-36.5091885805,59.0200515935,-29.2073508644,63.2357695645,-21.9055131483,67.4514875354,-14.6036754322,71.6672055064,-7.30183771609,84.3143594193,-1.49064802924e-12,80.0986414483,7.30183771609,75.8829234774,14.6036754322,71.6672055064,21.9055131483,67.4514875354,29.2073508644,63.2357695645,36.5091885805,59.0200515935,43.8110262966,54.8043336226,51.1128640127,50.5886156516,58.4147017287,46.3728976806,65.7165394448,42.1571797097,73.0183771609,33.7257437677,73.0183771609,25.2943078258,73.0183771609,16.8628718839,73.0183771609,8.43143594193,73.0183771609,2.0755858635e-12,73.0183771609,-8.43143594193,73.0183771609,-16.8628718839,73.0183771609,-25.2943078258,73.0183771609,-33.7257437677,73.0183771609,-42.1571797097,73.0183771609,-46.3728976806,65.7165394448,-50.5886156516,58.4147017287,-54.8043336226,51.1128640127,-59.0200515935,43.8110262966,-63.2357695645,36.5091885805,-67.4514875354,29.2073508644,-71.6672055064,21.9055131483,-75.8829234774,14.6036754322,-80.0986414483,7.30183771609,-84.3143594193,-1.11326878133e-12,-80.0986414483,-7.30183771609,-75.8829234774,-14.6036754322,-71.6672055064,-21.9055131483,-67.4514875354,-29.2073508644,-63.2357695645,-36.5091885805,-59.0200515935,-43.8110262966,-54.8043336226,-51.1128640127,-50.5886156516,-58.4147017287,-46.3728976806,-65.7165394448,-42.1571797097,-73.0183771609,-33.7257437677,-73.0183771609,-25.2943078258,-73.0183771609,-16.8628718839,-73.0183771609,-8.43143594193,-73.0183771609,-5.66068871864e-14,-73.0183771609,8.43143594193,-73.0183771609,16.8628718839,-73.0183771609,25.2943078258,-73.0183771609,33.7257437677,-73.0183771609,42.1571797097,-73.0183771609,46.3728976806,-65.7165394448,50.5886156516,-58.4147017287,54.8043336226,-51.1128640127,59.0200515935,-43.8110262966,63.2357695645,-36.5091885805,67.4514875354,-29.2073508644,71.6672055064,-21.9055131483,75.8829234774,-14.6036754322,80.0986414483,-7.3018377161]
9815         conn=[0,2,3,4,5,6,1,1,8,2,0,6,18,7,2,9,10,3,0,1,8,3,10,11,12,4,0,2,4,3,12,13,14,5,0,5,0,4,14,15,16,6,6,1,0,5,16,17,18,7,20,8,1,18,36,19,8,21,9,2,1,7,20,9,22,23,10,2,8,21,10,23,24,11,3,2,9,11,24,25,26,12,3,10,12,11,26,27,13,4,3,13,12,27,28,29,14,4,14,4,13,29,30,15,5,15,5,14,30,31,32,16,16,6,5,15,32,33,17,17,18,6,16,33,34,35,18,7,1,6,17,35,36,19,38,20,7,36,60,37,20,39,21,8,7,19,38,21,40,22,9,8,20,39,22,41,42,23,9,21,40,23,42,43,24,10,9,22,24,43,44,25,11,10,23,25,44,45,46,26,11,24,26,25,46,47,27,12,11,27,26,47,48,28,13,12,28,27,48,49,50,29,13,29,13,28,50,51,30,14,30,14,29,51,52,31,15,31,15,30,52,53,54,32,32,16,15,31,54,55,33,33,17,16,32,55,56,34,34,35,17,33,56,57,58,35,36,18,17,34,58,59,36,19,7,18,35,59,60,37,62,38,19,60,90,61,38,63,39,20,19,37,62,39,64,40,21,20,38,63,40,65,41,22,21,39,64,41,66,67,42,22,40,65,42,67,68,43,23,22,41,43,68,69,44,24,23,42,44,69,70,45,25,24,43,45,70,71,72,46,25,44,46,45,72,73,47,26,25,47,46,73,74,48,27,26,48,47,74,75,49,28,27,49,48,75,76,77,50,28,50,28,49,77,78,51,29,51,29,50,78,79,52,30,52,30,51,79,80,53,31,53,31,52,80,81,82,54,54,32,31,53,82,83,55,55,33,32,54,83,84,56,56,34,33,55,84,85,57,57,58,34,56,85,86,87,58,59,35,34,57,87,88,59,60,36,35,58,88,89,60,37,19,36,59,89,90,61,92,62,37,90,126,91,62,93,63,38,37,61,92,63,94,64,39,38,62,93,64,95,65,40,39,63,94,65,96,66,41,40,64,95,66,97,98,67,41,65,96,67,98,99,68,42,41,66,68,99,100,69,43,42,67,69,100,101,70,44,43,68,70,101,102,71,45,44,69,71,102,103,104,72,45,70,72,71,104,105,73,46,45,73,72,105,106,74,47,46,74,73,106,107,75,48,47,75,74,107,108,76,49,48,76,75,108,109,110,77,49,77,49,76,110,111,78,50,78,50,77,111,112,79,51,79,51,78,112,113,80,52,80,52,79,113,114,81,53,81,53,80,114,115,116,82,82,54,53,81,116,117,83,83,55,54,82,117,118,84,84,56,55,83,118,119,85,85,57,56,84,119,120,86,86,87,57,85,120,121,122,87,88,58,57,86,122,123,88,89,59,58,87,123,124,89,90,60,59,88,124,125,90,61,37,60,89,125,126,91,128,92,61,126,168,127,92,129,93,62,61,91,128,93,130,94,63,62,92,129,94,131,95,64,63,93,130,95,132,96,65,64,94,131,96,133,97,66,65,95,132,97,134,135,98,66,96,133,98,135,136,99,67,66,97,99,136,137,100,68,67,98,100,137,138,101,69,68,99,101,138,139,102,70,69,100,102,139,140,103,71,70,101,103,140,141,142,104,71,102,104,103,142,143,105,72,71,105,104,143,144,106,73,72,106,105,144,145,107,74,73,107,106,145,146,108,75,74,108,107,146,147,109,76,75,109,108,147,148,149,110,76,110,76,109,149,150,111,77,111,77,110,150,151,112,78,112,78,111,151,152,113,79,113,79,112,152,153,114,80,114,80,113,153,154,115,81,115,81,114,154,155,156,116,116,82,81,115,156,157,117,117,83,82,116,157,158,118,118,84,83,117,158,159,119,119,85,84,118,159,160,120,120,86,85,119,160,161,121,121,122,86,120,161,162,163,122,123,87,86,121,163,164,123,124,88,87,122,164,165,124,125,89,88,123,165,166,125,126,90,89,124,166,167,126,91,61,90,125,167,168,127,170,128,91,168,216,169,128,171,129,92,91,127,170,129,172,130,93,92,128,171,130,173,131,94,93,129,172,131,174,132,95,94,130,173,132,175,133,96,95,131,174,133,176,134,97,96,132,175,134,177,178,135,97,133,176,135,178,179,136,98,97,134,136,179,180,137,99,98,135,137,180,181,138,100,99,136,138,181,182,139,101,100,137,139,182,183,140,102,101,138,140,183,184,141,103,102,139,141,184,185,186,142,103,140,142,141,186,187,143,104,103,143,142,187,188,144,105,104,144,143,188,189,145,106,105,145,144,189,190,146,107,106,146,145,190,191,147,108,107,147,146,191,192,148,109,108,148,147,192,193,194,149,109,149,109,148,194,195,150,110,150,110,149,195,196,151,111,151,111,150,196,197,152,112,152,112,151,197,198,153,113,153,113,152,198,199,154,114,154,114,153,199,200,155,115,155,115,154,200,201,202,156,156,116,115,155,202,203,157,157,117,116,156,203,204,158,158,118,117,157,204,205,159,159,119,118,158,205,206,160,160,120,119,159,206,207,161,161,121,120,160,207,208,162,162,163,121,161,208,209,210,163,164,122,121,162,210,211,164,165,123,122,163,211,212,165,166,124,123,164,212,213,166,167,125,124,165,213,214,167,168,126,125,166,214,215,168,127,91,126,167,215,216,169,218,170,127,216,270,217,170,219,171,128,127,169,218,171,220,172,129,128,170,219,172,221,173,130,129,171,220,173,222,174,131,130,172,221,174,223,175,132,131,173,222,175,224,176,133,132,174,223,176,225,177,134,133,175,224,177,226,227,178,134,176,225,178,227,228,179,135,134,177,179,228,229,180,136,135,178,180,229,230,181,137,136,179,181,230,231,182,138,137,180,182,231,232,183,139,138,181,183,232,233,184,140,139,182,184,233,234,185,141,140,183,185,234,235,236,186,141,184,186,185,236,237,187,142,141,187,186,237,238,188,143,142,188,187,238,239,189,144,143,189,188,239,240,190,145,144,190,189,240,241,191,146,145,191,190,241,242,192,147,146,192,191,242,243,193,148,147,193,192,243,244,245,194,148,194,148,193,245,246,195,149,195,149,194,246,247,196,150,196,150,195,247,248,197,151,197,151,196,248,249,198,152,198,152,197,249,250,199,153,199,153,198,250,251,200,154,200,154,199,251,252,201,155,201,155,200,252,253,254,202,202,156,155,201,254,255,203,203,157,156,202,255,256,204,204,158,157,203,256,257,205,205,159,158,204,257,258,206,206,160,159,205,258,259,207,207,161,160,206,259,260,208,208,162,161,207,260,261,209,209,210,162,208,261,262,263,210,211,163,162,209,263,264,211,212,164,163,210,264,265,212,213,165,164,211,265,266,213,214,166,165,212,266,267,214,215,167,166,213,267,268,215,216,168,167,214,268,269,216,169,127,168,215,269,270,217,272,218,169,270,330,271,218,273,219,170,169,217,272,219,274,220,171,170,218,273,220,275,221,172,171,219,274,221,276,222,173,172,220,275,222,277,223,174,173,221,276,223,278,224,175,174,222,277,224,279,225,176,175,223,278,225,280,226,177,176,224,279,226,281,282,227,177,225,280,227,282,283,228,178,177,226,228,283,284,229,179,178,227,229,284,285,230,180,179,228,230,285,286,231,181,180,229,231,286,287,232,182,181,230,232,287,288,233,183,182,231,233,288,289,234,184,183,232,234,289,290,235,185,184,233,235,290,291,292,236,185,234,236,235,292,293,237,186,185,237,236,293,294,238,187,186,238,237,294,295,239,188,187,239,238,295,296,240,189,188,240,239,296,297,241,190,189,241,240,297,298,242,191,190,242,241,298,299,243,192,191,243,242,299,300,244,193,192,244,243,300,301,302,245,193,245,193,244,302,303,246,194,246,194,245,303,304,247,195,247,195,246,304,305,248,196,248,196,247,305,306,249,197,249,197,248,306,307,250,198,250,198,249,307,308,251,199,251,199,250,308,309,252,200,252,200,251,309,310,253,201,253,201,252,310,311,312,254,254,202,201,253,312,313,255,255,203,202,254,313,314,256,256,204,203,255,314,315,257,257,205,204,256,315,316,258,258,206,205,257,316,317,259,259,207,206,258,317,318,260,260,208,207,259,318,319,261,261,209,208,260,319,320,262,262,263,209,261,320,321,322,263,264,210,209,262,322,323,264,265,211,210,263,323,324,265,266,212,211,264,324,325,266,267,213,212,265,325,326,267,268,214,213,266,326,327,268,269,215,214,267,327,328,269,270,216,215,268,328,329,270,217,169,216,269,329,330,271,272,217,330,273,218,217,271,274,219,218,272,275,220,219,273,276,221,220,274,277,222,221,275,278,223,222,276,279,224,223,277,280,225,224,278,281,226,225,279,281,282,226,280,283,227,226,281,284,228,227,282,285,229,228,283,286,230,229,284,287,231,230,285,288,232,231,286,289,233,232,287,290,234,233,288,291,235,234,289,291,292,235,290,291,293,236,235,292,294,237,236,293,295,238,237,294,296,239,238,295,297,240,239,296,298,241,240,297,299,242,241,298,300,243,242,299,301,244,243,301,300,302,244,244,301,303,245,245,302,304,246,246,303,305,247,247,304,306,248,248,305,307,249,249,306,308,250,250,307,309,251,251,308,310,252,252,309,311,253,311,253,310,312,254,253,311,313,255,254,312,314,256,255,313,315,257,256,314,316,258,257,315,317,259,258,316,318,260,259,317,319,261,260,318,320,262,261,319,321,321,322,262,320,323,263,262,321,324,264,263,322,325,265,264,323,326,266,265,324,327,267,266,325,328,268,267,326,329,269,268,327,330,270,269,328,271,217,270,329]
9816         connI=[0,7,14,21,28,35,42,49,56,63,70,77,84,91,98,105,112,119,126,133,140,147,154,161,168,175,182,189,196,203,210,217,224,231,238,245,252,259,266,273,280,287,294,301,308,315,322,329,336,343,350,357,364,371,378,385,392,399,406,413,420,427,434,441,448,455,462,469,476,483,490,497,504,511,518,525,532,539,546,553,560,567,574,581,588,595,602,609,616,623,630,637,644,651,658,665,672,679,686,693,700,707,714,721,728,735,742,749,756,763,770,777,784,791,798,805,812,819,826,833,840,847,854,861,868,875,882,889,896,903,910,917,924,931,938,945,952,959,966,973,980,987,994,1001,1008,1015,1022,1029,1036,1043,1050,1057,1064,1071,1078,1085,1092,1099,1106,1113,1120,1127,1134,1141,1148,1155,1162,1169,1176,1183,1190,1197,1204,1211,1218,1225,1232,1239,1246,1253,1260,1267,1274,1281,1288,1295,1302,1309,1316,1323,1330,1337,1344,1351,1358,1365,1372,1379,1386,1393,1400,1407,1414,1421,1428,1435,1442,1449,1456,1463,1470,1477,1484,1491,1498,1505,1512,1519,1526,1533,1540,1547,1554,1561,1568,1575,1582,1589,1596,1603,1610,1617,1624,1631,1638,1645,1652,1659,1666,1673,1680,1687,1694,1701,1708,1715,1722,1729,1736,1743,1750,1757,1764,1771,1778,1785,1792,1799,1806,1813,1820,1827,1834,1841,1848,1855,1862,1869,1876,1883,1890,1897,1901,1905,1909,1913,1917,1921,1925,1929,1933,1937,1941,1945,1949,1953,1957,1961,1965,1969,1973,1977,1981,1985,1989,1993,1997,2001,2005,2009,2013,2017,2021,2025,2029,2033,2037,2041,2045,2049,2053,2057,2061,2065,2069,2073,2077,2081,2085,2089,2093,2097,2101,2105,2109,2113,2117,2121,2125,2129,2133,2137]
9817         #
9818         m=MEDCouplingUMesh.New("convexhull",2);
9819         m.allocateCells(331);
9820         for i in xrange(331):
9821             m.insertNextCell(NORM_POLYGON,conn[connI[i]:connI[i+1]]);
9822             pass
9823         m.finishInsertingCells();
9824         coordsDa=DataArrayDouble.New(coords,331,2);
9825         m.setCoords(coordsDa);
9826         m.checkCoherency();
9827         #
9828         da=m.convexEnvelop2D();
9829         m.checkCoherency()
9830         self.assertEqual(coordsDa.getHiddenCppPointer(),m.getCoords().getHiddenCppPointer())
9831         daC=da.buildComplement(m.getNumberOfCells());
9832         expected2=DataArrayInt.New([271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,302,303,304,305,306,307,308,309,310,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330]);
9833         self.assertTrue(expected2.isEqual(daC));
9834         #
9835         vals=m.getMeasureField(ON_CELLS).getArray()
9836         ref=271*[184.69493088478035]+3*[-61.564976961404426,-92.34746544254946,-92.34746544259811,-92.34746544253488,-92.3474654425349,-92.34746544180479,-92.34746544253493,-92.3474654419026,-92.34746544190256,-92.34746544253491]+2*[61.564976961404426,-92.34746544254946,-92.34746544259811,-92.34746544253488,-92.3474654425349,-92.34746544180479,-92.34746544253493,-92.3474654419026,-92.34746544190256,-92.34746544253491]+[-61.564976961404426,-92.34746544254946,-92.34746544259811,-92.34746544253488,-92.3474654425349,-92.34746544180479,-92.34746544253493,-92.3474654419026,-92.34746544190256,-92.34746544253491]
9837         vals-=DataArrayDouble.New(ref)
9838         vals.abs()
9839         theTest=vals.getIdsInRange(-1.,1e-7)
9840         self.assertTrue(theTest.isIdentity())
9841         self.assertEqual(331,len(theTest))
9842         pass
9843
9844     def testSwigDAIOp8(self):
9845         da=DataArrayInt.New([7,5,6,7,8,9,9,10,12,13,47,15])
9846         self.assertTrue(7 in da)
9847         self.assertTrue(47 in da)
9848         self.assertTrue(15 in da)
9849         self.assertEqual(0,da.index(7))
9850         self.assertEqual(10,da.index(47))
9851         self.assertTrue(14 not in da)
9852         self.assertEqual(5,da.search([9,9]))
9853         self.assertEqual(-1,da.search([5,8]))
9854         da.rearrange(2)
9855         self.assertTrue([47,16] not in da)
9856         self.assertTrue([5,6] not in da)
9857         self.assertTrue([6,7] in da)
9858         self.assertEqual(4,da.index([12,13]))
9859         pass
9860
9861     def testDataArraySort1(self):
9862         arr=DataArrayInt.New();
9863         self.assertRaises(InterpKernelException,arr.sort,True)
9864         self.assertRaises(InterpKernelException,arr.sort,False)
9865         values=[2,1,6,5,4,7]
9866         arr.alloc(3,2);
9867         self.assertRaises(InterpKernelException,arr.sort,True)
9868         self.assertRaises(InterpKernelException,arr.sort,False)
9869         arr.rearrange(1);
9870         arr.setValues(values,6,1)
9871         arr1=arr.deepCpy();
9872         arr2=arr.deepCpy();
9873         arr1.sort(True);
9874         expected1=[1,2,4,5,6,7]
9875         self.assertEqual(6,arr1.getNumberOfTuples());
9876         self.assertEqual(1,arr1.getNumberOfComponents());
9877         self.assertEqual(expected1,arr1.getValues());
9878         arr2.sort(False);
9879         expected2=[7,6,5,4,2,1]
9880         self.assertEqual(6,arr2.getNumberOfTuples());
9881         self.assertEqual(1,arr2.getNumberOfComponents());
9882         self.assertTrue(expected2,arr2.getValues());
9883         #
9884         ard=DataArrayDouble.New();
9885         self.assertRaises(InterpKernelException,ard.sort,True)
9886         self.assertRaises(InterpKernelException,ard.sort,False)
9887         valuesD=[2.,1.,6.,5.,4.,7.]
9888         ard.alloc(3,2);
9889         self.assertRaises(InterpKernelException,ard.sort,True)
9890         self.assertRaises(InterpKernelException,ard.sort,False)
9891         ard.rearrange(1);
9892         ard.setValues(valuesD,6,1)
9893         ard1=ard.deepCpy();
9894         ard2=ard.deepCpy();
9895         ard1.sort(True);
9896         expected3=[1.,2.,4.,5.,6.,7.]
9897         self.assertEqual(6,ard1.getNumberOfTuples());
9898         self.assertEqual(1,ard1.getNumberOfComponents());
9899         for i in xrange(6):
9900             self.assertAlmostEqual(expected3[i],ard1.getIJ(i,0),12)
9901             pass
9902         ard2.sort(False);
9903         expected4=[7.,6.,5.,4.,2.,1.]
9904         self.assertEqual(6,ard2.getNumberOfTuples());
9905         self.assertEqual(1,ard2.getNumberOfComponents());
9906         for i in xrange(6):
9907             self.assertAlmostEqual(expected4[i],ard2.getIJ(i,0),12)
9908             pass
9909         pass
9910     
9911     def testPartitionBySpreadZone1(self):
9912         m=MEDCouplingDataForTest.build2DTargetMesh_1();
9913         m4=MEDCouplingUMesh.MergeUMeshes([m,m[-3:],m[0:2]]);
9914         m4.renumberCells([5,2,9,6,4,7,0,1,3,8]);
9915         #
9916         v2=m4.partitionBySpreadZone();
9917         self.assertTrue(3,len(v2));
9918         self.assertTrue(v2[0].isEqual(DataArrayInt.New([0,1,7])))
9919         self.assertTrue(v2[1].isEqual(DataArrayInt.New([2,4,5,6,9])))
9920         self.assertTrue(v2[2].isEqual(DataArrayInt.New([3,8])))
9921         #
9922         m5=m4.buildSpreadZonesWithPoly();
9923         self.assertEqual(3,m5.getNumberOfCells());
9924         self.assertTrue(m5.getCoords().getHiddenCppPointer()==m4.getCoords().getHiddenCppPointer());
9925         self.assertEqual([5,15,16,17,14,11,13,12,5,2,1,0,3,6,7,8,5,5,18,21,22,20,19],m5.getNodalConnectivity().getValues())
9926         self.assertEqual([0,8,17,23],m5.getNodalConnectivityIndex().getValues())
9927         #
9928         pass
9929
9930     def testGiveCellsWithType1(self):
9931         expected0=[1,2]
9932         expected1=[0,3,4]
9933         m=MEDCouplingDataForTest.build2DTargetMesh_1();
9934         da=m.giveCellsWithType(NORM_TRI3);
9935         self.assertEqual(2,da.getNumberOfTuples());
9936         self.assertEqual(1,da.getNumberOfComponents());
9937         self.assertEqual(expected0,da.getValues())
9938         #
9939         da=m.giveCellsWithType(NORM_QUAD4);
9940         self.assertEqual(3,da.getNumberOfTuples());
9941         self.assertEqual(1,da.getNumberOfComponents());
9942         self.assertEqual(expected1,da.getValues())
9943         #
9944         da=m.giveCellsWithType(NORM_TRI6);
9945         self.assertEqual(0,da.getNumberOfTuples());
9946         self.assertEqual(1,da.getNumberOfComponents());
9947         #
9948         self.assertRaises(InterpKernelException,m.giveCellsWithType,NORM_SEG2)
9949         self.assertRaises(InterpKernelException,m.giveCellsWithType,NORM_HEXA8)
9950         pass
9951
9952     def testSwigDAOp1(self):
9953         d=DataArrayDouble.New(5,2)
9954         d.rearrange(1) ; d.iota(2.) ; d.rearrange(2)
9955         d.setInfoOnComponents(["X [m]","Y [m]"])
9956         d.setName("AName")
9957         #
9958         d1=d+[8,9]
9959         self.assertTrue(d1.isEqualWithoutConsideringStr(DataArrayDouble.New([10.0,12.0,12.0,14.0,14.0,16.0,16.0,18.0,18.0,20.0]),1e-12))
9960         d1bis=DataArrayDouble.New([8,9],1,2)+d
9961         self.assertTrue(d1bis.isEqual(d1,1e-12))
9962         d1ter=[8,9]+d
9963         self.assertTrue(d1ter.isEqual(d1,1e-12))
9964         #
9965         d2=d1-[8,9]
9966         self.assertTrue(d2.isEqual(d,1e-12))
9967         self.assertRaises(InterpKernelException,d1.__rsub__,[8,9])#[8,9]-d1
9968         #
9969         d3=d*[8,9]
9970         self.assertTrue(d3.isEqualWithoutConsideringStr(DataArrayDouble.New([16.0,27.0,32.0,45.0,48.0,63.0,64.0,81.0,80.0,99.0]),1e-12))
9971         d3bis=DataArrayDouble.New([8,9],1,2)*d
9972         self.assertTrue(d3bis.isEqual(d3,1e-12))
9973         d3ter=[8,9]*d
9974         self.assertTrue(d3ter.isEqual(d3,1e-12))
9975         #
9976         d4=d3/[8,9]
9977         self.assertTrue(d4.isEqual(d,1e-12))
9978         #
9979         d=DataArrayInt.New(5,2)
9980         d.rearrange(1) ; d.iota(2) ; d.rearrange(2)
9981         d.setInfoOnComponents(["X [m]","Y [m]"])
9982         d.setName("AName")
9983         #
9984         d1=d+[8,9]
9985         self.assertEqual(d1.getValues(),[10,12,12,14,14,16,16,18,18,20])
9986         d1bis=DataArrayInt.New([8,9],1,2)+d
9987         self.assertTrue(d1bis.isEqual(d1))
9988         d1ter=[8,9]+d
9989         self.assertTrue(d1ter.isEqual(d1))
9990         #
9991         d2=d1-[8,9]
9992         self.assertTrue(d2.isEqual(d))
9993         self.assertRaises(InterpKernelException,d1.__rsub__,[8,9])
9994         #
9995         d3=d*[8,9]
9996         self.assertEqual(d3.getValues(),[16,27,32,45,48,63,64,81,80,99])
9997         d3bis=DataArrayInt.New([8,9],1,2)*d
9998         self.assertTrue(d3bis.isEqual(d3))
9999         d3ter=[8,9]*d
10000         self.assertTrue(d3ter.isEqual(d3))
10001         #
10002         d4=d3/[8,9]
10003         self.assertTrue(d4.isEqual(d))
10004         #
10005         d5=d%[4,5]
10006         self.assertEqual(d5.getValues(),[2,3,0,0,2,2,0,4,2,1])
10007         pass
10008
10009     def testSwigSelectTupleId2DAIBug1(self):
10010         da=DataArrayInt.New([0,1,2,3,12,13,4,5,6,7,14,15,8,9,10,11,16,17])
10011         self.assertEqual([2,6,10],da[2::6].getValues())
10012         self.assertEqual([0,4,8],da[::6].getValues())
10013         self.assertEqual([5,9],da[7::6].getValues())
10014         self.assertEqual([5],da[7:-5:6].getValues())
10015         pass
10016
10017     def testSwigCpp5Safe1(self):
10018         m=MEDCouplingUMesh.New("toto",2)
10019         coords=DataArrayDouble.New([0.,0.,1.,0.,1.,1.,0.,1.],4,2)
10020         m.setCoords(coords)
10021         vecs=DataArrayDouble.New([2.,3.,4.,5.,6.,7.],3,2)
10022         expected1=[[2.,3.,3.,3.,3.,4.,2.,4.0],[4.,5.,5.,5.,5.,6.,4.,6.0],[6.,7.,7.,7.,7.,8.,6.,8.0]]
10023         for pos,vec in enumerate(vecs):
10024             m2=m.deepCpy()
10025             m2.translate(vec)
10026             self.assertTrue(m2.getCoords().isEqual(DataArrayDouble.New(expected1[pos],4,2),1e-12))
10027             pass
10028         for pos,vec in enumerate(vecs):
10029             m2=m.deepCpy()
10030             m2.translate(vec.buildDADouble())
10031             self.assertTrue(m2.getCoords().isEqual(DataArrayDouble.New(expected1[pos],4,2),1e-12))
10032             pass
10033         pass
10034     
10035     def testSwigBugNonRegressionZipDA(self):
10036         angles=map(lambda x:pi/3*x,xrange(6))
10037         radius=3
10038         #
10039         dad=DataArrayDouble.New(6, 2)
10040         dad[:,0]=radius
10041         dad[:,1]=angles
10042         #
10043         dad2=dad.fromPolarToCart()
10044         dads=[dad2.deepCpy() for elt in 7*[None]]
10045         #
10046         translationToPerform=[[0.01,0.02],[3./2.*radius,-radius*sqrt(3.)/2],[3./2.*radius,radius*sqrt(3.)/2],[0.,radius*sqrt(3.)],[-3./2.*radius,radius*sqrt(3.)/2],[-3./2.*radius,-radius*sqrt(3.)/2],[0.,-radius*sqrt(3.)]]
10047         for d,t in zip(dads,translationToPerform):
10048             d+=t
10049             pass
10050         for elt in dads:
10051             self.assertTrue(not dad2.isEqual(elt,1e-12))
10052             pass
10053         for d,t in zip(dads,translationToPerform):
10054             d-=t
10055             pass
10056         for elt in dads:
10057             self.assertTrue(dad2.isEqual(elt,1e-12))
10058             pass
10059         pass
10060
10061     def testBuildSlice3D2(self):
10062         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
10063         vec1=[-0.07,1.,0.07]
10064         origin1=[1.524,1.4552,1.74768]
10065         slice1,ids=mesh3D.buildSlice3D(origin1,vec1,1e-10);
10066         f=MEDCouplingFieldDouble(ON_CELLS,ONE_TIME)
10067         f.setTime(4.5,6,7) ; f.setMesh(mesh3D)
10068         arr=DataArrayDouble(mesh3D.getNumberOfCells(),2)
10069         arr.rearrange(1) ; arr.iota(2.) ; arr.rearrange(2)
10070         f.setArray(arr)
10071         f.checkCoherency()
10072         expected1=DataArrayInt([1,3,4,7,9,10,13,15,16])
10073         self.assertTrue(expected1.isEqual(ids))
10074         arr2=arr[expected1]
10075         #
10076         f2=f.extractSlice3D(origin1,vec1,1e-10)
10077         self.assertTrue(f2.getArray().isEqual(arr2,1e-12));
10078         self.assertTrue(slice1.isEqual(f2.getMesh(),1e-12))
10079         self.assertEqual(6,f2.getTime()[1]) ; self.assertEqual(7,f2.getTime()[2])
10080         self.assertAlmostEqual(4.5,f2.getTime()[0],12);
10081         pass
10082
10083     def testComputeTupleIdsToSelectFromCellIds1(self):
10084         m=MEDCouplingDataForTest.build2DTargetMesh_3()
10085         f=MEDCouplingFieldDouble.New(ON_GAUSS_NE,NO_TIME);
10086         f.setMesh(m);
10087         arr=DataArrayDouble(52,2) ; arr.rearrange(1) ; arr.iota(7.) ; arr.rearrange(2)
10088         f.setArray(arr)
10089         #
10090         f2=f.buildSubPart([1,5,9])
10091         f2.checkCoherency()
10092         cI=m.computeNbOfNodesPerCell()
10093         cI.computeOffsets2()
10094         sel=DataArrayInt([1,5,9])
10095         res=sel.buildExplicitArrByRanges(cI)
10096         arr2=arr[res]
10097         self.assertTrue(arr2.isEqual(DataArrayDouble([13,14,15,16,17,18,19,20,59,60,61,62,63,64,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110],15,2),1e-12))
10098         self.assertTrue(arr2.isEqual(f2.getArray(),1e-12))
10099         pass
10100
10101     def testComputeSkin1(self):
10102         arrX=DataArrayDouble([2.,3.4,5.6,7.7,8.0]) ; arrY=DataArrayDouble([2.,3.4,5.6,7.7,9.0,14.2])
10103         cmesh=MEDCouplingCMesh() ; cmesh.setCoordsAt(0,arrX) ; cmesh.setCoordsAt(1,arrY)
10104         umesh=cmesh.buildUnstructured()
10105         #
10106         skin=umesh.computeSkin()
10107         self.assertEqual(18,skin.getNumberOfCells())
10108         self.assertEqual(1,skin.getMeshDimension())
10109         self.assertTrue(skin.getCoords().getHiddenCppPointer()==umesh.getCoords().getHiddenCppPointer())
10110         self.assertEqual([0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48,51,54],skin.getNodalConnectivityIndex().getValues())
10111         self.assertEqual([1,1,0,1,0,5,1,2,1,1,3,2,1,4,3,1,9,4,1,5,10,1,14,9,1,10,15,1,19,14,1,15,20,1,24,19,1,20,25,1,25,26,1,26,27,1,27,28,1,28,29,1,29,24],skin.getNodalConnectivity().getValues())
10112         ids=skin.computeFetchedNodeIds()
10113         self.assertEqual([0,1,2,3,4,5,9,10,14,15,19,20,24,25,26,27,28,29],ids.getValues())
10114         part=umesh.buildFacePartOfMySelfNode(ids,True)
10115         part.setName(skin.getName());
10116         self.assertTrue(part.isEqual(skin,1e-12))
10117         part2=part[1::2]
10118         part[::2]=part2
10119         self.assertTrue(not part.isEqual(skin,1e-12))
10120         trad=part.zipConnectivityTraducer(0)
10121         self.assertEqual(9,part.getNumberOfCells())
10122         self.assertEqual([0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8],trad.getValues())
10123         pass
10124
10125     def testUMeshSetPartOfMySelf2(self):
10126         # resize with explicit ids list
10127         m=MEDCouplingDataForTest.build2DTargetMesh_1()
10128         self.assertEqual([3,4],m.getAllTypes())
10129         part=m[[0,3,4]]
10130         part.simplexize(0)
10131         part2=part[[1,2,5]]
10132         m[[0,3,4]]=part2
10133         self.assertEqual([3,0,4,1,3,1,4,2,3,4,5,2,3,6,7,4,3,7,5,4],m.getNodalConnectivity().getValues())
10134         self.assertEqual([0,4,8,12,16,20],m.getNodalConnectivityIndex().getValues())
10135         self.assertEqual([3],m.getAllTypes())
10136         # no resize with explicit ids list
10137         m=MEDCouplingDataForTest.build2DTargetMesh_1()
10138         part=m[[0,3]]
10139         part.convertAllToPoly()
10140         m[[3,4]]=part
10141         self.assertEqual([4,0,3,4,1,3,1,4,2,3,4,5,2,5,0,3,4,1,5,6,7,4,3],m.getNodalConnectivity().getValues())
10142         self.assertEqual([0,5,9,13,18,23],m.getNodalConnectivityIndex().getValues())
10143         self.assertEqual([3,4,5],m.getAllTypes())
10144         # resize with range ids
10145         m=MEDCouplingDataForTest.build2DTargetMesh_1()
10146         part=m[3:]
10147         m[1:3]=part
10148         self.assertEqual([4,0,3,4,1,4,6,7,4,3,4,7,8,5,4,4,6,7,4,3,4,7,8,5,4],m.getNodalConnectivity().getValues())
10149         self.assertEqual([0,5,10,15,20,25],m.getNodalConnectivityIndex().getValues())
10150         self.assertEqual([4],m.getAllTypes())
10151         # no resize with range ids
10152         m=MEDCouplingDataForTest.build2DTargetMesh_1()
10153         part=m[0::3]
10154         part.convertAllToPoly()
10155         m[3:]=part
10156         self.assertEqual([4,0,3,4,1,3,1,4,2,3,4,5,2,5,0,3,4,1,5,6,7,4,3],m.getNodalConnectivity().getValues())
10157         self.assertEqual([0,5,9,13,18,23],m.getNodalConnectivityIndex().getValues())
10158         self.assertEqual([3,4,5],m.getAllTypes())
10159         # no resize with range ids negative direction
10160         m=MEDCouplingDataForTest.build2DTargetMesh_1()
10161         part=m[3::-3]
10162         part.convertAllToPoly()
10163         m[:-3:-1]=part
10164         self.assertEqual([4,0,3,4,1,3,1,4,2,3,4,5,2,5,0,3,4,1,5,6,7,4,3],m.getNodalConnectivity().getValues())
10165         self.assertEqual([0,5,9,13,18,23],m.getNodalConnectivityIndex().getValues())
10166         self.assertEqual([3,4,5],m.getAllTypes())
10167         pass
10168
10169     def testUnPolyze3(self):
10170         coord=[0.0,0.5,-0.5,-0.5,-0.5,-0.5,0.5,-0.5,-0.5,0.0,0.5,0.5,-0.5,-0.5,0.5,0.5,-0.5,0.5]
10171         conn=[1,2,5,4,-1,4,3,0,1,-1,2,0,3,5,-1,0,2,1,-1,4,5,3]
10172         m=MEDCouplingUMesh.New("a mesh",3);
10173         m.allocateCells(1);
10174         m.insertNextCell(NORM_POLYHED,22,conn[0:22])
10175         m.finishInsertingCells();
10176         coords=DataArrayDouble(coord,6,3);
10177         m.setCoords(coords);
10178         m.checkCoherency();
10179         #
10180         vol=m.getMeasureField(ON_CELLS);
10181         self.assertEqual(1,vol.getArray().getNumberOfTuples());
10182         self.assertAlmostEqual(0.5,vol.getArray().getIJ(0,0),12)
10183         #
10184         m.unPolyze();
10185         #
10186         self.assertEqual([NORM_PENTA6],m.getAllTypes())
10187         self.assertTrue(DataArrayInt([0,7]).isEqual(m.getNodalConnectivityIndex()))
10188         self.assertTrue(DataArrayInt([16,0,2,1,3,5,4]).isEqual(m.getNodalConnectivity()))
10189         #
10190         vol=m.getMeasureField(ON_CELLS);
10191         self.assertEqual(1,vol.getArray().getNumberOfTuples());
10192         self.assertAlmostEqual(0.5,vol.getArray().getIJ(0,0),12)
10193         pass
10194
10195     def testKrSpatialDiscretization1(self):
10196         srcPointCoordsX=[0.8401877171547095, 0.7830992237586059, 0.9116473579367843, 0.335222755714889, 0.2777747108031878, 0.4773970518621602, 0.3647844727918433, 0.9522297251747128, 0.6357117279599009, 0.1416025553558034]
10197         srcFieldValsOnPoints=[2.129892434968836, 2.295320474540621, 1.931948594981134, 2.728013590937196, 2.715603240418478, 2.661778472822935, 2.695696990104364, 1.893710234970982, 2.529628016549284, 2.728432341300668]
10198         targetPointCoordsX=[-0.5,-0.45,-0.4,-0.35,-0.3,-0.25,-0.2,-0.15,-0.1,-0.05,-6.93889390391e-17,0.05,0.1,0.15,0.2,0.25,0.3,0.35,0.4,0.45,0.5,0.55,0.6,0.65,0.7,0.75,0.8,0.85,0.9,0.95,1.0,1.05,1.1,1.15,1.2,1.25,1.3,1.35,1.4,1.45]
10199         targetFieldValsExpected=[2.975379475824351, 2.95613491917003, 2.936890362515361, 2.917645805861018, 2.898401249206574, 2.879156692552137, 2.859912135897732, 2.840667579243201, 2.821423022588731, 2.802178465934342, 2.78293390927989, 2.763689352625457, 2.744444795971001, 2.725209522098197, 2.709077577124666, 2.706677252549218, 2.727467797847971, 2.713338094723676, 2.671342424824244, 2.664877370146978, 2.653840141412181, 2.619607861392791, 2.569777214476479, 2.513263929794591, 2.450732752808528, 2.368313560985155, 2.250909795670307, 2.098194272085416, 1.954257891732065, 1.895040660973802, 1.865256788315972, 1.835475248687992, 1.80569370905998, 1.775912169431971, 1.746130629803976, 1.716349090175918, 1.686567550547855, 1.656786010919941, 1.627004471291988, 1.597222931663817]
10200         coeffsExpected=DataArrayDouble.New([52.238272642008695, 26.186513281350948, -173.42106377948534, 324.56733663875184, -104.64968873410248, 34.375030568158316, -256.12372208190425, 105.2292032463934, -16.239907618144965, 7.838025836978943, 2.621910745077291, -0.4902609628247241])
10201         #
10202         nbOfInputPoints=10;
10203         f=MEDCouplingFieldDouble.New(ON_NODES_KR,ONE_TIME);
10204         srcArrX=DataArrayDouble.New(srcPointCoordsX,nbOfInputPoints,1);
10205         cmesh=MEDCouplingCMesh.New("aMesh");
10206         cmesh.setCoordsAt(0,srcArrX);
10207         umesh=cmesh.buildUnstructured();
10208         f.setMesh(umesh);
10209         srcVals=DataArrayDouble.New(srcFieldValsOnPoints,nbOfInputPoints,1);
10210         f.setArray(srcVals);
10211         f.checkCoherency();
10212         #
10213         res0=f.getValueOn(targetPointCoordsX[:1]);
10214         self.assertAlmostEqual(targetFieldValsExpected[0],res0[0],10)
10215         #
10216         valuesToTest=f.getValueOnMulti(targetPointCoordsX);
10217         self.assertEqual(40,valuesToTest.getNumberOfTuples());
10218         self.assertEqual(1,valuesToTest.getNumberOfComponents());
10219         for i in xrange(40):
10220             self.assertAlmostEqual(targetFieldValsExpected[i],valuesToTest.getIJ(i,0),10)
10221             pass
10222         fd=f.getDiscretization()
10223         del f
10224         self.assertTrue(isinstance(fd,MEDCouplingFieldDiscretizationKriging))
10225         coeffs,isDrift=fd.computeVectorOfCoefficients(umesh,srcVals)
10226         self.assertEqual(2,isDrift)
10227         self.assertTrue(coeffsExpected.isEqual(coeffs,1e-8))
10228         #
10229         pass
10230
10231     def testDuplicateEachTupleNTimes1(self):
10232         d=DataArrayDouble.New([9.,8.,7.,6.],4,1) ; d.setInfoOnComponents(["mass [kg]"]) ; d.setName("aname")
10233         d2=d.duplicateEachTupleNTimes(3)
10234         self.assertTrue(d2.isEqualWithoutConsideringStr(DataArrayDouble.New([9.,9.,9.,8.,8.,8.,7.,7.,7.,6.,6.,6.],4*3,1),1e-14))
10235         self.assertEqual("aname",d2.getName())
10236         self.assertEqual(["mass [kg]"],d2.getInfoOnComponents())
10237         #
10238         d=DataArrayInt.New([9,8,7,6],4,1) ; d.setInfoOnComponents(["mass [kg]"]) ; d.setName("aname")
10239         d2=d.duplicateEachTupleNTimes(3)
10240         self.assertTrue(d2.isEqualWithoutConsideringStr(DataArrayInt.New([9,9,9,8,8,8,7,7,7,6,6,6],4*3,1)))
10241         self.assertEqual("aname",d2.getName())
10242         self.assertEqual(["mass [kg]"],d2.getInfoOnComponents())
10243         pass
10244
10245     def testSwigComputeTupleIdsNearTuples1(self):
10246         da=DataArrayDouble([5.,6.,-5.,-6.,5.,-6.,-5.,6.,5.,6.],5,2)
10247         arr,arrI=da.computeTupleIdsNearTuples(DataArrayDouble([5.,-6.,5.,6.,-5.,-6.],3,2),1e-10)
10248         self.assertEqual([2,0,4,1],arr.getValues())
10249         self.assertEqual([0,1,3,4],arrI.getValues())
10250         arr,arrI=da.computeTupleIdsNearTuples([5.,-6.,5.,6.,-5.,-6.],1e-10)
10251         self.assertEqual([2,0,4,1],arr.getValues())
10252         self.assertEqual([0,1,3,4],arrI.getValues())
10253         expected0=[[2],[0,4],[1]]
10254         expected1=[[0,1],[0,2],[0,1]]
10255         for pos,it in enumerate(DataArrayDouble([5.,-6.,5.,6.,-5.,-6.],3,2)):
10256             arr,arrI=da.computeTupleIdsNearTuples(it,1e-10)
10257             self.assertEqual(expected0[pos],arr.getValues())
10258             self.assertEqual(expected1[pos],arrI.getValues())
10259             pass
10260         pass
10261
10262     def testSwigDataTupleIOp1(self):
10263         d=DataArrayDouble(10,1)
10264         d.iota(7.)
10265         for elt in d:
10266             elt+=2.
10267             pass
10268         toTest=DataArrayDouble([9.0,10.0,11.0,12.0,13.0,14.0,15.0,16.0,17.0,18.0])
10269         self.assertTrue(toTest.isEqual(d,1e-12))
10270         for elt in d:
10271             elt-=2.
10272             pass
10273         toTest=DataArrayDouble([7.0,8.0,9.0,10.0,11.0,12.0,13.0,14.0,15.0,16.0])
10274         self.assertTrue(toTest.isEqual(d,1e-12))
10275         for elt in d:
10276             elt*=2.
10277             pass
10278         toTest=DataArrayDouble([14.0,16.0,18.0,20.0,22.0,24.0,26.0,28.0,30.0,32.0])
10279         self.assertTrue(toTest.isEqual(d,1e-12))
10280         for elt in d:
10281             elt/=2.
10282             pass
10283         toTest=DataArrayDouble([7.0,8.0,9.0,10.0,11.0,12.0,13.0,14.0,15.0,16.0])
10284         self.assertTrue(toTest.isEqual(d,1e-12))
10285         #
10286         d=DataArrayInt(10,1)
10287         d.iota(7)
10288         for elt in d:
10289             elt+=2
10290             pass
10291         self.assertEqual(d.getValues(),[9,10,11,12,13,14,15,16,17,18])
10292         for elt in d:
10293             elt-=2
10294             pass
10295         self.assertEqual(d.getValues(),[7,8,9,10,11,12,13,14,15,16])
10296         for elt in d:
10297             elt*=2
10298             pass
10299         self.assertEqual(d.getValues(),[14,16,18,20,22,24,26,28,30,32])
10300         for elt in d:
10301             elt/=2
10302             pass
10303         self.assertEqual(d.getValues(),[7,8,9,10,11,12,13,14,15,16])
10304         for elt in d:
10305             elt%=3
10306             pass
10307         self.assertEqual(d.getValues(),[1,2,0,1,2,0,1,2,0,1])
10308         pass
10309
10310     def testIntersect2DMeshesTmp5(self):
10311         coords=DataArrayDouble.New([41,0,42,0,0,42,0,41,41.5,0,29.698484809834998,29.698484809834994,0,41.5,28.991378028648452,28.991378028648445,-42,0,-41,0,-29.698484809834994,29.698484809834998,-41.5,0,-28.991378028648445,28.991378028648452,0,-42,0,-41,-29.698484809835001,-29.698484809834994,0,-41.5,-28.991378028648455,-28.991378028648445,29.698484809834987,-29.698484809835001,28.991378028648441,-28.991378028648455,43,0,0,43,42.5,0,30.405591591021544,30.40559159102154,0,42.5,-43,0,-30.40559159102154,30.405591591021544,-42.5,0,0,-43,-30.405591591021551,-30.40559159102154,0,-42.5,30.405591591021537,-30.405591591021551,44,0,0,44,43.5,0,31.112698372208094,31.112698372208087,0,43.5,-44,0,-31.112698372208087,31.112698372208094,-43.5,0,0,-44,-31.112698372208097,-31.112698372208087,0,-43.5,31.112698372208083,-31.112698372208097,45,0,0,45,44.5,0,31.81980515339464,31.819805153394636,0,44.5,-45,0,-31.819805153394636,31.81980515339464,-44.5,0,0,-45,-31.819805153394647,-31.819805153394636,0,-44.5,31.819805153394629,-31.819805153394647,47,0,0,47,46,0,33.234018715767739,33.234018715767732,0,46,-47,0,-33.234018715767732,33.234018715767739,-46,0,0,-47,-33.234018715767739,-33.234018715767732,0,-46,33.234018715767725,-33.234018715767739,49,0,0,49,48,0,34.648232278140831,34.648232278140824,0,48,-49,0,-34.648232278140824,34.648232278140831,-48,0,0,-49,-34.648232278140839,-34.648232278140824,0,-48,34.648232278140817,-34.648232278140839,51,0,0,51,50,0,36.062445840513924,36.062445840513924,0,50,-51,0,-36.062445840513924,36.062445840513924,-50,0,0,-51,-36.062445840513931,-36.062445840513924,0,-50,36.062445840513917,-36.062445840513931,53,0,0,53,52,0,37.476659402887023,37.476659402887016,0,52,-53,0,-37.476659402887016,37.476659402887023,-52,0,0,-53,-37.47665940288703,-37.476659402887016,0,-52,37.476659402887009,-37.47665940288703,55,0,0,55,54,0,38.890872965260115,38.890872965260108,0,54,-55,0,-38.890872965260108,38.890872965260115,-54,0,0,-55,-38.890872965260122,-38.890872965260108,0,-54,38.890872965260101,-38.890872965260122,59,0,0,59,57,0,41.719300090006307,41.7193000900063,0,57,-59,0,-41.7193000900063,41.719300090006307,-57,0,0,-59,-41.719300090006314,-41.7193000900063,0,-57,41.719300090006293,-41.719300090006314,63,0,0,63,61,0,44.547727214752499,44.547727214752491,0,61,-63,0,-44.547727214752491,44.547727214752499,-61,0,0,-63,-44.547727214752506,-44.547727214752491,0,-61,44.547727214752484,-44.547727214752506,67,0,0,67,65,0,47.37615433949869,47.376154339498683,0,65,-67,0,-47.376154339498683,47.37615433949869,-65,0,0,-67,-47.376154339498697,-47.376154339498683,0,-65,47.376154339498676,-47.376154339498697,71,0,0,71,69,0,50.204581464244875,50.204581464244868,0,69,-71,0,-50.204581464244868,50.204581464244875,-69,0,0,-71,-50.204581464244889,-50.204581464244868,0,-69,50.20458146424486,-50.204581464244889,75,0,0,75,73,0,53.033008588991066,53.033008588991059,0,73,-75,0,-53.033008588991059,53.033008588991066,-73,0,0,-75,-53.033008588991073,-53.033008588991059,0,-73,53.033008588991052,-53.033008588991073,80,0,0,80,77.5,0,56.568542494923804,56.568542494923797,0,77.5,-80,0,-56.568542494923797,56.568542494923804,-77.5,0,0,-80,-56.568542494923818,-56.568542494923797,0,-77.5,56.56854249492379,-56.568542494923818],188,2)
10312         conn=DataArrayInt.New([8,0,1,2,3,4,5,6,7,8,3,2,8,9,6,10,11,12,8,9,8,13,14,11,15,16,17,8,14,13,1,0,16,18,4,19,8,1,20,21,2,22,23,24,5,8,2,21,25,8,24,26,27,10,8,8,25,28,13,27,29,30,15,8,13,28,20,1,30,31,22,18,8,20,32,33,21,34,35,36,23,8,21,33,37,25,36,38,39,26,8,25,37,40,28,39,41,42,29,8,28,40,32,20,42,43,34,31,8,32,44,45,33,46,47,48,35,8,33,45,49,37,48,50,51,38,8,37,49,52,40,51,53,54,41,8,40,52,44,32,54,55,46,43,8,44,56,57,45,58,59,60,47,8,45,57,61,49,60,62,63,50,8,49,61,64,52,63,65,66,53,8,52,64,56,44,66,67,58,55,8,56,68,69,57,70,71,72,59,8,57,69,73,61,72,74,75,62,8,61,73,76,64,75,77,78,65,8,64,76,68,56,78,79,70,67,8,68,80,81,69,82,83,84,71,8,69,81,85,73,84,86,87,74,8,73,85,88,76,87,89,90,77,8,76,88,80,68,90,91,82,79,8,80,92,93,81,94,95,96,83,8,81,93,97,85,96,98,99,86,8,85,97,100,88,99,101,102,89,8,88,100,92,80,102,103,94,91,8,92,104,105,93,106,107,108,95,8,93,105,109,97,108,110,111,98,8,97,109,112,100,111,113,114,101,8,100,112,104,92,114,115,106,103,8,104,116,117,105,118,119,120,107,8,105,117,121,109,120,122,123,110,8,109,121,124,112,123,125,126,113,8,112,124,116,104,126,127,118,115,8,116,128,129,117,130,131,132,119,8,117,129,133,121,132,134,135,122,8,121,133,136,124,135,137,138,125,8,124,136,128,116,138,139,130,127,8,128,140,141,129,142,143,144,131,8,129,141,145,133,144,146,147,134,8,133,145,148,136,147,149,150,137,8,136,148,140,128,150,151,142,139,8,140,152,153,141,154,155,156,143,8,141,153,157,145,156,158,159,146,8,145,157,160,148,159,161,162,149,8,148,160,152,140,162,163,154,151,8,152,164,165,153,166,167,168,155,8,153,165,169,157,168,170,171,158,8,157,169,172,160,171,173,174,161,8,160,172,164,152,174,175,166,163,8,164,176,177,165,178,179,180,167,8,165,177,181,169,180,182,183,170,8,169,181,184,172,183,185,186,173,8,172,184,176,164,186,187,178,175],540)
10313         connI=DataArrayInt.New([0,9,18,27,36,45,54,63,72,81,90,99,108,117,126,135,144,153,162,171,180,189,198,207,216,225,234,243,252,261,270,279,288,297,306,315,324,333,342,351,360,369,378,387,396,405,414,423,432,441,450,459,468,477,486,495,504,513,522,531,540],61)
10314         #
10315         m1=MEDCouplingUMesh.New("Fix",2);
10316         m1.setCoords(coords);
10317         m1.setConnectivity(conn,connI,True);
10318         #
10319         coords=DataArrayDouble([46.5,-2.5,53.5,-2.5,53.5,2.5,46.5,2.5,50,-2.5,53.5,0,50,2.5,46.5,0,60.5,-2.5,60.5,2.5,57,-2.5,60.5,0,57,2.5,53.5,7.5,46.5,7.5,53.5,5,50,7.5,46.5,5,60.5,7.5,60.5,5,57,7.5,-2,47,2,47,2,53,-2,53,0,47,2,50,0,53,-2,50,6,47,6,53,4,47,6,50,4,53,2,59,-2,59,2,56,0,59,-2,56,6,59,6,56,4,59],42,2)
10320         # connectivity
10321         conn=DataArrayInt([8,0,1,2,3,4,5,6,7,8,1,8,9,2,10,11,12,5,8,3,2,13,14,6,15,16,17,8,2,9,18,13,12,19,20,15,8,21,22,23,24,25,26,27,28,8,22,29,30,23,31,32,33,26,8,24,23,34,35,27,36,37,38,8,23,30,39,34,33,40,41,36],72);
10322         conn.setName("");
10323         connI=DataArrayInt([0,9,18,27,36,45,54,63,72],9)
10324         m2=MEDCouplingUMesh.New("Mobile",2);
10325         m2.setCoords(coords);
10326         m2.setConnectivity(conn,connI,True);
10327         #
10328         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m1,m2,1e-10);
10329         self.assertEqual(105,m3.getNumberOfCells());
10330         self.assertEqual(105,d1.getNumberOfTuples());
10331         self.assertEqual(105,d2.getNumberOfTuples());
10332         self.assertEqual(704,m3.getNumberOfNodes());
10333         #
10334         areaExpected=[-65.18804756198824,-65.18804756198824,-65.18804756198824,-65.18804756198824,-66.75884388878285,-66.75884388878285,-66.7588438887833,-66.75884388878308,-68.32964021557768,-68.32964021557768,-68.32964021557814,-68.32964021557791,-69.9004365423732,-69.9004365423732,-69.90043654237297,-69.90043654237297,-1.194568659706448,-1.0869994447159463,-142.2316939607081,-144.51326206513068,-144.5132620651309,-1.1945686597064424,-143.3186934054243,-5.002264310862817,-10.0261332846393,-3.9727823117092953,-7.290862524642649,-124.504404940456,-3.9727823117093237,-146.82366506060032,-150.79644737231024,-5.002264310862776,-145.79418306144626,-5.00208651738126,-10.054764051268958,-4.001067863263231,-8.027932154428669,-129.99378209314813,-4.001067863263216,-153.07856481622616,-157.0796326794898,-5.0020865173811915,-152.07754616210832,-5.001928880064381,-10.050590216368969,-4.00098721602491,-8.025810856794209,-136.28350081741684,-4.000987216024939,-159.36183077064402,-163.36281798667005,-5.0019288800643285,-158.36088910660442,-1.2991516319851801,-3.702636830195414,-3.7815130030068254,-6.265364371195623,-0.02516260900254963,-0.6553944641345026,-3.975752765070567,-7.368528340442765,-142.57249927881398,-0.02516260900254963,-3.9757527650706095,-165.64508791977525,-169.64600329384803,-1.299151631985167,-3.7026368301953885,-164.6442148316677,-10.00321285677458,-20.08414323176165,-8.001644468035863,-16.042954878437143,-304.0096070742277,-8.00164446803587,-350.1399180412005,-358.1415625092368,-10.003212856774468,-348.13834965246224,-3.794150313030109,-8.65049239704272,-0.02260276689354157,-0.5885167811200915,-370.2185414798688,-0.022602766893559393,-383.2517009710623,-383.2743037379555,-3.7941503130300576,-379.48015342492505,-408.40704496667513,-408.4070449666742,-408.4070449666742,-408.4070449666742,-433.53978619538975,-433.5397861953902,-433.5397861953911,-433.53978619539066,-458.67252742410983,-458.6725274241094,-458.67252742410983,-458.6725274241089,-608.6835766330232,-608.6835766330232,-608.6835766330232,-608.6835766330241]
10335         expected1=[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,16,16,17,18,19,19,20,20,20,20,20,21,21,22,23,23,24,24,24,24,24,25,25,26,27,27,28,28,28,28,28,29,29,30,31,31,32,32,32,32,32,32,32,32,32,33,33,33,34,35,35,35,36,36,36,36,36,37,37,38,39,39,40,40,40,40,40,41,41,42,43,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59]
10336         expected2=[-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,0,2,-1,-1,-1,0,-1,0,2,4,5,-1,4,-1,-1,0,-1,0,2,4,5,-1,4,-1,-1,0,-1,0,2,4,5,-1,4,-1,-1,0,-1,0,1,2,3,4,5,6,7,-1,4,6,-1,-1,0,1,-1,1,3,6,7,-1,6,-1,-1,1,-1,1,3,6,7,-1,6,-1,-1,1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1]
10337         f3=m3.getMeasureField(ON_CELLS).getArray().getValues();
10338         for i in xrange(105):
10339             self.assertAlmostEqual(areaExpected[i],f3[i],10)
10340             pass
10341         self.assertEqual(expected1,d1.getValues())
10342         self.assertEqual(expected2,d2.getValues())
10343         pass
10344
10345     def testDAIBuildUnique1(self):
10346         d=DataArrayInt([1,2,2,3,3,3,3,4,5,5,7,7,7,19])
10347         e=d.buildUnique()
10348         self.assertTrue(e.isEqual(DataArrayInt([1,2,3,4,5,7,19])))
10349         pass
10350
10351     def testDAIPartitionByDifferentValues1(self):
10352         d=DataArrayInt([1,0,1,2,0,2,2,-3,2])
10353         expected=[[-3,[7]],[0,[1,4]],[1,[0,2]],[2,[3,5,6,8]]]
10354         for i,elt in enumerate(zip(*d.partitionByDifferentValues())):
10355             self.assertEqual(expected[i][0],elt[1])
10356             self.assertEqual(expected[i][1],elt[0].getValues())
10357             pass
10358         pass
10359
10360     def testFieldGaussMultiDiscPerType1(self):
10361         coords=DataArrayDouble([0.,0.,0.,1.,1.,1.,1.,0.,0.,0.5,0.5,1.,1.,0.5,0.5,0.],8,2)
10362         mQ8=MEDCouplingUMesh("",2) ; mQ8.setCoords(coords)
10363         mQ8.allocateCells(1)
10364         mQ8.insertNextCell(NORM_QUAD8,range(8))
10365         mQ8.finishInsertingCells()
10366         mQ4=MEDCouplingUMesh("",2) ; mQ4.setCoords(coords)
10367         mQ4.allocateCells(1)
10368         mQ4.insertNextCell(NORM_QUAD4,range(4))
10369         mQ4.finishInsertingCells()
10370         mT3=MEDCouplingUMesh("",2) ; mT3.setCoords(coords)
10371         mT3.allocateCells(1)
10372         mT3.insertNextCell(NORM_TRI3,range(3))
10373         mT3.finishInsertingCells()
10374         
10375         tr=[[0.,0.],[2.,0.], [0.,2.],[2.,2.],[4.,2.],[6.,2.],[8.,2.],[10.,2.],[12.,2.],[0.,4.],[2.,4.],[4.,4.],[6.,4.],[8.,4.],[10.,4.],[12.,4.],[14.,4.],[16.,4.],[18.,4.],[20.,4.],[22.,4.]]
10376         ms=2*[mQ4]+7*[mQ8]+11*[mT3]
10377         ms[:]=(elt.deepCpy() for elt in ms)
10378         for m,t in zip(ms,tr):
10379             d=m.getCoords() ; d+= t
10380             pass
10381         m=MEDCouplingUMesh.MergeUMeshes(ms)
10382         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,NO_TIME)
10383         f.setMesh(m)
10384         # throw because cell 0,1 are QUAD4 and cell 3 is QUAD8
10385         self.assertRaises(InterpKernelException,f.setGaussLocalizationOnCells,[0,1,3],[0.,0.,1.,0.,1.,1.,0.,1.],[0.3,0.3,0.7,0.7],[0.8,0.2])
10386         f.setGaussLocalizationOnCells([0,1],[0.,0.,1.,0.,1.,1.,0.,1.],[0.3,0.3,0.7,0.7],[0.8,0.2])
10387         f.setGaussLocalizationOnCells([3,2,5],[0.,0.,1.,0.,1.,1.,0.,1.,0.5,0.,1.,0.5,0.5,1.,0.,0.5],[0.3,0.3,0.7,0.7,0.9,0.9],[0.8,0.05,0.15])
10388         f.setGaussLocalizationOnCells([4,6,8,7],[0.,0.,1.,0.,1.,1.,0.,1.,0.5,0.,1.,0.5,0.5,1.,0.,0.5],[0.3,0.3,0.7,0.7,0.9,0.9,-0.1,0.3],[0.7,0.05,0.15,0.1])
10389         f.setGaussLocalizationOnCells([9,10,11,12,13],[0.,0.,1.,0.,1.,1.],[0.4,0.4],[1.])
10390         f.setGaussLocalizationOnCells([14,15,16,17,18,19],[0.,0.,1.,0.,1.,1.],[0.4,0.4,0.14,0.16],[0.22,0.78])
10391         self.assertEqual(46,f.getNumberOfTuplesExpected())
10392         vals=DataArrayDouble.New(46*3,1) ; vals.iota(7.7) ; vals.rearrange(3)
10393         f.setArray(vals)
10394         f.checkCoherency()
10395         #f.getLocalizationOfDiscr()
10396         self.assertRaises(InterpKernelException,f.getGaussLocalizationIdOfOneType,NORM_QUAD8) #throw because several loc
10397         self.assertEqual([1,2],f.getGaussLocalizationIdsOfOneType(NORM_QUAD8))
10398         self.assertEqual([0,0,1,1,2,1,2,2,2,3,3,3,3,3,4,4,4,4,4,4],f.getDiscretization().getArrayOfDiscIds().getValues())
10399         fc=f[[1,2,3,8]]
10400         fc.checkCoherency()
10401         self.assertTrue(DataArrayDouble([13.7,14.7,15.7,16.7,17.7,18.7,19.7,20.7,21.7,22.7,23.7,24.7,25.7,26.7,27.7,28.7,29.7,30.7,31.7,32.7,33.7,34.7,35.7,36.7,82.7,83.7,84.7,85.7,86.7,87.7,88.7,89.7,90.7,91.7,92.7,93.7],12,3).isEqual(fc.getArray(),1e-10))
10402         fc.renumberCells([3,2,0,1])
10403         self.assertTrue(DataArrayDouble([28.7, 29.7, 30.7, 31.7, 32.7, 33.7, 34.7, 35.7, 36.7, 82.7, 83.7, 84.7, 85.7, 86.7, 87.7, 88.7, 89.7, 90.7, 91.7, 92.7, 93.7, 19.7, 20.7, 21.7, 22.7, 23.7, 24.7, 25.7, 26.7, 27.7, 13.7, 14.7, 15.7, 16.7, 17.7, 18.7],12,3).isEqual(fc.getArray(),1e-10))
10404         fc.getArray()
10405         pass
10406
10407     def testSwigRotate(self):
10408         d=DataArrayDouble([1.,2.,3.,4.,6.,5.],2,3)
10409         MEDCouplingPointSet.Rotate3DAlg([0.,0.,0.],[0.,1.,0.],1.5707963267948966,d)
10410         self.assertTrue(d.isEqual(DataArrayDouble([3.,2.,-1.,5.,6.,-4.],2,3),1e-12))
10411         d=DataArrayDouble([1.,2.,3.,4.,6.,5.],3,2)
10412         MEDCouplingPointSet.Rotate2DAlg([0.,0.],1.5707963267948966,d)
10413         self.assertTrue(d.isEqual(DataArrayDouble([-2.,1.,-4.,3.,-5.,6.],3,2),1e-12))
10414         pass
10415
10416     def testSwigCMeshProtection(self):
10417         cm=MEDCouplingCMesh()
10418         self.assertRaises(InterpKernelException,cm.setCoordsAt,0,DataArrayDouble([4.,4.5,6.,7.],2,2))
10419         self.assertRaises(InterpKernelException,cm.setCoords,DataArrayDouble([4.,4.5,6.,7.],2,2))
10420         pass
10421
10422     def testSwigCellsInBoundingBox1(self):
10423         m3D=MEDCouplingDataForTest.build3DExtrudedUMesh_1()[0]
10424         self.assertTrue(m3D.getCellsInBoundingBox([(0,3),(0,3),(0,1)],-1e-12).isEqual(DataArrayInt([0,1,2,3,4,5])))
10425         self.assertRaises(InterpKernelException,m3D.getCellsInBoundingBox,[(0,3,0),(3,0,1)],-1e-12)
10426         pass
10427
10428     def testDAICheckMonotonic1(self):
10429         data1=[-1,0,2,2,4,5]
10430         data2=[6,2,0,-8,-9,-56]
10431         data3=[-1,0,3,2,4,6]
10432         data4=[7,5,2,3,0,-6]
10433         d=DataArrayInt.New(data1);
10434         self.assertTrue(d.isMonotonic(True));
10435         self.assertTrue(not d.isMonotonic(False));
10436         d.checkMonotonic(True);
10437         self.assertRaises(InterpKernelException,d.checkMonotonic,False)
10438         d=DataArrayInt.New(data2);
10439         self.assertTrue(d.isMonotonic(False));
10440         self.assertTrue(not d.isMonotonic(True));
10441         d.checkMonotonic(False);
10442         self.assertRaises(InterpKernelException,d.checkMonotonic,True)
10443         d=DataArrayInt.New(data3);
10444         self.assertTrue(not d.isMonotonic(False));
10445         self.assertTrue(not d.isMonotonic(True));
10446         self.assertRaises(InterpKernelException,d.checkMonotonic,True)
10447         self.assertRaises(InterpKernelException,d.checkMonotonic,False)
10448         d=DataArrayInt.New(data4);
10449         self.assertTrue(not d.isMonotonic(False));
10450         self.assertTrue(not d.isMonotonic(True));
10451         self.assertRaises(InterpKernelException,d.checkMonotonic,True)
10452         self.assertRaises(InterpKernelException,d.checkMonotonic,False)
10453         d=DataArrayInt.New(0,1)
10454         self.assertTrue(d.isMonotonic(True));
10455         self.assertTrue(d.isMonotonic(False));
10456         d.checkMonotonic(True);
10457         d.checkMonotonic(False);
10458         d=DataArrayInt.New(data4,3,2);#throw because nbComp!=1
10459         self.assertRaises(InterpKernelException,d.isMonotonic,True)
10460         self.assertRaises(InterpKernelException,d.isMonotonic,False)
10461         self.assertRaises(InterpKernelException,d.checkMonotonic,True)
10462         self.assertRaises(InterpKernelException,d.checkMonotonic,False)
10463         pass
10464
10465     def testSwigDASetItemOnEmpty1(self):
10466         d=DataArrayInt(0,1)
10467         isThrow=False
10468         try:
10469             d[0:1000:2]=4
10470         except InterpKernelException as e:
10471             isThrow=True
10472             pass
10473         self.assertTrue(isThrow)
10474         d[:]=4
10475         d[::2]=5
10476         #
10477         d=DataArrayDouble(0,1)
10478         isThrow=False
10479         try:
10480             d[0:1000:2]=4
10481         except InterpKernelException as e:
10482             isThrow=True
10483             pass
10484         self.assertTrue(isThrow)
10485         d[:]=4
10486         d[::2]=5
10487         d=DataArrayInt([],0,1)
10488         d2=DataArrayInt(0)
10489         self.assertTrue(d2.isEqual(d))
10490         d=DataArrayDouble([],0,1)
10491         d2=DataArrayDouble(0)
10492         self.assertTrue(d2.isEqual(d,1e-12))
10493         pass
10494
10495     def testSwigDAITransformWithIndArr1(self):
10496         arr=DataArrayInt([0,4,5,1])
10497         d=DataArrayInt([7,8,9,10])
10498         self.assertRaises(InterpKernelException,arr.transformWithIndArr,d)
10499         pass
10500
10501     def testIntersect2DMeshesTmp6(self):
10502         # coordinates
10503         coords=DataArrayDouble.New([2.7554552980815448e-15,45,-45,5.5109105961630896e-15,-31.819805153394636,31.81980515339464,2.8779199779962799e-15,47,2.8166876380389124e-15,46,-47,5.7558399559925599e-15,-33.234018715767732,33.234018715767739,-46,5.6333752760778247e-15],8,2);
10504         # connectivity
10505         conn=DataArrayInt.New([8,0,3,5,1,4,6,7,2])
10506         connI=DataArrayInt.New([0,9]);
10507         m1=MEDCouplingUMesh.New("Fixe",2);
10508         m1.setCoords(coords);
10509         m1.setConnectivity(conn,connI,True);
10510         #
10511         coords=DataArrayDouble.New([-7.3800475508445391,41.854329503018846,-3.7041190667754655,42.338274668899189,-3.7041190667754655,45.338274668899189,-7.3800475508445382,44.854329503018839,-5.5473631693521845,42.136406608386956,-3.7041190667754655,43.838274668899189,-5.5420833088100014,45.09630208595901,-7.3800475508445382,43.354329503018839,-3.7041190667754651,52.338274668899189,-7.3800475508445382,51.854329503018839,-3.7041190667754655,48.838274668899189,-5.5420833088100014,52.09630208595901,-7.3800475508445382,48.354329503018839],13,2);
10512         # connectivity
10513         conn=DataArrayInt.New([8,0,1,2,3,4,5,6,7,8,3,2,8,9,6,10,11,12]);
10514         connI=DataArrayInt.New([0,9,18]);
10515         #
10516         m2=MEDCouplingUMesh.New("Mobile",2);
10517         m2.setCoords(coords);
10518         m2.setConnectivity(conn,connI,True);
10519         #
10520         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m1,m2,1e-10);
10521         self.assertTrue(d1.isEqual(DataArrayInt([0,0,0,0])));
10522         self.assertTrue(d2.isEqual(DataArrayInt([0,1,-1,-1])));
10523         self.assertEqual(4,m3.getNumberOfCells());
10524         self.assertEqual(4,d1.getNumberOfTuples());
10525         self.assertEqual(4,d2.getNumberOfTuples());
10526         self.assertEqual(43,m3.getNumberOfNodes());
10527         dI,areMerged,newNbOfNodes=m3.mergeNodes(1e-12)
10528         self.assertEqual(35,m3.getNumberOfNodes());
10529         m3.zipCoords();
10530         self.assertEqual(23,m3.getNumberOfNodes());
10531         #
10532         f=m3.getMeasureField(True);
10533         valuesExpected=DataArrayDouble([1.6603638692585716,5.747555728471923,129.68907101754394,7.4162714498559694])
10534         self.assertTrue(f.getArray().isEqual(valuesExpected,1e-12))
10535         pass
10536
10537     def testDAPushBack(self):
10538         d=DataArrayDouble(0,1)
10539         for i in xrange(8):
10540             d.pushBackSilent(i)
10541             pass
10542         self.assertEqual(d.getNumberOfTuples(),8)
10543         self.assertEqual(d.getNbOfElemAllocated(),8)
10544         d.pushBackSilent(4.44)
10545         self.assertEqual(d.getNumberOfTuples(),9)
10546         self.assertEqual(d.getNbOfElemAllocated(),16)
10547         self.assertTrue(d.isEqual(DataArrayDouble([0.,1.,2.,3.,4.,5.,6.,7.,4.44]),1e-12))
10548         e=d.deepCpy()
10549         self.assertEqual(e.getNumberOfTuples(),9)
10550         self.assertEqual(e.getNbOfElemAllocated(),9)
10551         self.assertTrue(e.isEqual(DataArrayDouble([0.,1.,2.,3.,4.,5.,6.,7.,4.44]),1e-12))
10552         self.assertAlmostEqual(d.popBackSilent(),4.44,12)
10553         self.assertEqual(d.getNumberOfTuples(),8)
10554         self.assertEqual(d.getNbOfElemAllocated(),16)
10555         self.assertTrue(d.isEqual(DataArrayDouble([0.,1.,2.,3.,4.,5.,6.,7.]),1e-12))
10556         f=DataArrayDouble()
10557         f.reserve(1000)
10558         f.pushBackSilent(4.)
10559         self.assertTrue(f.isEqual(DataArrayDouble([4.]),1e-12))
10560         self.assertEqual(f.getNumberOfTuples(),1)
10561         self.assertEqual(f.getNbOfElemAllocated(),1000)
10562         ff=f[:]
10563         self.assertTrue(ff.isEqual(DataArrayDouble([4.]),1e-12))
10564         self.assertEqual(ff.getNumberOfTuples(),1)
10565         self.assertEqual(ff.getNbOfElemAllocated(),1)
10566         d=DataArrayDouble()
10567         d.pushBackSilent(4.44)
10568         d.pushBackSilent(5.55)
10569         d.pushBackSilent(6.66)
10570         self.assertTrue(d.isEqual(DataArrayDouble([4.44,5.55,6.66]),1e-12))
10571         #
10572         d=DataArrayInt(0,1)
10573         for i in xrange(8):
10574             d.pushBackSilent(i)
10575             pass
10576         self.assertEqual(d.getNumberOfTuples(),8)
10577         self.assertEqual(d.getNbOfElemAllocated(),8)
10578         d.pushBackSilent(444)
10579         self.assertEqual(d.getNumberOfTuples(),9)
10580         self.assertEqual(d.getNbOfElemAllocated(),16)
10581         self.assertTrue(d.isEqual(DataArrayInt([0,1,2,3,4,5,6,7,444])))
10582         e=d.deepCpy()
10583         self.assertEqual(e.getNumberOfTuples(),9)
10584         self.assertEqual(e.getNbOfElemAllocated(),9)
10585         self.assertTrue(e.isEqual(DataArrayInt([0,1,2,3,4,5,6,7,444])))
10586         self.assertEqual(d.popBackSilent(),444)
10587         self.assertEqual(d.getNumberOfTuples(),8)
10588         self.assertEqual(d.getNbOfElemAllocated(),16)
10589         self.assertTrue(d.isEqual(DataArrayInt([0,1,2,3,4,5,6,7])))
10590         f=DataArrayInt()
10591         f.reserve(1000)
10592         f.pushBackSilent(4)
10593         self.assertTrue(f.isEqual(DataArrayInt([4])))
10594         self.assertEqual(f.getNumberOfTuples(),1)
10595         self.assertEqual(f.getNbOfElemAllocated(),1000)
10596         ff=f[:]
10597         self.assertTrue(ff.isEqual(DataArrayInt([4])))
10598         self.assertEqual(ff.getNumberOfTuples(),1)
10599         self.assertEqual(ff.getNbOfElemAllocated(),1)
10600         d=DataArrayInt()
10601         d.pushBackSilent(444)
10602         d.pushBackSilent(555)
10603         d.pushBackSilent(666)
10604         self.assertTrue(d.isEqual(DataArrayInt([444,555,666])))
10605         #
10606         d=DataArrayInt()
10607         d.alloc(10,1)
10608         d.setInfoOnComponent(0,"ABC")
10609         d.setName("dEf")
10610         d.iota(7)
10611         e=DataArrayInt([7,8,9,10,11,12,13,14,15,16]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
10612         self.assertEqual(10,d.getNbOfElemAllocated())
10613         d.pushBackSilent(55)
10614         e=DataArrayInt([7,8,9,10,11,12,13,14,15,16,55]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
10615         self.assertEqual(20,d.getNbOfElemAllocated())
10616         d.reserve(4)
10617         e=DataArrayInt([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
10618         self.assertEqual(4,d.getNbOfElemAllocated())
10619         d.pushBackSilent(5)
10620         e=DataArrayInt([7,8,9,10,5]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
10621         self.assertEqual(8,d.getNbOfElemAllocated())
10622         self.assertEqual(5,d.popBackSilent())
10623         e=DataArrayInt([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
10624         self.assertEqual(8,d.getNbOfElemAllocated())
10625         self.assertRaises(InterpKernelException,d.reserve,-1)
10626         e=DataArrayInt([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
10627         self.assertEqual(8,d.getNbOfElemAllocated())
10628         d.reserve(0)
10629         e=DataArrayInt([]) ; e.setInfoOnComponent(0,"ABC") ; e.setName("dEf") ; self.assertTrue(d.isEqual(e))
10630         self.assertEqual(0,d.getNbOfElemAllocated())
10631         #
10632         d=DataArrayDouble()
10633         d.alloc(10,1)
10634         d.setInfoOnComponent(0,"ABC")
10635         d.setName("dEf")
10636         d.iota(7)
10637         e=DataArrayDouble([7,8,9,10,11,12,13,14,15,16]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
10638         self.assertEqual(10,d.getNbOfElemAllocated())
10639         d.pushBackSilent(55)
10640         e=DataArrayDouble([7,8,9,10,11,12,13,14,15,16,55]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
10641         self.assertEqual(20,d.getNbOfElemAllocated())
10642         d.reserve(4)
10643         e=DataArrayDouble([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
10644         self.assertEqual(4,d.getNbOfElemAllocated())
10645         d.pushBackSilent(5)
10646         e=DataArrayDouble([7,8,9,10,5]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
10647         self.assertEqual(8,d.getNbOfElemAllocated())
10648         self.assertEqual(5.,d.popBackSilent())
10649         e=DataArrayDouble([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
10650         self.assertEqual(8,d.getNbOfElemAllocated())
10651         self.assertRaises(InterpKernelException,d.reserve,-1)
10652         e=DataArrayDouble([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
10653         self.assertEqual(8,d.getNbOfElemAllocated())
10654         d.reserve(0)
10655         e=DataArrayDouble([]) ; e.setInfoOnComponent(0,"ABC") ; e.setName("dEf") ; self.assertTrue(d.isEqual(e,1e-14))
10656         self.assertEqual(0,d.getNbOfElemAllocated())
10657         pass
10658
10659     def testDAIBuildSubstractionOptimized1(self):
10660         da1=DataArrayInt.New([1,3,5,6,7,9,13])
10661         da2=DataArrayInt.New([3,5,9])
10662         da3=DataArrayInt.New([1,3,5])
10663         da4=DataArrayInt.New([1,3,5,6,7,9,13])
10664         #
10665         a=da1.buildSubstractionOptimized(da2);
10666         self.assertTrue(a.isEqual(DataArrayInt([1,6,7,13])));
10667         #
10668         a=da1.buildSubstractionOptimized(da3);
10669         self.assertTrue(a.isEqual(DataArrayInt([6,7,9,13])));
10670         #
10671         a=da1.buildSubstractionOptimized(da4);
10672         self.assertTrue(a.isEqual(DataArrayInt([])));
10673         pass
10674
10675     def testDAIIsStrictlyMonotonic1(self):
10676         da1=DataArrayInt.New([1,3,5,6,7,9,13])
10677         self.assertTrue(da1.isStrictlyMonotonic(True));
10678         da1.checkStrictlyMonotonic(True);
10679         self.assertTrue(da1.isMonotonic(True));
10680         da1.checkMonotonic(True);
10681         self.assertTrue(not da1.isStrictlyMonotonic(False));
10682         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,False)
10683         self.assertTrue(not da1.isMonotonic(False));
10684         self.assertRaises(InterpKernelException,da1.checkMonotonic,False)
10685         #
10686         da1=DataArrayInt.New([1,3,5,6,6,9,13])
10687         self.assertTrue(not da1.isStrictlyMonotonic(True));
10688         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,True)
10689         self.assertTrue(da1.isMonotonic(True));
10690         da1.checkMonotonic(True);
10691         self.assertTrue(not da1.isStrictlyMonotonic(False));
10692         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,False)
10693         self.assertTrue(not da1.isMonotonic(False));
10694         self.assertRaises(InterpKernelException,da1.checkMonotonic,False)
10695         #
10696         da1=DataArrayInt.New([1,3,5,6,5,9,13])
10697         self.assertTrue(not da1.isStrictlyMonotonic(True));
10698         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,True)
10699         self.assertTrue(not da1.isMonotonic(True));
10700         self.assertRaises(InterpKernelException,da1.checkMonotonic,True)
10701         self.assertTrue(not da1.isStrictlyMonotonic(False));
10702         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,False)
10703         self.assertTrue(not da1.isMonotonic(False));
10704         self.assertRaises(InterpKernelException,da1.checkMonotonic,False)
10705         #
10706         da1=DataArrayInt.New([13,9,7,6,5,3,1])
10707         self.assertTrue(not da1.isStrictlyMonotonic(True));
10708         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,True)
10709         self.assertTrue(not da1.isMonotonic(True));
10710         self.assertRaises(InterpKernelException,da1.checkMonotonic,True)
10711         self.assertTrue(da1.isStrictlyMonotonic(False));
10712         da1.checkStrictlyMonotonic(False);
10713         self.assertTrue(da1.isMonotonic(False));
10714         da1.checkMonotonic(False);
10715         #
10716         da1=DataArrayInt.New([13,9,6,6,5,3,1])
10717         self.assertTrue(not da1.isStrictlyMonotonic(True));
10718         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,True)
10719         self.assertTrue(not da1.isMonotonic(True));
10720         self.assertRaises(InterpKernelException,da1.checkMonotonic,True)
10721         self.assertTrue(not da1.isStrictlyMonotonic(False));
10722         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,False)
10723         self.assertTrue(da1.isMonotonic(False));
10724         da1.checkMonotonic(False);
10725         #
10726         da1=DataArrayInt.New([13,9,5,6,5,3,1])
10727         self.assertTrue(not da1.isStrictlyMonotonic(True));
10728         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,True)
10729         self.assertTrue(not da1.isMonotonic(True));
10730         self.assertRaises(InterpKernelException,da1.checkMonotonic,True)
10731         self.assertTrue(not da1.isStrictlyMonotonic(False));
10732         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,False)
10733         self.assertTrue(not da1.isMonotonic(False));
10734         self.assertRaises(InterpKernelException,da1.checkMonotonic,False)
10735         #
10736         da1=DataArrayInt.New([])
10737         self.assertTrue(da1.isStrictlyMonotonic(True));
10738         da1.checkStrictlyMonotonic(True);
10739         self.assertTrue(da1.isMonotonic(True));
10740         da1.checkMonotonic(True);
10741         self.assertTrue(da1.isStrictlyMonotonic(False));
10742         da1.checkStrictlyMonotonic(False);
10743         self.assertTrue(da1.isMonotonic(False));
10744         da1.checkMonotonic(False);
10745         #
10746         da1=DataArrayInt.New([13])
10747         self.assertTrue(da1.isStrictlyMonotonic(True));
10748         da1.checkStrictlyMonotonic(True);
10749         self.assertTrue(da1.isMonotonic(True));
10750         da1.checkMonotonic(True);
10751         self.assertTrue(da1.isStrictlyMonotonic(False));
10752         da1.checkStrictlyMonotonic(False);
10753         self.assertTrue(da1.isMonotonic(False));
10754         da1.checkMonotonic(False);
10755         pass
10756
10757     def testFindAndCorrectBadOriented3DCells1(self):
10758         nbOfDisc=20
10759         vects=([0,0,-1],[0.3,0.7,0.2],[-0.3,0.7,0.2],[-0.3,-0.7,0.2])
10760         #
10761         m0=MEDCouplingUMesh("m",3) ; m0.allocateCells(0); m0.insertNextCell(NORM_TETRA4,[0,1,2,3]); #Well oriented
10762         m1=MEDCouplingUMesh("m",3) ; m1.allocateCells(0); m1.insertNextCell(NORM_PYRA5,[0,1,2,3,4]); #Well oriented
10763         m2=MEDCouplingUMesh("m",3) ; m2.allocateCells(0); m2.insertNextCell(NORM_PENTA6,[0,1,2,3,4,5]); #Well oriented 
10764         m3=MEDCouplingUMesh("m",3) ; m3.allocateCells(0); m3.insertNextCell(NORM_HEXA8,[0,1,2,3,4,5,6,7]); #Well oriented
10765         m4=MEDCouplingUMesh("m",3) ; m4.allocateCells(0)
10766         self.assertRaises(InterpKernelException,m4.insertNextCell,NORM_HEXGP12,[0,1,2,3,4,5,6,7,8,9,10,11,12]);
10767         m4.insertNextCell(NORM_HEXGP12,[0,1,2,3,4,5,6,7,8,9,10,11]); #Well oriented
10768         c0=DataArrayDouble([0.,0.,0.,0.,1.,0.,1.,0.,0.,0.,0.,1.],4,3) ; m0.setCoords(c0)
10769         c1=DataArrayDouble([0.,0.,0.,0.,1.,0.,1.,1.,0.,1.,0.,0.,0.,0.,1.],5,3) ; m1.setCoords(c1)
10770         c2=DataArrayDouble([0.,0.,0.,0.,1.,0.,1.,0.,0., 0.,0.,1.,0.,1.,1.,1.,0.,1.],6,3) ; m2.setCoords(c2)
10771         c3=DataArrayDouble([0.,0.,0.,0.,1.,0.,1.,1.,0.,1.,0.,0.,0.,0.,1.,0.,1.,1.,1.,1.,1.,1.,0.,1.],8,3) ; m3.setCoords(c3)
10772         c4=DataArrayDouble([0.,0.,0.,0.,1.,0.,1.,1.,0.,1.,0.,0.,0.8,0.,0.,0.45,0.,0.,   0.,0.,1.,0.,1.,1.,1.,1.,1.,1.,0.,1.,0.8,0.,1.,0.45,0.,1.],12,3) ; m4.setCoords(c4)
10773         m=MEDCouplingMesh.MergeMeshes([m0,m1,m2,m3,m4])
10774         expected1=DataArrayDouble([0.16666666666666666,0.3333333333333333,0.5,1.,1.])
10775         for v in vects:
10776             for i in xrange(nbOfDisc):
10777                 mm=m.deepCpy()
10778                 mm.rotate([0.,0.,0.],[0.3,0.7,0.2],float(i)/float(nbOfDisc)*2*pi)
10779                 mm2=mm.deepCpy()
10780                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
10781                 self.assertTrue(mm.findAndCorrectBadOriented3DCells().empty())
10782                 self.assertTrue(mm.isEqual(mm2,1e-14))
10783                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
10784                 mm.convertAllToPoly()
10785                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
10786                 pass
10787             pass
10788         #
10789         mOK=m.deepCpy()
10790         m0=MEDCouplingUMesh("m",3) ; m0.allocateCells(0); m0.insertNextCell(NORM_TETRA4,[0,2,1,3]); #Not well oriented
10791         m1=MEDCouplingUMesh("m",3) ; m1.allocateCells(0); m1.insertNextCell(NORM_PYRA5,[0,1,2,3,4]); #Well oriented 
10792         m2=MEDCouplingUMesh("m",3) ; m2.allocateCells(0); m2.insertNextCell(NORM_PENTA6,[0,1,2,3,4,5]); #Well oriented 
10793         m3=MEDCouplingUMesh("m",3) ; m3.allocateCells(0); m3.insertNextCell(NORM_HEXA8,[0,3,2,1,4,7,6,5]); #Not well oriented
10794         m4=MEDCouplingUMesh("m",3) ; m4.allocateCells(0); m4.insertNextCell(NORM_HEXGP12,[0,5,4,3,2,1,6,11,10,9,8,7]); #Not well oriented
10795         m0.setCoords(c0) ; m1.setCoords(c1) ; m2.setCoords(c2) ; m3.setCoords(c3) ; m4.setCoords(c4)
10796         m=MEDCouplingMesh.MergeMeshes([m0,m1,m2,m3,m4])
10797         expected2=DataArrayDouble([-0.16666666666666666,0.3333333333333333,0.5,-1.,-1.])
10798         for v in vects:
10799             for i in xrange(nbOfDisc):
10800                 mm=m.deepCpy()
10801                 mm.rotate([0.,0.,0.],[0.3,0.7,0.2],float(i)/float(nbOfDisc)*2*pi)
10802                 mm2=mm.deepCpy() ; mm3=mm.deepCpy() ; mm3.convertAllToPoly()
10803                 self.assertTrue(mm3.getMeasureField(False).getArray().isEqual(expected2,1e-14))
10804                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected2,1e-14))
10805                 self.assertTrue(mm.findAndCorrectBadOriented3DCells().isEqual(DataArrayInt([0,3,4])))
10806                 mOK.setCoords(mm.getCoords())
10807                 self.assertTrue(mm.isEqual(mOK,1e-14))
10808                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
10809                 mmm=mm.deepCpy()
10810                 self.assertTrue(mmm.findAndCorrectBadOriented3DCells().empty())
10811                 mm.convertAllToPoly()
10812                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
10813                 pass
10814             pass
10815         #
10816         m0=MEDCouplingUMesh("m",3) ; m0.allocateCells(0); m0.insertNextCell(NORM_TETRA4,[0,1,2,3]); #Well oriented
10817         m1=MEDCouplingUMesh("m",3) ; m1.allocateCells(0); m1.insertNextCell(NORM_PYRA5,[0,3,2,1,4]); #Not well oriented 
10818         m2=MEDCouplingUMesh("m",3) ; m2.allocateCells(0); m2.insertNextCell(NORM_PENTA6,[0,2,1,3,5,4]); #Not well oriented 
10819         m3=MEDCouplingUMesh("m",3) ; m3.allocateCells(0); m3.insertNextCell(NORM_HEXA8,[0,1,2,3,4,5,6,7]); #Well oriented
10820         m4=MEDCouplingUMesh("m",3) ; m4.allocateCells(0); m4.insertNextCell(NORM_HEXGP12,range(12)); #Well oriented
10821         m0.setCoords(c0) ; m1.setCoords(c1) ; m2.setCoords(c2) ; m3.setCoords(c3) ; m4.setCoords(c4)
10822         m=MEDCouplingMesh.MergeMeshes([m0,m1,m2,m3,m4])
10823         expected3=DataArrayDouble([0.16666666666666666,-0.3333333333333333,-0.5,1.,1.])
10824         for v in vects:
10825             for i in xrange(nbOfDisc):
10826                 mm=m.deepCpy()
10827                 mm.rotate([0.,0.,0.],[0.3,0.7,0.2],float(i)/float(nbOfDisc)*2*pi)
10828                 mm2=mm.deepCpy() ; mm3=mm.deepCpy() ; mm3.convertAllToPoly()
10829                 self.assertTrue(mm3.getMeasureField(False).getArray().isEqual(expected3,1e-14))
10830                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected3,1e-14))
10831                 self.assertTrue(mm.findAndCorrectBadOriented3DCells().isEqual(DataArrayInt([1,2])))
10832                 mOK.setCoords(mm.getCoords())
10833                 self.assertTrue(mm.isEqual(mOK,1e-14))
10834                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
10835                 mmm=mm.deepCpy()
10836                 self.assertTrue(mmm.findAndCorrectBadOriented3DCells().empty())
10837                 mm.convertAllToPoly()
10838                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
10839                 pass
10840             pass
10841         pass
10842
10843     def testSwig2CellOrientation1(self):
10844         coords=DataArrayDouble([-0.21606,-0.10803,0.29999999999999999,-0.21606,-0.10803,0.37700000000000006,0,-0.10803,0.29999999999999999,0,-0.10803,0.37700000000000006,0,0.10803,0.29999999999999999,0,0.10803,0.37700000000000006,-0.21606,0.10803,0.29999999999999999,-0.21606,0.10803,0.37700000000000006,0,0.03601,0.29999999999999999,0,0.03601,0.37700000000000006,0,-0.03601,0.29999999999999999,0,-0.03601,0.37700000000000006],12,3)
10845         conn=[[0,2,10,8,4,6],[1,3,11,9,5,7],[0,1,3,2],[2,3,11,10],[10,11,9,8],[8,9,5,4],[4,5,7,6],[6,7,1,0]]
10846         for i in xrange(256):
10847             mesh=MEDCouplingUMesh("FluidMesh_1",3);
10848             mesh.allocateCells(0)
10849             conn2=[elt[:] for elt in conn]
10850             code=bin(i)[2:] ; code='0'*(8-len(code))+code
10851             for face,rev in zip(conn2,code):
10852                 if bool(int(rev)):
10853                     face.reverse()
10854                     pass
10855                 pass
10856             conn3=[elt+[-1] for elt in conn2]
10857             conn3=sum(conn3,[])[:-1]
10858             mesh.insertNextCell(NORM_POLYHED,conn3)
10859             mesh.setCoords(coords)
10860             mesh.orientCorrectlyPolyhedrons()
10861             self.assertTrue(mesh.getBarycenterAndOwner().isEqual(DataArrayDouble([-0.10803,0.,0.3385],1,3),1e-12))
10862             pass
10863         pass
10864
10865     def testSwig2CheckConsecutiveCellTypesForMEDFileFrmt1(self):
10866         m1=MEDCouplingUMesh("",2) ; m1.allocateCells(0)
10867         m1.insertNextCell(NORM_QUAD4,[0,1,2,3])
10868         m1.insertNextCell(NORM_TRI3,[0,1,2])
10869         d=DataArrayDouble(4,3) ; d[:]=0.
10870         m1.setCoords(d)
10871         self.assertTrue(m1.checkConsecutiveCellTypes())
10872         self.assertTrue(not m1.checkConsecutiveCellTypesForMEDFileFrmt())
10873         m1.renumberCells([1,0])
10874         self.assertTrue(m1.checkConsecutiveCellTypes())
10875         self.assertTrue(m1.checkConsecutiveCellTypesForMEDFileFrmt())
10876         pass
10877
10878     def testSwig2DAAccumulate1(self):
10879         d=DataArrayInt(10) ; d.iota(0)
10880         self.assertEqual([45],d.accumulate())
10881         self.assertEqual(45,d.accumulate(0))
10882         d=DataArrayInt(30) ; d.iota(0) ; d.rearrange(3)
10883         self.assertEqual([135,145,155],d.accumulate())
10884         self.assertEqual(135,d.accumulate(0))
10885         self.assertEqual(145,d.accumulate(1))
10886         self.assertEqual(155,d.accumulate(2))
10887         d=DataArrayDouble(10) ; d.iota(0.)
10888         self.assertEqual([45.],d.accumulate())
10889         self.assertEqual(45.,d.accumulate(0))
10890         d=DataArrayDouble(30) ; d.iota(0) ; d.rearrange(3)
10891         self.assertEqual([135.,145.,155.],d.accumulate())
10892         self.assertEqual(135.,d.accumulate(0))
10893         self.assertEqual(145.,d.accumulate(1))
10894         self.assertEqual(155.,d.accumulate(2))
10895         pass
10896
10897     def testSwig2UMeshDistanceToMesh1(self):
10898         m=MEDCouplingUMesh("toto",2)
10899         coords=DataArrayDouble([2.3,3.4,5.6,6.5,-4.3,3.2,-9.8,7.6,-5.4],3,3)
10900         m.setCoords(coords)
10901         m.allocateCells(0)
10902         m.insertNextCell(NORM_TRI3,[0,1,2])
10903         a,b,c=m.distanceToPoint([-0.335,2.27,1.21])
10904         self.assertEqual(0,b) ; self.assertEqual(0,c)
10905         self.assertAlmostEqual(0.022360988100374124,a,14);
10906         a,b,c=m.distanceToPoint(DataArrayDouble([-0.335,2.27,1.21],1,3))
10907         self.assertEqual(0,b) ; self.assertEqual(0,c)
10908         self.assertAlmostEqual(0.022360988100374124,a,14);
10909         a,b=coords.distanceToTuple([-0.335,2.27,1.21])
10910         self.assertAlmostEqual(5.243302871282566,a,14)
10911         self.assertEqual(0,b)
10912         #
10913         m=MEDCouplingUMesh("toto",2)
10914         coords=DataArrayDouble([0.,0.,0., 8.,0.,0., 8.,8.,0., 0.,8.,0.],4,3)
10915         m.setCoords(coords)
10916         m.allocateCells(0)
10917         m.insertNextCell(NORM_QUAD4,[0,1,2,3])
10918         m.checkCoherency2()
10919         self.assertEqual([4,0,1,2,3],m.getNodalConnectivity().getValues())
10920         a,b,c=m.distanceToPoint([5.,2.,0.1])
10921         self.assertAlmostEqual(0.1,a,14) ; self.assertEqual(0,b) ; self.assertEqual(1,c)
10922         a,b,c=m.distanceToPoint([5.,-2.,4.])
10923         self.assertAlmostEqual(sqrt(2*2+4*4),a,14) ; self.assertEqual(0,b) ; self.assertEqual(1,c)
10924         m.allocateCells(0)
10925         m.insertNextCell(NORM_POLYGON,[0,1,2,3])
10926         m.checkCoherency2()
10927         self.assertEqual([5,0,1,2,3],m.getNodalConnectivity().getValues())
10928         a,b,c=m.distanceToPoint([11.,3.,4.])
10929         self.assertAlmostEqual(sqrt(3*3+4*4),a,14) ; self.assertEqual(0,b) ; self.assertEqual(1,c)
10930         a,b,c=m.distanceToPoint([4.,12.,5.])
10931         self.assertAlmostEqual(sqrt(4*4+5*5),a,14) ; self.assertEqual(0,b) ; self.assertEqual(2,c)
10932         d=DataArrayDouble([-1.2,3.,2.],1,3)
10933         for elt in d:
10934             a,b,c=m.distanceToPoint(d)
10935             self.assertAlmostEqual(sqrt(1.2*1.2+2*2),a,14) ; self.assertEqual(0,b) ; self.assertEqual(0,c)
10936             pass
10937         #
10938         m=MEDCouplingUMesh("toto",1)
10939         coords=DataArrayDouble([0.,0.,4.,0.,0.,4.],3,2) ; m.setCoords(coords)
10940         m.allocateCells(0) ; m.insertNextCell(NORM_SEG2,[0,1]) ; m.insertNextCell(NORM_SEG2,[1,2])
10941         a,b,c=m.distanceToPoint([-0.1,4.1])
10942         self.assertAlmostEqual(0.14142135623730925,a,14) ; self.assertEqual(-1,b) ; self.assertEqual(2,c)
10943         a,b,c=m.distanceToPoint([0.,3.9])
10944         self.assertAlmostEqual(0.07071067811865482,a,14) ; self.assertEqual(1,b) ; self.assertEqual(2,c)
10945         pass
10946
10947     def testSwig2NonRegressionPartitionBySpreadZone1(self):
10948         m=MEDCouplingCMesh()
10949         arr=DataArrayDouble(6) ; arr.iota(0.)
10950         m.setCoords(arr,arr,arr)
10951         m=m.buildUnstructured()
10952         mPart=m[50,80,85,87,92,122]
10953         zones=mPart.partitionBySpreadZone()
10954         self.assertEqual(4,len(zones))
10955         self.assertTrue(zones[0].isEqual(DataArrayInt([0])))
10956         self.assertTrue(zones[1].isEqual(DataArrayInt([1,2])))
10957         self.assertTrue(zones[2].isEqual(DataArrayInt([3,4])))
10958         self.assertTrue(zones[3].isEqual(DataArrayInt([5])))
10959         #
10960         n,ni=m.computeNeighborsOfCells()
10961         a,b=MEDCouplingUMesh.ComputeSpreadZoneGraduallyFromSeed(0,n,ni)
10962         self.assertEqual(13,b) ; self.assertEqual(125,len(a)) ; self.assertTrue(a.isIdentity())
10963         a,b=MEDCouplingUMesh.ComputeSpreadZoneGraduallyFromSeed([1],n,ni)
10964         self.assertEqual(12,b) ; self.assertEqual(125,len(a)) ; self.assertTrue(a.isIdentity())
10965         a,b=MEDCouplingUMesh.ComputeSpreadZoneGraduallyFromSeed((2,),n,ni)
10966         self.assertEqual(11,b) ; self.assertEqual(125,len(a)) ; self.assertTrue(a.isIdentity())
10967         a,b=MEDCouplingUMesh.ComputeSpreadZoneGraduallyFromSeed(DataArrayInt([3]),n,ni)
10968         self.assertEqual(12,b) ; self.assertEqual(125,len(a)) ; self.assertTrue(a.isIdentity())
10969         pass
10970
10971     def testSwigUMeshInsertNextCell1(self):
10972         m=MEDCouplingUMesh("toto",2)
10973         #
10974         coords=DataArrayDouble([0.,0.,1.,1.,1.,0.]) ; m.setCoords(coords)
10975         da=DataArrayInt([0,1,2])
10976         m.allocateCells(0)
10977         for i in xrange(5):
10978             m.insertNextCell(NORM_TRI3,da)
10979             pass
10980         self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([3,0,1,2,3,0,1,2,3,0,1,2,3,0,1,2,3,0,1,2])))
10981         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4,8,12,16,20])))
10982         #
10983         da=DataArrayInt([0,1,2,3])
10984         m.allocateCells(0)
10985         for i in xrange(5):
10986             m.insertNextCell(NORM_TRI3,3,da)
10987             pass
10988         self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([3,0,1,2,3,0,1,2,3,0,1,2,3,0,1,2,3,0,1,2])))
10989         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4,8,12,16,20])))
10990         #
10991         da=DataArrayInt([0,1])
10992         m.allocateCells(0)
10993         self.assertRaises(InterpKernelException,m.insertNextCell,NORM_TRI3,3,da)
10994         #
10995         da=DataArrayInt([0,1,2,0,1,3,0,1,4,0,1,5,0,1,6],5,3)
10996         m.allocateCells(0)
10997         for t in da:
10998             m.insertNextCell(NORM_TRI3,t)
10999             pass
11000         self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([3,0,1,2,3,0,1,3,3,0,1,4,3,0,1,5,3,0,1,6])))
11001         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4,8,12,16,20])))
11002         self.assertRaises(InterpKernelException,m.insertNextCell,NORM_TRI3,None)
11003         pass
11004
11005     def testSwigCurveLinearMesh1(self):
11006         m=MEDCouplingCurveLinearMesh("toto")
11007         m.setNodeGridStructure([2,3])
11008         coords=DataArrayDouble([0.,0., 2.,0., 0.,1., 1.9,1.1, 0.3,1.9, 2.2,2.1],6,2)
11009         m.setCoords(coords)
11010         m.checkCoherency()
11011         m0=m.deepCpy()
11012         self.assertTrue(m0.isEqual(m,1e-12))
11013         m.getCoords().setInfoOnComponents(["X [m]","Y [m]"])
11014         self.assertTrue(not m0.isEqual(m,1e-12))
11015         m0=m.deepCpy()
11016         self.assertTrue(m0.isEqual(m,1e-12))
11017         self.assertEqual(m.getNodeGridStructure(),(2,3))
11018         pass
11019
11020     def testSimplexize3(self):
11021         m=MEDCouplingUMesh("toto",3)
11022         m.allocateCells(0)
11023         m.insertNextCell(NORM_TETRA4,[0,1,2,3])
11024         m.insertNextCell(NORM_HEXA8,[4,5,6,7,8,9,10,11])
11025         m.insertNextCell(NORM_HEXA8,[12,13,14,15,16,17,18,19])
11026         m.insertNextCell(NORM_TETRA4,[20,21,22,23])
11027         c1=DataArrayDouble([0.,0.,0.,0.,1.,0.,1.,0.,0.,0.,0.,1.],4,3)
11028         c2=DataArrayDouble([0.,0.,0.,0.,1.,0.,1.,1.,0.,1.,0.,0., 0.,0.,1.,0.,1.,1.,1.,1.,1.,1.,0.,1.],8,3) ; c2+=[2.,0.,0.]
11029         c3=c2+[2.,0.,0.]
11030         c4=c1+[6.,0.,0.]
11031         c=DataArrayDouble.Aggregate([c1,c2,c3,c4])
11032         m.setCoords(c)
11033         m.checkCoherency2()
11034         #
11035         m1=m.deepCpy()
11036         d1=m1.simplexize(PLANAR_FACE_5)
11037         m1.checkCoherency2()
11038         vol1=m1.getMeasureField(ON_CELLS).getArray()
11039         self.assertTrue(vol1.isEqual(DataArrayDouble([1./6, 1./6, 1./6,1./6, 1./6, 1./3,1./6, 1./6, 1./6, 1./6, 1./3, 1./6]),1e-12))
11040         self.assertEqual(m1.getNodalConnectivity().getValues(),[14,0,1,2,3,14,4,9,5,6,14,4,8,9,11,14,4,7,11,6,14,9,11,10,6,14,4,9,6,11,14,12,17,13,14,14,12,16,17,19,14,12,15,19,14,14,17,19,18,14,14,12,17,14,19,14,20,21,22,23])
11041         self.assertEqual(m1.getNodalConnectivityIndex().getValues(),[0,5,10,15,20,25,30,35,40,45,50,55,60])
11042         self.assertTrue(d1.isEqual(DataArrayInt([0,1,1,1,1,1,2,2,2,2,2,3])))
11043         #
11044         m2=m.deepCpy()
11045         d2=m2.simplexize(PLANAR_FACE_6)
11046         m2.checkCoherency2()
11047         vol2=m2.getMeasureField(ON_CELLS).getArray()
11048         self.assertTrue(vol2.isEqual(DataArrayDouble([1./6, 1./6, 1./6,1./6, 1./6, 1./6,1./6,1./6, 1./6, 1./6, 1./6, 1./6,1./6,1./6]),1e-12))
11049         self.assertEqual(m2.getNodalConnectivity().getValues(),[14,0,1,2,3,14,4,9,5,10,14,4,5,6,10,14,4,8,9,10,14,4,11,8,10,14,4,6,7,10,14,4,7,11,10,14,12,17,13,18,14,12,13,14,18,14,12,16,17,18,14,12,19,16,18,14,12,14,15,18,14,12,15,19,18,14,20,21,22,23])
11050         self.assertEqual(m2.getNodalConnectivityIndex().getValues(),[0,5,10,15,20,25,30,35,40,45,50,55,60,65,70])
11051         self.assertTrue(d2.isEqual(DataArrayInt([0,1,1,1,1,1,1,2,2,2,2,2,2,3])))
11052         pass
11053
11054     def testSwig2CurveLinearMesh2(self):
11055         c=MEDCouplingCMesh()
11056         #2D
11057         arr1=DataArrayDouble([0,1,3,7])
11058         arr2=DataArrayDouble([0,1,1.5])
11059         c.setCoords(arr1,arr2)
11060         u=c.buildUnstructured()
11061         coo=u.getCoords()
11062         cl=MEDCouplingCurveLinearMesh()
11063         cl.setCoords(coo)
11064         cl.setNodeGridStructure([4,3])
11065         cl.checkCoherency2()
11066         li1=[1.,2.,4.,0.5,1.,2.]
11067         self.assertTrue(cl.getMeasureField(False).getArray().isEqual(DataArrayDouble(li1),1e-14))
11068         self.assertTrue(u.getMeasureField(False).getArray().isEqual(DataArrayDouble(li1),1e-14))
11069         li1_1=[0.5,0.5,2.,0.5,5.,0.5,0.5,1.25,2.,1.25,5.,1.25]
11070         self.assertTrue(cl.getBarycenterAndOwner().isEqual(DataArrayDouble(li1_1,6,2),1e-14))
11071         self.assertTrue(u.getBarycenterAndOwner().isEqual(DataArrayDouble(li1_1,6,2),1e-14))
11072         #3D
11073         c.setCoords(arr1,arr2,arr2)
11074         u=c.buildUnstructured()
11075         coo=u.getCoords()
11076         cl=MEDCouplingCurveLinearMesh()
11077         cl.setCoords(coo)
11078         cl.setNodeGridStructure([4,3,3])
11079         cl.checkCoherency2()
11080         li2=[1.,2.,4.,0.5, 1.,2.,0.5,1.,2.,0.25,0.5,1.]
11081         li2_1=[0.5,0.5,0.5,2.,0.5,0.5,5.,0.5,0.5,0.5,1.25,0.5,2.,1.25,0.5,5.,1.25,0.5,0.5,0.5,1.25,2.,0.5,1.25,5.,0.5,1.25,0.5,1.25,1.25,2.,1.25,1.25,5.,1.25,1.25]
11082         self.assertTrue(cl.getMeasureField(False).getArray().isEqual(DataArrayDouble(li2),1e-14))
11083         self.assertTrue(u.getMeasureField(False).getArray().isEqual(DataArrayDouble(li2),1e-14))
11084         self.assertTrue(cl.getBarycenterAndOwner().isEqual(DataArrayDouble(li2_1,12,3),1e-14))
11085         self.assertTrue(u.getBarycenterAndOwner().isEqual(DataArrayDouble(li2_1,12,3),1e-14))
11086         #1D spaceDim 1
11087         coo=DataArrayDouble(5) ; coo.iota(0.)
11088         coo=coo*coo
11089         cl.setCoords(coo)
11090         cl.setNodeGridStructure([5])
11091         cl.checkCoherency2()
11092         li3=[1.,3.,5.,7.]
11093         li3_1=[0.5,2.5,6.5,12.5]
11094         self.assertTrue(cl.getMeasureField(False).getArray().isEqual(DataArrayDouble(li3),1e-14))
11095         self.assertTrue(cl.buildUnstructured().getMeasureField(False).getArray().isEqual(DataArrayDouble(li3),1e-14))
11096         self.assertTrue(cl.getBarycenterAndOwner().isEqual(DataArrayDouble(li3_1),1e-14))
11097         self.assertTrue(cl.buildUnstructured().getBarycenterAndOwner().isEqual(DataArrayDouble(li3_1),1e-14))
11098         #1D spaceDim 2
11099         coo=DataArrayDouble.Meld(coo,coo)
11100         cl.setCoords(coo)
11101         cl.checkCoherency2()
11102         li4=[sqrt(2.)*elt for elt in [1.,3.,5.,7.]]
11103         li4_1=[0.5,0.5,2.5,2.5,6.5,6.5,12.5,12.5]
11104         self.assertTrue(cl.getMeasureField(False).getArray().isEqual(DataArrayDouble(li4),1e-14))
11105         self.assertTrue(cl.buildUnstructured().getMeasureField(False).getArray().isEqual(DataArrayDouble(li4),1e-14))
11106         self.assertTrue(cl.getBarycenterAndOwner().isEqual(DataArrayDouble(li4_1,4,2),1e-14))
11107         self.assertTrue(cl.buildUnstructured().getBarycenterAndOwner().isEqual(DataArrayDouble(li4_1,4,2),1e-14))
11108         pass
11109
11110     def testSwig2CurveLinearMeshNonRegression1(self):
11111         coords=DataArrayDouble([0.0, 0.0, 0.10000000149011612, 0.6000000238418579, 0.10000000149011612, 0.30000001192092896, 1.100000023841858, 0.10000000149011612, 0.20000000298023224, 0.10000000149011612, 0.6000000238418579, 0.20000000298023224, 0.699999988079071, 0.6000000238418579, 0.10000000149011612, 1.2000000476837158, 0.6000000238418579, 0.30000001192092896, 0.10000000149011612, 1.100000023841858, 0.30000001192092896, 0.5, 1.100000023841858, 0.20000000298023224, 1.0, 1.2000000476837158, 0.10000000149011612, 0.0, 0.10000000149011612, 0.5, 0.5, 0.10000000149011612, 0.6000000238418579, 1.2000000476837158, 0.10000000149011612, 0.699999988079071, 0.10000000149011612, 0.6000000238418579, 0.699999988079071, 0.6000000238418579, 0.6000000238418579, 0.5, 1.100000023841858, 0.6000000238418579, 0.6000000238418579, 0.10000000149011612, 1.0, 0.6000000238418579, 0.699999988079071, 1.2000000476837158, 0.699999988079071, 0.8999999761581421, 1.0, 0.5, 0.10000000149011612, 0.10000000149011612, 1.2000000476837158, 0.699999988079071, 0.10000000149011612, 1.0, 1.0, 0.10000000149011612, 1.100000023841858, 0.10000000149011612, 0.6000000238418579, 1.100000023841858, 0.6000000238418579, 0.6000000238418579, 1.100000023841858, 1.100000023841858, 0.6000000238418579, 1.2000000476837158, 0.10000000149011612, 1.2000000476837158, 1.0, 0.5, 1.100000023841858, 1.2000000476837158, 1.2000000476837158, 1.100000023841858, 1.0],27,3)
11112         m=MEDCouplingCurveLinearMesh("toto")
11113         m.setCoords(coords)
11114         m.setNodeGridStructure([3,3,3])
11115         #
11116         vol=m.getMeasureField(False).getArray()
11117         self.assertTrue(vol.isEqual(DataArrayDouble([0.11450000709295281, 0.10583334351579375,0.11149999939029423,0.08866666863113633, 0.1404166805123294,0.1250000135352219,0.1270833433481557,0.13258334288001067]),1e-12))
11118         self.assertTrue(vol.isEqual(m.buildUnstructured().getMeasureField(False).getArray(),1e-12))
11119         #
11120         self.assertTrue(m.getBarycenterAndOwner().isEqual(m.buildUnstructured().getBarycenterAndOwner(),1e-12))
11121         pass
11122
11123     def testSwig2NonRegressionDASetSelectedComponents1(self):
11124         da=DataArrayDouble.New([1.,2.,3.,4.,5.,6.],3,2)
11125         dv=DataArrayDouble.New();
11126         dv.alloc(4,4)
11127         dv.fillWithZero()
11128         # da has less tuples than dv
11129         dv.setSelectedComponents(da,[1,0])
11130         #
11131         self.assertTrue(dv.isEqual(DataArrayDouble([2.,1.,0.,0.,4.,3.,0.,0.,6.,5.,0.,0.,0.,0.,0.,0.],4,4),1e-14))
11132         #
11133         da=DataArrayInt.New([1,2,3,4,5,6],3,2)
11134         dv=DataArrayInt.New();
11135         dv.alloc(4,4)
11136         dv.fillWithZero()
11137         # da has less tuples than dv
11138         dv.setSelectedComponents(da,[1,0])
11139         #
11140         self.assertTrue(dv.isEqual(DataArrayInt([2,1,0,0,4,3,0,0,6,5,0,0,0,0,0,0],4,4)))
11141         pass
11142
11143     def testSwigSetItem3(self):
11144         # 1-2 
11145         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11146         d[3]=[1,2]
11147         self.assertTrue(d.isEqual(DataArrayDouble([0,0,0,0,0,0,1,2,0,0,0,0],6,2),1e-14))
11148         # 2-2 false
11149         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11150         d[[5,3,2]]=[1,2]
11151         self.assertTrue(d.isEqual(DataArrayDouble([0,0,0,0,1,2,1,2,0,0,1,2],6,2),1e-14))
11152         # 3-2 false
11153         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11154         d[:]=[1,2]
11155         self.assertTrue(d.isEqual(DataArrayDouble([1,2,1,2,1,2,1,2,1,2,1,2],6,2),1e-14))
11156         # 4-2 false
11157         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11158         d[DataArrayInt([0,3,4])]=[1,2]
11159         self.assertTrue(d.isEqual(DataArrayDouble([1,2,0,0,0,0,1,2,1,2,0,0],6,2),1e-14))
11160         # 5-2
11161         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11162         d[5,1]=[7]
11163         self.assertTrue(d.isEqual(DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,7],6,2),1e-14))
11164         # 6-2 false
11165         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11166         d[[3,5],1]=[7]
11167         self.assertTrue(d.isEqual(DataArrayDouble([0,0,0,0,0,0,0,7,0,0,0,7],6,2),1e-14))
11168         # 7-2 false
11169         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11170         d[:-1:2,1]=[7]
11171         self.assertTrue(d.isEqual(DataArrayDouble([0,7,0,0,0,7,0,0,0,7,0,0],6,2),1e-14))
11172         # 8-2 false
11173         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11174         d[DataArrayInt([0,3,4]),1]=[7]
11175         self.assertTrue(d.isEqual(DataArrayDouble([0,7,0,0,0,0,0,7,0,7,0,0],6,2),1e-14))
11176         # 9-2
11177         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11178         d[3,[1,0]]=[7,8]
11179         self.assertTrue(d.isEqual(DataArrayDouble([0,0,0,0,0,0,8,7,0,0,0,0],6,2),1e-14))
11180         # 10-2 false
11181         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11182         d[[1,3,4],[1,0]]=[7,8]
11183         self.assertTrue(d.isEqual(DataArrayDouble([0,0,8,7,0,0,8,7,8,7,0,0],6,2),1e-14))
11184         # 11-2 false
11185         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11186         d[1::2,[1,0]]=[7,8]
11187         self.assertTrue(d.isEqual(DataArrayDouble([0,0,8,7,0,0,8,7,0,0,8,7],6,2),1e-14))
11188         # 12-2 false
11189         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11190         d[DataArrayInt([1,4]),[1,0]]=[7,8]
11191         self.assertTrue(d.isEqual(DataArrayDouble([0,0,8,7,0,0,0,0,8,7,0,0],6,2),1e-14))
11192         # 13-2
11193         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11194         d[1,:-1]=[9]
11195         self.assertTrue(d.isEqual(DataArrayDouble([0,0,9,0,0,0,0,0,0,0,0,0],6,2),1e-14))
11196         # 14-2 false
11197         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11198         d[[1,4,5],:]=[7,8]
11199         self.assertTrue(d.isEqual(DataArrayDouble([0,0,7,8,0,0,0,0,7,8,7,8],6,2),1e-14))
11200         # 15-2 false
11201         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11202         d[1::2,:]=[3,9]
11203         self.assertTrue(d.isEqual(DataArrayDouble([0,0,3,9,0,0,3,9,0,0,3,9],6,2),1e-14))
11204         # 1-2 
11205         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11206         d[3]=[1,2]
11207         self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,0,0,1,2,0,0,0,0],6,2)))
11208         # 2-2 false
11209         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11210         d[[5,3,2]]=[1,2]
11211         self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,1,2,1,2,0,0,1,2],6,2)))
11212         # 3-2 false
11213         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11214         d[:]=[1,2]
11215         self.assertTrue(d.isEqual(DataArrayInt([1,2,1,2,1,2,1,2,1,2,1,2],6,2)))
11216         # 4-2 false
11217         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11218         d[DataArrayInt([0,3,4])]=[1,2]
11219         self.assertTrue(d.isEqual(DataArrayInt([1,2,0,0,0,0,1,2,1,2,0,0],6,2)))
11220         # 5-2
11221         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11222         d[5,1]=[7]
11223         self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,7],6,2)))
11224         # 6-2 false
11225         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11226         d[[3,5],1]=[7]
11227         self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,0,0,0,7,0,0,0,7],6,2)))
11228         # 7-2 false
11229         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11230         d[:-1:2,1]=[7]
11231         self.assertTrue(d.isEqual(DataArrayInt([0,7,0,0,0,7,0,0,0,7,0,0],6,2)))
11232         # 8-2 false
11233         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11234         d[DataArrayInt([0,3,4]),1]=[7]
11235         self.assertTrue(d.isEqual(DataArrayInt([0,7,0,0,0,0,0,7,0,7,0,0],6,2)))
11236         # 9-2
11237         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11238         d[3,[1,0]]=[7,8]
11239         self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,0,0,8,7,0,0,0,0],6,2)))
11240         # 10-2 false
11241         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11242         d[[1,3,4],[1,0]]=[7,8]
11243         self.assertTrue(d.isEqual(DataArrayInt([0,0,8,7,0,0,8,7,8,7,0,0],6,2)))
11244         # 11-2 false
11245         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11246         d[1::2,[1,0]]=[7,8]
11247         self.assertTrue(d.isEqual(DataArrayInt([0,0,8,7,0,0,8,7,0,0,8,7],6,2)))
11248         # 12-2 false
11249         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11250         d[DataArrayInt([1,4]),[1,0]]=[7,8]
11251         self.assertTrue(d.isEqual(DataArrayInt([0,0,8,7,0,0,0,0,8,7,0,0],6,2)))
11252         # 13-2
11253         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11254         d[1,:-1]=[9]
11255         self.assertTrue(d.isEqual(DataArrayInt([0,0,9,0,0,0,0,0,0,0,0,0],6,2)))
11256         # 14-2 false
11257         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11258         d[[1,4,5],:]=[7,8]
11259         self.assertTrue(d.isEqual(DataArrayInt([0,0,7,8,0,0,0,0,7,8,7,8],6,2)))
11260         # 15-2 false
11261         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11262         d[1::2,:]=[3,9]
11263         self.assertTrue(d.isEqual(DataArrayInt([0,0,3,9,0,0,3,9,0,0,3,9],6,2)))
11264         pass
11265
11266     def testSwig2ConvertLinearCellsToQuadratic1(self):
11267         coordsExp=DataArrayDouble([-0.3,-0.3,0.2,-0.3,0.7,-0.3,-0.3,0.2,0.2,0.2,0.7,0.2,-0.3,0.7,0.2,0.7,0.7,0.7,-0.3,-0.05,-0.05,0.2,0.2,-0.05,-0.05,-0.3,0.45,-0.05,0.45,-0.3,0.45,0.2,0.7,-0.05,-0.05,0.7,0.2,0.45,-0.3,0.45,0.45,0.7,0.7,0.45],22,2)
11268         # 2D
11269         m2D=MEDCouplingDataForTest.build2DTargetMesh_1()
11270         m2D.convertLinearCellsToQuadratic(0)
11271         m2D.checkCoherency1()
11272         self.assertEqual(m2D.getNodalConnectivity().getValues(),[8,0,3,4,1,9,10,11,12,6,1,4,2,11,13,14,6,4,5,2,15,16,13,8,6,7,4,3,17,18,10,19,8,7,8,5,4,20,21,15,18])
11273         self.assertEqual(m2D.getNodalConnectivityIndex().getValues(),[0,9,16,23,32,41])
11274         self.assertTrue(m2D.getCoords().isEqual(coordsExp,1e-14))
11275         # 1D
11276         m1D=MEDCouplingDataForTest.build2DTargetMesh_1().buildDescendingConnectivity()[0]
11277         m1D.convertLinearCellsToQuadratic(0)
11278         m1D.checkCoherency1()
11279         self.assertEqual(m1D.getNodalConnectivity().getValues(),[2,0,3,9,2,3,4,10,2,4,1,11,2,1,0,12,2,4,2,13,2,2,1,14,2,4,5,15,2,5,2,16,2,6,7,17,2,7,4,18,2,3,6,19,2,7,8,20,2,8,5,21])
11280         self.assertEqual(m1D.getNodalConnectivityIndex().getValues(),[0,4,8,12,16,20,24,28,32,36,40,44,48,52])
11281         self.assertTrue(m1D.getCoords().isEqual(coordsExp,1e-14))
11282         # 3D
11283         m2D=MEDCouplingDataForTest.build2DTargetMesh_1()
11284         m2D.changeSpaceDimension(3)
11285         arr=DataArrayDouble(4);  arr.iota(0) ; z=MEDCouplingCMesh() ; z.setCoords(arr)
11286         m1D=z.buildUnstructured() ; m1D.setCoords(arr.changeNbOfComponents(3,0.))
11287         m1D.getCoords()[:]=m1D.getCoords()[:,[1,2,0]]
11288         cooTmp=m2D.getCoords()[:]
11289         m3D=m2D.buildExtrudedMesh(m1D,0)
11290         m3D.convertLinearCellsToQuadratic(0)
11291         m3D.checkCoherency1()
11292         # check of new m3D content
11293         coordsExp2=[coordsExp.changeNbOfComponents(3,i) for i in xrange(4)]
11294         coordsExp3=[DataArrayDouble.Meld(cooTmp[:,[0,1]],cooTmp[:,2]+(0.5+float(i))) for i in xrange(3)]
11295         coordsExp4=DataArrayDouble.Aggregate([coordsExp2[0],coordsExp3[0],coordsExp2[1],coordsExp3[1],coordsExp2[2],coordsExp3[2],coordsExp2[3]])
11296         c=DataArrayDouble.Aggregate(m3D.getCoords(),coordsExp4)
11297         self.assertEqual(len(coordsExp4),115)
11298         self.assertEqual(len(m3D.getCoords()),115)
11299         a,b=c.findCommonTuples(1e-14)
11300         self.assertEqual(len(b),len(coordsExp4)+1)
11301         e,f=DataArrayInt.BuildOld2NewArrayFromSurjectiveFormat2(2*115,a,b)
11302         self.assertEqual(f,115)
11303         self.assertTrue(e.isEqual(DataArrayInt([0,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,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,0,1,2,3,4,5,6,7,8,36,37,38,39,48,49,53,54,58,59,60,66,67,44,47,52,45,46,57,64,65,70,9,10,11,12,13,14,15,16,17,40,41,42,43,50,51,55,56,61,62,63,68,69,75,78,81,76,77,84,88,89,92,18,19,20,21,22,23,24,25,26,71,72,73,74,79,80,82,83,85,86,87,90,91,97,100,103,98,99,106,110,111,114,27,28,29,30,31,32,33,34,35,93,94,95,96,101,102,104,105,107,108,109,112,113])))
11304         self.assertTrue(DataArrayInt([30,0,3,4,1,9,12,13,10,36,37,38,39,40,41,42,43,44,45,46,47,25,1,4,2,10,13,11,38,48,49,42,50,51,47,46,52,25,4,5,2,13,14,11,53,54,48,55,56,50,46,57,52,30,6,7,4,3,15,16,13,12,58,59,37,60,61,62,41,63,64,65,46,45,30,7,8,5,4,16,17,14,13,66,67,53,59,68,69,55,62,65,70,57,46,30,9,12,13,10,18,21,22,19,40,41,42,43,71,72,73,74,75,76,77,78,25,10,13,11,19,22,20,42,50,51,73,79,80,78,77,81,25,13,14,11,22,23,20,55,56,50,82,83,79,77,84,81,30,15,16,13,12,24,25,22,21,61,62,41,63,85,86,72,87,88,89,77,76,30,16,17,14,13,25,26,23,22,68,69,55,62,90,91,82,86,89,92,84,77,30,18,21,22,19,27,30,31,28,71,72,73,74,93,94,95,96,97,98,99,100,25,19,22,20,28,31,29,73,79,80,95,101,102,100,99,103,25,22,23,20,31,32,29,82,83,79,104,105,101,99,106,103,30,24,25,22,21,33,34,31,30,85,86,72,87,107,108,94,109,110,111,99,98,30,25,26,23,22,34,35,32,31,90,91,82,86,112,113,104,108,111,114,106,99]).isEqual(m3D.getNodalConnectivity()))
11305         self.assertTrue(DataArrayInt([0,21,37,53,74,95,116,132,148,169,190,211,227,243,264,285]).isEqual(m3D.getNodalConnectivityIndex()))
11306         # testing explode3DMeshTo1D
11307         m3DSlice0=m3D[:5]
11308         m3DSlice0.zipCoords()
11309         a,b,c,d,e=m3DSlice0.explode3DMeshTo1D()
11310         self.assertTrue(b.isEqual(DataArrayInt([0,1,2,3,4,5,6,7,8,9,10,11,2,12,13,6,14,15,11,10,16,17,18,12,19,20,14,10,21,16,22,23,1,24,25,26,5,27,28,29,10,9,30,31,17,23,32,33,19,26,29,34,21,10])))
11311         self.assertTrue(c.isEqual(DataArrayInt([0,12,21,30,42,54])))
11312         self.assertTrue(d.isEqual(DataArrayInt([0,0,3,0,1,0,0,0,3,0,1,0,0,0,3,0,1,2,3,4,0,1,1,2,1,1,2,1,1,2,2,4,2,2,4,2,2,4,3,3,4,3,3,3,4,3,3,3,4,4,4,4,4,4])))
11313         self.assertTrue(e.isEqual(DataArrayInt([0,1,3,5,6,7,9,11,12,13,15,20,22,24,25,27,28,30,32,33,35,36,38,39,41,42,43,45,46,47,49,50,51,52,53,54])))
11314         self.assertTrue(a.getNodalConnectivity().isEqual(DataArrayInt([2,0,3,18,2,3,4,19,2,4,1,20,2,1,0,21,2,9,12,22,2,12,13,23,2,13,10,24,2,10,9,25,2,0,9,26,2,3,12,27,2,4,13,28,2,1,10,29,2,4,2,30,2,2,1,31,2,13,11,32,2,11,10,33,2,2,11,34,2,4,5,35,2,5,2,36,2,13,14,37,2,14,11,38,2,5,14,39,2,6,7,40,2,7,4,41,2,3,6,42,2,15,16,43,2,16,13,44,2,12,15,45,2,6,15,46,2,7,16,47,2,7,8,48,2,8,5,49,2,16,17,50,2,17,14,51,2,8,17,52])))
11315         self.assertTrue(a.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4,8,12,16,20,24,28,32,36,40,44,48,52,56,60,64,68,72,76,80,84,88,92,96,100,104,108,112,116,120,124,128,132,136,140])))
11316         self.assertTrue(a.getCoords().isEqual(DataArrayDouble([-0.3,-0.3,0.0,0.2,-0.3,0.0,0.7,-0.3,0.0,-0.3,0.2,0.0,0.2,0.2,0.0,0.7,0.2,0.0,-0.3,0.7,0.0,0.2,0.7,0.0,0.7,0.7,0.0,-0.3,-0.3,1.0,0.2,-0.3,1.0,0.7,-0.3,1.0,-0.3,0.2,1.0,0.2,0.2,1.0,0.7,0.2,1.0,-0.3,0.7,1.0,0.2,0.7,1.0,0.7,0.7,1.0,-0.3,-0.05,0.0,-0.05,0.2,0.0,0.2,-0.05,0.0,-0.05,-0.3,0.0,-0.3,-0.05,1.0,-0.05,0.2,1.0,0.2,-0.05,1.0,-0.05,-0.3,1.0,-0.3,-0.3,0.5,-0.3,0.2,0.5,0.2,0.2,0.5,0.2,-0.3,0.5,0.45,-0.05,0.0,0.45,-0.3,0.0,0.45,-0.05,1.0,0.45,-0.3,1.0,0.7,-0.3,0.5,0.45,0.2,0.0,0.7,-0.05,0.0,0.45,0.2,1.0,0.7,-0.05,1.0,0.7,0.2,0.5,-0.05,0.7,0.0,0.2,0.45,0.0,-0.3,0.45,0.0,-0.05,0.7,1.0,0.2,0.45,1.0,-0.3,0.45,1.0,-0.3,0.7,0.5,0.2,0.7,0.5,0.45,0.7,0.0,0.7,0.45,0.0,0.45,0.7,1.0,0.7,0.45,1.0,0.7,0.7,0.5],53,3),1e-14))
11317         pass
11318
11319     def testSwig2DataArrayPushBackValsSilent1(self):
11320         d=DataArrayDouble()
11321         d.pushBackValsSilent([4,5,6])
11322         self.assertTrue(d.isEqual(DataArrayDouble([4.,5.,6.]),1e-14))
11323         e=DataArrayDouble([1,2,3],1,3)
11324         for t in e: d.pushBackValsSilent(t)
11325         self.assertTrue(d.isEqual(DataArrayDouble([4.,5.,6.,1.,2.,3.]),1e-14))
11326         d.pushBackValsSilent(DataArrayDouble([9,10.]))
11327         self.assertTrue(d.isEqual(DataArrayDouble([4.,5.,6.,1.,2.,3.,9.,10.]),1e-14))
11328         d.pushBackValsSilent(DataArrayDouble(0,1))
11329         self.assertTrue(d.isEqual(DataArrayDouble([4.,5.,6.,1.,2.,3.,9.,10.]),1e-14))
11330         e=DataArrayDouble([1,2,3],3,1)
11331         for t in e: d.pushBackValsSilent(t)
11332         self.assertTrue(d.isEqual(DataArrayDouble([4.,5.,6.,1.,2.,3.,9.,10.,1.,2.,3.]),1e-14))
11333         d.pushBackValsSilent(77)
11334         self.assertTrue(d.isEqual(DataArrayDouble([4.,5.,6.,1.,2.,3.,9.,10.,1.,2.,3.,77.]),1e-14))
11335         #
11336         d=DataArrayInt()
11337         d.pushBackValsSilent([4,5,6])
11338         self.assertTrue(d.isEqual(DataArrayInt([4,5,6])))
11339         e=DataArrayInt([1,2,3],1,3)
11340         for t in e: d.pushBackValsSilent(t)
11341         self.assertTrue(d.isEqual(DataArrayInt([4,5,6,1,2,3])))
11342         d.pushBackValsSilent(DataArrayInt([9,10]))
11343         self.assertTrue(d.isEqual(DataArrayInt([4,5,6,1,2,3,9,10])))
11344         d.pushBackValsSilent(DataArrayInt(0,1))
11345         self.assertTrue(d.isEqual(DataArrayInt([4,5,6,1,2,3,9,10])))
11346         e=DataArrayInt([1,2,3],3,1)
11347         for t in e: d.pushBackValsSilent(t)
11348         self.assertTrue(d.isEqual(DataArrayInt([4,5,6,1,2,3,9,10,1,2,3])))
11349         d.pushBackValsSilent(77)
11350         self.assertTrue(d.isEqual(DataArrayInt([4,5,6,1,2,3,9,10,1,2,3,77])))
11351         pass
11352
11353     def testSwig2ConvertLinearCellsToQuadratic2(self):
11354         m2D=MEDCouplingDataForTest.build2DTargetMesh_1()
11355         ret=m2D.convertLinearCellsToQuadratic(1)
11356         self.assertTrue(ret.isIdentity())
11357         self.assertEqual(5,len(ret))
11358         m2D.checkCoherency1()
11359         coordsExp=DataArrayDouble([-0.3,-0.3,0.2,-0.3,0.7,-0.3,-0.3,0.2,0.2,0.2,0.7,0.2,-0.3,0.7,0.2,0.7,0.7,0.7,-0.3,-0.05,-0.05,0.2,0.2,-0.05,-0.05,-0.3,0.45,-0.05,0.45,-0.3,0.45,0.2,0.7,-0.05,-0.05,0.7,0.2,0.45,-0.3,0.45,0.45,0.7,0.7,0.45,-0.05,-0.05,0.3666666666666667,-0.1333333333333333,0.5333333333333332,0.03333333333333334,-0.05,0.45,0.45,0.45],27,2)
11360         self.assertTrue(m2D.getCoords().isEqual(coordsExp,1e-14))
11361         self.assertTrue(m2D.getNodalConnectivity().isEqual(DataArrayInt([9,0,3,4,1,9,10,11,12,22,7,1,4,2,11,13,14,23,7,4,5,2,15,16,13,24,9,6,7,4,3,17,18,10,19,25,9,7,8,5,4,20,21,15,18,26])))
11362         self.assertTrue(m2D.getNodalConnectivityIndex().isEqual(DataArrayInt([0,10,18,26,36,46])))
11363         #
11364         m2D=MEDCouplingDataForTest.build2DTargetMesh_1()[(0,3)] ; m2D.zipCoords()
11365         m2D.changeSpaceDimension(3)
11366         arr=DataArrayDouble(3);  arr.iota(0) ; z=MEDCouplingCMesh() ; z.setCoords(arr)
11367         m1D=z.buildUnstructured() ; m1D.setCoords(arr.changeNbOfComponents(3,0.))
11368         m1D.getCoords()[:]=m1D.getCoords()[:,[1,2,0]]
11369         cooTmp=m2D.getCoords()[:]
11370         m3D=m2D.buildExtrudedMesh(m1D,0)
11371         ret=m3D.convertLinearCellsToQuadratic(1)
11372         m3D.writeVTK("m3D.vtu")
11373         self.assertTrue(ret.isIdentity())
11374         self.assertEqual(4,len(ret))
11375         m3D.checkCoherency1()
11376         coordsExp2=DataArrayDouble([-0.3,-0.3,0.0,0.2,-0.3,0.0,-0.3,0.2,0.0,0.2,0.2,0.0,-0.3,0.7,0.0,0.2,0.7,0.0,-0.3,-0.3,1.0,0.2,-0.3,1.0,-0.3,0.2,1.0,0.2,0.2,1.0,-0.3,0.7,1.0,0.2,0.7,1.0,-0.3,-0.3,2.0,0.2,-0.3,2.0,-0.3,0.2,2.0,0.2,0.2,2.0,-0.3,0.7,2.0,0.2,0.7,2.0,-0.3,-0.05,0.0,-0.05,0.2,0.0,0.2,-0.05,0.0,-0.05,-0.3,0.0,-0.3,-0.05,1.0,-0.05,0.2,1.0,0.2,-0.05,1.0,-0.05,-0.3,1.0,-0.3,-0.3,0.5,-0.3,0.2,0.5,0.2,0.2,0.5,0.2,-0.3,0.5,-0.05,0.7,0.0,0.2,0.45,0.0,-0.3,0.45,0.0,-0.05,0.7,1.0,0.2,0.45,1.0,-0.3,0.45,1.0,-0.3,0.7,0.5,0.2,0.7,0.5,-0.3,-0.05,2.0,-0.05,0.2,2.0,0.2,-0.05,2.0,-0.05,-0.3,2.0,-0.3,-0.3,1.5,-0.3,0.2,1.5,0.2,0.2,1.5,0.2,-0.3,1.5,-0.05,0.7,2.0,0.2,0.45,2.0,-0.3,0.45,2.0,-0.3,0.7,1.5,0.2,0.7,1.5,-0.05,-0.05,0.0,-0.3,-0.05,0.5,-0.05,0.2,0.5,0.2,-0.05,0.5,-0.05,-0.05,1.0,-0.05,0.45,0.0,-0.05,0.7,0.5,0.2,0.45,0.5,-0.05,0.45,1.0,-0.3,-0.05,1.5,-0.05,0.2,1.5,0.2,-0.05,1.5,-0.05,-0.05,2.0,-0.05,0.7,1.5,0.2,0.45,1.5,-0.05,0.45,2.0,-0.05,-0.05,0.5,-0.05,0.45,0.5,-0.05,-0.05,1.5,-0.05,0.45,1.5],71,3)
11377         self.assertTrue(m3D.getCoords().isEqual(coordsExp2,1e-14))
11378         self.assertTrue(m3D.getNodalConnectivity().isEqual(DataArrayInt([27,0,2,3,1,6,8,9,7,18,19,20,21,22,23,24,25,26,27,28,29,51,52,53,54,55,51,67,27,4,5,3,2,10,11,9,8,30,31,19,32,33,34,23,35,36,37,28,27,56,57,58,53,59,56,68,27,6,8,9,7,12,14,15,13,22,23,24,25,38,39,40,41,42,43,44,45,55,60,61,62,63,55,69,27,10,11,9,8,16,17,15,14,33,34,23,35,46,47,39,48,49,50,44,43,59,64,65,61,66,59,70])))
11379         self.assertTrue(m3D.getNodalConnectivityIndex().isEqual(DataArrayInt([0,28,56,84,112])))
11380         pass
11381
11382     def testSwig2GaussNEIntegral1(self):
11383         m2D=MEDCouplingDataForTest.build2DTargetMesh_1()
11384         m0=m2D[0] ; m0.zipCoords()
11385         m1=m2D[[1,2]] ; m1.zipCoords()
11386         m2=m2D[[3,4]] ; m2.zipCoords()
11387         m0.convertLinearCellsToQuadratic(1)
11388         m1.convertLinearCellsToQuadratic(0)
11389         m2.convertLinearCellsToQuadratic(1)
11390         m=MEDCouplingUMesh.MergeUMeshes([m0,m1,m2])
11391         m.mergeNodes(1e-12)
11392         f=MEDCouplingFieldDouble(ON_GAUSS_NE)
11393         f.setMesh(m)
11394         arr=DataArrayDouble([1.1,2.2,3.3,4.4,5.5,6.6,7.7,8.8,9.9,
11395                              11.1,12.2,13.3,14.4,15.5,16.6,
11396                              21.1,22.2,23.3,24.4,25.5,26.6,
11397                              31.1,32.2,33.3,34.4,35.5,36.6,37.7,38.8,39.9,
11398                              41.1,42.2,43.3,44.4,45.5,46.6,47.7,48.8,49.9])
11399         arr2=DataArrayDouble(len(arr),2)
11400         arr2[:,0]=arr ; arr2[:,1]=arr+100
11401         f.setArray(arr2)
11402         f.checkCoherency()
11403         res=f.integral(False)
11404         # a=25./81 ; b=40./81 ; c=64./81
11405         # p1=0.11169079483905 ; p2=0.0549758718227661
11406         # 1st compo
11407         # c0=(a*(1.1+2.2+3.3+4.4)+b*(5.5+6.6+7.7+8.8)+c*9.9)*0.25/3.9999999999999978 ; c0=1.5837962962962973
11408         # c1=(p2*(11.1+12.2+13.3)+p1*(14.4+15.5+16.6))*0.125/0.4999999999854482 ; c1=1.8014347172346943
11409         # c2=(p2*(21.1+22.2+23.3)+p1*(24.4+25.5+26.6))*0.125/0.4999999999854482 ; c2=3.0514347172346943
11410         # c3=(a*(31.1+32.2+33.3+34.4)+b*(35.5+36.6+37.7+38.8)+c*39.9)*0.25/3.9999999999999978 ; c3=9.0837962962963
11411         # c4=(a*(41.1+42.2+43.3+44.4)+b*(45.5+46.6+47.7+48.8)+c*49.9)*0.25/3.9999999999999978 ; c4=11.583796296296303
11412         # c0+c1+c2+c3+c4=27.104258323358287
11413         integExp0=27.104258323358287
11414         self.assertAlmostEqual(res[0],integExp0,13)
11415         # 2nd compo
11416         # c0=(a*(101.1+102.2+103.3+104.4)+b*(105.5+106.6+107.7+108.8)+c*109.9)*0.25/3.9999999999999978 ; c0=26.58379629629631
11417         # c1=(p2*(111.1+112.2+113.3)+p1*(114.4+115.5+116.6))*0.125/0.4999999999854482 ; c1=14.301434717234699
11418         # c2=(p2*(121.1+122.2+123.3)+p1*(124.4+125.5+126.6))*0.125/0.4999999999854482 ; c2=15.5514347172347
11419         # c3=(a*(131.1+132.2+133.3+134.4)+b*(135.5+136.6+137.7+138.8)+c*139.9)*0.25/3.9999999999999978 ; c3=34.08379629629631
11420         # c4=(a*(141.1+142.2+143.3+144.4)+b*(145.5+146.6+147.7+148.8)+c*149.9)*0.25/3.9999999999999978 ; c4=36.58379629629632
11421         # c0+c1+c2+c3+c4=127.10425832335835
11422         integExp1=127.10425832335835
11423         self.assertAlmostEqual(res[1],integExp1,12)
11424         meas=f.getDiscretization().getMeasureField(f.getMesh(),False)
11425         intPerTuple=meas*f
11426         res2=intPerTuple.accumulate()
11427         self.assertAlmostEqual(res2[0],integExp0,13)
11428         self.assertAlmostEqual(res2[1],integExp1,12)
11429         #
11430         meas2=f.buildMeasureField(False)
11431         intPerTuple=meas2*f
11432         res3=intPerTuple.accumulate()
11433         self.assertAlmostEqual(res3[0],integExp0,13)
11434         self.assertAlmostEqual(res3[1],integExp1,12)
11435         #
11436         res4=f.getWeightedAverageValue(False) # res4==res2 because sum of area of mesh is equal to 1
11437         self.assertAlmostEqual(res4[0],integExp0,13)
11438         self.assertAlmostEqual(res4[1],integExp1,12)
11439         #
11440         m.scale([0,0],2.)
11441         #
11442         res5=f.getWeightedAverageValue() # res4==res4 because weighted average is not sensitive to the scaling
11443         self.assertAlmostEqual(res5[0],integExp0,13)
11444         self.assertAlmostEqual(res5[1],integExp1,12)
11445         meas3=f.buildMeasureField(False)
11446         delta=4*meas2.getArray()-meas3.getArray()
11447         delta.abs()
11448         self.assertTrue(delta.isUniform(0.,1e-16))
11449         res6=f.integral(False)
11450         self.assertAlmostEqual(res6[0],4.*integExp0,12)
11451         self.assertAlmostEqual(res6[1],4.*integExp1,11)
11452         pass
11453
11454     def testSwig2SlowDADFindClosestTupleId(self):
11455         nbPts=[10,]
11456         for nbPt in nbPts:
11457             d=DataArrayDouble(nbPt) ; d.iota() ; d*=1./(nbPt-1)
11458             c=MEDCouplingCMesh() ; c.setCoords(d,d) ; m=c.buildUnstructured() ; pts=m.getCoords() ; del m
11459             #
11460             d0=DataArrayDouble((nbPt-1)*(nbPt-1)) ; d0.iota() ; d0*=(3./((nbPt-1)*(nbPt-1))) ; d0=d0.applyFunc("exp(x)-1")
11461             d1=DataArrayDouble((nbPt-1)*(nbPt-1)) ; d1.iota()
11462             d2=DataArrayDouble.Meld(d0,d1) ; d2=d2.fromPolarToCart() ; d2+=[0.32,0.73]
11463             ids=pts.findClosestTupleId(d2)
11464             #print "Start of costly computation"
11465             idsExpected=DataArrayInt(len(d2))
11466             tmp=1e300
11467             for i,elt in enumerate(d2):
11468                 l,m=(pts-elt).magnitude().getMinValue()
11469                 idsExpected.setIJSilent(i,0,m)
11470                 if l<tmp:
11471                     tmp=l ; tmp1=m ; tmp2=i
11472                     pass
11473                 pass
11474             #print "End of costly computation"
11475             self.assertTrue(idsExpected.isEqual(ids))
11476             a,b,c=pts.minimalDistanceTo(d2)
11477             self.assertEqual(tmp,a)
11478             self.assertEqual(tmp1,b)
11479             self.assertEqual(tmp2,c)
11480             #
11481             l=[d2[:,i] for i in [0,1]]
11482             for elt in l: elt.reverse()
11483             d2i=DataArrayDouble.Meld(l)
11484             ids1=pts.findClosestTupleId(d2i)
11485             idsExpectedI=idsExpected.deepCpy() ; idsExpectedI.reverse()
11486             self.assertTrue(idsExpectedI.isEqual(ids1))
11487             #
11488             l=[pts[:,i] for i in [0,1]]
11489             for elt in l: elt.reverse()
11490             ptsi=DataArrayDouble.Meld(l)
11491             ids2=ptsi.findClosestTupleId(d2)
11492             idsExpected2=nbPt*nbPt-1-ids
11493             self.assertTrue(idsExpected2.isEqual(ids2))
11494             #
11495             ids3=ptsi.findClosestTupleId(d2i)
11496             idsExpected3=idsExpected2.deepCpy() ; idsExpected3.reverse()
11497             self.assertTrue(idsExpected3.isEqual(ids3))
11498             pass
11499
11500     def testSwig2DataArrayAsciiChar1(self):
11501         alpha=DataArrayInt(26) ; alpha.iota(ord("A"))
11502         d=DataArrayAsciiChar(alpha.getValues(),2,13)
11503         d.setInfoOnComponents(["c%i"%(v) for v in xrange(13)])
11504         self.assertEqual('ABCDEFGHIJKLM',d.getTuple(0))
11505         self.assertEqual('NOPQRSTUVWXYZ',d.getTuple(1))
11506         self.assertEqual(2,d.getNumberOfTuples())
11507         self.assertEqual(26,d.getNbOfElems())
11508         self.assertEqual(13,d.getNumberOfComponents())
11509         dd=d.deepCpy()
11510         self.assertTrue(d.isEqual(dd))
11511         dd.setIJ(0,3,'d')
11512         self.assertTrue(not d.isEqual(dd))
11513         d.setIJ(0,3,ord('d'))
11514         self.assertTrue(d.isEqual(dd))
11515         d.rearrange(1)
11516         d.reserve(20)
11517         self.assertEqual(20,d.getNumberOfTuples())
11518         self.assertEqual(20,d.getNbOfElems())
11519         self.assertEqual(1,d.getNumberOfComponents())
11520         #
11521         d0=DataArrayAsciiChar([ord('a')],1,1)
11522         self.assertEqual('a',d0.asciiCharValue())
11523         self.assertTrue(not d0.empty())
11524         d0=DataArrayAsciiChar(0,3)
11525         self.assertTrue(d0.empty())
11526         d.pushBackSilent("U") ; d.pushBackSilent("V") ; d.pushBackSilent("W")
11527         self.assertEqual("W",d.popBackSilent())
11528         d.rearrange(2)
11529         self.assertEqual(['AB','Cd','EF','GH','IJ','KL','MN','OP','QR','ST','UV'],d.toStrList())
11530         d.fillWithZero()
11531         self.assertEqual(11*[''],d.toStrList())
11532         d.fillWithValue('T')
11533         self.assertEqual(11*["TT"],d.toStrList())
11534         d.rearrange(1)
11535         self.assertTrue(d.isUniform("T"))
11536         d.rearrange(2)
11537         #
11538         dd.rearrange(2)
11539         dd2=dd.deepCpy()
11540         dd.renumberInPlace([3,1,2,4,0,11,10,9,8,7,5,12,6])
11541         self.assertEqual(dd.toStrList(),['IJ','Cd','EF','AB','GH','UV','YZ','ST','QR','OP','MN','KL','WX'])
11542         dd.renumberInPlaceR([3,1,2,4,0,11,10,9,8,7,5,12,6])
11543         self.assertEqual(['AB','Cd','EF','GH','IJ','KL','MN','OP','QR','ST','UV','WX','YZ'],dd.toStrList())
11544         e=dd.renumber([3,1,2,4,0,11,10,9,8,7,5,12,6])
11545         self.assertEqual(e.toStrList(),['IJ','Cd','EF','AB','GH','UV','YZ','ST','QR','OP','MN','KL','WX'])
11546         e=dd.renumberR([3,1,2,4,0,11,10,9,8,7,5,12,6])
11547         self.assertEqual(e.toStrList(),['GH','Cd','EF','IJ','AB','WX','UV','ST','QR','OP','KL','YZ','MN'])
11548         e=dd.renumberAndReduce([1,1,1,1,1,1,1,2,0,0,0,0,0],3)
11549         self.assertEqual(['YZ','MN','OP'],e.toStrList())
11550         self.assertEqual(['GH','IJ'],dd.selectByTupleIdSafe([3,4]).toStrList())
11551         self.assertEqual(['AB','GH','MN','ST','YZ'],dd.selectByTupleId2(0,13,3).toStrList())
11552         dd3=dd.changeNbOfComponents(3,"G")
11553         self.assertEqual(['ABG','CdG','EFG','GHG','IJG','KLG','MNG','OPG','QRG','STG','UVG','WXG','YZG'],dd3.toStrList())
11554         dd3.rearrange(1) ; self.assertEqual("G",dd3.back()) ; dd3.rearrange(3)
11555         self.assertTrue(dd3.changeNbOfComponents(2,"\0").isEqual(dd))
11556         self.assertEqual(len(dd),13)
11557         d=DataArrayAsciiChar(13,2) ; d.fillWithValue('Y')
11558         dd3.meldWith(d)
11559         self.assertEqual(['ABGYY','CdGYY','EFGYY','GHGYY','IJGYY','KLGYY','MNGYY','OPGYY','QRGYY','STGYY','UVGYY','WXGYY','YZGYY'],dd3.toStrList())
11560         self.assertEqual("d",dd3.getIJ(0,6))
11561         self.assertRaises(InterpKernelException,dd3.getIJSafe,0,6)
11562         self.assertEqual("d",dd3.getIJSafe(1,1))
11563         dd3.rearrange(1)
11564         e=dd3.getIdsEqual("Y")
11565         self.assertTrue(e.isEqual(DataArrayInt([3,4,8,9,13,14,18,19,23,24,28,29,33,34,38,39,43,44,48,49,53,54,58,59,60,63,64])))
11566         e=dd3.getIdsNotEqual("Y")
11567         self.assertTrue(e.isEqual(DataArrayInt([0,1,2,5,6,7,10,11,12,15,16,17,20,21,22,25,26,27,30,31,32,35,36,37,40,41,42,45,46,47,50,51,52,55,56,57,61,62])))
11568         self.assertEqual(("d",6),dd3.getMaxValue())
11569         self.assertEqual(("A",0),dd3.getMinValue())
11570         self.assertEqual(26,dd3.search("LGYYM"))
11571         self.assertEqual(-1,dd3.search("LGYYN"))
11572         dd3.rearrange(5)
11573         self.assertEqual(7,dd3.locateTuple("OPGYY"))
11574         self.assertTrue("OPGYY" in dd3)
11575         self.assertEqual(7,dd3.index("OPGYY"))
11576         self.assertEqual(-1,dd3.locateTuple("OPGYP"))
11577         dd3.rearrange(1)
11578         self.assertEqual(2,dd3.locateValue("OPGYY"))
11579         self.assertTrue(dd3.presenceOfValue("OPGYY"))
11580         self.assertTrue("O" in dd3)
11581         self.assertTrue(not dd3.presenceOfValue("z"))
11582         self.assertTrue("z" not in dd3)
11583         dd3.rearrange(5)
11584         l=list(dd3)
11585         self.assertEqual([e.buildDAAsciiChar().toStrList()[0] for e in list(dd3)],dd3.toStrList())
11586         dd3.reAlloc(5)
11587         dd4=DataArrayChar.Aggregate(dd3,dd3)
11588         self.assertEqual(['ABGYY','CdGYY','EFGYY','GHGYY','IJGYY','ABGYY','CdGYY','EFGYY','GHGYY','IJGYY'],dd4.toStrList())
11589         dd5=DataArrayChar.Aggregate([dd4,dd3,dd4])
11590         self.assertEqual(['ABGYY','CdGYY','EFGYY','GHGYY','IJGYY','ABGYY','CdGYY','EFGYY','GHGYY','IJGYY','ABGYY','CdGYY','EFGYY','GHGYY','IJGYY','ABGYY','CdGYY','EFGYY','GHGYY','IJGYY','ABGYY','CdGYY','EFGYY','GHGYY','IJGYY'],dd5.toStrList())
11591         # getitem, __iter__,__setitem__
11592         a=list(dd3)
11593         self.assertEqual("ABGYY",str(a[0]))
11594         dd4=dd3[::2]
11595         self.assertEqual(['ABGYY','EFGYY','IJGYY'],dd4.toStrList())
11596         dd4=dd3[(3,2,1)]
11597         self.assertEqual(['GHGYY','EFGYY','CdGYY'],dd4.toStrList())
11598         dd4=dd3[:]
11599         dd4[::2]=["12","345","67890"]
11600         self.assertEqual(['12   ','CdGYY','345  ','GHGYY','67890'],dd4.toStrList())
11601         dd4=dd3[:]
11602         dd4[[1,2]]=" "
11603         self.assertEqual(['ABGYY','     ','     ','GHGYY','IJGYY'],dd4.toStrList())
11604         dd4=dd3[:]
11605         dd4[4]='12345'
11606         self.assertEqual(['ABGYY','CdGYY','EFGYY','GHGYY','12345'],dd4.toStrList())
11607         dd4[0]=dd4[1]
11608         self.assertEqual(['CdGYY','CdGYY','EFGYY','GHGYY','12345'],dd4.toStrList())
11609         dd4=DataArrayAsciiChar(["abc","de","fghi"])
11610         self.assertEqual(['abc ','de  ','fghi'],dd4.toStrList())
11611         dd4=DataArrayAsciiChar(["abc","de","fghi"],"t")
11612         self.assertEqual(['abct','dett','fghi'],dd4.toStrList())
11613         pass
11614
11615     def setUp(self):
11616         pass
11617     pass
11618
11619 unittest.main()