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         myCoords=DataArrayDouble.New();
 153         myCoords.setValues(targetCoords,9,3);
 154         targetMesh.setCoords(myCoords);
 155         self.assertEqual(targetMesh.getSpaceDimension(),3)
 156         self.assertEqual(targetMesh.getNumberOfCells(),8)
 157         self.assertEqual(targetMesh.getNumberOfNodes(),9)
 158         self.assertEqual(targetMesh.getMeshDimension(),0)
 159         pass
 160
 161     def testMeshM1D(self):
 162         meshM1D=MEDCouplingUMesh.New();
 163         self.assertRaises(InterpKernelException,meshM1D.getMeshDimension);
 164         self.assertRaises(InterpKernelException,meshM1D.getNumberOfNodes);
 165         self.assertRaises(InterpKernelException,meshM1D.getNumberOfCells);
 166         self.assertRaises(InterpKernelException,meshM1D.setMeshDimension,-2)
 167         self.assertRaises(InterpKernelException,meshM1D.setMeshDimension,-10)
 168         meshM1D.setMeshDimension(-1);
 169         meshM1D.checkCoherency();
 170         self.assertEqual(meshM1D.getMeshDimension(),-1);
 171         self.assertEqual(meshM1D.getNumberOfCells(),1);
 172         self.assertRaises(InterpKernelException,meshM1D.getNumberOfNodes);
 173         self.assertRaises(InterpKernelException,meshM1D.getSpaceDimension);
 174         cpy=meshM1D.clone(True);
 175         self.assertTrue(cpy.isEqual(meshM1D,1e-12));
 176         fieldOnCells=MEDCouplingFieldDouble.New(ON_CELLS);
 177         fieldOnCells.setMesh(meshM1D);
 178         array=DataArrayDouble.New();
 179         array.setValues(6*[7.],1,6);
 180         fieldOnCells.setArray(array);
 181         fieldOnCells.checkCoherency();
 182         pass
 183
 184     def testDeepCopy(self):
 185         array=DataArrayDouble.New();
 186         array.setValues(5*3*[7.],5,3);
 187         self.assertEqual(array.getIJ(3,2),7.);
 188         array2=array.deepCpy();
 189         self.assertEqual(array2.getIJ(3,2),7.)
 190         #
 191         array3=DataArrayInt.New();
 192         array3.setValues(5*3*[17],5,3);
 193         self.assertEqual(array3.getIJ(3,2),17);
 194         array4=array3.deepCpy();
 195         self.assertEqual(array4.getIJ(3,2),17);
 196         pass
 197
 198     def testRevNodal(self):
 199         mesh=MEDCouplingDataForTest.build2DTargetMesh_1()
 200         revNodal,revNodalIndx=mesh.getReverseNodalConnectivity();
 201         revNodalExpected=[0,0,1,1,2,0,3,0,1,2,3,4,2,4,3,3,4,4];
 202         revNodalIndexExpected=[0,1,3,5,7,12,14,15,17,18];
 203         self.assertEqual(revNodal.getNbOfElems(),18)
 204         self.assertEqual(revNodalIndx.getNbOfElems(),10)
 205         self.assertEqual(list(revNodal.getValues()),revNodalExpected)
 206         self.assertEqual(list(revNodalIndx.getValues()),revNodalIndexExpected)
 207         pass
 208
 209     def testConvertToPolyTypes(self):
 210         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
 211         elts=[1,3];
 212         mesh.convertToPolyTypes(elts);
 213         mesh.checkCoherency();
 214         self.assertEqual(5,mesh.getNumberOfCells());
 215         self.assertEqual(23,mesh.getNodalConnectivity().getNumberOfTuples());
 216         expected1=[4, 0, 3, 4, 1, 5, 1, 4, 2, 3, 4, 5, 2, 5, 6, 7, 4, 3, 4, 7, 8, 5, 4]
 217         self.assertEqual(expected1,list(mesh.getNodalConnectivity().getValues()));
 218         #
 219         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
 220         mesh.convertToPolyTypes(elts);
 221         mesh.checkCoherency();
 222         self.assertEqual(8,mesh.getNumberOfCells());
 223         self.assertEqual(114,mesh.getNodalConnectivity().getNumberOfTuples());
 224         mesh.convertToPolyTypes(elts);
 225         mesh.checkCoherency();
 226         self.assertEqual(8,mesh.getNumberOfCells());
 227         self.assertEqual(114,mesh.getNodalConnectivity().getNumberOfTuples());
 228         pass
 229
 230     def testDescConn2D(self):
 231         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
 232         desc=DataArrayInt.New();
 233         descIndx=DataArrayInt.New();
 234         revDesc=DataArrayInt.New();
 235         revDescIndx=DataArrayInt.New();
 236         mesh2=mesh.buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
 237         mesh2.checkCoherency();
 238         self.assertEqual(1,mesh2.getMeshDimension());
 239         self.assertEqual(13,mesh2.getNumberOfCells());
 240         self.assertEqual(14,revDescIndx.getNbOfElems()); self.assertEqual(14,revDescIndx.getNumberOfTuples());
 241         self.assertEqual(6,descIndx.getNbOfElems()); self.assertEqual(6,descIndx.getNumberOfTuples());
 242         self.assertEqual(18,desc.getNbOfElems()); self.assertEqual(18,desc.getNumberOfTuples());
 243         self.assertEqual(18,revDesc.getNbOfElems()); self.assertEqual(18,revDesc.getNumberOfTuples());
 244         expected1=[0,1,2,3, 2,4,5, 6,7,4, 8,9,1,10, 11,12,6,9];
 245         self.assertEqual(expected1,list(desc.getValues()));
 246         expected2=[0,4,7,10,14,18];
 247         self.assertEqual(expected2,list(descIndx.getValues()));
 248         expected3=[0,1,3,5,6,8,9,11,12,13,15,16,17,18];
 249         self.assertEqual(expected3,list(revDescIndx.getValues()));
 250         expected4=[0, 0,3, 0,1, 0, 1,2, 1, 2,4, 2, 3, 3,4, 3, 4, 4];
 251         self.assertEqual(expected4,list(revDesc.getValues()));
 252         conn=mesh2.getNodalConnectivity();
 253         connIndex=mesh2.getNodalConnectivityIndex();
 254         expected5=[0,3,6,9,12,15,18,21,24,27,30,33,36,39];
 255         self.assertEqual(expected5,list(connIndex.getValues()));
 256         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];
 257         self.assertEqual(expected6,list(conn.getValues()));
 258         #
 259         eltsV=[1,3];
 260         mesh.convertToPolyTypes(eltsV);
 261         mesh.checkCoherency();
 262         #
 263         desc=DataArrayInt.New();
 264         descIndx=DataArrayInt.New();
 265         revDesc=DataArrayInt.New();
 266         revDescIndx=DataArrayInt.New();
 267         #
 268         mesh2=mesh.buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
 269         mesh2.checkCoherency();
 270         self.assertEqual(1,mesh2.getMeshDimension());
 271         self.assertEqual(13,mesh2.getNumberOfCells());
 272         self.assertEqual(14,revDescIndx.getNbOfElems()); self.assertEqual(14,revDescIndx.getNumberOfTuples());
 273         self.assertEqual(6,descIndx.getNbOfElems()); self.assertEqual(6,descIndx.getNumberOfTuples());
 274         self.assertEqual(18,desc.getNbOfElems()); self.assertEqual(18,desc.getNumberOfTuples());
 275         self.assertEqual(18,revDesc.getNbOfElems()); self.assertEqual(18,revDesc.getNumberOfTuples());
 276         self.assertEqual(expected1,list(desc.getValues()));
 277         self.assertEqual(expected2,list(descIndx.getValues()));
 278         self.assertEqual(expected3,list(revDescIndx.getValues()));
 279         self.assertEqual(expected4,list(revDesc.getValues()));
 280         conn=mesh2.getNodalConnectivity();
 281         connIndex=mesh2.getNodalConnectivityIndex();
 282         self.assertEqual(expected5,list(connIndex.getValues()));
 283         self.assertEqual(expected6,list(conn.getValues()));
 284         pass
 285
 286     def testDescConn3D(self):
 287         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
 288         desc=DataArrayInt.New();
 289         descIndx=DataArrayInt.New();
 290         revDesc=DataArrayInt.New();
 291         revDescIndx=DataArrayInt.New();
 292         #
 293         mesh2=mesh.buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
 294         mesh2.checkCoherency();
 295         self.assertEqual(2,mesh2.getMeshDimension());
 296         self.assertEqual(36,mesh2.getNumberOfCells());
 297         self.assertEqual(37,revDescIndx.getNbOfElems()); self.assertEqual(37,revDescIndx.getNumberOfTuples());
 298         self.assertEqual(9,descIndx.getNbOfElems()); self.assertEqual(9,descIndx.getNumberOfTuples());
 299         self.assertEqual(48,desc.getNbOfElems()); self.assertEqual(48,desc.getNumberOfTuples());
 300         self.assertEqual(48,revDesc.getNbOfElems()); self.assertEqual(48,revDesc.getNumberOfTuples());
 301         expected1=[0, 6, 12, 18, 24, 30, 36, 42, 48]
 302         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]
 303         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]
 304         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]
 305         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]
 306         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,
 307                    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,
 308                    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,
 309                    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]
 310         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,
 311                    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,
 312                    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,
 313                    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]
 314
 315         self.assertEqual(expected1,list(descIndx.getValues()));
 316         self.assertEqual(expected2,list(desc.getValues()));
 317         self.assertEqual(expected3,list(revDescIndx.getValues()));
 318         self.assertEqual(expected4,list(revDesc.getValues()));
 319         self.assertEqual(expected5,list(mesh2.getNodalConnectivityIndex().getValues()));
 320         self.assertEqual(expected6,list(mesh2.getNodalConnectivity().getValues()));
 321         #
 322         eltsV=[1,3]
 323         mesh.convertToPolyTypes(eltsV);
 324         mesh.checkCoherency();
 325         desc=DataArrayInt.New();
 326         descIndx=DataArrayInt.New();
 327         revDesc=DataArrayInt.New();
 328         revDescIndx=DataArrayInt.New();
 329         mesh2=mesh.buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
 330         mesh2.checkCoherency();
 331         self.assertEqual(2,mesh2.getMeshDimension());
 332         self.assertEqual(36,mesh2.getNumberOfCells());
 333         self.assertEqual(37,revDescIndx.getNbOfElems()); self.assertEqual(37,revDescIndx.getNumberOfTuples());
 334         self.assertEqual(9,descIndx.getNbOfElems()); self.assertEqual(9,descIndx.getNumberOfTuples());
 335         self.assertEqual(48,desc.getNbOfElems()); self.assertEqual(48,desc.getNumberOfTuples());
 336         self.assertEqual(48,revDesc.getNbOfElems()); self.assertEqual(48,revDesc.getNumberOfTuples());
 337         self.assertEqual(expected1,list(descIndx.getValues()));
 338         self.assertEqual(expected2,list(desc.getValues()));
 339         self.assertEqual(expected3,list(revDescIndx.getValues()));
 340         self.assertEqual(expected4,list(revDesc.getValues()));
 341         self.assertEqual(expected5,list(mesh2.getNodalConnectivityIndex().getValues()));
 342         self.assertEqual(expected7,list(mesh2.getNodalConnectivity().getValues()));
 343         pass
 344
 345     def testFindBoundaryNodes(self):
 346         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
 347         boundaryNodes=mesh.findBoundaryNodes();
 348         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];
 349         self.assertEqual(expected1,boundaryNodes.getValues());
 350         pass
 351
 352     def testBoundaryMesh(self):
 353         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
 354         mesh2=mesh.buildBoundaryMesh(False);
 355         self.assertEqual(24,mesh2.getNumberOfCells());
 356         self.assertEqual(26,mesh2.getNumberOfNodes());
 357         pass
 358
 359     def testBuildPartOfMySelf(self):
 360         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
 361         mesh.setName("Toto");
 362         tab1=[0,4]
 363         tab2=[0,2,3]
 364         #
 365         subMesh=mesh.buildPart(tab1)
 366         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
 367         subMesh=mesh.buildPartOfMySelf(tab1,True);
 368         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
 369         name=subMesh.getName();
 370         self.assertEqual(2,len(mesh.getAllTypes()));
 371         self.assertEqual(NORM_TRI3,mesh.getAllTypes()[0]);
 372         self.assertEqual(NORM_QUAD4,mesh.getAllTypes()[1]);
 373         self.assertEqual(1,len(subMesh.getAllTypes()));
 374         self.assertEqual(NORM_QUAD4,subMesh.getAllTypes()[0]);
 375         self.assertEqual(name,"Toto");
 376         self.assertEqual(2,subMesh.getNumberOfCells());
 377         subConn=[4,0,3,4,1,4,7,8,5,4];
 378         subConnIndex=[0,5,10];
 379         self.assertEqual(10,subMesh.getNodalConnectivity().getNbOfElems());
 380         self.assertEqual(3,subMesh.getNodalConnectivityIndex().getNbOfElems());
 381         self.assertEqual(subConn[0:10],list(subMesh.getNodalConnectivity().getValues()));
 382         self.assertEqual(subConnIndex[0:3],list(subMesh.getNodalConnectivityIndex().getValues()));
 383         #
 384         subMesh=mesh.buildPartOfMySelf(tab2[0:3],True);
 385         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh));
 386         name=subMesh.getName();
 387         self.assertEqual(2,len(subMesh.getAllTypes()));
 388         self.assertEqual(NORM_TRI3,subMesh.getAllTypes()[0]);
 389         self.assertEqual(NORM_QUAD4,subMesh.getAllTypes()[1]);
 390         self.assertEqual(name,"Toto");
 391         self.assertEqual(3,subMesh.getNumberOfCells());
 392         subConn2=[4,0,3,4,1,3,4,5,2,4,6,7,4,3]
 393         subConnIndex2=[0,5,9,14]
 394         self.assertEqual(14,subMesh.getNodalConnectivity().getNbOfElems());
 395         self.assertEqual(4,subMesh.getNodalConnectivityIndex().getNbOfElems());
 396         self.assertEqual(subConn2[0:14],list(subMesh.getNodalConnectivity().getValues()));
 397         self.assertEqual(subConnIndex2[0:4],list(subMesh.getNodalConnectivityIndex().getValues()));
 398         dd=DataArrayInt.New()
 399         dd.alloc(3,1)
 400         dd.iota(0)
 401         dd.setName("coucou")
 402         subMesh=subMesh.buildPartOfMySelf(dd,True);
 403         self.assertEqual("coucou",subMesh.getName());
 404         pass
 405
 406     def testBuildPartOfMySelfNode(self):
 407         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
 408         tab1=[5,7,8,4]
 409         subMesh=mesh.buildPartOfMySelfNode(tab1[0:4],True);
 410         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
 411         self.assertEqual(1,len(subMesh.getAllTypes()));
 412         self.assertEqual(NORM_QUAD4,subMesh.getAllTypes()[0]);
 413         self.assertEqual(1,subMesh.getNumberOfCells());
 414         self.assertEqual(5,subMesh.getNodalConnectivity().getNbOfElems());
 415         self.assertEqual(2,subMesh.getNodalConnectivityIndex().getNbOfElems());
 416         subConn=[4,7,8,5,4]
 417         subConnIndex=[0,5]
 418         self.assertEqual(subConn[0:5],list(subMesh.getNodalConnectivity().getValues()));
 419         self.assertEqual(subConnIndex[0:2],list(subMesh.getNodalConnectivityIndex().getValues()));
 420         #
 421         ddd=DataArrayInt.New()
 422         ddd.setValues(tab1[0:2],2,1)
 423         ddd.setName("ddd")
 424         subMesh=mesh.buildPartOfMySelfNode(ddd,False);
 425         self.assertEqual("ddd",subMesh.getName())
 426         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
 427         self.assertEqual(2,len(subMesh.getAllTypes()));
 428         self.assertEqual(NORM_TRI3,subMesh.getAllTypes()[0]);
 429         self.assertEqual(NORM_QUAD4,subMesh.getAllTypes()[1]);
 430         self.assertEqual(3,subMesh.getNumberOfCells());
 431         self.assertEqual(14,subMesh.getNodalConnectivity().getNbOfElems());
 432         self.assertEqual(4,subMesh.getNodalConnectivityIndex().getNbOfElems());
 433         subConn2=[3,4,5,2,4,6,7,4,3,4,7,8,5,4]
 434         subConnIndex2=[0,4,9,14]
 435         self.assertEqual(subConn2[0:14],list(subMesh.getNodalConnectivity().getValues()));
 436         self.assertEqual(subConnIndex2[0:4],list(subMesh.getNodalConnectivityIndex().getValues()));
 437         #testing the case where length of tab2 is greater than max number of node per cell.
 438         tab2=[0,3,2,1,4,5,6]
 439         subMesh=mesh.buildPartOfMySelfNode(tab2[0:7],True);
 440         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
 441         self.assertEqual(2,len(subMesh.getAllTypes()));
 442         self.assertEqual(NORM_TRI3,subMesh.getAllTypes()[0]);
 443         self.assertEqual(NORM_QUAD4,subMesh.getAllTypes()[1]);
 444         self.assertEqual(3,subMesh.getNumberOfCells());
 445         pass
 446
 447     def testZipCoords(self):
 448         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
 449         self.assertEqual(2,len(mesh.getAllTypes()));
 450         self.assertEqual(2,mesh.getSpaceDimension());
 451         self.assertEqual(9,mesh.getNumberOfNodes());
 452         self.assertEqual(5,mesh.getNumberOfCells());
 453         oldConn=mesh.getNodalConnectivity().getValues()[0:mesh.getNodalConnectivity().getNbOfElems()];
 454         oldConnIndex=mesh.getNodalConnectivityIndex().getValues()[0:mesh.getNumberOfCells()+1]
 455         oldCoords=mesh.getCoords();
 456         mesh.zipCoords();
 457         self.assertEqual(2,len(mesh.getAllTypes()));
 458         self.assertEqual(2,mesh.getSpaceDimension());
 459         self.assertEqual(9,mesh.getNumberOfNodes());
 460         self.assertEqual(5,mesh.getNumberOfCells());
 461         self.assertEqual(mesh.getCoords().getValues()[0:2*9],oldCoords.getValues());
 462         self.assertEqual(list(oldConn),list(mesh.getNodalConnectivity().getValues()));
 463         self.assertEqual(list(oldConnIndex),list(mesh.getNodalConnectivityIndex().getValues()));
 464         #
 465         tab1=[0,4]
 466         subMesh=mesh.buildPartOfMySelf(tab1,True);
 467         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
 468         traducer=subMesh.zipCoordsTraducer();
 469         expectedTraducer=[0, 1, -1, 2, 3, 4, -1, 5, 6]
 470         self.assertEqual(expectedTraducer,list(traducer.getValues()));
 471         self.assertEqual(NORM_QUAD4,subMesh.getAllTypes()[0]);
 472         self.assertEqual(2,subMesh.getNumberOfCells());
 473         subConn=[4,0,2,3,1,4,5,6,4,3]
 474         subConnIndex=[0,5,10]
 475         self.assertEqual(7,subMesh.getNumberOfNodes());
 476         self.assertEqual(10,subMesh.getNodalConnectivity().getNbOfElems());
 477         self.assertEqual(3,subMesh.getNodalConnectivityIndex().getNbOfElems());
 478         self.assertEqual(subConn,list(subMesh.getNodalConnectivity().getValues()));
 479         self.assertEqual(subConnIndex,list(subMesh.getNodalConnectivityIndex().getValues()));
 480         #
 481         subMesh=mesh.buildPartOfMySelf(tab1,False);
 482         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
 483         self.assertEqual(NORM_QUAD4,subMesh.getAllTypes()[0]);
 484         self.assertEqual(2,subMesh.getNumberOfCells());
 485         self.assertEqual(7,subMesh.getNumberOfNodes());
 486         self.assertEqual(10,subMesh.getNodalConnectivity().getNbOfElems());
 487         self.assertEqual(3,subMesh.getNodalConnectivityIndex().getNbOfElems());
 488         self.assertEqual(subConn,list(subMesh.getNodalConnectivity().getValues()));
 489         self.assertEqual(subConnIndex,list(subMesh.getNodalConnectivityIndex().getValues()));
 490         pass
 491
 492     def testZipConnectivity(self):
 493         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
 494         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
 495         cells1=[2,3,4]
 496         m3=m2.buildPartOfMySelf(cells1,True);
 497         self.assertTrue(isinstance(m3,MEDCouplingUMesh))
 498         m4=MEDCouplingDataForTest.build2DSourceMesh_1();
 499         m5=MEDCouplingUMesh.MergeUMeshes(m1,m3);
 500         m6=MEDCouplingUMesh.MergeUMeshes(m5,m4);
 501         #
 502         self.assertEqual(10,m6.getNumberOfCells());
 503         self.assertEqual(22,m6.getNumberOfNodes());
 504         (arr,areNodesMerged,newNbOfNodes)=m6.mergeNodes(1e-13);
 505         self.assertTrue(areNodesMerged);
 506         self.assertEqual(10,m6.getNumberOfCells());
 507         self.assertEqual(9,m6.getNumberOfNodes());
 508         #
 509         arr=m6.zipConnectivityTraducer(0);
 510         self.assertEqual(7,m6.getNumberOfCells());
 511         m7=m6.clone(True);
 512         arr=m6.zipConnectivityTraducer(0);
 513         self.assertTrue(m7.isEqual(m6,1e-12));
 514         self.assertEqual(7,m6.getNumberOfCells());
 515         pass
 516
 517     def testEqualMesh(self):
 518         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
 519         mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
 520         #
 521         self.assertTrue(mesh1.isEqual(mesh1,1e-12));
 522         #
 523         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
 524         self.assertTrue(mesh2.isEqual(mesh1,1e-12));
 525         pt=mesh2.getCoords().getValues();
 526         tmp=pt[1]
 527         mesh2.getCoords().setIJ(0,1,5.999);
 528         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
 529         self.assertTrue(not mesh2.isEqual(mesh1,1e-12));
 530         mesh2.getCoords().setIJ(0,1,tmp);
 531         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
 532         self.assertTrue(mesh2.isEqual(mesh1,1e-12));
 533         #
 534         pt2=mesh1.getNodalConnectivity().getValues();
 535         mesh1.getNodalConnectivity().setIJ(5,0,int(pt2[5])+1);
 536         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
 537         self.assertTrue(not mesh2.isEqual(mesh1,1e-12));
 538         mesh1.getNodalConnectivity().setIJ(5,0,int(pt2[5]));
 539         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
 540         self.assertTrue(mesh2.isEqual(mesh1,1e-12));
 541         #
 542         pt2=mesh1.getNodalConnectivityIndex().getValues();
 543         mesh1.getNodalConnectivityIndex().setIJ(1,0,int(pt2[1]+1));
 544         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
 545         self.assertTrue(not mesh2.isEqual(mesh1,1e-12));
 546         mesh1.getNodalConnectivityIndex().setIJ(1,0,int(pt2[1]));
 547         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
 548         self.assertTrue(mesh2.isEqual(mesh1,1e-12));
 549         #
 550         tmp3=mesh1.getName();
 551         mesh1.setName("lllll");
 552         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
 553         self.assertTrue(not mesh2.isEqual(mesh1,1e-12));
 554         mesh1.setName(tmp3);
 555         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
 556         self.assertTrue(mesh2.isEqual(mesh1,1e-12));
 557         #
 558         tmp3=mesh2.getCoords().getInfoOnComponent(1);
 559         mesh2.getCoords().setInfoOnComponent(1,"kkkkkk");
 560         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
 561         self.assertTrue(not mesh2.isEqual(mesh1,1e-12));
 562         mesh2.getCoords().setInfoOnComponent(1,tmp3);
 563         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
 564         self.assertTrue(mesh2.isEqual(mesh1,1e-12));
 565         pass
 566
 567     def testEqualFieldDouble(self):
 568         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
 569         mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
 570         #
 571         fieldOnCells1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
 572         fieldOnCells1.setMesh(mesh1);
 573         fieldOnCells2=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
 574         fieldOnCells2.setMesh(mesh2);
 575         #
 576         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 577         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 578         #
 579         fieldOnNodes1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
 580         self.assertTrue(not fieldOnCells1.isEqual(fieldOnNodes1,1e-12,1e-15));
 581         self.assertTrue(not fieldOnNodes1.isEqual(fieldOnCells1,1e-12,1e-15));
 582         #
 583         fieldOnCells2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
 584         self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 585         self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 586         fieldOnCells1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
 587         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 588         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 589         fieldOnCells1.setTime(4.,6,7);
 590         self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 591         self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 592         fieldOnCells2.setTime(4.,6,7);
 593         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 594         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 595         fieldOnCells1.setName("Power");
 596         self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 597         self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 598         fieldOnCells2.setName("Power");
 599         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 600         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 601         #
 602         fieldOnCells1.setMesh(mesh1);
 603         self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 604         self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 605         fieldOnCells2.setMesh(mesh1);
 606         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 607         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 608         arr=DataArrayDouble.New();
 609         arr.setName("popo");
 610         arr.setValues(mesh1.getNumberOfCells()*3*[6.],mesh1.getNumberOfCells(),3);
 611         fieldOnCells1.setArray(arr);
 612         self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 613         self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 614         fieldOnCells2.setArray(arr);
 615         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 616         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 617         #
 618         arr2=arr.deepCpy();
 619         fieldOnCells2.setArray(arr2);
 620         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 621         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 622         arr.setIJ(1,2,6.1);
 623         self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 624         self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 625         arr.setIJ(1,2,6.);
 626         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 627         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 628         arr2.setName("popo2");
 629         self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 630         self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 631         #
 632         arr2.setName("popo");
 633         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 634         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 635         #
 636         arr2.setInfoOnComponent(2,"jjj");
 637         self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 638         self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 639         arr.setInfoOnComponent(2,"jjj");
 640         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 641         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 642         pass
 643
 644     def testNatureChecking(self):
 645         field=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
 646         field.setNature(Integral);
 647         field.setNature(ConservativeVolumic);
 648         field.setNature(IntegralGlobConstraint);
 649         field=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
 650         field.setNature(ConservativeVolumic);
 651         self.assertRaises(InterpKernelException,field.setNature,Integral);
 652         self.assertRaises(InterpKernelException,field.setNature,IntegralGlobConstraint);
 653         pass
 654
 655     def testBuildSubMeshData(self):
 656         targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1()
 657         #check buildSubMesh on field on cells
 658         fieldCells=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
 659         fieldCells.setMesh(targetMesh);
 660         elts=[1,2,4]
 661         ret1,di=fieldCells.buildSubMeshData(elts);
 662         self.assertTrue(isinstance(ret1,MEDCouplingUMesh))
 663         self.assertEqual(3,ret1.getNumberOfCells());
 664         self.assertEqual(9,ret1.getNumberOfNodes());
 665         self.assertEqual(3,di.getNumberOfTuples());
 666         self.assertEqual(1,di.getNumberOfComponents());
 667         toCheck=di.getValues();
 668         self.assertTrue(elts,toCheck);
 669         #check buildSubMesh on field on nodes
 670         fieldNodes=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
 671         fieldNodes.setMesh(targetMesh);
 672         ret2,di=fieldNodes.buildSubMeshData(elts);
 673         self.assertTrue(isinstance(ret2,MEDCouplingUMesh))
 674         self.assertEqual(3,ret2.getNumberOfCells());
 675         self.assertEqual(6,ret2.getNumberOfNodes());
 676         self.assertEqual(6,di.getNumberOfTuples());
 677         self.assertEqual(1,di.getNumberOfComponents());
 678         toCheck=di.getValues();
 679         expected=[1,2,4,5,7,8]
 680         self.assertEqual(expected,list(toCheck));
 681         pass
 682
 683     def testExtrudedMesh1(self):
 684         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
 685         ext=MEDCouplingExtrudedMesh.New(mesh3D,mesh2D,1);
 686         self.assertEqual(18,ext.getNumberOfCells());
 687         self.assertEqual(60,ext.getNumberOfNodes());
 688         ids3D=ext.getMesh3DIds();
 689         ids3DExpected=[5,4,3,2,1,0, 11,10,9,8,7,6, 17,16,15,14,13,12]
 690         self.assertEqual(18,ids3D.getNumberOfTuples());
 691         self.assertEqual(1,ids3D.getNumberOfComponents());
 692         self.assertEqual(ids3DExpected,list(ids3D.getValues()));
 693         mesh1D=ext.getMesh1D();
 694         self.assertEqual(4,mesh1D.getNumberOfNodes());
 695         self.assertEqual(3,mesh1D.getNumberOfCells());
 696         mesh1DExpected=[0.66666666666666663, 1.4583333333333333, 0, 0.66666666666666663,
 697                         1.4583333333333333, 1, 0.66666666666666663, 1.4583333333333333,
 698                         2, 0.66666666666666663, 1.4583333333333333, 3]
 699         mesh1DCoords=mesh1D.getCoords();
 700         self.assertEqual(4,mesh1DCoords.getNumberOfTuples());
 701         self.assertEqual(3,mesh1DCoords.getNumberOfComponents());
 702         self.assertEqual(mesh1DExpected,mesh1DCoords.getValues());
 703         conn1D=mesh1D.getNodalConnectivity();
 704         self.assertEqual(9,conn1D.getNumberOfTuples());
 705         self.assertEqual(1,conn1D.getNumberOfComponents());
 706         conn1DExpected=[1,0,1,1,1,2,1,2,3]
 707         self.assertEqual(conn1DExpected,list(conn1D.getValues()));
 708         pass
 709
 710     def testExtrudedMesh3(self):
 711         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
 712         m1.changeSpaceDimension(3);
 713         m2=MEDCouplingDataForTest.buildCU1DMesh_U();
 714         m2.changeSpaceDimension(3);
 715         center=[0.,0.,0.]
 716         vector=[0.,1.,0.]
 717         m2.rotate(center,vector,-pi/2.);
 718         m3=m1.buildExtrudedMesh(m2,0);
 719         #
 720         m4=MEDCouplingExtrudedMesh.New(m3,m1,0);
 721         self.assertEqual(15,m4.getNumberOfCells());
 722         self.assertEqual(5,m4.getMesh2D().getNumberOfCells());
 723         self.assertEqual(3,m4.getMesh1D().getNumberOfCells());
 724         m3DIds=m4.getMesh3DIds().getValues();
 725         self.assertEqual(range(15),list(m3DIds));
 726         #some random in cells to check that extrusion alg find it correctly
 727         expected1=[1,3,2,0,6,5,7,10,11,8,12,9,14,13,4]
 728         m3.renumberCells(expected1,False);
 729         m4=MEDCouplingExtrudedMesh.New(m3,m1,0);
 730         self.assertEqual(15,m4.getNumberOfCells());
 731         self.assertEqual(5,m4.getMesh2D().getNumberOfCells());
 732         self.assertEqual(3,m4.getMesh1D().getNumberOfCells());
 733         m3DIds=m4.getMesh3DIds().getValues();
 734         self.assertEqual(expected1,list(m3DIds));
 735         #play with polygons and polyedrons
 736         cells=[2,3]
 737         m1.convertToPolyTypes(cells);
 738         m3=m1.buildExtrudedMesh(m2,0);
 739         self.assertEqual(NORM_HEXA8,m3.getTypeOfCell(0));
 740         self.assertEqual(NORM_PENTA6,m3.getTypeOfCell(1));
 741         self.assertEqual(NORM_POLYHED,m3.getTypeOfCell(2));
 742         self.assertEqual(NORM_POLYHED,m3.getTypeOfCell(3));
 743         self.assertEqual(NORM_HEXA8,m3.getTypeOfCell(4));
 744         m3.renumberCells(expected1,False);
 745         m4=MEDCouplingExtrudedMesh.New(m3,m1,0);
 746         self.assertEqual(15,m4.getNumberOfCells());
 747         self.assertEqual(5,m4.getMesh2D().getNumberOfCells());
 748         self.assertEqual(3,m4.getMesh1D().getNumberOfCells());
 749         m3DIds=m4.getMesh3DIds().getValues();
 750         self.assertEqual(expected1,list(m3DIds));
 751         pass
 752
 753     def testExtrudedMesh4(self):
 754         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
 755         cells=[2,4];
 756         m1.convertToPolyTypes(cells);
 757         m1.changeSpaceDimension(3);
 758         m2=MEDCouplingDataForTest.buildCU1DMesh_U();
 759         m2.changeSpaceDimension(3);
 760         center=[0.,0.,0.]
 761         vector=[0.,1.,0.]
 762         m2.rotate(center,vector,-pi/2.);
 763         m3=m1.buildExtrudedMesh(m2,0);
 764         expected1=[1,3,2,0,6,5,7,10,11,8,12,9,14,13,4]
 765         rexpected1=[3, 0, 2, 1, 14, 5, 4, 6, 9, 11, 7, 8, 10, 13, 12]
 766         m3.renumberCells(expected1,False);
 767         m4=MEDCouplingExtrudedMesh.New(m3,m1,0);
 768         self.assertEqual(NORM_HEXA8,m4.getTypeOfCell(0));
 769         self.assertEqual(NORM_HEXA8,m4.getTypeOfCell(1));
 770         self.assertEqual(NORM_POLYHED,m4.getTypeOfCell(2));
 771         self.assertEqual(NORM_PENTA6,m4.getTypeOfCell(7));
 772         f=m4.getMeasureField(True);
 773         arr=f.getArray();
 774         self.assertEqual(15,arr.getNumberOfTuples());
 775         self.assertEqual(1,arr.getNumberOfComponents());
 776         arrPtr=arr.getValues();
 777         expected2=[0.075,0.0375,0.0375,0.075,0.075,
 778                    0.1125,0.05625,0.05625,0.1125,0.1125,
 779                    0.0625,0.03125,0.03125,0.0625,0.0625]
 780         for i in xrange(15):
 781             self.assertAlmostEqual(expected2[rexpected1[i]],arrPtr[i],16);
 782             pass
 783         m5=m4.build3DUnstructuredMesh();
 784         self.assertTrue(m5.isEqual(m3,1e-12));
 785         f=m5.getMeasureField(True);
 786         f.setMesh(m4)
 787         self.assertTrue(isinstance(f.getMesh(),MEDCouplingExtrudedMesh))
 788         arr=f.getArray();
 789         arrPtr=arr.getValues();
 790         for i in xrange(15):
 791             self.assertAlmostEqual(expected2[rexpected1[i]],arrPtr[i],15);
 792             pass
 793         pass
 794
 795     def testFindCommonNodes(self):
 796         targetMesh=MEDCouplingDataForTest.build3DTargetMesh_1();
 797         comm,commI=targetMesh.findCommonNodes(1e-10,-1);
 798         self.assertEqual(1,commI.getNumberOfTuples());
 799         self.assertEqual(0,comm.getNumberOfTuples());
 800         o2n,newNbOfNodes=targetMesh.buildNewNumberingFromCommonNodesFormat(comm,commI);
 801         self.assertEqual(27,newNbOfNodes);
 802         self.assertEqual(27,o2n.getNumberOfTuples());
 803         o2nExp1=range(27)
 804         self.assertEqual(o2nExp1,list(o2n.getValues()));
 805         #
 806         targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
 807         self.assertEqual(31,targetMesh.getNumberOfNodes());
 808         comm,commI=targetMesh.findCommonNodes(1e-10);# testing default parameter
 809         self.assertEqual(3,commI.getNumberOfTuples());
 810         self.assertEqual(6,comm.getNumberOfTuples());
 811         commExpected=[1,27,28,29,23,30]
 812         commIExpected=[0,4,6]
 813         self.assertEqual(commExpected,list(comm.getValues()));
 814         self.assertEqual(commIExpected,list(commI.getValues()));
 815         o2n,newNbOfNodes=targetMesh.buildNewNumberingFromCommonNodesFormat(comm,commI);
 816         self.assertEqual(31,o2n.getNumberOfTuples());
 817         self.assertEqual(27,newNbOfNodes);
 818         o2nExp2=[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,
 819                  21,22,23,24,25,26,1,1,1,23]
 820         self.assertEqual(o2nExp2,list(o2n.getValues()));
 821         #
 822         targetMesh=MEDCouplingDataForTest.build3DTargetMesh_1();
 823         time=targetMesh.getTimeOfThis();
 824         o2n,areNodesMerged,newNbOfNodes=targetMesh.mergeNodes(1e-10);
 825         targetMesh.updateTime();
 826         self.assertEqual(time,targetMesh.getTimeOfThis());
 827         self.assertTrue(not areNodesMerged);
 828         #
 829         targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
 830         time=targetMesh.getTimeOfThis();
 831         o2n,areNodesMerged,newNbOfNodes=targetMesh.mergeNodes(1e-10);
 832         targetMesh.updateTime();
 833         self.assertTrue(time!=targetMesh.getTimeOfThis());
 834         self.assertTrue(areNodesMerged);
 835         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,
 836                  18,4,5,8,7,13,14,17,16,
 837                  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,
 838                  18,13,14,17,16,22,23,26,25]
 839         self.assertEqual(72,targetMesh.getNodalConnectivity().getNumberOfTuples());
 840         self.assertEqual(connExp,list(targetMesh.getNodalConnectivity().getValues()));
 841         self.assertEqual(27,targetMesh.getCoords().getNumberOfTuples());
 842         coordsExp=[ 0., 0., 0., 50., 0., 0. , 200., 0., 0.  , 0., 50., 0., 50., 50., 0. ,
 843                     200., 50., 0.,   0., 200., 0., 50., 200., 0. , 200., 200., 0. ,
 844                     0., 0., 50., 50., 0., 50. , 200., 0., 50.  , 0., 50., 50., 50.,
 845                     50., 50. , 200., 50., 50.,   0., 200., 50., 50., 200., 50. ,
 846                     200., 200., 50. , 0., 0., 200., 50., 0., 200. , 200., 0., 200.
 847                     , 0., 50., 200., 50., 50., 200. , 200., 50., 200.,
 848                     0., 200., 200., 50., 200., 200. , 200., 200., 200. ]
 849         self.assertEqual(coordsExp,targetMesh.getCoords().getValues());
 850         # 2D
 851         targetMesh=MEDCouplingDataForTest.build2DTargetMeshMergeNode_1();
 852         self.assertEqual(18,targetMesh.getNumberOfNodes());
 853         time=targetMesh.getTimeOfThis();
 854         o2n,areNodesMerged,newNbOfNodes=targetMesh.mergeNodes(1e-10);
 855         self.assertTrue(time!=targetMesh.getTimeOfThis());
 856         self.assertTrue(areNodesMerged);
 857         self.assertEqual(9,targetMesh.getNumberOfNodes());
 858         connExp2=[4,0,4,3,1, 3,1,3,2, 3,3,5,2, 4,4,6,7,3, 4,7,8,5,3]
 859         self.assertEqual(23,targetMesh.getNodalConnectivity().getNumberOfTuples());
 860         self.assertEqual(connExp2,list(targetMesh.getNodalConnectivity().getValues()));
 861         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]
 862         self.assertEqual(9,targetMesh.getCoords().getNumberOfTuples());
 863         self.assertEqual(coordsExp2,targetMesh.getCoords().getValues());
 864         pass
 865
 866     def testCheckButterflyCells(self):
 867         sourceMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
 868         cells=sourceMesh.checkButterflyCells();
 869         self.assertEqual(0,len(cells));
 870         conn=sourceMesh.getNodalConnectivity()
 871         tmp=conn.getIJ(15,0)
 872         conn.setIJ(15,0,conn.getIJ(16,0))
 873         conn.setIJ(16,0,tmp)
 874         cells=sourceMesh.checkButterflyCells();
 875         self.assertEqual(1,len(cells));
 876         self.assertEqual([3],cells.getValues());
 877         tmp=conn.getIJ(15,0)
 878         conn.setIJ(15,0,conn.getIJ(16,0))
 879         conn.setIJ(16,0,tmp)
 880         cells=sourceMesh.checkButterflyCells();
 881         self.assertEqual(0,len(cells));
 882         # 3D surf
 883         sourceMesh=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
 884         cells=sourceMesh.checkButterflyCells();
 885         self.assertEqual(0,len(cells));
 886         conn=sourceMesh.getNodalConnectivity()
 887         tmp=conn.getIJ(15,0)
 888         conn.setIJ(15,0,conn.getIJ(16,0))
 889         conn.setIJ(16,0,tmp)
 890         cells=sourceMesh.checkButterflyCells();
 891         self.assertEqual(1,len(cells));
 892         self.assertEqual([3],cells.getValues());
 893         tmp=conn.getIJ(15,0)
 894         conn.setIJ(15,0,conn.getIJ(16,0))
 895         conn.setIJ(16,0,tmp)
 896         cells=sourceMesh.checkButterflyCells();
 897         self.assertEqual(0,len(cells));
 898         pass
 899
 900     def testMergeMesh1(self):
 901         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
 902         m2=MEDCouplingDataForTest.build2DSourceMesh_1();
 903         vec=[1.,0.]
 904         m2.translate(vec);
 905         m3=m1.mergeMyselfWith(m2);
 906         self.assertTrue(isinstance(m3,MEDCouplingUMesh));
 907         m3.checkCoherency();
 908         m4=MEDCouplingDataForTest.build2DTargetMeshMerged_1();
 909         self.assertTrue(m3.isEqual(m4,1.e-12));
 910         da,isMerged,newNbOfNodes=m3.mergeNodes(1.e-12);
 911         self.assertEqual(11,m3.getNumberOfNodes());
 912         self.assertTrue(isMerged);
 913         pass
 914
 915     def testMergeMeshOnSameCoords1(self):
 916         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
 917         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
 918         cells=range(5);
 919         m2.convertToPolyTypes(cells);
 920         m1.tryToShareSameCoords(m2,1e-12);
 921         m3=MEDCouplingDataForTest.build2DTargetMesh_1();
 922         m3.tryToShareSameCoords(m2,1e-12);
 923         meshes=[m1,m2,m3]
 924         m4=MEDCouplingUMesh.MergeUMeshesOnSameCoords(meshes);
 925         m4.checkCoherency();
 926         self.assertEqual(15,m4.getNumberOfCells());
 927         cells1=[0,1,2,3,4]
 928         m1_1=m4.buildPartOfMySelf(cells1,True);
 929         m1_1.setName(m1.getName());
 930         self.assertTrue(m1.isEqual(m1_1,1e-12));
 931         cells2=[5,6,7,8,9]
 932         m2_1=m4.buildPartOfMySelf(cells2,True);
 933         m2_1.setName(m2.getName());
 934         self.assertTrue(m2.isEqual(m2_1,1e-12));
 935         cells3=[10,11,12,13,14]
 936         m3_1=m4.buildPartOfMySelf(cells3,True);
 937         m3_1.setName(m3.getName());
 938         self.assertTrue(m3.isEqual(m3_1,1e-12));
 939         pass
 940
 941     def testMergeField1(self):
 942         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
 943         m2=MEDCouplingDataForTest.build2DSourceMesh_1();
 944         vec=[1.,0.]
 945         m2.translate(vec);
 946         f1=m1.getMeasureField(True);
 947         f2=m2.getMeasureField(True);
 948         f3=MEDCouplingFieldDouble.MergeFields(f1,f2);
 949         f3.checkCoherency();
 950         m4=MEDCouplingDataForTest.build2DTargetMeshMerged_1();
 951         self.assertTrue(f3.getMesh().isEqual(m4,1.e-12));
 952         name=f3.getName();
 953         self.assertEqual(name,"MeasureOfMesh_");
 954         self.assertEqual(f3.getTypeOfField(),ON_CELLS);
 955         self.assertEqual(f3.getTimeDiscretization(),ONE_TIME);
 956         self.assertEqual(1,f3.getNumberOfComponents());
 957         self.assertEqual(7,f3.getNumberOfTuples());
 958         values=[0.25,0.125,0.125,0.25,0.25,0.5,0.5]
 959         tmp=f3.getArray().getValues();
 960         self.assertEqual(len(values),len(tmp))
 961         for i in xrange(7):
 962             self.assertTrue(abs(values[i]-tmp[i])<1e-12)
 963             pass
 964         pass
 965
 966     def testFillFromAnalytic(self):
 967         m=MEDCouplingDataForTest.build2DTargetMesh_1();
 968         m.setTime(3.4,5,6); m.setTimeUnit("us");
 969         f1=m.fillFromAnalytic(ON_CELLS,1,"x+y");
 970         self.assertAlmostEqual(3.4,f1.getTime()[0],12) ; self.assertEqual(5,f1.getTime()[1]) ; self.assertEqual(6,f1.getTime()[2])
 971         self.assertEqual("us",f1.getTimeUnit())
 972         f1.checkCoherency();
 973         self.assertEqual(f1.getTypeOfField(),ON_CELLS);
 974         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
 975         self.assertEqual(1,f1.getNumberOfComponents());
 976         self.assertEqual(5,f1.getNumberOfTuples());
 977         values1=[-0.1,0.23333333333333336,0.56666666666666665,0.4,0.9]
 978         tmp=f1.getArray().getValues();
 979         self.assertEqual(len(values1),len(tmp))
 980         for i in xrange(len(tmp)):
 981             self.assertTrue(abs(tmp[i]-values1[i])<1.e-12)
 982             pass
 983         #
 984         f1=m.fillFromAnalytic(ON_NODES,1,"x+y");
 985         f1.checkCoherency();
 986         self.assertEqual(f1.getTypeOfField(),ON_NODES);
 987         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
 988         self.assertEqual(1,f1.getNumberOfComponents());
 989         self.assertEqual(9,f1.getNumberOfTuples());
 990         values2=[-0.6,-0.1,0.4,-0.1,0.4,0.9,0.4,0.9,1.4]
 991         tmp=f1.getArray().getValues();
 992         self.assertEqual(len(values2),len(tmp))
 993         for i in xrange(len(tmp)):
 994             self.assertTrue(abs(tmp[i]-values2[i])<1.e-12)
 995             pass
 996         #
 997         f1=m.fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+(2*(x+y))*JVec");
 998         f1.checkCoherency();
 999         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1000         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1001         self.assertEqual(2,f1.getNumberOfComponents());
1002         self.assertEqual(9,f1.getNumberOfTuples());
1003         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]
1004         tmp=f1.getArray().getValues();
1005         self.assertEqual(len(values3),len(tmp))
1006         for i in xrange(len(tmp)):
1007             self.assertTrue(abs(tmp[i]-values3[i])<1.e-12)
1008             pass
1009         values4=f1.accumulate();
1010         self.assertEqual(2,len(values4))
1011         self.assertTrue(abs(3.6-values4[0])<1.e-12);
1012         self.assertTrue(abs(7.2-values4[1])<1.e-12);
1013         values4=f1.integral(True);
1014         self.assertEqual(2,len(values4))
1015         self.assertTrue(abs(0.5-values4[0])<1.e-12);
1016         self.assertTrue(abs(1.-values4[1])<1.e-12);
1017         #
1018         self.assertRaises(InterpKernelException,m.fillFromAnalytic,ON_NODES,1,"1./(x-0.2)");
1019         pass
1020
1021     def testFillFromAnalytic2(self):
1022         m=MEDCouplingDataForTest.build2DTargetMesh_1();
1023         f1=m.fillFromAnalytic(ON_CELLS,1,"y+x");
1024         f1.checkCoherency();
1025         self.assertEqual(f1.getTypeOfField(),ON_CELLS);
1026         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1027         self.assertEqual(1,f1.getNumberOfComponents());
1028         self.assertEqual(5,f1.getNumberOfTuples());
1029         values1=[-0.1,0.23333333333333336,0.56666666666666665,0.4,0.9]
1030         tmp=f1.getArray().getValues();
1031         self.assertEqual(len(values1),len(tmp))
1032         for i in xrange(len(values1)):
1033             self.assertTrue(abs(values1[i]-tmp[i])<1.e-12);
1034             pass
1035         #
1036         f1=m.fillFromAnalytic(ON_NODES,1,"y+2*x");
1037         f1.checkCoherency();
1038         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1039         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1040         self.assertEqual(1,f1.getNumberOfComponents());
1041         self.assertEqual(9,f1.getNumberOfTuples());
1042         values2=[-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1]
1043         tmp=f1.getArray().getValues();
1044         self.assertEqual(len(values2),len(tmp))
1045         for i in xrange(len(values2)):
1046             self.assertTrue(abs(values2[i]-tmp[i])<1.e-12);
1047             pass
1048         f1=m.fillFromAnalytic(ON_NODES,1,"2.*x+y");
1049         f1.checkCoherency();
1050         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1051         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1052         self.assertEqual(1,f1.getNumberOfComponents());
1053         self.assertEqual(9,f1.getNumberOfTuples());
1054         tmp=f1.getArray().getValues();
1055         values2Bis=[-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1]
1056         self.assertEqual(len(values2Bis),len(tmp))
1057         for i in xrange(len(values2Bis)):
1058             self.assertTrue(abs(values2Bis[i]-tmp[i])<1.e-12);
1059             pass
1060         #
1061         f1=m.fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+2*(x+y)*JVec");
1062         f1.checkCoherency();
1063         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1064         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1065         self.assertEqual(2,f1.getNumberOfComponents());
1066         self.assertEqual(9,f1.getNumberOfTuples());
1067         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]
1068         tmp=f1.getArray().getValues();
1069         self.assertEqual(len(values3),len(tmp))
1070         for i in xrange(len(values3)):
1071             self.assertTrue(abs(values3[i]-tmp[i])<1.e-12);
1072             pass
1073         values4=f1.accumulate();
1074         self.assertTrue(abs(3.6-values4[0])<1.e-12);
1075         self.assertTrue(abs(7.2-values4[1])<1.e-12);
1076         values4=f1.integral(True);
1077         self.assertTrue(abs(0.5-values4[0])<1.e-12);
1078         self.assertTrue(abs(1.-values4[1])<1.e-12);
1079         pass
1080
1081     def testApplyFunc(self):
1082         m=MEDCouplingDataForTest.build2DTargetMesh_1();
1083         f1=m.fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+(2*(x+y))*JVec");
1084         f1.checkCoherency();
1085         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1086         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1087         self.assertEqual(2,f1.getNumberOfComponents());
1088         self.assertEqual(9,f1.getNumberOfTuples());
1089         f1.applyFunc(1,"x+y");
1090         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1091         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1092         self.assertEqual(1,f1.getNumberOfComponents());
1093         self.assertEqual(9,f1.getNumberOfTuples());
1094         values1=[-1.8,-0.3,1.2,-0.3,1.2,2.7,1.2,2.7,4.2]
1095         tmp=f1.getArray().getValues();
1096         self.assertEqual(len(values1),len(tmp))
1097         for i in xrange(len(tmp)):
1098             self.assertTrue(abs(tmp[i]-values1[i])<1.e-12)
1099             pass
1100         pass
1101
1102     def testApplyFunc2(self):
1103         m=MEDCouplingDataForTest.build2DTargetMesh_1();
1104         f1=m.fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+2*(x+y)*JVec");
1105         f1.checkCoherency();
1106         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1107         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1108         self.assertEqual(2,f1.getNumberOfComponents());
1109         self.assertEqual(9,f1.getNumberOfTuples());
1110         #
1111         f2=f1.clone(True);
1112         self.assertRaises(InterpKernelException, f2.applyFunc, 1, "a+b+c+d");
1113         self.assertRaises(InterpKernelException, f2.applyFunc, 1, "a/0");
1114         self.assertRaises(InterpKernelException, f2.applyFunc, "a/0");
1115         f2.applyFunc("abs(u)^2.4+2*u");
1116         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1117         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1118         self.assertEqual(2,f1.getNumberOfComponents());
1119         self.assertEqual(9,f1.getNumberOfTuples());
1120         values2=[-0.9065304805418678, -0.85105859001709905, -0.19601892829446504, -0.37898777756476987,
1121                  0.91090317490482353, 2.1853504664669781, -0.19601892829446504, -0.37898777756476987,
1122                  0.91090317490482353, 2.1853504664669781, 2.5765725275664879, 7.6987743736515295,
1123                  0.91090317490482353, 2.1853504664669781, 2.5765725275664879, 7.6987743736515295,
1124                  5.0423700574830965, 17.435300118916864]
1125         tmp=f2.getArray().getValues();
1126         self.assertEqual(len(tmp),len(values2))
1127         for i in xrange(len(tmp)):
1128             self.assertTrue(abs(tmp[i]-values2[i])<1.e-12)
1129             pass
1130         #
1131         f1.applyFunc(1,"x+y");
1132         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1133         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1134         self.assertEqual(1,f1.getNumberOfComponents());
1135         self.assertEqual(9,f1.getNumberOfTuples());
1136         values1=[-1.8,-0.3,1.2,-0.3,1.2,2.7,1.2,2.7,4.2]
1137         tmp=f1.getArray().getValues();
1138         self.assertEqual(len(tmp),len(values1))
1139         for i in xrange(len(tmp)):
1140             self.assertTrue(abs(tmp[i]-values1[i])<1.e-12)
1141             pass
1142         pass
1143
1144     def testOperationsOnFields(self):
1145         m=MEDCouplingDataForTest.build2DTargetMesh_1();
1146         f1=m.fillFromAnalytic(ON_NODES,1,"x+y");
1147         f2=m.fillFromAnalytic(ON_NODES,1,"x+y");
1148         f1.checkCoherency();
1149         f2.checkCoherency();
1150         f3=f1+f2;
1151         f3.checkCoherency();
1152         self.assertEqual(f3.getTypeOfField(),ON_NODES);
1153         self.assertEqual(f3.getTimeDiscretization(),ONE_TIME);
1154         values1=[-1.2,-0.2,0.8,-0.2,0.8,1.8,0.8,1.8,2.8]
1155         tmp=f3.getArray().getValues();
1156         self.assertEqual(len(values1),len(tmp))
1157         for i in xrange(len(tmp)):
1158             self.assertTrue(abs(tmp[i]-values1[i])<1.e-12)
1159             pass
1160         #
1161         f3=f1*f2;
1162         f3.checkCoherency();
1163         self.assertEqual(f3.getTypeOfField(),ON_NODES);
1164         self.assertEqual(f3.getTimeDiscretization(),ONE_TIME);
1165         values2=[0.36,0.01,0.16,0.01,0.16,0.81,0.16,0.81,1.96]
1166         tmp=f3.getArray().getValues();
1167         self.assertEqual(len(values2),len(tmp))
1168         for i in xrange(len(tmp)):
1169             self.assertTrue(abs(tmp[i]-values2[i])<1.e-12)
1170             pass
1171         #
1172         f3=f1+f2;
1173         f4=f1-f3;
1174         f4.checkCoherency();
1175         self.assertEqual(f4.getTypeOfField(),ON_NODES);
1176         self.assertEqual(f4.getTimeDiscretization(),ONE_TIME);
1177         values3=[0.6,0.1,-0.4,0.1,-0.4,-0.9,-0.4,-0.9,-1.4]
1178         tmp=f4.getArray().getValues();
1179         self.assertEqual(len(values3),len(tmp))
1180         for i in xrange(len(tmp)):
1181             self.assertTrue(abs(tmp[i]-values3[i])<1.e-12)
1182             pass
1183         #
1184         f3=f1+f2;
1185         f4=f3/f2;
1186         f4.checkCoherency();
1187         self.assertEqual(f4.getTypeOfField(),ON_NODES);
1188         self.assertEqual(f4.getTimeDiscretization(),ONE_TIME);
1189         tmp=f4.getArray().getValues();
1190         for i in xrange(len(tmp)):
1191             self.assertTrue(abs(tmp[i]-2.)<1.e-12)
1192             pass
1193         #
1194         f4=f2.buildNewTimeReprFromThis(NO_TIME,False);
1195         f4.checkCoherency();
1196         self.assertEqual(f4.getTypeOfField(),ON_NODES);
1197         self.assertEqual(f4.getTimeDiscretization(),NO_TIME);
1198         self.assertRaises(InterpKernelException,f1.__add__,f4);
1199         f5=f4.buildNewTimeReprFromThis(ONE_TIME,False);
1200         self.assertEqual(f5.getTypeOfField(),ON_NODES);
1201         self.assertEqual(f5.getTimeDiscretization(),ONE_TIME);
1202         f3=f1+f5;
1203         tmp=f3.getArray().getValues();
1204         values4=[-1.2,-0.2,0.8,-0.2,0.8,1.8,0.8,1.8,2.8]
1205         self.assertEqual(len(values3),len(tmp))
1206         for i in xrange(len(tmp)):
1207             self.assertTrue(abs(tmp[i]-values4[i])<1.e-12)
1208             pass
1209         #
1210         f4=f2.buildNewTimeReprFromThis(NO_TIME,True);
1211         f4.checkCoherency();
1212         self.assertEqual(f4.getTypeOfField(),ON_NODES);
1213         self.assertEqual(f4.getTimeDiscretization(),NO_TIME);
1214         self.assertRaises(InterpKernelException,f1.__add__,f4);
1215         f5=f4.buildNewTimeReprFromThis(ONE_TIME,True);
1216         self.assertEqual(f5.getTypeOfField(),ON_NODES);
1217         self.assertEqual(f5.getTimeDiscretization(),ONE_TIME);
1218         f3=f1+f5;
1219         tmp=f3.getArray().getValues();
1220         values5=[-1.2,-0.2,0.8,-0.2,0.8,1.8,0.8,1.8,2.8]
1221         self.assertEqual(len(values5),len(tmp))
1222         for i in xrange(len(tmp)):
1223             self.assertTrue(abs(tmp[i]-values5[i])<1.e-12)
1224             pass
1225         pass
1226
1227     def testOperationsOnFields2(self):
1228         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1229         m.setTime(3.4,5,6); m.setTimeUnit("us");
1230         f1=m.fillFromAnalytic(ON_NODES,1,"x+y+z");
1231         f2=m.fillFromAnalytic(ON_NODES,1,"a*a+b+c*c");
1232         f3=f1/f2;
1233         f3.checkCoherency();
1234         self.assertEqual(f3.getTypeOfField(),ON_NODES);
1235         self.assertEqual(f3.getTimeDiscretization(),ONE_TIME);
1236         expected1=[-2.4999999999999991, 1.2162162162162162, 0.77868852459016391,
1237                    0.7407407407407407, 1.129032258064516, 0.81632653061224492,
1238                    0.86538461538461531, 1.0919540229885056, 0.84302325581395343]
1239         self.assertEqual(1,f3.getNumberOfComponents());
1240         self.assertEqual(9,f3.getNumberOfTuples());
1241         val=f3.getArray().getValues();
1242         for i in xrange(9):
1243             self.assertTrue(abs(expected1[i]-val[i])<1.e-12);
1244         #
1245         f1=m.buildOrthogonalField();
1246         self.assertAlmostEqual(3.4,f1.getTime()[0],12) ; self.assertEqual(5,f1.getTime()[1]) ; self.assertEqual(6,f1.getTime()[2])
1247         self.assertEqual("us",f1.getTimeUnit())
1248         f2=m.fillFromAnalytic(ON_CELLS,1,"x");
1249         f3=f1*f2;
1250         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]
1251         val=f3.getArray().getValues();
1252         for i in xrange(15):
1253             self.assertTrue(abs(expected2[i]-val[i])<1.e-12);
1254             pass
1255         #
1256         f3=f2*f1;
1257         val=f3.getArray().getValues();
1258         for i in xrange(15):
1259             self.assertTrue(abs(expected2[i]-val[i])<1.e-12);
1260             pass
1261         pass
1262
1263     def testOperationsOnFields3(self):
1264         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1265         f1=m.fillFromAnalytic(ON_NODES,1,"x+y+z");
1266         f2=m.fillFromAnalytic(ON_NODES,1,"a*a+b+c*c");
1267         f1/=f2
1268         f1.checkCoherency();
1269         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1270         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1271         expected1=[-2.4999999999999991, 1.2162162162162162, 0.77868852459016391,
1272                    0.7407407407407407, 1.129032258064516, 0.81632653061224492,
1273                    0.86538461538461531, 1.0919540229885056, 0.84302325581395343]
1274         self.assertEqual(1,f1.getNumberOfComponents());
1275         self.assertEqual(9,f1.getNumberOfTuples());
1276         val=f1.getArray().getValues();
1277         for i in xrange(9):
1278             self.assertTrue(abs(expected1[i]-val[i])<1.e-12);
1279             pass
1280         #
1281         f1=m.buildOrthogonalField();
1282         f2=m.fillFromAnalytic(ON_CELLS,1,"x");
1283         f1*=f2
1284         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]
1285         val=f1.getArray().getValues();
1286         for i in xrange(15):
1287             self.assertTrue(abs(expected2[i]-val[i])<1.e-12);
1288             pass
1289         #
1290         f1=m.buildOrthogonalField();
1291         # to avoid valgrind leaks
1292         # self.assertRaises(InterpKernelException,f2.__imul__,f1);
1293         pass
1294
1295     def testOperationsOnFields4(self):
1296         m=MEDCouplingDataForTest.build2DTargetMesh_1();
1297         nbOfCells=m.getNumberOfCells();
1298         f1=MEDCouplingFieldDouble.New(ON_CELLS,CONST_ON_TIME_INTERVAL);
1299         f1.setMesh(m);
1300         array=DataArrayDouble.New();
1301         f1.setArray(array);
1302         self.assertRaises(InterpKernelException,f1.setEndArray,array);
1303         self.assertRaises(InterpKernelException,f1.getEndArray);
1304         arr1=[0.,10.,20.,1.,11.,21.,2.,12.,22.,3.,13.,23.,4.,14.,24.]
1305         arr2=[5.,15.,25.,6.,16.,26.,7.,17.,27.,8.,18.,28.,9.,19.,29.]
1306         array.setValues(arr1,nbOfCells,3);
1307         f1.setStartTime(2.,0,0);
1308         f1.setEndTime(3.,0,0);
1309         f1.checkCoherency();
1310         pos=[0.3,-0.2]
1311         res=f1.getValueOn(pos);
1312         self.assertTrue(abs(arr1[3]-res[0])<1.e-12);
1313         self.assertTrue(abs(arr1[4]-res[1])<1.e-12);
1314         self.assertTrue(abs(arr1[5]-res[2])<1.e-12);
1315         res=None
1316         res=f1.getValueOn(pos,2.2);
1317         self.assertTrue(abs(arr1[3]-res[0])<1.e-12);
1318         self.assertTrue(abs(arr1[4]-res[1])<1.e-12);
1319         self.assertTrue(abs(arr1[5]-res[2])<1.e-12);
1320         res=None
1321         self.assertRaises(InterpKernelException,f1.getValueOn,pos,3.2)
1322         f2=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
1323         f2.setMesh(m);
1324         f2.setArray(f1.getArray());
1325         f2.setStartTime(2.,3,0);
1326         f2.setEndTime(4.,13,0);
1327         self.assertRaises(InterpKernelException,f2.checkCoherency)
1328         array2=DataArrayDouble.New();
1329         array2.setValues(arr2,nbOfCells,3);
1330         f2.setEndArray(array2);
1331         f2.checkCoherency();
1332         #
1333         res=None
1334         res=f2.getValueOn(pos,3.21);
1335         self.assertTrue(abs(4.025-res[0])<1.e-12);
1336         self.assertTrue(abs(14.025-res[1])<1.e-12);
1337         self.assertTrue(abs(24.025-res[2])<1.e-12);
1338         f3=f2.clone(True);
1339         self.assertTrue(f2.isEqual(f3,1e-12,1e-12));
1340         f3.getEndArray().setIJ(0,0,5.001);
1341         self.assertTrue(not f2.isEqual(f3,1e-12,1e-12));
1342         self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1343         f3.setStartTime(2.1,3,0);
1344         self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1345         f3.setStartTime(2.,3,0);
1346         self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1347         f3.setStartTime(2.,4,0);
1348         self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1349         f3.setStartTime(2.,3,1);
1350         self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1351         f3.setStartTime(2.,3,0);
1352         self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1353         f3.setEndTime(4.1,13,0);
1354         self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1355         f3.setEndTime(4.,13,0);
1356         self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1357         f3.setEndTime(4.,14,0);
1358         self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1359         f3.setEndTime(4.,13,1);
1360         self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1361         f3.setEndTime(4.,13,0);
1362         self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1363         f4=f2+f2
1364         res=None
1365         res=f4.getValueOn(pos,3.21);
1366         self.assertTrue(abs(8.05-res[0])<1.e-12);
1367         self.assertTrue(abs(28.05-res[1])<1.e-12);
1368         self.assertTrue(abs(48.05-res[2])<1.e-12);
1369         f4+=f2;
1370         res=None
1371         res=f4.getValueOn(pos,3.21);
1372         self.assertTrue(abs(12.075-res[0])<1.e-12);
1373         self.assertTrue(abs(42.075-res[1])<1.e-12);
1374         self.assertTrue(abs(72.075-res[2])<1.e-12);
1375         pass
1376
1377     def testMergeNodesOnField(self):
1378         targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
1379         f1=targetMesh.fillFromAnalytic(ON_NODES,1,"x+y+z");
1380         f1.mergeNodes(1e-10);
1381         #
1382         targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
1383         f1=targetMesh.fillFromAnalytic(ON_NODES,1,"x+y+z");
1384         tmp=f1.getArray()
1385         tmp.setIJ(0,0,1000.);
1386         f1.mergeNodes(1e-10);
1387         #
1388         targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
1389         f1=targetMesh.fillFromAnalytic(ON_NODES,1,"x+y+z");
1390         tmp=f1.getArray()
1391         tmp.setIJ(1,0,1000.);
1392         self.assertRaises(InterpKernelException,f1.mergeNodes,1.e-10)
1393         pass
1394
1395     def testCheckConsecutiveCellTypes(self):
1396         sourceMesh=MEDCouplingDataForTest.build2DSourceMesh_1();
1397         targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1398         self.assertTrue(sourceMesh.checkConsecutiveCellTypes());
1399         order1=[NORM_TRI3,NORM_QUAD4]
1400         order2=[NORM_QUAD4,NORM_TRI3]
1401         self.assertTrue(not targetMesh.checkConsecutiveCellTypes());
1402         self.assertTrue(not targetMesh.checkConsecutiveCellTypesAndOrder(order1));
1403         self.assertTrue(not targetMesh.checkConsecutiveCellTypesAndOrder(order2));
1404         da=targetMesh.getRenumArrForConsecutiveCellTypesSpec(order1);
1405         self.assertEqual(5,da.getNumberOfTuples());
1406         self.assertEqual(1,da.getNumberOfComponents());
1407         expected1=[2,0,1,3,4]
1408         self.assertTrue(expected1==list(da.getValues()));
1409         da=targetMesh.getRenumArrForConsecutiveCellTypesSpec(order2);
1410         self.assertEqual(5,da.getNumberOfTuples());
1411         self.assertEqual(1,da.getNumberOfComponents());
1412         expected2=[0,3,4,1,2]
1413         self.assertTrue(expected2==list(da.getValues()));
1414         renumber1=[4,0,1,2,3]
1415         targetMesh.renumberCells(renumber1,False);
1416         self.assertTrue(targetMesh.checkConsecutiveCellTypes());
1417         self.assertTrue(targetMesh.checkConsecutiveCellTypesAndOrder(order1));
1418         self.assertTrue(not targetMesh.checkConsecutiveCellTypesAndOrder(order2));
1419         pass
1420
1421     def testRearrange2ConsecutiveCellTypes(self):
1422         m1_1=MEDCouplingDataForTest.build2DSourceMesh_1();
1423         m2_1=MEDCouplingDataForTest.build2DTargetMesh_1();
1424         arr1=m1_1.rearrange2ConsecutiveCellTypes();
1425         m1_2=MEDCouplingDataForTest.build2DSourceMesh_1();
1426         self.assertTrue(m1_2.isEqual(m1_1,1e-12));
1427         expected1=[0,1]
1428         self.assertEqual(2,arr1.getNumberOfTuples());
1429         self.assertEqual(1,arr1.getNumberOfComponents());
1430         self.assertEqual(expected1,arr1.getValues());
1431         expected2=[0,3,4,1,2]
1432         arr1=m2_1.rearrange2ConsecutiveCellTypes();
1433         self.assertEqual(5,arr1.getNumberOfTuples());
1434         self.assertEqual(1,arr1.getNumberOfComponents());
1435         self.assertEqual(expected2,list(arr1.getValues()));
1436         m2_2=MEDCouplingDataForTest.build2DTargetMesh_1();
1437         self.assertEqual(5,arr1.getNumberOfTuples());
1438         self.assertEqual(1,arr1.getNumberOfComponents());
1439         self.assertEqual(expected2,list(arr1.getValues()));
1440         self.assertTrue(not m2_2.isEqual(m2_1,1e-12));
1441         m2_2.renumberCells(expected2,False);
1442         self.assertTrue(m2_2.isEqual(m2_1,1e-12));
1443         pass
1444
1445     def testSplitByType(self):
1446         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1447         v=m1.splitByType();
1448         self.assertEqual(3,len(v));
1449         m2=MEDCouplingUMesh.MergeUMeshesOnSameCoords(v);
1450         m2.setName(m1.getName());
1451         self.assertTrue(m1.isEqual(m2,1.e-12));
1452         pass
1453
1454     def testFuseUMeshesOnSameCoords(self):
1455         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
1456         cells1=[2,3,4]
1457         m3=m2.buildPartOfMySelf(cells1,True);
1458         self.assertTrue(isinstance(m3,MEDCouplingUMesh))
1459         cells2=[1,2,4]
1460         m4=m2.buildPartOfMySelf(cells2,True);
1461         self.assertTrue(isinstance(m4,MEDCouplingUMesh))
1462         cells3=[1,2]
1463         m5=m2.buildPartOfMySelf(cells3,True);
1464         self.assertTrue(isinstance(m5,MEDCouplingUMesh))
1465         meshes=[m3,m4,m5]
1466         #
1467         m7,corr=MEDCouplingUMesh.FuseUMeshesOnSameCoords(meshes,0);
1468         self.assertEqual(4,m7.getNumberOfCells());
1469         self.assertEqual(3,len(corr));
1470         expectedVals1=[3,3,2]
1471         expectedVals2=[[0,1,2],[3,0,2],[3,0]]
1472         for i in xrange(3):
1473             arr=corr[i];
1474             self.assertEqual(1,arr.getNumberOfComponents());
1475             nbOfVals=expectedVals1[i];
1476             self.assertEqual(nbOfVals,arr.getNumberOfTuples());
1477             vals=arr.getValues();
1478             self.assertEqual(expectedVals2[i],list(vals));
1479             pass
1480         arr2,fidsOfGroups=DataArrayInt.MakePartition(corr,m7.getNumberOfCells());
1481         fidExp=[5,1,3,4]
1482         fidsGrp=[[1,3,5],[3,4,5],[4,5]]
1483         self.assertEqual(3,len(fidsOfGroups));
1484         self.assertEqual(1,arr2.getNumberOfComponents());
1485         self.assertEqual(4,arr2.getNumberOfTuples());
1486         self.assertEqual(fidExp,list(arr2.getValues()));
1487         for i in xrange(3):
1488             nbOfVals=expectedVals1[i];
1489             self.assertEqual(list(fidsOfGroups[i]),fidsGrp[i]);
1490             pass
1491         pass
1492
1493     def testFuseUMeshesOnSameCoords2(self):
1494         m1,m2=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
1495         part1=[2,3,6,4,10]
1496         m3=m1.buildPartOfMySelf(part1,True);
1497         part2=[5,6,4,7]
1498         m4=m1.buildPartOfMySelf(part2,True);
1499         meshes=[m1,m3,m3,m4]
1500         m5,corr=MEDCouplingUMesh.FuseUMeshesOnSameCoords(meshes,0);
1501         self.assertEqual(18,m5.getNumberOfCells());
1502         exp2=[
1503             [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17],
1504             [2,3,6,4,10],
1505             [2,3,6,4,10],
1506             [5,6,4,7]]
1507         i=0;
1508         for it in corr:
1509             self.assertEqual(exp2[i],list(it.getValues()));
1510             i+=1
1511             pass
1512         pass
1513
1514     def testBuildOrthogonalField(self):
1515         targetMesh=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1516         field=targetMesh.buildOrthogonalField();
1517         expected=[0.70710678118654746,0.,-0.70710678118654746]
1518         self.assertEqual(5,field.getNumberOfTuples());
1519         self.assertEqual(3,field.getNumberOfComponents());
1520         vals=field.getArray().getValues();
1521         for i in xrange(15):
1522             self.assertTrue(abs(expected[i%3]-vals[i])<1e-12);
1523         # testing
1524         targetCoords=[0.,0.,0.,0.5,0.,0.5,1.,0.,1.,0.,1.,0.]
1525         targetConn=[0,1,2,3]
1526         targetMesh=MEDCouplingUMesh.New();
1527         targetMesh.setMeshDimension(2);
1528         targetMesh.allocateCells(1);
1529         targetMesh.insertNextCell(NORM_QUAD4,targetConn[0:4])
1530         targetMesh.finishInsertingCells();
1531         myCoords=DataArrayDouble.New();
1532         myCoords.setValues(targetCoords,4,3);
1533         targetMesh.setCoords(myCoords);
1534         field=targetMesh.buildOrthogonalField();
1535         self.assertEqual(1,field.getNumberOfTuples());
1536         self.assertEqual(3,field.getNumberOfComponents());
1537         vals=field.getArray().getValues();
1538         self.assertTrue(abs(-0.70710678118654746-vals[0])<1e-12);
1539         self.assertTrue(abs(0.-vals[1])<1e-12);
1540         self.assertTrue(abs(0.70710678118654746-vals[2])<1e-12);
1541         pass
1542
1543     def testGetCellsContainingPoint(self):
1544         targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1545         pos=[0.,0.,0.4,0.4,0.,0.4,0.1,0.1,0.25,0.,0.65,0.]
1546         #2D basic
1547         t1,t2=targetMesh.getCellsContainingPoints(pos,6,1e-12);
1548         self.assertEqual(6,t1.getNumberOfTuples());
1549         self.assertEqual(1,t1.getNumberOfComponents());
1550         self.assertEqual(7,t2.getNumberOfTuples());
1551         self.assertEqual(1,t2.getNumberOfComponents());
1552         expectedValues1=[0,4,3,0,1,2]
1553         expectedValues2=[0,1,2,3,4,5,6]
1554         self.assertEqual(list(t1.getValues()),expectedValues1);
1555         self.assertEqual(list(t2.getValues()),expectedValues2);
1556         #2D with no help of bounding box.
1557         center=[0.2,0.2]
1558         MEDCouplingPointSet.Rotate2DAlg(center,0.78539816339744830962,6,pos);
1559         targetMesh.rotate(center,0.78539816339744830962);
1560         t1=None
1561         t2=None
1562         t1,t2=targetMesh.getCellsContainingPoints(pos,1e-12);
1563         self.assertEqual(6,t1.getNumberOfTuples());
1564         self.assertEqual(7,t2.getNumberOfTuples());
1565         self.assertEqual(list(t1.getValues()),expectedValues1);
1566         self.assertEqual(list(t2.getValues()),expectedValues2);
1567         t1,t2=targetMesh.getCellsContainingPoints(DataArrayDouble.New(pos,6,2),1e-12);
1568         self.assertEqual(6,t1.getNumberOfTuples());
1569         self.assertEqual(7,t2.getNumberOfTuples());
1570         self.assertEqual(list(t1.getValues()),expectedValues1);
1571         self.assertEqual(list(t2.getValues()),expectedValues2);
1572         self.assertRaises(InterpKernelException,targetMesh.getCellsContainingPoints,DataArrayDouble.New(pos,4,3),1e-12);
1573         #2D outside
1574         pos1bis=[-0.3303300858899107,-0.11819805153394641]
1575         self.assertEqual(-1,targetMesh.getCellContainingPoint(pos1bis,1e-12));
1576         #test limits 2D
1577         targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1578         pos2=[0.2,-0.05]
1579         t1=None
1580         t1=targetMesh.getCellsContainingPoint(pos2,1e-12)
1581         self.assertEqual(2,len(t1));
1582         expectedValues3=[0,1]
1583         self.assertEqual(list(t1.getValues()),expectedValues3);
1584         pos3=[0.2,0.2]
1585         t1=None
1586         t1=targetMesh.getCellsContainingPoint(pos3,1e-12);
1587         self.assertEqual(5,len(t1));
1588         expectedValues4=[0,1,2,3,4]
1589         self.assertEqual(list(t1.getValues()),expectedValues4);
1590         self.assertEqual(0,targetMesh.getCellContainingPoint(pos3,1e-12));
1591         #3D
1592         targetMesh=MEDCouplingDataForTest.build3DTargetMesh_1();
1593         pos4=[25.,25.,25.]
1594         self.assertEqual(0,targetMesh.getCellContainingPoint(pos4,1e-12));
1595         pos5=[50.,50.,50.]
1596         t1=None
1597         t1=targetMesh.getCellsContainingPoint(pos5,1e-12);
1598         self.assertEqual(8,len(t1));
1599         expectedValues5=[0,1,2,3,4,5,6,7]
1600         self.assertEqual(list(t1.getValues()),expectedValues5);
1601         pos6=[0., 50., 0.]
1602         t1=None
1603         t1=targetMesh.getCellsContainingPoint(pos6,1e-12);
1604         self.assertEqual(2,len(t1));
1605         expectedValues6=[0,2]
1606         self.assertEqual(list(t1.getValues()),expectedValues6);
1607         #3D outside
1608         pos7=[-1.0,-1.0,0.]
1609         self.assertEqual(-1,targetMesh.getCellContainingPoint(pos7,1e-12));
1610         #3D outside 2
1611         center2=[0.,0.,0.]
1612         vec2=[0.,-1.,0.]
1613         targetMesh.rotate(center2,vec2,0.78539816339744830962);
1614         pos8=[-25.,25.,12.]
1615         self.assertEqual(-1,targetMesh.getCellContainingPoint(pos8,1e-12));
1616         pass
1617
1618     def testGetValueOn1(self):
1619         targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1620         fieldOnCells=MEDCouplingFieldDouble.New(ON_CELLS);
1621         nbOfCells=targetMesh.getNumberOfCells();
1622         fieldOnCells.setMesh(targetMesh);
1623         array=DataArrayDouble.New();
1624         tmp=2*nbOfCells*[None]
1625         for i in xrange(nbOfCells):
1626             tmp[2*i]=7.+float(i);
1627             tmp[2*i+1]=17.+float(i)
1628             pass
1629         array.setValues(tmp,nbOfCells,2);
1630         fieldOnCells.setArray(array);
1631         #
1632         pos1=[0.25,0.]
1633         res=fieldOnCells.getValueOn(pos1);
1634         self.assertEqual(2,len(res))
1635         self.assertTrue(abs(8.-res[0])<1e-12);
1636         self.assertTrue(abs(18.-res[1])<1e-12);
1637         #
1638         #
1639         targetMesh=MEDCouplingDataForTest.build2DSourceMesh_1();
1640         fieldOnNodes=MEDCouplingFieldDouble.New(ON_NODES);
1641         nbOfNodes=targetMesh.getNumberOfNodes();
1642         fieldOnNodes.setMesh(targetMesh);
1643         array=DataArrayDouble.New();
1644         tmp=2*nbOfNodes*[None]
1645         for i in xrange(nbOfNodes):
1646             tmp[2*i]=17.+float(i);
1647             tmp[2*i+1]=27.+float(i)
1648             pass
1649         array.setValues(tmp,nbOfNodes,2);
1650         fieldOnNodes.setArray(array);
1651         #
1652         pos2=[-0.13333333333333333,-0.13333333333333333]
1653         res=None
1654         res=fieldOnNodes.getValueOn(pos2);
1655         self.assertEqual(2,len(res))
1656         self.assertTrue(abs(17.5-res[0])<1e-12);
1657         self.assertTrue(abs(27.5-res[1])<1e-12);
1658         pos3=[0.033333333333333326,0.36666666666666664]
1659         res=None
1660         res=fieldOnNodes.getValueOn(pos3);
1661         self.assertEqual(2,len(res))
1662         self.assertTrue(abs(18.666666666666667-res[0])<1e-12);
1663         self.assertTrue(abs(28.666666666666667-res[1])<1e-12);
1664         pass
1665
1666     def testCMesh0(self):
1667         mesh=MEDCouplingCMesh.New();
1668         meshEmpty=mesh.clone(True);
1669         self.assertTrue(meshEmpty.isEqual(mesh, 1e-12));
1670
1671         coordsX=DataArrayDouble.New();
1672         arrX=[ -1., 1., 2., 4. ]
1673         coordsX.setValues(arrX, 4, 1);
1674         coordsY=DataArrayDouble.New();
1675         arrY=[ -2., 2., 4., 8. ]
1676         coordsY.setValues(arrY, 4, 1);
1677         coordsZ=DataArrayDouble.New();
1678         arrZ=[ -3., 3., 6., 12. ]
1679         coordsZ.setValues(arrZ, 4, 1);
1680         mesh.setCoords(coordsX, coordsY, coordsZ);
1681         #
1682         fieldOnNodes=mesh.fillFromAnalytic(ON_NODES, 1, "x+y/2.+z/3.");
1683         self.assertEqual(1, fieldOnNodes.getNumberOfComponents());
1684         self.assertEqual(64, fieldOnNodes.getNumberOfTuples());
1685         expected1=[-3., -1., 0., 2., -1., 1., 2., 4., 0., 2., 3., 5., 2., 4., 5., 7., -1., 1., 2.,
1686                     4., 1., 3., 4., 6., 2., 4., 5., 7., 4., 6., 7., 9., 0., 2., 3., 5., 2., 4., 5.,
1687                     7., 3., 5., 6., 8., 5., 7., 8., 10., 2., 4., 5.,
1688                     7., 4., 6., 7., 9., 5., 7., 8., 10., 7., 9., 10., 12.];
1689
1690         val=fieldOnNodes.getArray().getValues();
1691         for i in xrange(64):
1692           self.assertAlmostEqual(expected1[i], val[i], 12)
1693         res=fieldOnNodes.getValueOnPos(1, 3, 2);
1694         self.assertAlmostEqual(7., res[0], 12);
1695         #
1696         fieldOnCells=mesh.fillFromAnalytic(ON_CELLS, 1, "x+y/2.+z/3.");
1697         self.assertEqual(1, fieldOnCells.getNumberOfComponents());
1698         self.assertEqual(27, fieldOnCells.getNumberOfTuples());
1699         val=fieldOnCells.getArray().getValues();
1700         expected2=[0, 1.5, 3, 1.5, 3, 4.5, 3, 4.5, 6, 1.5, 3, 4.5, 3, 4.5,
1701                     6, 4.5, 6, 7.5, 3, 4.5, 6, 4.5, 6, 7.5, 6, 7.5, 9];
1702         for i in xrange(27):
1703           self.assertAlmostEqual(expected2[i], val[i], 12);
1704         #res=fieldOnCells.getValueOnPos(1,2,1);
1705         #self.assertAlmostEqual(6.,res,12);
1706         #
1707         meshDeepCopy=mesh.deepCpy();
1708         meshClone=mesh.clone(False);
1709
1710         meshEmpty.copyTinyStringsFrom(mesh);
1711         #no data in meshEmpty, expected False
1712         self.assertTrue(not meshEmpty.isEqual(mesh, 1e-12));
1713
1714         self.assertTrue(meshDeepCopy.isEqual(mesh, 1e-12));
1715         meshDeepCopy.copyTinyStringsFrom(mesh);
1716         self.assertTrue(meshDeepCopy.isEqual(mesh, 1e-12));
1717         self.assertTrue(meshClone.isEqual(mesh, 1e-12));
1718
1719         self.assertEqual(CARTESIAN, mesh.getType());
1720         self.assertEqual(CARTESIAN, meshEmpty.getType());
1721         self.assertEqual(CARTESIAN, meshDeepCopy.getType());
1722         self.assertEqual(CARTESIAN, meshClone.getType());
1723         pass
1724
1725     def testCMesh1(self):
1726         mesh1=MEDCouplingCMesh.New();
1727         coordsX1=DataArrayDouble.New();
1728         arrX1=[ -1., 1., 2., 4. ]
1729         coordsX1.setValues(arrX1, 4, 1);
1730         coordsY1=DataArrayDouble.New();
1731         arrY1=[ -2., 2., 4., 8. ]
1732         coordsY1.setValues(arrY1, 4, 1);
1733         coordsZ1=DataArrayDouble.New();
1734         arrZ1=[ -3., 3., 6., 12. ]
1735         coordsZ1.setValues(arrZ1, 4, 1);
1736         mesh1.setCoords(coordsX1, coordsY1, coordsZ1);
1737
1738         mesh2=MEDCouplingCMesh.New();
1739         coordsX2=DataArrayDouble.New();
1740         arrX2=[ -1., 1., 2., 4. ]
1741         coordsX2.setValues(arrX2, 4, 1);
1742         coordsY2=DataArrayDouble.New();
1743         arrY2=[ -2., 2., 4., 8. ]
1744         coordsY2.setValues(arrY2, 4, 1);
1745         coordsZ2=DataArrayDouble.New();
1746         arrZ2=[ -3., 3., 6., 12.+1e-6 ]
1747         coordsZ2.setValues(arrZ2, 4, 1);
1748         mesh2.setCoords(coordsX2, coordsY2, coordsZ2);
1749
1750         mesh3=MEDCouplingCMesh.New();
1751         coordsX3=DataArrayDouble.New();
1752         arrX3=[-1.]
1753         coordsX3.setValues(arrX3, 1, 1);
1754         coordsY3=DataArrayDouble.New();
1755         arrY3=[-2.]
1756         coordsY3.setValues(arrY3, 1, 1);
1757         coordsZ3=DataArrayDouble.New();
1758         arrZ3=[-3.]
1759         coordsZ3.setValues(arrZ3, 1, 1);
1760         mesh3.setCoords(coordsX3, coordsY3, coordsZ3);
1761
1762         self.assertEqual(3, mesh1.getSpaceDimension());
1763         self.assertEqual(3, mesh1.getMeshDimension());
1764
1765         self.assertTrue(not mesh1.isEqual(mesh2, 1e-12));
1766         self.assertTrue(not mesh2.isEqual(mesh1, 1e-12));
1767         self.assertTrue(not mesh2.isEqualWithoutConsideringStr(mesh1, 1e-12));
1768         self.assertTrue(mesh1.isEqual(mesh2, 1e-5));
1769         self.assertTrue(not mesh1.isEqual(mesh2, 1e-7));
1770
1771         self.assertRaises(InterpKernelException, mesh3.checkCoherency1, 1e-12);
1772         mesh1.checkCoherency2(1e-12);
1773         self.assertEqual(NORM_HEXA8, mesh1.getTypeOfCell(1));
1774
1775         self.assertEqual(NORM_HEXA8, mesh1.getAllGeoTypes()[0]);
1776         self.assertEqual(27, mesh1.getNumberOfCellsWithType(NORM_HEXA8));
1777         self.assertRaises(InterpKernelException, mesh1.getNumberOfCellsWithType, NORM_QUAD4);
1778
1779         coo=mesh1.getCoordinatesOfNode(0);
1780         self.assertEqual(3, len(coo));
1781         self.assertAlmostEqual(-1., coo[0], 14);
1782         self.assertAlmostEqual(-2., coo[1], 14);
1783         self.assertAlmostEqual(-3., coo[2], 14);
1784         coo=mesh1.getCoordinatesOfNode(63);
1785         self.assertEqual(3, len(coo));
1786         self.assertAlmostEqual(4., coo[0], 14);
1787         self.assertAlmostEqual(8., coo[1], 14);
1788         self.assertAlmostEqual(12., coo[2], 14);
1789
1790         a=str(mesh1)
1791         repr=mesh1.simpleRepr();
1792         repr=mesh1.advancedRepr();
1793         self.assertTrue("Cartesian" in repr);
1794         self.assertTrue("Number of components : 1" in repr);
1795         self.assertTrue("Number of tuples : 4" in repr);
1796         self.assertTrue("Z Array :" in repr);
1797         pass
1798
1799     def testCMesh2(self):
1800         mesh1=MEDCouplingCMesh.New();
1801         coordsX1=DataArrayDouble.New();
1802         arrX1=[ -1., 1., 2., 4. ]
1803         coordsX1.setValues(arrX1, 4, 1);
1804         coordsY1=DataArrayDouble.New();
1805         arrY1=[ -2., 2., 4., 8. ]
1806         coordsY1.setValues(arrY1, 4, 1);
1807         coordsZ1=DataArrayDouble.New();
1808         arrZ1=[ -3., 3., 6., 12. ]
1809         coordsZ1.setValues(arrZ1, 4, 1);
1810         mesh1.setCoords(coordsX1, coordsY1, coordsZ1);
1811
1812         dis=mesh1.getDistributionOfTypes();
1813         self.assertEqual(1, len(dis));
1814         self.assertEqual(NORM_HEXA8, dis[0][0]);
1815         self.assertEqual(27, dis[0][1]);
1816         self.assertEqual(0, dis[0][2]);
1817
1818         idsPerType=[]
1819         self.assertRaises(InterpKernelException, mesh1.checkTypeConsistencyAndContig, dis, idsPerType);
1820         dis[0][2]=-1;
1821         idsPerType=[]
1822         self.assertTrue(not mesh1.checkTypeConsistencyAndContig(dis, idsPerType));
1823         dis[0][0]=NORM_QUAD4;
1824         self.assertRaises(InterpKernelException, mesh1.checkTypeConsistencyAndContig, dis, idsPerType);
1825         dis[0][0]=NORM_HEXA8;
1826         dis[0][2]=0;
1827         ids=DataArrayInt.New();
1828         ids.alloc(10, 1);
1829         ids.fillWithValue(111);
1830         idsPerType=[ids];
1831         check=mesh1.checkTypeConsistencyAndContig(dis, idsPerType);
1832         self.assertTrue(check);
1833         self.assertTrue(check.isEqual(ids));
1834
1835         code, idsInPflPerType, pfls=mesh1.splitProfilePerType(ids);
1836         self.assertEqual(3, len(code));
1837         self.assertEqual(NORM_HEXA8, code[0]);
1838         self.assertEqual(27, code[1]);
1839         self.assertEqual(0, code[2]);
1840         self.assertEqual(1, len(idsInPflPerType));
1841         self.assertEqual(1, len(pfls));
1842         self.assertTrue(idsInPflPerType[0].isEqual(ids));
1843         self.assertTrue(pfls[0].isEqual(ids));
1844
1845         cells1=[0, 1, 25, 26]
1846         partMesh1=mesh1.buildPart(cells1)
1847         self.assertTrue(isinstance(partMesh1,MEDCouplingMesh))
1848         self.assertEqual(4, partMesh1.getNumberOfCellsWithType(NORM_HEXA8));
1849         self.assertEqual(64, mesh1.getNumberOfNodes());
1850         self.assertEqual(64, partMesh1.getNumberOfNodes());
1851
1852         cells2=[25, 26]
1853         partMesh2, arr1=mesh1.buildPartAndReduceNodes(cells2)
1854         self.assertTrue(isinstance(partMesh2,MEDCouplingUMesh))
1855         self.assertEqual(2,partMesh2.getNumberOfCellsWithType(NORM_HEXA8));
1856         self.assertEqual(12,partMesh2.getNumberOfNodes());
1857
1858         cells3=[2, 3]
1859         partMesh3, arr2=partMesh1.buildPartAndReduceNodes(cells3)
1860         self.assertTrue(isinstance(partMesh3,MEDCouplingUMesh))
1861         self.assertEqual(2, partMesh3.getNumberOfCellsWithType(NORM_HEXA8));
1862         self.assertEqual(12, partMesh3.getNumberOfNodes());
1863
1864         self.assertRaises(InterpKernelException, mesh1.simplexize, 0);
1865         self.assertRaises(InterpKernelException, mesh1.getMeasureFieldOnNode, True);
1866
1867         #double bbox1[6];
1868         #double bbox2[6];
1869         bbox1=mesh1.getBoundingBox(); #[(-1.0, 4.0), (-2.0, 8.0), (-3.0, 12.0)]
1870         bbox2=partMesh1.getBoundingBox();
1871         self.assertTrue(bbox1==bbox2);
1872         bbox1=partMesh3.getBoundingBox();
1873         bbox2=partMesh2.getBoundingBox();
1874         self.assertTrue(bbox1==bbox2);
1875
1876         self.assertRaises(InterpKernelException, mesh1.buildOrthogonalField);
1877         mesh2d=MEDCouplingCMesh.New();
1878         mesh2d.setCoords(coordsX1, coordsY1);
1879         f1=mesh2d.buildOrthogonalField();
1880
1881         pass
1882
1883     def testScale(self):
1884         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1885         pos=[0.2,0.2]
1886         mesh.scale(pos,0.5);
1887         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,
1888                    -0.05,0.45, 0.2,0.45, 0.45,0.45]
1889         val=mesh.getCoords().getValues();
1890         self.assertEqual(18,len(val))
1891         for i in xrange(18):
1892             self.assertTrue(abs(expected1[i]-val[i])<1e-12);
1893             pass
1894         pass
1895
1896     def testTryToShareSameCoords(self):
1897         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
1898         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
1899         self.assertTrue(m1.getCoords().getHiddenCppPointer()!=m2.getCoords().getHiddenCppPointer());
1900         m1.tryToShareSameCoords(m2,1e-12);
1901         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1902         m1.tryToShareSameCoords(m2,1e-12);
1903         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1904         m2.tryToShareSameCoords(m1,1e-12);
1905         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1906         #
1907         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
1908         m2=MEDCouplingDataForTest.build2DTargetMesh_2();
1909         self.assertTrue(m1.getCoords().getHiddenCppPointer()!=m2.getCoords().getHiddenCppPointer());
1910         m1.tryToShareSameCoords(m2,1e-12);
1911         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1912         m1.tryToShareSameCoords(m2,1e-12);
1913         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1914         m2.tryToShareSameCoords(m1,1e-12);
1915         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1916         #
1917         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
1918         m2=MEDCouplingDataForTest.build2DSourceMesh_1();
1919         self.assertTrue(m1.getCoords().getHiddenCppPointer()!=m2.getCoords().getHiddenCppPointer());
1920         self.assertRaises(InterpKernelException,m1.tryToShareSameCoords,m2,1e-12)
1921         pass
1922
1923     def testFindNodeOnPlane(self):
1924         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
1925         pt=[300.,300.,0.]
1926         v=[0.,0.,2.]
1927         n=mesh.findNodesOnPlane(pt,v,1e-12);
1928         self.assertEqual(9,len(n));
1929         m3dSurf=mesh.buildFacePartOfMySelfNode(n,True);
1930         self.assertTrue(isinstance(m3dSurf,MEDCouplingUMesh))
1931         me=MEDCouplingExtrudedMesh.New(mesh,m3dSurf,0);
1932         da=me.getMesh3DIds();
1933         self.assertEqual(8,me.getNumberOfCells());
1934         expected=[0,1,2,3,4,5,6,7]
1935         val=da.getValues();
1936         self.assertEqual(expected,list(val));
1937         #
1938         m3dSurf=mesh.buildFacePartOfMySelfNode(n,True);
1939         self.assertTrue(isinstance(m3dSurf,MEDCouplingUMesh))
1940         me=MEDCouplingExtrudedMesh.New(mesh,m3dSurf,0);
1941         da=me.getMesh3DIds();
1942         self.assertEqual(8,me.getNumberOfCells());
1943         expected=[0,1,2,3,4,5,6,7]
1944         val=da.getValues();
1945         self.assertEqual(expected,list(val));
1946         pass
1947
1948     def testRenumberCells(self):
1949         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1950         m2=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1951         self.assertTrue(m.isEqual(m2,0));
1952         arr=[12,3,25,2,26]
1953         m.renumberCells(arr,True);
1954         self.assertTrue(not m.isEqual(m2,0));
1955         self.assertEqual(NORM_QUAD4,m.getTypeOfCell(0));
1956         self.assertEqual(NORM_TRI3,m.getTypeOfCell(1));
1957         self.assertEqual(NORM_QUAD4,m.getTypeOfCell(2));
1958         self.assertEqual(NORM_TRI3,m.getTypeOfCell(3));
1959         self.assertEqual(NORM_QUAD4,m.getTypeOfCell(4));
1960         arr2=[5,-1,-5,4,8]
1961         m.renumberCells(arr2,True);
1962         self.assertTrue(m.isEqual(m2,0));
1963         pass
1964
1965     def testChangeSpaceDimension(self):
1966         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1967         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
1968         #
1969         self.assertEqual(3,m1.getSpaceDimension());
1970         m1.changeSpaceDimension(2);
1971         self.assertEqual(2,m1.getSpaceDimension());
1972         m1.setName(m2.getName());
1973         self.assertTrue(m1.isEqual(m2,1e-12));
1974         m1.changeSpaceDimension(3);
1975         self.assertEqual(3,m1.getSpaceDimension());
1976         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.]
1977         val=m1.getCoords().getValues();
1978         for i in xrange(27):
1979             self.assertTrue(abs(expected[i]-val[i])<1e-14);
1980             pass
1981         pass
1982
1983     def testGaussPointField1(self):
1984         _a=0.446948490915965;
1985         _b=0.091576213509771;
1986         _p1=0.11169079483905;
1987         _p2=0.0549758718227661;
1988         refCoo1=[ 0.,0., 1.,0., 0.,1. ]
1989         gsCoo1=[ 2*_b-1, 1-4*_b, 2*_b-1, 2.07*_b-1, 1-4*_b,
1990                  2*_b-1, 1-4*_a, 2*_a-1, 2*_a-1, 1-4*_a, 2*_a-1, 2*_a-1 ]
1991         wg1=[ 4*_p2, 4*_p2, 4*_p2, 4*_p1, 4*_p1, 4*_p1 ]
1992         _refCoo1=refCoo1
1993         _gsCoo1=gsCoo1
1994         _wg1=wg1
1995         #
1996         m=MEDCouplingDataForTest.build2DTargetMesh_1();
1997         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,NO_TIME);
1998         f.setMesh(m);
1999         self.assertEqual(5,f.getNumberOfMeshPlacesExpected());
2000         self.assertEqual(0,f.getNbOfGaussLocalization());
2001         f.setGaussLocalizationOnType(NORM_TRI3,_refCoo1,_gsCoo1,_wg1);
2002         f.setGaussLocalizationOnType(NORM_TRI3,_refCoo1,_gsCoo1,_wg1); # not a bug only to check that it works well
2003         self.assertRaises(InterpKernelException,f.setGaussLocalizationOnType,NORM_QUAD4,_refCoo1,_gsCoo1,_wg1)
2004         self.assertEqual(1,f.getNbOfGaussLocalization());
2005         refCoo2=[ 0.,0., 1.,0., 1.,1., 0.,1. ]
2006         _refCoo2=refCoo2
2007         _gsCoo1=_gsCoo1[0:4]
2008         _wg1=_wg1[0:2]
2009         f.setGaussLocalizationOnType(NORM_QUAD4,_refCoo2,_gsCoo1,_wg1);
2010         self.assertEqual(2,f.getNbOfGaussLocalization());
2011         array=DataArrayDouble.New();
2012         ptr=18*2*[None]
2013         for i in xrange(18*2):
2014             ptr[i]=float(i+1)
2015         array.setValues(ptr,18,2);
2016         ptr=array.getPointer();
2017         f.setArray(array);
2018         f.setName("MyFirstFieldOnGaussPoint");
2019         f.checkCoherency();
2020         self.assertAlmostEqual(27.,f.getIJK(2,5,0),14);
2021         self.assertAlmostEqual(16.,f.getIJK(1,5,1),14);
2022         #
2023         f.clearGaussLocalizations();
2024         self.assertEqual(0,f.getNbOfGaussLocalization());
2025         self.assertRaises(InterpKernelException,f.checkCoherency);
2026         ids1=[0,1,3,4]
2027         self.assertRaises(InterpKernelException,f.setGaussLocalizationOnCells,ids1,_refCoo2,_gsCoo1,_wg1);
2028         self.assertEqual(0,f.getNbOfGaussLocalization());
2029         ids2=[0,4]
2030         f.setGaussLocalizationOnCells(ids2,_refCoo2,_gsCoo1,_wg1);
2031         self.assertEqual(1,f.getNbOfGaussLocalization());
2032         self.assertEqual(0,f.getGaussLocalizationIdOfOneCell(0));
2033         self.assertRaises(InterpKernelException,f.getGaussLocalizationIdOfOneCell,1);
2034         ids3=[1,2]
2035         f.setGaussLocalizationOnCells(ids3,_refCoo1,_gsCoo1,_wg1);
2036         self.assertEqual(2,f.getNbOfGaussLocalization());
2037         self.assertEqual(0,f.getGaussLocalizationIdOfOneCell(0));
2038         self.assertEqual(1,f.getGaussLocalizationIdOfOneCell(1));
2039         self.assertEqual(1,f.getGaussLocalizationIdOfOneCell(2));
2040         self.assertRaises(InterpKernelException,f.checkCoherency);#<- cell 3 has no localization
2041         ids4=[3]
2042         _gsCoo2=_gsCoo1;
2043         _wg2=_wg1;
2044         _gsCoo2[0]=0.8888777776666;
2045         _wg2[0]=0.1234567892377;
2046         f.setGaussLocalizationOnCells(ids4,_refCoo2,_gsCoo2,_wg2);
2047         self.assertEqual(3,f.getNbOfGaussLocalization());
2048         tmpIds=f.getCellIdsHavingGaussLocalization(0);
2049         self.assertEqual(ids2,list(tmpIds.getValues()));
2050         self.assertRaises(InterpKernelException,f.checkCoherency);#<- it's always not ok because undelying array not with the good size.
2051         array2=f.getArray().substr(0,10);
2052         f.setArray(array2);
2053         f.checkCoherency();#<- here it is OK
2054         f2=f.clone(True);
2055         self.assertTrue(f.isEqual(f2,1e-14,1e-14));
2056         gl1=f2.getGaussLocalization(0);
2057         tmp=gl1.getGaussCoord(1,1);
2058         self.assertAlmostEqual(2.07*_b-1,tmp,14);
2059         gl1.setGaussCoord(1,1,0.07);
2060         self.assertTrue(not f.isEqual(f2,1e-14,1e-14));
2061         gl1.setGaussCoord(1,1,tmp);
2062         self.assertTrue(f.isEqual(f2,1e-14,1e-14));
2063         f2.checkCoherency();
2064         pass
2065
2066     def testGaussPointNEField1(self):
2067         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2068         f=MEDCouplingFieldDouble.New(ON_GAUSS_NE,NO_TIME);
2069         f.setMesh(m);
2070         self.assertEqual(5,f.getNumberOfMeshPlacesExpected());
2071         f.setName("MyFirstFieldOnNE");
2072         f.setDescription("MyDescriptionNE");
2073         array=DataArrayDouble.New();
2074         tmp=18*2*[None]
2075         for i in xrange(18*2):
2076             tmp[i]=float(i+7)
2077             pass
2078         array.setValues(tmp,18,2);
2079         ptr=array.getPointer();
2080         f.setArray(array);
2081         #
2082         f.checkCoherency();
2083         f2=f.clone(True);
2084         self.assertTrue(f.isEqual(f2,1e-14,1e-14));
2085         self.assertAlmostEqual(21.,f.getIJK(2,0,0),14);
2086         self.assertAlmostEqual(18.,f.getIJK(1,1,1),14);
2087         pass
2088
2089     def testCellOrientation1(self):
2090         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2091         vec=[0.,0.,-1.]
2092         self.assertRaises(InterpKernelException,m.are2DCellsNotCorrectlyOriented,vec,False);
2093         m.changeSpaceDimension(3);
2094         res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2095         self.assertTrue(len(res1)==0);
2096         vec[2]=1.;
2097         res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2098         self.assertEqual(5,len(res1));
2099         #
2100         vec[2]=-1.;
2101         # connectivity inversion
2102         conn=m.getNodalConnectivity().getValues();
2103         tmp=conn[11];
2104         conn[11]=conn[12];
2105         conn[12]=tmp;
2106         m.getNodalConnectivity().setValues(conn,len(conn),1)
2107         res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2108         self.assertEqual(1,len(res1));
2109         self.assertEqual(2,res1.getValues()[0]);
2110         m.orientCorrectly2DCells(vec,False);
2111         res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2112         self.assertTrue(len(res1)==0);
2113         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
2114         m2.changeSpaceDimension(3);
2115         self.assertTrue(m.isEqual(m2,1e-12));
2116         pass
2117
2118     def testCellOrientation2(self):
2119         m2,m1=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
2120         res1=m2.arePolyhedronsNotCorrectlyOriented();
2121         self.assertEqual(6,len(res1));
2122         m2.orientCorrectlyPolyhedrons();
2123         res1=m2.arePolyhedronsNotCorrectlyOriented();
2124         self.assertTrue(len(res1)==0);
2125         m2.checkCoherency();
2126         self.assertEqual(18,m2.getNumberOfCells());
2127         cellIds2=[0,6,12]
2128         m2.convertToPolyTypes(cellIds2);
2129         m2.orientCorrectlyPolyhedrons();
2130         res1=m2.arePolyhedronsNotCorrectlyOriented();
2131         self.assertTrue(len(res1)==0);
2132         f2=m2.getMeasureField(False);
2133         f2Ptr=f2.getArray().getValues();
2134         #Test to check global reverse in MEDCouplingUMesh::tryToCorrectPolyhedronOrientation
2135         m3=MEDCouplingDataForTest.build2DTargetMesh_1();
2136         vec=[0.,0.,1.]
2137         m3.changeSpaceDimension(3);
2138         ids2=[0,1,2,3,4]
2139         m3.convertToPolyTypes(ids2);
2140         m3.orientCorrectly2DCells(vec,False);
2141         m4=MEDCouplingDataForTest.buildCU1DMesh_U();
2142         m4.changeSpaceDimension(3);
2143         center=[0.,0.,0.]
2144         vector=[0.,1.,0.]
2145         m4.rotate(center,vector,-pi/2.);
2146         m5=m3.buildExtrudedMesh(m4,0);
2147         res1=m5.arePolyhedronsNotCorrectlyOriented();
2148         self.assertEqual(15,len(res1));
2149         m5.orientCorrectlyPolyhedrons();
2150         res1=m5.arePolyhedronsNotCorrectlyOriented();
2151         self.assertTrue(len(res1)==0);
2152         f3=m5.getMeasureField(False);
2153         self.assertEqual(15,f3.getArray().getNumberOfTuples());
2154         self.assertEqual(1,f3.getNumberOfComponents());
2155         f3Ptr=f3.getArray().getValues();
2156         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];
2157         for i in xrange(15):
2158             self.assertTrue(abs(expected1[i]-f3Ptr[i])<1e-12);
2159             pass
2160         f4=m5.getBarycenterAndOwner();
2161         self.assertEqual(15,f4.getNumberOfTuples());
2162         self.assertEqual(3,f4.getNumberOfComponents());
2163         f4Ptr=f4.getValues();
2164         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];
2165         for i in xrange(45):
2166             self.assertTrue(abs(expected2[i]-f4Ptr[i])<1e-12);
2167             pass
2168         pass
2169
2170     def testPolyhedronBarycenter(self):
2171         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];
2172         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];
2173         meshN=MEDCouplingUMesh.New();
2174         meshN.setName("ForBary");
2175         meshN.setMeshDimension(3);
2176         meshN.allocateCells(4);
2177         meshN.insertNextCell(NORM_POLYHED,29,connN[0:29])
2178         meshN.finishInsertingCells();
2179         myCoords=DataArrayDouble.New();
2180         myCoords.setValues(coords,9,3);
2181         meshN.setCoords(myCoords);
2182         meshN.checkCoherency();
2183         #
2184         res1=meshN.arePolyhedronsNotCorrectlyOriented();
2185         meshN.orientCorrectlyPolyhedrons();
2186         self.assertTrue(len(res1)==0);
2187         da=meshN.getBarycenterAndOwner();
2188         self.assertEqual(1,da.getNumberOfTuples());
2189         self.assertEqual(3,da.getNumberOfComponents());
2190         daPtr=da.getValues();
2191         ref=meshN.getCoords().getValues()[24:];
2192         for i in xrange(3):
2193             self.assertTrue(abs(ref[i]-daPtr[i])<1e-12);
2194             pass
2195         #
2196         center=[0.,0.,0.]
2197         vec=[0.,2.78,0.]
2198         da=meshN.getBarycenterAndOwner();
2199         daPtr=da.getValues();
2200         ref=meshN.getCoords().getValues()[24:];
2201         for i in xrange(3):
2202             self.assertTrue(abs(ref[i]-daPtr[i])<1e-12);
2203             pass
2204         #
2205         meshN.rotate(center,vec,pi/7.);
2206         meshN.translate(vec);
2207         da=meshN.getBarycenterAndOwner();
2208         daPtr=da.getValues();
2209         ref=meshN.getCoords().getValues()[24:];
2210         for i in xrange(3):
2211             self.assertTrue(abs(ref[i]-daPtr[i])<1e-12);
2212             pass
2213         #
2214         center2=[1.12,3.45,6.78]
2215         vec2=[4.5,9.3,2.8]
2216         meshN.rotate(center2,vec2,e);
2217         meshN.translate(vec2);
2218         da=meshN.getBarycenterAndOwner();
2219         daPtr=da.getValues();
2220         ref=meshN.getCoords().getValues()[24:];
2221         for i in xrange(3):
2222             self.assertTrue(abs(ref[i]-daPtr[i])<1e-10);
2223             pass
2224         pass
2225
2226     def testNormL12Integ1D(self):
2227         m1=MEDCouplingDataForTest.build1DTargetMesh_3();
2228         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2229         f1.setMesh(m1);
2230         array=DataArrayDouble.New();
2231         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]
2232         array.setValues(arr,m1.getNumberOfCells(),3);
2233         f1.setArray(array);
2234         #
2235         f3=m1.getBarycenterAndOwner();
2236         self.assertEqual(4,f3.getNumberOfTuples());
2237         self.assertEqual(1,f3.getNumberOfComponents());
2238         expected9=[0.75,5.105,0.8,5.155]
2239         ptr=f3.getValues();
2240         for i in xrange(4):
2241             self.assertTrue(abs(expected9[i]-ptr[i])<1e-12);
2242             pass
2243         #
2244         f2=m1.getMeasureField(False);
2245         self.assertEqual(4,f2.getArray().getNumberOfTuples());
2246         self.assertEqual(1,f2.getNumberOfComponents());
2247         expected1=[0.5,0.21,-0.6,-0.31]
2248         ptr=f2.getArray().getValues();
2249         for i in xrange(4):
2250             self.assertTrue(abs(expected1[i]-ptr[i])<1e-12);
2251             pass
2252         expected2=[0.5,0.21,0.6,0.31]
2253         f2=m1.getMeasureField(True);
2254         ptr=f2.getArray().getValues();
2255         for i in xrange(4):
2256             self.assertTrue(abs(expected2[i]-ptr[i])<1e-12);
2257             pass
2258         #integral
2259         self.assertTrue(4,f1.getNumberOfTuples())
2260         res=f1.integral(False);
2261         self.assertTrue(3,len(res))
2262         expected3=[0.9866,-0.3615,0.4217]
2263         for i in xrange(3):
2264             self.assertTrue(abs(expected3[i]-res[i])<1e-12);
2265             pass
2266         self.assertTrue(abs(expected3[0]-f1.integral(0,False))<1e-12);
2267         self.assertTrue(abs(expected3[1]-f1.integral(1,False))<1e-12);
2268         self.assertTrue(abs(expected3[2]-f1.integral(2,False))<1e-12);
2269         res=f1.integral(True);
2270         expected4=[-3.4152,8.7639,-14.6879]
2271         for i in xrange(3):
2272             self.assertTrue(abs(expected4[i]-res[i])<1e-12);
2273             pass
2274         #normL1
2275         res=f1.normL1();
2276         self.assertTrue(3,len(res))
2277         expected5=[6.979506172839505, 16.89018518518518, 27.02969135802469]
2278         for i in xrange(3):
2279             self.assertTrue(abs(expected5[i]-res[i])<1e-12);
2280             pass
2281         self.assertTrue(abs(expected5[0]-f1.normL1(0))<1e-12);
2282         self.assertTrue(abs(expected5[1]-f1.normL1(1))<1e-12);
2283         self.assertTrue(abs(expected5[2]-f1.normL1(2))<1e-12);
2284         #normL2
2285         res=f1.normL2();
2286         self.assertTrue(3,len(res))
2287         expected7=[7.090910979452395, 16.9275542960123, 27.053271464160858]
2288         for i in xrange(3):
2289             self.assertTrue(abs(expected7[i]-res[i])<1e-9);
2290             pass
2291         self.assertTrue(abs(expected7[0]-f1.normL2(0))<1e-9);
2292         self.assertTrue(abs(expected7[1]-f1.normL2(1))<1e-9);
2293         self.assertTrue(abs(expected7[2]-f1.normL2(2))<1e-9);
2294         #buildMeasureField
2295         f4=f1.buildMeasureField(False);
2296         self.assertTrue(abs(-0.2-f4.accumulate(0))<1e-12);
2297         f4=f1.buildMeasureField(True);
2298         self.assertTrue(abs(1.62-f4.accumulate(0))<1e-12);
2299         # Testing with 2D Curve
2300         m1=MEDCouplingDataForTest.build2DCurveTargetMesh_3();
2301         f2=m1.getMeasureField(False);
2302         self.assertEqual(4,f2.getArray().getNumberOfTuples());
2303         self.assertEqual(1,f2.getNumberOfComponents());
2304         ptr=f2.getArray().getValues();
2305         for i in xrange(4):
2306             self.assertTrue(abs(sqrt(2.)*expected2[i]-ptr[i])<1e-12);
2307             pass
2308         f2=m1.getMeasureField(True);
2309         self.assertEqual(4,f2.getArray().getNumberOfTuples());
2310         self.assertEqual(1,f2.getNumberOfComponents());
2311         ptr=f2.getArray().getValues();
2312         for i in xrange(4):
2313             self.assertTrue(abs(expected2[i]*sqrt(2.)-ptr[i])<1e-12);
2314             pass
2315         #bary
2316         f3=m1.getBarycenterAndOwner();
2317         self.assertEqual(4,f3.getNumberOfTuples());
2318         self.assertEqual(2,f3.getNumberOfComponents());
2319         expected10=[0.75,0.75,5.105,5.105,0.8,0.8,5.155,5.155]
2320         ptr=f3.getValues();
2321         for i in xrange(8):
2322             self.assertTrue(abs(expected10[i]-ptr[i])<1e-12);
2323             pass
2324         #
2325         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2326         f1.setMesh(m1);
2327         array=DataArrayDouble.New();
2328         array.setValues(arr,m1.getNumberOfCells(),3);
2329         f1.setArray(array);
2330         res=f1.integral(False);
2331         for i in xrange(3):
2332             self.assertTrue(abs(sqrt(2.)*expected4[i]-res[i])<1e-12);
2333             pass
2334         res=f1.integral(True);
2335         for i in xrange(3):
2336             self.assertTrue(abs(sqrt(2.)*expected4[i]-res[i])<1e-12);
2337             pass
2338         res=f1.normL1();
2339         for i in xrange(3):
2340             self.assertTrue(abs(expected5[i]-res[i])<1e-12);
2341             pass
2342         res=f1.normL2();
2343         for i in xrange(3):
2344             self.assertTrue(abs(expected7[i]-res[i])<1e-12);
2345             pass
2346         pass
2347
2348     def testAreaBary2D(self):
2349         m1=MEDCouplingDataForTest.build2DTargetMesh_3();
2350         f1=m1.getMeasureField(False);
2351         self.assertEqual(10,f1.getArray().getNumberOfTuples());
2352         self.assertEqual(1,f1.getNumberOfComponents());
2353         expected1=[-0.5,-1,-1.5,-0.5,-1,  0.5,1,1.5,0.5,1]
2354         ptr=f1.getArray().getValues();
2355         for i in xrange(10):
2356             self.assertTrue(abs(expected1[i]-ptr[i])<1e-12);
2357             pass
2358         f1=m1.getMeasureField(True);
2359         ptr=f1.getArray().getValues();
2360         for i in xrange(10):
2361             self.assertTrue(abs(abs(expected1[i])-ptr[i])<1e-12);
2362             pass
2363         f2=m1.getBarycenterAndOwner();
2364         self.assertEqual(10,f2.getNumberOfTuples());
2365         self.assertEqual(2,f2.getNumberOfComponents());
2366         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]
2367         ptr=f2.getValues();
2368         for i in xrange(20):
2369             self.assertTrue(abs(expected2[i]-ptr[i])<1e-12);
2370             pass
2371         m1.changeSpaceDimension(3);
2372         f1=m1.getMeasureField(False);
2373         self.assertEqual(10,f1.getArray().getNumberOfTuples());
2374         self.assertEqual(1,f1.getNumberOfComponents());
2375         ptr=f1.getArray().getValues();
2376         for i in xrange(10):
2377             self.assertTrue(abs(abs(expected1[i])-ptr[i])<1e-12);
2378             pass
2379         f2=m1.getBarycenterAndOwner();
2380         self.assertEqual(10,f2.getNumberOfTuples());
2381         self.assertEqual(3,f2.getNumberOfComponents());
2382         ptr=f2.getValues();
2383         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.]
2384         for i in xrange(30):
2385             self.assertTrue(abs(expected3[i]-ptr[i])<1e-12);
2386             pass
2387         pass
2388
2389     def testAreaBary3D(self):
2390         coords=[ 0.241310763507 , 0.0504777305619 , 0.0682283524903 , 0.252501053866 , -0.0625176732937 , 0.137272639894 ,
2391                  0.152262663601 , 0.241816569527 , 0.133812556197 , 0.18047750211 , -0.0789949051358 , 0.339098173401 ,
2392                  0.151741971857 , 0.238885278571 , 0.137715037333 , 0.242532155481 , -0.0928169086456 , 0.0678043417367 ,
2393                  0.240941965335 , -0.015461491464 , 0.0617186345825 , 0.24127650112 , 0.0499427876717 , 0.0679634099148 ,
2394                  -0.145828917428 , 0.206291632565 , 0.0310071927543 , 0.0125651775307 , 0.266262085828 , 0.105228430543 ,
2395                  -0.0994066533286 , 0.233224271238 , 0.0572213839567 , -0.0951345338317 , 0.234819509426 , 0.0592126284538 ,
2396                  0.136580574205 , -0.205486212579 , 0.0572866072014 , 0.0637270784978 , -0.168886355238 , 0.446614057077 ,
2397                  0.041337157151 , -0.213402568198 , 0.372407095999 , 0.0411601970268 , -0.202387875756 , 0.411334979491 ,
2398                  -0.108355701857 , 0.193636239335 , 0.204886756738 , 0.00639779029829 , 0.155296981517 , 0.252585892979 ,
2399                  0.0262473111702 , -0.112919732543 , 0.424286639249 ,-0.224103052733 , -0.139430015438 , -0.0122352295701 ,
2400                 -0.0312760589481 , -0.274272003594 , 0.0323959636568 , -0.166663422532 , -0.217754445175 , 0.00392109070364 ,
2401                  -0.30586619777 , -0.0475168041091 , -0.0144585228182 , -0.280881480586 , 0.135571293538 , 0.00623923647986 ,
2402                  -0.25548538234 , 0.156819217766 , 0.0645277879769 , -0.131567009284 , 0.184133752309 , 0.206021802753 ,
2403                  -0.196204010965 , 0.151602971681 , 0.212974777736 , -0.183713879463 , 0.0802946639531 , 0.260115662599 ,
2404                  -0.244241178767 , -0.0738873389604 , 0.144590565817 , -0.155804057829 , -0.164892720025 , 0.210613950558 ,
2405                  -0.170950800428 , -0.215099334026 , 0.00610122860092 , -0.30552634869 , -0.0490020791904 , -0.0132786533145 ,
2406                  0.271831011884 , 0.15105657296 , 0.0230534827908 , 0.281919192283 , 0.0898544306288 , -0.0625201489143 ,
2407                  0.260240727276 , -0.0120688706637 , -0.0532316588626 , 0.244947737722 , 0.0197984684293 , 0.0309341209233 ,
2408                  0.23439631578 , 0.229825279875 , 0.0508520585381 , 0.160921316875 , 0.265078502128 , 0.121716560626 ,
2409                  -0.315088694175 , 0.0747700471918 , -0.245836615071 , -0.327728781776 , 0.0857114674649 , -0.239431905957 ,
2410                  -0.308385460634 , 0.145142997084 , -0.149886828433 , 0.0488236045164 , 0.309462801914 , 0.0849169148265 ,
2411                 -0.0244964803395 , 0.33145611751 , -0.0476415818061 , 0.0060567994229 , 0.32418412014 , 0.0367779543812 ,
2412                  -0.0950221448063 , 0.236675326003 , 0.0572594453983 , 0.248723023186 , 0.0886648784791 , -0.176629430538 ,
2413                  0.116796984 , 0.256596599567 , -0.292863523603 , 0.118024552914 , 0.229154257843 , -0.34233232501 ,
2414                  0.217507892549 , -0.0417822335742 , -0.176771782888 , -0.224429321304 , 0.0125595300114 , -0.362064725588 ,
2415                  0.0937301100955 , -0.0500824832657 , -0.299713548444 , -0.244162220397 , 0.0383853931293 , -0.389856984411 ,
2416                  -0.0281989366102 , 0.097392811563 , -0.458244577284 , -0.385010847162 , 0.10122766194 , -0.140052859922 ,
2417                  -0.377936358012 , 0.110875172128 , -0.176207095463 , 0.244483045556 , -0.0991073977045 , 0.0575134372934 ,
2418                 0.262605120167 , -0.100243191645 , -0.0495620806935 , 0.240306880972 , -0.136153701579 , -0.114745281696 ,
2419                  0.215763176129 , -0.0836766059189 , -0.183249640616 , 0.237870396603 , -0.132449578286 , -0.121598854639 ,
2420                  -0.0637683083097 , -0.27921020214 , -0.149112321992 , -0.0856211014977 , -0.2973233473 , -0.0446878139589 ,
2421                  0.104675342288 , -0.0625908305324 , -0.290346256534 , 0.0248264249186 , -0.247797708548 , -0.165830884019 ,
2422                  0.0719302438309 , -0.178468260473 , -0.211432157345 , 0.142871843159 , -0.208769948542 , 0.0454101128246 ,
2423                  0.167803379307 , -0.207851396623 , -0.088802726124 , 0.12868717152 , -0.230920439715 , 0.00760508389036 ,
2424                  -0.0372812069535 , -0.286740286332 , 0.00963701291166 ]
2425
2426         connN = [ #polyhedron 0
2427             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
2428             , 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
2429             , 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
2430             , 22 , 19 , 21 , 30 , 31 , -1 , 22 , 31 , 28 , 27 , 26 , 24 , 23 , -1 , 31 , 30 , 29 , 28,
2431             # polyhedron 1
2432             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
2433             , 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
2434             , 33 , 34 , 48 , 45 , -1 , 35 , 34 , 48 , 50 , 49 , 38 , -1 , 41 , 43 , 42 , 46 , 36 , 37 , -1 , 38 , 39 , 51 , 49 , -1
2435             , 39 , 40 , 42 , 46 , 47 , 52 , 51 , -1 , 45 , 47 , 52 , 50 , 48 , -1 , 52 , 51 , 49 , 50,
2436             # polyhedron 2
2437             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
2438             , 23 , 53 , 54 , 40 , 8 , -1 , 53 , 22 , 23 , -1 , 39 , 54 , 40,
2439             # polyhedron 3
2440             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
2441             , 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
2442             , 55 , 5 , 12 , 65 , -1 , 66 , 67 , 65 , 55 , 56 , 57 , -1 , 63 , 66 , 57 , 59 , 64 , -1 , 64 , 62 , 58 , 59 , -1
2443             , 60 , 63 , 66 , 67 , 68 , 61 , -1 , 61 , 68 , 20 , 21 , -1 , 67 , 68 , 20 , 12 , 65]
2444
2445         barys = [ -0.0165220465527 , -0.0190922868195 , 0.158882733414 ,
2446                   0.0287618656076 , 0.135874379934 , -0.14601588119 ,
2447                   -0.147128055553 , 0.0465995097041 , -0.049391174453 ,
2448                   -0.00142506732317 , -0.0996953090351 , -0.115159183132 ]
2449         meshN=MEDCouplingUMesh.New();
2450         meshN.setName("ForBary");
2451         meshN.setMeshDimension(3);
2452         meshN.allocateCells(4);
2453         meshN.insertNextCell(NORM_POLYHED,113,connN);
2454         meshN.insertNextCell(NORM_POLYHED,99,connN[113:]);
2455         meshN.insertNextCell(NORM_POLYHED,43,connN[212:]);
2456         meshN.insertNextCell(NORM_POLYHED,92,connN[255:]);
2457         meshN.finishInsertingCells();
2458         myCoords=DataArrayDouble.New();
2459         myCoords.setValues(coords,69,3);
2460         meshN.setCoords(myCoords);
2461         meshN.checkCoherency();
2462         res1=meshN.arePolyhedronsNotCorrectlyOriented();
2463         meshN.orientCorrectlyPolyhedrons();
2464         res1=meshN.arePolyhedronsNotCorrectlyOriented();
2465         self.assertTrue(len(res1)==0);
2466         #
2467         da=meshN.getBarycenterAndOwner();
2468         self.assertEqual(4,da.getNumberOfTuples());
2469         self.assertEqual(3,da.getNumberOfComponents());
2470         daPtr=da.getValues();
2471         for i in xrange(12):
2472             self.assertTrue(abs(barys[i]-daPtr[i])<1e-12);
2473             pass
2474         pass
2475
2476     def testRenumberCellsForFields(self):
2477         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2478         f=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2479         f.setMesh(m);
2480         arr=DataArrayDouble.New();
2481         nbOfCells=m.getNumberOfCells();
2482         values1=[7.,107.,10007.,8.,108.,10008.,9.,109.,10009.,10.,110.,10010.,11.,111.,10011.]
2483         arr.setValues(values1,nbOfCells,3);
2484         f.setArray(arr);
2485         renumber1=[3,1,0,4,2]
2486         loc=[-0.05,-0.05, 0.55,-0.25, 0.55,0.15, -0.05,0.45, 0.45,0.45]
2487         for j in xrange(5):
2488             res=f.getValueOn(loc[2*j:2*j+2]);
2489             for i in xrange(3):
2490                 self.assertTrue(abs(values1[i+3*j]-res[i])<1e-12);
2491                 pass
2492             pass
2493         f.renumberCells(renumber1,False);
2494         ptr=f.getArray().getValues();
2495         expected1=[9.,109.,10009.,8.,108.,10008.,11.,111.,10011.,7.,107.,10007.,10.,110.,10010.]
2496         for i in xrange(15):
2497             self.assertTrue(abs(expected1[i]-ptr[i])<1e-12);
2498             pass
2499         #check that fields remains the same geometrically
2500         for j in xrange(5):
2501             res=f.getValueOn(loc[2*j:2*(j+1)]);
2502             for i in xrange(3):
2503                 self.assertTrue(abs(values1[i+3*j]-res[i])<1e-12);
2504                 pass
2505             pass
2506         #On gauss
2507         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,NO_TIME);
2508         f.setMesh(m);
2509         _a=0.446948490915965;
2510         _b=0.091576213509771;
2511         _p1=0.11169079483905;
2512         _p2=0.0549758718227661;
2513         refCoo1=[ 0.,0., 1.,0., 0.,1. ]
2514         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 ];
2515         wg1=[ 4*_p2, 4*_p2, 4*_p2, 4*_p1, 4*_p1, 4*_p1 ]
2516         _refCoo1=refCoo1[0:6];
2517         _gsCoo1=gsCoo1[0:12];
2518         _wg1=wg1[0:6];
2519         f.setGaussLocalizationOnType(NORM_TRI3,_refCoo1,_gsCoo1,_wg1);
2520         refCoo2=[ 0.,0., 1.,0., 1.,1., 0.,1. ]
2521         _refCoo2=refCoo2[0:8];
2522         _gsCoo1=_gsCoo1[0:4]
2523         _wg1=_wg1[0:2]
2524         f.setGaussLocalizationOnType(NORM_QUAD4,_refCoo2,_gsCoo1,_wg1);
2525         arr=DataArrayDouble.New();
2526         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.]
2527         arr.setValues(values2,18,2);
2528         f.setArray(arr);
2529         f.checkCoherency();
2530         fCpy=f.clone(True);
2531         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2532         f.renumberCells(renumber1,False);
2533         self.assertTrue(not f.isEqual(fCpy,1e-12,1e-12));
2534         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.]
2535         ptr=f.getArray().getValues();
2536         for i in xrange(36):
2537             self.assertTrue(abs(expected2[i]-ptr[i])<1e-12);
2538             pass
2539         renumber2=[2,1,4,0,3]
2540         f.renumberCells(renumber2,False);
2541         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2542         #GaussNE
2543         f=MEDCouplingFieldDouble.New(ON_GAUSS_NE,NO_TIME);
2544         f.setMesh(m);
2545         arr=DataArrayDouble.New();
2546         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.]
2547         arr.setValues(values3,18,2);
2548         f.setArray(arr);
2549         f.checkCoherency();
2550         fCpy=f.clone(True);
2551         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2552         f.renumberCells(renumber1,False);
2553         self.assertTrue(not f.isEqual(fCpy,1e-12,1e-12));
2554         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.]
2555         ptr=f.getArray().getValues();
2556         for i in xrange(36):
2557             self.assertTrue(abs(expected3[i]-ptr[i])<1e-12);
2558             pass
2559         f.renumberCells(renumber2,False);#perform reverse operation of renumbering to check that the resulting field is equal.
2560         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2561         #
2562         pass
2563
2564     def testRenumberNodesForFields(self):
2565         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2566         f=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
2567         f.setMesh(m);
2568         self.assertEqual(9,f.getNumberOfMeshPlacesExpected());
2569         arr=DataArrayDouble.New();
2570         nbOfNodes=m.getNumberOfNodes();
2571         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.]
2572         arr.setValues(values1,nbOfNodes,3);
2573         f.setArray(arr);
2574         f.checkCoherency();
2575         renumber1=[0,4,1,3,5,2,6,7,8]
2576         loc=[0.5432,-0.2432, 0.5478,0.1528]
2577         expected1=[9.0272, 109.0272, 10009.0272, 11.4124,111.4124,10011.4124]
2578         for j in xrange(2):
2579             res=f.getValueOn(loc[2*j:2*j+2]);
2580             for i in xrange(3):
2581                 self.assertTrue(abs(expected1[i+3*j]-res[i])<1e-12);
2582                 pass
2583             pass
2584         fCpy=f.clone(True);
2585         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2586         f.renumberNodes(renumber1);
2587         self.assertTrue(not f.isEqual(fCpy,1e-12,1e-12));
2588         for j in xrange(2):
2589             res=f.getValueOn(loc[2*j:2*j+2]);
2590             for i in xrange(3):
2591                 self.assertTrue(abs(expected1[i+3*j]-res[i])<1e-12);
2592                 pass
2593             pass
2594         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.]
2595         for i in xrange(27):
2596             self.assertTrue(abs(expected2[i]-f.getArray().getValues()[i])<1e-12);
2597             pass
2598         renumber2=[0,2,5,3,1,4,6,7,8]
2599         f.renumberNodes(renumber2);
2600         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2601         pass
2602
2603     def testConvertQuadraticCellsToLinear(self):
2604         mesh=MEDCouplingDataForTest.build2DTargetMesh_3();
2605         mesh.checkCoherency();
2606         types=mesh.getAllTypes();
2607         types.sort()
2608         self.assertEqual(5,len(types));
2609         expected1=[NORM_POLYGON, NORM_TRI3, NORM_QUAD4, NORM_TRI6, NORM_QUAD8]
2610         expected1.sort()
2611         self.assertEqual(expected1,types);
2612         self.assertTrue(mesh.isPresenceOfQuadratic());
2613         self.assertEqual(62,mesh.getMeshLength());
2614         f1=mesh.getMeasureField(False);
2615         #
2616         mesh.convertQuadraticCellsToLinear();
2617         self.assertTrue(not mesh.isPresenceOfQuadratic());
2618         #
2619         mesh.checkCoherency();
2620         f2=mesh.getMeasureField(False);
2621         self.assertTrue(f1.getArray().isEqual(f2.getArray(),1e-12));
2622         self.assertEqual(48,mesh.getMeshLength());
2623         types2=mesh.getAllTypes();
2624         types2.sort()
2625         self.assertEqual(3,len(types2));
2626         expected2=[NORM_POLYGON, NORM_TRI3, NORM_QUAD4]
2627         expected2.sort()
2628         self.assertEqual(expected2,types2);
2629         pass
2630
2631     def testCheckGeoEquivalWith(self):
2632         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2633         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2634         #First test mesh1
2635         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh1,0,1e-12);#deepEqual
2636         self.assertTrue(cellCor==None);
2637         self.assertTrue(nodeCor==None);
2638         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh1,1,1e-12);#fastEqual
2639         self.assertTrue(cellCor==None);
2640         self.assertTrue(nodeCor==None);
2641         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh1,10,1e-12);#deepEqual with geo permutations
2642         self.assertTrue(cellCor==None);
2643         self.assertTrue(nodeCor==None);
2644         #Second test mesh1 and mesh2 are 2 different meshes instance
2645         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,0,1e-12);#deepEqual
2646         self.assertTrue(cellCor==None);
2647         self.assertTrue(nodeCor==None);
2648         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,1,1e-12);#fastEqual
2649         self.assertTrue(cellCor==None);
2650         self.assertTrue(nodeCor==None);
2651         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);#deepEqual with geo permutations
2652         self.assertTrue(cellCor==None);
2653         self.assertTrue(nodeCor==None);
2654         #Third test : cell permutation by keeping the first the middle and the last as it is.
2655         renum=[0,2,1,3,4,5,6,8,7,9]
2656         mesh2.renumberCells(renum,False);
2657         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12);#deepEqual fails
2658         self.assertTrue(cellCor==None);
2659         self.assertTrue(nodeCor==None);
2660         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,1,1e-12);#fastEqual do not see anything
2661         self.assertTrue(cellCor==None);
2662         self.assertTrue(nodeCor==None);
2663         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);#deepEqual with geo permutations
2664         self.assertTrue(cellCor);
2665         self.assertEqual(10,cellCor.getNumberOfTuples());
2666         self.assertEqual(1,cellCor.getNumberOfComponents());
2667         self.assertEqual(renum,list(cellCor.getValues()))
2668         self.assertTrue(nodeCor==None);
2669         cellCor=0;
2670         self.assertTrue(nodeCor==None);
2671         #4th test : cell and node permutation by keeping the first the middle and the last as it is.
2672         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2673         renum2=[0,2,1,3,4,5,6,8,7,9,10]
2674         mesh2.renumberCells(renum,False);
2675         mesh2.renumberNodes(renum2,11);
2676         cellCor=None
2677         nodeCor=None
2678         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12);#deepEqual fails
2679         self.assertTrue(cellCor==None);
2680         self.assertTrue(nodeCor==None);
2681         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,1,1e-12);#fastEqual do not see anything
2682         self.assertTrue(cellCor==None);
2683         self.assertTrue(nodeCor==None);
2684         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);#deepEqual with geo permutations
2685         self.assertTrue(cellCor);
2686         self.assertEqual(10,cellCor.getNumberOfTuples());
2687         self.assertEqual(1,cellCor.getNumberOfComponents());
2688         self.assertEqual(renum,list(cellCor.getValues()))
2689         self.assertTrue(nodeCor);
2690         self.assertEqual(11,nodeCor.getNumberOfTuples());
2691         self.assertEqual(1,nodeCor.getNumberOfComponents());
2692         self.assertEqual(renum2,list(nodeCor.getValues()))
2693         cellCor=0;
2694         nodeCor=0;
2695         #5th test : modification of the last cell to check fastCheck detection.
2696         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2697         renum3=[0,2,1,3,4,5,6,8,9,7]
2698         mesh2.renumberCells(renum3,False);
2699         mesh2.renumberNodes(renum2,11);
2700         cellCor=None
2701         nodeCor=None
2702         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12)
2703         self.assertTrue(cellCor==None);
2704         self.assertTrue(nodeCor==None);
2705         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,1,1e-12)
2706         self.assertTrue(cellCor==None);
2707         self.assertTrue(nodeCor==None);
2708         cellCor,nodeCor=mesh2.checkGeoEquivalWith(mesh1,10,1e-12);#deepEqual with geo permutations
2709         self.assertTrue(cellCor!=None);
2710         self.assertEqual(10,cellCor.getNumberOfTuples());
2711         self.assertEqual(1,cellCor.getNumberOfComponents());
2712         self.assertEqual(renum3,list(cellCor.getValues()))
2713         self.assertTrue(nodeCor!=None);
2714         self.assertEqual(11,nodeCor.getNumberOfTuples());
2715         self.assertEqual(1,nodeCor.getNumberOfComponents());
2716         self.assertEqual(renum2,list(nodeCor.getValues()));
2717         pass
2718
2719     def testCheckGeoEquivalWith2(self):
2720         mesh1=MEDCouplingDataForTest.build2DTargetMesh_4();
2721         mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
2722         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);
2723         self.assertEqual(None,cellCor);
2724         self.assertNotEqual(None,nodeCor);
2725         expected1=[0, 1, 3, 4, 5, 6, 7, 8, 9]
2726         for i in xrange(9):
2727             self.assertEqual(expected1[i],nodeCor.getIJ(i,0));
2728             pass
2729         pass
2730
2731     def testCopyTinyStringsFromOnFields(self):
2732         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2733         nbOfCells=m.getNumberOfCells();
2734         f=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
2735         f.setMesh(m);
2736         self.assertEqual(5,f.getNumberOfMeshPlacesExpected());
2737         f.setName("a");
2738         f.setDescription("b");
2739         a1=DataArrayDouble.New();
2740         a1.alloc(nbOfCells,2);
2741         a1.fillWithZero();
2742         a1.setInfoOnComponent(0,"c");
2743         a1.setInfoOnComponent(1,"d");
2744         a2=a1.deepCpy();
2745         a2.setInfoOnComponent(0,"e");
2746         a2.setInfoOnComponent(1,"f");
2747         f.setArray(a1);
2748         f.setEndArray(a2);
2749         f.setEndTime(3.,3,4);
2750         m.setName("g");
2751         m.getCoords().setInfoOnComponent(0,"h");
2752         m.getCoords().setInfoOnComponent(1,"i");
2753         m.getCoords().setInfoOnComponent(2,"j");
2754         #
2755         f.checkCoherency();
2756         f2=f.clone(True);
2757         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2758         f2.setName("smth");
2759         self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2760         f2.copyTinyStringsFrom(f);
2761         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2762         f2.setDescription("GGG");
2763         self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2764         f2.copyTinyStringsFrom(f);
2765         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2766         f2.getArray().setInfoOnComponent(0,"mmmm");
2767         self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2768         f2.copyTinyStringsFrom(f);
2769         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2770         f2.getEndArray().setInfoOnComponent(1,"mmmm");
2771         self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2772         f2.copyTinyStringsFrom(f);
2773         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2774         m2=m.clone(True);
2775         self.assertTrue(m2.isEqual(m,1e-12));
2776         m2.setName("123");
2777         self.assertTrue(not m2.isEqual(m,1e-12));
2778         m2.copyTinyStringsFrom(m);
2779         self.assertTrue(m2.isEqual(m,1e-12));
2780         m2.getCoords().setInfoOnComponent(1,"eee");
2781         self.assertTrue(not m2.isEqual(m,1e-12));
2782         m2.copyTinyStringsFrom(m);
2783         self.assertTrue(m2.isEqual(m,1e-12));
2784         pass
2785
2786     def testTryToShareSameCoordsPermute(self):
2787         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2788         m2=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2789         #self.assertTrue(m.getCoords()!=m2.getCoords());
2790         m.tryToShareSameCoordsPermute(m2,1e-12);
2791         #self.assertTrue(m.getCoords()==m2.getCoords());
2792         self.assertTrue(m2.isEqual(m,1e-12));
2793         renum1=[1,2,0,5,8,7,4,3,6]
2794         r1=DataArrayInt.New()
2795         r1.setValues(renum1,len(renum1),1)
2796         m.renumberNodes(r1,9);
2797         #self.assertTrue(m.getCoords()!=m2.getCoords());
2798         self.assertTrue(not m2.isEqual(m,1e-12));
2799         m.tryToShareSameCoordsPermute(m2,1e-12);
2800         #self.assertTrue(m.getCoords()==m2.getCoords());
2801         self.assertTrue(m2.isEqual(m,1e-12));
2802         pass
2803
2804     def testTryToShareSameCoordsPermute2(self):
2805         m1=MEDCouplingDataForTest.build2DTargetMesh_4();
2806         targetCoords=[-0.3,-0.3, 0.2,-0.3, -0.3,0.2, 0.2,0.2 ]
2807         targetConn=[0,2,3,1]
2808         m2=MEDCouplingUMesh.New();
2809         m2.setMeshDimension(2);
2810         m2.allocateCells(1);
2811         m2.insertNextCell(NORM_QUAD4,targetConn[0:4])
2812         m2.finishInsertingCells();
2813         myCoords=DataArrayDouble.New();
2814         myCoords.setValues(targetCoords,4,2);
2815         m2.setCoords(myCoords);
2816         m2.checkCoherency();
2817         m1.checkCoherency();
2818         #
2819         expected1=[0.25,0.125,0.125,0.25,0.25]
2820         f1=m1.getMeasureField(False);
2821         f2=m2.getMeasureField(False);
2822         self.assertEqual(5,f1.getArray().getNumberOfTuples());
2823         self.assertEqual(1,f2.getArray().getNumberOfTuples());
2824         for i in xrange(5):
2825             self.assertAlmostEqual(expected1[i],f1.getIJ(i,0),12);
2826             pass
2827         self.assertAlmostEqual(expected1[0],f2.getIJ(0,0),12);
2828         self.assertRaises(InterpKernelException,m1.tryToShareSameCoordsPermute,m2,1e-12);# <- here in this order the sharing is impossible.
2829         # Let's go for deeper test of tryToShareSameCoordsPermute
2830         m2.tryToShareSameCoordsPermute(m1,1e-12);
2831         f1=m1.getMeasureField(False);
2832         f2=m2.getMeasureField(False);
2833         self.assertEqual(5,f1.getArray().getNumberOfTuples());
2834         self.assertEqual(1,f2.getArray().getNumberOfTuples());
2835         for i in xrange(5):
2836             self.assertAlmostEqual(expected1[i],f1.getIJ(i,0),12);
2837             pass
2838         self.assertAlmostEqual(expected1[0],f2.getIJ(0,0),12);
2839         pass
2840
2841     def testChangeUnderlyingMesh1(self):
2842         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2843         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2844         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2845         f1.setMesh(mesh1);
2846         array=DataArrayDouble.New();
2847         arr=[7., 107., 8., 108., 9., 109., 10., 110., 11., 111., 12., 112., 13., 113., 14., 114., 15., 115., 16., 116.]
2848         array.setValues(arr,mesh1.getNumberOfCells(),2);
2849         f1.setArray(array);
2850         #
2851         renum=[0,2,1,3,4,5,6,8,7,9]
2852         mesh2.renumberCells(renum,False);
2853         #self.assertTrue(f1.getMesh()==mesh1);
2854         f1.changeUnderlyingMesh(mesh1,10,1e-12);# nothing done only to check that nothing done.
2855         #self.assertTrue(f1.getMesh()==mesh1);
2856         f1.changeUnderlyingMesh(mesh2,10,1e-12);
2857         #self.assertTrue(f1.getMesh()==mesh2);
2858         expected1=[7.,107.,9.,109.,8.,108.,10.,110.,11.,111.,12.,112.,13.,113.,15.,115.,14.,114.,16.,116.]
2859         for i in xrange(20):
2860             self.assertAlmostEqual(expected1[i],f1.getArray().getIJ(0,i),12);
2861             pass
2862         #
2863         f1=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
2864         f1.setMesh(mesh1);
2865         array=DataArrayDouble.New();
2866         arr2=[7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.,17.,117.]
2867         array.setValues(arr2,mesh1.getNumberOfNodes(),2);
2868         f1.setArray(array);
2869         #
2870         renum2=[0,2,10,3,4,5,6,8,7,9,1]
2871         mesh2.renumberNodes(renum2,11);
2872         #self.assertTrue(f1.getMesh()==mesh1);
2873         f1.changeUnderlyingMesh(mesh2,10,1e-12);
2874         #self.assertTrue(f1.getMesh()==mesh2);
2875         expected2=[7.,107.,17.,117.,8.,108.,10.,110.,11.,111.,12.,112.,13.,113.,15.,115.,14.,114.,16.,116.,9.,109.]
2876         for i in xrange(22):
2877             self.assertAlmostEqual(expected2[i],f1.getArray().getIJ(0,i),12);
2878             pass
2879         pass
2880
2881     def testGetMaxValue1(self):
2882         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2883         nbOfCells=m.getNumberOfCells();
2884         f=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
2885         f.setMesh(m);
2886         a1=DataArrayDouble.New();
2887         val1=[3.,4.,5.,6.,7.]
2888         a1.setValues(val1,nbOfCells,1);
2889         a2=DataArrayDouble.New();
2890         val2=[0.,1.,2.,8.,7.]
2891         a2.setValues(val2,nbOfCells,1);
2892         f.setArray(a1);
2893         f.setEndArray(a2);
2894         f.setEndTime(3.,3,4);
2895         f.checkCoherency();
2896         #
2897         self.assertAlmostEqual(8.,f.getMaxValue(),14);
2898         self.assertAlmostEqual(0.,f.getMinValue(),14);
2899         self.assertAlmostEqual(5.,f.getAverageValue(),14);
2900         self.assertAlmostEqual(5.125,f.getWeightedAverageValue(),14);
2901         a1.setIJ(0,2,9.5);
2902         self.assertAlmostEqual(9.5,f.getMaxValue(),14);
2903         self.assertAlmostEqual(0.,f.getMinValue(),14);
2904         a2.setIJ(0,0,9.);
2905         self.assertAlmostEqual(9.5,f.getMaxValue(),14);
2906         self.assertAlmostEqual(1.,f.getMinValue(),14);
2907         pass
2908
2909     def testSubstractInPlaceDM1(self):
2910         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2911         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2912         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2913         f1.setMesh(mesh1);
2914         array=DataArrayDouble.New();
2915         arr=[7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.]
2916         array.setValues(arr,mesh1.getNumberOfCells(),2);
2917         f1.setArray(array);
2918         #
2919         self.assertEqual(10,f1.getNumberOfTuples());
2920         self.assertEqual(2,f1.getNumberOfComponents());
2921         self.assertEqual(20,f1.getNumberOfValues());
2922         #
2923         renum=[0,2,3,1,4,5,6,8,7,9]
2924         mesh2.renumberCells(renum,False);
2925         #
2926         f2=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2927         f2.setMesh(mesh2);
2928         array=DataArrayDouble.New();
2929         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]
2930         array.setValues(arr2,mesh2.getNumberOfCells(),2);
2931         f2.setArray(array);
2932         #
2933         f1.substractInPlaceDM(f2,10,1e-12);
2934         f1.applyFunc(1,"abs(x+y+0.2)");
2935         self.assertAlmostEqual(0.,f1.getMaxValue(),13);
2936         pass
2937
2938     def testDotCrossProduct1(self):
2939         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2940         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
2941         f1.setTime(2.3,5,6);
2942         f1.setMesh(mesh1);
2943         array=DataArrayDouble.New();
2944         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.]
2945         array.setValues(arr1,mesh1.getNumberOfCells(),3);
2946         f1.setArray(array);
2947         f2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
2948         f2.setTime(7.8,4,5);
2949         f2.setMesh(mesh1);
2950         array=DataArrayDouble.New();
2951         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.]
2952         array.setValues(arr2,mesh1.getNumberOfCells(),3);
2953         f2.setArray(array);
2954         #
2955         f3=f1.dot(f2);
2956         expected1=[842.,1820.,2816.,3830.,4862.,5912.,6980.,8066.,9170.,10292.]
2957         for i in xrange(10):
2958             self.assertAlmostEqual(expected1[i],f3.getIJ(i,0),9);
2959             pass
2960         #
2961         f4=f1.crossProduct(f2);
2962         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.]
2963         for i in xrange(30):
2964             self.assertAlmostEqual(expected2[i],f4.getIJ(0,i),9);
2965             pass
2966         pass
2967
2968     def testMinMaxFields1(self):
2969         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2970         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
2971         f1.setTime(2.3,5,6);
2972         f1.setMesh(mesh1);
2973         array=DataArrayDouble.New();
2974         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.]
2975         array.setValues(arr1,mesh1.getNumberOfCells(),3);
2976         f1.setArray(array);
2977         f2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
2978         f2.setTime(7.8,4,5);
2979         f2.setMesh(mesh1);
2980         array=DataArrayDouble.New();
2981         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.]
2982         array.setValues(arr2,mesh1.getNumberOfCells(),3);
2983         f2.setArray(array);
2984         #
2985         f3=f1.max(f2);
2986         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.]
2987         for i in xrange(30):
2988             self.assertAlmostEqual(expected1[i],f3.getIJ(0,i),9);
2989             pass
2990         #
2991         f4=f1.min(f2);
2992         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.]
2993         for i in xrange(30):
2994             self.assertAlmostEqual(expected2[i],f4.getIJ(0,i),9);
2995             pass
2996         #
2997         pass
2998
2999     def testApplyLin1(self):
3000         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
3001         f1=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
3002         f1.setMesh(mesh1);
3003         array=DataArrayDouble.New();
3004         arr=[7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.]
3005         array.setValues(arr,mesh1.getNumberOfCells(),2);
3006         f1.setArray(array);
3007         #
3008         f1.applyLin(2.,3.,0);
3009         expected1=[17.,107.,19.,108.,21.,109.,23.,110.,25.,111.,27.,112.,29.,113.,31.,114.,33.,115.,35.,116.]
3010         for i in xrange(20):
3011             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),9);
3012             pass
3013         #
3014         arr2=[2.,102.,3.,103.,4.,104.,5.,105.,6.,106.,7.,107.,8.,108.,9.,109.,10.,110.,11.,111.]
3015         array=DataArrayDouble.New();
3016         array.setValues(arr2,mesh1.getNumberOfCells(),2);
3017         f1.setEndArray(array);
3018         #
3019         f1.applyLin(4.,5.,1);
3020         #
3021         expected2=[17.,433.,19.,437.,21.,441.,23.,445.,25.,449.,27.,453.,29.,457.,31.,461.,33.,465.,35.,469.]
3022         for i in xrange(20):
3023             self.assertAlmostEqual(expected2[i],f1.getIJ(0,i),9);
3024             pass
3025         expected3=[2.,413.,3.,417.,4.,421.,5.,425.,6.,429.,7.,433.,8.,437.,9.,441.,10.,445.,11.,449.]
3026         for i in xrange(20):
3027             self.assertAlmostEqual(expected3[i],f1.getEndArray().getIJ(0,i),9);
3028             pass
3029         #
3030         pass
3031
3032     def testGetIdsInRange1(self):
3033         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
3034         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3035         f1.setTime(2.3,5,6);
3036         f1.setMesh(mesh1);
3037         array=DataArrayDouble.New();
3038         arr1=[2.,8.,6.,5.,11.,7.,9.,3.,10.,4.]
3039         array.setValues(arr1,mesh1.getNumberOfCells(),1);
3040         f1.setArray(array);
3041         #
3042         f1.checkCoherency();
3043         da=f1.getIdsInRange(2.9,7.1);
3044         self.failUnlessEqual(5,da.getNbOfElems());
3045         expected1=[2,3,5,7,9]
3046         self.failUnlessEqual(expected1,list(da.getValues()));
3047         da=f1.getIdsInRange(8.,12.);
3048         self.failUnlessEqual(4,da.getNbOfElems());
3049         expected2=[1,4,6,8]
3050         self.failUnlessEqual(expected2,list(da.getValues()));
3051         #
3052         pass
3053
3054     def testBuildSubPart1(self):
3055         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3056         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3057         f1.setTime(2.3,5,6);
3058         f1.setMesh(mesh1);
3059         array=DataArrayDouble.New();
3060         arr1=[3.,103.,4.,104.,5.,105.,6.,106.,7.,107.]
3061         array.setValues(arr1,mesh1.getNumberOfCells(),2);
3062         f1.setArray(array);
3063         #
3064         part1=[2,1,4]
3065         f2=f1[part1];
3066         f2.zipCoords()
3067         self.failUnlessEqual(3,f2.getNumberOfTuples());
3068         self.failUnlessEqual(2,f2.getNumberOfComponents());
3069         expected1=[5.,105.,4.,104.,7.,107.]
3070         for i in xrange(6):
3071             self.assertAlmostEqual(f2.getIJ(0,i),expected1[i],12);
3072             pass
3073         self.failUnlessEqual(3,f2.getMesh().getNumberOfCells());
3074         self.failUnlessEqual(6,f2.getMesh().getNumberOfNodes());
3075         self.failUnlessEqual(2,f2.getMesh().getSpaceDimension());
3076         self.failUnlessEqual(2,f2.getMesh().getMeshDimension());
3077         m2C=f2.getMesh();
3078         self.failUnlessEqual(13,m2C.getMeshLength());
3079         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]
3080         for i in xrange(12):
3081             self.assertAlmostEqual(expected2[i],m2C.getCoords().getIJ(0,i),12);
3082             pass
3083         expected3=[3,2,3,1,3,0,2,1,4,4,5,3,2]
3084         self.failUnlessEqual(expected3,list(m2C.getNodalConnectivity().getValues()));
3085         expected4=[0,4,8,13]
3086         self.failUnlessEqual(expected4,list(m2C.getNodalConnectivityIndex().getValues()));
3087         # Test with field on nodes.
3088         f1=MEDCouplingFieldDouble.New(ON_NODES,ONE_TIME);
3089         f1.setTime(2.3,5,6);
3090         f1.setMesh(mesh1);
3091         array=DataArrayDouble.New();
3092         arr2=[3.,103.,4.,104.,5.,105.,6.,106.,7.,107.,8.,108.,9.,109.,10.,110.,11.,111.]
3093         array.setValues(arr2,mesh1.getNumberOfNodes(),2);
3094         f1.setArray(array);
3095         part2=[1,2]
3096         f2=f1.buildSubPart(part2);
3097         self.failUnlessEqual(4,f2.getNumberOfTuples());
3098         self.failUnlessEqual(2,f2.getNumberOfComponents());
3099         expected5=[4.,104.,5.,105.,7.,107.,8.,108.]
3100         for i in xrange(8):
3101             self.assertAlmostEqual(f2.getIJ(0,i),expected5[i],12);
3102             pass
3103         self.failUnlessEqual(2,f2.getMesh().getNumberOfCells());
3104         self.failUnlessEqual(4,f2.getMesh().getNumberOfNodes());
3105         self.failUnlessEqual(2,f2.getMesh().getSpaceDimension());
3106         self.failUnlessEqual(2,f2.getMesh().getMeshDimension());
3107         m2C=f2.getMesh();
3108         self.failUnlessEqual(8,m2C.getMeshLength());
3109         for i in xrange(8):#8 is not an error
3110             self.assertAlmostEqual(expected2[i],m2C.getCoords().getIJ(0,i),12);
3111             pass
3112         self.failUnlessEqual(expected3[:4],list(m2C.getNodalConnectivity().getValues())[4:]);
3113         self.failUnlessEqual(expected3[4:8],list(m2C.getNodalConnectivity().getValues())[:4]);
3114         self.failUnlessEqual(expected4[:3],list(m2C.getNodalConnectivityIndex().getValues()));
3115         #idem previous because nodes of cell#4 are not fully present in part3
3116         part3=[1,2]
3117         arrr=DataArrayInt.New();
3118         arrr.setValues(part3,2,1);
3119         f2=f1.buildSubPart(arrr);
3120         self.failUnlessEqual(4,f2.getNumberOfTuples());
3121         self.failUnlessEqual(2,f2.getNumberOfComponents());
3122         for i in xrange(8):
3123             self.assertAlmostEqual(f2.getIJ(0,i),expected5[i],12);
3124             pass
3125         self.failUnlessEqual(2,f2.getMesh().getNumberOfCells());
3126         self.failUnlessEqual(4,f2.getMesh().getNumberOfNodes());
3127         self.failUnlessEqual(2,f2.getMesh().getSpaceDimension());
3128         self.failUnlessEqual(2,f2.getMesh().getMeshDimension());
3129         m2C=f2.getMesh();
3130         self.failUnlessEqual(8,m2C.getMeshLength());
3131         for i in xrange(8):#8 is not an error
3132             self.assertAlmostEqual(expected2[i],m2C.getCoords().getIJ(0,i),12);
3133             pass
3134         self.failUnlessEqual(expected3[:4],list(m2C.getNodalConnectivity().getValues())[4:8]);
3135         self.failUnlessEqual(expected3[4:8],list(m2C.getNodalConnectivity().getValues())[:4]);
3136         self.failUnlessEqual(expected4[:3],list(m2C.getNodalConnectivityIndex().getValues()));
3137         #
3138         part4=[1,2,4]
3139         f2=f1.buildSubPart(part4);
3140         self.failUnlessEqual(6,f2.getNumberOfTuples());
3141         self.failUnlessEqual(2,f2.getNumberOfComponents());
3142         expected6=[4.,104.,5.,105.,7.,107.,8.,108.,10.,110.,11.,111.]
3143         for i in xrange(12):
3144             self.assertAlmostEqual(f2.getIJ(0,i),expected6[i],12);
3145             pass
3146         self.failUnlessEqual(3,f2.getMesh().getNumberOfCells());
3147         self.failUnlessEqual(6,f2.getMesh().getNumberOfNodes());
3148         self.failUnlessEqual(2,f2.getMesh().getSpaceDimension());
3149         self.failUnlessEqual(2,f2.getMesh().getMeshDimension());
3150         m2C=f2.getMesh();
3151         self.failUnlessEqual(13,m2C.getMeshLength());
3152         for i in xrange(12):
3153             self.assertAlmostEqual(expected2[i],m2C.getCoords().getIJ(0,i),12);
3154             pass
3155         self.failUnlessEqual(expected3[0:4],list(m2C.getNodalConnectivity().getValues())[4:8]);
3156         self.failUnlessEqual(expected3[4:8],list(m2C.getNodalConnectivity().getValues())[0:4]);
3157         self.failUnlessEqual(expected3[8:13],list(m2C.getNodalConnectivity().getValues())[8:13]);
3158         self.failUnlessEqual(expected4,list(m2C.getNodalConnectivityIndex().getValues()));
3159         pass
3160
3161     def testDoublyContractedProduct1(self):
3162         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3163         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3164         f1.setMesh(mesh1);
3165         array=DataArrayDouble.New();
3166         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]
3167         array.setValues(arr1,mesh1.getNumberOfCells(),6);
3168         f1.setArray(array);
3169         f1.checkCoherency();
3170         #
3171         f2=f1.doublyContractedProduct();
3172         f2.checkCoherency();
3173         self.assertEqual(1,f2.getNumberOfComponents());
3174         self.assertEqual(5,f2.getNumberOfTuples());
3175         for i in xrange(5):
3176             self.assertAlmostEqual(3906.56,f2.getIJ(i,0),9);
3177             pass
3178         #
3179         pass
3180
3181     def testDeterminant1(self):
3182         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3183         f1=MEDCouplingFieldDouble.New(ON_CELLS,CONST_ON_TIME_INTERVAL);
3184         f1.setTime(2.3,5,6);
3185         f1.setEndTime(3.8,7,3);
3186         f1.setMesh(mesh1);
3187         array=DataArrayDouble.New();
3188         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]
3189         array.setValues(arr1,mesh1.getNumberOfCells(),4);
3190         f1.setArray(array);
3191         #4 components
3192         f1.checkCoherency();
3193         f2=f1.determinant();
3194         f2.checkCoherency();
3195         self.assertEqual(CONST_ON_TIME_INTERVAL,f2.getTimeDiscretization());
3196         self.assertEqual(1,f2.getNumberOfComponents());
3197         self.assertEqual(5,f2.getNumberOfValues());
3198         for i in xrange(5):
3199             self.assertAlmostEqual(-2.42,f2.getIJ(i,0),13);
3200             pass
3201         #6 components multi arrays with end array not defined
3202         f1=MEDCouplingFieldDouble.New(ON_NODES,LINEAR_TIME);
3203         f1.setTime(2.3,5,6);
3204         f1.setEndTime(3.8,7,3);
3205         f1.setMesh(mesh1);
3206         array=DataArrayDouble.New();
3207         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,
3208               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]
3209         array.setValues(arr2,mesh1.getNumberOfNodes(),6);
3210         f1.setArray(array);
3211         self.assertRaises(InterpKernelException,f1.checkCoherency);#no end array specified !
3212         #
3213         f2=f1.determinant();
3214         self.assertEqual(LINEAR_TIME,f2.getTimeDiscretization());
3215         self.assertEqual(1,f2.getArray().getNumberOfComponents());
3216         self.assertEqual(9,f2.getNumberOfTuples());
3217         for i in xrange(9):
3218             self.assertAlmostEqual(137.335,f2.getIJ(i,0),10);
3219             pass
3220         #6 components multi arrays with end array defined
3221         array=DataArrayDouble.New();
3222         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,
3223               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]
3224         array.setValues(arr3,mesh1.getNumberOfNodes(),6);
3225         f1.setEndArray(array);
3226         f1.checkCoherency();
3227         f2=f1.determinant();
3228         f2.checkCoherency();
3229         self.assertEqual(LINEAR_TIME,f2.getTimeDiscretization());
3230         self.assertEqual(1,f2.getNumberOfComponents());
3231         self.assertEqual(9,f2.getNumberOfTuples());
3232         time2,it,order=f2.getTime()
3233         self.assertAlmostEqual(2.3,time2,12);
3234         self.assertEqual(5,it);
3235         self.assertEqual(6,order);
3236         time2,it,order=f2.getEndTime()
3237         self.assertAlmostEqual(3.8,time2,12);
3238         self.assertEqual(7,it);
3239         self.assertEqual(3,order);
3240         for i in xrange(9):
3241             self.assertAlmostEqual(137.335,f2.getIJ(i,0),10);
3242             self.assertAlmostEqual(1289.685,f2.getEndArray().getIJ(i,0),9);
3243             pass
3244         #9 components
3245         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3246         f1.setTime(7.8,10,2);
3247         f1.setMesh(mesh1);
3248         array=DataArrayDouble.New();
3249         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]
3250         array.setValues(arr4,mesh1.getNumberOfCells(),9);
3251         f1.setArray(array);
3252         #
3253         f1.checkCoherency();
3254         f2=f1.determinant();
3255         f2.checkCoherency();
3256         self.assertEqual(ONE_TIME,f2.getTimeDiscretization());
3257         self.assertEqual(1,f2.getNumberOfComponents());
3258         self.assertEqual(5,f2.getNumberOfTuples());
3259         time2,it,order=f2.getTime()
3260         self.assertAlmostEqual(7.8,time2,12);
3261         self.assertEqual(10,it);
3262         self.assertEqual(2,order);
3263         for i in xrange(5):
3264             self.assertAlmostEqual(3.267,f2.getIJ(i,0),13);
3265             pass
3266         pass
3267
3268     def testEigenValues1(self):
3269         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3270         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3271         f1.setMesh(mesh1);
3272         array=DataArrayDouble.New();
3273         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]
3274         array.setValues(arr1,mesh1.getNumberOfCells(),6);
3275         f1.setArray(array);
3276         f1.checkCoherency();
3277         #
3278         f2=f1.eigenValues();
3279         f2.checkCoherency();
3280         self.assertEqual(3,f2.getNumberOfComponents());
3281         self.assertEqual(5,f2.getNumberOfTuples());
3282         expected1=[13.638813677891717,-4.502313844635971,-2.2364998332557486]
3283         for i in xrange(5):
3284             self.assertAlmostEqual(expected1[0],f2.getIJ(i,0),13);
3285             self.assertAlmostEqual(expected1[1],f2.getIJ(i,1),13);
3286             self.assertAlmostEqual(expected1[2],f2.getIJ(i,2),13);
3287             pass
3288         pass
3289
3290     def testEigenVectors1(self):
3291         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3292         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3293         f1.setMesh(mesh1);
3294         array=DataArrayDouble.New();
3295         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]
3296         array.setValues(arr1,mesh1.getNumberOfCells(),6);
3297         f1.setArray(array);
3298         f1.checkCoherency();
3299         #
3300         f2=f1.eigenVectors();
3301         f2.checkCoherency();
3302         self.assertEqual(9,f2.getNumberOfComponents());
3303         self.assertEqual(5,f2.getNumberOfTuples());
3304         expected1=[0.5424262364180696, 0.5351201064614425, 0.6476266283176001,#eigenvect 0
3305                    0.7381111277307373, 0.06458838384003074, -0.6715804522117897,#eigenvect 1
3306                    -0.4012053603397987, 0.8423032781211455, -0.3599436712889738#eigenvect 2
3307                    ]
3308         for i in xrange(5):
3309             self.assertAlmostEqual(expected1[0],f2.getIJ(i,0),13);
3310             self.assertAlmostEqual(expected1[1],f2.getIJ(i,1),13);
3311             self.assertAlmostEqual(expected1[2],f2.getIJ(i,2),13);
3312             self.assertAlmostEqual(expected1[3],f2.getIJ(i,3),13);
3313             self.assertAlmostEqual(expected1[4],f2.getIJ(i,4),13);
3314             self.assertAlmostEqual(expected1[5],f2.getIJ(i,5),13);
3315             self.assertAlmostEqual(expected1[6],f2.getIJ(i,6),13);
3316             self.assertAlmostEqual(expected1[7],f2.getIJ(i,7),13);
3317             self.assertAlmostEqual(expected1[8],f2.getIJ(i,8),13);
3318             pass
3319         #
3320         pass
3321
3322     def testInverse1(self):
3323         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3324         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3325         f1.setMesh(mesh1);
3326         array=DataArrayDouble.New();
3327         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]
3328         array.setValues(arr1,mesh1.getNumberOfCells(),9);
3329         f1.setArray(array);
3330         f1.checkCoherency();
3331         #
3332         f2=f1.inverse();
3333         f2.checkCoherency();
3334         self.assertEqual(9,f2.getNumberOfComponents());
3335         self.assertEqual(5,f2.getNumberOfTuples());
3336         expected1=[-2.6538108356290113, 2.855831037649208, -1.1111111111111067, 3.461891643709813, -4.775022956841121, 2.2222222222222143, -1.1111111111111054, 2.222222222222214, -1.1111111111111072]
3337         for i in xrange(5):
3338             self.assertAlmostEqual(expected1[0],f2.getIJ(i,0),13);
3339             self.assertAlmostEqual(expected1[1],f2.getIJ(i,1),13);
3340             self.assertAlmostEqual(expected1[2],f2.getIJ(i,2),13);
3341             self.assertAlmostEqual(expected1[3],f2.getIJ(i,3),13);
3342             self.assertAlmostEqual(expected1[4],f2.getIJ(i,4),13);
3343             self.assertAlmostEqual(expected1[5],f2.getIJ(i,5),13);
3344             self.assertAlmostEqual(expected1[6],f2.getIJ(i,6),13);
3345             self.assertAlmostEqual(expected1[7],f2.getIJ(i,7),13);
3346             self.assertAlmostEqual(expected1[8],f2.getIJ(i,8),13);
3347             pass
3348         #
3349         array=DataArrayDouble.New();
3350         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]
3351         array.setValues(arr3,mesh1.getNumberOfCells(),6);
3352         f1.setArray(array);
3353         f1.checkCoherency();
3354         #
3355         f2=f1.inverse();
3356         f2.checkCoherency();
3357         self.assertEqual(6,f2.getNumberOfComponents());
3358         self.assertEqual(5,f2.getNumberOfTuples());
3359         expected3=[-0.3617705098531818, -0.8678630828458127, -0.026843764174972983, 0.5539957431465833, 0.13133439560823013, -0.05301294502145887]
3360         for i in xrange(5):
3361             self.assertAlmostEqual(expected3[0],f2.getIJ(i,0),13);
3362             self.assertAlmostEqual(expected3[1],f2.getIJ(i,1),13);
3363             self.assertAlmostEqual(expected3[2],f2.getIJ(i,2),13);
3364             self.assertAlmostEqual(expected3[3],f2.getIJ(i,3),13);
3365             self.assertAlmostEqual(expected3[4],f2.getIJ(i,4),13);
3366             self.assertAlmostEqual(expected3[5],f2.getIJ(i,5),13);
3367             pass
3368         #
3369         array=DataArrayDouble.New();
3370         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]
3371         array.setValues(arr2,mesh1.getNumberOfCells(),4);
3372         f1.setArray(array);
3373         f1.checkCoherency();
3374         #
3375         f2=f1.inverse();
3376         f2.checkCoherency();
3377         self.assertEqual(4,f2.getNumberOfComponents());
3378         self.assertEqual(5,f2.getNumberOfTuples());
3379         expected2=[-1.8595041322314059, 0.9504132231404963, 1.404958677685951, -0.49586776859504156]
3380         for i in xrange(5):
3381             self.assertAlmostEqual(expected2[0],f2.getIJ(i,0),13);
3382             self.assertAlmostEqual(expected2[1],f2.getIJ(i,1),13);
3383             self.assertAlmostEqual(expected2[2],f2.getIJ(i,2),13);
3384             self.assertAlmostEqual(expected2[3],f2.getIJ(i,3),13);
3385             pass
3386         #
3387         pass
3388
3389     def testTrace1(self):
3390         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3391         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3392         f1.setMesh(mesh1);
3393         array=DataArrayDouble.New();
3394         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]
3395         array.setValues(arr1,mesh1.getNumberOfCells(),9);
3396         f1.setArray(array);
3397         f1.checkCoherency();
3398         #
3399         f2=f1.trace();
3400         f2.checkCoherency();
3401         self.assertEqual(1,f2.getNumberOfComponents());
3402         self.assertEqual(5,f2.getNumberOfTuples());
3403         for i in xrange(5):
3404             self.assertAlmostEqual(15.9,f2.getIJ(i,0),13);
3405             pass
3406         #
3407         array=DataArrayDouble.New();
3408         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]
3409         array.setValues(arr3,mesh1.getNumberOfCells(),6);
3410         f1.setArray(array);
3411         f1.checkCoherency();
3412         #
3413         f2=f1.trace();
3414         f2.checkCoherency();
3415         self.assertEqual(1,f2.getNumberOfComponents());
3416         self.assertEqual(5,f2.getNumberOfTuples());
3417         for i in xrange(5):
3418             self.assertAlmostEqual(25.8,f2.getIJ(i,0),13);
3419             pass
3420         #
3421         array=DataArrayDouble.New();
3422         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]
3423         array.setValues(arr2,mesh1.getNumberOfCells(),4);
3424         f1.setArray(array);
3425         f1.checkCoherency();
3426         #
3427         f2=f1.trace();
3428         f2.checkCoherency();
3429         self.assertEqual(1,f2.getNumberOfComponents());
3430         self.assertEqual(5,f2.getNumberOfTuples());
3431         for i in xrange(5):
3432             self.assertAlmostEqual(5.7,f2.getIJ(i,0),13);
3433             pass
3434         #
3435         pass
3436
3437     def testDeviator1(self):
3438         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3439         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3440         f1.setMesh(mesh1);
3441         array=DataArrayDouble.New();
3442         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]
3443         array.setValues(arr1,mesh1.getNumberOfCells(),6);
3444         f1.setArray(array);
3445         f1.checkCoherency();
3446         #
3447         f2=f1.deviator();
3448         f2.checkCoherency();
3449         self.assertEqual(6,f2.getNumberOfComponents());
3450         self.assertEqual(5,f2.getNumberOfTuples());
3451         expected1=[-1.1,0.,1.1,4.5,5.6,6.7]
3452         for i in xrange(5):
3453             self.assertAlmostEqual(expected1[0],f2.getIJ(i,0),13);
3454             self.assertAlmostEqual(expected1[1],f2.getIJ(i,1),13);
3455             self.assertAlmostEqual(expected1[2],f2.getIJ(i,2),13);
3456             self.assertAlmostEqual(expected1[3],f2.getIJ(i,3),13);
3457             self.assertAlmostEqual(expected1[4],f2.getIJ(i,4),13);
3458             self.assertAlmostEqual(expected1[5],f2.getIJ(i,5),13);
3459             pass
3460         #
3461         pass
3462
3463     def testMagnitude1(self):
3464         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3465         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3466         f1.setMesh(mesh1);
3467         array=DataArrayDouble.New();
3468         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]
3469         array.setValues(arr1,mesh1.getNumberOfCells(),5);
3470         f1.setArray(array);
3471         f1.checkCoherency();
3472         #
3473         f2=f1.magnitude();
3474         f2.checkCoherency();
3475         self.assertEqual(1,f2.getNumberOfComponents());
3476         self.assertEqual(5,f2.getNumberOfTuples());
3477         for i in xrange(5):
3478             self.assertAlmostEqual(8.3606219864313918,f2.getIJ(i,0),13);
3479             pass
3480         #
3481         pass
3482
3483     def testMaxPerTuple1(self):
3484         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3485         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3486         f1.setMesh(mesh1);
3487         array=DataArrayDouble.New();
3488         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]
3489         array.setValues(arr1,mesh1.getNumberOfCells(),5);
3490         f1.setArray(array);
3491         f1.checkCoherency();
3492         #
3493         f2=f1.maxPerTuple();
3494         f2.checkCoherency();
3495         self.assertEqual(1,f2.getNumberOfComponents());
3496         self.assertEqual(5,f2.getNumberOfTuples());
3497         for i in xrange(5):
3498             self.assertAlmostEqual(5.6,f2.getIJ(i,0),13);
3499             pass
3500         #
3501         pass
3502
3503     def testChangeNbOfComponents(self):
3504         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3505         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3506         f1.setMesh(mesh1);
3507         array=DataArrayDouble.New();
3508         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]
3509         array.setValues(arr1,mesh1.getNumberOfCells(),5);
3510         f1.setArray(array);
3511         f1.checkCoherency();
3512         #
3513         f1.changeNbOfComponents(3,7.77);
3514         f1.checkCoherency();
3515         self.assertEqual(3,f1.getNumberOfComponents());
3516         self.assertEqual(5,f1.getNumberOfTuples());
3517         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]
3518         for i in xrange(15):
3519             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),13);
3520             pass
3521         f1.changeNbOfComponents(4,7.77);
3522         f1.checkCoherency();
3523         self.assertEqual(4,f1.getNumberOfComponents());
3524         self.assertEqual(5,f1.getNumberOfTuples());
3525         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]
3526         for i in xrange(20):
3527             self.assertAlmostEqual(expected2[i],f1.getIJ(0,i),13);
3528             pass
3529         #
3530         pass
3531
3532     def testSortPerTuple1(self):
3533         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3534         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3535         f1.setMesh(mesh1);
3536         array=DataArrayDouble.New();
3537         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]
3538         array.setValues(arr1,mesh1.getNumberOfCells(),5);
3539         f1.setArray(array);
3540         f1.checkCoherency();
3541         #
3542         f1.sortPerTuple(True);
3543         f1.checkCoherency();
3544         self.assertEqual(5,f1.getNumberOfComponents());
3545         self.assertEqual(5,f1.getNumberOfTuples());
3546         for i in xrange(5):
3547             self.assertAlmostEqual(arr1[0],f1.getIJ(i,0),13);
3548             self.assertAlmostEqual(arr1[1],f1.getIJ(i,1),13);
3549             self.assertAlmostEqual(arr1[2],f1.getIJ(i,2),13);
3550             self.assertAlmostEqual(arr1[3],f1.getIJ(i,3),13);
3551             self.assertAlmostEqual(arr1[4],f1.getIJ(i,4),13);
3552             pass
3553         #
3554         f1.sortPerTuple(False);
3555         f1.checkCoherency();
3556         self.assertEqual(5,f1.getNumberOfComponents());
3557         self.assertEqual(5,f1.getNumberOfTuples());
3558         for i in xrange(5):
3559             self.assertAlmostEqual(arr1[4],f1.getIJ(i,0),13);
3560             self.assertAlmostEqual(arr1[3],f1.getIJ(i,1),13);
3561             self.assertAlmostEqual(arr1[2],f1.getIJ(i,2),13);
3562             self.assertAlmostEqual(arr1[1],f1.getIJ(i,3),13);
3563             self.assertAlmostEqual(arr1[0],f1.getIJ(i,4),13);
3564             pass
3565         #
3566         pass
3567
3568     def testIsEqualWithoutConsideringStr1(self):
3569         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3570         mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
3571         #
3572         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3573         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3574         mesh2.setName("rr");
3575         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
3576         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3577         da1,da2=mesh1.checkGeoEquivalWith(mesh2,2,1e-12);
3578         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12);
3579         mesh2.setName("");
3580         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3581         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3582         mesh2.getCoords().setInfoOnComponent(0,"tty");
3583         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
3584         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3585         mesh2.getCoords().setInfoOnComponent(0,"");
3586         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3587         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3588         mesh2.getCoords().setInfoOnComponent(1,"tty");
3589         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
3590         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3591         mesh2.getCoords().setInfoOnComponent(1,"");
3592         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3593         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3594         tmp=mesh2.getCoords().getIJ(0,3);
3595         mesh2.getCoords().setIJ(0,3,9999.);
3596         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
3597         self.assertTrue(not mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3598         mesh2.getCoords().setIJ(0,3,tmp);
3599         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3600         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3601         tmp2=mesh2.getNodalConnectivity().getIJ(0,4);
3602         mesh2.getNodalConnectivity().setIJ(0,4,0);
3603         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
3604         self.assertTrue(not mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3605         mesh2.getNodalConnectivity().setIJ(0,4,tmp2);
3606         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3607         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3608         #
3609         f1=mesh1.getMeasureField(True);
3610         f2=mesh2.getMeasureField(True);
3611         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
3612         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3613         f2.setName("ftest");
3614         self.assertTrue(not f1.isEqual(f2,1e-12,1e-12));
3615         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3616         f1.setName("ftest");
3617         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
3618         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3619         #
3620         f2.getArray().setInfoOnComponent(0,"eee");
3621         self.assertTrue(not f1.isEqual(f2,1e-12,1e-12));
3622         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3623         f2.getArray().setInfoOnComponent(0,"");
3624         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
3625         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3626         #
3627         f2.getArray().setIJ(1,0,0.123);
3628         self.assertTrue(not f1.isEqual(f2,1e-12,1e-12));
3629         self.assertTrue(not f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3630         f2.getArray().setIJ(1,0,0.125);
3631         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
3632         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3633         #
3634         pass
3635
3636     def testGetNodeIdsOfCell1(self):
3637         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3638         li=mesh1.getNodeIdsOfCell(1)
3639         expected1=[1, 4, 2]
3640         self.assertEqual(expected1,list(li))
3641         li=mesh1.getCoordinatesOfNode(4)
3642         self.assertEqual(2,len(li))
3643         self.assertAlmostEqual(0.2,li[0],13);
3644         self.assertAlmostEqual(0.2,li[1],13);
3645         li=mesh1.getCoords().getValuesAsTuple()
3646         self.assertEqual(9,len(li))
3647         li2=mesh1.getNodalConnectivityIndex().getValuesAsTuple()
3648         self.assertEqual(6,len(li2))
3649         pass
3650
3651     def testGetEdgeRatioField1(self):
3652         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
3653         m1.setTime(3.4,5,6); m1.setTimeUnit("us");
3654         f1=m1.getEdgeRatioField();
3655         self.assertAlmostEqual(3.4,f1.getTime()[0],12) ; self.assertEqual(5,f1.getTime()[1]) ; self.assertEqual(6,f1.getTime()[2])
3656         self.assertEqual("us",f1.getTimeUnit())
3657         self.assertEqual(m1.getNumberOfCells(),f1.getNumberOfTuples());
3658         self.assertEqual(5,f1.getNumberOfTuples());
3659         self.assertEqual(1,f1.getNumberOfComponents());
3660         expected1=[1.,1.4142135623730951, 1.4142135623730951,1.,1.]
3661         for i in xrange(5):
3662             self.assertAlmostEqual(expected1[i],f1.getIJ(i,0),14);
3663             pass
3664         #
3665         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
3666         f1=m1.getEdgeRatioField();
3667         self.assertEqual(m1.getNumberOfCells(),f1.getNumberOfTuples());
3668         self.assertEqual(5,f1.getNumberOfTuples());
3669         self.assertEqual(1,f1.getNumberOfComponents());
3670         expected2=[1.4142135623730951, 1.7320508075688772, 1.7320508075688772, 1.4142135623730951, 1.4142135623730951]
3671         for i in xrange(5):
3672             self.assertAlmostEqual(expected2[i],f1.getIJ(i,0),14);
3673             pass
3674         pass
3675
3676     def testFillFromAnalytic3(self):
3677         m=MEDCouplingDataForTest.build2DTargetMesh_1()
3678         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME)
3679         self.assertRaises(InterpKernelException,f1.fillFromAnalytic,1,"y+x");
3680         f1.setMesh(m)
3681         f1.setName("myField");
3682         f1.fillFromAnalytic(1,"y+x");
3683         f1.checkCoherency();
3684         self.assertEqual(f1.getName(),"myField");
3685         self.assertEqual(f1.getTypeOfField(),ON_CELLS);
3686         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
3687         self.assertEqual(1,f1.getNumberOfComponents());
3688         self.assertEqual(5,f1.getNumberOfTuples());
3689         values1=[-0.1,0.23333333333333336,0.56666666666666665,0.4,0.9]
3690         tmp=f1.getArray().getValues();
3691         self.assertEqual(len(values1),len(tmp))
3692         for i in xrange(len(values1)):
3693             self.assertTrue(abs(values1[i]-tmp[i])<1.e-12);
3694             pass
3695         #
3696         f1=MEDCouplingFieldDouble.New(ON_NODES,CONST_ON_TIME_INTERVAL)
3697         f1.setMesh(m)
3698         f1.fillFromAnalytic(1,"y+2*x");
3699         f1.setEndTime(1.2,3,4);
3700         f1.checkCoherency();
3701         self.assertEqual(f1.getTypeOfField(),ON_NODES);
3702         self.assertEqual(f1.getTimeDiscretization(),CONST_ON_TIME_INTERVAL);
3703         self.assertEqual(1,f1.getNumberOfComponents());
3704         self.assertEqual(9,f1.getNumberOfTuples());
3705         values2=[-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1]
3706         tmp=f1.getArray().getValues();
3707         self.assertEqual(len(values2),len(tmp))
3708         for i in xrange(len(values2)):
3709             self.assertTrue(abs(values2[i]-tmp[i])<1.e-12);
3710             pass
3711         f1=MEDCouplingFieldDouble.New(ON_NODES,LINEAR_TIME);
3712         f1.setMesh(m)
3713         f1.fillFromAnalytic(1,"2.*x+y");
3714         f1.setEndTime(1.2,3,4);
3715         f1.checkCoherency();
3716         self.assertEqual(f1.getTypeOfField(),ON_NODES);
3717         self.assertEqual(f1.getTimeDiscretization(),LINEAR_TIME);
3718         self.assertEqual(1,f1.getNumberOfComponents());
3719         self.assertEqual(9,f1.getNumberOfTuples());
3720         tmp=f1.getArray().getValues();
3721         values2Bis=[-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1]
3722         self.assertEqual(len(values2Bis),len(tmp))
3723         for i in xrange(len(values2Bis)):
3724             self.assertTrue(abs(values2Bis[i]-tmp[i])<1.e-12);
3725             pass
3726         tmp=f1.getEndArray().getValues();
3727         self.assertEqual(len(values2Bis),len(tmp))
3728         for i in xrange(len(values2Bis)):
3729             self.assertTrue(abs(values2Bis[i]-tmp[i])<1.e-12);
3730             pass
3731         #
3732         f1=MEDCouplingFieldDouble.New(ON_NODES,ONE_TIME);
3733         f1.setMesh(m)
3734         f1.fillFromAnalytic(2,"(x+y)*IVec+2*(x+y)*JVec");
3735         f1.checkCoherency();
3736         self.assertEqual(f1.getTypeOfField(),ON_NODES);
3737         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
3738         self.assertEqual(2,f1.getNumberOfComponents());
3739         self.assertEqual(9,f1.getNumberOfTuples());
3740         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]
3741         tmp=f1.getArray().getValues();
3742         self.assertEqual(len(values3),len(tmp))
3743         for i in xrange(len(values3)):
3744             self.assertTrue(abs(values3[i]-tmp[i])<1.e-12);
3745             pass
3746         values4=f1.accumulate();
3747         self.assertTrue(abs(3.6-values4[0])<1.e-12);
3748         self.assertTrue(abs(7.2-values4[1])<1.e-12);
3749         values4=f1.integral(True);
3750         self.assertTrue(abs(0.5-values4[0])<1.e-12);
3751         self.assertTrue(abs(1.-values4[1])<1.e-12);
3752         #
3753         f1=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
3754         f1.setMesh(m);
3755         self.assertRaises(InterpKernelException,f1.fillFromAnalytic,1,"1./(x-0.2)");
3756         pass
3757
3758     def testFieldDoubleOpEqual1(self):
3759         m=MEDCouplingDataForTest.build2DTargetMesh_1();
3760         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3761         self.assertRaises(InterpKernelException,f1.assign,0.07);
3762         f1.setMesh(m);
3763         f1.assign(0.07);
3764         f1.checkCoherency();
3765         self.assertEqual(1,f1.getNumberOfComponents());
3766         self.assertEqual(5,f1.getNumberOfTuples());
3767         for i in xrange(5):
3768             self.assertAlmostEqual(0.07,f1.getIJ(i,0),16);
3769             pass
3770         f1.assign(0.09);
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.09,f1.getIJ(i,0),16);
3776             pass
3777         #
3778         f1=MEDCouplingFieldDouble.New(ON_NODES,LINEAR_TIME);
3779         f1.setEndTime(4.5,2,3);
3780         f1.setMesh(m);
3781         f1.assign(0.08);
3782         f1.checkCoherency();
3783         self.assertEqual(1,f1.getNumberOfComponents());
3784         self.assertEqual(9,f1.getNumberOfTuples());
3785         for i in xrange(9):
3786             self.assertAlmostEqual(0.08,f1.getIJ(i,0),16);
3787             pass
3788         self.assertEqual(1,f1.getEndArray().getNumberOfComponents());
3789         self.assertEqual(9,f1.getEndArray().getNumberOfTuples());
3790         for i in xrange(9):
3791             self.assertAlmostEqual(0.08,f1.getEndArray().getIJ(i,0),16);
3792             pass
3793         pass
3794
3795     def testAreaBary3D2(self):
3796         coordsForHexa8=[-75.45749305371, 180.95495078401, 39.515472018008,
3797                         -9.755591679144, 23.394927935279, 5.108794294848,
3798                         14.337630157832, 61.705351002702, 160.42422501908,
3799                         -27.273893776752, 167.567731083961, 192.830034145464,
3800                         99.857193154796,264.499264735586,-8.287335493412,
3801                         144.939882761126,156.38626563134,-31.896173894226,
3802                         161.34096835726,182.4654895809,73.832387065572,
3803                         132.680430393685,255.37973247196,96.15235602819];
3804         volHexa8=3258520.29637466;
3805         baryHexa8=[43.925705821778, 155.31893955289, 65.874418109644]
3806
3807         coordsForPenta6=[-68.199829618726,178.938498373416,62.608505919588,
3808                          8.461744647847,76.653979804423,165.00018874933,
3809                          -27.273893776752,167.567731083961,192.830034145464,
3810                          106.586501038965,262.629609408327,13.124533008813,
3811                          155.465082847275,197.414118382622,78.408350795821,
3812                          132.680430393685,255.37973247196,96.15235602819];
3813         volPenta6=944849.868507338;
3814         baryPenta6=[39.631002313543,182.692711783428,106.98540473964]
3815
3816         coordsForPyra5=[132.680430393685,255.37973247196,96.15235602819,
3817                         -27.273893776752,167.567731083961,192.830034145464,
3818                         8.461744647847,76.653979804423,165.00018874933,
3819                         155.465082847275,197.414118382622,78.408350795821,
3820                         -68.199829618726,178.938498373416,62.608505919588];
3821         volPyra5=756943.92980254;
3822         baryPyra5=[29.204294116618,172.540129749156,118.01035951483]
3823         mesh=MEDCouplingUMesh.New("Bary3D2",3);
3824         coo=DataArrayDouble.New();
3825         tmp=coordsForHexa8+coordsForPenta6+coordsForPyra5
3826         coo.setValues(tmp,19,3);
3827         mesh.setCoords(coo);
3828         #
3829         tmpConn=[0,1,2,3,4,5,6,7]
3830         mesh.allocateCells(3);
3831         self.assertRaises(InterpKernelException,mesh.insertNextCell,NORM_HEXA8,9,tmpConn[0:8])
3832         mesh.insertNextCell(NORM_HEXA8,tmpConn[0:8])
3833         mesh.insertNextCell(NORM_PENTA6,6,[i+8 for i in tmpConn])
3834         mesh.insertNextCell(NORM_PYRA5,5,[i+14 for i in tmpConn])
3835         mesh.finishInsertingCells();
3836         mesh.checkCoherency();
3837         mesh.mergeNodes(1e-7)
3838         self.assertEqual(12,mesh.getNumberOfNodes());
3839         vols=mesh.getMeasureField(True);
3840         self.assertEqual(3,vols.getNumberOfTuples());
3841         self.assertEqual(1,vols.getNumberOfComponents());
3842         self.assertAlmostEqual(volHexa8,vols.getIJ(0,0),6);
3843         self.assertAlmostEqual(volPenta6,vols.getIJ(1,0),7);
3844         self.assertAlmostEqual(volPyra5,vols.getIJ(2,0),7);
3845         bary=mesh.getBarycenterAndOwner();
3846         self.assertEqual(3,bary.getNumberOfTuples());
3847         self.assertEqual(3,bary.getNumberOfComponents());
3848         self.assertAlmostEqual(baryHexa8[0],bary.getIJ(0,0),11);
3849         self.assertAlmostEqual(baryHexa8[1],bary.getIJ(0,1),11);
3850         self.assertAlmostEqual(baryHexa8[2],bary.getIJ(0,2),11);
3851         self.assertAlmostEqual(baryPenta6[0],bary.getIJ(1,0),11);
3852         self.assertAlmostEqual(baryPenta6[1],bary.getIJ(1,1),11);
3853         self.assertAlmostEqual(baryPenta6[2],bary.getIJ(1,2),11);
3854         self.assertAlmostEqual(baryPyra5[0],bary.getIJ(2,0),11);
3855         self.assertAlmostEqual(baryPyra5[1],bary.getIJ(2,1),11);
3856         self.assertAlmostEqual(baryPyra5[2],bary.getIJ(2,2),11);
3857         pass
3858
3859     def testGetMeasureFieldCMesh1(self):
3860         m=MEDCouplingCMesh.New();
3861         da=DataArrayDouble.New();
3862         discX=[2.3,3.4,5.8,10.2]
3863         discY=[12.3,23.4,45.8]
3864         discZ=[-0.7,1.2,1.25,2.13,2.67]
3865         da.setValues(discX,4,1);
3866         m.setCoordsAt(0,da);
3867         m.checkCoherency();
3868         self.assertEqual(4,m.getNumberOfNodes());
3869         self.assertEqual(3,m.getNumberOfCells());
3870         self.assertEqual(1,m.getSpaceDimension());
3871         f=m.getMeasureField(True);
3872         self.assertEqual(3,f.getNumberOfTuples());
3873         self.assertEqual(1,f.getNumberOfComponents());
3874         expected1=[1.1,2.4,4.4]
3875         for i in xrange(3):
3876             self.assertAlmostEqual(expected1[i],f.getIJ(i,0),12);
3877             pass
3878         coords=m.getCoordinatesAndOwner();
3879         self.assertEqual(4,coords.getNumberOfTuples());
3880         self.assertEqual(1,coords.getNumberOfComponents());
3881         for i in xrange(4):
3882             self.assertAlmostEqual(discX[i],coords.getIJ(i,0),12);
3883             pass
3884         coords=m.getBarycenterAndOwner();
3885         self.assertEqual(3,coords.getNumberOfTuples());
3886         self.assertEqual(1,coords.getNumberOfComponents());
3887         expected1_3=[2.85,4.6,8.]
3888         for i in xrange(3):
3889             self.assertAlmostEqual(expected1_3[i],coords.getIJ(i,0),12);
3890             pass
3891         #
3892         da=DataArrayDouble.New();
3893         da.setValues(discY,3,1);
3894         m.setCoordsAt(1,da);
3895         m.checkCoherency();
3896         self.assertEqual(12,m.getNumberOfNodes());
3897         self.assertEqual(6,m.getNumberOfCells());
3898         self.assertEqual(2,m.getSpaceDimension());
3899         f=m.getMeasureField(True);
3900         self.assertEqual(6,f.getNumberOfTuples());
3901         self.assertEqual(1,f.getNumberOfComponents());
3902         expected2=[12.21,26.64,48.84,24.64,53.76,98.56]
3903         for i in xrange(6):
3904             self.assertAlmostEqual(expected2[i],f.getIJ(i,0),12);
3905             pass
3906         coords=m.getCoordinatesAndOwner();
3907         self.assertEqual(12,coords.getNumberOfTuples());
3908         self.assertEqual(2,coords.getNumberOfComponents());
3909         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]
3910         for i in xrange(24):
3911             self.assertAlmostEqual(expected2_2[i],coords.getIJ(0,i),12);
3912             pass
3913         coords=m.getBarycenterAndOwner();
3914         self.assertEqual(6,coords.getNumberOfTuples());
3915         self.assertEqual(2,coords.getNumberOfComponents());
3916         expected2_3=[2.85,17.85,4.6,17.85,8.,17.85, 2.85,34.6,4.6,34.6,8.,34.6]
3917         for i in xrange(12):
3918             self.assertAlmostEqual(expected2_3[i],coords.getIJ(0,i),12);
3919             pass
3920         #
3921         da=DataArrayDouble.New();
3922         da.setValues(discZ,5,1);
3923         m.setCoordsAt(2,da);
3924         m.checkCoherency();
3925         self.assertEqual(60,m.getNumberOfNodes());
3926         self.assertEqual(24,m.getNumberOfCells());
3927         self.assertEqual(3,m.getSpaceDimension());
3928         f=m.getMeasureField(True);
3929         self.assertEqual(24,f.getNumberOfTuples());
3930         self.assertEqual(1,f.getNumberOfComponents());
3931         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]
3932         for i in xrange(24):
3933             self.assertAlmostEqual(expected3[i],f.getIJ(i,0),12);
3934             pass
3935         coords=m.getCoordinatesAndOwner();
3936         self.assertEqual(60,coords.getNumberOfTuples());
3937         self.assertEqual(3,coords.getNumberOfComponents());
3938         expected3_2=[
3939             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,
3940             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,
3941             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,
3942             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,
3943             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];
3944         for i in xrange(180):
3945             self.assertAlmostEqual(expected3_2[i],coords.getIJ(0,i),12);
3946             pass
3947         coords=m.getBarycenterAndOwner();
3948         self.assertEqual(24,coords.getNumberOfTuples());
3949         self.assertEqual(3,coords.getNumberOfComponents());
3950         expected3_3=[
3951             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,
3952             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,
3953             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,
3954             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];
3955         for i in xrange(72):
3956             self.assertAlmostEqual(expected3_3[i],coords.getIJ(0,i),12);
3957             pass
3958         pass
3959
3960     def testFieldDoubleZipCoords1(self):
3961         m=MEDCouplingDataForTest.build2DTargetMeshMergeNode_1();
3962         f=m.fillFromAnalytic(ON_NODES,2,"x*2.");
3963         f.getArray().setInfoOnComponent(0,"titi");
3964         f.getArray().setInfoOnComponent(1,"tutu");
3965         f.checkCoherency();
3966         self.assertEqual(18,f.getNumberOfTuples());
3967         self.assertEqual(2,f.getNumberOfComponents());
3968         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]
3969         for i in xrange(36):
3970             self.assertAlmostEqual(expected1[i],f.getIJ(0,i),12);
3971             pass
3972         self.assertTrue(f.zipCoords());
3973         f.checkCoherency();
3974         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]
3975         for i in xrange(30):
3976             self.assertAlmostEqual(expected2[i],f.getIJ(0,i),12);
3977             pass
3978         self.assertTrue(not f.zipCoords());
3979         f.checkCoherency();
3980         for i in xrange(30):
3981             self.assertAlmostEqual(expected2[i],f.getIJ(0,i),12);
3982             pass
3983         self.assertTrue(f.getArray().getInfoOnComponent(0)=="titi");
3984         self.assertTrue(f.getArray().getInfoOnComponent(1)=="tutu");
3985         pass
3986
3987     def testFieldDoubleZipConnectivity1(self):
3988         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
3989         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
3990         cells1=[2,3,4]
3991         m3_1=m2.buildPartOfMySelf(cells1,True);
3992         m3=m3_1;
3993         m4=MEDCouplingDataForTest.build2DSourceMesh_1();
3994         m5=MEDCouplingUMesh.MergeUMeshes(m1,m3);
3995         m6=MEDCouplingUMesh.MergeUMeshes(m5,m4);
3996         #
3997         self.assertEqual(10,m6.getNumberOfCells());
3998         self.assertEqual(22,m6.getNumberOfNodes());
3999         arr,areNodesMerged,newNbOfNodes=m6.mergeNodes(1e-13);
4000         self.assertEqual(9,m6.getNumberOfNodes());
4001         f=m6.fillFromAnalytic(ON_CELLS,2,"x");
4002         f2=m6.fillFromAnalytic(ON_NODES,2,"x");
4003         self.assertEqual(10,f.getNumberOfTuples());
4004         self.assertEqual(2,f.getNumberOfComponents());
4005         expected1=[-0.05, -0.05, 0.3666666666666667, 0.3666666666666667, 0.53333333333333321, 0.53333333333333321,
4006                    -0.05, -0.05, 0.45, 0.45, 0.53333333333333321, 0.53333333333333321, -0.05, -0.05, 0.45, 0.45,
4007                    0.36666666666666659, 0.36666666666666659, 0.033333333333333326, 0.033333333333333326];
4008         for i in xrange(20):
4009             self.assertAlmostEqual(expected1[i],f.getIJ(0,i),12);
4010             pass
4011         f.getArray().setInfoOnComponent(0,"titi");
4012         f.getArray().setInfoOnComponent(1,"tutu");
4013         f.checkCoherency();
4014         self.assertTrue(f.zipConnectivity(0));
4015         expected2=[-0.05, -0.05, 0.3666666666666667, 0.3666666666666667, 0.53333333333333321, 0.53333333333333321,
4016                    -0.05, -0.05, 0.45, 0.45, 0.36666666666666659, 0.36666666666666659, 0.033333333333333326, 0.033333333333333326];
4017         self.assertEqual(7,f.getNumberOfTuples());
4018         self.assertEqual(2,f.getNumberOfComponents());
4019         for i in xrange(14):
4020             self.assertAlmostEqual(expected2[i],f.getIJ(0,i),12);
4021             pass
4022         self.assertTrue(f.getArray().getInfoOnComponent(0)=="titi");
4023         self.assertTrue(f.getArray().getInfoOnComponent(1)=="tutu");
4024         self.assertTrue(not f.zipConnectivity(0));
4025         #
4026         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,
4027                    -0.3, -0.3, 0.2, 0.2, 0.7, 0.7];
4028         self.assertEqual(9,f2.getNumberOfTuples());
4029         self.assertEqual(2,f2.getNumberOfComponents());
4030         for i in xrange(18):
4031             self.assertAlmostEqual(expected3[i],f2.getIJ(0,i),12);
4032             pass
4033         self.assertTrue(f2.zipConnectivity(0));
4034         self.assertEqual(9,f2.getNumberOfTuples());
4035         self.assertEqual(2,f2.getNumberOfComponents());
4036         for i in xrange(18):
4037             self.assertAlmostEqual(expected3[i],f2.getIJ(0,i),12);
4038             pass
4039         pass
4040
4041     def testDaDoubleRenumber1(self):
4042         a=DataArrayDouble.New();
4043         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]
4044         a.setValues(arr1,7,2);
4045         a.setInfoOnComponent(0,"toto");
4046         a.setInfoOnComponent(1,"tata");
4047         #
4048         arr2=[3,1,0,6,5,4,2]
4049         b=a.renumber(arr2);
4050         self.assertEqual(7,b.getNumberOfTuples());
4051         self.assertEqual(2,b.getNumberOfComponents());
4052         self.assertTrue(b.getInfoOnComponent(0)=="toto");
4053         self.assertTrue(b.getInfoOnComponent(1)=="tata");
4054         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]
4055         for i in xrange(14):
4056             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
4057             pass
4058         #
4059         c=DataArrayInt.New();
4060         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4061         c.setValues(arr3,7,2);
4062         c.setInfoOnComponent(0,"toto");
4063         c.setInfoOnComponent(1,"tata");
4064         d=c.renumber(arr2);
4065         self.assertEqual(7,d.getNumberOfTuples());
4066         self.assertEqual(2,d.getNumberOfComponents());
4067         self.assertTrue(d.getInfoOnComponent(0)=="toto");
4068         self.assertTrue(d.getInfoOnComponent(1)=="tata");
4069         expected2=[3, 13, 2, 12, 7, 17, 1, 11, 6, 16, 5, 15, 4, 14]
4070         for i in xrange(14):
4071             self.assertEqual(expected2[i],d.getIJ(0,i));
4072             pass
4073         pass
4074
4075     def testDaDoubleRenumberAndReduce1(self):
4076         a=DataArrayDouble.New();
4077         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]
4078         a.setValues(arr1,7,2);
4079         a.setInfoOnComponent(0,"toto");
4080         a.setInfoOnComponent(1,"tata");
4081         #
4082         arr2=[2,-1,1,-1,0,4,3]
4083         b=a.renumberAndReduce(arr2,5);
4084         self.assertEqual(5,b.getNumberOfTuples());
4085         self.assertEqual(2,b.getNumberOfComponents());
4086         self.assertTrue(b.getInfoOnComponent(0)=="toto");
4087         self.assertTrue(b.getInfoOnComponent(1)=="tata");
4088         expected1=[5.1,15.1,3.1,13.1,1.1,11.1,7.1,17.1,6.1,16.1]
4089         for i in xrange(10):
4090             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
4091             pass
4092         #
4093         c=DataArrayInt.New();
4094         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4095         c.setValues(arr3,7,2);
4096         c.setInfoOnComponent(0,"toto");
4097         c.setInfoOnComponent(1,"tata");
4098         d=c.renumberAndReduce(arr2,5);
4099         self.assertEqual(5,d.getNumberOfTuples());
4100         self.assertEqual(2,d.getNumberOfComponents());
4101         self.assertTrue(d.getInfoOnComponent(0)=="toto");
4102         self.assertTrue(d.getInfoOnComponent(1)=="tata");
4103         expected2=[5,15,3,13,1,11,7,17,6,16]
4104         for i in xrange(10):
4105             self.assertEqual(expected2[i],d.getIJ(0,i));
4106             pass
4107         pass
4108
4109     def testDaDoubleRenumberInPlace1(self):
4110         a=DataArrayDouble.New();
4111         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]
4112         a.setValues(arr1,7,2);
4113         #
4114         arr2=[3,1,0,6,5,4,2]
4115         a.renumberInPlace(arr2);
4116         self.assertEqual(7,a.getNumberOfTuples());
4117         self.assertEqual(2,a.getNumberOfComponents());
4118         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]
4119         for i in xrange(14):
4120             self.assertAlmostEqual(expected1[i],a.getIJ(0,i),14);
4121             pass
4122         #
4123         c=DataArrayInt.New();
4124         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4125         c.setValues(arr3,7,2);
4126         c.renumberInPlace(arr2);
4127         self.assertEqual(7,c.getNumberOfTuples());
4128         self.assertEqual(2,c.getNumberOfComponents());
4129         expected2=[3, 13, 2, 12, 7, 17, 1, 11, 6, 16, 5, 15, 4, 14]
4130         for i in xrange(14):
4131             self.assertEqual(expected2[i],c.getIJ(0,i));
4132             pass
4133         pass
4134
4135     def testDaDoubleRenumberR1(self):
4136         a=DataArrayDouble.New();
4137         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]
4138         a.setValues(arr1,7,2);
4139         a.setInfoOnComponent(0,"toto");
4140         a.setInfoOnComponent(1,"tata");
4141         #
4142         arr2=[3,1,0,6,5,4,2]
4143         b=a.renumberR(arr2);
4144         self.assertEqual(7,b.getNumberOfTuples());
4145         self.assertEqual(2,b.getNumberOfComponents());
4146         self.assertTrue(b.getInfoOnComponent(0)=="toto");
4147         self.assertTrue(b.getInfoOnComponent(1)=="tata");
4148         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]
4149         for i in xrange(14):
4150             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
4151             pass
4152         #
4153         c=DataArrayInt.New();
4154         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4155         c.setValues(arr3,7,2);
4156         c.setInfoOnComponent(0,"toto");
4157         c.setInfoOnComponent(1,"tata");
4158         d=c.renumberR(arr2);
4159         self.assertEqual(7,d.getNumberOfTuples());
4160         self.assertEqual(2,d.getNumberOfComponents());
4161         self.assertTrue(d.getInfoOnComponent(0)=="toto");
4162         self.assertTrue(d.getInfoOnComponent(1)=="tata");
4163         expected2=[4, 14, 2, 12, 1, 11, 7, 17, 6, 16, 5, 15, 3, 13]
4164         for i in xrange(14):
4165             self.assertEqual(expected2[i],d.getIJ(0,i));
4166             pass
4167         pass
4168
4169     def testDaDoubleRenumberInPlaceR1(self):
4170         a=DataArrayDouble.New();
4171         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]
4172         a.setValues(arr1,7,2);
4173         #
4174         arr2=[3,1,0,6,5,4,2]
4175         a.renumberInPlaceR(arr2);
4176         self.assertEqual(7,a.getNumberOfTuples());
4177         self.assertEqual(2,a.getNumberOfComponents());
4178         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]
4179         for i in xrange(14):
4180             self.assertAlmostEqual(expected1[i],a.getIJ(0,i),14);
4181             pass
4182         #
4183         c=DataArrayInt.New();
4184         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4185         c.setValues(arr3,7,2);
4186         c.renumberInPlaceR(arr2);
4187         self.assertEqual(7,c.getNumberOfTuples());
4188         self.assertEqual(2,c.getNumberOfComponents());
4189         expected2=[4, 14, 2, 12, 1, 11, 7, 17, 6, 16, 5, 15, 3, 13]
4190         for i in xrange(14):
4191             self.assertEqual(expected2[i],c.getIJ(0,i));
4192             pass
4193         pass
4194
4195     def testDaDoubleSelectByTupleId1(self):
4196         a=DataArrayDouble.New();
4197         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]
4198         a.setValues(arr1,7,2);
4199         a.setInfoOnComponent(0,"toto");
4200         a.setInfoOnComponent(1,"tata");
4201         #
4202         arr2=[4,2,0,6,5]
4203         b=a.selectByTupleId(arr2);
4204         self.assertEqual(5,b.getNumberOfTuples());
4205         self.assertEqual(2,b.getNumberOfComponents());
4206         self.assertTrue(b.getInfoOnComponent(0)=="toto");
4207         self.assertTrue(b.getInfoOnComponent(1)=="tata");
4208         expected1=[5.1,15.1,3.1,13.1,1.1,11.1,7.1,17.1,6.1,16.1]
4209         for i in xrange(10):
4210             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
4211             pass
4212         #
4213         c=DataArrayInt.New();
4214         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4215         c.setValues(arr3,7,2);
4216         c.setInfoOnComponent(0,"toto");
4217         c.setInfoOnComponent(1,"tata");
4218         d=c.selectByTupleId(arr2);
4219         self.assertEqual(5,d.getNumberOfTuples());
4220         self.assertEqual(2,d.getNumberOfComponents());
4221         self.assertTrue(d.getInfoOnComponent(0)=="toto");
4222         self.assertTrue(d.getInfoOnComponent(1)=="tata");
4223         expected2=[5,15,3,13,1,11,7,17,6,16]
4224         for i in xrange(10):
4225             self.assertEqual(expected2[i],d.getIJ(0,i));
4226             pass
4227         pass
4228
4229     def testDaDoubleGetMinMaxValues1(self):
4230         a=DataArrayDouble.New();
4231         arr1=[2.34,4.56,-6.77,4.55,4.56,2.24,2.34,1.02,4.56]
4232         a.setValues(arr1,9,1);
4233         m,where=a.getMaxValue();
4234         self.assertEqual(1,where);
4235         self.assertAlmostEqual(4.56,m,12);
4236         m,ws=a.getMaxValue2();
4237         self.assertAlmostEqual(4.56,m,12);
4238         self.assertEqual(3,ws.getNumberOfTuples());
4239         self.assertEqual(1,ws.getNumberOfComponents());
4240         expected1=[1,4,8]
4241         for i in xrange(3):
4242             self.assertEqual(expected1[i],ws.getIJ(i,0));
4243             pass
4244         a=DataArrayDouble.New();
4245         arr2=[-2.34,-4.56,6.77,-4.55,-4.56,-2.24,-2.34,-1.02,-4.56]
4246         a.setValues(arr2,9,1);
4247         m,where=a.getMinValue();
4248         self.assertEqual(1,where);
4249         self.assertAlmostEqual(-4.56,m,12);
4250         m,ws=a.getMinValue2();
4251         self.assertAlmostEqual(-4.56,m,12);
4252         self.assertEqual(3,ws.getNumberOfTuples());
4253         self.assertEqual(1,ws.getNumberOfComponents());
4254         for i in xrange(3):
4255             self.assertEqual(expected1[i],ws.getIJ(i,0));
4256             pass
4257         pass
4258
4259     def testFieldDoubleGetMinMaxValues2(self):
4260         m2,m1=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
4261         self.assertEqual(18,m2.getNumberOfCells());
4262         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]
4263         f=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
4264         a=DataArrayDouble.New();
4265         a.setValues(arr1,18,1);
4266         f.setArray(a);
4267         f.setMesh(m2);
4268         #
4269         f.checkCoherency();
4270         m=f.getMaxValue();
4271         self.assertAlmostEqual(8.71,m,12);
4272         m,ws=f.getMaxValue2();
4273         self.assertAlmostEqual(8.71,m,12);
4274         self.assertEqual(4,ws.getNumberOfTuples());
4275         self.assertEqual(1,ws.getNumberOfComponents());
4276         expected1=[0,3,7,17]
4277         for i in xrange(4):
4278             self.assertEqual(expected1[i],ws.getIJ(i,0));
4279             pass
4280         #
4281         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]
4282         a.setValues(arr2,18,1);
4283         f.checkCoherency();
4284         m=f.getMinValue();
4285         self.assertAlmostEqual(-8.71,m,12);
4286         m,ws=f.getMinValue2();
4287         self.assertAlmostEqual(-8.71,m,12);
4288         self.assertEqual(4,ws.getNumberOfTuples());
4289         self.assertEqual(1,ws.getNumberOfComponents());
4290         for i in xrange(4):
4291             self.assertEqual(expected1[i],ws.getIJ(i,0));
4292             pass
4293         pass
4294
4295     def testBuildUnstructuredCMesh1(self):
4296         m=MEDCouplingCMesh.New();
4297         da=DataArrayDouble.New();
4298         discX=[2.3,3.4,5.8,10.2]
4299         discY=[12.3,23.4,45.8]
4300         discZ=[-0.7,1.2,1.25,2.13,2.67]
4301         da.setValues(discX,4,1);
4302         m.setCoordsAt(0,da);
4303         m.checkCoherency();
4304         self.assertEqual(0,m.getCellContainingPoint([2.4],1e-12));
4305         self.assertEqual(1,m.getCellContainingPoint([3.7],1e-12));
4306         self.assertEqual(2,m.getCellContainingPoint([5.9],1e-12));
4307         self.assertEqual(-1,m.getCellContainingPoint([10.3],1e-12));
4308         self.assertEqual(-1,m.getCellContainingPoint([1.3],1e-12));
4309         #
4310         m2=m.buildUnstructured();
4311         m2.checkCoherency();
4312         f1=m.getMeasureField(False);
4313         f2=m2.getMeasureField(False);
4314         self.assertTrue(isinstance(f1.getMesh(),MEDCouplingCMesh))
4315         self.assertEqual(f1.getNumberOfTuples(),3);
4316         self.assertEqual(f2.getNumberOfTuples(),3);
4317         self.assertEqual(1,m2.getMeshDimension());
4318         self.assertEqual(1,m2.getSpaceDimension());
4319         for i in xrange(3):
4320             self.assertAlmostEqual(f1.getIJ(i,0),f2.getIJ(i,0),10);
4321             pass
4322         da=DataArrayDouble.New();
4323         da.setValues(discY,3,1);
4324         m.setCoordsAt(1,da);
4325         #
4326         m2=m.buildUnstructured();
4327         m2.checkCoherency();
4328         f1=m.getMeasureField(False);
4329         f2=m2.getMeasureField(False);
4330         self.assertEqual(f1.getNumberOfTuples(),6);
4331         self.assertEqual(f2.getNumberOfTuples(),6);
4332         self.assertEqual(2,m2.getMeshDimension());
4333         self.assertEqual(2,m2.getSpaceDimension());
4334         for i in xrange(6):
4335             self.assertAlmostEqual(f1.getIJ(i,0),f2.getIJ(i,0),10);
4336             pass
4337         #
4338         da=DataArrayDouble.New();
4339         da.setValues(discZ,5,1);
4340         m.setCoordsAt(2,da);
4341         m2=m.buildUnstructured();
4342         m2.checkCoherency();
4343         f1=m.getMeasureField(False);
4344         f2=m2.getMeasureField(False);
4345         self.assertEqual(f1.getNumberOfTuples(),24);
4346         self.assertEqual(f2.getNumberOfTuples(),24);
4347         self.assertEqual(3,m2.getMeshDimension());
4348         self.assertEqual(3,m2.getSpaceDimension());
4349         for i in xrange(24):
4350             self.assertAlmostEqual(f1.getIJ(i,0),f2.getIJ(i,0),10);
4351             pass
4352         #
4353         pos1=[5.,30.,2.]
4354         self.assertEqual(16,m.getCellContainingPoint(pos1,1e-12));
4355         #
4356         elems=m2.getCellsInBoundingBox([3.5,6.,12.2,25.,0.,1.5],1e-7)
4357         self.assertEqual([1, 2, 4, 5, 7, 8, 10, 11, 13, 14, 16, 17],elems.getValues())
4358         #
4359         pt=[2.4,12.7,-3.4]
4360         m.scale(pt,3.7);
4361         m3=m.buildUnstructured();
4362         m2.scale(pt,3.7);
4363         self.assertTrue(m3.isEqual(m2,1e-12));
4364         pass
4365
4366     def testDataArrayIntInvertO2NNO21(self):
4367         arr1=[2,0,4,1,5,3]
4368         da=DataArrayInt.New();
4369         da.setValues(arr1,6,1);
4370         da2=da.invertArrayO2N2N2O(6);
4371         self.assertEqual(6,da2.getNumberOfTuples());
4372         self.assertEqual(1,da2.getNumberOfComponents());
4373         expected1=[1,3,0,5,2,4]
4374         for i in xrange(6):
4375             self.assertEqual(expected1[i],da2.getIJ(i,0));
4376             pass
4377         da3=da2.invertArrayN2O2O2N(6);
4378         for i in xrange(6):
4379             self.assertEqual(arr1[i],da3.getIJ(i,0));
4380             pass
4381         #
4382         arr2=[3,-1,5,4,-1,0,-1,1,2,-1]
4383         da=DataArrayInt.New();
4384         da.setValues(arr2,10,1);
4385         da2=da.invertArrayO2N2N2O(6);
4386         self.assertEqual(6,da2.getNumberOfTuples());
4387         self.assertEqual(1,da2.getNumberOfComponents());
4388         expected2=[5,7,8,0,3,2]
4389         for i in xrange(6):
4390             self.assertEqual(expected2[i],da2.getIJ(i,0));
4391             pass
4392         da3=da2.invertArrayN2O2O2N(10);
4393         for i in xrange(10):
4394             self.assertEqual(arr2[i],da3.getIJ(i,0));
4395             pass
4396         pass
4397
4398     def testKeepSetSelectedComponent1(self):
4399         arr1=[1.,2.,3.,4., 11.,12.,13.,14., 21.,22.,23.,24., 31.,32.,33.,34., 41.,42.,43.,44.]
4400         a1=DataArrayDouble.New();
4401         a1.setValues(arr1,5,4);
4402         expp=[21.,22.,23.,24.]
4403         self.assertEqual(4,len(a1.getTuple(2)));
4404         for i in xrange(4):
4405             self.assertAlmostEqual(expp[i],a1.getTuple(2)[i],12)
4406             pass
4407         a1.setInfoOnComponent(0,"aaaa");
4408         a1.setInfoOnComponent(1,"bbbb");
4409         a1.setInfoOnComponent(2,"cccc");
4410         a1.setInfoOnComponent(3,"dddd");
4411         arr2V=[1,2,1,2,0,0]
4412         a2=a1.keepSelectedComponents(arr2V);
4413         self.assertEqual(6,a2.getNumberOfComponents());
4414         self.assertEqual(5,a2.getNumberOfTuples());
4415         self.assertTrue(a2.getInfoOnComponent(0)=="bbbb");
4416         self.assertTrue(a2.getInfoOnComponent(1)=="cccc");
4417         self.assertTrue(a2.getInfoOnComponent(2)=="bbbb");
4418         self.assertTrue(a2.getInfoOnComponent(3)=="cccc");
4419         self.assertTrue(a2.getInfoOnComponent(4)=="aaaa");
4420         self.assertTrue(a2.getInfoOnComponent(5)=="aaaa");
4421         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.]
4422         for i in xrange(30):
4423             self.assertAlmostEqual(expected1[i],a2.getIJ(0,i),14);
4424             pass
4425         a3=a1.convertToIntArr();
4426         self.assertEqual([21,22,23,24],a3.getTuple(2))
4427         a4=a3.keepSelectedComponents(arr2V);
4428         self.assertEqual(6,a4.getNumberOfComponents());
4429         self.assertEqual(5,a4.getNumberOfTuples());
4430         self.assertTrue(a4.getInfoOnComponent(0)=="bbbb");
4431         self.assertTrue(a4.getInfoOnComponent(1)=="cccc");
4432         self.assertTrue(a4.getInfoOnComponent(2)=="bbbb");
4433         self.assertTrue(a4.getInfoOnComponent(3)=="cccc");
4434         self.assertTrue(a4.getInfoOnComponent(4)=="aaaa");
4435         self.assertTrue(a4.getInfoOnComponent(5)=="aaaa");
4436         for i in xrange(30):
4437             self.assertEqual(int(expected1[i]),a4.getIJ(0,i));
4438             pass
4439         # setSelectedComponents
4440         arr3V=[3,2]
4441         a5=a1.keepSelectedComponents(arr3V);
4442         a5.setInfoOnComponent(0,"eeee");
4443         a5.setInfoOnComponent(1,"ffff");
4444         arr4V=[1,2]
4445         a2.setSelectedComponents(a5,arr4V);
4446         self.assertEqual(6,a2.getNumberOfComponents());
4447         self.assertEqual(5,a2.getNumberOfTuples());
4448         self.assertTrue(a2.getInfoOnComponent(0)=="bbbb");
4449         self.assertTrue(a2.getInfoOnComponent(1)=="eeee");
4450         self.assertTrue(a2.getInfoOnComponent(2)=="ffff");
4451         self.assertTrue(a2.getInfoOnComponent(3)=="cccc");
4452         self.assertTrue(a2.getInfoOnComponent(4)=="aaaa");
4453         self.assertTrue(a2.getInfoOnComponent(5)=="aaaa");
4454         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.]
4455         for i in xrange(30):
4456             self.assertAlmostEqual(expected2[i],a2.getIJ(0,i),14);
4457             pass
4458         a6=a5.convertToIntArr();
4459         a6.setInfoOnComponent(0,"eeee");
4460         a6.setInfoOnComponent(1,"ffff");
4461         a4.setSelectedComponents(a6,arr4V);
4462         self.assertEqual(6,a4.getNumberOfComponents());
4463         self.assertEqual(5,a4.getNumberOfTuples());
4464         self.assertTrue(a4.getInfoOnComponent(0)=="bbbb");
4465         self.assertTrue(a4.getInfoOnComponent(1)=="eeee");
4466         self.assertTrue(a4.getInfoOnComponent(2)=="ffff");
4467         self.assertTrue(a4.getInfoOnComponent(3)=="cccc");
4468         self.assertTrue(a4.getInfoOnComponent(4)=="aaaa");
4469         self.assertTrue(a4.getInfoOnComponent(5)=="aaaa");
4470         for i in xrange(30):
4471             self.assertEqual(int(expected2[i]),a4.getIJ(0,i));
4472             pass
4473         # test of throw
4474         arr5V=[2,3,6]
4475         arr6V=[2,7,5]
4476         arr7V=[2,1,4,6]
4477         self.assertRaises(InterpKernelException,a2.keepSelectedComponents,arr5V);
4478         self.assertRaises(InterpKernelException,a2.keepSelectedComponents,arr6V);
4479         self.assertRaises(InterpKernelException,a2.setSelectedComponents,a1,arr7V);
4480         arr7V=arr7V[0:3]
4481         self.assertRaises(InterpKernelException,a2.setSelectedComponents,a1,arr7V);
4482         #
4483         pass
4484
4485     def testKeepSetSelectedComponent2(self):
4486         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
4487         arr1=[1.,2.,3.,4., 11.,12.,13.,14., 21.,22.,23.,24., 31.,32.,33.,34., 41.,42.,43.,44.]
4488         a1=DataArrayDouble.New();
4489         a1.setValues(arr1,5,4);
4490         a1.setInfoOnComponent(0,"aaaa");
4491         a1.setInfoOnComponent(1,"bbbb");
4492         a1.setInfoOnComponent(2,"cccc");
4493         a1.setInfoOnComponent(3,"dddd");
4494         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
4495         f1.setTime(2.3,4,5);
4496         f1.setMesh(m1);
4497         f1.setName("f1");
4498         f1.setArray(a1);
4499         f1.checkCoherency();
4500         #
4501         arr2V=[1,2,1,2,0,0]
4502         f2=f1.keepSelectedComponents(arr2V);
4503         self.assertTrue(f2.getTimeDiscretization()==ONE_TIME);
4504         t,dt,it=f2.getTime()
4505         self.assertAlmostEqual(2.3,t,13);
4506         self.assertEqual(4,dt);
4507         self.assertEqual(5,it);
4508         f2.checkCoherency();
4509         self.assertEqual(6,f2.getNumberOfComponents());
4510         self.assertEqual(5,f2.getNumberOfTuples());
4511         self.assertTrue(f2.getArray().getInfoOnComponent(0)=="bbbb");
4512         self.assertTrue(f2.getArray().getInfoOnComponent(1)=="cccc");
4513         self.assertTrue(f2.getArray().getInfoOnComponent(2)=="bbbb");
4514         self.assertTrue(f2.getArray().getInfoOnComponent(3)=="cccc");
4515         self.assertTrue(f2.getArray().getInfoOnComponent(4)=="aaaa");
4516         self.assertTrue(f2.getArray().getInfoOnComponent(5)=="aaaa");
4517         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.]
4518         for i in xrange(30):
4519             self.assertAlmostEqual(expected1[i],f2.getIJ(0,i),14);
4520             pass
4521         #setSelectedComponents
4522         arr3V=[3,2]
4523         f5=f1.keepSelectedComponents(arr3V);
4524         f5.setTime(6.7,8,9);
4525         f5.getArray().setInfoOnComponent(0,"eeee");
4526         f5.getArray().setInfoOnComponent(1,"ffff");
4527         f5.checkCoherency();
4528         arr4V=[1,2]
4529         f2.setSelectedComponents(f5,arr4V);
4530         self.assertEqual(6,f2.getNumberOfComponents());
4531         self.assertEqual(5,f2.getNumberOfTuples());
4532         f2.checkCoherency();
4533         t,dt,it=f2.getTime()
4534         self.assertAlmostEqual(2.3,t,13);
4535         self.assertEqual(4,dt);
4536         self.assertEqual(5,it);
4537         self.assertTrue(f2.getArray().getInfoOnComponent(0)=="bbbb");
4538         self.assertTrue(f2.getArray().getInfoOnComponent(1)=="eeee");
4539         self.assertTrue(f2.getArray().getInfoOnComponent(2)=="ffff");
4540         self.assertTrue(f2.getArray().getInfoOnComponent(3)=="cccc");
4541         self.assertTrue(f2.getArray().getInfoOnComponent(4)=="aaaa");
4542         self.assertTrue(f2.getArray().getInfoOnComponent(5)=="aaaa");
4543         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.]
4544         for i in xrange(30):
4545             self.assertAlmostEqual(expected2[i],f2.getIJ(0,i),14);
4546             pass
4547         #
4548         pass
4549
4550     def testElementaryDAThrowAndSpecialCases(self):
4551         da=DataArrayInt.New();
4552         self.assertRaises(InterpKernelException, da.checkAllocated);
4553         self.assertRaises(InterpKernelException, da.fillWithValue, 1);
4554         self.assertRaises(InterpKernelException, da.iota, 1);
4555         da.alloc(7,1);
4556         da.fillWithValue(11); #11,11,11,11...
4557         da.iota(10); #10,11,12,13...
4558
4559         db=DataArrayInt.New();
4560         db.alloc(7,2);
4561
4562         dbl2=DataArrayDouble.New();
4563         dbl2.alloc(7,2);
4564         self.assertRaises(InterpKernelException, dbl2.isUniform, 10., 1e-15);
4565         self.assertRaises(InterpKernelException, dbl2.sort);
4566         self.assertRaises(InterpKernelException, dbl2.reverse);
4567         self.assertRaises(InterpKernelException, dbl2.iota, 10.);
4568
4569         dbl=DataArrayDouble.New();
4570         #DataArrayDouble not allocated yet
4571         self.assertRaises(InterpKernelException, dbl.iota, 10.);
4572         self.assertRaises(InterpKernelException, dbl.isUniform, 10., 1e-15);
4573         self.assertRaises(InterpKernelException, dbl.sort);
4574         self.assertRaises(InterpKernelException, dbl.reverse);
4575         self.assertRaises(InterpKernelException, dbl.fromNoInterlace);
4576         self.assertRaises(InterpKernelException, dbl.toNoInterlace);
4577
4578         dbl.alloc(7,1);
4579         dbl.iota(10.);
4580         self.assertTrue(not dbl.isUniform(10.,1e-15));
4581         dbl.sort();
4582         self.assertTrue(dbl.isMonotonic(True, .99));
4583         self.assertTrue(dbl.isMonotonic(True, -.99));
4584         self.assertTrue(not dbl.isMonotonic(True, 1.1));
4585         self.assertTrue(not dbl.isMonotonic(True, -1.1));
4586         dbl.reverse();
4587         self.assertTrue(dbl.isMonotonic(False, .99));
4588         self.assertTrue(not dbl.isMonotonic(False, 1.1));
4589         self.assertTrue(not dbl.isMonotonic(False, -1.1));
4590
4591         dc=DataArrayInt.New();
4592         dc.alloc(14,1);
4593
4594         dd=DataArrayDouble.New();
4595         self.assertRaises(InterpKernelException, dd.checkAllocated);
4596         self.assertRaises(InterpKernelException, dd.fillWithValue, 1.);
4597         self.assertRaises(InterpKernelException, dd.iota, 1.);
4598         self.assertTrue(not ((dd.repr().find("No data"))==-1));
4599
4600         dd.alloc(0,1); #Allocated but nbOfElements==0!
4601         self.assertTrue(not ((dd.repr().find("Number of tuples : 0"))==-1));
4602         self.assertTrue(not ((dd.repr().find("Empty Data"))==-1));
4603         dd.fillWithValue(11); #?!...ok
4604         dd.iota(10); #?!...ok
4605         self.assertTrue(dd.isMonotonic(True, 1.));  #nothing is monotonic
4606         self.assertTrue(dd.isMonotonic(False, 1.));
4607
4608         self.assertRaises(InterpKernelException, db.copyStringInfoFrom, da);
4609         self.assertRaises(InterpKernelException, db.copyStringInfoFrom, da);
4610         cIds=[2,2]
4611         self.assertRaises(InterpKernelException, da.copyPartOfStringInfoFrom, db, cIds);
4612         cIds[0]=1;
4613         cIds[0]=-1;
4614         self.assertRaises(InterpKernelException, da.copyPartOfStringInfoFrom, db, cIds);
4615
4616         info=["infoOfOneComponent"]*2;
4617         self.assertRaises(InterpKernelException, da.setInfoOnComponents, info);
4618         self.assertRaises(InterpKernelException, da.setInfoOnComponent, 1, info[0]);
4619         db.setInfoOnComponents(info);
4620
4621         self.assertRaises(InterpKernelException, da.getInfoOnComponent, -1);
4622         self.assertRaises(InterpKernelException, da.getInfoOnComponent, 2);
4623         self.assertTrue(db.getInfoOnComponent(1)==db.getInfoOnComponent(0));
4624         self.assertRaises(InterpKernelException, db.getVarOnComponent, -1);
4625         self.assertRaises(InterpKernelException, db.getVarOnComponent, 2);
4626         self.assertRaises(InterpKernelException, db.getUnitOnComponent, -1);
4627         self.assertRaises(InterpKernelException, db.getUnitOnComponent, 2);
4628
4629         self.assertTrue(da.GetVarNameFromInfo("varname unit ")=="varname unit ");
4630         self.assertTrue(da.GetVarNameFromInfo("varname]unit[")=="varname]unit[");
4631         self.assertTrue(da.GetVarNameFromInfo("[unit]")=="");
4632         self.assertTrue(da.GetVarNameFromInfo("varname [unit]")=="varname");
4633
4634         self.assertTrue(da.GetUnitFromInfo("varname unit ")=="");
4635         self.assertTrue(da.GetUnitFromInfo("varname]unit[")=="");
4636         self.assertTrue(da.GetUnitFromInfo("[unit]")=="unit");
4637         self.assertTrue(da.GetUnitFromInfo("varname [unit]")=="unit");
4638
4639         self.assertRaises(InterpKernelException, da.checkNbOfTuplesAndComp, db, "theMessageInThrow");
4640         self.assertRaises(InterpKernelException, da.checkNbOfTuplesAndComp, dc, "theMessageInThrow");
4641         self.assertRaises(InterpKernelException, db.checkNbOfTuplesAndComp, dc, "theMessageInThrow");
4642
4643         self.assertRaises(InterpKernelException, da.checkNbOfTuplesAndComp, 7, 2, "theMessageInThrow");
4644         da.checkNbOfTuplesAndComp(7,1,"theMessageInThrow");
4645
4646         self.assertRaises(InterpKernelException, db.checkNbOfElems, 7*2+1, "theMessageInThrow");
4647         db.checkNbOfElems(7*2,"theMessageInThrow");
4648
4649         self.assertRaises(InterpKernelException, db.GetNumberOfItemGivenBES, 10, 9, 1, "theMessageInThrow");
4650         self.assertRaises(InterpKernelException, db.GetNumberOfItemGivenBES, 0, 1, -1, "theMessageInThrow");
4651         self.assertEqual(10,db.GetNumberOfItemGivenBES(0,10,1,"theMessageInThrow"));
4652         self.assertEqual(5,db.GetNumberOfItemGivenBES(0,10,2,"theMessageInThrow"));
4653         self.assertEqual(6,db.GetNumberOfItemGivenBES(0,11,2,"theMessageInThrow"));
4654
4655         self.assertTrue(not ((da.repr().find("Number of components : 1"))==-1));
4656         self.assertTrue(not ((dd.repr().find("Number of components : 1"))==-1));
4657         self.assertTrue(not ((dbl.repr().find("Number of components : 1"))==-1));
4658
4659         self.assertTrue(not ((da.reprZip().find("Number of components : 1"))==-1));
4660         self.assertTrue(not ((dd.reprZip().find("Number of components : 1"))==-1));
4661         self.assertTrue(not ((dbl.reprZip().find("Number of components : 1"))==-1));
4662
4663         self.assertRaises(InterpKernelException, dbl.selectByTupleId2, 0, 1, -1);
4664         self.assertRaises(InterpKernelException, dbl.substr, -1, 1);
4665         self.assertRaises(InterpKernelException, dbl.substr, 8, 1);
4666         self.assertRaises(InterpKernelException, dbl.substr, 0, 8);
4667         self.assertRaises(InterpKernelException, dbl.meldWith, dd);
4668
4669         self.assertRaises(InterpKernelException, dbl.setPartOfValuesAdv, dbl2, da); #dbl dbl2 not have the same number of components
4670         self.assertRaises(InterpKernelException, dbl.setPartOfValuesAdv, dd, da);  #da tuple selector DataArrayInt instance not have exactly 2 components
4671
4672         dbl3=DataArrayDouble.New();
4673         dbl3.alloc(6,2);
4674         dbl3.fillWithValue(11.);
4675         #bad number of components
4676         self.assertRaises(InterpKernelException, dbl3.getMaxValue);
4677         self.assertRaises(InterpKernelException, dd.getMaxValue);
4678         self.assertRaises(InterpKernelException, dbl3.getMinValue);
4679         self.assertRaises(InterpKernelException, dd.getMinValue);
4680         self.assertRaises(InterpKernelException, dbl3.getAverageValue);
4681         self.assertRaises(InterpKernelException, dd.getAverageValue);
4682         self.assertRaises(InterpKernelException, dd.accumulate, 100);
4683         self.assertRaises(InterpKernelException, dbl.fromPolarToCart);
4684         self.assertRaises(InterpKernelException, dbl3.fromCylToCart);
4685         self.assertRaises(InterpKernelException, dbl3.fromSpherToCart);
4686         self.assertRaises(InterpKernelException, dbl3.doublyContractedProduct);
4687         self.assertRaises(InterpKernelException, dbl3.determinant);
4688         self.assertRaises(InterpKernelException, dbl3.eigenValues);
4689         self.assertRaises(InterpKernelException, dbl3.eigenVectors);
4690         self.assertRaises(InterpKernelException, dbl3.inverse);
4691         self.assertRaises(InterpKernelException, dbl3.trace);
4692         self.assertRaises(InterpKernelException, dbl3.deviator);
4693
4694         dbl3.setIJ(5,1,12.);
4695         self.assertTrue(dbl3.getMaxValueInArray()==12.);
4696         self.assertTrue(dbl3.getMinValueInArray()==11.);
4697
4698         db.fillWithValue(100); #bad Ids
4699         self.assertRaises(InterpKernelException, dbl3.setPartOfValuesAdv, dbl2, db);
4700         db.fillWithValue(-1); #bad Ids
4701         self.assertRaises(InterpKernelException, dbl3.setPartOfValuesAdv, dbl2, db);
4702         db.fillWithValue(6); #bad Ids for dbl3
4703         self.assertRaises(InterpKernelException, dbl3.setPartOfValuesAdv, dbl2, db);
4704
4705         dbl3.checkNoNullValues();
4706         dbl3.setIJ(5,0,0.);
4707         self.assertRaises(InterpKernelException, dbl3.checkNoNullValues);
4708         self.assertRaises(InterpKernelException, dbl3.applyInv, 1.);  #div by zero
4709         self.assertRaises(InterpKernelException, dbl2.getIdsInRange, 1., 2.);
4710         a=[]
4711         self.assertRaises(InterpKernelException, DataArrayDouble_Aggregate, a);
4712         self.assertRaises(InterpKernelException, DataArrayDouble_Meld, a);
4713
4714         a=[dbl2,dbl]; #Nb of components mismatch
4715         self.assertRaises(InterpKernelException, DataArrayDouble_Aggregate, a);
4716
4717         self.assertRaises(InterpKernelException, DataArrayDouble_Dot, dbl2, dbl);
4718
4719         self.assertRaises(InterpKernelException, DataArrayDouble_CrossProduct, dbl2, dbl); #Nb of components mismatch
4720         self.assertRaises(InterpKernelException, DataArrayDouble_CrossProduct, dbl2, dbl2); #Nb of components must be equal to 3
4721         dbl4=DataArrayDouble.New();
4722         dbl4.alloc(6,3);
4723         dbl5=DataArrayDouble.New();
4724         dbl5.alloc(7,3);
4725         self.assertRaises(InterpKernelException, DataArrayDouble_CrossProduct, dbl4, dbl5); #Nb of tuples mismatch
4726
4727         a[0]=dbl4; #Nb of tuple mismatch
4728         a[1]=dbl5; #Nb of tuple mismatch
4729         self.assertRaises(InterpKernelException, DataArrayDouble_Meld, a);
4730         self.assertRaises(InterpKernelException, DataArrayDouble_Dot, dbl4, dbl5);
4731         pass
4732
4733     def testDAIGetIdsEqual1(self):
4734         tab1=[5,-2,-4,-2,3,2,-2];
4735         da=DataArrayInt.New();
4736         da.setValues(tab1,7,1);
4737         da2=da.getIdsEqual(-2);
4738         self.assertEqual(3,da2.getNumberOfTuples());
4739         self.assertEqual(1,da2.getNumberOfComponents());
4740         expected1=[1,3,6];
4741         self.assertEqual(expected1,da2.getValues());
4742         pass
4743
4744     def testDAIGetIdsEqualList1(self):
4745         tab1=[5,-2,-4,-2,3,2,-2];
4746         da=DataArrayInt.New();
4747         da.setValues(tab1,7,1);
4748         da2=da.getIdsEqualList([3,-2,0]);
4749         self.assertEqual(4,da2.getNumberOfTuples());
4750         self.assertEqual(1,da2.getNumberOfComponents());
4751         expected1=[1,3,4,6];
4752         self.assertEqual(expected1,da2.getValues());
4753         pass
4754
4755     def testDAFromNoInterlace1(self):
4756         tab1=[1,11,21,31,41,2,12,22,32,42,3,13,23,33,43]
4757         da=DataArrayInt.New();
4758         da.setValues(tab1,5,3);
4759         da2=da.fromNoInterlace();
4760         expected1=[1,2,3,11,12,13,21,22,23,31,32,33,41,42,43]
4761         self.assertEqual(5,da2.getNumberOfTuples());
4762         self.assertEqual(3,da2.getNumberOfComponents());# it's not a bug. Avoid to have 1 million components !
4763         self.assertEqual(expected1,da2.getValues());
4764         da3=da.convertToDblArr();
4765         da4=da3.fromNoInterlace();
4766         self.assertEqual(5,da4.getNumberOfTuples());
4767         self.assertEqual(3,da4.getNumberOfComponents());# it's not a bug. Avoid to have 1 million components !
4768         for i in xrange(15):
4769             self.assertAlmostEqual(expected1[i],da4.getIJ(0,i),14);
4770             pass
4771         pass
4772
4773     def testDAToNoInterlace1(self):
4774         tab1=[1,2,3,11,12,13,21,22,23,31,32,33,41,42,43]
4775         da=DataArrayInt.New();
4776         da.setValues(tab1,5,3);
4777         da2=da.toNoInterlace();
4778         expected1=[1,11,21,31,41,2,12,22,32,42,3,13,23,33,43]
4779         self.assertEqual(5,da2.getNumberOfTuples());
4780         self.assertEqual(3,da2.getNumberOfComponents());# it's not a bug. Avoid to have 1 million components !
4781         self.assertEqual(expected1,da2.getValues());
4782         da3=da.convertToDblArr();
4783         da4=da3.toNoInterlace();
4784         self.assertEqual(5,da4.getNumberOfTuples());
4785         self.assertEqual(3,da4.getNumberOfComponents());# it's not a bug. Avoid to have 1 million components !
4786         for i in xrange(15):
4787             self.assertAlmostEqual(expected1[i],da4.getIJ(0,i),14);
4788             pass
4789         pass
4790
4791     def testDAIsUniform1(self):
4792         tab1=[1,1,1,1,1]
4793         da=DataArrayInt.New();
4794         da.setValues(tab1,5,1);
4795         self.assertTrue(da.isUniform(1));
4796         da.setIJ(2,0,2);
4797         self.assertTrue(not da.isUniform(1));
4798         da.setIJ(2,0,1);
4799         self.assertTrue(da.isUniform(1));
4800         da2=da.convertToDblArr();
4801         self.assertTrue(da2.isUniform(1.,1.e-12));
4802         da2.setIJ(1,0,1.+1.e-13);
4803         self.assertTrue(da2.isUniform(1.,1.e-12));
4804         da2.setIJ(1,0,1.+1.e-11);
4805         self.assertTrue(not da2.isUniform(1.,1.e-12));
4806         pass
4807
4808     def testDADFromPolarToCart1(self):
4809         tab1=[2.,0.2,2.5,0.7]
4810         da=DataArrayDouble.New();
4811         da.setValues(tab1,2,2);
4812         da2=da.fromPolarToCart();
4813         expected1=[1.9601331556824833,0.39733866159012243, 1.9121054682112213,1.6105442180942275]
4814         for i in xrange(4):
4815             self.assertAlmostEqual(expected1[i],da2.getIJ(0,i),13);
4816             pass
4817         pass
4818
4819     def testDADFromCylToCart1(self):
4820         tab1=[2.,0.2,4.,2.5,0.7,9.]
4821         da=DataArrayDouble.New();
4822         da.setValues(tab1,2,3);
4823         da2=da.fromCylToCart();
4824         expected1=[1.9601331556824833,0.39733866159012243,4., 1.9121054682112213,1.6105442180942275,9.]
4825         for i in xrange(6):
4826             self.assertAlmostEqual(expected1[i],da2.getIJ(0,i),13);
4827             pass
4828         pass
4829
4830     def testDADFromSpherToCart1(self):
4831         tab1=[2.,0.2,0.3,2.5,0.7,0.8]
4832         da=DataArrayDouble.New();
4833         da.setValues(tab1,2,3);
4834         da2=da.fromSpherToCart();
4835         expected1=[0.37959212195737485,0.11742160338765303,1.9601331556824833, 1.1220769624465328,1.1553337045129035,1.9121054682112213]
4836         for i in xrange(6):
4837             self.assertAlmostEqual(expected1[i],da2.getIJ(0,i),13);
4838             pass
4839         pass
4840
4841     def testUnPolyze1(self):
4842         elts=[0,1,2,3,4,5,6,7]
4843         eltsV=elts;
4844         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
4845         mesh.convertToPolyTypes(eltsV);
4846         mesh.unPolyze();
4847         mesh2=MEDCouplingDataForTest.build3DTargetMesh_1();
4848         mesh.checkCoherency();
4849         self.assertTrue(mesh.isEqual(mesh2,1e-12));
4850         mesh.convertToPolyTypes(eltsV);
4851         self.assertTrue(not mesh.isEqual(mesh2,1e-12));
4852         mesh.getNodalConnectivity().setIJ(0,6,10);
4853         mesh.getNodalConnectivity().setIJ(0,7,9);
4854         mesh.getNodalConnectivity().setIJ(0,8,12);
4855         mesh.getNodalConnectivity().setIJ(0,9,13);
4856         mesh.unPolyze();
4857         self.assertTrue(mesh.isEqual(mesh2,1e-12));
4858         mesh.convertToPolyTypes(eltsV);
4859         mesh.getNodalConnectivity().setIJ(0,6,12);
4860         mesh.getNodalConnectivity().setIJ(0,7,13);
4861         mesh.getNodalConnectivity().setIJ(0,8,10);
4862         mesh.getNodalConnectivity().setIJ(0,9,9);
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,10);
4868         mesh.getNodalConnectivity().setIJ(0,8,13);
4869         mesh.getNodalConnectivity().setIJ(0,9,9);
4870         mesh.unPolyze();
4871         self.assertTrue(not mesh.isEqual(mesh2,1e-12));
4872         # Test for 2D mesh
4873         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
4874         mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
4875         eltsV=eltsV[:5];
4876         mesh.convertToPolyTypes(eltsV);
4877         self.assertTrue(not mesh.isEqual(mesh2,1e-12));
4878         mesh.unPolyze();
4879         self.assertTrue(mesh.isEqual(mesh2,1e-12));
4880         pass
4881
4882     def testConvertDegeneratedCells1(self):
4883         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
4884         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]
4885         mesh.allocateCells(4);
4886         mesh.insertNextCell(NORM_HEXA8,8,conn[0:8])
4887         mesh.insertNextCell(NORM_HEXA8,8,conn[8:16])
4888         mesh.insertNextCell(NORM_HEXA8,8,conn[16:24])
4889         mesh.insertNextCell(NORM_HEXA8,8,conn[24:32])
4890         mesh.finishInsertingCells();
4891         mesh.checkCoherency();
4892         self.assertEqual(4,mesh.getNumberOfCells());
4893         self.assertEqual(NORM_HEXA8,mesh.getTypeOfCell(0));
4894         self.assertEqual(NORM_HEXA8,mesh.getTypeOfCell(1));
4895         self.assertEqual(NORM_HEXA8,mesh.getTypeOfCell(2));
4896         self.assertEqual(NORM_HEXA8,mesh.getTypeOfCell(3));
4897         f1=mesh.getMeasureField(True);
4898         mesh.convertDegeneratedCells();
4899         mesh.checkCoherency();
4900         f2=mesh.getMeasureField(True);
4901         self.assertEqual(4,mesh.getNumberOfCells());
4902         self.assertEqual(NORM_PENTA6,mesh.getTypeOfCell(0));
4903         self.assertEqual(NORM_PYRA5,mesh.getTypeOfCell(1));
4904         self.assertEqual(NORM_TETRA4,mesh.getTypeOfCell(2));
4905         self.assertEqual(NORM_PYRA5,mesh.getTypeOfCell(3));
4906         for i in xrange(4):
4907             self.assertAlmostEqual(f1.getArray().getIJ(0,i),f2.getArray().getIJ(0,i),5);
4908             pass
4909         pass
4910
4911     def testGetNodeIdsNearPoints1(self):
4912         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
4913         coords=mesh.getCoords();
4914         tmp=DataArrayDouble.New();
4915         vals=[0.2,0.2,0.1,0.2,0.2,0.2]
4916         tmp.setValues(vals,3,2);
4917         tmp2=DataArrayDouble.Aggregate(coords,tmp);
4918         mesh.setCoords(tmp2);
4919         pts=[0.2,0.2,0.1,0.3,-0.3,0.7]
4920         c=mesh.getNodeIdsNearPoint(pts[:2],1e-7);
4921         self.assertEqual([4,9,11],c.getValues());
4922         c,cI=mesh.getNodeIdsNearPoints(pts,3,1e-7);
4923         self.assertEqual([0,3,3,4],cI.getValues());
4924         self.assertEqual([4,9,11,6],c.getValues());
4925         c,cI=mesh.getNodeIdsNearPoints(pts,1e-7);
4926         self.assertEqual([0,3,3,4],cI.getValues());
4927         self.assertEqual([4,9,11,6],c.getValues());
4928         c,cI=mesh.getNodeIdsNearPoints(DataArrayDouble.New(pts,3,2),1e-7);
4929         self.assertEqual([0,3,3,4],cI.getValues());
4930         self.assertEqual([4,9,11,6],c.getValues());
4931         self.assertRaises(InterpKernelException,mesh.getNodeIdsNearPoints,DataArrayDouble.New(pts,2,3),1e-7);
4932         pass
4933
4934     def testFieldCopyTinyAttrFrom1(self):
4935         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
4936         f1.setName("f1");
4937         f1.setTimeTolerance(1.e-5);
4938         f1.setDescription("f1Desc");
4939         f1.setTime(1.23,4,5);
4940         f2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
4941         f2.setName("f2");
4942         f2.setDescription("f2Desc");
4943         f2.setTime(6.78,9,10);
4944         f2.setTimeTolerance(4.556e-12);
4945         #
4946         f1.copyTinyAttrFrom(f2);
4947         self.assertAlmostEqual(4.556e-12,f1.getTimeTolerance(),24);
4948         t,dt,it=f1.getTime()
4949         self.assertAlmostEqual(6.78,t,12);
4950         self.assertEqual(9,dt);
4951         self.assertEqual(10,it);
4952         self.assertTrue(f1.getName()=="f1");#name unchanged
4953         self.assertTrue(f1.getDescription()=="f1Desc");#description unchanged
4954         #
4955         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
4956         f1.setName("f1");
4957         f1.setTimeTolerance(1.e-5);
4958         f1.setDescription("f1Desc");
4959         f2=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
4960         f2.setName("f2");
4961         f2.setDescription("f2Desc");
4962         f2.setTimeTolerance(4.556e-12);
4963         #
4964         f1.copyTinyAttrFrom(f2);
4965         self.assertAlmostEqual(4.556e-12,f1.getTimeTolerance(),24);
4966         self.assertTrue(f1.getName()=="f1");#name unchanged
4967         self.assertTrue(f1.getDescription()=="f1Desc");#description unchanged
4968         #
4969         f1=MEDCouplingFieldDouble.New(ON_CELLS,CONST_ON_TIME_INTERVAL);
4970         f1.setName("f1");
4971         f1.setTimeTolerance(1.e-5);
4972         f1.setDescription("f1Desc");
4973         f1.setTime(1.23,4,5);
4974         f1.setEndTime(5.43,2,1);
4975         f2=MEDCouplingFieldDouble.New(ON_CELLS,CONST_ON_TIME_INTERVAL);
4976         f2.setName("f2");
4977         f2.setDescription("f2Desc");
4978         f2.setTimeTolerance(4.556e-12);
4979         f2.setTime(6.78,9,10);
4980         f2.setEndTime(10.98,7,6);
4981         #
4982         f1.copyTinyAttrFrom(f2);
4983         self.assertAlmostEqual(4.556e-12,f1.getTimeTolerance(),24);
4984         self.assertTrue(f1.getName()=="f1");#name unchanged
4985         self.assertTrue(f1.getDescription()=="f1Desc");#description unchanged
4986         t,dt,it=f1.getTime()
4987         self.assertAlmostEqual(6.78,t,12);
4988         self.assertEqual(9,dt);
4989         self.assertEqual(10,it);
4990         t,dt,it=f1.getEndTime()
4991         self.assertAlmostEqual(10.98,t,12);
4992         self.assertEqual(7,dt);
4993         self.assertEqual(6,it);
4994         #
4995         f1=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
4996         f1.setName("f1");
4997         f1.setTimeTolerance(1.e-5);
4998         f1.setDescription("f1Desc");
4999         f1.setTime(1.23,4,5);
5000         f1.setEndTime(5.43,2,1);
5001         f2=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
5002         f2.setName("f2");
5003         f2.setDescription("f2Desc");
5004         f2.setTimeTolerance(4.556e-12);
5005         f2.setTime(6.78,9,10);
5006         f2.setEndTime(10.98,7,6);
5007         #
5008         f1.copyTinyAttrFrom(f2);
5009         self.assertAlmostEqual(4.556e-12,f1.getTimeTolerance(),24);
5010         self.assertTrue(f1.getName()=="f1");#name unchanged
5011         self.assertTrue(f1.getDescription()=="f1Desc");#description unchanged
5012         t,dt,it=f1.getTime()
5013         self.assertAlmostEqual(6.78,t,12);
5014         self.assertEqual(9,dt);
5015         self.assertEqual(10,it);
5016         t,dt,it=f1.getEndTime()
5017         self.assertAlmostEqual(10.98,t,12);
5018         self.assertEqual(7,dt);
5019         self.assertEqual(6,it);
5020         pass
5021
5022     def testExtrudedMesh5(self):
5023         coo1=[0.,1.,2.,3.5]
5024         a=DataArrayDouble.New();
5025         a.setValues(coo1,4,1);
5026         b=MEDCouplingCMesh.New();
5027         b.setCoordsAt(0,a);
5028         c=b.buildUnstructured();
5029         self.assertEqual(1,c.getSpaceDimension());
5030         c.changeSpaceDimension(2);
5031         #
5032         d=DataArrayDouble.New();
5033         d.alloc(13,1);
5034         d.iota();
5035         e=MEDCouplingCMesh.New();
5036         e.setCoordsAt(0,d);
5037         f=e.buildUnstructured();
5038         g=f.getCoords().applyFunc(2,"3.5*IVec+x/6*3.14159265359*JVec");
5039         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 !
5040         h=g.fromPolarToCart();
5041         f.setCoords(h);
5042         i=c.buildExtrudedMesh(f,1);
5043         self.assertEqual(52,i.getNumberOfNodes());
5044         tmp,tmp2,tmp3=i.mergeNodes(1e-9);
5045         self.assertTrue(tmp2);
5046         self.assertEqual(37,tmp3);
5047         i.convertDegeneratedCells();
5048         i.checkCoherency();
5049         self.assertEqual(36,i.getNumberOfCells());
5050         self.assertEqual(37,i.getNumberOfNodes());
5051         self.assertEqual(12,i.getNumberOfCellsWithType(NORM_TRI3));
5052         self.assertEqual(24,i.getNumberOfCellsWithType(NORM_QUAD4));
5053         expected1=[0.25,0.75,2.0625]
5054         j=i.getMeasureField(True);
5055         for ii in xrange(12):
5056             for k in xrange(3):
5057                 self.assertAlmostEqual(expected1[k],j.getIJ(0,ii*3+k),10);
5058                 pass
5059             pass
5060         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]
5061         m=i.getBarycenterAndOwner();
5062         for i in xrange(72):
5063             self.assertAlmostEqual(expected2[i],m.getIJ(0,i),10);
5064             pass
5065         #
5066         pass
5067
5068     def testExtrudedMesh6(self):
5069         coo1=[0.,1.,2.,3.5]
5070         a=DataArrayDouble.New();
5071         a.setValues(coo1,4,1);
5072         b=MEDCouplingCMesh.New();
5073         b.setCoordsAt(0,a);
5074         c=b.buildUnstructured();
5075         self.assertEqual(1,c.getSpaceDimension());
5076         c.changeSpaceDimension(2);
5077         #
5078         d=DataArrayDouble.New();
5079         d.alloc(5,1);
5080         d.iota();
5081         e=MEDCouplingCMesh.New();
5082         e.setCoordsAt(0,d);
5083         f=e.buildUnstructured();
5084         d2=f.getCoords().applyFunc("x*x/2");
5085         f.setCoords(d2);
5086         f.changeSpaceDimension(2);
5087         #
5088         center=[0.,0.]
5089         f.rotate(center,None,pi/3);
5090         g=c.buildExtrudedMesh(f,0);
5091         g.checkCoherency();
5092         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 ]
5093         f1=g.getMeasureField(True);
5094         for i in xrange(12):
5095             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),12);
5096             pass
5097         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]
5098         f2=g.getBarycenterAndOwner();
5099         for i in xrange(24):
5100             self.assertAlmostEqual(expected2[i],f2.getIJ(0,i),12);
5101             pass
5102         pass
5103
5104     def testExtrudedMesh7(self):
5105         coo1=[0.,1.,2.,3.5]
5106         a=DataArrayDouble.New();
5107         a.setValues(coo1,4,1);
5108         b=MEDCouplingCMesh.New();
5109         b.setCoordsAt(0,a);
5110         c=b.buildUnstructured();
5111         self.assertEqual(1,c.getSpaceDimension());
5112         c.changeSpaceDimension(2);
5113         #
5114         d=DataArrayDouble.New();
5115         d.alloc(13,1);
5116         d.iota();
5117         e=MEDCouplingCMesh.New();
5118         e.setCoordsAt(0,d);
5119         f=e.buildUnstructured();
5120         g=f.getCoords().applyFunc(2,"3.5*IVec+x/6*3.14159265359*JVec");
5121         h=g.fromPolarToCart();
5122         f.setCoords(h);
5123         i=c.buildExtrudedMesh(f,1);
5124         self.assertEqual(52,i.getNumberOfNodes());
5125         tmp,tmp2,tmp3=i.mergeNodes(1e-9);
5126         self.assertTrue(tmp2);
5127         self.assertEqual(37,tmp3);
5128         i.convertDegeneratedCells();
5129         vec1=[10.,0]
5130         i.translate(vec1);
5131         g2=h.applyFunc(3,"13.5/3.5*x*IVec+0*JVec+13.5/3.5*y*KVec");
5132         f.setCoords(g2);
5133         i.changeSpaceDimension(3);
5134         i3=i.buildExtrudedMesh(f,1);
5135         f2=i3.getMeasureField(True);
5136         tmp,tmp2,tmp3=i.mergeNodes(1e-9);
5137         self.assertTrue(tmp2);
5138         self.assertEqual(444,tmp3);
5139         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]
5140         for ii in xrange(12):
5141             for jj in xrange(36):
5142                 self.assertAlmostEqual(expected1[jj],f2.getIJ(0,ii*36+jj),9);
5143                 pass
5144         #
5145         pass
5146
5147     def testSimplexize1(self):
5148         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5149         m.convertToPolyTypes([3]);
5150         da=m.simplexize(0);
5151         self.assertEqual(7,da.getNumberOfTuples());
5152         self.assertEqual(1,da.getNumberOfComponents());
5153         expected2=[0,0,1,2,3,4,4]
5154         for i in xrange(7):
5155             self.assertEqual(expected2[i],da.getIJ(i,0));
5156             pass
5157         m.checkCoherency();
5158         self.assertEqual(7,m.getNumberOfCells());
5159         self.assertEqual(NORM_TRI3,m.getTypeOfCell(0));
5160         self.assertEqual(NORM_TRI3,m.getTypeOfCell(1));
5161         self.assertEqual(NORM_TRI3,m.getTypeOfCell(2));
5162         self.assertEqual(NORM_TRI3,m.getTypeOfCell(3));
5163         self.assertEqual(NORM_POLYGON,m.getTypeOfCell(4));
5164         self.assertEqual(NORM_TRI3,m.getTypeOfCell(5));
5165         self.assertEqual(NORM_TRI3,m.getTypeOfCell(6));
5166         expected1=[0.125,0.125,0.125,0.125,0.25,0.125,0.125]
5167         f=m.getMeasureField(False);
5168         for i in xrange(7):
5169             self.assertAlmostEqual(expected1[i]*sqrt(2.),f.getIJ(i,0),10);
5170             pass
5171         types=m.getAllTypes();
5172         self.assertEqual([NORM_TRI3,NORM_POLYGON],types);
5173         #
5174         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5175         m.convertToPolyTypes([3]);
5176         da=m.simplexize(1);
5177         self.assertEqual(7,da.getNumberOfTuples());
5178         self.assertEqual(1,da.getNumberOfComponents());
5179         for i in xrange(7):
5180             self.assertEqual(expected2[i],da.getIJ(i,0));
5181             pass
5182         m.checkCoherency();
5183         types=m.getAllTypes();
5184         self.assertEqual([NORM_TRI3,NORM_POLYGON],types);
5185         self.assertEqual(7,m.getNumberOfCells());
5186         self.assertEqual(NORM_TRI3,m.getTypeOfCell(0));
5187         self.assertEqual(NORM_TRI3,m.getTypeOfCell(1));
5188         self.assertEqual(NORM_TRI3,m.getTypeOfCell(2));
5189         self.assertEqual(NORM_TRI3,m.getTypeOfCell(3));
5190         self.assertEqual(NORM_POLYGON,m.getTypeOfCell(4));
5191         self.assertEqual(NORM_TRI3,m.getTypeOfCell(5));
5192         self.assertEqual(NORM_TRI3,m.getTypeOfCell(6));
5193         f=m.getMeasureField(False);
5194         for i in xrange(7):
5195             self.assertAlmostEqual(expected1[i]*sqrt(2.),f.getIJ(i,0),10);
5196             pass
5197         pass
5198
5199     def testSimplexize2(self):
5200         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5201         m.convertToPolyTypes([3]);
5202         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
5203         f1.setMesh(m);
5204         arr=DataArrayDouble.New();
5205         arr1=[10.,110.,20.,120.,30.,130.,40.,140.,50.,150.]
5206         arr.setValues(arr1,5,2);
5207         f1.setArray(arr);
5208         #
5209         f1.checkCoherency();
5210         self.assertTrue(f1.simplexize(0));
5211         f1.checkCoherency();
5212         expected1=[10.,110.,10.,110.,20.,120.,30.,130.,40.,140.,50.,150.,50.,150.]
5213         for i in xrange(14):
5214             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),10);
5215             pass
5216         self.assertTrue(not f1.simplexize(0));
5217         for i in xrange(14):
5218             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),10);
5219             pass
5220         #
5221         pass
5222
5223     def testDAMeld1(self):
5224         da1=DataArrayDouble.New();
5225         da1.alloc(7,2);
5226         da2=DataArrayDouble.New();
5227         da2.alloc(7,1);
5228         #
5229         da1.fillWithValue(7.);
5230         da2.iota(0.);
5231         da3=da2.applyFunc(3,"10*x*IVec+100*x*JVec+1000*x*KVec");
5232         #
5233         da1.setInfoOnComponent(0,"c0da1");
5234         da1.setInfoOnComponent(1,"c1da1");
5235         da3.setInfoOnComponent(0,"c0da3");
5236         da3.setInfoOnComponent(1,"c1da3");
5237         da3.setInfoOnComponent(2,"c2da3");
5238         #
5239         da1C=da1.deepCpy();
5240         da1.meldWith(da3);
5241         self.assertEqual(5,da1.getNumberOfComponents());
5242         self.assertEqual(7,da1.getNumberOfTuples());
5243         self.assertTrue(da1.getInfoOnComponent(0)=="c0da1");
5244         self.assertTrue(da1.getInfoOnComponent(1)=="c1da1");
5245         self.assertTrue(da1.getInfoOnComponent(2)=="c0da3");
5246         self.assertTrue(da1.getInfoOnComponent(3)=="c1da3");
5247         self.assertTrue(da1.getInfoOnComponent(4)=="c2da3");
5248         #
5249         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.]
5250         for i in xrange(35):
5251             self.assertAlmostEqual(expected1[i],da1.getIJ(0,i),10);
5252             pass
5253         #
5254         dai1=da1C.convertToIntArr();
5255         dai3=da3.convertToIntArr();
5256         dai1.meldWith(dai3);
5257         self.assertEqual(5,dai1.getNumberOfComponents());
5258         self.assertEqual(7,dai1.getNumberOfTuples());
5259         self.assertTrue(dai1.getInfoOnComponent(0)=="c0da1");
5260         self.assertTrue(dai1.getInfoOnComponent(1)=="c1da1");
5261         self.assertTrue(dai1.getInfoOnComponent(2)=="c0da3");
5262         self.assertTrue(dai1.getInfoOnComponent(3)=="c1da3");
5263         self.assertTrue(dai1.getInfoOnComponent(4)=="c2da3");
5264         for i in xrange(35):
5265             self.assertEqual(int(expected1[i]),dai1.getIJ(0,i));
5266             pass
5267         # test of static method DataArrayDouble::meld
5268         da4=DataArrayDouble.Meld(da1C,da3);
5269         tmp=DataArrayDouble.Meld([da1C,da3]);
5270         self.assertTrue(da4.isEqual(tmp,1e-10))
5271         self.assertEqual(5,da4.getNumberOfComponents());
5272         self.assertEqual(7,da4.getNumberOfTuples());
5273         self.assertTrue(da4.getInfoOnComponent(0)=="c0da1");
5274         self.assertTrue(da4.getInfoOnComponent(1)=="c1da1");
5275         self.assertTrue(da4.getInfoOnComponent(2)=="c0da3");
5276         self.assertTrue(da4.getInfoOnComponent(3)=="c1da3");
5277         self.assertTrue(da4.getInfoOnComponent(4)=="c2da3");
5278         for i in xrange(35):
5279             self.assertAlmostEqual(expected1[i],da4.getIJ(0,i),10);
5280             pass
5281         # test of static method DataArrayInt::meld
5282         dai1=da1C.convertToIntArr();
5283         dai4=DataArrayInt.Meld(dai1,dai3);
5284         tmp=DataArrayInt.Meld([dai1,dai3]);
5285         self.assertTrue(dai4.isEqual(tmp))
5286         self.assertEqual(5,dai4.getNumberOfComponents());
5287         self.assertEqual(7,dai4.getNumberOfTuples());
5288         self.assertTrue(dai4.getInfoOnComponent(0)=="c0da1");
5289         self.assertTrue(dai4.getInfoOnComponent(1)=="c1da1");
5290         self.assertTrue(dai4.getInfoOnComponent(2)=="c0da3");
5291         self.assertTrue(dai4.getInfoOnComponent(3)=="c1da3");
5292         self.assertTrue(dai4.getInfoOnComponent(4)=="c2da3");
5293         for i in xrange(35):
5294             self.assertEqual(int(expected1[i]),dai4.getIJ(0,i));
5295             pass
5296         pass
5297
5298     def testFieldMeld1(self):
5299         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5300         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
5301         f1.setMesh(m);
5302         da1=DataArrayDouble.New();
5303         arr1=[12.,23.,34.,45.,56.]
5304         da1.setValues(arr1,5,1);
5305         da1.setInfoOnComponent(0,"aaa");
5306         f1.setArray(da1);
5307         f1.setTime(3.4,2,1);
5308         f1.checkCoherency();
5309         #
5310         f2=f1.deepCpy();
5311         f2.setMesh(f1.getMesh());
5312         f2.checkCoherency();
5313         f2.changeNbOfComponents(2,5.);
5314         f2.assign(5.);
5315         f2.getArray().setInfoOnComponent(0,"bbb");
5316         f2.getArray().setInfoOnComponent(1,"ccc");
5317         f2.checkCoherency();
5318         #
5319         f3=MEDCouplingFieldDouble.MeldFields(f2,f1);
5320         f3.checkCoherency();
5321         self.assertEqual(5,f3.getNumberOfTuples());
5322         self.assertEqual(3,f3.getNumberOfComponents());
5323         self.assertTrue(f3.getArray().getInfoOnComponent(0)=="bbb");
5324         self.assertTrue(f3.getArray().getInfoOnComponent(1)=="ccc");
5325         self.assertTrue(f3.getArray().getInfoOnComponent(2)=="aaa");
5326         expected1=[5.,5.,12.,5.,5.,23.,5.,5.,34.,5.,5.,45.,5.,5.,56.]
5327         for i in xrange(15):
5328             self.assertAlmostEqual(expected1[i],f3.getIJ(0,i),12);
5329             pass
5330         time,dt,it=f3.getTime();
5331         self.assertAlmostEqual(3.4,time,14);
5332         self.assertEqual(2,dt);
5333         self.assertEqual(1,it);
5334         #
5335         f4=f2.buildNewTimeReprFromThis(NO_TIME,False);
5336         f5=f1.buildNewTimeReprFromThis(NO_TIME,False);
5337         f6=MEDCouplingFieldDouble.MeldFields(f4,f5);
5338         f6.checkCoherency();
5339         self.assertEqual(5,f6.getNumberOfTuples());
5340         self.assertEqual(3,f6.getNumberOfComponents());
5341         self.assertTrue(f6.getArray().getInfoOnComponent(0)=="bbb");
5342         self.assertTrue(f6.getArray().getInfoOnComponent(1)=="ccc");
5343         self.assertTrue(f6.getArray().getInfoOnComponent(2)=="aaa");
5344         for i in xrange(15):
5345             self.assertAlmostEqual(expected1[i],f6.getIJ(0,i),12);
5346             pass
5347         #
5348         pass
5349
5350     def testMergeNodes2(self):
5351         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5352         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
5353         vec=[0.002,0.]
5354         m2.translate(vec);
5355         #
5356         m3=MEDCouplingUMesh.MergeUMeshes([m1,m2]);
5357         da,b,newNbOfNodes=m3.mergeNodes2(0.01);
5358         self.assertEqual(9,m3.getNumberOfNodes());
5359         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]
5360         for i in xrange(18):
5361             self.assertAlmostEqual(expected1[i],m3.getCoords().getIJ(0,i),13);
5362             pass
5363         #
5364         pass
5365
5366     def testMergeField2(self):
5367         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5368         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
5369         f1.setMesh(m);
5370         arr=DataArrayDouble.New();
5371         arr.alloc(5,2);
5372         arr.fillWithValue(2.);
5373         f1.setArray(arr);
5374         f2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
5375         f2.setMesh(m);
5376         arr=DataArrayDouble.New();
5377         arr.alloc(5,2);
5378         arr.fillWithValue(5.);
5379         f2.setArray(arr);
5380         f3=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
5381         f3.setMesh(m);
5382         arr=DataArrayDouble.New();
5383         arr.alloc(5,2);
5384         arr.fillWithValue(7.);
5385         f3.setArray(arr);
5386         #
5387         f4=MEDCouplingFieldDouble.MergeFields([f1,f2,f3]);
5388         self.assertEqual(15,f4.getMesh().getNumberOfCells());
5389         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.]
5390         for i in xrange(30):
5391             self.assertAlmostEqual(expected1[i],f4.getIJ(0,i),13);
5392             pass
5393         #
5394         pass
5395
5396     def testDAIBuildComplement1(self):
5397         a=DataArrayInt.New();
5398         tab=[3,1,7,8]
5399         a.setValues(tab,4,1);
5400         b=a.buildComplement(12);
5401         self.assertEqual(8,b.getNumberOfTuples());
5402         self.assertEqual(1,b.getNumberOfComponents());
5403         expected1=[0,2,4,5,6,9,10,11]
5404         for i in xrange(8):
5405             self.assertEqual(expected1[i],b.getIJ(0,i));
5406             pass
5407         pass
5408
5409     def testDAIBuildUnion1(self):
5410         a=DataArrayInt.New();
5411         tab1=[3,1,7,8]
5412         a.setValues(tab1,4,1);
5413         c=DataArrayInt.New();
5414         tab2=[5,3,0,18,8]
5415         c.setValues(tab2,5,1);
5416         b=a.buildUnion(c);
5417         self.assertEqual(7,b.getNumberOfTuples());
5418         self.assertEqual(1,b.getNumberOfComponents());
5419         expected1=[0,1,3,5,7,8,18]
5420         for i in xrange(7):
5421             self.assertEqual(expected1[i],b.getIJ(0,i));
5422             pass
5423         b=DataArrayInt.BuildUnion([a,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         pass
5431
5432     def testDAIBuildIntersection1(self):
5433         a=DataArrayInt.New();
5434         tab1=[3,1,7,8]
5435         a.setValues(tab1,4,1);
5436         c=DataArrayInt.New();
5437         tab2=[5,3,0,18,8]
5438         c.setValues(tab2,5,1);
5439         b=a.buildIntersection(c);
5440         self.assertEqual(2,b.getNumberOfTuples());
5441         self.assertEqual(1,b.getNumberOfComponents());
5442         expected1=[3,8]
5443         for i in xrange(2):
5444             self.assertEqual(expected1[i],b.getIJ(0,i));
5445             pass
5446         b=DataArrayInt.BuildIntersection([a,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         pass
5454
5455     def testDAIDeltaShiftIndex1(self):
5456         a=DataArrayInt.New();
5457         tab=[1,3,6,7,7,9,15]
5458         a.setValues(tab,7,1);
5459         b=a.deltaShiftIndex();
5460         self.assertEqual(6,b.getNumberOfTuples());
5461         self.assertEqual(1,b.getNumberOfComponents());
5462         expected1=[2,3,1,0,2,6]
5463         for i in xrange(6):
5464             self.assertEqual(expected1[i],b.getIJ(0,i));
5465             pass
5466         pass
5467
5468     def testDaDoubleSelectByTupleIdSafe1(self):
5469         a=DataArrayDouble.New();
5470         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]
5471         a.setValues(arr1,7,2);
5472         a.setInfoOnComponent(0,"toto");
5473         a.setInfoOnComponent(1,"tata");
5474         #
5475         arr2=[4,2,0,6,5]
5476         b=a.selectByTupleIdSafe(arr2);
5477         self.assertEqual(5,b.getNumberOfTuples());
5478         self.assertEqual(2,b.getNumberOfComponents());
5479         self.assertTrue(b.getInfoOnComponent(0)=="toto");
5480         self.assertTrue(b.getInfoOnComponent(1)=="tata");
5481         expected1=[5.1,15.1,3.1,13.1,1.1,11.1,7.1,17.1,6.1,16.1]
5482         for i in xrange(10):
5483             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
5484             pass
5485         arr4=[4,-1,0,6,5]
5486         self.assertRaises(InterpKernelException,a.selectByTupleIdSafe,arr4);
5487         arr5=[4,2,0,6,7]
5488         self.assertRaises(InterpKernelException,a.selectByTupleIdSafe,arr5);
5489         #
5490         c=DataArrayInt.New();
5491         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
5492         c.setValues(arr3,7,2);
5493         c.setInfoOnComponent(0,"toto");
5494         c.setInfoOnComponent(1,"tata");
5495         d=c.selectByTupleIdSafe(arr2);
5496         self.assertEqual(5,d.getNumberOfTuples());
5497         self.assertEqual(2,d.getNumberOfComponents());
5498         self.assertTrue(d.getInfoOnComponent(0)=="toto");
5499         self.assertTrue(d.getInfoOnComponent(1)=="tata");
5500         expected2=[5,15,3,13,1,11,7,17,6,16]
5501         for i in xrange(10):
5502             self.assertEqual(expected2[i],d.getIJ(0,i));
5503             pass
5504         self.assertRaises(InterpKernelException,c.selectByTupleIdSafe,arr4);
5505         self.assertRaises(InterpKernelException,c.selectByTupleIdSafe,arr5);
5506         pass
5507
5508     def testAreCellsIncludedIn1(self):
5509         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5510         pt=[1,3]
5511         m2=m.buildPartOfMySelf(pt,True);
5512         ret,tmp=m.areCellsIncludedIn(m2,0)
5513         self.assertTrue(ret);
5514         self.assertEqual(2,tmp.getNumberOfTuples());
5515         self.assertEqual(1,tmp.getNumberOfComponents());
5516         self.assertEqual(pt[0],tmp.getIJ(0,0));
5517         self.assertEqual(pt[1],tmp.getIJ(0,1));
5518         ret,tmp=m2.areCellsIncludedIn(m,0)
5519         self.assertTrue(not ret);
5520         m3=MEDCouplingUMesh.MergeUMeshesOnSameCoords(m,m2)
5521         c,cI=m3.findCommonCells(2,m.getNumberOfCells())
5522         self.assertTrue(c.isEqual(DataArrayInt([1,5,3,6])))
5523         self.assertTrue(cI.isEqual(DataArrayInt([0,2,4])))
5524         pass
5525
5526     def testSwigErrorProtection1(self):
5527         m=MEDCouplingDataForTest.build3DTargetMesh_1();
5528         m.rotate([0.,0.,0.],[0.3,0.6,1.2],0.37)
5529         m.rotate([0.,0.,0.],[0.3,6,1.2],0.37)
5530         self.assertRaises(InterpKernelException,m.rotate,[0.,0.,0.],(0.3,6,"1.2"),0.37)
5531         self.assertRaises(InterpKernelException,m.rotate,[0.,"0.",0.],[0.3,0.6,1.2],0.37)
5532         self.assertRaises(InterpKernelException,m.rotate,[0.,0.,0.],[0.3,'0.6',1.2],0.37)
5533         m2=m.buildPartOfMySelf([2,5],True)
5534         m3=m.buildPartOfMySelf((2,5),True)
5535         self.assertTrue(m2.isEqual(m3,1e-12))
5536         self.assertRaises(InterpKernelException,m.buildPartOfMySelf,[2,5.],True)
5537         da1=m.getCoords().keepSelectedComponents([1])
5538         da2=m.getCoords().keepSelectedComponents((1,))
5539         self.assertTrue(da1.isEqual(da2,1e-12))
5540         self.assertRaises(InterpKernelException,m.getCoords().keepSelectedComponents,["1"])
5541         pass
5542
5543     def testDAIBuildSubstraction1(self):
5544         a=DataArrayInt.New()
5545         aa=[2,3,6,8,9]
5546         a.setValues(aa,5,1)
5547         b=DataArrayInt.New()
5548         bb=[1,3,5,9,11]
5549         b.setValues(bb,5,1)
5550         self.assertEqual([2,6,8],a.buildSubstraction(b).getValues())
5551         pass
5552
5553     def testBuildOrthogonalField2(self):
5554         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5555         d1=DataArrayInt.New();
5556         d2=DataArrayInt.New();
5557         d3=DataArrayInt.New();
5558         d4=DataArrayInt.New();
5559         m1=m.buildDescendingConnectivity(d1,d2,d3,d4);
5560         #
5561         f1=m1.buildOrthogonalField();
5562         da1=f1.getArray();
5563         self.assertEqual(2,da1.getNumberOfComponents());
5564         self.assertEqual(13,da1.getNumberOfTuples());
5565         #
5566         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.];
5567         for i in xrange(26):
5568             self.assertAlmostEqual(expected1[i],da1.getIJ(0,i),14);
5569             pass
5570         pass
5571
5572     def testSwigErrorProtection2(self):
5573         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5574         coo=m.getCoords()
5575         c=m.getNodalConnectivity()
5576         ci=m.getNodalConnectivityIndex()
5577         del m
5578         self.assertEqual(2,coo.getNumberOfComponents());
5579         self.assertEqual(6,ci.getNumberOfTuples());
5580         self.assertEqual(23,c.getNumberOfTuples());
5581         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5582         f=m.getMeasureField(True)
5583         c=f.getArray()
5584         del f
5585         self.assertEqual(1,c.getNumberOfComponents());
5586         m=MEDCouplingCMesh.New()
5587         x=DataArrayDouble.New()
5588         x.setValues([1.,2.,4.],3,1)
5589         m.setCoordsAt(0,x)
5590         del x
5591         xx=m.getCoordsAt(0)
5592         del m
5593         self.assertEqual(3,xx.getNumberOfTuples());
5594         #
5595         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5596         f=m.getMeasureField(True)
5597         m2=f.getMesh()
5598         del m
5599         del f
5600         self.assertEqual(5,m2.getNumberOfCells());
5601         pass
5602
5603     def testUMInsertNextCell1(self):
5604         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 ]
5605         targetConn=[0,3,4,1, 1,4,2, 4,5,2, 6,7,4,3, 7,8,5,4]
5606         targetMesh=MEDCouplingUMesh.New();
5607         targetMesh.allocateCells(5);
5608         self.assertRaises(InterpKernelException,targetMesh.insertNextCell,NORM_QUAD4,4,targetConn[0:4])
5609         targetMesh.setMeshDimension(2);
5610         targetMesh.insertNextCell(NORM_QUAD4,4,targetConn[0:4])
5611         self.assertRaises(InterpKernelException,targetMesh.insertNextCell,NORM_TETRA4,4,targetConn[0:4])
5612         self.assertRaises(InterpKernelException,targetMesh.insertNextCell,NORM_SEG2,2,targetConn[0:2])
5613         self.assertRaises(InterpKernelException,targetMesh.insertNextCell,NORM_POINT1,1,targetConn[0:1])
5614         targetMesh.insertNextCell(NORM_TRI3,3,targetConn[4:7])
5615         targetMesh.insertNextCell(NORM_TRI3,3,targetConn[7:10])
5616         targetMesh.insertNextCell(NORM_QUAD4,4,targetConn[10:14])
5617         targetMesh.insertNextCell(NORM_QUAD4,4,targetConn[14:18])
5618         targetMesh.finishInsertingCells();
5619         myCoords=DataArrayDouble.New();
5620         myCoords.setValues(targetCoords,9,2);
5621         targetMesh.setCoords(myCoords);
5622         targetMesh.checkCoherency();
5623         pass
5624
5625     def testFieldOperatorDivDiffComp1(self):
5626         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5627         m1,d0,d1,d2,d3=m.buildDescendingConnectivity();
5628         #
5629         f1=m1.buildOrthogonalField();
5630         arr1=[2.,3.,4.,5.,6.,7.,8.,9.,10.,11.,12.,13.,14.]
5631         arr=DataArrayDouble.New();
5632         arr.setValues(arr1,13,1);
5633         f2=MEDCouplingFieldDouble.New(ON_CELLS);
5634         f2.setArray(arr);
5635         f2.setMesh(m1);
5636         f2.checkCoherency();
5637         #
5638         f3=f1/f2;
5639         self.assertRaises(InterpKernelException,f2.__div__,f1)
5640         f3.checkCoherency();
5641         f1/=f2;
5642         #self.assertRaises(InterpKernelException,f2.__idiv__,f1) # mem leaks
5643         self.assertTrue(f1.isEqual(f3,1e-10,1e-10));
5644         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]
5645         for i in xrange(26):
5646             self.assertAlmostEqual(expected1[i],f3.getIJ(0,i),10);
5647             pass
5648         pass
5649
5650     def testDARearrange1(self):
5651         da1=DataArrayInt.New();
5652         da1.alloc(12,1);
5653         da1.iota(0);
5654         #
5655         self.assertEqual(12,da1.getNbOfElems());
5656         self.assertEqual(1,da1.getNumberOfComponents());
5657         self.assertEqual(12,da1.getNumberOfTuples());
5658         da1.rearrange(4);
5659         self.assertEqual(12,da1.getNbOfElems());
5660         self.assertEqual(4,da1.getNumberOfComponents());
5661         self.assertEqual(3,da1.getNumberOfTuples());
5662         for i in xrange(12):
5663             self.assertEqual(i,da1.getIJ(0,i));
5664         #
5665         da1.rearrange(6);
5666         self.assertEqual(12,da1.getNbOfElems());
5667         self.assertEqual(6,da1.getNumberOfComponents());
5668         self.assertEqual(2,da1.getNumberOfTuples());
5669         for i in xrange(12):
5670             self.assertEqual(i,da1.getIJ(0,i));
5671         #
5672         self.assertRaises(InterpKernelException,da1.rearrange,7);
5673         #
5674         da1.rearrange(12);
5675         self.assertEqual(12,da1.getNbOfElems());
5676         self.assertEqual(12,da1.getNumberOfComponents());
5677         self.assertEqual(1,da1.getNumberOfTuples());
5678         for i in xrange(12):
5679             self.assertEqual(i,da1.getIJ(0,i));
5680         #
5681         da1.rearrange(3);
5682         self.assertEqual(12,da1.getNbOfElems());
5683         self.assertEqual(3,da1.getNumberOfComponents());
5684         self.assertEqual(4,da1.getNumberOfTuples());
5685         for i in xrange(12):
5686             self.assertEqual(i,da1.getIJ(0,i));
5687         #double
5688         da2=da1.convertToDblArr();
5689         st=da2.getHiddenCppPointer()
5690         #
5691         self.assertEqual(12,da2.getNbOfElems());
5692         self.assertEqual(3,da2.getNumberOfComponents());
5693         self.assertEqual(4,da2.getNumberOfTuples());
5694         da2.rearrange(4);
5695         self.assertEqual(12,da2.getNbOfElems());
5696         self.assertEqual(4,da2.getNumberOfComponents());
5697         self.assertEqual(3,da2.getNumberOfTuples());
5698         for i in xrange(12):
5699             self.assertAlmostEqual(float(i),da2.getIJ(0,i),14);
5700         #
5701         da2.rearrange(6);
5702         self.assertEqual(12,da2.getNbOfElems());
5703         self.assertEqual(6,da2.getNumberOfComponents());
5704         self.assertEqual(2,da2.getNumberOfTuples());
5705         for i in xrange(12):
5706             self.assertAlmostEqual(float(i),da2.getIJ(0,i),14);
5707         #
5708         self.assertRaises(InterpKernelException,da2.rearrange,7);
5709         #
5710         da2.rearrange(1);
5711         self.assertEqual(st,da2.getHiddenCppPointer())
5712         self.assertEqual(12,da2.getNbOfElems());
5713         self.assertEqual(1,da2.getNumberOfComponents());
5714         self.assertEqual(12,da2.getNumberOfTuples());
5715         for i in xrange(12):
5716             self.assertAlmostEqual(float(i),da2.getIJ(0,i),14);
5717         #
5718         da2.rearrange(3);
5719         self.assertEqual(12,da2.getNbOfElems());
5720         self.assertEqual(3,da2.getNumberOfComponents());
5721         self.assertEqual(4,da2.getNumberOfTuples());
5722         for i in xrange(12):
5723             self.assertAlmostEqual(float(i),da2.getIJ(0,i),14);
5724         pass
5725
5726     def testDARearrange2(self):
5727         da1=DataArrayInt.New();
5728         arr=[1,2,3,2,2,3,5,1,5,5,2,2]
5729         da1.setValues(arr,4,3);
5730         s=da1.getDifferentValues();
5731         expected1=[1,2,3,5]
5732         self.assertEqual(expected1,s);
5733         pass
5734
5735     def testSwigErrorProtection3(self):
5736         da=DataArrayInt.New()
5737         da.setValues([1,2,3,4,0,0,0,0,0,0,0,0],4,3)
5738         self.assertEqual([1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0],da.getValues())
5739         self.assertEqual(3,da.getNumberOfComponents());
5740         self.assertEqual(4,da.getNumberOfTuples());
5741         da=DataArrayInt.New()
5742         da.setValues(((1,2,3),(4,4,3),(0,0,0),(0,0,0)),4,3)
5743         self.assertEqual([1, 2, 3, 4, 4, 3, 0, 0, 0, 0, 0, 0],da.getValues())
5744         self.assertEqual(3,da.getNumberOfComponents());
5745         self.assertEqual(4,da.getNumberOfTuples());
5746         da.setValues((10*[1]+290*[2])[:12],4,3)
5747         self.assertEqual(10*[1]+[2,2],da.getValues())
5748         self.assertEqual(3,da.getNumberOfComponents());
5749         self.assertEqual(4,da.getNumberOfTuples());
5750         #
5751         da=DataArrayDouble.New()
5752         da.setValues([1,2,3.,4,0,0,0,0,0,0,0,0],4,3)
5753         self.assertEqual([1., 2., 3., 4., 0., 0., 0., 0., 0., 0., 0., 0.],da.getValues())
5754         self.assertEqual(3,da.getNumberOfComponents());
5755         self.assertEqual(4,da.getNumberOfTuples());
5756         da=DataArrayDouble.New()
5757         da.setValues(((1,2,3),(4.,4,3),(0,0,0),(0,0,0)),4,3)
5758         self.assertEqual([1., 2., 3., 4., 4., 3., 0., 0., 0., 0., 0., 0.],da.getValues())
5759         self.assertEqual(3,da.getNumberOfComponents());
5760         self.assertEqual(4,da.getNumberOfTuples());
5761         da.setValues((10*[1]+290*[2])[:12],4,3)
5762         self.assertEqual(10*[1.]+[2.,2.],da.getValues())
5763         self.assertEqual(3,da.getNumberOfComponents());
5764         self.assertEqual(4,da.getNumberOfTuples());
5765         pass
5766
5767     def testDAIBuildPermutationArr1(self):
5768         a=DataArrayInt.New()
5769         a.setValues([4,5,6,7,8],5,1)
5770         b=DataArrayInt.New()
5771         b.setValues([5,4,8,6,7],5,1)
5772         c=a.buildPermutationArr(b)
5773         self.assertEqual([1,0,4,2,3],c.getValues())
5774         self.assertTrue(a.isEqualWithoutConsideringStrAndOrder(b))
5775         b.setIJ(0,0,9)
5776         self.assertTrue(not a.isEqualWithoutConsideringStrAndOrder(b))
5777         self.assertRaises(InterpKernelException,a.buildPermutationArr,b)
5778         a.setIJ(3,0,4)
5779         b.setIJ(0,0,5)
5780         b.setIJ(4,0,4)#a==[4,5,6,4,8] and b==[5,4,8,6,4]
5781         self.assertTrue(a.isEqualWithoutConsideringStrAndOrder(b))
5782         c=a.buildPermutationArr(b)
5783         self.assertEqual([1,3,4,2,3],c.getValues())
5784         d=b.convertToDblArr()
5785         expect3=[4,4,5,6,8]
5786         b.sort()
5787         self.assertEqual(expect3,b.getValues())
5788         d.sort()
5789         self.assertEqual(5,d.getNumberOfTuples());
5790         self.assertEqual(1,d.getNumberOfComponents());
5791         for i in xrange(5):
5792             self.assertAlmostEqual(float(expect3[i]),d.getIJ(i,0),14);
5793             pass
5794         pass
5795
5796     def testAreCellsIncludedIn2(self):
5797         myName="Vitoo";
5798         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5799         m2=m.buildPartOfMySelf([],True);
5800         self.assertEqual(0,m2.getNumberOfCells());
5801         self.assertEqual(3,m2.getSpaceDimension());
5802         self.assertEqual(2,m2.getMeshDimension());
5803         m2.setName(myName);
5804         test,tmp=m.areCellsIncludedIn(m2,0)
5805         self.assertTrue(test);
5806         self.assertEqual(myName,tmp.getName());
5807         self.assertEqual(0,tmp.getNumberOfTuples())
5808         self.assertEqual(1,tmp.getNumberOfComponents())
5809         pass
5810
5811     def testUMeshGetPartBarycenterAndOwner1(self):
5812         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5813         part1=[1,0,4];
5814         part=DataArrayInt.New();
5815         part.setValues(part1,3,1);
5816         b=m1.getPartBarycenterAndOwner(part);
5817         self.assertEqual(2,b.getNumberOfComponents());
5818         self.assertEqual(3,b.getNumberOfTuples());
5819         expected1=[0.36666666666666665,-0.13333333333333333,-0.05,-0.05,0.45,0.45];
5820         for i in xrange(6):
5821             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
5822             pass
5823         pass
5824
5825     def testUMeshGetPartMeasureField1(self):
5826         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5827         part1=[1,0,4];
5828         part=DataArrayInt.New();
5829         part.setValues(part1,3,1);
5830         b=m1.getPartMeasureField(True,part);
5831         self.assertEqual(1,b.getNumberOfComponents());
5832         self.assertEqual(3,b.getNumberOfTuples());
5833         expected1=[0.125,0.25,0.25];
5834         for i in xrange(3):
5835             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
5836             pass
5837         pass
5838
5839     def testUMeshBuildPartOrthogonalField1(self):
5840         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5841         m1.changeSpaceDimension(3);
5842         part1=[1,0,4];
5843         part=DataArrayInt.New();
5844         part.setValues(part1,3,1);
5845         b=m1.buildPartOrthogonalField(part);
5846         self.assertEqual(3,b.getArray().getNumberOfComponents());
5847         self.assertEqual(3,b.getArray().getNumberOfTuples());
5848         expected1=[0.,0.,-1.,0.,0.,-1.,0.,0.,-1.];
5849         for i in xrange(9):
5850             self.assertAlmostEqual(expected1[i],b.getArray().getIJ(0,i),14);
5851             pass
5852         pass
5853
5854     def testUMeshGetTypesOfPart1(self):
5855         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5856         part1=[0,3,4];
5857         p1=DataArrayInt.New()
5858         p1.setValues(part1,3,1)
5859         s=m1.getTypesOfPart(p1);
5860         self.assertEqual([NORM_QUAD4],s);
5861         part2=[2,2,2,1];
5862         p2=DataArrayInt.New()
5863         p2.setValues(part2,4,1)
5864         s=m1.getTypesOfPart(p2);
5865         self.assertEqual([NORM_TRI3],s);
5866         part3=[3,2,1];
5867         p3=DataArrayInt.New()
5868         p3.setValues(part3,3,1)
5869         s=m1.getTypesOfPart(p3);
5870         self.assertEqual(s,[NORM_TRI3,NORM_QUAD4]);
5871         pass
5872
5873     def testUMeshKeepCellIdsByType1(self):
5874         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5875         part1=[0,3,4]
5876         p1=DataArrayInt.New()
5877         p1.setValues(part1,3,1)
5878         p1.setName("p1")
5879         a=m1.keepCellIdsByType(NORM_TRI3,p1);
5880         self.assertEqual("p1",a.getName())
5881         self.assertEqual(1,a.getNumberOfComponents());
5882         self.assertEqual(0,a.getNumberOfTuples());
5883         #
5884         part2=[3,2,0,2,4]
5885         p2=DataArrayInt.New()
5886         p2.setValues(part2,5,1)
5887         p2.setName("p2")
5888         a=m1.keepCellIdsByType(NORM_TRI3,p2);
5889         self.assertEqual("p2",a.getName())
5890         self.assertEqual(1,a.getNumberOfComponents());
5891         self.assertEqual(2,a.getNumberOfTuples());
5892         self.assertEqual(2,a.getIJ(0,0));
5893         self.assertEqual(2,a.getIJ(1,0));
5894         #
5895         a=m1.keepCellIdsByType(NORM_QUAD4,p2);
5896         self.assertEqual("p2",a.getName())
5897         self.assertEqual(1,a.getNumberOfComponents());
5898         self.assertEqual(3,a.getNumberOfTuples());
5899         self.assertEqual(3,a.getIJ(0,0));
5900         self.assertEqual(0,a.getIJ(1,0));
5901         self.assertEqual(4,a.getIJ(2,0));
5902         pass
5903
5904     def testSwigErrorDaIntSelectByTupleId1(self):
5905         a=DataArrayInt.New();
5906         arr1=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
5907         a.setValues(arr1,7,2);
5908         a.setInfoOnComponent(0,"toto");
5909         a.setInfoOnComponent(1,"tata");
5910         #
5911         arr2=[4,2,0,6,5]
5912         b=a.selectByTupleId(arr2);
5913         self.assertEqual(5,b.getNumberOfTuples());
5914         self.assertEqual(2,b.getNumberOfComponents());
5915         self.assertTrue(b.getInfoOnComponent(0)=="toto");
5916         self.assertTrue(b.getInfoOnComponent(1)=="tata");
5917         expected1=[5,15,3,13,1,11,7,17,6,16]
5918         self.assertEqual(expected1,b.getValues())
5919         #
5920         a2=DataArrayInt.New()
5921         a2.setValues(arr2,5,1)
5922         b=a.selectByTupleId(a2);
5923         self.assertEqual(5,b.getNumberOfTuples());
5924         self.assertEqual(2,b.getNumberOfComponents());
5925         self.assertTrue(b.getInfoOnComponent(0)=="toto");
5926         self.assertTrue(b.getInfoOnComponent(1)=="tata");
5927         expected1=[5,15,3,13,1,11,7,17,6,16]
5928         self.assertEqual(expected1,b.getValues())
5929         pass
5930
5931     def testSwigErrorRenum(self):
5932         da=DataArrayDouble.New()
5933         da.setValues([7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.],10,2)
5934         d=DataArrayInt.New()
5935         d.setValues([0,2,3,1,4,5,6,8,7,9],10,1)
5936         da.renumberInPlace(d)
5937         da.renumber(d)
5938         pass
5939
5940     def testSwigGetItem1(self):
5941         da=DataArrayInt.New()
5942         da.alloc(16,3)
5943         da.rearrange(1)
5944         da.iota(7)
5945         da.rearrange(3)
5946         da.setInfoOnComponent(0,"X [m]")
5947         da.setInfoOnComponent(1,"Y [m]")
5948         da.setInfoOnComponent(2,"Z [km]")
5949         da2=da[5:-1]
5950         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())
5951         da2=da[4]
5952         self.assertEqual([19, 20, 21],da2.getValues())
5953         try:
5954             da2=da[4:17]
5955         except InterpKernelException as e:
5956             self.assertTrue(True)
5957         else:
5958             self.assertTrue(False)
5959             pass
5960         da2=da[5:-2,2]
5961         self.assertEqual([24, 27, 30, 33, 36, 39, 42, 45, 48],da2.getValues())
5962         da2=da[5:8,:]
5963         self.assertEqual([22, 23, 24, 25, 26, 27, 28, 29, 30],da2.getValues())
5964         da2=da[:]
5965         self.assertTrue(da2.isEqual(da))
5966         da2=da[:,:]
5967         self.assertTrue(da2.isEqual(da))
5968         try:
5969             da2=da[:,:,:]
5970         except InterpKernelException as e:
5971             self.assertTrue(True)
5972         else:
5973             self.assertTrue(False)
5974             pass
5975         try:
5976             da2=da[5:8,-2]
5977         except InterpKernelException as e:
5978             self.assertTrue(True)
5979         else:
5980             self.assertTrue(False)
5981             pass
5982         da2=da[5:8,:-2]
5983         self.assertEqual([22, 25, 28],da2.getValues())
5984         try:
5985             da2=da[5:-18,2]
5986         except InterpKernelException as e:
5987             self.assertTrue(True)
5988         else:
5989             self.assertTrue(False)
5990             pass
5991         da2=da[5:5,2]
5992         self.assertEqual([],da2.getValues())
5993         pass
5994
5995     def testSwigGetItem2(self):
5996         da=DataArrayDouble.New()
5997         da.alloc(16,3)
5998         da.rearrange(1)
5999         da.iota(7)
6000         da.rearrange(3)
6001         da.setInfoOnComponent(0,"X [m]")
6002         da.setInfoOnComponent(1,"Y [m]")
6003         da.setInfoOnComponent(2,"Z [km]")
6004         da2=da[5:-1]
6005         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())
6006         da2=da[4]
6007         self.assertEqual([19., 20., 21],da2.getValues())
6008         try:
6009             da2=da[4:17]
6010         except InterpKernelException as e:
6011             self.assertTrue(True)
6012         else:
6013             self.assertTrue(False)
6014             pass
6015         da2=da[5:-2,2]
6016         self.assertEqual([24., 27., 30., 33., 36., 39., 42., 45., 48.],da2.getValues())
6017         da2=da[5:8,:]
6018         self.assertEqual([22., 23., 24., 25., 26., 27., 28., 29., 30.],da2.getValues())
6019         da2=da[:]
6020         self.assertTrue(da2.isEqual(da,1e-12))
6021         da2=da[:,:]
6022         self.assertTrue(da2.isEqual(da,1e-12))
6023         try:
6024             da2=da[:,:,:]
6025         except InterpKernelException as e:
6026             self.assertTrue(True)
6027         else:
6028             self.assertTrue(False)
6029             pass
6030         try:
6031             da2=da[5:8,-2]
6032         except InterpKernelException as e:
6033             self.assertTrue(True)
6034         else:
6035             self.assertTrue(False)
6036             pass
6037         da2=da[5:8,:-2]
6038         self.assertEqual([22., 25., 28.],da2.getValues())
6039         try:
6040             da2=da[5:-18,2]
6041         except InterpKernelException as e:
6042             self.assertTrue(True)
6043         else:
6044             self.assertTrue(False)
6045             pass
6046         da2=da[5:5,2]
6047         self.assertEqual([],da2.getValues())
6048         pass
6049
6050     def testSwigSetItem1(self):
6051         da=DataArrayInt.New()
6052         da.alloc(20,1)
6053         da.iota(7)
6054         da.rearrange(5)
6055         da.setInfoOnComponent(0,"X [m]") ; da.setInfoOnComponent(1,"Y [km]") ; da.setInfoOnComponent(2,"Y [m]")
6056         da.setInfoOnComponent(3,"Z [W]") ; da.setInfoOnComponent(4,"ZZ [km]") ;
6057         da[:,2]=3
6058         self.assertEqual([7, 8, 3, 10, 11, 12, 13, 3, 15, 16, 17, 18, 3, 20, 21, 22, 23, 3, 25, 26],da.getValues())
6059         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6060         da[2]=3
6061         self.assertEqual([7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 3, 3, 3, 3, 3, 22, 23, 24, 25, 26],da.getValues())
6062         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6063         da[[0,3]]=-1
6064         self.assertEqual([-1, -1, -1, -1, -1, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, -1, -1, -1, -1, -1],da.getValues())
6065         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6066         da[:,[1,3,4]]=-3
6067         self.assertEqual([7, -3, 9, -3, -3, 12, -3, 14, -3, -3, 17, -3, 19, -3, -3, 22, -3, 24, -3, -3],da.getValues())
6068         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6069         da2=DataArrayInt.New() ; da2.setValues([0,2,3],3,1)
6070         da[da2]=-7
6071         self.assertEqual([-7, -7, -7, -7, -7, 12, 13, 14, 15, 16, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7],da.getValues())
6072         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6073         da[da2,-2:]=-7
6074         self.assertEqual([7, 8, 9, -7, -7, 12, 13, 14, 15, 16, 17, 18, 19, -7, -7, 22, 23, 24, -7, -7],da.getValues())
6075         # Let's test with DAI right hand side
6076         da1=DataArrayInt.New()
6077         da1.setValues([25,26,27,125,126,127],2,3)
6078         #
6079         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6080         da[-2:,1:4]=da1
6081         self.assertEqual([7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 25, 26, 27, 21, 22, 125, 126, 127, 26],da.getValues())
6082         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6083         da[1:,3]=[225,226,227]
6084         self.assertEqual([7, 8, 9, 10, 11, 12, 13, 14, 225, 16, 17, 18, 19, 226, 21, 22, 23, 24, 227, 26],da.getValues())
6085         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6086         da[1,2:]=[225,226,227]
6087         self.assertEqual([7, 8, 9, 10, 11, 12, 13, 225, 226, 227, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26],da.getValues())
6088         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6089         da[da2,-2:]=[88,99,1010,1111,1212,1313]
6090         self.assertEqual([7, 8, 9, 88, 99, 12, 13, 14, 15, 16, 17, 18, 19, 1010, 1111, 22, 23, 24, 1212, 1313],da.getValues())
6091         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6092         da3=DataArrayInt.New(); da3.setValues([88,99,1010,1111,1212,1313],3,2)
6093         da[da2,-2:]=da3
6094         self.assertEqual([7, 8, 9, 88, 99, 12, 13, 14, 15, 16, 17, 18, 19, 1010, 1111, 22, 23, 24, 1212, 1313],da.getValues())
6095         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6096         da[da2,[0,2]]=da3
6097         self.assertEqual([88, 8, 99, 10, 11, 12, 13, 14, 15, 16, 1010, 18, 1111, 20, 21, 1212, 23, 1313, 25, 26],da.getValues())
6098         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6099         da[da2,0:3:2]=da3
6100         self.assertEqual([88, 8, 99, 10, 11, 12, 13, 14, 15, 16, 1010, 18, 1111, 20, 21, 1212, 23, 1313, 25, 26],da.getValues())
6101         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6102         da[da2,0:3:2]=-8
6103         self.assertEqual([-8, 8, -8, 10, 11, 12, 13, 14, 15, 16, -8, 18, -8, 20, 21, -8, 23, -8, 25, 26],da.getValues())
6104         pass
6105
6106     def testSwigSetItem2(self):
6107         da=DataArrayDouble.New()
6108         da.alloc(20,1)
6109         da.iota(7)
6110         da.rearrange(5)
6111         da.setInfoOnComponent(0,"X [m]") ; da.setInfoOnComponent(1,"Y [km]") ; da.setInfoOnComponent(2,"Y [m]")
6112         da.setInfoOnComponent(3,"Z [W]") ; da.setInfoOnComponent(4,"ZZ [km]") ;
6113         da[:,2]=3.
6114         self.assertEqual([7., 8., 3., 10., 11., 12., 13., 3., 15., 16., 17., 18., 3., 20., 21., 22., 23., 3., 25., 26.],da.getValues())
6115         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6116         da[2]=3.
6117         self.assertEqual([7., 8., 9., 10., 11., 12., 13., 14., 15., 16., 3., 3., 3., 3., 3., 22., 23., 24., 25., 26.],da.getValues())
6118         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6119         da[[0,3]]=-1.
6120         self.assertEqual([-1., -1., -1., -1., -1., 12., 13., 14., 15., 16., 17., 18., 19., 20., 21., -1., -1., -1., -1., -1.],da.getValues())
6121         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6122         da[:,[1,3,4]]=-3.
6123         self.assertEqual([7., -3., 9., -3., -3., 12., -3., 14., -3., -3., 17., -3., 19., -3., -3., 22., -3., 24., -3., -3.],da.getValues())
6124         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6125         da2=DataArrayInt.New() ; da2.setValues([0,2,3],3,1)
6126         da[da2]=-7.
6127         self.assertEqual([-7., -7., -7., -7., -7., 12., 13., 14., 15., 16., -7., -7., -7., -7., -7., -7., -7., -7., -7., -7.],da.getValues())
6128         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6129         da[da2,-2:]=-7
6130         self.assertEqual([7., 8., 9., -7., -7., 12., 13., 14., 15., 16., 17., 18., 19., -7., -7., 22., 23., 24., -7., -7.],da.getValues())
6131         # Let's test with DAI right hand side
6132         da1=DataArrayDouble.New()
6133         da1.setValues([25,26,27,125,126,127],2,3)
6134         #
6135         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6136         da[-2:,1:4]=da1
6137         self.assertEqual([7., 8., 9., 10., 11., 12., 13., 14., 15., 16., 17., 25., 26., 27., 21., 22., 125., 126., 127., 26.],da.getValues())
6138         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6139         da[1:,3]=[225.,226.,227.]
6140         self.assertEqual([7., 8., 9., 10., 11., 12., 13., 14., 225., 16., 17., 18., 19., 226., 21., 22., 23., 24., 227., 26.],da.getValues())
6141         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6142         da[1,2:]=[225,226,227]
6143         self.assertEqual([7., 8., 9., 10., 11., 12., 13., 225., 226., 227., 17., 18., 19., 20., 21., 22., 23., 24., 25., 26.],da.getValues())
6144         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6145         da[da2,-2:]=[88,99,1010,1111,1212,1313]
6146         self.assertEqual([7., 8., 9., 88., 99., 12., 13., 14., 15., 16., 17., 18., 19., 1010., 1111., 22., 23., 24., 1212., 1313.],da.getValues())
6147         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6148         da3=DataArrayDouble.New(); da3.setValues([88,99,1010,1111,1212,1313],3,2)
6149         da[da2,-2:]=da3
6150         self.assertEqual([7., 8., 9., 88., 99., 12., 13., 14., 15., 16., 17., 18., 19., 1010., 1111., 22., 23., 24., 1212., 1313.],da.getValues())
6151         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6152         da[da2,[0,2]]=da3
6153         self.assertEqual([88., 8., 99., 10., 11., 12., 13., 14., 15., 16., 1010., 18., 1111., 20., 21., 1212., 23., 1313., 25., 26.],da.getValues())
6154         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6155         da[da2,0:3:2]=da3
6156         self.assertEqual([88., 8., 99., 10., 11., 12., 13., 14., 15., 16., 1010., 18., 1111., 20., 21., 1212., 23., 1313., 25., 26.],da.getValues())
6157         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6158         da[da2,0:3:2]=-8.
6159         self.assertEqual([-8., 8., -8., 10., 11., 12., 13., 14., 15., 16., -8., 18., -8., 20., 21., -8., 23., -8., 25., 26.],da.getValues())
6160         pass
6161
6162     def testSwigDADOp(self):
6163         da=DataArrayDouble.New()
6164         da.alloc(12,1)
6165         da.iota(7.)
6166         da1=DataArrayDouble.New()
6167         da1.alloc(12,1)
6168         da1.iota(8.)
6169         da2=da+da1
6170         self.assertEqual([15., 17., 19., 21., 23., 25., 27., 29., 31., 33., 35., 37.],da2.getValues())
6171         da2=da+3
6172         da3=3+da
6173         self.assertTrue(da2.isEqual(da3,1e-12))
6174         da2=da-1.
6175         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())
6176         da2=1-da
6177         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())
6178         da2=da*3
6179         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())
6180         da2=3.*da
6181         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())
6182         da2=da*da1
6183         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())
6184         da2=da/4.
6185         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())
6186         da3=4./da
6187         da4=da3*da2
6188         self.assertTrue(da4.isUniform(1.,1e-12))
6189         st1=da.getHiddenCppPointer()
6190         da+=1
6191         st2=da.getHiddenCppPointer()
6192         self.assertEqual(st1,st2)
6193         self.assertTrue(da.isEqual(da1,1e-12))
6194         da-=8
6195         st2=da.getHiddenCppPointer()
6196         self.assertEqual(st1,st2)
6197         self.assertEqual(range(12),da.getValues())
6198         da+=da1
6199         st2=da.getHiddenCppPointer()
6200         self.assertEqual(st1,st2)
6201         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())
6202         da*=0.5
6203         st2=da.getHiddenCppPointer()
6204         self.assertEqual(st1,st2)
6205         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())
6206         da*=da1
6207         st2=da.getHiddenCppPointer()
6208         self.assertEqual(st1,st2)
6209         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())
6210         da/=da1
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/=2
6214         st2=da.getHiddenCppPointer()
6215         self.assertEqual(st1,st2)
6216         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())
6217         da.rearrange(3)
6218         da5=DataArrayDouble.New()
6219         da5.setValues([5.,4.,3.,2.],4,1)
6220         da*=da5 # it works with unmathing number of compo
6221         st2=da.getHiddenCppPointer()
6222         self.assertEqual(st1,st2)
6223         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())
6224         #
6225         da.alloc(30,1)
6226         da.iota(7.)
6227         da.rearrange(3)
6228         ids=DataArrayInt.New()
6229         ids.setValues([3,4,7],3,1)
6230         da[ids,:]=[5.,8.,9.]
6231         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())
6232         #
6233         da.rearrange(1) ; da.iota(7) ; da.rearrange(3)
6234         da[ids,[1,2]]=[5,8]
6235         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())
6236         pass
6237
6238     def testSwigDAIOp(self):
6239         da=DataArrayInt.New()
6240         da.alloc(12,1)
6241         da.iota(7)
6242         da1=DataArrayInt.New()
6243         da1.alloc(12,1)
6244         da1.iota(8)
6245         da2=da+da1
6246         self.assertEqual([15,17,19,21,23,25,27,29,31,33,35,37],da2.getValues())
6247         da2=da+3
6248         da3=3+da
6249         self.assertTrue(da2.isEqual(da3))
6250         da2=da-1
6251         self.assertEqual([6,7,8,9,10,11,12,13,14,15,16,17],da2.getValues())
6252         da2=1-da
6253         self.assertEqual([-6,-7,-8,-9,-10,-11,-12,-13,-14,-15,-16,-17],da2.getValues())
6254         da2=da*3
6255         self.assertEqual([21,24,27,30,33,36,39,42,45,48,51,54.0],da2.getValues())
6256         da2=3*da
6257         self.assertEqual([21,24,27,30,33,36,39,42,45,48,51,54.0],da2.getValues())
6258         da2=da*da1
6259         self.assertEqual([56,72,90,110,132,156,182,210,240,272,306,342.0],da2.getValues())
6260         da2=da/4
6261         self.assertEqual([1,2,2,2,2,3,3,3,3,4,4,4],da2.getValues())
6262         da3=4/da
6263         da4=da3*da2
6264         self.assertTrue(da4.isUniform(0))
6265         st1=da.getHiddenCppPointer()
6266         da+=1
6267         st2=da.getHiddenCppPointer()
6268         self.assertEqual(st1,st2)
6269         self.assertTrue(da.isEqual(da1))
6270         da-=8
6271         st2=da.getHiddenCppPointer()
6272         self.assertEqual(st1,st2)
6273         self.assertEqual(range(12),da.getValues())
6274         da+=da1
6275         st2=da.getHiddenCppPointer()
6276         self.assertEqual(st1,st2)
6277         self.assertEqual([8,10,12,14,16,18,20,22,24,26,28,30],da.getValues())
6278         da/=2
6279         st2=da.getHiddenCppPointer()
6280         self.assertEqual(st1,st2)
6281         self.assertEqual([4,5,6,7,8,9,10,11,12,13,14,15],da.getValues())
6282         da*=da1
6283         st2=da.getHiddenCppPointer()
6284         self.assertEqual(st1,st2)
6285         self.assertEqual([32,45,60,77,96,117,140,165,192,221,252,285],da.getValues())
6286         da/=da1
6287         self.assertEqual(st1,st2)
6288         self.assertEqual([4,5,6,7,8,9,10,11,12,13,14,15],da.getValues())
6289         da/=2
6290         st2=da.getHiddenCppPointer()
6291         self.assertEqual(st1,st2)
6292         self.assertEqual([2,2, 3,3, 4,4, 5,5, 6,6, 7,7],da.getValues())
6293         da.rearrange(3)
6294         da5=DataArrayInt.New()
6295         da5.setValues([5,4,3,2],4,1)
6296         da*=da5 # it works with unmathing number of compo
6297         st2=da.getHiddenCppPointer()
6298         self.assertEqual(st1,st2)
6299         self.assertEqual([10,10, 15,12,16,16,15,15, 18,12,14,14],da.getValues())
6300         da%=6
6301         st2=da.getHiddenCppPointer()
6302         self.assertEqual(st1,st2)
6303         self.assertEqual([4,4,3,0,4,4,3,3,0,0,2,2],da.getValues())
6304         #
6305         da.alloc(30,1)
6306         da.iota(7)
6307         da.rearrange(3)
6308         ids=DataArrayInt.New()
6309         ids.setValues([3,4,7],3,1)
6310         da[ids,:]=[5,8,9]
6311         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())
6312         #
6313         da.rearrange(1) ; da.iota(7) ; da.rearrange(3)
6314         da[ids,[1,2]]=[5,8]
6315         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())
6316         pass
6317
6318     def testSwigDAIOp2(self):
6319         da=DataArrayInt.New()
6320         st=da.getHiddenCppPointer()
6321         da.alloc(10,3)
6322         da.rearrange(1)
6323         da.iota(0)
6324         da.rearrange(3)
6325         da[:,1]+=4
6326         da[-2:,2]+=10
6327         da[-2:,2]+=10
6328         da[:,2]+=da[:,0]
6329         da[da[0],:]=7
6330         self.assertEqual(st,da.getHiddenCppPointer())
6331         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])
6332         pass
6333
6334     def testSwigDAIOp3(self):
6335         da=DataArrayInt.New()
6336         self.assertRaises(InterpKernelException,da.__len__)
6337         self.assertRaises(InterpKernelException,da.__int__)
6338         for elt in da:
6339             self.assertTrue(False)
6340             pass
6341         da.alloc(12,3)
6342         da.rearrange(1) ; da.fillWithZero()
6343         l1=list(da)
6344         self.assertEqual(36,len(da));
6345         da.rearrange(3)
6346         tmp=da[0]
6347         self.assertRaises(InterpKernelException,tmp.__int__)
6348         self.assertEqual(12,len(da));
6349         l=list(da)
6350         for elt in enumerate(l):
6351             elt[1][2]=elt[0]
6352             pass
6353         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]
6354         self.assertEqual(ref,da.getValues());
6355         da.rearrange(1)
6356         l=[int(elt) for elt in l1]
6357         self.assertEqual(ref,da.getValues());
6358         self.assertEqual(11,int(da[-1:]))
6359         pass
6360
6361     def testSwigDADOp3(self):
6362         da=DataArrayDouble.New()
6363         self.assertRaises(InterpKernelException,da.__len__)
6364         self.assertRaises(InterpKernelException,da.__float__)
6365         for elt in da:
6366             self.assertTrue(False)
6367             pass
6368         da.alloc(12,3)
6369         da.rearrange(1) ; da.fillWithZero()
6370         l1=list(da)
6371         self.assertEqual(36,len(da));
6372         da.rearrange(3)
6373         tmp=da[0]
6374         self.assertRaises(InterpKernelException,tmp.__float__)
6375         self.assertEqual(12,len(da));
6376         l=list(da)
6377         for elt in enumerate(l):
6378             elt[1][2]=elt[0]
6379             pass
6380         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.]
6381         self.assertEqual(ref,da.getValues());
6382         da.rearrange(1)
6383         l=[float(elt) for elt in l1]
6384         self.assertEqual(ref,da.getValues());
6385         self.assertEqual(11.,float(da[-1:]))
6386         pass
6387
6388     def testSwigDataArrayIntIterator1(self):
6389         da=DataArrayInt.New()
6390         da.alloc(12,1)
6391         da.iota(2)
6392         da.rearrange(3)
6393         # __getitem__ testing
6394         li=[]
6395         for it in da:
6396             li+=it[1:]
6397             pass
6398         self.assertEqual([3, 4, 6, 7, 9, 10, 12, 13],li)
6399         li=[]
6400         for it in da:
6401             li+=[it[-1]]
6402             pass
6403         self.assertEqual([4, 7, 10, 13],li)
6404         li=[]
6405         for it in da:
6406             li+=it[[2,1,0]]
6407             pass
6408         self.assertEqual([4, 3, 2, 7, 6, 5, 10, 9, 8, 13, 12, 11],li)
6409         # __setitem__ testing
6410         da3=da.deepCpy()
6411         da2=DataArrayInt.New()
6412         da2.alloc(12,1)
6413         da2.iota(2002)
6414         da2.rearrange(3)
6415         it2=da2.__iter__()
6416         i=0
6417         for it in da:
6418             pt=it2.next()
6419             it[:]=pt
6420             pass
6421         self.assertTrue(da.isEqual(da2))
6422         da=da3
6423         da3=da.deepCpy()
6424         #
6425         for it in da:
6426             it[:]=5
6427             pass
6428         da.rearrange(1)
6429         self.assertTrue(da.isUniform(5))
6430         da=da3
6431         da3=da.deepCpy()
6432         #
6433         for it in da:
6434             it[:]=[8,9,12]
6435             pass
6436         self.assertEqual([8, 9, 12, 8, 9, 12, 8, 9, 12, 8, 9, 12],da.getValues())
6437         da=da3
6438         da3=da.deepCpy()
6439         #
6440         for it in da:
6441             it[2]=[7]
6442             pass
6443         self.assertEqual([2, 3, 7, 5, 6, 7, 8, 9, 7, 11, 12, 7],da.getValues())
6444         pass
6445
6446     def testSwigDataArrayDoubleIterator1(self):
6447         da=DataArrayDouble.New()
6448         da.alloc(12,1)
6449         da.iota(2)
6450         da.rearrange(3)
6451         # __getitem__ testing
6452         li=[]
6453         for it in da:
6454             li+=it[1:]
6455             pass
6456         self.assertEqual([3, 4, 6, 7, 9, 10, 12, 13],li)
6457         li=[]
6458         for it in da:
6459             li+=[it[-1]]
6460             pass
6461         self.assertEqual([4, 7, 10, 13],li)
6462         li=[]
6463         for it in da:
6464             li+=it[[2,1,0]]
6465             pass
6466         self.assertEqual([4, 3, 2, 7, 6, 5, 10, 9, 8, 13, 12, 11],li)
6467         # __setitem__ testing
6468         da3=da.deepCpy()
6469         da2=DataArrayDouble.New()
6470         da2.alloc(12,1)
6471         da2.iota(2002)
6472         da2.rearrange(3)
6473         it2=da2.__iter__()
6474         i=0
6475         for it in da:
6476             pt=it2.next()
6477             it[:]=pt
6478             pass
6479         self.assertTrue(da.isEqual(da2,1e-12))
6480         da=da3
6481         da3=da.deepCpy()
6482         #
6483         for it in da:
6484             it[:]=5
6485             pass
6486         da.rearrange(1)
6487         self.assertTrue(da.isUniform(5,1e-12))
6488         da=da3
6489         da3=da.deepCpy()
6490         #
6491         for it in da:
6492             it[:]=[8,9,12]
6493             pass
6494         self.assertEqual([8, 9, 12, 8, 9, 12, 8, 9, 12, 8, 9, 12],da.getValues())
6495         da=da3
6496         da3=da.deepCpy()
6497         #
6498         for it in da:
6499             it[2]=[7]
6500             pass
6501         self.assertEqual([2, 3, 7, 5, 6, 7, 8, 9, 7, 11, 12, 7],da.getValues())
6502         pass
6503
6504     def testSwigUMeshIterator1(self):
6505         m=MEDCouplingDataForTest.build2DTargetMesh_1()
6506         li1=[]
6507         li2=[]
6508         for cell in m:
6509             li1+=cell.getAllConn()[1:]
6510             li2+=[cell.getType()]
6511             pass
6512         self.assertEqual(li1,[0, 3, 4, 1, 1, 4, 2, 4, 5, 2, 6, 7, 4, 3, 7, 8, 5, 4])
6513         self.assertEqual(li2,[4, 3, 3, 4, 4])
6514         pass
6515
6516     def testSwigUMeshIterator2(self):
6517         m=MEDCouplingDataForTest.build2DTargetMesh_1()
6518         self.assertRaises(InterpKernelException,m.cellsByType);
6519         m.rearrange2ConsecutiveCellTypes()
6520         li1=[]
6521         li2=[]
6522         li3=[]
6523         for cellsByType in m.cellsByType():
6524             li1.append(cellsByType.getType())
6525             li2.append(cellsByType.getNumberOfElems())
6526             temp=[]
6527             for cell in cellsByType:
6528                 t=[None,None]
6529                 t[0]=cell.getType()
6530                 t[1]=cell.getAllConn()[1:]
6531                 temp.append(t)
6532                 pass
6533             li3.append(temp)
6534             pass
6535         self.assertEqual(li1,[4, 3])
6536         self.assertEqual(li2,[3, 2])
6537         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)]]])
6538         pass
6539
6540     def testDAIAggregateMulti1(self):
6541         a=DataArrayInt.New()
6542         a.setValues(range(4),2,2)
6543         a.setName("aa")
6544         b=DataArrayInt.New()
6545         b.setValues(range(6),3,2)
6546         c=DataArrayInt.Aggregate([a,b])
6547         self.assertEqual(range(4)+range(6),c.getValues())
6548         self.assertEqual("aa",c.getName())
6549         self.assertEqual(5,c.getNumberOfTuples())
6550         self.assertEqual(2,c.getNumberOfComponents())
6551         pass
6552
6553     def testMergeUMeshes2(self):
6554         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6555         m2=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6556         m3=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6557         #
6558         vec1=[0,2,3]
6559         m2_2=m2.buildPartOfMySelf(vec1,False);
6560         vec2=[1,1]
6561         m3_2=m3.buildPartOfMySelf(vec2,False);
6562         #
6563         ms=[m1,m2_2,m3_2];
6564         #
6565         self.assertRaises(InterpKernelException,MEDCouplingUMesh.MergeUMeshes,ms+[None]);
6566         self.assertRaises(InterpKernelException,MEDCouplingUMesh.MergeUMeshes,ms+[3.4])
6567         m4=MEDCouplingUMesh.MergeUMeshes(ms);
6568         m4.checkCoherency();
6569         self.assertEqual(10,m4.getNumberOfCells());
6570         self.assertEqual(20,m4.getNumberOfNodes());
6571         self.assertEqual(45,m4.getMeshLength());
6572         m4bis=MEDCouplingMesh.MergeMeshes(ms);
6573         self.assertTrue(m4.isEqual(m4bis,1e-12))
6574         del m4bis
6575         #
6576         vec3=[0,1,2,3,4]
6577         m4_1=m4.buildPartOfMySelf(vec3,False);
6578         m4_1.setName(m1.getName());
6579         self.assertTrue(m4_1.isEqual(m1,1e-12));
6580         #
6581         vec4=[5,6,7]
6582         m4_2=m4.buildPartOfMySelf(vec4,False);
6583         cellCor,nodeCor=m4_2.checkGeoEquivalWith(m2_2,10,1e-12);
6584         #
6585         vec5=[8,9]
6586         m4_3=m4.buildPartOfMySelf(vec5,False);
6587         self.assertEqual(2,m4_3.getNumberOfCells());
6588         self.assertEqual(3,m4_3.getNumberOfNodes());
6589         m3_2.zipCoords();
6590         m4_3.setName(m3_2.getName());
6591         self.assertTrue(m4_3.isEqual(m3_2,1e-12));
6592         #
6593         pass
6594
6595     def testBuild0DMeshFromCoords1(self):
6596         sourceCoords=[-0.3,-0.3,0., 0.7,-0.3,0., -0.3,0.7,0., 0.7,0.7,0.]
6597         coo=DataArrayDouble.New();
6598         coo.setValues(sourceCoords,4,3);
6599         coo.setName("My0D");
6600         m=MEDCouplingUMesh.Build0DMeshFromCoords(coo);
6601         m.checkCoherency();
6602         self.assertEqual(4,m.getNumberOfNodes());
6603         self.assertEqual(4,m.getNumberOfCells());
6604         self.assertEqual(3,m.getSpaceDimension());
6605         self.assertEqual(0,m.getMeshDimension());
6606         types1=m.getAllTypes();
6607         self.assertEqual([NORM_POINT1],types1);
6608         for i in xrange(4):
6609             conn=m.getNodeIdsOfCell(i);
6610             self.assertEqual([i],conn);
6611             self.assertTrue(NORM_POINT1==m.getTypeOfCell(i));
6612             pass
6613         self.assertEqual(m.getName(),"My0D");
6614         pass
6615
6616     def testDescriptionInMeshTimeUnit1(self):
6617         text1="totoTTEDD";
6618         m=MEDCouplingDataForTest.build2DTargetMesh_1();
6619         m.setDescription(text1);
6620         self.assertEqual(m.getDescription(),text1);
6621         m2=m.deepCpy();
6622         self.assertTrue(m.isEqual(m2,1e-12));
6623         self.assertEqual(m2.getDescription(),text1);
6624         m2.setDescription("ggg");
6625         self.assertTrue(not m.isEqual(m2,1e-12));
6626         #
6627         f=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
6628         f.setTimeUnit(text1);
6629         self.assertEqual(f.getTimeUnit(),text1);
6630         f2=f.deepCpy();
6631         self.assertEqual(f2.getTimeUnit(),text1);
6632         #
6633         pass
6634
6635     def testMultiFields1(self):
6636         mfs=MEDCouplingDataForTest.buildMultiFields_1();
6637         ms=mfs.getMeshes();
6638         dms,refs=mfs.getDifferentMeshes()
6639         das=mfs.getArrays();
6640         das2,refs2=mfs.getDifferentArrays()
6641         self.assertEqual(5,len(mfs.getFields()))
6642         self.assertEqual(1,len(mfs.getFields()[0].getArrays()));
6643         self.assertEqual(2,len(mfs.getFields()[1].getArrays()));
6644         self.assertEqual(1,len(mfs.getFields()[2].getArrays()));
6645         self.assertEqual(1,len(mfs.getFields()[3].getArrays()));
6646         self.assertEqual(1,len(mfs.getFields()[4].getArrays()));
6647         self.assertEqual(5,len(ms));
6648         self.assertEqual(2,len(dms));
6649         self.assertEqual(6,len(das));
6650         self.assertEqual(5,len(das2));
6651         mfs2=mfs.deepCpy();
6652         self.assertTrue(mfs.isEqual(mfs2,1e-12,1e-12))
6653         pass
6654
6655     def testFieldOverTime1(self):
6656         fs=MEDCouplingDataForTest.buildMultiFields_2();
6657         self.assertRaises(InterpKernelException,MEDCouplingFieldOverTime.New,fs);
6658         f4bis=fs[4].buildNewTimeReprFromThis(ONE_TIME,False);
6659         fs[4]=f4bis;
6660         self.assertRaises(InterpKernelException,MEDCouplingFieldOverTime.New,fs);
6661         f4bis.setTime(2.7,20,21);
6662         fot=MEDCouplingFieldOverTime.New(fs);
6663         dt=fot.getDefinitionTimeZone();
6664         hs=dt.getHotSpotsTime();
6665         self.assertEqual(6,len(hs));
6666         expected1=[0.2,0.7,1.2,1.35,1.7,2.7]
6667         for i in xrange(6):
6668             self.assertAlmostEqual(expected1[i],hs[i],12);
6669             pass
6670         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(0.2);
6671         self.assertEqual(0,meshId);
6672         self.assertEqual(0,arrId);
6673         self.assertEqual(0,arrIdInField);
6674         self.assertEqual(0,fieldId);
6675         #
6676         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(0.7);
6677         self.assertEqual(0,meshId);
6678         self.assertEqual(1,arrId);
6679         self.assertEqual(0,arrIdInField);
6680         self.assertEqual(1,fieldId);
6681         #
6682         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeLeft(1.2);#**** WARNING left here
6683         self.assertEqual(0,meshId);
6684         self.assertEqual(2,arrId);
6685         self.assertEqual(1,arrIdInField);
6686         self.assertEqual(1,fieldId);
6687         #
6688         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(1.2);#**** WARNING right again here
6689         self.assertEqual(1,meshId);
6690         self.assertEqual(3,arrId);
6691         self.assertEqual(0,arrIdInField);
6692         self.assertEqual(2,fieldId);
6693         #
6694         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(1.35);
6695         self.assertEqual(1,meshId);
6696         self.assertEqual(3,arrId);
6697         self.assertEqual(0,arrIdInField);
6698         self.assertEqual(2,fieldId);
6699         #
6700         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(1.7);
6701         self.assertEqual(0,meshId);
6702         self.assertEqual(3,arrId);
6703         self.assertEqual(0,arrIdInField);
6704         self.assertEqual(3,fieldId);
6705         #
6706         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(2.7);
6707         self.assertEqual(1,meshId);
6708         self.assertEqual(4,arrId);
6709         self.assertEqual(0,arrIdInField);
6710         self.assertEqual(4,fieldId);
6711         #
6712         dt2=MEDCouplingDefinitionTime();
6713         self.assertTrue(not dt2.isEqual(dt));
6714         dt2.assign(dt);
6715         dt2.assign(dt);#to check memory management
6716         self.assertTrue(dt2.isEqual(dt));
6717         #
6718         dt3=MEDCouplingDefinitionTime();
6719         #
6720         pass
6721
6722     def testDAICheckAndPreparePermutation1(self):
6723         vals1=[9,10,0,6,4,11,3,7];
6724         expect1=[5,6,0,3,2,7,1,4];
6725         vals2=[9,10,0,6,10,11,3,7];
6726         da=DataArrayInt.New();
6727         da.setValues(vals1,8,1);
6728         da2=da.checkAndPreparePermutation();
6729         self.assertEqual(8,da2.getNumberOfTuples());
6730         self.assertEqual(1,da2.getNumberOfComponents());
6731         for i in xrange(8):
6732             self.assertEqual(expect1[i],da2.getIJ(i,0));
6733             pass
6734         #
6735         da=DataArrayInt.New();
6736         da.alloc(8,1);
6737         da.iota(0);
6738         da2=da.checkAndPreparePermutation();
6739         self.assertEqual(8,da2.getNumberOfTuples());
6740         self.assertEqual(1,da2.getNumberOfComponents());
6741         self.assertTrue(da2.isIdentity());
6742         #
6743         da=DataArrayInt.New();
6744         da.alloc(8,1);
6745         da.setValues(vals2,8,1);
6746         self.assertRaises(InterpKernelException,da.checkAndPreparePermutation);
6747         pass
6748
6749     def testDAIChangeSurjectiveFormat1(self):
6750         vals1=[0,3,2,3,2,2,1,2]
6751         expected1=[0,1,2,6,8]
6752         expected2=[0,  6,  2,4,5,7,  1,3]
6753         da=DataArrayInt.New();
6754         da.setValues(vals1,8,1);
6755         #
6756         da2,da2I=da.changeSurjectiveFormat(4);
6757         self.assertEqual(5,da2I.getNumberOfTuples());
6758         self.assertEqual(8,da2.getNumberOfTuples());
6759         self.assertEqual(expected1,da2I.getValues());
6760         self.assertEqual(expected2,da2.getValues());
6761         #
6762         self.assertRaises(InterpKernelException,da.changeSurjectiveFormat,3);
6763         #
6764         pass
6765
6766     def testUMeshGetCellIdsLyingOnNodes1(self):
6767         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6768         nodeIds1=[1,2,3,4,6]
6769         nodeIds2=[6,7]
6770         da=m.getCellIdsLyingOnNodes(nodeIds1,True);
6771         self.assertEqual(1,da.getNumberOfTuples());
6772         self.assertEqual(1,da.getNumberOfComponents());
6773         self.assertEqual(1,da.getIJ(0,0));
6774         da2=DataArrayInt.New()
6775         da2.setValues(nodeIds2,2,1)
6776         da=m.getCellIdsLyingOnNodes(da2,False);
6777         self.assertEqual(2,da.getNumberOfTuples());
6778         self.assertEqual(1,da.getNumberOfComponents());
6779         self.assertEqual(3,da.getIJ(0,0));
6780         self.assertEqual(4,da.getIJ(1,0));
6781         pass
6782
6783     def testUMeshFindCellIdsOnBoundary1(self):
6784         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6785         da5=m.findCellIdsOnBoundary();
6786         self.assertEqual(5,da5.getNumberOfTuples());
6787         self.assertTrue(da5.isIdentity());
6788         pass
6789
6790     def testMeshSetTime1(self):
6791         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6792         m2=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6793         #
6794         self.assertTrue(m1.isEqual(m2,1e-12));
6795         m1.setTime(3.14,6,7);
6796         tmp3,tmp1,tmp2=m1.getTime();
6797         self.assertEqual(6,tmp1);
6798         self.assertEqual(7,tmp2);
6799         self.assertAlmostEqual(3.14,tmp3,12);
6800         self.assertTrue(not m1.isEqual(m2,1e-12));
6801         m2.setTime(3.14,6,7);
6802         self.assertTrue(m1.isEqual(m2,1e-12));
6803         m1.setTimeUnit("ms");
6804         self.assertTrue(m1.getTimeUnit()=="ms");
6805         m1.setTimeUnit("us");
6806         self.assertTrue(m1.getTimeUnit()=="us");
6807         self.assertTrue(not m1.isEqual(m2,1e-12));
6808         m2.setTimeUnit("us");
6809         self.assertTrue(m1.isEqual(m2,1e-12));
6810         m2.setTime(3.14,6,8);
6811         self.assertTrue(not m1.isEqual(m2,1e-12));
6812         m2.setTime(3.14,7,7);
6813         self.assertTrue(not m1.isEqual(m2,1e-12));
6814         m2.setTime(3.15,6,7);
6815         self.assertTrue(not m1.isEqual(m2,1e-12));
6816         #
6817         m1.setTime(10.34,55,12);
6818         m3=m1.deepCpy();
6819         self.assertTrue(m1.isEqual(m3,1e-12));
6820         tmp3,tmp1,tmp2=m3.getTime();
6821         self.assertEqual(55,tmp1);
6822         self.assertEqual(12,tmp2);
6823         self.assertAlmostEqual(10.34,tmp3,12);
6824         #
6825         # testing CMesh
6826         coo1=[0.,1.,2.,3.5]
6827         a=DataArrayDouble.New();
6828         a.setValues(coo1,4,1);
6829         b=MEDCouplingCMesh.New();
6830         b.setCoordsAt(0,a);
6831         #
6832         b.setTime(5.67,8,100);
6833         tmp3,tmp1,tmp2=b.getTime();
6834         self.assertEqual(8,tmp1);
6835         self.assertEqual(100,tmp2);
6836         self.assertAlmostEqual(5.67,tmp3,12);
6837         c=b.deepCpy();
6838         self.assertTrue(c.isEqual(b,1e-12));
6839         tmp3,tmp1,tmp2=c.getTime();
6840         self.assertEqual(8,tmp1);
6841         self.assertEqual(100,tmp2);
6842         self.assertAlmostEqual(5.67,tmp3,12);
6843         pass
6844
6845     def testApplyFuncTwo1(self):
6846         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6847         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
6848         f1.setMesh(m1);
6849         #
6850         vals=[1.,11.,21.,2.,12.,22.,3.,13.,23.,4.,14.,24.,5.,15.,25.]
6851         da=DataArrayDouble.New();
6852         da.setValues(vals,5,3);
6853         f1.setArray(da);
6854         #
6855         self.assertRaises(InterpKernelException,da.applyFunc2,1,"y+z");
6856         da.setInfoOnComponent(0,"x [m]");
6857         da.setInfoOnComponent(1,"y [mm]");
6858         da.setInfoOnComponent(2,"z [km]");
6859
6860         self.assertRaises(InterpKernelException, da.applyFunc2, 1, "x+y+zz+zzz");
6861         self.assertRaises(InterpKernelException, da.applyFunc2, 1, "toto(x+y)");
6862         self.assertRaises(InterpKernelException, da.applyFunc2, 1, "x/0");
6863
6864         da2=da.applyFunc2(1,"y+z");
6865         self.assertEqual(1,da2.getNumberOfComponents());
6866         self.assertEqual(5,da2.getNumberOfTuples());
6867         expected1=[32.,34.,36.,38.,40.]
6868         for i in xrange(5):
6869             self.assertAlmostEqual(expected1[i],da2.getIJ(0,i),12);
6870             pass
6871         da2=da.applyFunc(1,"y+z");
6872         expected2=[12.,14.,16.,18.,20.]
6873         for i in xrange(5):
6874             self.assertAlmostEqual(expected2[i],da2.getIJ(0,i),12);
6875             pass
6876         #
6877         self.assertEqual(3,f1.getNumberOfComponents());
6878         self.assertEqual(5,f1.getNumberOfTuples());
6879         f1.applyFunc2(1,"y+z");
6880         self.assertEqual(1,f1.getNumberOfComponents());
6881         self.assertEqual(5,f1.getNumberOfTuples());
6882         for i in xrange(5):
6883             self.assertAlmostEqual(expected1[i],f1.getArray().getIJ(0,i),12);
6884             pass
6885         #
6886         pass
6887
6888     def testApplyFuncThree1(self):
6889         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6890         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
6891         f1.setMesh(m1);
6892         #
6893         vals=[1.,11.,21.,2.,12.,22.,3.,13.,23.,4.,14.,24.,5.,15.,25.]
6894         da=DataArrayDouble.New();
6895         da.setValues(vals,5,3);
6896         f1.setArray(da);
6897         #
6898         vs=3*[None];
6899         vs[0]="x"; vs[1]="Y"; vs[2]="z";
6900         self.assertRaises(InterpKernelException, da.applyFunc3, 1, vs, "y+z");
6901         self.assertRaises(InterpKernelException, da.applyFunc3, 1, vs, "x+Y+z+zz+zzz");
6902         self.assertRaises(InterpKernelException, da.applyFunc3, 1, vs, "x/0");
6903         vs[1]="y";
6904         da2=da.applyFunc3(1,vs,"y+z");
6905         expected1=[32.,34.,36.,38.,40.]
6906         for i in xrange(5):
6907             self.assertAlmostEqual(expected1[i],da2.getIJ(0,i),12);
6908             pass
6909         self.assertRaises(InterpKernelException, da.applyFunc3, 1, ["x","y","z","a"],"x+a")
6910         f1.setArray(da);
6911         self.assertEqual(3,f1.getNumberOfComponents());
6912         self.assertEqual(5,f1.getNumberOfTuples());
6913         f1.applyFunc3(1,vs,"y+z");
6914         self.assertEqual(1,f1.getNumberOfComponents());
6915         self.assertEqual(5,f1.getNumberOfTuples());
6916         for i in xrange(5):
6917             self.assertAlmostEqual(expected1[i],f1.getArray().getIJ(0,i),12);
6918             pass
6919         pass
6920
6921     def testFillFromAnalyticTwo1(self):
6922         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6923         m1.setTime(3.4,5,6); m1.setTimeUnit("us");
6924         self.assertRaises(InterpKernelException,m1.fillFromAnalytic2,ON_NODES,1,"y+z");
6925         m1.getCoords().setInfoOnComponent(0,"x [m]");
6926         m1.getCoords().setInfoOnComponent(1,"y");
6927         m1.getCoords().setInfoOnComponent(2,"z");
6928         f1=m1.fillFromAnalytic2(ON_NODES,1,"y+z");
6929         self.assertAlmostEqual(3.4,f1.getTime()[0],12) ; self.assertEqual(5,f1.getTime()[1]) ; self.assertEqual(6,f1.getTime()[2])
6930         self.assertEqual("us",f1.getTimeUnit())
6931         self.assertEqual(1,f1.getNumberOfComponents());
6932         self.assertEqual(9,f1.getNumberOfTuples());
6933         expected1=[0.2, 0.7, 1.2, 0.7, 1.2, 1.7, 1.2, 1.7, 2.2]
6934         for i in xrange(9):
6935             self.assertAlmostEqual(expected1[i],f1.getArray().getIJ(0,i),12);
6936             pass
6937         pass
6938
6939     def testFillFromAnalyticThree1(self):
6940         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6941         m1.setTime(3.4,5,6); m1.setTimeUnit("us");
6942         vs=3*[None];
6943         vs[0]="x"; vs[1]="Y"; vs[2]="z";
6944         self.assertRaises(InterpKernelException,m1.fillFromAnalytic3,ON_NODES,1,vs,"y+z");
6945         vs[1]="y";
6946         f1=m1.fillFromAnalytic3(ON_NODES,1,vs,"y+z");
6947         self.assertAlmostEqual(3.4,f1.getTime()[0],12) ; self.assertEqual(5,f1.getTime()[1]) ; self.assertEqual(6,f1.getTime()[2])
6948         self.assertEqual("us",f1.getTimeUnit())
6949         self.assertEqual(1,f1.getNumberOfComponents());
6950         self.assertEqual(9,f1.getNumberOfTuples());
6951         expected1=[0.2, 0.7, 1.2, 0.7, 1.2, 1.7, 1.2, 1.7, 2.2]
6952         for i in xrange(9):
6953             self.assertAlmostEqual(expected1[i],f1.getArray().getIJ(0,i),12);
6954             pass
6955         pass
6956
6957     def testDAUnitVar1(self):
6958         da=DataArrayDouble.New();
6959         da.alloc(1,3);
6960         da.setInfoOnComponent(0,"XPS [m]");
6961         st1=da.getVarOnComponent(0);
6962         self.assertTrue(st1=="XPS");
6963         st2=da.getUnitOnComponent(0);
6964         self.assertTrue(st2=="m");
6965         #
6966         da.setInfoOnComponent(0,"XPS         [m]");
6967         st1=da.getVarOnComponent(0);
6968         self.assertTrue(st1=="XPS");
6969         st2=da.getUnitOnComponent(0);
6970         self.assertTrue(st2=="m");
6971         #
6972         da.setInfoOnComponent(0,"XPP         [m]");
6973         st1=da.getVarOnComponent(0);
6974         self.assertTrue(st1=="XPP");
6975         st2=da.getUnitOnComponent(0);
6976         self.assertTrue(st2=="m");
6977         #
6978         da.setInfoOnComponent(0,"XPP kdep  kefer   [ m  ]");
6979         st1=da.getVarOnComponent(0);
6980         self.assertTrue(st1=="XPP kdep  kefer");
6981         st2=da.getUnitOnComponent(0);
6982         self.assertTrue(st2==" m  ");
6983         #
6984         da.setInfoOnComponent(0,"     XPP k[  dep  k]efer   [ m^ 2/s^3*kJ  ]");
6985         st1=da.getVarOnComponent(0);
6986         self.assertTrue(st1=="     XPP k[  dep  k]efer");
6987         st2=da.getUnitOnComponent(0);
6988         self.assertTrue(st2==" m^ 2/s^3*kJ  ");
6989         #
6990         da.setInfoOnComponent(0,"     XPP kefer   ");
6991         st1=da.getVarOnComponent(0);
6992         self.assertTrue(st1=="     XPP kefer   ");
6993         st2=da.getUnitOnComponent(0);
6994         self.assertTrue(st2=="");
6995         #
6996         da.setInfoOnComponent(0,"temperature( bof)");
6997         st1=da.getVarOnComponent(0);
6998         self.assertTrue(st1=="temperature( bof)");
6999         st2=da.getUnitOnComponent(0);
7000         self.assertTrue(st2=="");
7001         #
7002         da.setInfoOnComponent(0,"kkk [m]");
7003         da.setInfoOnComponent(1,"ppp   [m^2/kJ]");
7004         da.setInfoOnComponent(2,"abcde   [MW/s]");
7005         #
7006         vs=da.getVarsOnComponent();
7007         self.assertEqual(3,len(vs));
7008         self.assertTrue(vs[0]=="kkk");
7009         self.assertTrue(vs[1]=="ppp");
7010         self.assertTrue(vs[2]=="abcde");
7011         vs=da.getUnitsOnComponent();
7012         self.assertEqual(3,len(vs));
7013         self.assertTrue(vs[0]=="m");
7014         self.assertTrue(vs[1]=="m^2/kJ");
7015         self.assertTrue(vs[2]=="MW/s");
7016         pass
7017
7018     def testGaussCoordinates1(self):
7019         #Testing 1D cell types
7020         m1=MEDCouplingDataForTest.build1DMultiTypes_1();
7021         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,ONE_TIME);
7022         f.setMesh(m1);
7023         wg1=[0.3];
7024         gsCoo1=[0.2];
7025         refCoo1=[-1.0,1.0];
7026         f.setGaussLocalizationOnType(NORM_SEG2,refCoo1,gsCoo1,wg1);
7027         wg2=wg1;
7028         gsCoo2=[0.2];
7029         refCoo2=[-1.0,1.0,0.0];
7030         f.setGaussLocalizationOnType(NORM_SEG3,refCoo2,gsCoo2,wg2);
7031         #
7032         resToTest=f.getLocalizationOfDiscr();
7033         self.assertEqual(3,resToTest.getNumberOfComponents());
7034         self.assertEqual(2,resToTest.getNumberOfTuples());
7035         expected1=[0.6,0.6,0.6, 0.6,0.6,0.6]
7036         for i in xrange(6):
7037             self.assertAlmostEqual(expected1[i],resToTest.getIJ(0,i),14);
7038             pass
7039         #
7040         #Testing 2D cell types
7041         m2=MEDCouplingDataForTest.build2DMultiTypes_1();
7042         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,ONE_TIME);
7043         f.setMesh(m2);
7044         wg3=[0.3,0.3];
7045         tria3CooGauss=[ 0.1, 0.8, 0.2, 0.7 ]
7046         gsCoo3=tria3CooGauss
7047         tria3CooRef=[ 0.0, 0.0, 1.0 , 0.0, 0.0, 1.0 ]
7048         refCoo3=tria3CooRef;
7049         f.setGaussLocalizationOnType(NORM_TRI3,refCoo3,gsCoo3,wg3);
7050         wg4=[0.3,0.3,0.3];
7051         tria6CooGauss=[ 0.3, 0.2, 0.2, 0.1, 0.2, 0.4 ]
7052         gsCoo4=tria6CooGauss;
7053         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]
7054         refCoo4=tria6CooRef;
7055         f.setGaussLocalizationOnType(NORM_TRI6,refCoo4,gsCoo4,wg4);
7056         wg5=[0.3,0.3,0.3,0.3];
7057         quad4CooGauss=[ 0.3, 0.2, 0.2, 0.1, 0.2, 0.4, 0.15, 0.27 ]
7058         gsCoo5=quad4CooGauss;
7059         quad4CooRef=[-1.0, 1.0, -1.0, -1.0, 1.0, -1.0, 1.0, 1.0]
7060         refCoo5=quad4CooRef;
7061         f.setGaussLocalizationOnType(NORM_QUAD4,refCoo5,gsCoo5,wg5);
7062         wg6=[0.3,0.3,0.3,0.3];
7063         quad8CooGauss=[ 0.34, 0.16, 0.21, 0.3, 0.23, 0.4, 0.14, 0.37 ]
7064         gsCoo6=quad8CooGauss;
7065         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]
7066         refCoo6=quad8CooRef;
7067         f.setGaussLocalizationOnType(NORM_QUAD8,refCoo6,gsCoo6,wg6);
7068         #
7069         resToTest=f.getLocalizationOfDiscr();
7070         self.assertEqual(3,resToTest.getNumberOfComponents());
7071         self.assertEqual(13,resToTest.getNumberOfTuples());#2+3+4+4 gauss points for resp TRI3,TRI6,QUAD4,QUAD8
7072         expected2=[5.1,1.55,0.0, 4.7,1.65,0.0,
7073                    2.32,1.52,0.0, 1.6,1.32,0.0, 3.52,1.26,0.0,#TRI6
7074                    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
7075                    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
7076         for i in xrange(39):
7077             self.assertAlmostEqual(expected2[i],resToTest.getIJ(0,i),14);
7078             pass
7079         #
7080         #Testing 3D cell types
7081         m3=MEDCouplingDataForTest.build3DMultiTypes_1();
7082         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,ONE_TIME);
7083         f.setMesh(m3);
7084         #
7085         wg7=[0.3];
7086         tetra4CooGauss=[0.34, 0.16, 0.21]
7087         gsCoo7=tetra4CooGauss;
7088         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]
7089         refCoo7=tetra4CooRef;
7090         f.setGaussLocalizationOnType(NORM_TETRA4,refCoo7,gsCoo7,wg7);
7091         wg8=[0.3];
7092         tetra10CooGauss=[0.2, 0.3, 0.1]
7093         gsCoo8=tetra10CooGauss;
7094         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]
7095         refCoo8=tetra10CooRef;
7096         f.setGaussLocalizationOnType(NORM_TETRA10,refCoo8,gsCoo8,wg8);
7097         wg9=[0.3];
7098         pyra5CooGauss=[0.2, 0.3, 0.1]
7099         gsCoo9=pyra5CooGauss;
7100         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]
7101         refCoo9=pyra5CooRef;
7102         f.setGaussLocalizationOnType(NORM_PYRA5,refCoo9,gsCoo9,wg9);
7103         wg10=[0.3];
7104         pyra13CooGauss=[0.1, 0.2, 0.7]
7105         gsCoo10=pyra13CooGauss;
7106         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]
7107         refCoo10=pyra13CooRef;
7108         f.setGaussLocalizationOnType(NORM_PYRA13,refCoo10,gsCoo10,wg10);
7109         wg11=[0.3];
7110         penta6CooGauss=[0.2, 0.3, 0.1]
7111         gsCoo11=penta6CooGauss;
7112         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]
7113         refCoo11=penta6CooRef;
7114         f.setGaussLocalizationOnType(NORM_PENTA6,refCoo11,gsCoo11,wg11);
7115         wg12=[0.3];
7116         penta15CooGauss=[0.2, 0.3,0.15]
7117         gsCoo12=penta15CooGauss;
7118         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]
7119         refCoo12=penta15CooRef;
7120         f.setGaussLocalizationOnType(NORM_PENTA15,refCoo12,gsCoo12,wg12);
7121         wg13=[0.3];
7122         hexa8CooGauss=[0.2,0.3,0.15]
7123         gsCoo13=hexa8CooGauss;
7124         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]
7125         refCoo13=hexa8CooRef;
7126         f.setGaussLocalizationOnType(NORM_HEXA8,refCoo13,gsCoo13,wg13);
7127         wg14=[0.3];
7128         hexa20CooGauss=[0.11,0.3,0.55]
7129         gsCoo14=hexa20CooGauss;
7130         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]
7131         refCoo14=hexa20CooRef;
7132         f.setGaussLocalizationOnType(NORM_HEXA20,refCoo14,gsCoo14,wg14);
7133         #
7134         resToTest=f.getLocalizationOfDiscr();
7135         self.assertEqual(3,resToTest.getNumberOfComponents());
7136         self.assertEqual(8,resToTest.getNumberOfTuples());#2+3+4+4 gauss points for resp TRI3,TRI6,QUAD4,QUAD8
7137         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]
7138         for i in xrange(24):
7139             self.assertAlmostEqual(expected3[i],resToTest.getIJ(0,i),14);
7140             pass
7141         #
7142         pass
7143
7144     def testP2Localization1(self):
7145         m=MEDCouplingUMesh.New("testP2",2);
7146         coords=[0.,2.,3.5,0.,4.5,1.5,1.2,0.32,3.4,1.,2.1,2.4]
7147         conn=[0,1,2,3,4,5]
7148         coo=DataArrayDouble.New();
7149         coo.setValues(coords,6,2);
7150         m.setCoords(coo);
7151         m.allocateCells(1);
7152         m.insertNextCell(NORM_TRI6,6,conn[0:6])
7153         m.finishInsertingCells();
7154         #
7155         f=MEDCouplingFieldDouble.New(ON_NODES,ONE_TIME);
7156         f.setMesh(m);
7157         da=DataArrayDouble.New();
7158         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]
7159         da.setValues(vals1,6,3);
7160         f.setArray(da);
7161         #
7162         loc=[2.27,1.3]
7163         locs=f.getValueOnMulti(loc);
7164         expected1=[6.0921164547752236, 7.1921164547752232, 8.2921164547752255]
7165         for i in xrange(3):
7166             self.assertAlmostEqual(expected1[i],locs.getIJ(0,i),12);
7167             pass
7168         pass
7169
7170     def testP2Localization2(self):
7171         m=MEDCouplingUMesh.New("testP2_2",3);
7172         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]
7173         conn=[0,1,2,3,4,5,6,7,8,9]
7174         coo=DataArrayDouble.New();
7175         coo.setValues(coords,10,3);
7176         m.setCoords(coo);
7177         m.allocateCells(1);
7178         m.insertNextCell(NORM_TETRA10,10,conn[0:10])
7179         m.finishInsertingCells();
7180         #
7181         f=MEDCouplingFieldDouble.New(ON_NODES,ONE_TIME);
7182         f.setMesh(m);
7183         da=DataArrayDouble.New();
7184         vals1=[1.1,2.1,3.1,4.1,5.2,6.2,7.2,8.2,9.2,10.2]
7185         da.setValues(vals1,10,1);
7186         f.setArray(da);
7187         #
7188         loc=[0.64637931739890486, -0.16185896817550552, 0.22678966365273748]
7189         locs=f.getValueOnMulti(loc);
7190         expected1=[10.0844021968047]
7191         for i in xrange(1):
7192             self.assertAlmostEqual(expected1[i],locs.getIJ(0,i),12);
7193             pass
7194         pass
7195
7196     def testGetValueOn2(self):
7197         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7198         f=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
7199         f.setMesh(m);
7200         arr=DataArrayDouble.New();
7201         nbOfCells=m.getNumberOfCells();
7202         f.setArray(arr);
7203         values1=[7.,107.,10007.,8.,108.,10008.,9.,109.,10009.,10.,110.,10010.,11.,111.,10011.]
7204         arr.setValues(values1,nbOfCells,3);
7205         loc=[-0.05,-0.05, 0.55,-0.25, 0.55,0.15, -0.05,0.45, 0.45,0.45]
7206         f.checkCoherency();
7207         locs=f.getValueOnMulti(loc);
7208         self.assertEqual(5,locs.getNumberOfTuples());
7209         self.assertEqual(3,locs.getNumberOfComponents());
7210         for j in xrange(15):
7211             self.assertAlmostEqual(values1[j],locs.getIJ(0,j),12);
7212             pass
7213         # Testing ON_NODES
7214         f=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
7215         f.setMesh(m);
7216         arr=DataArrayDouble.New();
7217         nbOfNodes=m.getNumberOfNodes();
7218         f.setArray(arr);
7219         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.]
7220         arr.setValues(values2,nbOfNodes,3);
7221         loc2=[0.5432,-0.2432, 0.5478,0.1528, 0.5432,-0.2432, 0.5432,-0.2432]
7222         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]
7223         f.checkCoherency();
7224         loc3=DataArrayDouble.New()
7225         loc3.setValues(loc2,4,2);
7226         locs=f.getValueOnMulti(loc3);
7227         self.assertEqual(4,locs.getNumberOfTuples());
7228         self.assertEqual(3,locs.getNumberOfComponents());
7229         for i in xrange(12):
7230             self.assertAlmostEqual(expected2[i],locs.getIJ(0,i),12);
7231             pass
7232         #
7233         pass
7234
7235     def testDAIGetIdsNotEqual1(self):
7236         d=DataArrayInt.New();
7237         vals1=[2,3,5,6,8,5,5,6,1,-5]
7238         d.setValues(vals1,10,1);
7239         d2=d.getIdsNotEqual(5);
7240         self.assertEqual(7,d2.getNumberOfTuples());
7241         self.assertEqual(1,d2.getNumberOfComponents());
7242         expected1=[0,1,3,4,7,8,9]
7243         for i in xrange(7):
7244             self.assertEqual(expected1[i],d2.getIJ(0,i));
7245             pass
7246         d.rearrange(2);
7247         self.assertRaises(InterpKernelException,d.getIdsNotEqual,5);
7248         vals2=[-4,5,6]
7249         vals3=vals2;
7250         d.rearrange(1);
7251         d3=d.getIdsNotEqualList(vals3);
7252         self.assertEqual(5,d3.getNumberOfTuples());
7253         self.assertEqual(1,d3.getNumberOfComponents());
7254         expected2=[0,1,4,8,9]
7255         for i in xrange(5):
7256             self.assertEqual(expected2[i],d3.getIJ(0,i));
7257             pass
7258         pass
7259
7260     def testDAIComputeOffsets1(self):
7261         d=DataArrayInt.New();
7262         vals1=[3,5,1,2,0,8]
7263         expected1=[0,3,8,9,11,11]
7264         d.setValues(vals1,6,1);
7265         d.computeOffsets();
7266         self.assertEqual(6,d.getNumberOfTuples());
7267         self.assertEqual(1,d.getNumberOfComponents());
7268         for i in xrange(6):
7269             self.assertEqual(expected1[i],d.getIJ(0,i));
7270             pass
7271         pass
7272
7273     def testUMeshHexagonPrism1(self):
7274         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,
7275                 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];
7276         conn=[1,2,3,4,5,0,7,8,9,10,11,6]
7277         mesh=MEDCouplingUMesh.New("MyFirstHexagonalPrism",3);
7278         coo=DataArrayDouble.New();
7279         coo.setValues(coords,12,3);
7280         mesh.setCoords(coo);
7281         mesh.allocateCells(1);
7282         mesh.insertNextCell(NORM_HEXGP12,12,conn[0:12])
7283         mesh.finishInsertingCells();
7284         #
7285         mesh.checkCoherency();
7286         vols=mesh.getMeasureField(False);
7287         self.assertEqual(1,vols.getNumberOfTuples());
7288         self.assertEqual(1,vols.getNumberOfComponents());
7289         self.assertAlmostEqual(-5.196152422706632,vols.getIJ(0,0),12);
7290         bary=mesh.getBarycenterAndOwner();
7291         self.assertEqual(1,bary.getNumberOfTuples());
7292         self.assertEqual(3,bary.getNumberOfComponents());
7293         expected1=[0.,0.,1.]
7294         for i in xrange(3):
7295             self.assertAlmostEqual(expected1[i],bary.getIJ(0,i),12);
7296             pass
7297         d1=DataArrayInt.New();
7298         d2=DataArrayInt.New();
7299         d3=DataArrayInt.New();
7300         d4=DataArrayInt.New();
7301         m2=mesh.buildDescendingConnectivity(d1,d2,d3,d4);
7302         self.assertEqual(8,m2.getNumberOfCells());
7303         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]];
7304         expected2=[NORM_POLYGON, NORM_POLYGON, NORM_QUAD4, NORM_QUAD4, NORM_QUAD4, NORM_QUAD4, NORM_QUAD4, NORM_QUAD4];
7305         expected3=[6,6,4,4,4,4,4,4]
7306         for i in xrange(8):
7307             self.assertTrue(m2.getTypeOfCell(i)==expected2[i]);
7308             v=m2.getNodeIdsOfCell(i);
7309             self.assertTrue(len(v)==expected3[i]);
7310             self.assertEqual(expected4[i],v);
7311         #
7312         mesh.convertAllToPoly();
7313         self.assertTrue(NORM_POLYHED==mesh.getTypeOfCell(0));
7314         mesh.unPolyze();
7315         self.assertTrue(NORM_HEXGP12==mesh.getTypeOfCell(0));
7316         self.assertEqual(13,mesh.getMeshLength());
7317         #
7318         pass
7319
7320     def testDADCheckIsMonotonic(self):
7321         da=DataArrayDouble.New();
7322         da.setValues([-1.,1.01,2.03,6.],2,2);
7323         self.assertRaises(InterpKernelException,da.isMonotonic,True,1e-12);
7324         da.rearrange(1);
7325         self.assertTrue(da.isMonotonic(True,1e-12));
7326         da.checkMonotonic(True,1e-12);
7327         da.setIJ(2,0,6.1);
7328         self.assertTrue(not da.isMonotonic(True,1e-12));
7329         self.assertRaises(InterpKernelException,da.checkMonotonic,True,1e-12);
7330         da.setIJ(2,0,5.99);
7331         self.assertTrue(da.isMonotonic(True,1e-12));
7332         self.assertTrue(not da.isMonotonic(True,1e-1));
7333         pass
7334
7335     def testCheckCoherencyDeeper1(self):
7336         m=MEDCouplingDataForTest.build3DSourceMesh_1();
7337         m.checkCoherency();
7338         m.checkCoherency1();
7339         m.getNodalConnectivity().setIJ(8,0,-1);
7340         m.checkCoherency();
7341         self.assertRaises(InterpKernelException,m.checkCoherency1);
7342         m.getNodalConnectivity().setIJ(8,0,-6);
7343         m.checkCoherency();
7344         self.assertRaises(InterpKernelException,m.checkCoherency1);
7345         m.getNodalConnectivity().setIJ(8,0,9);#9>=NbOfNodes
7346         m.checkCoherency();
7347         self.assertRaises(InterpKernelException,m.checkCoherency1);
7348         m.getNodalConnectivity().setIJ(8,0,8);#OK
7349         m.checkCoherency();
7350         m.checkCoherency1();
7351         elts=[1,5]
7352         m.convertToPolyTypes(elts);
7353         m.checkCoherency();
7354         m.checkCoherency1();
7355         m.getNodalConnectivity().setIJ(2,0,9);#9>=NbOfNodes
7356         m.checkCoherency();
7357         self.assertRaises(InterpKernelException,m.checkCoherency1);
7358         m.getNodalConnectivity().setIJ(2,0,-3);
7359         m.checkCoherency();
7360         self.assertRaises(InterpKernelException,m.checkCoherency1);
7361         m.getNodalConnectivity().setIJ(2,0,-1);
7362         m.checkCoherency();
7363         self.assertRaises(InterpKernelException,m.checkCoherency1);#Throw because cell#0 is not a polyhedron
7364         m.getNodalConnectivity().setIJ(2,0,4);
7365         m.checkCoherency();
7366         m.checkCoherency1();
7367         m.getNodalConnectivity().setIJ(7,0,-1);
7368         m.checkCoherency();
7369         m.checkCoherency1();#OK because we are in polyhedron connec
7370         m.getNodalConnectivity().setIJ(36,0,14);
7371         m.checkCoherency();
7372         self.assertRaises(InterpKernelException,m.checkCoherency1);#Throw beacause now cell 5 is a TETRA4 (14) so mimatch of number index and static type.
7373         pass
7374
7375     def testUnPolyze2(self):
7376         m=MEDCouplingUMesh.New("jjj",3);
7377         coo=DataArrayDouble.New();
7378         coo.alloc(4,3);
7379         coo.rearrange(1);
7380         coo.iota(0);
7381         coo.rearrange(3);
7382         m.setCoords(coo);
7383         m.allocateCells(2);
7384         m.insertNextCell(NORM_TETRA4,4,[0,1,2,3]);
7385         m.insertNextCell(NORM_TETRA4,4,[0,1,2,3]);
7386         m.finishInsertingCells();
7387         m2=MEDCouplingUMesh.MergeUMeshesOnSameCoords(4*[m]);
7388         m2.convertToPolyTypes([2]);
7389         m2.unPolyze();
7390         self.assertEqual(NORM_TETRA4,m2.getTypeOfCell(2));
7391         self.assertEqual(40,m2.getMeshLength());
7392         temp2=m2.getNodeIdsOfCell(2);
7393         self.assertEqual(temp2,[0,1,2,3]);
7394         m2.checkCoherency1();
7395         m3=m2.deepCpy();
7396         m2.unPolyze();
7397         self.assertTrue(m3.isEqual(m2,1e-12));
7398         pass
7399
7400     def testDACpyFrom1(self):
7401         d=DataArrayDouble.New();
7402         d.alloc(12,1);
7403         d.iota(14.);
7404         d.rearrange(3);
7405         d.setName("Toto");
7406         d.setInfoOnComponent(0,"X [m]");
7407         d.setInfoOnComponent(1,"Y [m]");
7408         d.setInfoOnComponent(2,"Z [m]");
7409         #
7410         d1=DataArrayDouble.New();
7411         self.assertTrue(not d.isEqual(d1,1e-12));
7412         d1.cpyFrom(d);
7413         self.assertTrue(d.isEqual(d1,1e-12));
7414         d1.cpyFrom(d);
7415         self.assertTrue(d.isEqual(d1,1e-12));
7416         d1.rearrange(2);
7417         self.assertTrue(not d.isEqual(d1,1e-12));
7418         d1.cpyFrom(d);
7419         self.assertTrue(d.isEqual(d1,1e-12));
7420         #
7421         d2=d.convertToIntArr();
7422         d4=DataArrayInt.New();
7423         self.assertTrue(not d2.isEqual(d4));
7424         d4.cpyFrom(d2);
7425         self.assertTrue(d2.isEqual(d4));
7426         d4.cpyFrom(d2);
7427         self.assertTrue(d2.isEqual(d4));
7428         d4.rearrange(2);
7429         self.assertTrue(not d2.isEqual(d4));
7430         d4.cpyFrom(d2);
7431         self.assertTrue(d2.isEqual(d4));
7432         pass
7433
7434     def testDAITransformWithIndArr1(self):
7435         tab1=[17,18,22,19]
7436         tab2=[0,1,1,3,3,0,1,3,2,2,3,0]
7437         expected=[17,18,18,19,19,17,18,19,22,22,19,17]
7438         d=DataArrayInt.New();
7439         d.setValues(tab1,4,1);
7440         d1=DataArrayInt.New();
7441         d1.setValues(tab2,12,1);
7442         d2=d1[:]
7443         #
7444         d1.transformWithIndArr(d);
7445         self.assertEqual(12,d1.getNumberOfTuples());
7446         self.assertEqual(1,d1.getNumberOfComponents());
7447         for i in xrange(12):
7448             self.assertEqual(expected[i],d1.getIJ(i,0));
7449             pass
7450         #
7451         d1=d2
7452         d1.transformWithIndArr(tab1)
7453         self.assertEqual(12,d1.getNumberOfTuples());
7454         self.assertEqual(1,d1.getNumberOfComponents());
7455         for i in xrange(12):
7456             self.assertEqual(expected[i],d1.getIJ(i,0));
7457             pass
7458         pass
7459
7460     def testDAIBuildPermArrPerLevel1(self):
7461         arr=[2,0,1,1,0,1,2,0,1,1,0,0]
7462         expected1=[10,0,5,6,1,7,11,2,8,9,3,4]
7463         da=DataArrayInt.New();
7464         da.setValues(arr,12,1);
7465         da2=da.buildPermArrPerLevel();
7466         self.assertEqual(12,da2.getNumberOfTuples());
7467         self.assertEqual(1,da2.getNumberOfComponents());
7468         for i in xrange(12):
7469             self.assertEqual(expected1[i],da2.getIJ(i,0));
7470             pass
7471         pass
7472
7473     def testDAIOperations1(self):
7474         arr1=[-1,-2,4,7,3,2,6,6,4,3,0,1]
7475         da=DataArrayInt.New();
7476         da.setValues(arr1,4,3);
7477         da1=DataArrayInt.New();
7478         da1.alloc(12,1);
7479         da1.iota(2);
7480         self.assertRaises(InterpKernelException,DataArrayInt.Add,da,da1);#not same number of tuples/Components
7481         da1.rearrange(3);
7482         da2=DataArrayInt.Add(da,da1);
7483         self.assertEqual(4,da2.getNumberOfTuples());
7484         self.assertEqual(3,da2.getNumberOfComponents());
7485         expected1=[1,1,8,12,9,9,14,15,14,14,12,14]
7486         for i in xrange(12):
7487             self.assertEqual(expected1[i],da2.getIJ(0,i));
7488             pass
7489         da1.substractEqual(da);
7490         expected2=[3,5,0,-2,3,5,2,3,6,8,12,12]
7491         for i in xrange(12):
7492             self.assertEqual(expected2[i],da1.getIJ(0,i));
7493             pass
7494         da1.rearrange(1); da1.iota(2); da1.rearrange(3);
7495         da1.addEqual(da);
7496         for i in xrange(12):
7497             self.assertEqual(expected1[i],da1.getIJ(0,i));
7498             pass
7499         da1.rearrange(1); da1.iota(2); da1.rearrange(3);
7500         da2=DataArrayInt.Multiply(da,da1);
7501         self.assertEqual(4,da2.getNumberOfTuples());
7502         self.assertEqual(3,da2.getNumberOfComponents());
7503         expected3=[-2,-6,16,35,18,14,48,54,40,33,0,13]
7504         for i in xrange(12):
7505             self.assertEqual(expected3[i],da2.getIJ(0,i));
7506             pass
7507         da.divideEqual(da1);
7508         self.assertEqual(4,da.getNumberOfTuples());
7509         self.assertEqual(3,da.getNumberOfComponents());
7510         expected4=[0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0]
7511         for i in xrange(12):
7512             self.assertEqual(expected4[i],da.getIJ(0,i));
7513             pass
7514         da.setValues(arr1,4,3);
7515         da1.multiplyEqual(da);
7516         self.assertEqual(4,da1.getNumberOfTuples());
7517         self.assertEqual(3,da1.getNumberOfComponents());
7518         for i in xrange(12):
7519             self.assertEqual(expected3[i],da1.getIJ(0,i));
7520             pass
7521         da1.rearrange(1); da1.iota(2); da1.rearrange(3);
7522         da2=DataArrayInt.Divide(da,da1);
7523         self.assertEqual(4,da2.getNumberOfTuples());
7524         self.assertEqual(3,da2.getNumberOfComponents());
7525         for i in xrange(12):
7526             self.assertEqual(expected4[i],da2.getIJ(0,i));
7527             pass
7528         da1.applyInv(321);
7529         self.assertEqual(4,da1.getNumberOfTuples());
7530         self.assertEqual(3,da1.getNumberOfComponents());
7531         expected5=[160,107,80,64,53,45,40,35,32,29,26,24]
7532         for i in xrange(12):
7533             self.assertEqual(expected5[i],da1.getIJ(0,i));
7534             pass
7535         da1.applyDivideBy(2);
7536         self.assertEqual(4,da1.getNumberOfTuples());
7537         self.assertEqual(3,da1.getNumberOfComponents());
7538         expected6=[80,53,40,32,26,22,20,17,16,14,13,12]
7539         for i in xrange(12):
7540             self.assertEqual(expected6[i],da1.getIJ(0,i));
7541             pass
7542         expected7=[3,4,5,4,5,1,6,3,2,0,6,5]
7543         da1.applyModulus(7);
7544         for i in xrange(12):
7545             self.assertEqual(expected7[i],da1.getIJ(0,i));
7546             pass
7547         da1.applyLin(1,1);
7548         expected8=[3,3,3,3,3,1,3,3,0,0,3,3]
7549         da1.applyRModulus(3);
7550         for i in xrange(12):
7551             self.assertEqual(expected8[i],da1.getIJ(0,i));
7552             pass
7553         pass
7554
7555     def testEmulateMEDMEMBDC1(self):
7556         m,m1=MEDCouplingDataForTest.buildPointe_1();
7557         m2,da1,da2,da3,da4,da5,da0=m.emulateMEDMEMBDC(m1)
7558         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]
7559         expected1=[1,32,29,23,41,36]
7560         self.assertEqual(47,da0.getNumberOfTuples());
7561         self.assertEqual(1,da0.getNumberOfComponents());
7562         for i in xrange(47):
7563             self.assertEqual(expected0[i],da0.getIJ(0,i));
7564             pass
7565         self.assertEqual(6,da5.getNumberOfTuples());
7566         self.assertEqual(1,da5.getNumberOfComponents());
7567         for i in xrange(6):
7568             self.assertEqual(expected1[i],da5.getIJ(0,i));
7569             pass
7570         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]
7571         self.assertEqual(70,da1.getNumberOfTuples());
7572         self.assertEqual(1,da1.getNumberOfComponents());
7573         for i in xrange(70):
7574             self.assertEqual(expected2[i],da1.getIJ(0,i));
7575             pass
7576         expected3=[0,4,8,12,16,20,24,28,32,36,40,44,48,53,58,64,70]
7577         self.assertEqual(17,da2.getNumberOfTuples());
7578         self.assertEqual(1,da2.getNumberOfComponents());
7579         for i in xrange(17):
7580             self.assertEqual(expected3[i],da2.getIJ(0,i));
7581             pass
7582         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]
7583         #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];
7584         self.assertEqual(48,da4.getNumberOfTuples());
7585         self.assertEqual(1,da4.getNumberOfComponents());
7586         for i in xrange(48):
7587             self.assertEqual(expected4[i],da4.getIJ(0,i));
7588             pass
7589         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]
7590         self.assertEqual(70,da3.getNumberOfTuples());
7591         self.assertEqual(1,da3.getNumberOfComponents());
7592         for i in xrange(70):
7593             self.assertEqual(expected5[i],da3.getIJ(0,i));
7594             pass
7595         pass
7596
7597     def testGetLevArrPerCellTypes1(self):
7598         m,m1=MEDCouplingDataForTest.buildPointe_1();
7599         m1,d0,d1,d2,d3=m.buildDescendingConnectivity();
7600         order=[NORM_TRI3,NORM_QUAD4];
7601         da0,da1=m1.getLevArrPerCellTypes(order);
7602         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]
7603         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]
7604         self.assertEqual(47,da0.getNumberOfTuples());
7605         self.assertEqual(1,da0.getNumberOfComponents());
7606         for i in xrange(47):
7607             self.assertEqual(expected0[i],da0.getIJ(0,i));
7608             pass
7609         self.assertEqual(2,da1.getNumberOfTuples());
7610         self.assertEqual(1,da1.getNumberOfComponents());
7611         self.assertEqual(36,da1.getIJ(0,0));#36 TRI3
7612         self.assertEqual(11,da1.getIJ(1,0));#11 QUAD4
7613         #
7614         da2=da0.buildPermArrPerLevel();
7615         #
7616         self.assertEqual(47,da2.getNumberOfTuples());
7617         self.assertEqual(1,da2.getNumberOfComponents());
7618         for i in xrange(47):
7619             self.assertEqual(expected1[i],da2.getIJ(0,i));
7620             pass
7621         pass
7622
7623     def testSortCellsInMEDFileFrmt1(self):
7624         m,m1=MEDCouplingDataForTest.buildPointe_1();
7625         m2=m.deepCpy()
7626         da=DataArrayInt.New()
7627         da.setValues([0,1,2,14,3,12,4,5,15,6,7,8,9,10,11,13],16,1)
7628         daa=da.invertArrayN2O2O2N(16)
7629         m.renumberCells(daa,False)
7630         da2=m.sortCellsInMEDFileFrmt()
7631         self.assertEqual(da2.getValues(),[0,1,2,14,3,12,4,5,15,6,7,8,9,10,11,13])
7632         self.assertTrue(m.isEqual(m2,1e-12))
7633         self.assertTrue(da.isEqual(da2))
7634         pass
7635
7636     def testBuildPartAndReduceNodes1(self):
7637         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7638         arr=[1,0]
7639         m2,da=m.buildPartAndReduceNodes(arr);
7640         self.assertEqual(5,m2.getNumberOfNodes());
7641         self.assertEqual(2,m2.getNumberOfCells());
7642         f=m2.getMeasureField(True);
7643         self.assertAlmostEqual(0.125,f.getArray().getIJ(0,0),12);
7644         self.assertAlmostEqual(0.25,f.getArray().getIJ(1,0),12);
7645         #
7646         arr2=DataArrayInt.New()
7647         arr2.setValues(arr,2,1)
7648         m2,da=m.buildPartAndReduceNodes(arr2);
7649         self.assertEqual(5,m2.getNumberOfNodes());
7650         self.assertEqual(2,m2.getNumberOfCells());
7651         f=m2.getMeasureField(True);
7652         self.assertAlmostEqual(0.125,f.getArray().getIJ(0,0),12);
7653         self.assertAlmostEqual(0.25,f.getArray().getIJ(1,0),12);
7654         pass
7655
7656     def testDAITransformWithIndArrR1(self):
7657         tab1=[2,4,5,3,6,7]
7658         tab2=[-1,-1,0,1,2,3,4,5,-1,-1,-1,-1]
7659         expected=[0,3,1,2,4,5]
7660         d=DataArrayInt.New();
7661         d.setValues(tab1,6,1);
7662         d1=DataArrayInt.New();
7663         d1.setValues(tab2,12,1);
7664         d2=d1[:]
7665         #
7666         d3=d.transformWithIndArrR(d1);
7667         self.assertEqual(6,d3.getNumberOfTuples());
7668         self.assertEqual(1,d3.getNumberOfComponents());
7669         for i in xrange(6):
7670             self.assertEqual(expected[i],d3.getIJ(i,0));
7671             pass
7672         #
7673         d1=d2
7674         d3=d.transformWithIndArrR(tab2)
7675         self.assertEqual(6,d3.getNumberOfTuples());
7676         self.assertEqual(1,d3.getNumberOfComponents());
7677         for i in xrange(6):
7678             self.assertEqual(expected[i],d3.getIJ(i,0));
7679             pass
7680         pass
7681
7682     def testDAISplitByValueRange1(self):
7683         val1=[6,5,0,3,2,7,8,1,4]
7684         val2=[0,4,9]
7685         d=DataArrayInt.New();
7686         d.setValues(val1,9,1);
7687         e,f,g=d.splitByValueRange(val2);
7688         self.assertEqual(9,e.getNumberOfTuples());
7689         self.assertEqual(1,e.getNumberOfComponents());
7690         self.assertEqual(9,f.getNumberOfTuples());
7691         self.assertEqual(1,f.getNumberOfComponents());
7692         self.assertEqual(2,g.getNumberOfTuples());
7693         self.assertEqual(1,g.getNumberOfComponents());
7694         #
7695         expected1=[1,1,0,0,0,1,1,0,1]
7696         expected2=[2,1,0,3,2,3,4,1,0]
7697         for i in xrange(9):
7698             self.assertEqual(expected1[i],e.getIJ(i,0));
7699             self.assertEqual(expected2[i],f.getIJ(i,0));
7700             pass
7701         self.assertEqual(0,g.getIJ(0,0));
7702         self.assertEqual(1,g.getIJ(1,0));
7703         #
7704         d.setIJ(6,0,9);
7705         self.assertRaises(InterpKernelException,d.splitByValueRange,val2);
7706         pass
7707
7708     def testUMeshSplitProfilePerType1(self):
7709         val0=[2,0,1,3,4]
7710         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7711         m.renumberCells(val0,False);
7712         #
7713         val1=[0,2,3]
7714         d=DataArrayInt.New();
7715         d.setValues(val1,3,1);
7716         d.setName("sup")
7717         code,idsInPflPerType,pfls=m.splitProfilePerType(d);
7718         self.assertEqual(6,len(code));
7719         self.assertEqual(2,len(idsInPflPerType));
7720         expected1=[3,1,0, 4,2,1]
7721         for i in xrange(6):
7722             self.assertEqual(expected1[i],code[i]);
7723             pass
7724         self.assertEqual(2,len(idsInPflPerType));
7725         self.assertEqual(1,idsInPflPerType[0].getNumberOfTuples());
7726         self.assertEqual(0,idsInPflPerType[0].getIJ(0,0));
7727         self.assertEqual(2,idsInPflPerType[1].getNumberOfTuples());
7728         self.assertEqual(1,idsInPflPerType[1].getIJ(0,0));
7729         self.assertEqual(2,idsInPflPerType[1].getIJ(1,0));
7730         #
7731         self.assertEqual(2,len(pfls));
7732         self.assertEqual("sup",pfls[0].getName())
7733         self.assertEqual(1,pfls[0].getNumberOfTuples());
7734         self.assertEqual(0,pfls[0].getIJ(0,0));
7735         self.assertEqual("sup",pfls[1].getName())
7736         self.assertEqual(2,pfls[1].getNumberOfTuples());
7737         self.assertEqual(0,pfls[1].getIJ(0,0));
7738         self.assertEqual(1,pfls[1].getIJ(1,0));
7739         #
7740         val2=[0,2,3,4]
7741         d=DataArrayInt.New();
7742         d.setValues(val2,4,1);
7743         code,idsInPflPerType,pfls=m.splitProfilePerType(d);
7744         self.assertEqual(6,len(code));
7745         self.assertEqual(2,len(idsInPflPerType));
7746         expected2=[3,1,0, 4,3,-1]
7747         for i in xrange(6):
7748             self.assertEqual(expected2[i],code[i]);
7749             pass
7750         self.assertEqual(2,len(idsInPflPerType));
7751         self.assertEqual(1,idsInPflPerType[0].getNumberOfTuples());
7752         self.assertEqual(0,idsInPflPerType[0].getIJ(0,0));
7753         self.assertEqual(3,idsInPflPerType[1].getNumberOfTuples());
7754         self.assertEqual(1,idsInPflPerType[1].getIJ(0,0));
7755         self.assertEqual(2,idsInPflPerType[1].getIJ(1,0));
7756         self.assertEqual(3,idsInPflPerType[1].getIJ(2,0));
7757         #
7758         self.assertEqual(1,len(pfls));
7759         self.assertEqual(1,pfls[0].getNumberOfTuples());
7760         self.assertEqual(0,pfls[0].getIJ(0,0));
7761         #
7762         val3=[1,0,2]
7763         d=DataArrayInt.New();
7764         d.setValues(val3,3,1);
7765         code,idsInPflPerType,pfls=m.splitProfilePerType(d);
7766         self.assertEqual(6,len(code));
7767         self.assertEqual(2,len(idsInPflPerType));
7768         expected3=[3,2,0, 4,1,1]
7769         for i in xrange(6):
7770             self.assertEqual(expected3[i],code[i]);
7771             pass
7772         self.assertEqual(2,len(idsInPflPerType));
7773         self.assertEqual(2,idsInPflPerType[0].getNumberOfTuples());
7774         self.assertEqual(0,idsInPflPerType[0].getIJ(0,0));
7775         self.assertEqual(1,idsInPflPerType[0].getIJ(1,0));
7776         self.assertEqual(1,idsInPflPerType[1].getNumberOfTuples());
7777         self.assertEqual(2,idsInPflPerType[1].getIJ(0,0));
7778         #
7779         self.assertEqual(2,len(pfls));
7780         self.assertEqual(2,pfls[0].getNumberOfTuples());
7781         self.assertEqual(1,pfls[0].getIJ(0,0));
7782         self.assertEqual(0,pfls[0].getIJ(1,0));
7783         self.assertEqual(0,pfls[1].getIJ(0,0));
7784         #
7785         val4=[3,4]
7786         d=DataArrayInt.New();
7787         d.setValues(val4,2,1);
7788         code,idsInPflPerType,pfls=m.splitProfilePerType(d);
7789         self.assertEqual(3,len(code));
7790         self.assertEqual(1,len(idsInPflPerType));
7791         expected4=[4,2,0]
7792         for i in xrange(3):
7793             self.assertEqual(expected4[i],code[i]);
7794             pass
7795         self.assertEqual(1,len(idsInPflPerType));
7796         self.assertEqual(2,idsInPflPerType[0].getNumberOfTuples());
7797         self.assertEqual(0,idsInPflPerType[0].getIJ(0,0));
7798         self.assertEqual(1,idsInPflPerType[0].getIJ(1,0));
7799         #
7800         self.assertEqual(1,len(pfls));
7801         self.assertEqual(2,pfls[0].getNumberOfTuples());
7802         self.assertEqual(1,pfls[0].getIJ(0,0));
7803         self.assertEqual(2,pfls[0].getIJ(1,0));
7804         pass
7805
7806     def testDAIBuildExplicitArrByRanges1(self):
7807         d=DataArrayInt.New();
7808         vals1=[0,2,3]
7809         d.setValues(vals1,3,1);
7810         e=DataArrayInt.New();
7811         vals2=[0,3,6,10,14,20]
7812         e.setValues(vals2,6,1);
7813         #
7814         f=d.buildExplicitArrByRanges(e);
7815         self.assertEqual(11,f.getNumberOfTuples());
7816         self.assertEqual(1,f.getNumberOfComponents());
7817         expected1=[0,1,2,6,7,8,9,10,11,12,13]
7818         for i in xrange(11):
7819             self.assertEqual(expected1[i],f.getIJ(i,0));
7820             pass
7821         pass
7822
7823     def testDAIComputeOffsets2(self):
7824         d=DataArrayInt.New();
7825         vals1=[3,5,1,2,0,8]
7826         expected1=[0,3,8,9,11,11,19]
7827         d.setValues(vals1,6,1);
7828         d.computeOffsets2();
7829         self.assertEqual(7,d.getNumberOfTuples());
7830         self.assertEqual(1,d.getNumberOfComponents());
7831         for i in xrange(7):
7832             self.assertEqual(expected1[i],d.getIJ(0,i));
7833             pass
7834         pass
7835
7836     def testMergeField3(self):
7837         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7838         m.getCoords().setInfoOnComponent(0,"x [m]");
7839         m.getCoords().setInfoOnComponent(1,"z [km]");
7840         m.setName("m");
7841         m.setDescription("desc");
7842         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
7843         f1.setName("f1");
7844         f1.setMesh(m);
7845         arr=DataArrayDouble.New();
7846         arr.alloc(5,2);
7847         arr.setInfoOnComponent(0,"X [m]");
7848         arr.setInfoOnComponent(1,"YY [mm]");
7849         arr.fillWithValue(2.);
7850         f1.setArray(arr);
7851         #
7852         f2=MEDCouplingFieldDouble.MergeFields([f1]);
7853         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
7854         #
7855         pass
7856
7857     def testGetDistributionOfTypes1(self):
7858         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7859         tab1=[2,0,1,3,4]
7860         self.assertRaises(InterpKernelException,m.getDistributionOfTypes);
7861         m.renumberCells(tab1,False);
7862         code=m.getDistributionOfTypes();
7863         self.assertEqual(2,len(code));
7864         self.assertEqual(3,code[0][0]);
7865         self.assertEqual(2,code[0][1]);
7866         self.assertEqual(0,code[0][2]);
7867         self.assertEqual(4,code[1][0]);
7868         self.assertEqual(3,code[1][1]);
7869         self.assertEqual(0,code[1][2]);
7870         pass
7871
7872     def testNorm2_1(self):
7873         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7874         f=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
7875         f.setMesh(m);
7876         #
7877         d=DataArrayDouble.New();
7878         tab=[1.2,1.3,2.2,2.3,3.2,3.3,4.2,4.3,5.2,5.3]
7879         d.setValues(tab,5,2);
7880         f.setArray(d);
7881         f.checkCoherency();
7882         #
7883         self.assertAlmostEqual(11.209371079592289,f.norm2(),14);
7884         #
7885         pass
7886
7887     def testNormMax1(self):
7888         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7889         f=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
7890         f.setMesh(m);
7891         #
7892         d=DataArrayDouble.New();
7893         tab=[2.3,-1.2,6.3,-7.8,2.9,7.7,2.1,0.,3.6,-7.6]
7894         d.setValues(tab,5,2);
7895         f.setArray(d);
7896         f.checkCoherency();
7897         #
7898         self.assertAlmostEqual(7.8,f.normMax(),14);
7899         #
7900         pass
7901
7902     def testFindAndCorrectBadOriented3DExtrudedCells1(self):
7903         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];
7904         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]
7905         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]
7906         invalidCells=[2,3,6,7]
7907         m=MEDCouplingUMesh.New("Example",3);
7908         coo=DataArrayDouble.New();
7909         coo.setValues(coords,38,3);
7910         m.setCoords(coo);
7911         m.allocateCells(8);
7912         m.insertNextCell(NORM_PENTA6,6,conn[0:6])
7913         m.insertNextCell(NORM_PENTA6,6,conn[6:12])
7914         m.insertNextCell(NORM_PENTA6,6,conn[12:18])
7915         m.insertNextCell(NORM_PENTA6,6,conn[18:24])
7916         m.insertNextCell(NORM_HEXA8,8,conn[24:32])
7917         m.insertNextCell(NORM_HEXA8,8,conn[32:40])
7918         m.insertNextCell(NORM_HEXA8,8,conn[40:48])
7919         m.insertNextCell(NORM_HEXA8,8,conn[48:56])
7920         m.finishInsertingCells();
7921         #
7922         v=m.findAndCorrectBadOriented3DExtrudedCells();
7923         self.assertEqual(4,len(v));
7924         self.assertEqual(v.getValues(),invalidCells);
7925         self.assertEqual(connExp,m.getNodalConnectivity().getValues());
7926         self.assertTrue(m.findAndCorrectBadOriented3DExtrudedCells().empty())
7927         #
7928         pass
7929
7930     def testConvertExtrudedPolyhedra1(self):
7931         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]
7932         m=MEDCouplingUMesh.New("Example",3);
7933         coo=DataArrayDouble.New();
7934         coo.alloc(73,3);
7935         coo.rearrange(1); coo.iota(0); coo.rearrange(3);
7936         m.setCoords(coo);
7937         m.allocateCells(9);
7938         m.insertNextCell(NORM_TETRA4,4,conn[0:4])
7939         m.insertNextCell(NORM_HEXA8,8,conn[4:12])
7940         m.insertNextCell(NORM_TETRA4,4,conn[12:16])
7941         m.insertNextCell(NORM_POLYHED,6,conn[16:22])
7942         m.insertNextCell(NORM_PENTA6,6,conn[22:28])
7943         m.insertNextCell(NORM_POLYHED,10,conn[28:38])
7944         m.insertNextCell(NORM_HEXA8,8,conn[38:46])
7945         m.insertNextCell(NORM_HEXGP12,12,conn[46:58])
7946         m.insertNextCell(NORM_POLYHED,14,conn[58:72])
7947         m.finishInsertingCells();
7948         #
7949         m.convertExtrudedPolyhedra();
7950         da=m.getNodalConnectivity();
7951         dai=m.getNodalConnectivityIndex();
7952         self.assertEqual(10,dai.getNbOfElems());
7953         self.assertEqual(159,da.getNbOfElems());
7954         #
7955         expected1=[14, 1, 2, 3, 4,
7956                    18, 5, 6, 7, 8, 9, 10, 11, 12,
7957                    14, 13, 14, 15, 16,
7958                    31, 17, 18, 19, -1, 20, 22, 21, -1, 17, 18, 21, 20, -1, 18, 19, 22, 21, -1, 19, 17, 20, 22,
7959                    16, 23, 24, 25, 26, 27, 28,
7960                    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,
7961                    18, 39, 40, 41, 42, 43, 44, 45, 46,
7962                    22, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
7963                    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];
7964         expected2=[0,5,14,19,42,49,86,95,108,159]
7965         self.assertEqual(expected1,da.getValues());
7966         self.assertEqual(expected2,dai.getValues());
7967         m.checkCoherency2()
7968         pass
7969
7970     def testNonRegressionCopyTinyStrings(self):
7971         m=MEDCouplingDataForTest.build2DTargetMesh_1()
7972         f1=m.getMeasureField(True)
7973         f1.getArray().setInfoOnComponent(0,"P [N/m^2]")
7974         bary=m.getBarycenterAndOwner()
7975         f2=f1.buildNewTimeReprFromThis(NO_TIME,False)
7976         f2.setArray(bary)
7977         self.assertRaises(InterpKernelException,f1.copyTinyAttrFrom,f2)
7978         pass
7979
7980     def testDaDSetPartOfValuesAdv1(self):
7981         tab1=[3.,4.,5., 13.,14.,15., 23.,24.,25., 33.,34.,35., 43.,44.,45., 53.,54.,55.]
7982         tab2=[6.,7.,8., 16.,17.,18., 26.,27.,28.]
7983         tab3=[4,1, 2,2, 3,0]
7984         a=DataArrayDouble.New();
7985         a.setValues(tab1,6,3);
7986         b=DataArrayDouble.New();
7987         b.setValues(tab2,3,3);
7988         c=DataArrayInt.New();
7989         c.setValues(tab3,3,2);
7990         #
7991         a.setPartOfValuesAdv(b,c);
7992         expected1=[3.,4.,5., 13.,14.,15., 26.,27.,28., 6.,7.,8., 16.,17.,18., 53.,54.,55.]
7993         self.assertEqual(expected1,a.getValues());
7994         pass
7995
7996     def testUMeshBuildSetInstanceFromThis1(self):
7997         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
7998         m2=m.buildSetInstanceFromThis(3);
7999         self.assertTrue(m.isEqual(m2,1e-12));
8000         #
8001         m=MEDCouplingUMesh.New("toto",2);
8002         m2=m.buildSetInstanceFromThis(3);
8003         self.assertEqual(0,m2.getNumberOfNodes());
8004         self.assertEqual(0,m2.getNumberOfCells());
8005         pass
8006
8007     def testUMeshMergeMeshesCVW1(self):
8008         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
8009         m2=MEDCouplingUMesh.New("toto",2);
8010         m3=MEDCouplingUMesh.MergeUMeshes([m,m2]);
8011         m3.setName(m.getName());
8012         self.assertTrue(m.isEqual(m3,1e-12));
8013         pass
8014
8015     def testChangeUnderlyingMeshWithCMesh1(self):
8016         mesh=MEDCouplingCMesh.New();
8017         coordsX=DataArrayDouble.New();
8018         arrX=[ -1., 1., 2., 4. ]
8019         coordsX.setValues(arrX,4,1);
8020         coordsY=DataArrayDouble.New();
8021         arrY=[ -2., 2., 4., 8. ]
8022         coordsY.setValues(arrY,4,1);
8023         coordsZ=DataArrayDouble.New();
8024         arrZ=[ -3., 3., 6., 12. ]
8025         coordsZ.setValues(arrZ,4,1);
8026         mesh.setCoords(coordsX,coordsY,coordsZ);
8027         f=mesh.getMeasureField(True)
8028         mesh2=mesh.deepCpy()
8029         for myId in [0,1,2,10,11,12,20,21,22]:
8030             f=mesh.getMeasureField(True)
8031             f.changeUnderlyingMesh(mesh2,myId,1e-12);
8032             pass
8033         mesh2.setName("uuuu")
8034         for myId in [1,2,10,11,12,20,21,22]:
8035             f=mesh.getMeasureField(True)
8036             f.changeUnderlyingMesh(mesh2,myId,1e-12);
8037             pass
8038         pass
8039
8040     def testDADFindCommonTuples1(self):
8041         da=DataArrayDouble.New();
8042         # nbOftuples=1
8043         array1=[2.3,1.2,1.3,2.3,2.301,0.8]
8044         da.setValues(array1,6,1)
8045         c,cI=da.findCommonTuples(1e-2);
8046         expected1=[0,3,4]
8047         expected2=[0,3]
8048         self.assertEqual(3,c.getNbOfElems());
8049         self.assertEqual(2,cI.getNbOfElems());
8050         self.assertEqual(expected1,c.getValues())
8051         self.assertEqual(expected2,cI.getValues())
8052         c,cI=da.findCommonTuples(2e-1)
8053         expected3=[0,3,4,1,2]
8054         expected4=[0,3,5]
8055         self.assertEqual(5,c.getNbOfElems());
8056         self.assertEqual(3,cI.getNbOfElems());
8057         self.assertEqual(expected3,c.getValues())
8058         self.assertEqual(expected4,cI.getValues())
8059         # nbOftuples=2
8060         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]
8061         da.setValues(array2,6,2)
8062         c,cI=da.findCommonTuples(1e-2);
8063         self.assertEqual(3,c.getNbOfElems());
8064         self.assertEqual(2,cI.getNbOfElems());
8065         self.assertEqual(expected1,c.getValues())
8066         self.assertEqual(expected2,cI.getValues())
8067         c,cI=da.findCommonTuples(2e-1)
8068         self.assertEqual(5,c.getNbOfElems());
8069         self.assertEqual(3,cI.getNbOfElems());
8070         self.assertEqual(expected3,c.getValues())
8071         self.assertEqual(expected4,cI.getValues())
8072         # nbOftuples=3
8073         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]
8074         da.setValues(array3,6,3)
8075         c,cI=da.findCommonTuples(1e-2);
8076         self.assertEqual(3,c.getNbOfElems());
8077         self.assertEqual(2,cI.getNbOfElems());
8078         self.assertEqual(expected1,c.getValues())
8079         self.assertEqual(expected2,cI.getValues())
8080         c,cI=da.findCommonTuples(2e-1)
8081         self.assertEqual(5,c.getNbOfElems());
8082         self.assertEqual(3,cI.getNbOfElems());
8083         self.assertEqual(expected3,c.getValues())
8084         self.assertEqual(expected4,cI.getValues())
8085         # nbOftuples=1, no common groups
8086         array11=[2.3,1.2,1.3,2.4,2.5,0.8]
8087         da.setValues(array11,6,1)
8088         c,cI=da.findCommonTuples(1e-2);
8089         self.assertEqual(0,c.getNbOfElems());
8090         self.assertEqual(1,cI.getNbOfElems());
8091         self.assertEqual([0],cI.getValues())
8092
8093         array12=[0.]*(6*4)
8094         da.setValues(array12,6,4) #bad NumberOfComponents
8095         self.assertRaises(InterpKernelException, da.findCommonTuples, 1e-2);
8096         pass
8097
8098     def testDABack1(self):
8099         da=DataArrayDouble.New();
8100         array1=[2.3,1.2,1.3,2.3,2.301,0.8]
8101         da.setValues(array1,6,1);
8102         self.assertAlmostEqual(0.8,da.back(),14);
8103         da.rearrange(2);
8104         self.assertRaises(InterpKernelException,da.back);
8105         da.alloc(0,1);
8106         self.assertRaises(InterpKernelException,da.back);
8107         #
8108         da=DataArrayInt.New();
8109         array2=[4,7,8,2]
8110         da.setValues(array2,4,1);
8111         self.assertEqual(2,da.back());
8112         da.rearrange(2);
8113         self.assertRaises(InterpKernelException,da.back);
8114         da.alloc(0,1);
8115         self.assertRaises(InterpKernelException,da.back);
8116         pass
8117
8118     def testDADGetDifferentValues1(self):
8119         da=DataArrayDouble.New();
8120         array1=[2.3,1.2,1.3,2.3,2.301,0.8]
8121         da.setValues(array1,6,1)
8122         #
8123         expected1=[2.301,1.2,1.3,0.8]
8124         dv=da.getDifferentValues(1e-2);
8125         self.assertEqual(4,dv.getNbOfElems());
8126         for i in xrange(4):
8127             self.assertAlmostEqual(expected1[i],dv.getIJ(i,0),14);
8128             pass
8129         #
8130         dv=da.getDifferentValues(2e-1);
8131         expected2=[2.301,1.3,0.8]
8132         self.assertEqual(3,dv.getNbOfElems());
8133         for i in xrange(3):
8134             self.assertAlmostEqual(expected2[i],dv.getIJ(i,0),14);
8135             pass
8136         pass
8137
8138     def testDAIBuildOld2NewArrayFromSurjectiveFormat2(self):
8139         arr=[0,3, 5,7,9]
8140         arrI=[0,2,5]
8141         a=DataArrayInt.New();
8142         a.setValues(arr,5,1);
8143         b=DataArrayInt.New();
8144         b.setValues(arrI,3,1);
8145         ret,newNbTuple=DataArrayInt.BuildOld2NewArrayFromSurjectiveFormat2(10,a,b);
8146         expected=[0,1,2,0,3,4,5,4,6,4]
8147         self.assertEqual(10,ret.getNbOfElems());
8148         self.assertEqual(7,newNbTuple);
8149         self.assertEqual(1,ret.getNumberOfComponents());
8150         self.assertEqual(expected,ret.getValues());
8151         self.assertRaises(InterpKernelException,DataArrayInt.BuildOld2NewArrayFromSurjectiveFormat2,9,a,b);
8152         pass
8153
8154     def testDADIReverse1(self):
8155         arr=[0,3,5,7,9,2]
8156         a=DataArrayInt.New();
8157         a.setValues(arr,6,1);
8158         self.assertEqual(2,a.back());
8159         a.reverse();
8160         for i in xrange(6):
8161             self.assertEqual(arr[5-i],a.getIJ(i,0));
8162             pass
8163         a.setValues(arr[:-1],5,1);
8164         a.reverse();
8165         for i in xrange(5):
8166             self.assertEqual(arr[4-i],a.getIJ(i,0));
8167             pass
8168         #
8169         arr2=[0.,3.,5.,7.,9.,2.]
8170         b=DataArrayDouble.New();
8171         b.setValues(arr2,6,1);
8172         b.reverse();
8173         for i in xrange(6):
8174             self.assertAlmostEqual(arr2[5-i],b.getIJ(i,0),14);
8175             pass
8176         b.setValues(arr2[:5],5,1);
8177         self.assertAlmostEqual(9.,b.back(),14)
8178         b.reverse();
8179         for i in xrange(5):
8180             self.assertAlmostEqual(arr2[4-i],b.getIJ(i,0),14);
8181             pass
8182         pass
8183
8184     def testGetNodeIdsInUse1(self):
8185         m0=MEDCouplingDataForTest.build2DTargetMesh_1();
8186         CellIds=[1,2]
8187         m1=m0.buildPartOfMySelf(CellIds,True);
8188         arr,newNbOfNodes=m1.getNodeIdsInUse();
8189         expected=[-1,0,1,-1,2,3,-1,-1,-1]
8190         self.assertEqual(4,newNbOfNodes);
8191         self.assertEqual(9,arr.getNbOfElems());
8192         self.assertEqual(expected,arr.getValues());
8193         arr2=arr.invertArrayO2N2N2O(newNbOfNodes);
8194         self.assertEqual(4,arr2.getNbOfElems());
8195         expected2=[1,2,4,5]
8196         self.assertEqual(expected2,arr2.getValues());
8197         pass
8198
8199     def testBuildDescendingConnec2(self):
8200         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
8201         #
8202         mesh2,desc,descIndx,revDesc,revDescIndx=mesh.buildDescendingConnectivity2();
8203         mesh2.checkCoherency();
8204         self.assertEqual(1,mesh2.getMeshDimension());
8205         self.assertEqual(13,mesh2.getNumberOfCells());
8206         self.assertEqual(14,revDescIndx.getNbOfElems()); self.assertEqual(14,revDescIndx.getNumberOfTuples());
8207         self.assertEqual(6,descIndx.getNbOfElems()); self.assertEqual(6,descIndx.getNumberOfTuples());
8208         self.assertEqual(18,desc.getNbOfElems()); self.assertEqual(18,desc.getNumberOfTuples());
8209         self.assertEqual(18,revDesc.getNbOfElems()); self.assertEqual(18,revDesc.getNumberOfTuples());
8210         expected1=[1,2,3,4,-3,5,6, 7,8,-5,9,10,-2,11, 12,13,-7,-10]
8211         self.assertEqual(expected1,desc.getValues());
8212         expected2=[0,4,7,10,14,18]
8213         self.assertEqual(expected2,descIndx.getValues());
8214         expected3=[0,1,3,5,6,8,9,11,12,13,15,16,17,18]
8215         self.assertEqual(expected3,revDescIndx.getValues());
8216         expected4=[0, 0,3, 0,1, 0, 1,2, 1, 2,4, 2, 3, 3,4, 3, 4, 4]
8217         self.assertEqual(expected4,revDesc.getValues());
8218         conn=mesh2.getNodalConnectivity();
8219         connIndex=mesh2.getNodalConnectivityIndex();
8220         expected5=[0,3,6,9,12,15,18,21,24,27,30,33,36,39]
8221         self.assertEqual(expected5,connIndex.getValues());
8222         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]
8223         self.assertEqual(expected6,conn.getValues());
8224         pass
8225
8226     def testIntersect2DMeshesTmp1(self):
8227         m1c=MEDCouplingCMesh.New();
8228         coordsX=DataArrayDouble.New();
8229         arrX=[ -1., 1., 2., 4. ]
8230         coordsX.setValues(arrX,4,1);
8231         m1c.setCoordsAt(0,coordsX);
8232         coordsY=DataArrayDouble.New();
8233         arrY=[ -2., 2., 4., 8. ]
8234         coordsY.setValues(arrY,4,1);
8235         m1c.setCoordsAt(1,coordsY);
8236         m1=m1c.buildUnstructured()
8237         m1bis=m1.buildPartOfMySelf([3,4,5],False)
8238         m2=m1.deepCpy()
8239         m2=m2.buildPartOfMySelf([0,1,2],False)
8240         m2.translate([0.5,0.5])
8241         #
8242         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m1bis,m2,1e-10)
8243         expected1=[0,0,1,1,1,2,2,2]
8244         expected2=[0,-1,0,1,-1,1,2,-1]
8245         self.assertEqual(8,d1.getNumberOfTuples());
8246         self.assertEqual(8,d2.getNumberOfTuples());
8247         self.assertEqual(8,m3.getNumberOfCells());
8248         self.assertEqual(22,m3.getNumberOfNodes());
8249         self.assertEqual(2,m3.getSpaceDimension());
8250         self.assertEqual(expected1,d1.getValues());
8251         self.assertEqual(expected2,d2.getValues());
8252         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]
8253         expected4=[0,5,12,17,22,28,33,38,44]
8254         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]
8255         self.assertEqual(44,m3.getNodalConnectivity().getNumberOfTuples());
8256         self.assertEqual(9,m3.getNodalConnectivityIndex().getNumberOfTuples());
8257         self.assertEqual(expected3,m3.getNodalConnectivity().getValues());
8258         self.assertEqual(expected4,m3.getNodalConnectivityIndex().getValues());
8259         for i in xrange(44):
8260             self.assertAlmostEqual(expected5[i],m3.getCoords().getIJ(0,i),12);
8261             pass
8262         pass
8263
8264     def testFindNodesOnLine1(self):
8265         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
8266         pt=[-0.3,-0.3]
8267         pt2=[0.,0.,0.]
8268         pt3=[-0.3,0.,0.]
8269         vec=[0.,1.]
8270         vec2=[1.,0.,0.]
8271         vec3=[0.,1.,1.]
8272         expected1=[0,3,6]
8273         res=mesh.findNodesOnLine(pt,vec,1e-12);
8274         self.assertEqual(3,len(res));
8275         self.assertEqual(expected1,res.getValues());
8276         #
8277         mesh.changeSpaceDimension(3);
8278         mesh.rotate(pt2,vec2,pi/4.);
8279         res=mesh.findNodesOnLine(pt3,vec3,1e-12);
8280         self.assertEqual(3,len(res));
8281         self.assertEqual(expected1,res.getValues());
8282         pass
8283
8284     def testIntersect2DMeshesTmp2(self):
8285         m1c=MEDCouplingCMesh.New();
8286         coordsX1=DataArrayDouble.New();
8287         arrX1=[ 0., 1., 1.5, 2. ]
8288         coordsX1.setValues(arrX1,4,1);
8289         m1c.setCoordsAt(0,coordsX1);
8290         coordsY1=DataArrayDouble.New();
8291         arrY1=[ 0., 1.5, 3.]
8292         coordsY1.setValues(arrY1,3,1);
8293         m1c.setCoordsAt(1,coordsY1);
8294         m1=m1c.buildUnstructured();
8295         m2c=MEDCouplingCMesh.New();
8296         coordsX2=DataArrayDouble.New();
8297         arrX2=[ 0., 1., 2. ]
8298         coordsX2.setValues(arrX2,3,1);
8299         m2c.setCoordsAt(0,coordsX2);
8300         coordsY2=DataArrayDouble.New();
8301         arrY2=[ 0., 1., 3.]
8302         coordsY2.setValues(arrY2,3,1);
8303         m2c.setCoordsAt(1,coordsY2);
8304         m2=m2c.buildUnstructured();
8305         #
8306         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m1,m2,1e-10)
8307         #
8308         expected1=[0,0,1,1,2,2,3,4,5]
8309         expected2=[0,2,1,3,1,3,2,3,3]
8310         self.assertEqual(9,d1.getNumberOfTuples());
8311         self.assertEqual(9,d2.getNumberOfTuples());
8312         self.assertEqual(9,m3.getNumberOfCells());
8313         self.assertEqual(22,m3.getNumberOfNodes());
8314         self.assertEqual(2,m3.getSpaceDimension());
8315         self.assertEqual(expected1,d1.getValues());
8316         self.assertEqual(expected2,d2.getValues());
8317         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]
8318         expected4=[0,5,10,15,20,25,30,35,40,45]
8319         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]
8320         self.assertEqual(45,m3.getNodalConnectivity().getNumberOfTuples());
8321         self.assertEqual(10,m3.getNodalConnectivityIndex().getNumberOfTuples());
8322         self.assertEqual(expected3,m3.getNodalConnectivity().getValues());
8323         self.assertEqual(expected4,m3.getNodalConnectivityIndex().getValues());
8324         for i in xrange(44):
8325             self.assertAlmostEqual(expected5[i],m3.getCoords().getIJ(0,i),12);
8326             pass
8327         pass
8328
8329     def testBuildPartOfMySelfSafe1(self):
8330         mesh=MEDCouplingDataForTest.build2DTargetMesh_1()
8331         self.assertRaises(InterpKernelException,mesh.buildPartOfMySelf,[0,-1,4,2],True)
8332         self.assertRaises(InterpKernelException,mesh.buildPartOfMySelf,[0,4,5,4],True)
8333         pass
8334
8335     def testIntersect2DMeshesTmp3(self):
8336         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];
8337         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];
8338         m1=MEDCouplingUMesh.New();
8339         m1.setMeshDimension(2);
8340         m1.allocateCells(8);
8341         m1.insertNextCell(NORM_TRI6,6,m1Conn[0:6]);
8342         m1.insertNextCell(NORM_QUAD8,8,m1Conn[6:14]);
8343         m1.insertNextCell(NORM_TRI6,6,m1Conn[14:20]);
8344         m1.insertNextCell(NORM_QUAD8,8,m1Conn[20:28]);
8345         m1.insertNextCell(NORM_TRI6,6,m1Conn[28:34]);
8346         m1.insertNextCell(NORM_QUAD8,8,m1Conn[34:42]);
8347         m1.insertNextCell(NORM_TRI6,6,m1Conn[42:48]);
8348         m1.insertNextCell(NORM_QUAD8,8,m1Conn[48:56]);
8349         m1.finishInsertingCells();
8350         myCoords1=DataArrayDouble.New();
8351         myCoords1.setValues(m1Coords,25,2);
8352         m1.setCoords(myCoords1);
8353         #
8354         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.]
8355         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]
8356         m2=MEDCouplingUMesh.New();
8357         m2.setMeshDimension(2);
8358         m2.allocateCells(8);
8359         for i in xrange(8):
8360             m2.insertNextCell(NORM_QUAD4,4,m2Conn[4*i:4*(i+1)])
8361             pass
8362         m2.finishInsertingCells();
8363         myCoords2=DataArrayDouble.New();
8364         myCoords2.setValues(m2Coords,15,2);
8365         m2.setCoords(myCoords2);
8366         #
8367         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m1,m2,1e-10)
8368         m3.unPolyze()
8369         #
8370         expected1=[0,1,1,1,2,3,3,3,4,5,5,5,6,7,7,7]
8371         expected2=[0,0,1,-1,2,2,3,-1,4,4,5,-1,6,6,7,-1]
8372         self.assertEqual(16,d1.getNumberOfTuples());
8373         self.assertEqual(16,d2.getNumberOfTuples());
8374         self.assertEqual(16,m3.getNumberOfCells());
8375         self.assertEqual(104,m3.getNumberOfNodes());
8376         self.assertEqual(2,m3.getSpaceDimension());
8377         self.assertEqual(expected1,d1.getValues());
8378         self.assertEqual(expected2,d2.getValues());
8379         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]
8380         expected4=[0,7,16,25,34,41,50,59,68,75,84,93,102,109,118,127,136]
8381         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]
8382         self.assertEqual(136,m3.getNodalConnectivity().getNumberOfTuples());
8383         self.assertEqual(17,m3.getNodalConnectivityIndex().getNumberOfTuples());
8384         self.assertEqual(expected3,m3.getNodalConnectivity().getValues());
8385         self.assertEqual(expected4,m3.getNodalConnectivityIndex().getValues());
8386         for i in xrange(208):
8387             self.assertAlmostEqual(expected5[i],m3.getCoords().getIJ(0,i),12);
8388             pass
8389         pass
8390
8391     def testUMeshTessellate2D1(self):
8392         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];
8393         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];
8394         m1=MEDCouplingUMesh.New();
8395         m1.setMeshDimension(2);
8396         m1.allocateCells(8);
8397         m1.insertNextCell(NORM_TRI6,6,m1Conn[0:6]);
8398         m1.insertNextCell(NORM_QUAD8,8,m1Conn[6:14]);
8399         m1.insertNextCell(NORM_TRI6,6,m1Conn[14:20]);
8400         m1.insertNextCell(NORM_QUAD8,8,m1Conn[20:28]);
8401         m1.insertNextCell(NORM_TRI6,6,m1Conn[28:34]);
8402         m1.insertNextCell(NORM_QUAD8,8,m1Conn[34:42]);
8403         m1.insertNextCell(NORM_TRI6,6,m1Conn[42:48]);
8404         m1.insertNextCell(NORM_QUAD8,8,m1Conn[48:56]);
8405         m1.finishInsertingCells();
8406         myCoords1=DataArrayDouble.New();
8407         myCoords1.setValues(m1Coords,25,2);
8408         m1.setCoords(myCoords1);
8409         #
8410         m11=m1.deepCpy();
8411         m11.tessellate2D(1.);
8412         self.assertTrue(m11.getCoords().isEqual(m11.getCoords(),1e-12));
8413         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]
8414         expected2=[0,5,12,17,24,29,36,41,48]
8415         self.assertEqual(48,m11.getNodalConnectivity().getNumberOfTuples());
8416         self.assertEqual(9,m11.getNodalConnectivityIndex().getNumberOfTuples());
8417         self.assertEqual(expected1,m11.getNodalConnectivity().getValues());
8418         self.assertEqual(expected2,m11.getNodalConnectivityIndex().getValues());
8419         #
8420         m12=m1.deepCpy();
8421         m12.tessellate2D(0.5);
8422         self.assertEqual(41,m12.getNumberOfNodes());
8423         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]
8424         expected4=[0,6,15,21,30,36,45,51,60]
8425         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]
8426         for i in xrange(82):
8427             self.assertAlmostEqual(expected5[i],m12.getCoords().getIJ(0,i),12);
8428             pass
8429         self.assertEqual(60,m12.getNodalConnectivity().getNumberOfTuples());
8430         self.assertEqual(9,m12.getNodalConnectivityIndex().getNumberOfTuples());
8431         self.assertEqual(expected3,m12.getNodalConnectivity().getValues());
8432         self.assertEqual(expected4,m12.getNodalConnectivityIndex().getValues());
8433         pass
8434
8435     def testIntersect2DMeshesTmp4(self):
8436         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];
8437         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];
8438         m1=MEDCouplingUMesh.New();
8439         m1.setMeshDimension(2);
8440         m1.allocateCells(8);
8441         m1.insertNextCell(NORM_TRI6,6,m1Conn[0:6]);
8442         m1.insertNextCell(NORM_QUAD8,8,m1Conn[6:14]);
8443         m1.insertNextCell(NORM_TRI6,6,m1Conn[14:20]);
8444         m1.insertNextCell(NORM_QUAD8,8,m1Conn[20:28]);
8445         m1.insertNextCell(NORM_TRI6,6,m1Conn[28:34]);
8446         m1.insertNextCell(NORM_QUAD8,8,m1Conn[34:42]);
8447         m1.insertNextCell(NORM_TRI6,6,m1Conn[42:48]);
8448         m1.insertNextCell(NORM_QUAD8,8,m1Conn[48:56]);
8449         m1.finishInsertingCells();
8450         myCoords1=DataArrayDouble.New();
8451         myCoords1.setValues(m1Coords,25,2);
8452         m1.setCoords(myCoords1);
8453         #
8454         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.]
8455         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]
8456         m2=MEDCouplingUMesh.New();
8457         m2.setMeshDimension(2);
8458         m2.allocateCells(8);
8459         for i in xrange(8):
8460             m2.insertNextCell(NORM_QUAD4,4,m2Conn[4*i:4*(i+1)])
8461             pass
8462         m2.finishInsertingCells();
8463         myCoords2=DataArrayDouble.New();
8464         myCoords2.setValues(m2Coords,15,2);
8465         m2.setCoords(myCoords2);
8466         #
8467         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m2,m1,1e-10)
8468         m3.unPolyze()
8469         #
8470         expected1=[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
8471         expected2=[0,1,1,-1,2,3,3,-1,4,5,5,-1,6,7,7,-1]
8472         self.assertEqual(16,d1.getNumberOfTuples());
8473         self.assertEqual(16,d2.getNumberOfTuples());
8474         self.assertEqual(16,m3.getNumberOfCells());
8475         self.assertEqual(104,m3.getNumberOfNodes());
8476         self.assertEqual(2,m3.getSpaceDimension());
8477         self.assertEqual(expected1,d1.getValues());
8478         self.assertEqual(expected2,d2.getValues());
8479         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]
8480         expected4=[0,7,16,25,34,41,50,59,68,75,84,93,102,109,118,127,136]
8481         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]
8482         self.assertEqual(136,m3.getNodalConnectivity().getNumberOfTuples());
8483         self.assertEqual(17,m3.getNodalConnectivityIndex().getNumberOfTuples());
8484         self.assertEqual(expected3,m3.getNodalConnectivity().getValues());
8485         self.assertEqual(expected4,m3.getNodalConnectivityIndex().getValues());
8486         for i in xrange(208):
8487             self.assertAlmostEqual(expected5[i],m3.getCoords().getIJ(0,i),12);
8488             pass
8489         pass
8490
8491     def testGetCellIdsCrossingPlane1(self):
8492         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
8493         vec=[-0.07,1.,0.07]
8494         origin=[1.524,1.4552,1.74768]
8495         ids1=mesh3D.getCellIdsCrossingPlane(origin,vec,1e-10)
8496         self.assertEqual([1,3,4,7,9,10,13,15,16],ids1.getValues())
8497         vec2=[0.,0.,1.]
8498         ids2=mesh3D.getCellIdsCrossingPlane(origin,vec2,1e-10)
8499         self.assertEqual([6,7,8,9,10,11],ids2.getValues())
8500         pass
8501
8502     def testBuildSlice3D1(self):
8503         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
8504         vec1=[-0.07,1.,0.07]
8505         origin1=[1.524,1.4552,1.74768]
8506         slice1,ids=mesh3D.buildSlice3D(origin1,vec1,1e-10);
8507         expected1=[1,3,4,7,9,10,13,15,16]
8508         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]
8509         expected3=[0,6,11,17,22,27,32,37,42,47]
8510         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.]
8511         self.assertEqual(2,slice1.getMeshDimension());
8512         self.assertEqual(3,slice1.getSpaceDimension());
8513         self.assertEqual(57,slice1.getNumberOfNodes());
8514         self.assertEqual(9,slice1.getNumberOfCells());
8515         self.assertEqual(9,ids.getNumberOfTuples());
8516         self.assertEqual(47,slice1.getNodalConnectivity().getNumberOfTuples());
8517         self.assertEqual(10,slice1.getNodalConnectivityIndex().getNumberOfTuples());
8518         self.assertEqual(expected1,ids.getValues());
8519         self.assertEqual(expected2,slice1.getNodalConnectivity().getValues());
8520         self.assertEqual(expected3,slice1.getNodalConnectivityIndex().getValues());
8521         for i in xrange(171):
8522             self.assertAlmostEqual(expected4[i],slice1.getCoords().getIJ(0,i),12);
8523             pass
8524         # 2nd slice based on already existing nodes of mesh3D.
8525         vec2=[0.,3.,1.]
8526         origin2=[2.5,1.,3.]
8527         slice1,ids=mesh3D.buildSlice3D(origin2,vec2,1e-10);
8528         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]
8529         expected6=[0,5,10,15,21,26,32,38,43,49]
8530         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]
8531         self.assertEqual(2,slice1.getMeshDimension());
8532         self.assertEqual(3,slice1.getSpaceDimension());
8533         self.assertEqual(60,slice1.getNumberOfNodes());
8534         self.assertEqual(9,slice1.getNumberOfCells());
8535         self.assertEqual(9,ids.getNumberOfTuples());
8536         self.assertEqual(49,slice1.getNodalConnectivity().getNumberOfTuples());
8537         self.assertEqual(10,slice1.getNodalConnectivityIndex().getNumberOfTuples());
8538         self.assertEqual(expected1,ids.getValues());
8539         self.assertEqual(expected5,slice1.getNodalConnectivity().getValues());
8540         self.assertEqual(expected6,slice1.getNodalConnectivityIndex().getValues());
8541         for i in xrange(180):
8542             self.assertAlmostEqual(expected7[i],slice1.getCoords().getIJ(0,i),12);
8543             pass
8544         # 3rd slice based on shared face of mesh3D.
8545         vec3=[0.,0.,1.]
8546         origin3=[2.5,1.,2.]
8547         slice1,ids=mesh3D.buildSlice3D(origin3,vec3,1e-10);
8548         expected8=[6,7,8,9,10,11,12,13,14,15,16,17]
8549         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]
8550         expected10=[0,5,12,17,22,29,34,39,46,51,56,63,68]
8551         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.]
8552         self.assertEqual(2,slice1.getMeshDimension());
8553         self.assertEqual(3,slice1.getSpaceDimension());
8554         self.assertEqual(45,slice1.getNumberOfNodes());
8555         self.assertEqual(12,slice1.getNumberOfCells());
8556         self.assertEqual(12,ids.getNumberOfTuples());
8557         self.assertEqual(68,slice1.getNodalConnectivity().getNumberOfTuples());
8558         self.assertEqual(13,slice1.getNodalConnectivityIndex().getNumberOfTuples());
8559         self.assertEqual(expected8,ids.getValues());
8560         self.assertEqual(expected9,slice1.getNodalConnectivity().getValues());
8561         self.assertEqual(expected10,slice1.getNodalConnectivityIndex().getValues());
8562         for i in xrange(135):
8563             self.assertAlmostEqual(expected11[i],slice1.getCoords().getIJ(0,i),12);
8564             pass
8565         pass
8566
8567     def testBuildSlice3DSurf1(self):
8568         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
8569         mesh2D=mesh3D.buildDescendingConnectivity()[0];
8570         vec1=[-0.07,1.,0.07]
8571         origin1=[1.524,1.4552,1.74768]
8572         slice1,ids=mesh2D.buildSlice3DSurf(origin1,vec1,1e-10);
8573         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]
8574         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]
8575         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];
8576         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.]
8577         self.assertEqual(1,slice1.getMeshDimension());
8578         self.assertEqual(3,slice1.getSpaceDimension());
8579         self.assertEqual(57,slice1.getNumberOfNodes());
8580         self.assertEqual(25,slice1.getNumberOfCells());
8581         self.assertEqual(25,ids.getNumberOfTuples());
8582         self.assertEqual(75,slice1.getNodalConnectivity().getNumberOfTuples());
8583         self.assertEqual(26,slice1.getNodalConnectivityIndex().getNumberOfTuples());
8584         self.assertEqual(expected1,ids.getValues());
8585         self.assertEqual(expected2,slice1.getNodalConnectivity().getValues());
8586         self.assertEqual(expected3,slice1.getNodalConnectivityIndex().getValues());
8587         for i in xrange(171):
8588             self.assertAlmostEqual(expected4[i],slice1.getCoords().getIJ(0,i),12);
8589             pass
8590         #
8591         vec2=[0.,0.,1.]
8592         origin2=[2.5,1.,2.]
8593         slice1,ids=mesh2D.buildSlice3DSurf(origin2,vec2,1e-10);
8594         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]
8595         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]
8596         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];
8597         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.]
8598         self.assertEqual(1,slice1.getMeshDimension());
8599         self.assertEqual(3,slice1.getSpaceDimension());
8600         self.assertEqual(45,slice1.getNumberOfNodes());
8601         self.assertEqual(68,slice1.getNumberOfCells());
8602         self.assertEqual(68,ids.getNumberOfTuples());
8603         self.assertEqual(204,slice1.getNodalConnectivity().getNumberOfTuples());
8604         self.assertEqual(69,slice1.getNodalConnectivityIndex().getNumberOfTuples());
8605         self.assertEqual(expected5,ids.getValues());
8606         self.assertEqual(expected6,slice1.getNodalConnectivity().getValues());
8607         self.assertEqual(expected7,slice1.getNodalConnectivityIndex().getValues());
8608         for i in xrange(135):
8609             self.assertAlmostEqual(expected8[i],slice1.getCoords().getIJ(0,i),12);
8610             pass
8611         pass
8612
8613     def testDataArrayDoubleAdvSetting1(self):
8614         data1=[1.,11.,2.,12.,3.,13.,4.,14.,5.,15.,6.,16.,7.,17.]
8615         data2=[8.,38.,9.,39.,0.,30.,11.,41.,12.,42.]
8616         compsCpp=["comp1","comp2"]
8617         da=DataArrayDouble.New();
8618         da.setInfoAndChangeNbOfCompo(compsCpp);
8619         da.setName("da");
8620         da.alloc(7,2);
8621         compsCpp=compsCpp[:-1]
8622         self.assertRaises(InterpKernelException,da.setInfoAndChangeNbOfCompo,compsCpp);
8623         da.setValues(data1,7,2)
8624         #
8625         p=[(0,3),(3,5),(5,7)]
8626         tmp=da.selectByTupleRanges(p);
8627         self.assertTrue(tmp.isEqual(da,1e-14));
8628         p=[(0,2),(3,4),(5,7)]
8629         tmp=da.selectByTupleRanges(p);
8630         expected1=[1.,11.,2.,12.,4.,14.,6.,16.,7.,17.]
8631         self.assertEqual(5,tmp.getNumberOfTuples());
8632         self.assertEqual(2,tmp.getNumberOfComponents());
8633         for i in xrange(10):
8634             self.assertAlmostEqual(expected1[i],tmp.getIJ(0,i),14);
8635             pass
8636         p=[(0,2),(0,2),(5,6)]
8637         tmp=da.selectByTupleRanges(p);
8638         expected2=[1.,11.,2.,12.,1.,11.,2.,12.,6.,16.]
8639         self.assertEqual(5,tmp.getNumberOfTuples());
8640         self.assertEqual(2,tmp.getNumberOfComponents());
8641         for i in xrange(10):
8642             self.assertAlmostEqual(expected2[i],tmp.getIJ(0,i),14);
8643             pass
8644         p=[(0,2),(-1,2),(5,6)]
8645         self.assertRaises(InterpKernelException,da.selectByTupleRanges,p);
8646         p=[(0,2),(0,2),(5,8)]
8647         self.assertRaises(InterpKernelException,da.selectByTupleRanges,p);
8648         #
8649         da2=DataArrayDouble.New();
8650         da2.setValues(data2,5,2);
8651         #
8652         dac=da.deepCpy();
8653         dac.setContigPartOfSelectedValues2(1,da2,2,4,1);
8654         expected3=[1.,11.,0.,30.,11.,41.,4.,14.,5.,15.,6.,16.,7.,17.]
8655         for i in xrange(14):
8656             self.assertAlmostEqual(expected3[i],dac.getIJ(0,i),14);
8657             pass
8658         #
8659         dac=da.deepCpy();
8660         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,3,da2,0,5,1);
8661         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,0,da2,4,6,1);
8662         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,3,da2,5,0,1);
8663         dac.setContigPartOfSelectedValues2(3,da2,1,5,1);
8664         expected4=[1.,11.,2.,12.,3.,13.,9.,39.,0.,30.,11.,41.,12.,42.]
8665         for i in xrange(14):
8666             self.assertAlmostEqual(expected4[i],dac.getIJ(0,i),14);
8667             pass
8668         #
8669         ids=DataArrayInt.New();
8670         ids.alloc(3,1);
8671         dac=da.deepCpy();
8672         ids.setIJ(0,0,2); ids.setIJ(1,0,0); ids.setIJ(2,0,4);
8673         dac.setContigPartOfSelectedValues(2,da2,ids);
8674         expected5=[1.,11.,2.,12.,0.,30.,8.,38.,12.,42.,6.,16.,7.,17.]
8675         for i in xrange(14):
8676             self.assertAlmostEqual(expected5[i],dac.getIJ(0,i),14);
8677             pass
8678         #
8679         dac=da.deepCpy();
8680         ids.setIJ(0,0,2); ids.setIJ(1,0,5); ids.setIJ(2,0,4);
8681         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,1,da2,ids);
8682         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,-1);
8683         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,1,da2,ids);
8684         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,1);
8685         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,5,da2,ids);
8686         #
8687         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,1);
8688         dac=da.deepCpy();
8689         dac.setContigPartOfSelectedValues(4,da2,ids);
8690         expected6=[1.,11.,2.,12.,3.,13.,4.,14.,0.,30.,0.,30.,9.,39.]
8691         for i in xrange(14):
8692             self.assertAlmostEqual(expected6[i],dac.getIJ(0,i),14);
8693             pass
8694         pass
8695
8696     def testDataArrayIntAdvSetting1(self):
8697         data1=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
8698         data2=[8,38,9,39,0,30,11,41,12,42]
8699         compsCpp=["comp1","comp2"]
8700         da=DataArrayInt.New();
8701         da.setInfoAndChangeNbOfCompo(compsCpp);
8702         da.setName("da");
8703         da.alloc(7,2);
8704         compsCpp=compsCpp[:-1]
8705         self.assertRaises(InterpKernelException,da.setInfoAndChangeNbOfCompo,compsCpp);
8706         da.setValues(data1,7,2)
8707         #
8708         p=[(0,3),(3,5),(5,7)]
8709         tmp=da.selectByTupleRanges(p);
8710         self.assertTrue(tmp.isEqual(da));
8711         p=[(0,2),(3,4),(5,7)]
8712         tmp=da.selectByTupleRanges(p);
8713         expected1=[1,11,2,12,4,14,6,16,7,17]
8714         self.assertEqual(5,tmp.getNumberOfTuples());
8715         self.assertEqual(2,tmp.getNumberOfComponents());
8716         for i in xrange(10):
8717             self.assertEqual(expected1[i],tmp.getIJ(0,i));
8718             pass
8719         p=[(0,2),(0,2),(5,6)]
8720         tmp=da.selectByTupleRanges(p);
8721         expected2=[1,11,2,12,1,11,2,12,6,16]
8722         self.assertEqual(5,tmp.getNumberOfTuples());
8723         self.assertEqual(2,tmp.getNumberOfComponents());
8724         for i in xrange(10):
8725             self.assertEqual(expected2[i],tmp.getIJ(0,i));
8726             pass
8727         p=[(0,2),(-1,2),(5,6)]
8728         self.assertRaises(InterpKernelException,da.selectByTupleRanges,p);
8729         p=[(0,2),(0,2),(5,8)]
8730         self.assertRaises(InterpKernelException,da.selectByTupleRanges,p);
8731         #
8732         da2=DataArrayInt.New();
8733         da2.setValues(data2,5,2);
8734         #
8735         dac=da.deepCpy();
8736         dac.setContigPartOfSelectedValues2(1,da2,2,4,1);
8737         expected3=[1,11,0,30,11,41,4,14,5,15,6,16,7,17]
8738         for i in xrange(14):
8739             self.assertEqual(expected3[i],dac.getIJ(0,i));
8740             pass
8741         #
8742         dac=da.deepCpy();
8743         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,3,da2,0,5,1);
8744         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,0,da2,4,6,1);
8745         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,3,da2,5,0,1);
8746         dac.setContigPartOfSelectedValues2(3,da2,1,5,1);
8747         expected4=[1,11,2,12,3,13,9,39,0,30,11,41,12,42]
8748         for i in xrange(14):
8749             self.assertEqual(expected4[i],dac.getIJ(0,i));
8750             pass
8751         #
8752         ids=DataArrayInt.New();
8753         ids.alloc(3,1);
8754         dac=da.deepCpy();
8755         ids.setIJ(0,0,2); ids.setIJ(1,0,0); ids.setIJ(2,0,4);
8756         dac.setContigPartOfSelectedValues(2,da2,ids);
8757         expected5=[1,11,2,12,0,30,8,38,12,42,6,16,7,17]
8758         for i in xrange(14):
8759             self.assertEqual(expected5[i],dac.getIJ(0,i));
8760             pass
8761         #
8762         dac=da.deepCpy();
8763         ids.setIJ(0,0,2); ids.setIJ(1,0,5); ids.setIJ(2,0,4);
8764         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,1,da2,ids);
8765         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,-1);
8766         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,1,da2,ids);
8767         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,1);
8768         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,5,da2,ids);
8769         #
8770         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,1);
8771         dac=da.deepCpy();
8772         dac.setContigPartOfSelectedValues(4,da2,ids);
8773         expected6=[1,11,2,12,3,13,4,14,0,30,0,30,9,39]
8774         for i in xrange(14):
8775             self.assertEqual(expected6[i],dac.getIJ(0,i));
8776             pass
8777         pass
8778
8779     def testBuildDescendingConnec2Of3DMesh1(self):
8780         mesh=MEDCouplingDataForTest.build3DSourceMesh_1();
8781         #
8782         mesh2,desc,descIndx,revDesc,revDescIndx=mesh.buildDescendingConnectivity2();
8783         mesh2.checkCoherency();
8784         self.assertEqual(2,mesh2.getMeshDimension());
8785         self.assertEqual(30,mesh2.getNumberOfCells());
8786         self.assertEqual(31,revDescIndx.getNbOfElems()); self.assertEqual(31,revDescIndx.getNumberOfTuples());
8787         self.assertEqual(13,descIndx.getNbOfElems()); self.assertEqual(13,descIndx.getNumberOfTuples());
8788         self.assertEqual(48,desc.getNbOfElems()); self.assertEqual(48,desc.getNumberOfTuples());
8789         self.assertEqual(48,revDesc.getNbOfElems()); self.assertEqual(48,revDesc.getNumberOfTuples());
8790         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]
8791         self.assertEqual(expected1,desc.getValues());
8792         expected2=[0,4,8,12,16,20,24,28,32,36,40,44,48]
8793         self.assertEqual(expected2,descIndx.getValues());
8794         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]
8795         self.assertEqual(expected3,revDescIndx.getValues());
8796         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]
8797         self.assertEqual(expected4,revDesc.getValues());
8798         conn=mesh2.getNodalConnectivity();
8799         connIndex=mesh2.getNodalConnectivityIndex();
8800         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]
8801         self.assertEqual(expected5,connIndex.getValues());
8802         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]
8803         self.assertEqual(expected6,conn.getValues());
8804         pass
8805
8806     def testAre2DCellsNotCorrectlyOriented1(self):
8807         m1Coords=[1.,1.,-1.,-1.,-1.,-1.,1.,-1.]
8808         m1Conn=[0,3,1,2]
8809         m1=MEDCouplingUMesh.New();
8810         m1.setMeshDimension(2);
8811         m1.allocateCells(1);
8812         m1.insertNextCell(NORM_QUAD4,4,m1Conn[0:4])
8813         m1.finishInsertingCells();
8814         myCoords1=DataArrayDouble.New();
8815         myCoords1.setValues(m1Coords,4,2);
8816         m1.setCoords(myCoords1);
8817         #
8818         vec1=[0.,0.,1.]
8819         for i in xrange(18):
8820             vec2=[3.*cos(pi/9.*i),3.*sin(pi/9.*i)];
8821             m1Cpy=m1.deepCpy();
8822             m1Cpy.translate(vec2);
8823             self.assertRaises(InterpKernelException,m1Cpy.are2DCellsNotCorrectlyOriented,vec1,False);
8824             m1Cpy.changeSpaceDimension(3);
8825             res=m1Cpy.are2DCellsNotCorrectlyOriented(vec1,False)
8826             self.assertEqual([0],res.getValues());
8827             pass
8828         pass
8829
8830     def testDataArrayAbs1(self):
8831         d1=DataArrayDouble.New();
8832         val1=[2.,-3.,-5.,6.,-7.,-8.,9.,10.,-11.,-12.,-13.,-15.]
8833         expected1=[2.,3.,5.,6.,7.,8.,9.,10.,11.,12.,13.,15.]
8834         d1.setValues(val1,6,2);
8835         d2=d1.convertToIntArr();
8836         #
8837         d1.abs();
8838         for i in xrange(12):
8839             self.assertAlmostEqual(expected1[i],d1.getIJ(0,i),14);
8840             pass
8841         #
8842         expected2=[2,3,5,6,7,8,9,10,11,12,13,15]
8843         d2.abs();
8844         for i in xrange(12):
8845             self.assertEqual(expected2[i],d2.getIJ(0,i));
8846             pass
8847         #
8848         pass
8849
8850     # test on 1D
8851     def testGetValueOn3(self):
8852         v=[0.,1.,1.5,2.]
8853         v2=[0.7,1.25,0.,2.,1.5]
8854         disp=[5.,50.,500.,6.,60.,600.,7.,70.,700.,8.,80.,800.]
8855         m=MEDCouplingUMesh.New("myMesh",1)
8856         nbNodes=len(v)
8857         nbCells=nbNodes-1
8858         m.allocateCells(nbCells)
8859         coords=DataArrayDouble.New() ; coords.setValues(v,nbNodes,1)
8860         m.setCoords(coords)
8861         m.insertNextCell(NORM_SEG2,2,[0,1])
8862         m.insertNextCell(NORM_SEG2,2,[2,1])
8863         m.insertNextCell(NORM_SEG2,2,[2,3])
8864         m.finishInsertingCells()
8865         f=MEDCouplingFieldDouble.New(ON_NODES)
8866         f.setMesh(m)
8867         array=DataArrayDouble.New(); array.setValues(disp,m.getNumberOfNodes(),3)
8868         f.setArray(array)
8869         arr1=f.getValueOnMulti(v2)
8870         self.assertEqual(5,arr1.getNumberOfTuples());
8871         self.assertEqual(3,arr1.getNumberOfComponents());
8872         expected1=[5.7,57.,570.,6.5,65.,650.,5.,50.,500.,8.,80.,800.,7.,70.,700.]
8873         for i in xrange(15):
8874             self.assertAlmostEqual(expected1[i],arr1.getIJ(0,i),14);
8875             pass
8876         pass
8877
8878     def testGetNodeIdsOfCell2(self):
8879         m1c=MEDCouplingCMesh.New();
8880         coordsX=DataArrayDouble.New();
8881         arrX=[ -1., 1., 2., 4., 4.5 ]
8882         coordsX.setValues(arrX,5,1);
8883         coordsY=DataArrayDouble.New();
8884         arrY=[ -2., 2., 4., 8.]
8885         coordsY.setValues(arrY,4,1);
8886         coordsZ=DataArrayDouble.New();
8887         arrZ=[ -2., 2., 4.]
8888         coordsZ.setValues(arrZ,3,1);
8889         # test in 1D
8890         m1c.setCoordsAt(0,coordsX);
8891         expected1=[[0,1],[1,2],[2,3],[3,4]]
8892         self.assertEqual(4,m1c.getNumberOfCells())
8893         for i in xrange(m1c.getNumberOfCells()):
8894             self.assertEqual(expected1[i],m1c.getNodeIdsOfCell(i))
8895             pass
8896         # test in 2D
8897         m1c.setCoordsAt(1,coordsY);
8898         self.assertEqual(12,m1c.getNumberOfCells())
8899         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]]
8900         for i in xrange(m1c.getNumberOfCells()):
8901             self.assertEqual(expected2[i],m1c.getNodeIdsOfCell(i))
8902             pass
8903         # test in 3D
8904         m1c.setCoordsAt(2,coordsZ);
8905         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]]
8906         self.assertEqual(24,m1c.getNumberOfCells())
8907         for i in xrange(m1c.getNumberOfCells()):
8908             self.assertEqual(expected3[i],m1c.getNodeIdsOfCell(i))
8909             pass
8910         pass
8911
8912     def testSwigDADOp4(self):
8913         da=DataArrayDouble.New(range(6,30),12,2)
8914         self.assertEqual(12,da.getNumberOfTuples());
8915         self.assertEqual(2,da.getNumberOfComponents());
8916         for i in xrange(24):
8917             self.assertAlmostEqual(da.getIJ(0,i),float(i+6),13)
8918             pass
8919         # operator transpose
8920         da.transpose()
8921         self.assertEqual(2,da.getNumberOfTuples());
8922         self.assertEqual(12,da.getNumberOfComponents());
8923         for i in xrange(24):
8924             self.assertAlmostEqual(da.getIJ(0,i),float(i+6),13)
8925             pass
8926         da.transpose()
8927         # operator __neg__
8928         da2=DataArrayDouble.New(12,1)
8929         da2.iota(0.)
8930         dabis=-da
8931         for i in xrange(24):
8932             self.assertAlmostEqual(dabis.getIJ(0,i),-float(i+6),13)
8933             pass
8934         # operator+=
8935         da+=da2
8936         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.]
8937         for i in xrange(24):
8938             self.assertAlmostEqual(da.getIJ(0,i),expected1[i],13)
8939             pass
8940         da=-dabis
8941         da+=[100.,101.]
8942         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.]
8943         self.assertEqual(12,da.getNumberOfTuples());
8944         self.assertEqual(2,da.getNumberOfComponents());
8945         for i in xrange(24):
8946             self.assertAlmostEqual(da.getIJ(0,i),expected2[i],13)
8947             pass
8948         for pos,elt in enumerate(dabis):
8949             da[pos]+=elt
8950             pass
8951         self.assertEqual(12,da.getNumberOfTuples());
8952         self.assertEqual(2,da.getNumberOfComponents());
8953         for elt in da:
8954             li=elt[:]
8955             self.assertAlmostEqual(li[0],100.,13) ; self.assertAlmostEqual(li[1],101.,13)
8956             pass
8957         # operator-=
8958         da=DataArrayDouble.New(range(6,30),12,2)
8959         da2=DataArrayDouble.New(range(12),12,1)
8960         dabis=-da
8961         da-=da2
8962         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.]
8963         for i in xrange(24):
8964             self.assertAlmostEqual(da.getIJ(0,i),expected1[i],13)
8965             pass
8966         da=-dabis
8967         da-=[100.,101.]
8968         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.]
8969         self.assertEqual(12,da.getNumberOfTuples());
8970         self.assertEqual(2,da.getNumberOfComponents());
8971         for i in xrange(24):
8972             self.assertAlmostEqual(da.getIJ(0,i),expected2[i],13)
8973             pass
8974         for pos,elt in enumerate(dabis):
8975             da[pos]-=elt
8976             pass
8977         self.assertEqual(12,da.getNumberOfTuples());
8978         self.assertEqual(2,da.getNumberOfComponents());
8979         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.]
8980         for i in xrange(24):
8981             self.assertAlmostEqual(da.getIJ(0,i),expected3[i],13)
8982             pass
8983         # operator*=
8984         da=DataArrayDouble.New(range(6,30),12,2)
8985         da2=DataArrayDouble.New(range(12),12,1)
8986         dabis=-da
8987         da*=da2
8988         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.]
8989         for i in xrange(24):
8990             self.assertAlmostEqual(da.getIJ(0,i),expected1[i],13)
8991             pass
8992         da=-dabis
8993         da*=[100.,101.]
8994         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.]
8995         self.assertEqual(12,da.getNumberOfTuples());
8996         self.assertEqual(2,da.getNumberOfComponents());
8997         for i in xrange(24):
8998             self.assertAlmostEqual(da.getIJ(0,i),expected2[i],13)
8999             pass
9000         for pos,elt in enumerate(dabis):
9001             da[pos]*=elt
9002             pass
9003         self.assertEqual(12,da.getNumberOfTuples());
9004         self.assertEqual(2,da.getNumberOfComponents());
9005         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]
9006         for i in xrange(24):
9007             self.assertAlmostEqual(da.getIJ(0,i),expected3[i],13)
9008             pass
9009         # operator/=
9010         da=DataArrayDouble.New(range(6,30),12,2)
9011         da2=DataArrayDouble.New(range(1,13),12,1)
9012         dabis=-da
9013         da/=da2
9014         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]
9015         for i in xrange(24):
9016             self.assertAlmostEqual(da.getIJ(0,i),expected1[i],13)
9017             pass
9018         da=-dabis
9019         da/=[100.,101.]
9020         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]
9021         self.assertEqual(12,da.getNumberOfTuples());
9022         self.assertEqual(2,da.getNumberOfComponents());
9023         for i in xrange(24):
9024             self.assertAlmostEqual(da.getIJ(0,i),expected2[i],13)
9025             pass
9026         for pos,elt in enumerate(dabis):
9027             da[pos]/=elt
9028             pass
9029         self.assertEqual(12,da.getNumberOfTuples());
9030         self.assertEqual(2,da.getNumberOfComponents());
9031         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]
9032         for i in xrange(24):
9033             self.assertAlmostEqual(da.getIJ(0,i),expected3[i],13)
9034             pass
9035         pass
9036
9037     def testSwigDAIOp4(self):
9038         da=DataArrayInt.New(range(6,30),12,2)
9039         self.assertEqual(12,da.getNumberOfTuples());
9040         self.assertEqual(2,da.getNumberOfComponents());
9041         for i in xrange(24):
9042             self.assertEqual(da.getIJ(0,i),i+6)
9043             pass
9044         # operator transpose
9045         da.transpose()
9046         self.assertEqual(2,da.getNumberOfTuples());
9047         self.assertEqual(12,da.getNumberOfComponents());
9048         for i in xrange(24):
9049             self.assertEqual(da.getIJ(0,i),i+6)
9050             pass
9051         da.transpose()
9052         # operator __neg__
9053         da2=DataArrayInt.New(12,1)
9054         da2.iota(0)
9055         dabis=-da
9056         for i in xrange(24):
9057             self.assertEqual(dabis.getIJ(0,i),-(i+6))
9058             pass
9059         # operator+=
9060         da+=da2
9061         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]
9062         for i in xrange(24):
9063             self.assertEqual(da.getIJ(0,i),expected1[i])
9064             pass
9065         da=-dabis
9066         da+=[100,101]
9067         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]
9068         self.assertEqual(12,da.getNumberOfTuples());
9069         self.assertEqual(2,da.getNumberOfComponents());
9070         for i in xrange(24):
9071             self.assertEqual(da.getIJ(0,i),expected2[i])
9072             pass
9073         for pos,elt in enumerate(dabis):
9074             da[pos]+=elt
9075             pass
9076         self.assertEqual(12,da.getNumberOfTuples());
9077         self.assertEqual(2,da.getNumberOfComponents());
9078         for elt in da:
9079             li=elt[:]
9080             self.assertEqual(li[0],100) ; self.assertEqual(li[1],101)
9081             pass
9082         # operator-=
9083         da=DataArrayInt.New(range(6,30),12,2)
9084         da2=DataArrayInt.New(range(12),12,1)
9085         dabis=-da
9086         da-=da2
9087         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]
9088         for i in xrange(24):
9089             self.assertEqual(da.getIJ(0,i),expected1[i])
9090             pass
9091         da=-dabis
9092         da-=[100,101]
9093         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]
9094         self.assertEqual(12,da.getNumberOfTuples());
9095         self.assertEqual(2,da.getNumberOfComponents());
9096         for i in xrange(24):
9097             self.assertEqual(da.getIJ(0,i),expected2[i])
9098             pass
9099         for pos,elt in enumerate(dabis):
9100             da[pos]-=elt
9101             pass
9102         self.assertEqual(12,da.getNumberOfTuples());
9103         self.assertEqual(2,da.getNumberOfComponents());
9104         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]
9105         for i in xrange(24):
9106             self.assertEqual(da.getIJ(0,i),expected3[i])
9107             pass
9108         # operator*=
9109         da=DataArrayInt.New(range(6,30),12,2)
9110         da2=DataArrayInt.New(range(12),12,1)
9111         dabis=-da
9112         da*=da2
9113         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]
9114         for i in xrange(24):
9115             self.assertEqual(da.getIJ(0,i),expected1[i])
9116             pass
9117         da=-dabis
9118         da*=[100,101]
9119         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]
9120         self.assertEqual(12,da.getNumberOfTuples());
9121         self.assertEqual(2,da.getNumberOfComponents());
9122         for i in xrange(24):
9123             self.assertEqual(da.getIJ(0,i),expected2[i])
9124             pass
9125         for pos,elt in enumerate(dabis):
9126             da[pos]*=elt
9127             pass
9128         self.assertEqual(12,da.getNumberOfTuples());
9129         self.assertEqual(2,da.getNumberOfComponents());
9130         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]
9131         for i in xrange(24):
9132             self.assertEqual(da.getIJ(0,i),expected3[i])
9133             pass
9134         # operator/=
9135         da=DataArrayInt.New(range(6,30),12,2)
9136         da2=DataArrayInt.New(range(1,13),12,1)
9137         dabis=-da
9138         da/=da2
9139         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]
9140         for i in xrange(24):
9141             self.assertEqual(da.getIJ(0,i),expected1[i])
9142             pass
9143         da=-dabis
9144         da/=DataArrayInt.New([2,3],1,2)
9145         self.assertEqual(12,da.getNumberOfTuples());
9146         self.assertEqual(2,da.getNumberOfComponents());
9147         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]
9148         for i in xrange(24):
9149             self.assertEqual(da.getIJ(0,i),expected2[i])
9150             pass
9151         pass
9152
9153     def testSwigDADOp5(self):
9154         da=DataArrayDouble.New([5,6,7,8,9,6,7,-2,3,9,8,10])
9155         da.rearrange(3)
9156         da2=DataArrayDouble.New([5.,8.,10.,12])
9157         self.assertEqual(4,da2.getNumberOfTuples());
9158         self.assertEqual(1,da2.getNumberOfComponents());
9159         da3=da+da2
9160         self.assertEqual(4,da3.getNumberOfTuples());
9161         self.assertEqual(3,da3.getNumberOfComponents());
9162         expected1=[10.,11.,12.,16.,17.,14.,17.,8.,13.,21.,20.,22.]
9163         for i in xrange(12):
9164             self.assertAlmostEqual(da3.getIJ(0,i),expected1[i],13)
9165             pass
9166         da3=da2+da
9167         self.assertEqual(4,da3.getNumberOfTuples());
9168         self.assertEqual(3,da3.getNumberOfComponents());
9169         for i in xrange(12):
9170             self.assertAlmostEqual(da3.getIJ(0,i),expected1[i],13)
9171             pass
9172         # Test new API of classmethod DataArrayDouble.New
9173         vals=[5,6,7,8,9,6,7,-2,3,9,8,10]
9174         da=DataArrayDouble.New(vals)
9175         self.assertEqual(12,da.getNumberOfTuples());
9176         self.assertEqual(1,da.getNumberOfComponents());
9177         for i in xrange(12):
9178             self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
9179             pass
9180         da=DataArrayDouble.New(vals,12)
9181         self.assertEqual(12,da.getNumberOfTuples());
9182         self.assertEqual(1,da.getNumberOfComponents());
9183         for i in xrange(12):
9184             self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
9185             pass
9186         da=DataArrayDouble.New(vals,1,12)
9187         self.assertEqual(1,da.getNumberOfTuples());
9188         self.assertEqual(12,da.getNumberOfComponents());
9189         for i in xrange(12):
9190             self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
9191             pass
9192         da=DataArrayDouble.New(vals,6,2)
9193         self.assertEqual(6,da.getNumberOfTuples());
9194         self.assertEqual(2,da.getNumberOfComponents());
9195         for i in xrange(12):
9196             self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
9197             pass
9198         da=DataArrayDouble.New(vals,4,3)
9199         self.assertEqual(4,da.getNumberOfTuples());
9200         self.assertEqual(3,da.getNumberOfComponents());
9201         for i in xrange(12):
9202             self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
9203             pass
9204         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,11);
9205         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,13);
9206         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,5,2);
9207         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,7,2);
9208         pass
9209
9210     def testSwigDADOp6(self):
9211         da=DataArrayInt.New([5,6,7,8,9,6,7,-2,3,9,8,10])
9212         da.rearrange(3)
9213         da2=DataArrayInt.New([5,8,10,12])
9214         self.assertEqual(4,da2.getNumberOfTuples());
9215         self.assertEqual(1,da2.getNumberOfComponents());
9216         da3=da+da2
9217         self.assertEqual(4,da3.getNumberOfTuples());
9218         self.assertEqual(3,da3.getNumberOfComponents());
9219         expected1=[10,11,12,16,17,14,17,8,13,21,20,22]
9220         for i in xrange(12):
9221             self.assertEqual(da3.getIJ(0,i),expected1[i])
9222             pass
9223         da3=da2+da
9224         self.assertEqual(4,da3.getNumberOfTuples());
9225         self.assertEqual(3,da3.getNumberOfComponents());
9226         for i in xrange(12):
9227             self.assertEqual(da3.getIJ(0,i),expected1[i])
9228             pass
9229         da3=da+DataArrayInt.New(da2.getValues())
9230         # Test new API of classmethod DataArrayInt.New
9231         vals=[5,6,7,8,9,6,7,-2,3,9,8,10]
9232         da=DataArrayDouble.New(vals)
9233         self.assertEqual(12,da.getNumberOfTuples());
9234         self.assertEqual(1,da.getNumberOfComponents());
9235         for i in xrange(12):
9236             self.assertEqual(da.getIJ(0,i),vals[i])
9237             pass
9238         da=DataArrayDouble.New(vals,12)
9239         self.assertEqual(12,da.getNumberOfTuples());
9240         self.assertEqual(1,da.getNumberOfComponents());
9241         for i in xrange(12):
9242             self.assertEqual(da.getIJ(0,i),vals[i])
9243             pass
9244         da=DataArrayDouble.New(vals,1,12)
9245         self.assertEqual(1,da.getNumberOfTuples());
9246         self.assertEqual(12,da.getNumberOfComponents());
9247         for i in xrange(12):
9248             self.assertEqual(da.getIJ(0,i),vals[i])
9249             pass
9250         da=DataArrayDouble.New(vals,6,2)
9251         self.assertEqual(6,da.getNumberOfTuples());
9252         self.assertEqual(2,da.getNumberOfComponents());
9253         for i in xrange(12):
9254             self.assertEqual(da.getIJ(0,i),vals[i])
9255             pass
9256         da=DataArrayDouble.New(vals,4,3)
9257         self.assertEqual(4,da.getNumberOfTuples());
9258         self.assertEqual(3,da.getNumberOfComponents());
9259         for i in xrange(12):
9260             self.assertEqual(da.getIJ(0,i),vals[i])
9261             pass
9262         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,11);
9263         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,13);
9264         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,5,2);
9265         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,7,2);
9266         pass
9267
9268     def testSwigDADOp9(self):
9269         l1=[(1.,2.,3),(4.,5.,6.),(7.,8.,9.),[10.,11.,12.]]
9270         da1=DataArrayDouble(l1,4,3)
9271         self.assertEqual(4,da1.getNumberOfTuples());
9272         self.assertEqual(3,da1.getNumberOfComponents());
9273         da2=DataArrayDouble(12) ; da2.iota(1.) ; da2.rearrange(3)
9274         self.assertTrue(da2.isEqual(da1,1e-12))
9275         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,3,4);
9276         da3=DataArrayDouble(l1,4)
9277         self.assertTrue(da3.isEqual(da1,1e-12))
9278         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,3);
9279         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,5);
9280         l1=[(1.,2.,3),(4.,(5.),((6.))),(7.,8.,9.),[10.,11.,12.]]
9281         da1=DataArrayDouble(l1,4,3)
9282         self.assertEqual(4,da1.getNumberOfTuples());
9283         self.assertEqual(3,da1.getNumberOfComponents());
9284         da2=DataArrayDouble(12) ; da2.iota(1.) ; da2.rearrange(3)
9285         self.assertTrue(da2.isEqual(da1,1e-12))
9286         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,3,4);
9287         da3=DataArrayDouble(l1,4)
9288         self.assertTrue(da3.isEqual(da1,1e-12))
9289         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,3);
9290         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,5);
9291         #
9292         l1=[(1,2,3),(4,5,6),(7,8,9),[10,11,12]]
9293         da1=DataArrayInt(l1,4,3)
9294         self.assertEqual(4,da1.getNumberOfTuples());
9295         self.assertEqual(3,da1.getNumberOfComponents());
9296         da2=DataArrayInt(12) ; da2.iota(1) ; da2.rearrange(3)
9297         self.assertTrue(da2.isEqual(da1))
9298         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,3,4);
9299         da3=DataArrayInt(l1,4)
9300         self.assertTrue(da3.isEqual(da1))
9301         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,3);
9302         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,5);
9303         l1=[(1,[2],3),(4,[(5)],6),((([7])),8,9),[10,11,12]]
9304         da1=DataArrayInt(l1,4,3)
9305         self.assertEqual(4,da1.getNumberOfTuples());
9306         self.assertEqual(3,da1.getNumberOfComponents());
9307         da2=DataArrayInt(12) ; da2.iota(1) ; da2.rearrange(3)
9308         self.assertTrue(da2.isEqual(da1))
9309         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,3,4);
9310         da3=DataArrayInt(l1,4)
9311         self.assertTrue(da3.isEqual(da1))
9312         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,3);
9313         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,5);
9314         pass
9315
9316     def testRenumberNodesInConn1(self):
9317         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. ]
9318         mesh2DConn=[1,4,2, 4,5,2, 0,3,4,1, 6,7,4,3, 7,8,5,4]
9319         mesh2D=MEDCouplingUMesh.New("mesh",2);
9320         mesh2D.allocateCells(5);
9321         mesh2D.insertNextCell(NORM_TRI3,3,mesh2DConn[0:3])
9322         mesh2D.insertNextCell(NORM_TRI3,3,mesh2DConn[3:6])
9323         mesh2D.insertNextCell(NORM_QUAD4,4,mesh2DConn[6:10])
9324         mesh2D.insertNextCell(NORM_QUAD4,4,mesh2DConn[10:14])
9325         mesh2D.insertNextCell(NORM_QUAD4,4,mesh2DConn[14:18])
9326         mesh2D.finishInsertingCells();
9327         myCoords=DataArrayDouble.New(mesh2DCoords,9,3);
9328         mesh2D.setCoords(myCoords);
9329         mesh2D.checkCoherency();
9330         #
9331         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. ]
9332         mesh3DConn=[0,1,2,3,4,5,6,7]
9333         mesh3D=MEDCouplingUMesh.New("mesh",3);
9334         mesh3D.allocateCells(1);
9335         mesh3D.insertNextCell(NORM_HEXA8,8,mesh3DConn[:])
9336         mesh3D.finishInsertingCells();
9337         myCoords3D=DataArrayDouble.New(mesh3DCoords,8,3);
9338         mesh3D.setCoords(myCoords3D);
9339         mesh3D.checkCoherency();
9340         #
9341         mesh3D_2=mesh3D.deepCpy();
9342         mesh2D_2=mesh2D.deepCpy();
9343         mesh3D_4=mesh3D.deepCpy();
9344         mesh2D_4=mesh2D.deepCpy();
9345         oldNbOf3DNodes=mesh3D.getNumberOfNodes();
9346         renumNodes=DataArrayInt.New();
9347         renumNodes.alloc(mesh2D.getNumberOfNodes(),1);
9348         renumNodes.iota(oldNbOf3DNodes);
9349         coo=DataArrayDouble.Aggregate(mesh3D.getCoords(),mesh2D.getCoords());
9350         mesh3D.setCoords(coo);
9351         mesh2D.setCoords(coo);
9352         mesh2DCpy=mesh2D.deepCpy()
9353         mesh2D_3=mesh2D.deepCpy();
9354         mesh2D_3.shiftNodeNumbersInConn(oldNbOf3DNodes);
9355         mesh2D.renumberNodesInConn(renumNodes);
9356         mesh2DCpy.renumberNodesInConn(renumNodes.getValues());
9357         self.assertTrue(mesh2D.isEqual(mesh2DCpy,1e-12))
9358         self.assertTrue(mesh2D.isEqual(mesh2D_3,1e-12))
9359         #
9360         da1,da2=mesh3D.checkGeoEquivalWith(mesh3D_2,10,1e-12);
9361         self.assertTrue(da1==None);
9362         self.assertEqual(8,da2.getNumberOfTuples());
9363         self.assertEqual(1,da2.getNumberOfComponents());
9364         expected1=[8,11,12,9,4,5,6,7]
9365         for i in xrange(8):
9366             self.assertEqual(expected1[i],da2.getIJ(i,0));
9367             pass
9368         #
9369         da1,da2=mesh2D.checkGeoEquivalWith(mesh2D_2,10,1e-12);
9370         self.assertTrue(da1==None);
9371         self.assertEqual(9,da2.getNumberOfTuples());
9372         self.assertEqual(1,da2.getNumberOfComponents());
9373         for i in xrange(9):
9374             self.assertEqual(8+i,da2.getIJ(i,0));
9375             pass
9376         #
9377         mesh2D_5=mesh2D_4.deepCpy();
9378         mesh2D_5.translate([1.,0.,0.]);
9379         meshes=[mesh3D_4,mesh2D_4,mesh2D_5];
9380         MEDCouplingUMesh.PutUMeshesOnSameAggregatedCoords(meshes);
9381         self.assertTrue(mesh3D_4.getCoords().getHiddenCppPointer()==mesh2D_4.getCoords().getHiddenCppPointer());
9382         self.assertTrue(mesh2D_4.getCoords().getHiddenCppPointer()==mesh2D_5.getCoords().getHiddenCppPointer());
9383         mesh3D_4.checkCoherency(); mesh2D_4.checkCoherency(); mesh2D_5.checkCoherency();
9384         self.assertEqual(26,mesh3D_4.getNumberOfNodes());
9385         self.assertEqual(3,mesh3D_4.getSpaceDimension());
9386         self.assertEqual(9,mesh3D_4.getNodalConnectivity().getNumberOfTuples());
9387         self.assertEqual(23,mesh2D_4.getNodalConnectivity().getNumberOfTuples());
9388         self.assertEqual(23,mesh2D_5.getNodalConnectivity().getNumberOfTuples());
9389         expected2=[18,0,1,2,3,4,5,6,7]
9390         expected3=[3,9,12,10, 3,12,13,10, 4,8,11,12,9, 4,14,15,12,11, 4,15,16,13,12]
9391         expected4=[3,18,21,19, 3,21,22,19, 4,17,20,21,18, 4,23,24,21,20, 4,24,25,22,21]
9392         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]
9393         self.assertEqual(expected2,mesh3D_4.getNodalConnectivity().getValues());
9394         self.assertEqual(expected3,mesh2D_4.getNodalConnectivity().getValues());
9395         self.assertEqual(expected4,mesh2D_5.getNodalConnectivity().getValues());
9396         for i in xrange(78):
9397             self.assertAlmostEqual(expected5[i],mesh3D_4.getCoords().getIJ(0,i),12);
9398             pass
9399         #
9400         MEDCouplingUMesh.MergeNodesOnUMeshesSharingSameCoords(meshes,1e-12);
9401         mesh3D_4.checkCoherency(); mesh2D_4.checkCoherency(); mesh2D_5.checkCoherency();
9402         self.assertTrue(mesh3D_4.getCoords().getHiddenCppPointer()==mesh2D_4.getCoords().getHiddenCppPointer());
9403         self.assertTrue(mesh2D_4.getCoords().getHiddenCppPointer()==mesh2D_5.getCoords().getHiddenCppPointer());
9404         self.assertEqual(19,mesh3D_4.getNumberOfNodes());
9405         self.assertEqual(3,mesh3D_4.getSpaceDimension());
9406         self.assertEqual(9,mesh3D_4.getNodalConnectivity().getNumberOfTuples());
9407         self.assertEqual(23,mesh2D_4.getNodalConnectivity().getNumberOfTuples());
9408         self.assertEqual(23,mesh2D_5.getNodalConnectivity().getNumberOfTuples());
9409         expected6=[18,0,1,2,3,4,5,6,7]
9410         expected7=[3,3,2,8, 3,2,9,8, 4,0,1,2,3, 4,10,11,2,1, 4,11,12,9,2]
9411         expected8=[3,13,15,14, 3,15,16,14, 4,8,9,15,13, 4,12,17,15,9, 4,17,18,16,15]
9412         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.,
9413                     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.,
9414                     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.]
9415         self.assertEqual(expected6,mesh3D_4.getNodalConnectivity().getValues());
9416         self.assertEqual(expected7,mesh2D_4.getNodalConnectivity().getValues());
9417         self.assertEqual(expected8,mesh2D_5.getNodalConnectivity().getValues());
9418         for i in xrange(57):
9419             self.assertAlmostEqual(expected9[i],mesh3D_4.getCoords().getIJ(0,i),12);
9420             pass
9421         #
9422         pass
9423
9424     def testComputeNeighborsOfCells1(self):
9425         m=MEDCouplingDataForTest.build2DTargetMesh_1();
9426         d1,d2=m.computeNeighborsOfCells();
9427         self.assertEqual(6,d2.getNumberOfTuples());
9428         self.assertEqual(10,d1.getNumberOfTuples());
9429         expected1=[0,2,4,6,8,10]
9430         expected2=[3,1,0,2,4,1,4,0,2,3]
9431         self.assertEqual(expected1,d2.getValues());
9432         self.assertEqual(expected2,d1.getValues());
9433         pass
9434
9435     def testCheckButterflyCellsBug1(self):
9436         mesh2DCoords=[323.85,120.983748908684,317.5,131.982271536747,336.55,120.983748908686,330.2,131.982271536751,323.85,142.98079416481]
9437         mesh2DConn=[4,1,0,2,3]
9438         mesh2D=MEDCouplingUMesh.New("mesh",2);
9439         mesh2D.allocateCells(1);
9440         mesh2D.insertNextCell(NORM_POLYGON,5,mesh2DConn[0:5])
9441         mesh2D.finishInsertingCells();
9442         myCoords=DataArrayDouble.New(mesh2DCoords,5,2);
9443         mesh2D.setCoords(myCoords);
9444         mesh2D.checkCoherency();
9445         #
9446         v=mesh2D.checkButterflyCells();
9447         self.assertTrue(v.empty());
9448         pass
9449
9450     def testDataArrayIntRange1(self):
9451         d=DataArrayInt.Range(2,17,7);
9452         expected1=[2,9,16]
9453         self.assertEqual(3,d.getNumberOfTuples());
9454         self.assertEqual(1,d.getNumberOfComponents());
9455         self.assertEqual(expected1,d.getValues());
9456         #
9457         d=DataArrayInt.Range(2,23,7);
9458         self.assertEqual(3,d.getNumberOfTuples());
9459         self.assertEqual(1,d.getNumberOfComponents());
9460         self.assertEqual(expected1,d.getValues());
9461         #
9462         d=DataArrayInt.Range(2,24,7);
9463         expected2=[2,9,16,23]
9464         self.assertEqual(4,d.getNumberOfTuples());
9465         self.assertEqual(1,d.getNumberOfComponents());
9466         self.assertEqual(expected2,d.getValues());
9467         #
9468         d=DataArrayInt.Range(24,2,-7);
9469         expected3=[24,17,10,3]
9470         self.assertEqual(4,d.getNumberOfTuples());
9471         self.assertEqual(1,d.getNumberOfComponents());
9472         self.assertEqual(expected3,d.getValues());
9473         #
9474         d=DataArrayInt.Range(23,2,-7);
9475         expected4=[23,16,9]
9476         self.assertEqual(3,d.getNumberOfTuples());
9477         self.assertEqual(1,d.getNumberOfComponents());
9478         self.assertEqual(expected4,d.getValues());
9479         #
9480         d=DataArrayInt.Range(23,22,-7);
9481         self.assertEqual(1,d.getNumberOfTuples());
9482         self.assertEqual(1,d.getNumberOfComponents());
9483         self.assertEqual(23,d.getIJ(0,0));
9484         #
9485         d=DataArrayInt.Range(22,23,7);
9486         self.assertEqual(1,d.getNumberOfTuples());
9487         self.assertEqual(1,d.getNumberOfComponents());
9488         self.assertEqual(22,d.getIJ(0,0));
9489         #
9490         d=DataArrayInt.Range(22,22,7);
9491         self.assertEqual(0,d.getNumberOfTuples());
9492         self.assertEqual(1,d.getNumberOfComponents());
9493         #
9494         d=DataArrayInt.Range(22,22,-7);
9495         self.assertEqual(0,d.getNumberOfTuples());
9496         self.assertEqual(1,d.getNumberOfComponents());
9497         #
9498         self.assertRaises(InterpKernelException,DataArrayInt.Range,22,23,-7);
9499         self.assertRaises(InterpKernelException,DataArrayInt.Range,23,22,7);
9500         self.assertRaises(InterpKernelException,DataArrayInt.Range,23,22,0);
9501         self.assertRaises(InterpKernelException,DataArrayInt.Range,22,23,0);
9502         pass
9503
9504     def testSwigUMeshGetItem1(self):
9505         m=MEDCouplingDataForTest.build2DTargetMesh_1();
9506         subMesh=m.buildPartOfMySelf([1,3],True);
9507         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
9508         m1=m[[1,3]]
9509         self.assertTrue(isinstance(m1,MEDCouplingUMesh))
9510         m2=m[(1,3)]
9511         self.assertTrue(isinstance(m2,MEDCouplingUMesh))
9512         m3=m[1::2]
9513         self.assertTrue(isinstance(m3,MEDCouplingUMesh))
9514         m4=m[DataArrayInt.New([1,3])]
9515         m5_1=m[1]
9516         self.assertTrue(isinstance(m5_1,MEDCouplingUMesh))
9517         m5_2=m[3]
9518         self.assertTrue(isinstance(m5_2,MEDCouplingUMesh))
9519         m5=MEDCouplingUMesh.MergeUMeshesOnSameCoords([m5_1,m5_2]);
9520         m5.setName(subMesh.getName())
9521         self.assertTrue(isinstance(m4,MEDCouplingUMesh))
9522         self.assertTrue(subMesh.isEqual(m1,1e-12))
9523         self.assertTrue(subMesh.isEqual(m2,1e-12))
9524         self.assertTrue(subMesh.isEqual(m3,1e-12))
9525         self.assertTrue(subMesh.isEqual(m4,1e-12))
9526         self.assertTrue(subMesh.isEqual(m5,1e-12))
9527         self.assertRaises(InterpKernelException,m.buildPartOfMySelf,[1,5],True);
9528         pass
9529
9530     def testSwigGetItem3(self):
9531         da=DataArrayInt.New([4,5,6])
9532         self.assertEqual(5,da[1])
9533         self.assertRaises(InterpKernelException,da.__getitem__,-1)
9534         self.assertRaises(InterpKernelException,da.__getitem__,3)
9535         da=DataArrayInt.New([4,5,6,7,8,9],2,3)
9536         self.assertEqual(9,da[1,2])
9537         da=DataArrayDouble.New([4.1,5.2,6.3])
9538         self.assertAlmostEqual(5.2,da[1],12)
9539         self.assertRaises(InterpKernelException,da.__getitem__,-1)
9540         self.assertRaises(InterpKernelException,da.__getitem__,3)
9541         da=DataArrayDouble.New([4.12,5.12,6.12,7.12,8.12,9.12],2,3)
9542         self.assertAlmostEqual(9.12,da[1,2],12)
9543         pass
9544
9545     def testSwigDADISub1(self):
9546         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
9547         bary=mesh3D.getBarycenterAndOwner()
9548         bary=bary[:,:2]
9549         pts=bary.getDifferentValues(1e-12)
9550         expected=[[0,6,12],[1,7,13],[2,8,14],[3,9,15],[4,10,16],[5,11,17]]
9551         for pos,pt in enumerate(pts):
9552             bary2=bary[:,:2]
9553             bary2[:]-=pt
9554             norm=bary2.magnitude()
9555             self.assertEqual(expected[pos],norm.getIdsInRange(-1.,1e-5).getValues())
9556             pass
9557         expected2=[[3.,54.],[-141.,180.],[21.,54.],[39.,72.],[-15.,90.],[21.,90.]]
9558         for pos,pt in enumerate(pts):
9559             bary2=bary[:,:2]
9560             bary2[:]+=pt
9561             self.assertAlmostEqual(expected2[pos][0],bary2.accumulate()[0],12);
9562             self.assertAlmostEqual(expected2[pos][1],bary2.accumulate()[1],12);
9563             pass
9564         expected3=[[-3.,22.5],[45.,337.5],[-9., 22.5],[-15.,67.5],[3.,112.5],[-9.,112.5]]
9565         for pos,pt in enumerate(pts):
9566             bary2=bary[:,:2]
9567             bary2[:]*=pt
9568             self.assertAlmostEqual(expected3[pos][0],bary2.accumulate()[0],12);
9569             self.assertAlmostEqual(expected3[pos][1],bary2.accumulate()[1],12);
9570             pass
9571         expected4=[[-12.,90.],[0.8,6.],[-4,90.],[-2.4,30.],[12.,18],[-4,18.]]
9572         for pos,pt in enumerate(pts):
9573             bary2=bary[:,:2]
9574             bary2[:]/=pt
9575             self.assertAlmostEqual(expected4[pos][0],bary2.accumulate()[0],12);
9576             self.assertAlmostEqual(expected4[pos][1],bary2.accumulate()[1],12);
9577             pass
9578         #
9579         d=DataArrayInt.New([1,2,0,1,0,2],3,2)
9580         e=DataArrayInt.New([1,11,101,2,12,102,3,13,103,4,14,104],4,3)
9581         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]]
9582         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]]
9583         for pos,tup in enumerate(d):
9584             f=e[:]
9585             self.assertTrue(isinstance(f,DataArrayInt))
9586             f[tup]=77
9587             self.assertEqual(expected5[pos],f.getValues())
9588             self.assertEqual(6*[77],f[tup].getValues())
9589             f=e[:]
9590             f[:,tup]=77
9591             self.assertEqual(expected6[pos],f.getValues())
9592             self.assertEqual(8*[77],f[:,tup].getValues())
9593             pass
9594         #
9595         e=e.convertToDblArr()
9596         for pos,tup in enumerate(d):
9597             f=e[:]
9598             self.assertTrue(isinstance(f,DataArrayDouble))
9599             f[tup]=77.
9600             self.assertEqual(expected5[pos],f.convertToIntArr().getValues())
9601             self.assertEqual(6*[77],f[tup].convertToIntArr().getValues())
9602             f=e[:]
9603             f[:,tup]=77.
9604             self.assertEqual(expected6[pos],f.convertToIntArr().getValues())
9605             self.assertEqual(8*[77],f[:,tup].convertToIntArr().getValues())
9606             pass
9607         pass
9608
9609     def testDataArrayDoubleGetMinMaxPerComponent1(self):
9610         values1=[1.,2.,3.,-0.9,2.1,3.,1.3,1.7,3.,1.,1.8,3.]
9611         d1=DataArrayDouble.New();
9612         self.assertRaises(InterpKernelException,d1.getMinMaxPerComponent)
9613         d1=DataArrayDouble.New(values1,4,3);
9614         res=d1.getMinMaxPerComponent();
9615         self.assertTrue(isinstance(res,list))
9616         self.assertEqual(3,len(res))
9617         for i in xrange(3):
9618             self.assertTrue(isinstance(res[i],tuple))
9619             self.assertEqual(2,len(res[i]))
9620             pass
9621         expected1=[-0.9,1.3,1.7,2.1,3.,3.]
9622         for i in xrange(6):
9623             self.assertAlmostEqual(expected1[i],res[i/2][i%2],14)
9624             pass
9625         #
9626         d1.rearrange(2);
9627         res=d1.getMinMaxPerComponent();
9628         self.assertTrue(isinstance(res,list))
9629         self.assertEqual(2,len(res))
9630         for i in xrange(2):
9631             self.assertTrue(isinstance(res[i],tuple))
9632             self.assertEqual(2,len(res[i]))
9633             pass
9634         expected2=[1.,3.,-0.9,3.]
9635         for i in xrange(4):
9636             self.assertAlmostEqual(expected2[i],res[i/2][i%2],14)
9637             pass
9638         #
9639         d1.rearrange(1);
9640         res=d1.getMinMaxPerComponent();
9641         self.assertTrue(isinstance(res,list))
9642         self.assertEqual(1,len(res))
9643         for i in xrange(1):
9644             self.assertTrue(isinstance(res[i],tuple))
9645             self.assertEqual(2,len(res[i]))
9646             pass
9647         expected3=[-0.9,3.]
9648         for i in xrange(2):
9649             self.assertAlmostEqual(expected3[i],res[i/2][i%2],14)
9650             pass
9651         pass
9652
9653     def testDataArrayIntGetHashCode1(self):
9654         d1=DataArrayInt.New(range(3545))
9655         d2=DataArrayInt.New(range(3545))
9656         self.assertEqual(d2.getHashCode(),d1.getHashCode())
9657         self.assertEqual(232341068,d1.getHashCode())
9658         d1[886]=6
9659         self.assertEqual(232340188,d1.getHashCode())
9660         pass
9661
9662     def testZipConnectivityPol1(self):
9663         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
9664         cells1=[2,3,4]
9665         m2_1=m1.buildPartOfMySelf(cells1,True);
9666         m2=m2_1
9667         self.assertTrue(isinstance(m2,MEDCouplingUMesh))
9668         # no permutation policy 0
9669         isOk,arr=m1.areCellsIncludedIn(m2,0)
9670         self.assertTrue(isOk);
9671         self.assertEqual(3,arr.getNumberOfTuples());
9672         self.assertEqual(1,arr.getNumberOfComponents());
9673         self.assertEqual(cells1,arr.getValues())
9674         # no permutation policy 1
9675         isOk,arr=m1.areCellsIncludedIn(m2,1)
9676         self.assertTrue(isOk);
9677         self.assertEqual(3,arr.getNumberOfTuples());
9678         self.assertEqual(1,arr.getNumberOfComponents());
9679         self.assertEqual(cells1,arr.getValues())
9680         # no permutation policy 2
9681         isOk,arr=m1.areCellsIncludedIn(m2,2)
9682         self.assertTrue(isOk);
9683         self.assertEqual(3,arr.getNumberOfTuples());
9684         self.assertEqual(1,arr.getNumberOfComponents());
9685         self.assertEqual(cells1,arr.getValues())
9686         # some modification into m2
9687         modif1=[2,4,5]
9688         m2.getNodalConnectivity()[1:4]=modif1
9689         #policy 0 fails because cell0 in m2 has same orientation be not same connectivity
9690         expected1=[5,3,4]
9691         isOk,arr=m1.areCellsIncludedIn(m2,0)
9692         self.assertTrue(not isOk);
9693         self.assertEqual(3,arr.getNumberOfTuples());
9694         self.assertEqual(1,arr.getNumberOfComponents());
9695         self.assertEqual(expected1,arr.getValues())
9696         #policy 1 succeeds because cell0 in m2 has not exactly the same conn
9697         isOk,arr=m1.areCellsIncludedIn(m2,1)
9698         self.assertTrue(isOk);
9699         self.assertEqual(3,arr.getNumberOfTuples());
9700         self.assertEqual(1,arr.getNumberOfComponents());
9701         self.assertEqual(cells1,arr.getValues())
9702         #policy 2 succeeds because cell0 in m2 has same nodes in connectivity
9703         isOk,arr=m1.areCellsIncludedIn(m2,2)
9704         self.assertTrue(isOk);
9705         self.assertEqual(3,arr.getNumberOfTuples());
9706         self.assertEqual(1,arr.getNumberOfComponents());
9707         self.assertEqual(cells1,arr.getValues())
9708         #some new modification into m2
9709         modif2=[2,5,4]
9710         m2.getNodalConnectivity()[1:4]=modif2
9711         #policy 0 fails because cell0 in m2 has not exactly the same conn
9712         isOk,arr=m1.areCellsIncludedIn(m2,0)
9713         self.assertTrue(not isOk);
9714         self.assertEqual(3,arr.getNumberOfTuples());
9715         self.assertEqual(1,arr.getNumberOfComponents());
9716         self.assertEqual(expected1,arr.getValues())
9717         #policy 1 fails too because cell0 in m2 has not same orientation
9718         isOk,arr=m1.areCellsIncludedIn(m2,1)
9719         self.assertTrue(not isOk);
9720         self.assertEqual(3,arr.getNumberOfTuples());
9721         self.assertEqual(1,arr.getNumberOfComponents());
9722         self.assertEqual(expected1,arr.getValues())
9723         #policy 2 succeeds because cell0 in m2 has same nodes in connectivity
9724         isOk,arr=m1.areCellsIncludedIn(m2,2)
9725         self.assertTrue(isOk);
9726         self.assertEqual(3,arr.getNumberOfTuples());
9727         self.assertEqual(1,arr.getNumberOfComponents());
9728         self.assertEqual(cells1,arr.getValues())
9729         # Now 1D
9730         cells2=[3,2]
9731         m1=MEDCouplingDataForTest.build1DSourceMesh_2();
9732         m2_1=m1.buildPartOfMySelf(cells2,True);
9733         m2=m2_1
9734         self.assertTrue(isinstance(m2,MEDCouplingUMesh))
9735         # no permutation policy 0
9736         isOk,arr=m1.areCellsIncludedIn(m2,0)
9737         self.assertTrue(isOk);
9738         self.assertEqual(2,arr.getNumberOfTuples());
9739         self.assertEqual(1,arr.getNumberOfComponents());
9740         self.assertEqual(cells2,arr.getValues())
9741         # no permutation policy 1
9742         isOk,arr=m1.areCellsIncludedIn(m2,1)
9743         self.assertTrue(isOk);
9744         self.assertEqual(2,arr.getNumberOfTuples());
9745         self.assertEqual(1,arr.getNumberOfComponents());
9746         self.assertEqual(cells2,arr.getValues())
9747         # no permutation policy 2
9748         isOk,arr=m1.areCellsIncludedIn(m2,2)
9749         self.assertTrue(isOk);
9750         self.assertEqual(2,arr.getNumberOfTuples());
9751         self.assertEqual(1,arr.getNumberOfComponents());
9752         self.assertEqual(cells2,arr.getValues())
9753         # some modification into m2
9754         modif3=[4,3]
9755         m2.getNodalConnectivity()[1:3]=modif3
9756         #policy 0 fails because cell0 in m2 has not exactly the same conn
9757         expected2=[4,2]
9758         isOk,arr=m1.areCellsIncludedIn(m2,0)
9759         self.assertTrue(not isOk);
9760         self.assertEqual(2,arr.getNumberOfTuples());
9761         self.assertEqual(1,arr.getNumberOfComponents());
9762         self.assertEqual(expected2,arr.getValues())
9763         #policy 1 fails too because cell0 in m2 has not same orientation
9764         isOk,arr=m1.areCellsIncludedIn(m2,1)
9765         self.assertTrue(not isOk);
9766         self.assertEqual(2,arr.getNumberOfTuples());
9767         self.assertEqual(1,arr.getNumberOfComponents());
9768         self.assertEqual(expected2,arr.getValues())
9769         #policy 2 succeeds because cell0 in m2 has same nodes in connectivity
9770         isOk,arr=m1.areCellsIncludedIn(m2,2)
9771         self.assertTrue(isOk);
9772         self.assertEqual(2,arr.getNumberOfTuples());
9773         self.assertEqual(1,arr.getNumberOfComponents());
9774         self.assertEqual(cells2,arr.getValues())
9775         pass
9776
9777     def toSeeIfDaIIopsAreOK(self,d):
9778         d+=5
9779         d*=6
9780         d/=3
9781         d-=2
9782         d%=7
9783         pass
9784
9785     def testSwigDAIOp5(self):
9786         d=DataArrayInt.New([4,5,6,10,3,-1],2,3)
9787         self.toSeeIfDaIIopsAreOK(d)
9788         dExp=DataArrayInt.New([2,4,6,0,0,6],2,3)
9789         self.assertTrue(d.isEqual(dExp));
9790         pass
9791
9792     def toSeeIfDaDIopsAreOK(self,d):
9793         d+=5
9794         d*=6
9795         d/=3
9796         d-=2
9797         pass
9798
9799     def testSwigDADOp7(self):
9800         d=DataArrayDouble.New([4.,5.,6.,10.,3.,-1.],2,3)
9801         self.toSeeIfDaDIopsAreOK(d)
9802         dExp=DataArrayDouble.New([16.,18.,20.,28.,14.,6.],2,3)
9803         self.assertTrue(d.isEqual(dExp,1e-14));
9804         pass
9805
9806     def testConvexEnvelop2D1(self):
9807         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]
9808         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]
9809         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]
9810         #
9811         m=MEDCouplingUMesh.New("convexhull",2);
9812         m.allocateCells(331);
9813         for i in xrange(331):
9814             m.insertNextCell(NORM_POLYGON,conn[connI[i]:connI[i+1]]);
9815             pass
9816         m.finishInsertingCells();
9817         coordsDa=DataArrayDouble.New(coords,331,2);
9818         m.setCoords(coordsDa);
9819         m.checkCoherency();
9820         #
9821         da=m.convexEnvelop2D();
9822         m.checkCoherency()
9823         self.assertEqual(coordsDa.getHiddenCppPointer(),m.getCoords().getHiddenCppPointer())
9824         daC=da.buildComplement(m.getNumberOfCells());
9825         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]);
9826         self.assertTrue(expected2.isEqual(daC));
9827         #
9828         vals=m.getMeasureField(ON_CELLS).getArray()
9829         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]
9830         vals-=DataArrayDouble.New(ref)
9831         vals.abs()
9832         theTest=vals.getIdsInRange(-1.,1e-7)
9833         self.assertTrue(theTest.isIdentity())
9834         self.assertEqual(331,len(theTest))
9835         pass
9836
9837     def testSwigDAIOp8(self):
9838         da=DataArrayInt.New([7,5,6,7,8,9,9,10,12,13,47,15])
9839         self.assertTrue(7 in da)
9840         self.assertTrue(47 in da)
9841         self.assertTrue(15 in da)
9842         self.assertEqual(0,da.index(7))
9843         self.assertEqual(10,da.index(47))
9844         self.assertTrue(14 not in da)
9845         self.assertEqual(5,da.search([9,9]))
9846         self.assertEqual(-1,da.search([5,8]))
9847         da.rearrange(2)
9848         self.assertTrue([47,16] not in da)
9849         self.assertTrue([5,6] not in da)
9850         self.assertTrue([6,7] in da)
9851         self.assertEqual(4,da.index([12,13]))
9852         pass
9853
9854     def testDataArraySort1(self):
9855         arr=DataArrayInt.New();
9856         self.assertRaises(InterpKernelException,arr.sort,True)
9857         self.assertRaises(InterpKernelException,arr.sort,False)
9858         values=[2,1,6,5,4,7]
9859         arr.alloc(3,2);
9860         self.assertRaises(InterpKernelException,arr.sort,True)
9861         self.assertRaises(InterpKernelException,arr.sort,False)
9862         arr.rearrange(1);
9863         arr.setValues(values,6,1)
9864         arr1=arr.deepCpy();
9865         arr2=arr.deepCpy();
9866         arr1.sort(True);
9867         expected1=[1,2,4,5,6,7]
9868         self.assertEqual(6,arr1.getNumberOfTuples());
9869         self.assertEqual(1,arr1.getNumberOfComponents());
9870         self.assertEqual(expected1,arr1.getValues());
9871         arr2.sort(False);
9872         expected2=[7,6,5,4,2,1]
9873         self.assertEqual(6,arr2.getNumberOfTuples());
9874         self.assertEqual(1,arr2.getNumberOfComponents());
9875         self.assertTrue(expected2,arr2.getValues());
9876         #
9877         ard=DataArrayDouble.New();
9878         self.assertRaises(InterpKernelException,ard.sort,True)
9879         self.assertRaises(InterpKernelException,ard.sort,False)
9880         valuesD=[2.,1.,6.,5.,4.,7.]
9881         ard.alloc(3,2);
9882         self.assertRaises(InterpKernelException,ard.sort,True)
9883         self.assertRaises(InterpKernelException,ard.sort,False)
9884         ard.rearrange(1);
9885         ard.setValues(valuesD,6,1)
9886         ard1=ard.deepCpy();
9887         ard2=ard.deepCpy();
9888         ard1.sort(True);
9889         expected3=[1.,2.,4.,5.,6.,7.]
9890         self.assertEqual(6,ard1.getNumberOfTuples());
9891         self.assertEqual(1,ard1.getNumberOfComponents());
9892         for i in xrange(6):
9893             self.assertAlmostEqual(expected3[i],ard1.getIJ(i,0),12)
9894             pass
9895         ard2.sort(False);
9896         expected4=[7.,6.,5.,4.,2.,1.]
9897         self.assertEqual(6,ard2.getNumberOfTuples());
9898         self.assertEqual(1,ard2.getNumberOfComponents());
9899         for i in xrange(6):
9900             self.assertAlmostEqual(expected4[i],ard2.getIJ(i,0),12)
9901             pass
9902         pass
9903
9904     def testPartitionBySpreadZone1(self):
9905         m=MEDCouplingDataForTest.build2DTargetMesh_1();
9906         m4=MEDCouplingUMesh.MergeUMeshes([m,m[-3:],m[0:2]]);
9907         m4.renumberCells([5,2,9,6,4,7,0,1,3,8]);
9908         #
9909         v2=m4.partitionBySpreadZone();
9910         self.assertTrue(3,len(v2));
9911         self.assertTrue(v2[0].isEqual(DataArrayInt.New([0,1,7])))
9912         self.assertTrue(v2[1].isEqual(DataArrayInt.New([2,4,5,6,9])))
9913         self.assertTrue(v2[2].isEqual(DataArrayInt.New([3,8])))
9914         #
9915         m5=m4.buildSpreadZonesWithPoly();
9916         self.assertEqual(3,m5.getNumberOfCells());
9917         self.assertTrue(m5.getCoords().getHiddenCppPointer()==m4.getCoords().getHiddenCppPointer());
9918         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())
9919         self.assertEqual([0,8,17,23],m5.getNodalConnectivityIndex().getValues())
9920         #
9921         pass
9922
9923     def testGiveCellsWithType1(self):
9924         expected0=[1,2]
9925         expected1=[0,3,4]
9926         m=MEDCouplingDataForTest.build2DTargetMesh_1();
9927         da=m.giveCellsWithType(NORM_TRI3);
9928         self.assertEqual(2,da.getNumberOfTuples());
9929         self.assertEqual(1,da.getNumberOfComponents());
9930         self.assertEqual(expected0,da.getValues())
9931         #
9932         da=m.giveCellsWithType(NORM_QUAD4);
9933         self.assertEqual(3,da.getNumberOfTuples());
9934         self.assertEqual(1,da.getNumberOfComponents());
9935         self.assertEqual(expected1,da.getValues())
9936         #
9937         da=m.giveCellsWithType(NORM_TRI6);
9938         self.assertEqual(0,da.getNumberOfTuples());
9939         self.assertEqual(1,da.getNumberOfComponents());
9940         #
9941         self.assertRaises(InterpKernelException,m.giveCellsWithType,NORM_SEG2)
9942         self.assertRaises(InterpKernelException,m.giveCellsWithType,NORM_HEXA8)
9943         pass
9944
9945     def testSwigDAOp1(self):
9946         d=DataArrayDouble.New(5,2)
9947         d.rearrange(1) ; d.iota(2.) ; d.rearrange(2)
9948         d.setInfoOnComponents(["X [m]","Y [m]"])
9949         d.setName("AName")
9950         #
9951         d1=d+[8,9]
9952         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))
9953         d1bis=DataArrayDouble.New([8,9],1,2)+d
9954         self.assertTrue(d1bis.isEqual(d1,1e-12))
9955         d1ter=[8,9]+d
9956         self.assertTrue(d1ter.isEqual(d1,1e-12))
9957         #
9958         d2=d1-[8,9]
9959         self.assertTrue(d2.isEqual(d,1e-12))
9960         self.assertRaises(InterpKernelException,d1.__rsub__,[8,9])#[8,9]-d1
9961         #
9962         d3=d*[8,9]
9963         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))
9964         d3bis=DataArrayDouble.New([8,9],1,2)*d
9965         self.assertTrue(d3bis.isEqual(d3,1e-12))
9966         d3ter=[8,9]*d
9967         self.assertTrue(d3ter.isEqual(d3,1e-12))
9968         #
9969         d4=d3/[8,9]
9970         self.assertTrue(d4.isEqual(d,1e-12))
9971         #
9972         d=DataArrayInt.New(5,2)
9973         d.rearrange(1) ; d.iota(2) ; d.rearrange(2)
9974         d.setInfoOnComponents(["X [m]","Y [m]"])
9975         d.setName("AName")
9976         #
9977         d1=d+[8,9]
9978         self.assertEqual(d1.getValues(),[10,12,12,14,14,16,16,18,18,20])
9979         d1bis=DataArrayInt.New([8,9],1,2)+d
9980         self.assertTrue(d1bis.isEqual(d1))
9981         d1ter=[8,9]+d
9982         self.assertTrue(d1ter.isEqual(d1))
9983         #
9984         d2=d1-[8,9]
9985         self.assertTrue(d2.isEqual(d))
9986         self.assertRaises(InterpKernelException,d1.__rsub__,[8,9])
9987         #
9988         d3=d*[8,9]
9989         self.assertEqual(d3.getValues(),[16,27,32,45,48,63,64,81,80,99])
9990         d3bis=DataArrayInt.New([8,9],1,2)*d
9991         self.assertTrue(d3bis.isEqual(d3))
9992         d3ter=[8,9]*d
9993         self.assertTrue(d3ter.isEqual(d3))
9994         #
9995         d4=d3/[8,9]
9996         self.assertTrue(d4.isEqual(d))
9997         #
9998         d5=d%[4,5]
9999         self.assertEqual(d5.getValues(),[2,3,0,0,2,2,0,4,2,1])
10000         pass
10001
10002     def testSwigSelectTupleId2DAIBug1(self):
10003         da=DataArrayInt.New([0,1,2,3,12,13,4,5,6,7,14,15,8,9,10,11,16,17])
10004         self.assertEqual([2,6,10],da[2::6].getValues())
10005         self.assertEqual([0,4,8],da[::6].getValues())
10006         self.assertEqual([5,9],da[7::6].getValues())
10007         self.assertEqual([5],da[7:-5:6].getValues())
10008         pass
10009
10010     def testSwigCpp5Safe1(self):
10011         m=MEDCouplingUMesh.New("toto",2)
10012         coords=DataArrayDouble.New([0.,0.,1.,0.,1.,1.,0.,1.],4,2)
10013         m.setCoords(coords)
10014         vecs=DataArrayDouble.New([2.,3.,4.,5.,6.,7.],3,2)
10015         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]]
10016         for pos,vec in enumerate(vecs):
10017             m2=m.deepCpy()
10018             m2.translate(vec)
10019             self.assertTrue(m2.getCoords().isEqual(DataArrayDouble.New(expected1[pos],4,2),1e-12))
10020             pass
10021         for pos,vec in enumerate(vecs):
10022             m2=m.deepCpy()
10023             m2.translate(vec.buildDADouble())
10024             self.assertTrue(m2.getCoords().isEqual(DataArrayDouble.New(expected1[pos],4,2),1e-12))
10025             pass
10026         pass
10027
10028     def testSwigBugNonRegressionZipDA(self):
10029         angles=map(lambda x:pi/3*x,xrange(6))
10030         radius=3
10031         #
10032         dad=DataArrayDouble.New(6, 2)
10033         dad[:,0]=radius
10034         dad[:,1]=angles
10035         #
10036         dad2=dad.fromPolarToCart()
10037         dads=[dad2.deepCpy() for elt in 7*[None]]
10038         #
10039         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.)]]
10040         for d,t in zip(dads,translationToPerform):
10041             d+=t
10042             pass
10043         for elt in dads:
10044             self.assertTrue(not dad2.isEqual(elt,1e-12))
10045             pass
10046         for d,t in zip(dads,translationToPerform):
10047             d-=t
10048             pass
10049         for elt in dads:
10050             self.assertTrue(dad2.isEqual(elt,1e-12))
10051             pass
10052         pass
10053
10054     def testBuildSlice3D2(self):
10055         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
10056         vec1=[-0.07,1.,0.07]
10057         origin1=[1.524,1.4552,1.74768]
10058         slice1,ids=mesh3D.buildSlice3D(origin1,vec1,1e-10);
10059         f=MEDCouplingFieldDouble(ON_CELLS,ONE_TIME)
10060         f.setTime(4.5,6,7) ; f.setMesh(mesh3D)
10061         arr=DataArrayDouble(mesh3D.getNumberOfCells(),2)
10062         arr.rearrange(1) ; arr.iota(2.) ; arr.rearrange(2)
10063         f.setArray(arr)
10064         f.checkCoherency()
10065         expected1=DataArrayInt([1,3,4,7,9,10,13,15,16])
10066         self.assertTrue(expected1.isEqual(ids))
10067         arr2=arr[expected1]
10068         #
10069         f2=f.extractSlice3D(origin1,vec1,1e-10)
10070         self.assertTrue(f2.getArray().isEqual(arr2,1e-12));
10071         self.assertTrue(slice1.isEqual(f2.getMesh(),1e-12))
10072         self.assertEqual(6,f2.getTime()[1]) ; self.assertEqual(7,f2.getTime()[2])
10073         self.assertAlmostEqual(4.5,f2.getTime()[0],12);
10074         pass
10075
10076     def testComputeTupleIdsToSelectFromCellIds1(self):
10077         m=MEDCouplingDataForTest.build2DTargetMesh_3()
10078         f=MEDCouplingFieldDouble.New(ON_GAUSS_NE,NO_TIME);
10079         f.setMesh(m);
10080         arr=DataArrayDouble(52,2) ; arr.rearrange(1) ; arr.iota(7.) ; arr.rearrange(2)
10081         f.setArray(arr)
10082         #
10083         f2=f.buildSubPart([1,5,9])
10084         f2.checkCoherency()
10085         cI=m.computeNbOfNodesPerCell()
10086         cI.computeOffsets2()
10087         sel=DataArrayInt([1,5,9])
10088         res=sel.buildExplicitArrByRanges(cI)
10089         arr2=arr[res]
10090         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))
10091         self.assertTrue(arr2.isEqual(f2.getArray(),1e-12))
10092         pass
10093
10094     def testComputeSkin1(self):
10095         arrX=DataArrayDouble([2.,3.4,5.6,7.7,8.0]) ; arrY=DataArrayDouble([2.,3.4,5.6,7.7,9.0,14.2])
10096         cmesh=MEDCouplingCMesh() ; cmesh.setCoordsAt(0,arrX) ; cmesh.setCoordsAt(1,arrY)
10097         umesh=cmesh.buildUnstructured()
10098         #
10099         skin=umesh.computeSkin()
10100         self.assertEqual(18,skin.getNumberOfCells())
10101         self.assertEqual(1,skin.getMeshDimension())
10102         self.assertTrue(skin.getCoords().getHiddenCppPointer()==umesh.getCoords().getHiddenCppPointer())
10103         self.assertEqual([0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48,51,54],skin.getNodalConnectivityIndex().getValues())
10104         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())
10105         ids=skin.computeFetchedNodeIds()
10106         self.assertEqual([0,1,2,3,4,5,9,10,14,15,19,20,24,25,26,27,28,29],ids.getValues())
10107         part=umesh.buildFacePartOfMySelfNode(ids,True)
10108         part.setName(skin.getName());
10109         self.assertTrue(part.isEqual(skin,1e-12))
10110         part2=part[1::2]
10111         part[::2]=part2
10112         self.assertTrue(not part.isEqual(skin,1e-12))
10113         trad=part.zipConnectivityTraducer(0)
10114         self.assertEqual(9,part.getNumberOfCells())
10115         self.assertEqual([0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8],trad.getValues())
10116         pass
10117
10118     def testUMeshSetPartOfMySelf2(self):
10119         # resize with explicit ids list
10120         m=MEDCouplingDataForTest.build2DTargetMesh_1()
10121         self.assertEqual([3,4],m.getAllTypes())
10122         part=m[[0,3,4]]
10123         part.simplexize(0)
10124         part2=part[[1,2,5]]
10125         m[[0,3,4]]=part2
10126         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())
10127         self.assertEqual([0,4,8,12,16,20],m.getNodalConnectivityIndex().getValues())
10128         self.assertEqual([3],m.getAllTypes())
10129         # no resize with explicit ids list
10130         m=MEDCouplingDataForTest.build2DTargetMesh_1()
10131         part=m[[0,3]]
10132         part.convertAllToPoly()
10133         m[[3,4]]=part
10134         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())
10135         self.assertEqual([0,5,9,13,18,23],m.getNodalConnectivityIndex().getValues())
10136         self.assertEqual([3,4,5],m.getAllTypes())
10137         # resize with range ids
10138         m=MEDCouplingDataForTest.build2DTargetMesh_1()
10139         part=m[3:]
10140         m[1:3]=part
10141         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())
10142         self.assertEqual([0,5,10,15,20,25],m.getNodalConnectivityIndex().getValues())
10143         self.assertEqual([4],m.getAllTypes())
10144         # no resize with range ids
10145         m=MEDCouplingDataForTest.build2DTargetMesh_1()
10146         part=m[0::3]
10147         part.convertAllToPoly()
10148         m[3:]=part
10149         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())
10150         self.assertEqual([0,5,9,13,18,23],m.getNodalConnectivityIndex().getValues())
10151         self.assertEqual([3,4,5],m.getAllTypes())
10152         # no resize with range ids negative direction
10153         m=MEDCouplingDataForTest.build2DTargetMesh_1()
10154         part=m[3::-3]
10155         part.convertAllToPoly()
10156         m[:-3:-1]=part
10157         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())
10158         self.assertEqual([0,5,9,13,18,23],m.getNodalConnectivityIndex().getValues())
10159         self.assertEqual([3,4,5],m.getAllTypes())
10160         pass
10161
10162     def testUnPolyze3(self):
10163         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]
10164         conn=[1,2,5,4,-1,4,3,0,1,-1,2,0,3,5,-1,0,2,1,-1,4,5,3]
10165         m=MEDCouplingUMesh.New("a mesh",3);
10166         m.allocateCells(1);
10167         m.insertNextCell(NORM_POLYHED,22,conn[0:22])
10168         m.finishInsertingCells();
10169         coords=DataArrayDouble(coord,6,3);
10170         m.setCoords(coords);
10171         m.checkCoherency();
10172         #
10173         vol=m.getMeasureField(ON_CELLS);
10174         self.assertEqual(1,vol.getArray().getNumberOfTuples());
10175         self.assertAlmostEqual(0.5,vol.getArray().getIJ(0,0),12)
10176         #
10177         m.unPolyze();
10178         #
10179         self.assertEqual([NORM_PENTA6],m.getAllTypes())
10180         self.assertTrue(DataArrayInt([0,7]).isEqual(m.getNodalConnectivityIndex()))
10181         self.assertTrue(DataArrayInt([16,0,2,1,3,5,4]).isEqual(m.getNodalConnectivity()))
10182         #
10183         vol=m.getMeasureField(ON_CELLS);
10184         self.assertEqual(1,vol.getArray().getNumberOfTuples());
10185         self.assertAlmostEqual(0.5,vol.getArray().getIJ(0,0),12)
10186         pass
10187
10188     def testKrSpatialDiscretization1(self):
10189         srcPointCoordsX=[0.8401877171547095, 0.7830992237586059, 0.9116473579367843, 0.335222755714889, 0.2777747108031878, 0.4773970518621602, 0.3647844727918433, 0.9522297251747128, 0.6357117279599009, 0.1416025553558034]
10190         srcFieldValsOnPoints=[2.129892434968836, 2.295320474540621, 1.931948594981134, 2.728013590937196, 2.715603240418478, 2.661778472822935, 2.695696990104364, 1.893710234970982, 2.529628016549284, 2.728432341300668]
10191         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]
10192         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]
10193         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])
10194         #
10195         nbOfInputPoints=10;
10196         f=MEDCouplingFieldDouble.New(ON_NODES_KR,ONE_TIME);
10197         srcArrX=DataArrayDouble.New(srcPointCoordsX,nbOfInputPoints,1);
10198         cmesh=MEDCouplingCMesh.New("aMesh");
10199         cmesh.setCoordsAt(0,srcArrX);
10200         umesh=cmesh.buildUnstructured();
10201         f.setMesh(umesh);
10202         srcVals=DataArrayDouble.New(srcFieldValsOnPoints,nbOfInputPoints,1);
10203         f.setArray(srcVals);
10204         f.checkCoherency();
10205         #
10206         res0=f.getValueOn(targetPointCoordsX[:1]);
10207         self.assertAlmostEqual(targetFieldValsExpected[0],res0[0],10)
10208         #
10209         valuesToTest=f.getValueOnMulti(targetPointCoordsX);
10210         self.assertEqual(40,valuesToTest.getNumberOfTuples());
10211         self.assertEqual(1,valuesToTest.getNumberOfComponents());
10212         for i in xrange(40):
10213             self.assertAlmostEqual(targetFieldValsExpected[i],valuesToTest.getIJ(i,0),10)
10214             pass
10215         fd=f.getDiscretization()
10216         del f
10217         self.assertTrue(isinstance(fd,MEDCouplingFieldDiscretizationKriging))
10218         coeffs,isDrift=fd.computeVectorOfCoefficients(umesh,srcVals)
10219         self.assertEqual(2,isDrift)
10220         self.assertTrue(coeffsExpected.isEqual(coeffs,1e-8))
10221         #
10222         pass
10223
10224     def testDuplicateEachTupleNTimes1(self):
10225         d=DataArrayDouble.New([9.,8.,7.,6.],4,1) ; d.setInfoOnComponents(["mass [kg]"]) ; d.setName("aname")
10226         d2=d.duplicateEachTupleNTimes(3)
10227         self.assertTrue(d2.isEqualWithoutConsideringStr(DataArrayDouble.New([9.,9.,9.,8.,8.,8.,7.,7.,7.,6.,6.,6.],4*3,1),1e-14))
10228         self.assertEqual("aname",d2.getName())
10229         self.assertEqual(["mass [kg]"],d2.getInfoOnComponents())
10230         #
10231         d=DataArrayInt.New([9,8,7,6],4,1) ; d.setInfoOnComponents(["mass [kg]"]) ; d.setName("aname")
10232         d2=d.duplicateEachTupleNTimes(3)
10233         self.assertTrue(d2.isEqualWithoutConsideringStr(DataArrayInt.New([9,9,9,8,8,8,7,7,7,6,6,6],4*3,1)))
10234         self.assertEqual("aname",d2.getName())
10235         self.assertEqual(["mass [kg]"],d2.getInfoOnComponents())
10236         pass
10237
10238     def testSwigComputeTupleIdsNearTuples1(self):
10239         da=DataArrayDouble([5.,6.,-5.,-6.,5.,-6.,-5.,6.,5.,6.],5,2)
10240         arr,arrI=da.computeTupleIdsNearTuples(DataArrayDouble([5.,-6.,5.,6.,-5.,-6.],3,2),1e-10)
10241         self.assertEqual([2,0,4,1],arr.getValues())
10242         self.assertEqual([0,1,3,4],arrI.getValues())
10243         arr,arrI=da.computeTupleIdsNearTuples([5.,-6.,5.,6.,-5.,-6.],1e-10)
10244         self.assertEqual([2,0,4,1],arr.getValues())
10245         self.assertEqual([0,1,3,4],arrI.getValues())
10246         expected0=[[2],[0,4],[1]]
10247         expected1=[[0,1],[0,2],[0,1]]
10248         for pos,it in enumerate(DataArrayDouble([5.,-6.,5.,6.,-5.,-6.],3,2)):
10249             arr,arrI=da.computeTupleIdsNearTuples(it,1e-10)
10250             self.assertEqual(expected0[pos],arr.getValues())
10251             self.assertEqual(expected1[pos],arrI.getValues())
10252             pass
10253         pass
10254
10255     def testSwigDataTupleIOp1(self):
10256         d=DataArrayDouble(10,1)
10257         d.iota(7.)
10258         for elt in d:
10259             elt+=2.
10260             pass
10261         toTest=DataArrayDouble([9.0,10.0,11.0,12.0,13.0,14.0,15.0,16.0,17.0,18.0])
10262         self.assertTrue(toTest.isEqual(d,1e-12))
10263         for elt in d:
10264             elt-=2.
10265             pass
10266         toTest=DataArrayDouble([7.0,8.0,9.0,10.0,11.0,12.0,13.0,14.0,15.0,16.0])
10267         self.assertTrue(toTest.isEqual(d,1e-12))
10268         for elt in d:
10269             elt*=2.
10270             pass
10271         toTest=DataArrayDouble([14.0,16.0,18.0,20.0,22.0,24.0,26.0,28.0,30.0,32.0])
10272         self.assertTrue(toTest.isEqual(d,1e-12))
10273         for elt in d:
10274             elt/=2.
10275             pass
10276         toTest=DataArrayDouble([7.0,8.0,9.0,10.0,11.0,12.0,13.0,14.0,15.0,16.0])
10277         self.assertTrue(toTest.isEqual(d,1e-12))
10278         #
10279         d=DataArrayInt(10,1)
10280         d.iota(7)
10281         for elt in d:
10282             elt+=2
10283             pass
10284         self.assertEqual(d.getValues(),[9,10,11,12,13,14,15,16,17,18])
10285         for elt in d:
10286             elt-=2
10287             pass
10288         self.assertEqual(d.getValues(),[7,8,9,10,11,12,13,14,15,16])
10289         for elt in d:
10290             elt*=2
10291             pass
10292         self.assertEqual(d.getValues(),[14,16,18,20,22,24,26,28,30,32])
10293         for elt in d:
10294             elt/=2
10295             pass
10296         self.assertEqual(d.getValues(),[7,8,9,10,11,12,13,14,15,16])
10297         for elt in d:
10298             elt%=3
10299             pass
10300         self.assertEqual(d.getValues(),[1,2,0,1,2,0,1,2,0,1])
10301         pass
10302
10303     def testIntersect2DMeshesTmp5(self):
10304         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)
10305         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)
10306         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)
10307         #
10308         m1=MEDCouplingUMesh.New("Fix",2);
10309         m1.setCoords(coords);
10310         m1.setConnectivity(conn,connI,True);
10311         #
10312         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)
10313         # connectivity
10314         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);
10315         conn.setName("");
10316         connI=DataArrayInt([0,9,18,27,36,45,54,63,72],9)
10317         m2=MEDCouplingUMesh.New("Mobile",2);
10318         m2.setCoords(coords);
10319         m2.setConnectivity(conn,connI,True);
10320         #
10321         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m1,m2,1e-10);
10322         self.assertEqual(105,m3.getNumberOfCells());
10323         self.assertEqual(105,d1.getNumberOfTuples());
10324         self.assertEqual(105,d2.getNumberOfTuples());
10325         self.assertEqual(704,m3.getNumberOfNodes());
10326         #
10327         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]
10328         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]
10329         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]
10330         f3=m3.getMeasureField(ON_CELLS).getArray().getValues();
10331         for i in xrange(105):
10332             self.assertAlmostEqual(areaExpected[i],f3[i],10)
10333             pass
10334         self.assertEqual(expected1,d1.getValues())
10335         self.assertEqual(expected2,d2.getValues())
10336         pass
10337
10338     def testDAIBuildUnique1(self):
10339         d=DataArrayInt([1,2,2,3,3,3,3,4,5,5,7,7,7,19])
10340         e=d.buildUnique()
10341         self.assertTrue(e.isEqual(DataArrayInt([1,2,3,4,5,7,19])))
10342         pass
10343
10344     def testDAIPartitionByDifferentValues1(self):
10345         d=DataArrayInt([1,0,1,2,0,2,2,-3,2])
10346         expected=[[-3,[7]],[0,[1,4]],[1,[0,2]],[2,[3,5,6,8]]]
10347         for i,elt in enumerate(zip(*d.partitionByDifferentValues())):
10348             self.assertEqual(expected[i][0],elt[1])
10349             self.assertEqual(expected[i][1],elt[0].getValues())
10350             pass
10351         pass
10352
10353     def testFieldGaussMultiDiscPerType1(self):
10354         coords=DataArrayDouble([0.,0.,0.,1.,1.,1.,1.,0.,0.,0.5,0.5,1.,1.,0.5,0.5,0.],8,2)
10355         mQ8=MEDCouplingUMesh("",2) ; mQ8.setCoords(coords)
10356         mQ8.allocateCells(1)
10357         mQ8.insertNextCell(NORM_QUAD8,range(8))
10358         mQ8.finishInsertingCells()
10359         mQ4=MEDCouplingUMesh("",2) ; mQ4.setCoords(coords)
10360         mQ4.allocateCells(1)
10361         mQ4.insertNextCell(NORM_QUAD4,range(4))
10362         mQ4.finishInsertingCells()
10363         mT3=MEDCouplingUMesh("",2) ; mT3.setCoords(coords)
10364         mT3.allocateCells(1)
10365         mT3.insertNextCell(NORM_TRI3,range(3))
10366         mT3.finishInsertingCells()
10367
10368         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.]]
10369         ms=2*[mQ4]+7*[mQ8]+11*[mT3]
10370         ms[:]=(elt.deepCpy() for elt in ms)
10371         for m,t in zip(ms,tr):
10372             d=m.getCoords() ; d+= t
10373             pass
10374         m=MEDCouplingUMesh.MergeUMeshes(ms)
10375         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,NO_TIME)
10376         f.setMesh(m)
10377         # throw because cell 0,1 are QUAD4 and cell 3 is QUAD8
10378         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])
10379         f.setGaussLocalizationOnCells([0,1],[0.,0.,1.,0.,1.,1.,0.,1.],[0.3,0.3,0.7,0.7],[0.8,0.2])
10380         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])
10381         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])
10382         f.setGaussLocalizationOnCells([9,10,11,12,13],[0.,0.,1.,0.,1.,1.],[0.4,0.4],[1.])
10383         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])
10384         self.assertEqual(46,f.getNumberOfTuplesExpected())
10385         vals=DataArrayDouble.New(46*3,1) ; vals.iota(7.7) ; vals.rearrange(3)
10386         f.setArray(vals)
10387         f.checkCoherency()
10388         #f.getLocalizationOfDiscr()
10389         self.assertRaises(InterpKernelException,f.getGaussLocalizationIdOfOneType,NORM_QUAD8) #throw because several loc
10390         self.assertEqual([1,2],f.getGaussLocalizationIdsOfOneType(NORM_QUAD8))
10391         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())
10392         fc=f[[1,2,3,8]]
10393         fc.checkCoherency()
10394         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))
10395         fc.renumberCells([3,2,0,1])
10396         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))
10397         fc.getArray()
10398         pass
10399
10400     def testSwigRotate(self):
10401         d=DataArrayDouble([1.,2.,3.,4.,6.,5.],2,3)
10402         MEDCouplingPointSet.Rotate3DAlg([0.,0.,0.],[0.,1.,0.],1.5707963267948966,d)
10403         self.assertTrue(d.isEqual(DataArrayDouble([3.,2.,-1.,5.,6.,-4.],2,3),1e-12))
10404         d=DataArrayDouble([1.,2.,3.,4.,6.,5.],3,2)
10405         MEDCouplingPointSet.Rotate2DAlg([0.,0.],1.5707963267948966,d)
10406         self.assertTrue(d.isEqual(DataArrayDouble([-2.,1.,-4.,3.,-5.,6.],3,2),1e-12))
10407         pass
10408
10409     def testSwigCMeshProtection(self):
10410         cm=MEDCouplingCMesh()
10411         self.assertRaises(InterpKernelException,cm.setCoordsAt,0,DataArrayDouble([4.,4.5,6.,7.],2,2))
10412         self.assertRaises(InterpKernelException,cm.setCoords,DataArrayDouble([4.,4.5,6.,7.],2,2))
10413         pass
10414
10415     def testSwigCellsInBoundingBox1(self):
10416         m3D=MEDCouplingDataForTest.build3DExtrudedUMesh_1()[0]
10417         self.assertTrue(m3D.getCellsInBoundingBox([(0,3),(0,3),(0,1)],-1e-12).isEqual(DataArrayInt([0,1,2,3,4,5])))
10418         self.assertRaises(InterpKernelException,m3D.getCellsInBoundingBox,[(0,3,0),(3,0,1)],-1e-12)
10419         pass
10420
10421     def testDAICheckMonotonic1(self):
10422         data1=[-1,0,2,2,4,5]
10423         data2=[6,2,0,-8,-9,-56]
10424         data3=[-1,0,3,2,4,6]
10425         data4=[7,5,2,3,0,-6]
10426         d=DataArrayInt.New(data1);
10427         self.assertTrue(d.isMonotonic(True));
10428         self.assertTrue(not d.isMonotonic(False));
10429         d.checkMonotonic(True);
10430         self.assertRaises(InterpKernelException,d.checkMonotonic,False)
10431         d=DataArrayInt.New(data2);
10432         self.assertTrue(d.isMonotonic(False));
10433         self.assertTrue(not d.isMonotonic(True));
10434         d.checkMonotonic(False);
10435         self.assertRaises(InterpKernelException,d.checkMonotonic,True)
10436         d=DataArrayInt.New(data3);
10437         self.assertTrue(not d.isMonotonic(False));
10438         self.assertTrue(not d.isMonotonic(True));
10439         self.assertRaises(InterpKernelException,d.checkMonotonic,True)
10440         self.assertRaises(InterpKernelException,d.checkMonotonic,False)
10441         d=DataArrayInt.New(data4);
10442         self.assertTrue(not d.isMonotonic(False));
10443         self.assertTrue(not d.isMonotonic(True));
10444         self.assertRaises(InterpKernelException,d.checkMonotonic,True)
10445         self.assertRaises(InterpKernelException,d.checkMonotonic,False)
10446         d=DataArrayInt.New(0,1)
10447         self.assertTrue(d.isMonotonic(True));
10448         self.assertTrue(d.isMonotonic(False));
10449         d.checkMonotonic(True);
10450         d.checkMonotonic(False);
10451         d=DataArrayInt.New(data4,3,2);#throw because nbComp!=1
10452         self.assertRaises(InterpKernelException,d.isMonotonic,True)
10453         self.assertRaises(InterpKernelException,d.isMonotonic,False)
10454         self.assertRaises(InterpKernelException,d.checkMonotonic,True)
10455         self.assertRaises(InterpKernelException,d.checkMonotonic,False)
10456         pass
10457
10458     def testSwigDASetItemOnEmpty1(self):
10459         d=DataArrayInt(0,1)
10460         isThrow=False
10461         try:
10462             d[0:1000:2]=4
10463         except InterpKernelException as e:
10464             isThrow=True
10465             pass
10466         self.assertTrue(isThrow)
10467         d[:]=4
10468         d[::2]=5
10469         #
10470         d=DataArrayDouble(0,1)
10471         isThrow=False
10472         try:
10473             d[0:1000:2]=4
10474         except InterpKernelException as e:
10475             isThrow=True
10476             pass
10477         self.assertTrue(isThrow)
10478         d[:]=4
10479         d[::2]=5
10480         d=DataArrayInt([],0,1)
10481         d2=DataArrayInt(0)
10482         self.assertTrue(d2.isEqual(d))
10483         d=DataArrayDouble([],0,1)
10484         d2=DataArrayDouble(0)
10485         self.assertTrue(d2.isEqual(d,1e-12))
10486         pass
10487
10488     def testSwigDAITransformWithIndArr1(self):
10489         arr=DataArrayInt([0,4,5,1])
10490         d=DataArrayInt([7,8,9,10])
10491         self.assertRaises(InterpKernelException,arr.transformWithIndArr,d)
10492         pass
10493
10494     def testIntersect2DMeshesTmp6(self):
10495         # coordinates
10496         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);
10497         # connectivity
10498         conn=DataArrayInt.New([8,0,3,5,1,4,6,7,2])
10499         connI=DataArrayInt.New([0,9]);
10500         m1=MEDCouplingUMesh.New("Fixe",2);
10501         m1.setCoords(coords);
10502         m1.setConnectivity(conn,connI,True);
10503         #
10504         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);
10505         # connectivity
10506         conn=DataArrayInt.New([8,0,1,2,3,4,5,6,7,8,3,2,8,9,6,10,11,12]);
10507         connI=DataArrayInt.New([0,9,18]);
10508         #
10509         m2=MEDCouplingUMesh.New("Mobile",2);
10510         m2.setCoords(coords);
10511         m2.setConnectivity(conn,connI,True);
10512         #
10513         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m1,m2,1e-10);
10514         self.assertTrue(d1.isEqual(DataArrayInt([0,0,0,0])));
10515         self.assertTrue(d2.isEqual(DataArrayInt([0,1,-1,-1])));
10516         self.assertEqual(4,m3.getNumberOfCells());
10517         self.assertEqual(4,d1.getNumberOfTuples());
10518         self.assertEqual(4,d2.getNumberOfTuples());
10519         self.assertEqual(43,m3.getNumberOfNodes());
10520         dI,areMerged,newNbOfNodes=m3.mergeNodes(1e-12)
10521         self.assertEqual(35,m3.getNumberOfNodes());
10522         m3.zipCoords();
10523         self.assertEqual(23,m3.getNumberOfNodes());
10524         #
10525         f=m3.getMeasureField(True);
10526         valuesExpected=DataArrayDouble([1.6603638692585716,5.747555728471923,129.68907101754394,7.4162714498559694])
10527         self.assertTrue(f.getArray().isEqual(valuesExpected,1e-12))
10528         pass
10529
10530     def testDAPushBack(self):
10531         d=DataArrayDouble(0,1)
10532         for i in xrange(8):
10533             d.pushBackSilent(i)
10534             pass
10535         self.assertEqual(d.getNumberOfTuples(),8)
10536         self.assertEqual(d.getNbOfElemAllocated(),8)
10537         d.pushBackSilent(4.44)
10538         self.assertEqual(d.getNumberOfTuples(),9)
10539         self.assertEqual(d.getNbOfElemAllocated(),16)
10540         self.assertTrue(d.isEqual(DataArrayDouble([0.,1.,2.,3.,4.,5.,6.,7.,4.44]),1e-12))
10541         e=d.deepCpy()
10542         self.assertEqual(e.getNumberOfTuples(),9)
10543         self.assertEqual(e.getNbOfElemAllocated(),9)
10544         self.assertTrue(e.isEqual(DataArrayDouble([0.,1.,2.,3.,4.,5.,6.,7.,4.44]),1e-12))
10545         self.assertAlmostEqual(d.popBackSilent(),4.44,12)
10546         self.assertEqual(d.getNumberOfTuples(),8)
10547         self.assertEqual(d.getNbOfElemAllocated(),16)
10548         self.assertTrue(d.isEqual(DataArrayDouble([0.,1.,2.,3.,4.,5.,6.,7.]),1e-12))
10549         f=DataArrayDouble()
10550         f.reserve(1000)
10551         f.pushBackSilent(4.)
10552         self.assertTrue(f.isEqual(DataArrayDouble([4.]),1e-12))
10553         self.assertEqual(f.getNumberOfTuples(),1)
10554         self.assertEqual(f.getNbOfElemAllocated(),1000)
10555         ff=f[:]
10556         self.assertTrue(ff.isEqual(DataArrayDouble([4.]),1e-12))
10557         self.assertEqual(ff.getNumberOfTuples(),1)
10558         self.assertEqual(ff.getNbOfElemAllocated(),1)
10559         d=DataArrayDouble()
10560         d.pushBackSilent(4.44)
10561         d.pushBackSilent(5.55)
10562         d.pushBackSilent(6.66)
10563         self.assertTrue(d.isEqual(DataArrayDouble([4.44,5.55,6.66]),1e-12))
10564         #
10565         d=DataArrayInt(0,1)
10566         for i in xrange(8):
10567             d.pushBackSilent(i)
10568             pass
10569         self.assertEqual(d.getNumberOfTuples(),8)
10570         self.assertEqual(d.getNbOfElemAllocated(),8)
10571         d.pushBackSilent(444)
10572         self.assertEqual(d.getNumberOfTuples(),9)
10573         self.assertEqual(d.getNbOfElemAllocated(),16)
10574         self.assertTrue(d.isEqual(DataArrayInt([0,1,2,3,4,5,6,7,444])))
10575         e=d.deepCpy()
10576         self.assertEqual(e.getNumberOfTuples(),9)
10577         self.assertEqual(e.getNbOfElemAllocated(),9)
10578         self.assertTrue(e.isEqual(DataArrayInt([0,1,2,3,4,5,6,7,444])))
10579         self.assertEqual(d.popBackSilent(),444)
10580         self.assertEqual(d.getNumberOfTuples(),8)
10581         self.assertEqual(d.getNbOfElemAllocated(),16)
10582         self.assertTrue(d.isEqual(DataArrayInt([0,1,2,3,4,5,6,7])))
10583         f=DataArrayInt()
10584         f.reserve(1000)
10585         f.pushBackSilent(4)
10586         self.assertTrue(f.isEqual(DataArrayInt([4])))
10587         self.assertEqual(f.getNumberOfTuples(),1)
10588         self.assertEqual(f.getNbOfElemAllocated(),1000)
10589         ff=f[:]
10590         self.assertTrue(ff.isEqual(DataArrayInt([4])))
10591         self.assertEqual(ff.getNumberOfTuples(),1)
10592         self.assertEqual(ff.getNbOfElemAllocated(),1)
10593         d=DataArrayInt()
10594         d.pushBackSilent(444)
10595         d.pushBackSilent(555)
10596         d.pushBackSilent(666)
10597         self.assertTrue(d.isEqual(DataArrayInt([444,555,666])))
10598         #
10599         d=DataArrayInt()
10600         d.alloc(10,1)
10601         d.setInfoOnComponent(0,"ABC")
10602         d.setName("dEf")
10603         d.iota(7)
10604         e=DataArrayInt([7,8,9,10,11,12,13,14,15,16]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
10605         self.assertEqual(10,d.getNbOfElemAllocated())
10606         d.pushBackSilent(55)
10607         e=DataArrayInt([7,8,9,10,11,12,13,14,15,16,55]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
10608         self.assertEqual(20,d.getNbOfElemAllocated())
10609         d.reserve(4)
10610         e=DataArrayInt([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
10611         self.assertEqual(4,d.getNbOfElemAllocated())
10612         d.pushBackSilent(5)
10613         e=DataArrayInt([7,8,9,10,5]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
10614         self.assertEqual(8,d.getNbOfElemAllocated())
10615         self.assertEqual(5,d.popBackSilent())
10616         e=DataArrayInt([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
10617         self.assertEqual(8,d.getNbOfElemAllocated())
10618         self.assertRaises(InterpKernelException,d.reserve,-1)
10619         e=DataArrayInt([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
10620         self.assertEqual(8,d.getNbOfElemAllocated())
10621         d.reserve(0)
10622         e=DataArrayInt([]) ; e.setInfoOnComponent(0,"ABC") ; e.setName("dEf") ; self.assertTrue(d.isEqual(e))
10623         self.assertEqual(0,d.getNbOfElemAllocated())
10624         #
10625         d=DataArrayDouble()
10626         d.alloc(10,1)
10627         d.setInfoOnComponent(0,"ABC")
10628         d.setName("dEf")
10629         d.iota(7)
10630         e=DataArrayDouble([7,8,9,10,11,12,13,14,15,16]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
10631         self.assertEqual(10,d.getNbOfElemAllocated())
10632         d.pushBackSilent(55)
10633         e=DataArrayDouble([7,8,9,10,11,12,13,14,15,16,55]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
10634         self.assertEqual(20,d.getNbOfElemAllocated())
10635         d.reserve(4)
10636         e=DataArrayDouble([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
10637         self.assertEqual(4,d.getNbOfElemAllocated())
10638         d.pushBackSilent(5)
10639         e=DataArrayDouble([7,8,9,10,5]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
10640         self.assertEqual(8,d.getNbOfElemAllocated())
10641         self.assertEqual(5.,d.popBackSilent())
10642         e=DataArrayDouble([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
10643         self.assertEqual(8,d.getNbOfElemAllocated())
10644         self.assertRaises(InterpKernelException,d.reserve,-1)
10645         e=DataArrayDouble([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
10646         self.assertEqual(8,d.getNbOfElemAllocated())
10647         d.reserve(0)
10648         e=DataArrayDouble([]) ; e.setInfoOnComponent(0,"ABC") ; e.setName("dEf") ; self.assertTrue(d.isEqual(e,1e-14))
10649         self.assertEqual(0,d.getNbOfElemAllocated())
10650         pass
10651
10652     def testDAIBuildSubstractionOptimized1(self):
10653         da1=DataArrayInt.New([1,3,5,6,7,9,13])
10654         da2=DataArrayInt.New([3,5,9])
10655         da3=DataArrayInt.New([1,3,5])
10656         da4=DataArrayInt.New([1,3,5,6,7,9,13])
10657         #
10658         a=da1.buildSubstractionOptimized(da2);
10659         self.assertTrue(a.isEqual(DataArrayInt([1,6,7,13])));
10660         #
10661         a=da1.buildSubstractionOptimized(da3);
10662         self.assertTrue(a.isEqual(DataArrayInt([6,7,9,13])));
10663         #
10664         a=da1.buildSubstractionOptimized(da4);
10665         self.assertTrue(a.isEqual(DataArrayInt([])));
10666         pass
10667
10668     def testDAIIsStrictlyMonotonic1(self):
10669         da1=DataArrayInt.New([1,3,5,6,7,9,13])
10670         self.assertTrue(da1.isStrictlyMonotonic(True));
10671         da1.checkStrictlyMonotonic(True);
10672         self.assertTrue(da1.isMonotonic(True));
10673         da1.checkMonotonic(True);
10674         self.assertTrue(not da1.isStrictlyMonotonic(False));
10675         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,False)
10676         self.assertTrue(not da1.isMonotonic(False));
10677         self.assertRaises(InterpKernelException,da1.checkMonotonic,False)
10678         #
10679         da1=DataArrayInt.New([1,3,5,6,6,9,13])
10680         self.assertTrue(not da1.isStrictlyMonotonic(True));
10681         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,True)
10682         self.assertTrue(da1.isMonotonic(True));
10683         da1.checkMonotonic(True);
10684         self.assertTrue(not da1.isStrictlyMonotonic(False));
10685         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,False)
10686         self.assertTrue(not da1.isMonotonic(False));
10687         self.assertRaises(InterpKernelException,da1.checkMonotonic,False)
10688         #
10689         da1=DataArrayInt.New([1,3,5,6,5,9,13])
10690         self.assertTrue(not da1.isStrictlyMonotonic(True));
10691         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,True)
10692         self.assertTrue(not da1.isMonotonic(True));
10693         self.assertRaises(InterpKernelException,da1.checkMonotonic,True)
10694         self.assertTrue(not da1.isStrictlyMonotonic(False));
10695         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,False)
10696         self.assertTrue(not da1.isMonotonic(False));
10697         self.assertRaises(InterpKernelException,da1.checkMonotonic,False)
10698         #
10699         da1=DataArrayInt.New([13,9,7,6,5,3,1])
10700         self.assertTrue(not da1.isStrictlyMonotonic(True));
10701         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,True)
10702         self.assertTrue(not da1.isMonotonic(True));
10703         self.assertRaises(InterpKernelException,da1.checkMonotonic,True)
10704         self.assertTrue(da1.isStrictlyMonotonic(False));
10705         da1.checkStrictlyMonotonic(False);
10706         self.assertTrue(da1.isMonotonic(False));
10707         da1.checkMonotonic(False);
10708         #
10709         da1=DataArrayInt.New([13,9,6,6,5,3,1])
10710         self.assertTrue(not da1.isStrictlyMonotonic(True));
10711         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,True)
10712         self.assertTrue(not da1.isMonotonic(True));
10713         self.assertRaises(InterpKernelException,da1.checkMonotonic,True)
10714         self.assertTrue(not da1.isStrictlyMonotonic(False));
10715         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,False)
10716         self.assertTrue(da1.isMonotonic(False));
10717         da1.checkMonotonic(False);
10718         #
10719         da1=DataArrayInt.New([13,9,5,6,5,3,1])
10720         self.assertTrue(not da1.isStrictlyMonotonic(True));
10721         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,True)
10722         self.assertTrue(not da1.isMonotonic(True));
10723         self.assertRaises(InterpKernelException,da1.checkMonotonic,True)
10724         self.assertTrue(not da1.isStrictlyMonotonic(False));
10725         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,False)
10726         self.assertTrue(not da1.isMonotonic(False));
10727         self.assertRaises(InterpKernelException,da1.checkMonotonic,False)
10728         #
10729         da1=DataArrayInt.New([])
10730         self.assertTrue(da1.isStrictlyMonotonic(True));
10731         da1.checkStrictlyMonotonic(True);
10732         self.assertTrue(da1.isMonotonic(True));
10733         da1.checkMonotonic(True);
10734         self.assertTrue(da1.isStrictlyMonotonic(False));
10735         da1.checkStrictlyMonotonic(False);
10736         self.assertTrue(da1.isMonotonic(False));
10737         da1.checkMonotonic(False);
10738         #
10739         da1=DataArrayInt.New([13])
10740         self.assertTrue(da1.isStrictlyMonotonic(True));
10741         da1.checkStrictlyMonotonic(True);
10742         self.assertTrue(da1.isMonotonic(True));
10743         da1.checkMonotonic(True);
10744         self.assertTrue(da1.isStrictlyMonotonic(False));
10745         da1.checkStrictlyMonotonic(False);
10746         self.assertTrue(da1.isMonotonic(False));
10747         da1.checkMonotonic(False);
10748         pass
10749
10750     def testFindAndCorrectBadOriented3DCells1(self):
10751         nbOfDisc=20
10752         vects=([0,0,-1],[0.3,0.7,0.2],[-0.3,0.7,0.2],[-0.3,-0.7,0.2])
10753         #
10754         m0=MEDCouplingUMesh("m",3) ; m0.allocateCells(0); m0.insertNextCell(NORM_TETRA4,[0,1,2,3]); #Well oriented
10755         m1=MEDCouplingUMesh("m",3) ; m1.allocateCells(0); m1.insertNextCell(NORM_PYRA5,[0,1,2,3,4]); #Well oriented
10756         m2=MEDCouplingUMesh("m",3) ; m2.allocateCells(0); m2.insertNextCell(NORM_PENTA6,[0,1,2,3,4,5]); #Well oriented
10757         m3=MEDCouplingUMesh("m",3) ; m3.allocateCells(0); m3.insertNextCell(NORM_HEXA8,[0,1,2,3,4,5,6,7]); #Well oriented
10758         m4=MEDCouplingUMesh("m",3) ; m4.allocateCells(0)
10759         self.assertRaises(InterpKernelException,m4.insertNextCell,NORM_HEXGP12,[0,1,2,3,4,5,6,7,8,9,10,11,12]);
10760         m4.insertNextCell(NORM_HEXGP12,[0,1,2,3,4,5,6,7,8,9,10,11]); #Well oriented
10761         c0=DataArrayDouble([0.,0.,0.,0.,1.,0.,1.,0.,0.,0.,0.,1.],4,3) ; m0.setCoords(c0)
10762         c1=DataArrayDouble([0.,0.,0.,0.,1.,0.,1.,1.,0.,1.,0.,0.,0.,0.,1.],5,3) ; m1.setCoords(c1)
10763         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)
10764         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)
10765         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)
10766         m=MEDCouplingMesh.MergeMeshes([m0,m1,m2,m3,m4])
10767         expected1=DataArrayDouble([0.16666666666666666,0.3333333333333333,0.5,1.,1.])
10768         for v in vects:
10769             for i in xrange(nbOfDisc):
10770                 mm=m.deepCpy()
10771                 mm.rotate([0.,0.,0.],[0.3,0.7,0.2],float(i)/float(nbOfDisc)*2*pi)
10772                 mm2=mm.deepCpy()
10773                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
10774                 self.assertTrue(mm.findAndCorrectBadOriented3DCells().empty())
10775                 self.assertTrue(mm.isEqual(mm2,1e-14))
10776                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
10777                 mm.convertAllToPoly()
10778                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
10779                 pass
10780             pass
10781         #
10782         mOK=m.deepCpy()
10783         m0=MEDCouplingUMesh("m",3) ; m0.allocateCells(0); m0.insertNextCell(NORM_TETRA4,[0,2,1,3]); #Not well oriented
10784         m1=MEDCouplingUMesh("m",3) ; m1.allocateCells(0); m1.insertNextCell(NORM_PYRA5,[0,1,2,3,4]); #Well oriented
10785         m2=MEDCouplingUMesh("m",3) ; m2.allocateCells(0); m2.insertNextCell(NORM_PENTA6,[0,1,2,3,4,5]); #Well oriented
10786         m3=MEDCouplingUMesh("m",3) ; m3.allocateCells(0); m3.insertNextCell(NORM_HEXA8,[0,3,2,1,4,7,6,5]); #Not well oriented
10787         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
10788         m0.setCoords(c0) ; m1.setCoords(c1) ; m2.setCoords(c2) ; m3.setCoords(c3) ; m4.setCoords(c4)
10789         m=MEDCouplingMesh.MergeMeshes([m0,m1,m2,m3,m4])
10790         expected2=DataArrayDouble([-0.16666666666666666,0.3333333333333333,0.5,-1.,-1.])
10791         for v in vects:
10792             for i in xrange(nbOfDisc):
10793                 mm=m.deepCpy()
10794                 mm.rotate([0.,0.,0.],[0.3,0.7,0.2],float(i)/float(nbOfDisc)*2*pi)
10795                 mm2=mm.deepCpy() ; mm3=mm.deepCpy() ; mm3.convertAllToPoly()
10796                 self.assertTrue(mm3.getMeasureField(False).getArray().isEqual(expected2,1e-14))
10797                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected2,1e-14))
10798                 self.assertTrue(mm.findAndCorrectBadOriented3DCells().isEqual(DataArrayInt([0,3,4])))
10799                 mOK.setCoords(mm.getCoords())
10800                 self.assertTrue(mm.isEqual(mOK,1e-14))
10801                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
10802                 mmm=mm.deepCpy()
10803                 self.assertTrue(mmm.findAndCorrectBadOriented3DCells().empty())
10804                 mm.convertAllToPoly()
10805                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
10806                 pass
10807             pass
10808         #
10809         m0=MEDCouplingUMesh("m",3) ; m0.allocateCells(0); m0.insertNextCell(NORM_TETRA4,[0,1,2,3]); #Well oriented
10810         m1=MEDCouplingUMesh("m",3) ; m1.allocateCells(0); m1.insertNextCell(NORM_PYRA5,[0,3,2,1,4]); #Not well oriented
10811         m2=MEDCouplingUMesh("m",3) ; m2.allocateCells(0); m2.insertNextCell(NORM_PENTA6,[0,2,1,3,5,4]); #Not well oriented
10812         m3=MEDCouplingUMesh("m",3) ; m3.allocateCells(0); m3.insertNextCell(NORM_HEXA8,[0,1,2,3,4,5,6,7]); #Well oriented
10813         m4=MEDCouplingUMesh("m",3) ; m4.allocateCells(0); m4.insertNextCell(NORM_HEXGP12,range(12)); #Well oriented
10814         m0.setCoords(c0) ; m1.setCoords(c1) ; m2.setCoords(c2) ; m3.setCoords(c3) ; m4.setCoords(c4)
10815         m=MEDCouplingMesh.MergeMeshes([m0,m1,m2,m3,m4])
10816         expected3=DataArrayDouble([0.16666666666666666,-0.3333333333333333,-0.5,1.,1.])
10817         for v in vects:
10818             for i in xrange(nbOfDisc):
10819                 mm=m.deepCpy()
10820                 mm.rotate([0.,0.,0.],[0.3,0.7,0.2],float(i)/float(nbOfDisc)*2*pi)
10821                 mm2=mm.deepCpy() ; mm3=mm.deepCpy() ; mm3.convertAllToPoly()
10822                 self.assertTrue(mm3.getMeasureField(False).getArray().isEqual(expected3,1e-14))
10823                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected3,1e-14))
10824                 self.assertTrue(mm.findAndCorrectBadOriented3DCells().isEqual(DataArrayInt([1,2])))
10825                 mOK.setCoords(mm.getCoords())
10826                 self.assertTrue(mm.isEqual(mOK,1e-14))
10827                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
10828                 mmm=mm.deepCpy()
10829                 self.assertTrue(mmm.findAndCorrectBadOriented3DCells().empty())
10830                 mm.convertAllToPoly()
10831                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
10832                 pass
10833             pass
10834         pass
10835
10836     def testSwigCellOrientation1(self):
10837         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)
10838         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]]
10839         for i in xrange(256):
10840             mesh=MEDCouplingUMesh("FluidMesh_1",3);
10841             mesh.allocateCells(0)
10842             conn2=[elt[:] for elt in conn]
10843             code=bin(i)[2:] ; code='0'*(8-len(code))+code
10844             for face,rev in zip(conn2,code):
10845                 if bool(int(rev)):
10846                     face.reverse()
10847                     pass
10848                 pass
10849             conn3=[elt+[-1] for elt in conn2]
10850             conn3=sum(conn3,[])[:-1]
10851             mesh.insertNextCell(NORM_POLYHED,conn3)
10852             mesh.setCoords(coords)
10853             mesh.orientCorrectlyPolyhedrons()
10854             self.assertTrue(mesh.getBarycenterAndOwner().isEqual(DataArrayDouble([-0.10803,0.,0.3385],1,3),1e-12))
10855             pass
10856         pass
10857
10858     def testSwigCheckConsecutiveCellTypesForMEDFileFrmt1(self):
10859         m1=MEDCouplingUMesh("",2) ; m1.allocateCells(0)
10860         m1.insertNextCell(NORM_QUAD4,[0,1,2,3])
10861         m1.insertNextCell(NORM_TRI3,[0,1,2])
10862         d=DataArrayDouble(4,3) ; d[:]=0.
10863         m1.setCoords(d)
10864         self.assertTrue(m1.checkConsecutiveCellTypes())
10865         self.assertTrue(not m1.checkConsecutiveCellTypesForMEDFileFrmt())
10866         m1.renumberCells([1,0])
10867         self.assertTrue(m1.checkConsecutiveCellTypes())
10868         self.assertTrue(m1.checkConsecutiveCellTypesForMEDFileFrmt())
10869         pass
10870
10871     def testSwigDAAccumulate1(self):
10872         d=DataArrayInt(10) ; d.iota(0)
10873         self.assertEqual([45],d.accumulate())
10874         self.assertEqual(45,d.accumulate(0))
10875         d=DataArrayInt(30) ; d.iota(0) ; d.rearrange(3)
10876         self.assertEqual([135,145,155],d.accumulate())
10877         self.assertEqual(135,d.accumulate(0))
10878         self.assertEqual(145,d.accumulate(1))
10879         self.assertEqual(155,d.accumulate(2))
10880         d=DataArrayDouble(10) ; d.iota(0.)
10881         self.assertEqual([45.],d.accumulate())
10882         self.assertEqual(45.,d.accumulate(0))
10883         d=DataArrayDouble(30) ; d.iota(0) ; d.rearrange(3)
10884         self.assertEqual([135.,145.,155.],d.accumulate())
10885         self.assertEqual(135.,d.accumulate(0))
10886         self.assertEqual(145.,d.accumulate(1))
10887         self.assertEqual(155.,d.accumulate(2))
10888         pass
10889
10890     def testSwigUMeshDistanceToMesh1(self):
10891         m=MEDCouplingUMesh("toto",2)
10892         coords=DataArrayDouble([2.3,3.4,5.6,6.5,-4.3,3.2,-9.8,7.6,-5.4],3,3)
10893         m.setCoords(coords)
10894         m.allocateCells(0)
10895         m.insertNextCell(NORM_TRI3,[0,1,2])
10896         a,b,c=m.distanceToPoint([-0.335,2.27,1.21])
10897         self.assertEqual(0,b) ; self.assertEqual(0,c)
10898         self.assertAlmostEqual(0.022360988100374124,a,14);
10899         a,b,c=m.distanceToPoint(DataArrayDouble([-0.335,2.27,1.21],1,3))
10900         self.assertEqual(0,b) ; self.assertEqual(0,c)
10901         self.assertAlmostEqual(0.022360988100374124,a,14);
10902         a,b=coords.distanceToTuple([-0.335,2.27,1.21])
10903         self.assertAlmostEqual(5.243302871282566,a,14)
10904         self.assertEqual(0,b)
10905         #
10906         m=MEDCouplingUMesh("toto",2)
10907         coords=DataArrayDouble([0.,0.,0., 8.,0.,0., 8.,8.,0., 0.,8.,0.],4,3)
10908         m.setCoords(coords)
10909         m.allocateCells(0)
10910         m.insertNextCell(NORM_QUAD4,[0,1,2,3])
10911         m.checkCoherency2()
10912         self.assertEqual([4,0,1,2,3],m.getNodalConnectivity().getValues())
10913         a,b,c=m.distanceToPoint([5.,2.,0.1])
10914         self.assertAlmostEqual(0.1,a,14) ; self.assertEqual(0,b) ; self.assertEqual(1,c)
10915         a,b,c=m.distanceToPoint([5.,-2.,4.])
10916         self.assertAlmostEqual(sqrt(2*2+4*4),a,14) ; self.assertEqual(0,b) ; self.assertEqual(1,c)
10917         m.allocateCells(0)
10918         m.insertNextCell(NORM_POLYGON,[0,1,2,3])
10919         m.checkCoherency2()
10920         self.assertEqual([5,0,1,2,3],m.getNodalConnectivity().getValues())
10921         a,b,c=m.distanceToPoint([11.,3.,4.])
10922         self.assertAlmostEqual(sqrt(3*3+4*4),a,14) ; self.assertEqual(0,b) ; self.assertEqual(1,c)
10923         a,b,c=m.distanceToPoint([4.,12.,5.])
10924         self.assertAlmostEqual(sqrt(4*4+5*5),a,14) ; self.assertEqual(0,b) ; self.assertEqual(2,c)
10925         d=DataArrayDouble([-1.2,3.,2.],1,3)
10926         for elt in d:
10927             a,b,c=m.distanceToPoint(d)
10928             self.assertAlmostEqual(sqrt(1.2*1.2+2*2),a,14) ; self.assertEqual(0,b) ; self.assertEqual(0,c)
10929             pass
10930         #
10931         m=MEDCouplingUMesh("toto",1)
10932         coords=DataArrayDouble([0.,0.,4.,0.,0.,4.],3,2) ; m.setCoords(coords)
10933         m.allocateCells(0) ; m.insertNextCell(NORM_SEG2,[0,1]) ; m.insertNextCell(NORM_SEG2,[1,2])
10934         a,b,c=m.distanceToPoint([-0.1,4.1])
10935         self.assertAlmostEqual(0.14142135623730925,a,14) ; self.assertEqual(-1,b) ; self.assertEqual(2,c)
10936         a,b,c=m.distanceToPoint([0.,3.9])
10937         self.assertAlmostEqual(0.07071067811865482,a,14) ; self.assertEqual(1,b) ; self.assertEqual(2,c)
10938         pass
10939
10940     def testSwigNonRegressionPartitionBySpreadZone1(self):
10941         m=MEDCouplingCMesh()
10942         arr=DataArrayDouble(6) ; arr.iota(0.)
10943         m.setCoords(arr,arr,arr)
10944         m=m.buildUnstructured()
10945         mPart=m[50,80,85,87,92,122]
10946         zones=mPart.partitionBySpreadZone()
10947         self.assertEqual(4,len(zones))
10948         self.assertTrue(zones[0].isEqual(DataArrayInt([0])))
10949         self.assertTrue(zones[1].isEqual(DataArrayInt([1,2])))
10950         self.assertTrue(zones[2].isEqual(DataArrayInt([3,4])))
10951         self.assertTrue(zones[3].isEqual(DataArrayInt([5])))
10952         #
10953         n,ni=m.computeNeighborsOfCells()
10954         a,b=MEDCouplingUMesh.ComputeSpreadZoneGraduallyFromSeed(0,n,ni)
10955         self.assertEqual(13,b) ; self.assertEqual(125,len(a)) ; self.assertTrue(a.isIdentity())
10956         a,b=MEDCouplingUMesh.ComputeSpreadZoneGraduallyFromSeed([1],n,ni)
10957         self.assertEqual(12,b) ; self.assertEqual(125,len(a)) ; self.assertTrue(a.isIdentity())
10958         a,b=MEDCouplingUMesh.ComputeSpreadZoneGraduallyFromSeed((2,),n,ni)
10959         self.assertEqual(11,b) ; self.assertEqual(125,len(a)) ; self.assertTrue(a.isIdentity())
10960         a,b=MEDCouplingUMesh.ComputeSpreadZoneGraduallyFromSeed(DataArrayInt([3]),n,ni)
10961         self.assertEqual(12,b) ; self.assertEqual(125,len(a)) ; self.assertTrue(a.isIdentity())
10962         pass
10963
10964     def testSwigUMeshInsertNextCell1(self):
10965         m=MEDCouplingUMesh("toto",2)
10966         #
10967         coords=DataArrayDouble([0.,0.,1.,1.,1.,0.]) ; m.setCoords(coords)
10968         da=DataArrayInt([0,1,2])
10969         m.allocateCells(0)
10970         for i in xrange(5):
10971             m.insertNextCell(NORM_TRI3,da)
10972             pass
10973         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])))
10974         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4,8,12,16,20])))
10975         #
10976         da=DataArrayInt([0,1,2,3])
10977         m.allocateCells(0)
10978         for i in xrange(5):
10979             m.insertNextCell(NORM_TRI3,3,da)
10980             pass
10981         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])))
10982         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4,8,12,16,20])))
10983         #
10984         da=DataArrayInt([0,1])
10985         m.allocateCells(0)
10986         self.assertRaises(InterpKernelException,m.insertNextCell,NORM_TRI3,3,da)
10987         #
10988         da=DataArrayInt([0,1,2,0,1,3,0,1,4,0,1,5,0,1,6],5,3)
10989         m.allocateCells(0)
10990         for t in da:
10991             m.insertNextCell(NORM_TRI3,t)
10992             pass
10993         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])))
10994         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4,8,12,16,20])))
10995         self.assertRaises(InterpKernelException,m.insertNextCell,NORM_TRI3,None)
10996         pass
10997
10998     def testSwigCurveLinearMesh1(self):
10999         m=MEDCouplingCurveLinearMesh("toto")
11000         m.setNodeGridStructure([2,3])
11001         coords=DataArrayDouble([0.,0., 2.,0., 0.,1., 1.9,1.1, 0.3,1.9, 2.2,2.1],6,2)
11002         m.setCoords(coords)
11003         m.checkCoherency()
11004         m0=m.deepCpy()
11005         self.assertTrue(m0.isEqual(m,1e-12))
11006         m.getCoords().setInfoOnComponents(["X [m]","Y [m]"])
11007         self.assertTrue(not m0.isEqual(m,1e-12))
11008         m0=m.deepCpy()
11009         self.assertTrue(m0.isEqual(m,1e-12))
11010         self.assertEqual(m.getNodeGridStructure(),(2,3))
11011         pass
11012
11013     def testSimplexize3(self):
11014         m=MEDCouplingUMesh("toto",3)
11015         m.allocateCells(0)
11016         m.insertNextCell(NORM_TETRA4,[0,1,2,3])
11017         m.insertNextCell(NORM_HEXA8,[4,5,6,7,8,9,10,11])
11018         m.insertNextCell(NORM_HEXA8,[12,13,14,15,16,17,18,19])
11019         m.insertNextCell(NORM_TETRA4,[20,21,22,23])
11020         c1=DataArrayDouble([0.,0.,0.,0.,1.,0.,1.,0.,0.,0.,0.,1.],4,3)
11021         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.]
11022         c3=c2+[2.,0.,0.]
11023         c4=c1+[6.,0.,0.]
11024         c=DataArrayDouble.Aggregate([c1,c2,c3,c4])
11025         m.setCoords(c)
11026         m.checkCoherency2()
11027         #
11028         m1=m.deepCpy()
11029         d1=m1.simplexize(PLANAR_FACE_5)
11030         m1.checkCoherency2()
11031         vol1=m1.getMeasureField(ON_CELLS).getArray()
11032         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))
11033         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])
11034         self.assertEqual(m1.getNodalConnectivityIndex().getValues(),[0,5,10,15,20,25,30,35,40,45,50,55,60])
11035         self.assertTrue(d1.isEqual(DataArrayInt([0,1,1,1,1,1,2,2,2,2,2,3])))
11036         #
11037         m2=m.deepCpy()
11038         d2=m2.simplexize(PLANAR_FACE_6)
11039         m2.checkCoherency2()
11040         vol2=m2.getMeasureField(ON_CELLS).getArray()
11041         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))
11042         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])
11043         self.assertEqual(m2.getNodalConnectivityIndex().getValues(),[0,5,10,15,20,25,30,35,40,45,50,55,60,65,70])
11044         self.assertTrue(d2.isEqual(DataArrayInt([0,1,1,1,1,1,1,2,2,2,2,2,2,3])))
11045         pass
11046
11047     def testSwigCurveLinearMesh2(self):
11048         c=MEDCouplingCMesh()
11049         #2D
11050         arr1=DataArrayDouble([0,1,3,7])
11051         arr2=DataArrayDouble([0,1,1.5])
11052         c.setCoords(arr1,arr2)
11053         u=c.buildUnstructured()
11054         coo=u.getCoords()
11055         cl=MEDCouplingCurveLinearMesh()
11056         cl.setCoords(coo)
11057         cl.setNodeGridStructure([4,3])
11058         cl.checkCoherency2()
11059         li1=[1.,2.,4.,0.5,1.,2.]
11060         self.assertTrue(cl.getMeasureField(False).getArray().isEqual(DataArrayDouble(li1),1e-14))
11061         self.assertTrue(u.getMeasureField(False).getArray().isEqual(DataArrayDouble(li1),1e-14))
11062         li1_1=[0.5,0.5,2.,0.5,5.,0.5,0.5,1.25,2.,1.25,5.,1.25]
11063         self.assertTrue(cl.getBarycenterAndOwner().isEqual(DataArrayDouble(li1_1,6,2),1e-14))
11064         self.assertTrue(u.getBarycenterAndOwner().isEqual(DataArrayDouble(li1_1,6,2),1e-14))
11065         #3D
11066         c.setCoords(arr1,arr2,arr2)
11067         u=c.buildUnstructured()
11068         coo=u.getCoords()
11069         cl=MEDCouplingCurveLinearMesh()
11070         cl.setCoords(coo)
11071         cl.setNodeGridStructure([4,3,3])
11072         cl.checkCoherency2()
11073         li2=[1.,2.,4.,0.5, 1.,2.,0.5,1.,2.,0.25,0.5,1.]
11074         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]
11075         self.assertTrue(cl.getMeasureField(False).getArray().isEqual(DataArrayDouble(li2),1e-14))
11076         self.assertTrue(u.getMeasureField(False).getArray().isEqual(DataArrayDouble(li2),1e-14))
11077         self.assertTrue(cl.getBarycenterAndOwner().isEqual(DataArrayDouble(li2_1,12,3),1e-14))
11078         self.assertTrue(u.getBarycenterAndOwner().isEqual(DataArrayDouble(li2_1,12,3),1e-14))
11079         #1D spaceDim 1
11080         coo=DataArrayDouble(5) ; coo.iota(0.)
11081         coo=coo*coo
11082         cl.setCoords(coo)
11083         cl.setNodeGridStructure([5])
11084         cl.checkCoherency2()
11085         li3=[1.,3.,5.,7.]
11086         li3_1=[0.5,2.5,6.5,12.5]
11087         self.assertTrue(cl.getMeasureField(False).getArray().isEqual(DataArrayDouble(li3),1e-14))
11088         self.assertTrue(cl.buildUnstructured().getMeasureField(False).getArray().isEqual(DataArrayDouble(li3),1e-14))
11089         self.assertTrue(cl.getBarycenterAndOwner().isEqual(DataArrayDouble(li3_1),1e-14))
11090         self.assertTrue(cl.buildUnstructured().getBarycenterAndOwner().isEqual(DataArrayDouble(li3_1),1e-14))
11091         #1D spaceDim 2
11092         coo=DataArrayDouble.Meld(coo,coo)
11093         cl.setCoords(coo)
11094         cl.checkCoherency2()
11095         li4=[sqrt(2.)*elt for elt in [1.,3.,5.,7.]]
11096         li4_1=[0.5,0.5,2.5,2.5,6.5,6.5,12.5,12.5]
11097         self.assertTrue(cl.getMeasureField(False).getArray().isEqual(DataArrayDouble(li4),1e-14))
11098         self.assertTrue(cl.buildUnstructured().getMeasureField(False).getArray().isEqual(DataArrayDouble(li4),1e-14))
11099         self.assertTrue(cl.getBarycenterAndOwner().isEqual(DataArrayDouble(li4_1,4,2),1e-14))
11100         self.assertTrue(cl.buildUnstructured().getBarycenterAndOwner().isEqual(DataArrayDouble(li4_1,4,2),1e-14))
11101         pass
11102
11103     def testSwigCurveLinearMeshNonRegression1(self):
11104         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)
11105         m=MEDCouplingCurveLinearMesh("toto")
11106         m.setCoords(coords)
11107         m.setNodeGridStructure([3,3,3])
11108         #
11109         vol=m.getMeasureField(False).getArray()
11110         self.assertTrue(vol.isEqual(DataArrayDouble([0.11450000709295281, 0.10583334351579375,0.11149999939029423,0.08866666863113633, 0.1404166805123294,0.1250000135352219,0.1270833433481557,0.13258334288001067]),1e-12))
11111         self.assertTrue(vol.isEqual(m.buildUnstructured().getMeasureField(False).getArray(),1e-12))
11112         #
11113         self.assertTrue(m.getBarycenterAndOwner().isEqual(m.buildUnstructured().getBarycenterAndOwner(),1e-12))
11114         pass
11115
11116     def setUp(self):
11117         pass
11118     pass
11119
11120 unittest.main()