src/MEDCoupling_Swig/MEDCouplingBasicsTest.py

   1 #  -*- coding: iso-8859-1 -*-
   2 # Copyright (C) 2007-2013  CEA/DEN, EDF R&D
   3 #
   4 # This library is free software; you can redistribute it and/or
   5 # modify it under the terms of the GNU Lesser General Public
   6 # License as published by the Free Software Foundation; either
   7 # version 2.1 of the License.
   8 #
   9 # This library is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 # Lesser General Public License for more details.
  13 #
  14 # You should have received a copy of the GNU Lesser General Public
  15 # License along with this library; if not, write to the Free Software
  16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  17 #
  18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  19 #
  20
  21 from MEDCoupling import *
  22 import unittest
  23 from math import pi,e,sqrt,cos,sin
  24 from MEDCouplingDataForTest import MEDCouplingDataForTest
  25
  26 class MEDCouplingBasicsTest(unittest.TestCase):
  27     def testArray2(self):
  28         arr=DataArrayDouble.New()
  29         arr.setValues([12.,11.,10.,9.,8.,7.,6.,5.,4.,3.,2.,1.],3,4)
  30         arr.setInfoOnComponent(0,"ggg");
  31         arr.setInfoOnComponent(1,"hhhh");
  32         arr.setInfoOnComponent(2,"jj");
  33         arr.setInfoOnComponent(3,"kkkkkk");
  34         arr2=arr.convertToIntArr();
  35         arr3=arr2.convertToDblArr();
  36         self.assertTrue(arr.isEqual(arr3,1e-14))
  37         pass
  38
  39     def testArray3(self):
  40         arr1=DataArrayInt.New();
  41         arr1Ref=[0,10,1,11,2,12,3,13,4,14,5,15,6,16]
  42         arr1.setValues(arr1Ref,7,2);
  43         self.assertEqual(7,arr1.getNumberOfTuples());
  44         self.assertEqual(2,arr1.getNumberOfComponents());
  45         self.assertEqual(arr1Ref,list(arr1.getValues()));
  46         arr2=arr1.substr(3);
  47         self.assertEqual(4,arr2.getNumberOfTuples());
  48         self.assertEqual(2,arr2.getNumberOfComponents());
  49         self.assertEqual(arr1Ref[6:],list(arr2.getValues()));
  50         arr3=arr1.substr(2,5);
  51         self.assertEqual(3,arr3.getNumberOfTuples());
  52         self.assertEqual(2,arr3.getNumberOfComponents());
  53         self.assertEqual(arr1Ref[4:10],list(arr3.getValues()));
  54         #
  55         arr4=DataArrayDouble.New();
  56         arr4Ref=[0.8,10.8,1.9,11.9,2.1,12.1,3.2,13.2,4.3,14.3,5.4,15.4,6.5,16.5]
  57         arr4.setValues(arr4Ref,7,2);
  58         self.assertEqual(7,arr4.getNumberOfTuples());
  59         self.assertEqual(2,arr4.getNumberOfComponents());
  60         tmp=arr4.getValues()
  61         for i in xrange(14):
  62             self.assertTrue(abs(arr4Ref[i]-tmp[i])<1e-14);
  63             pass
  64         arr5=arr4.substr(3);
  65         self.assertEqual(4,arr5.getNumberOfTuples());
  66         self.assertEqual(2,arr5.getNumberOfComponents());
  67         tmp=arr5.getValues()
  68         for i in xrange(8):
  69             self.assertTrue(abs(arr4Ref[6+i]-tmp[i])<1e-14);
  70             pass
  71         arr6=arr4.substr(2,5);
  72         self.assertEqual(3,arr6.getNumberOfTuples());
  73         self.assertEqual(2,arr6.getNumberOfComponents());
  74         tmp=arr6.getValues()
  75         for i in xrange(6):
  76             self.assertTrue(abs(arr4Ref[4+i]-tmp[i])<1e-14);
  77             pass
  78         pass
  79
  80     def testMesh(self):
  81         tab4=[1, 2, 8, 7, 2, 3, 9, 8, 3,
  82               4, 10, 9, 4, 5, 11, 10, 5,
  83               0, 6, 11, 0, 1, 7, 6 ]
  84         nbOfNodes=12
  85         nbOfCells=6
  86         coords=[ 0.024155, 0.04183768725682622, -0.305, 0.04831000000000001, -1.015761910347357e-17,
  87                  -0.305, 0.09662000000000001, -1.832979297858306e-18, -0.305, 0.120775, 0.04183768725682623,
  88                  -0.305, 0.09662000000000001, 0.08367537451365245, -0.305, 0.04831000000000001, 0.08367537451365246,
  89                  -0.305, 0.024155, 0.04183768725682622, -0.2863, 0.04831000000000001, -1.015761910347357e-17, -0.2863,
  90                  0.09662000000000001, -1.832979297858306e-18, -0.2863, 0.120775, 0.04183768725682623, -0.2863, 0.09662000000000001,
  91                  0.08367537451365245, -0.2863, 0.04831000000000001, 0.08367537451365246, -0.2863 ]
  92         mesh=MEDCouplingUMesh.New()
  93         mesh.setMeshDimension(2)
  94         mesh.allocateCells(8);
  95         mesh.setName("mesh1")
  96         self.assertTrue(mesh.getName()=="mesh1")
  97         for i in range(nbOfCells):
  98             mesh.insertNextCell(NORM_QUAD4,4,tab4[4*i:4*(i+1)]);
  99             pass
 100         mesh.finishInsertingCells()
 101         self.assertTrue(mesh.getNumberOfCells()==nbOfCells)
 102         self.assertTrue(mesh.getNodalConnectivity().getNbOfElems()==30)
 103         self.assertTrue(mesh.getNodalConnectivityIndex().getNbOfElems()==nbOfCells+1)
 104         myCoords=DataArrayDouble.New()
 105         myCoords.setValues(coords,nbOfNodes,3);
 106         self.assertTrue(myCoords.getIJ(3,2)==-0.305)
 107         mesh.setCoords(myCoords);
 108         mesh.checkCoherency();
 109         self.assertTrue(mesh.getAllTypes()==[4])
 110         myFalseConn=DataArrayInt.New()
 111         myFalseConn.setValues(tab4,6,4)
 112         self.assertTrue(myFalseConn.getIJ(1,1)==3)
 113         #
 114         field=MEDCouplingFieldDouble.New(ON_CELLS)
 115         field.setMesh(mesh)
 116         field.setNature(Integral)
 117         myCoords=DataArrayDouble.New()
 118         sampleTab=[]
 119         for i in range(nbOfCells*9):
 120             sampleTab.append(float(i))
 121         myCoords.setValues(sampleTab,nbOfCells,9);
 122         field.setArray(myCoords)
 123         self.assertTrue(3==mesh.getSpaceDimension())
 124         field.checkCoherency()
 125         mesh2=mesh.clone(False)
 126         mesh3=mesh.clone(True)
 127         mesh3=0
 128         mesh2=0
 129         ## deep full recursively copy of field -> both field and mesh underneath copied
 130         field2=field.clone(True)
 131         field2.setMesh(field.getMesh().clone(True))
 132         mesh3=mesh.clone(True)
 133         field3=mesh3.fillFromAnalytic(ON_CELLS,2,"x*IVec+(y+z)*JVec")
 134         field3.applyFunc("u*u*u+cos(u)")
 135         pass
 136
 137     def testMeshPointsCloud(self):
 138         targetCoords=[-0.3,-0.3,0.5, 0.2,-0.3,1., 0.7,-0.3,1.5,
 139                       -0.3,0.2,0.5, 0.2,0.2,1., 0.7,0.2,1.5, -0.3,0.7,0.5, 0.2,0.7,1., 0.7,0.7,1.5]
 140         targetMesh=MEDCouplingUMesh.New();
 141         targetMesh.setMeshDimension(0);
 142         targetMesh.allocateCells(8);
 143         targetMesh.insertNextCell(NORM_POINT1,1,[0]);
 144         targetMesh.insertNextCell(NORM_POINT1,1,[1]);
 145         targetMesh.insertNextCell(NORM_POINT1,1,[2]);
 146         targetMesh.insertNextCell(NORM_POINT1,1,[3]);
 147         targetMesh.insertNextCell(NORM_POINT1,1,[4]);
 148         targetMesh.insertNextCell(NORM_POINT1,1,[5]);
 149         targetMesh.insertNextCell(NORM_POINT1,1,[7]);
 150         targetMesh.insertNextCell(NORM_POINT1,1,[6]);
 151         targetMesh.finishInsertingCells();
 152         self.assertRaises(InterpKernelException,targetMesh.checkCoherency);
 153         myCoords=DataArrayDouble.New();
 154         myCoords.setValues(targetCoords,9,3);
 155         targetMesh.setCoords(myCoords);
 156         self.assertEqual(targetMesh.getSpaceDimension(),3)
 157         self.assertEqual(targetMesh.getNumberOfCells(),8)
 158         self.assertEqual(targetMesh.getNumberOfNodes(),9)
 159         self.assertEqual(targetMesh.getMeshDimension(),0)
 160         pass
 161
 162     def testMeshM1D(self):
 163         meshM1D=MEDCouplingUMesh.New();
 164         self.assertRaises(InterpKernelException,meshM1D.getMeshDimension);
 165         self.assertRaises(InterpKernelException,meshM1D.getNumberOfNodes);
 166         self.assertRaises(InterpKernelException,meshM1D.getNumberOfCells);
 167         self.assertRaises(InterpKernelException,meshM1D.setMeshDimension,-2)
 168         self.assertRaises(InterpKernelException,meshM1D.setMeshDimension,-10)
 169         meshM1D.setMeshDimension(-1);
 170         meshM1D.checkCoherency();
 171         self.assertEqual(meshM1D.getMeshDimension(),-1);
 172         self.assertEqual(meshM1D.getNumberOfCells(),1);
 173         self.assertRaises(InterpKernelException,meshM1D.getNumberOfNodes);
 174         self.assertRaises(InterpKernelException,meshM1D.getSpaceDimension);
 175         cpy=meshM1D.clone(True);
 176         self.assertTrue(cpy.isEqual(meshM1D,1e-12));
 177         fieldOnCells=MEDCouplingFieldDouble.New(ON_CELLS);
 178         fieldOnCells.setMesh(meshM1D);
 179         array=DataArrayDouble.New();
 180         array.setValues(6*[7.],1,6);
 181         fieldOnCells.setArray(array);
 182         fieldOnCells.checkCoherency();
 183         pass
 184
 185     def testDeepCopy(self):
 186         array=DataArrayDouble.New();
 187         array.setValues(5*3*[7.],5,3);
 188         self.assertEqual(array.getIJ(3,2),7.);
 189         array2=array.deepCpy();
 190         self.assertEqual(array2.getIJ(3,2),7.)
 191         #
 192         array3=DataArrayInt.New();
 193         array3.setValues(5*3*[17],5,3);
 194         self.assertEqual(array3.getIJ(3,2),17);
 195         array4=array3.deepCpy();
 196         self.assertEqual(array4.getIJ(3,2),17);
 197         pass
 198
 199     def testRevNodal(self):
 200         mesh=MEDCouplingDataForTest.build2DTargetMesh_1()
 201         revNodal,revNodalIndx=mesh.getReverseNodalConnectivity();
 202         revNodalExpected=[0,0,1,1,2,0,3,0,1,2,3,4,2,4,3,3,4,4];
 203         revNodalIndexExpected=[0,1,3,5,7,12,14,15,17,18];
 204         self.assertEqual(revNodal.getNbOfElems(),18)
 205         self.assertEqual(revNodalIndx.getNbOfElems(),10)
 206         self.assertEqual(list(revNodal.getValues()),revNodalExpected)
 207         self.assertEqual(list(revNodalIndx.getValues()),revNodalIndexExpected)
 208         pass
 209
 210     def testConvertToPolyTypes(self):
 211         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
 212         elts=[1,3];
 213         mesh.convertToPolyTypes(elts);
 214         mesh.checkCoherency();
 215         self.assertEqual(5,mesh.getNumberOfCells());
 216         self.assertEqual(23,mesh.getNodalConnectivity().getNumberOfTuples());
 217         expected1=[4, 0, 3, 4, 1, 5, 1, 4, 2, 3, 4, 5, 2, 5, 6, 7, 4, 3, 4, 7, 8, 5, 4]
 218         self.assertEqual(expected1,list(mesh.getNodalConnectivity().getValues()));
 219         #
 220         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
 221         mesh.convertToPolyTypes(elts);
 222         mesh.checkCoherency();
 223         self.assertEqual(8,mesh.getNumberOfCells());
 224         self.assertEqual(114,mesh.getNodalConnectivity().getNumberOfTuples());
 225         mesh.convertToPolyTypes(elts);
 226         mesh.checkCoherency();
 227         self.assertEqual(8,mesh.getNumberOfCells());
 228         self.assertEqual(114,mesh.getNodalConnectivity().getNumberOfTuples());
 229         pass
 230
 231     def testDescConn2D(self):
 232         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
 233         desc=DataArrayInt.New();
 234         descIndx=DataArrayInt.New();
 235         revDesc=DataArrayInt.New();
 236         revDescIndx=DataArrayInt.New();
 237         mesh2=mesh.buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
 238         mesh2.checkCoherency();
 239         self.assertEqual(1,mesh2.getMeshDimension());
 240         self.assertEqual(13,mesh2.getNumberOfCells());
 241         self.assertEqual(14,revDescIndx.getNbOfElems()); self.assertEqual(14,revDescIndx.getNumberOfTuples());
 242         self.assertEqual(6,descIndx.getNbOfElems()); self.assertEqual(6,descIndx.getNumberOfTuples());
 243         self.assertEqual(18,desc.getNbOfElems()); self.assertEqual(18,desc.getNumberOfTuples());
 244         self.assertEqual(18,revDesc.getNbOfElems()); self.assertEqual(18,revDesc.getNumberOfTuples());
 245         expected1=[0,1,2,3, 2,4,5, 6,7,4, 8,9,1,10, 11,12,6,9];
 246         self.assertEqual(expected1,list(desc.getValues()));
 247         expected2=[0,4,7,10,14,18];
 248         self.assertEqual(expected2,list(descIndx.getValues()));
 249         expected3=[0,1,3,5,6,8,9,11,12,13,15,16,17,18];
 250         self.assertEqual(expected3,list(revDescIndx.getValues()));
 251         expected4=[0, 0,3, 0,1, 0, 1,2, 1, 2,4, 2, 3, 3,4, 3, 4, 4];
 252         self.assertEqual(expected4,list(revDesc.getValues()));
 253         conn=mesh2.getNodalConnectivity();
 254         connIndex=mesh2.getNodalConnectivityIndex();
 255         expected5=[0,3,6,9,12,15,18,21,24,27,30,33,36,39];
 256         self.assertEqual(expected5,list(connIndex.getValues()));
 257         expected6=[1, 0, 3, 1, 3, 4, 1, 4, 1, 1, 1, 0, 1, 4, 2, 1, 2, 1, 1, 4, 5, 1, 5, 2, 1, 6, 7, 1, 7, 4, 1, 3, 6, 1, 7, 8, 1, 8, 5];
 258         self.assertEqual(expected6,list(conn.getValues()));
 259         #
 260         eltsV=[1,3];
 261         mesh.convertToPolyTypes(eltsV);
 262         mesh.checkCoherency();
 263         #
 264         desc=DataArrayInt.New();
 265         descIndx=DataArrayInt.New();
 266         revDesc=DataArrayInt.New();
 267         revDescIndx=DataArrayInt.New();
 268         #
 269         mesh2=mesh.buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
 270         mesh2.checkCoherency();
 271         self.assertEqual(1,mesh2.getMeshDimension());
 272         self.assertEqual(13,mesh2.getNumberOfCells());
 273         self.assertEqual(14,revDescIndx.getNbOfElems()); self.assertEqual(14,revDescIndx.getNumberOfTuples());
 274         self.assertEqual(6,descIndx.getNbOfElems()); self.assertEqual(6,descIndx.getNumberOfTuples());
 275         self.assertEqual(18,desc.getNbOfElems()); self.assertEqual(18,desc.getNumberOfTuples());
 276         self.assertEqual(18,revDesc.getNbOfElems()); self.assertEqual(18,revDesc.getNumberOfTuples());
 277         self.assertEqual(expected1,list(desc.getValues()));
 278         self.assertEqual(expected2,list(descIndx.getValues()));
 279         self.assertEqual(expected3,list(revDescIndx.getValues()));
 280         self.assertEqual(expected4,list(revDesc.getValues()));
 281         conn=mesh2.getNodalConnectivity();
 282         connIndex=mesh2.getNodalConnectivityIndex();
 283         self.assertEqual(expected5,list(connIndex.getValues()));
 284         self.assertEqual(expected6,list(conn.getValues()));
 285         pass
 286
 287     def testDescConn3D(self):
 288         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
 289         desc=DataArrayInt.New();
 290         descIndx=DataArrayInt.New();
 291         revDesc=DataArrayInt.New();
 292         revDescIndx=DataArrayInt.New();
 293         #
 294         mesh2=mesh.buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
 295         mesh2.checkCoherency();
 296         self.assertEqual(2,mesh2.getMeshDimension());
 297         self.assertEqual(36,mesh2.getNumberOfCells());
 298         self.assertEqual(37,revDescIndx.getNbOfElems()); self.assertEqual(37,revDescIndx.getNumberOfTuples());
 299         self.assertEqual(9,descIndx.getNbOfElems()); self.assertEqual(9,descIndx.getNumberOfTuples());
 300         self.assertEqual(48,desc.getNbOfElems()); self.assertEqual(48,desc.getNumberOfTuples());
 301         self.assertEqual(48,revDesc.getNbOfElems()); self.assertEqual(48,revDesc.getNumberOfTuples());
 302         expected1=[0, 6, 12, 18, 24, 30, 36, 42, 48]
 303         expected2=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 3, 11, 12, 4, 13, 14, 15, 16, 17, 10, 18, 19, 13, 1, 20, 21, 22, 23, 24, 7, 25, 26, 27, 28, 22, 12, 29, 23, 30, 31, 32, 17, 33, 28, 34, 35, 30]
 304         expected3=[0, 1, 3, 4, 6, 8, 9, 10, 12, 13, 14, 16, 17, 19, 21, 22, 23, 24, 26, 27, 28, 29, 30, 32, 34, 35, 36, 37, 38, 40, 41, 43, 44, 45, 46, 47, 48]
 305         expected4=[0, 0, 4, 0, 0, 1, 0, 2, 0, 1, 1, 5, 1, 1, 1, 3, 2, 2, 6, 2, 3, 2, 2, 3, 3, 7, 3, 3, 4, 4, 4, 5, 4, 6, 4, 5, 5, 5, 5, 7, 6, 6, 7, 6, 6, 7, 7, 7]
 306         expected5=[0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95, 100, 105, 110, 115, 120, 125, 130, 135, 140, 145, 150, 155, 160, 165, 170, 175, 180]
 307         expected6=[4, 0, 1, 4, 3, 4, 9, 12, 13, 10, 4, 0, 9, 10, 1, 4, 1, 10, 13, 4, 4, 4, 13, 12, 3, 4, 3, 12, 9, 0, 4, 1, 2, 5, 4, 4, 10, 13, 14, 11, 4, 1, 10, 11, 2, 4, 2, 11, 14,
 308                    5, 4, 5, 14, 13, 4, 4, 3, 4, 7, 6, 4, 12, 15, 16, 13, 4, 4, 13, 16, 7, 4, 7, 16, 15, 6, 4, 6, 15, 12, 3, 4, 4, 5, 8, 7, 4, 13, 16, 17, 14, 4, 5, 14, 17, 8, 4, 8,
 309                    17, 16, 7, 4, 18, 21, 22, 19, 4, 9, 18, 19, 10, 4, 10, 19, 22, 13, 4, 13, 22, 21, 12, 4, 12, 21, 18, 9, 4, 19, 22, 23, 20, 4, 10, 19, 20, 11, 4, 11, 20, 23, 14, 4,
 310                    14, 23, 22, 13, 4, 21, 24, 25, 22, 4, 13, 22, 25, 16, 4, 16, 25, 24, 15, 4, 15, 24, 21, 12, 4, 22, 25, 26, 23, 4, 14, 23, 26, 17, 4, 17, 26, 25, 16]
 311         expected7=[4, 0, 1, 4, 3, 4, 9, 12, 13, 10, 4, 0, 9, 10, 1, 4, 1, 10, 13, 4, 4, 4, 13, 12, 3, 4, 3, 12, 9, 0, 5, 1, 2, 5, 4, 5, 10, 13, 14, 11, 5, 1, 10, 11, 2, 5, 2, 11, 14,
 312                    5, 5, 5, 14, 13, 4, 4, 3, 4, 7, 6, 4, 12, 15, 16, 13, 4, 4, 13, 16, 7, 4, 7, 16, 15, 6, 4, 6, 15, 12, 3, 5, 4, 5, 8, 7, 5, 13, 16, 17, 14, 5, 5, 14, 17, 8, 5, 8,
 313                    17, 16, 7, 4, 18, 21, 22, 19, 4, 9, 18, 19, 10, 4, 10, 19, 22, 13, 4, 13, 22, 21, 12, 4, 12, 21, 18, 9, 4, 19, 22, 23, 20, 4, 10, 19, 20, 11, 4, 11, 20, 23, 14, 4,
 314                    14, 23, 22, 13, 4, 21, 24, 25, 22, 4, 13, 22, 25, 16, 4, 16, 25, 24, 15, 4, 15, 24, 21, 12, 4, 22, 25, 26, 23, 4, 14, 23, 26, 17, 4, 17, 26, 25, 16]
 315
 316         self.assertEqual(expected1,list(descIndx.getValues()));
 317         self.assertEqual(expected2,list(desc.getValues()));
 318         self.assertEqual(expected3,list(revDescIndx.getValues()));
 319         self.assertEqual(expected4,list(revDesc.getValues()));
 320         self.assertEqual(expected5,list(mesh2.getNodalConnectivityIndex().getValues()));
 321         self.assertEqual(expected6,list(mesh2.getNodalConnectivity().getValues()));
 322         #
 323         eltsV=[1,3]
 324         mesh.convertToPolyTypes(eltsV);
 325         mesh.checkCoherency();
 326         desc=DataArrayInt.New();
 327         descIndx=DataArrayInt.New();
 328         revDesc=DataArrayInt.New();
 329         revDescIndx=DataArrayInt.New();
 330         mesh2=mesh.buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
 331         mesh2.checkCoherency();
 332         self.assertEqual(2,mesh2.getMeshDimension());
 333         self.assertEqual(36,mesh2.getNumberOfCells());
 334         self.assertEqual(37,revDescIndx.getNbOfElems()); self.assertEqual(37,revDescIndx.getNumberOfTuples());
 335         self.assertEqual(9,descIndx.getNbOfElems()); self.assertEqual(9,descIndx.getNumberOfTuples());
 336         self.assertEqual(48,desc.getNbOfElems()); self.assertEqual(48,desc.getNumberOfTuples());
 337         self.assertEqual(48,revDesc.getNbOfElems()); self.assertEqual(48,revDesc.getNumberOfTuples());
 338         self.assertEqual(expected1,list(descIndx.getValues()));
 339         self.assertEqual(expected2,list(desc.getValues()));
 340         self.assertEqual(expected3,list(revDescIndx.getValues()));
 341         self.assertEqual(expected4,list(revDesc.getValues()));
 342         self.assertEqual(expected5,list(mesh2.getNodalConnectivityIndex().getValues()));
 343         self.assertEqual(expected7,list(mesh2.getNodalConnectivity().getValues()));
 344         pass
 345
 346     def testFindBoundaryNodes(self):
 347         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
 348         boundaryNodes=mesh.findBoundaryNodes();
 349         expected1=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26];
 350         self.assertEqual(expected1,boundaryNodes.getValues());
 351         pass
 352
 353     def testBoundaryMesh(self):
 354         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
 355         mesh2=mesh.buildBoundaryMesh(False);
 356         self.assertEqual(24,mesh2.getNumberOfCells());
 357         self.assertEqual(26,mesh2.getNumberOfNodes());
 358         pass
 359
 360     def testBuildPartOfMySelf(self):
 361         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
 362         mesh.setName("Toto");
 363         tab1=[0,4]
 364         tab2=[0,2,3]
 365         #
 366         subMesh=mesh.buildPart(tab1)
 367         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
 368         subMesh=mesh.buildPartOfMySelf(tab1,True);
 369         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
 370         name=subMesh.getName();
 371         self.assertEqual(2,len(mesh.getAllTypes()));
 372         self.assertEqual(NORM_TRI3,mesh.getAllTypes()[0]);
 373         self.assertEqual(NORM_QUAD4,mesh.getAllTypes()[1]);
 374         self.assertEqual(1,len(subMesh.getAllTypes()));
 375         self.assertEqual(NORM_QUAD4,subMesh.getAllTypes()[0]);
 376         self.assertEqual(name,"Toto");
 377         self.assertEqual(2,subMesh.getNumberOfCells());
 378         subConn=[4,0,3,4,1,4,7,8,5,4];
 379         subConnIndex=[0,5,10];
 380         self.assertEqual(10,subMesh.getNodalConnectivity().getNbOfElems());
 381         self.assertEqual(3,subMesh.getNodalConnectivityIndex().getNbOfElems());
 382         self.assertEqual(subConn[0:10],list(subMesh.getNodalConnectivity().getValues()));
 383         self.assertEqual(subConnIndex[0:3],list(subMesh.getNodalConnectivityIndex().getValues()));
 384         #
 385         subMesh=mesh.buildPartOfMySelf(tab2[0:3],True);
 386         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh));
 387         name=subMesh.getName();
 388         self.assertEqual(2,len(subMesh.getAllTypes()));
 389         self.assertEqual(NORM_TRI3,subMesh.getAllTypes()[0]);
 390         self.assertEqual(NORM_QUAD4,subMesh.getAllTypes()[1]);
 391         self.assertEqual(name,"Toto");
 392         self.assertEqual(3,subMesh.getNumberOfCells());
 393         subConn2=[4,0,3,4,1,3,4,5,2,4,6,7,4,3]
 394         subConnIndex2=[0,5,9,14]
 395         self.assertEqual(14,subMesh.getNodalConnectivity().getNbOfElems());
 396         self.assertEqual(4,subMesh.getNodalConnectivityIndex().getNbOfElems());
 397         self.assertEqual(subConn2[0:14],list(subMesh.getNodalConnectivity().getValues()));
 398         self.assertEqual(subConnIndex2[0:4],list(subMesh.getNodalConnectivityIndex().getValues()));
 399         dd=DataArrayInt.New()
 400         dd.alloc(3,1)
 401         dd.iota(0)
 402         dd.setName("coucou")
 403         subMesh=subMesh.buildPartOfMySelf(dd,True);
 404         self.assertEqual("coucou",subMesh.getName());
 405         pass
 406
 407     def testBuildPartOfMySelfNode(self):
 408         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
 409         tab1=[5,7,8,4]
 410         subMesh=mesh.buildPartOfMySelfNode(tab1[0:4],True);
 411         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
 412         self.assertEqual(1,len(subMesh.getAllTypes()));
 413         self.assertEqual(NORM_QUAD4,subMesh.getAllTypes()[0]);
 414         self.assertEqual(1,subMesh.getNumberOfCells());
 415         self.assertEqual(5,subMesh.getNodalConnectivity().getNbOfElems());
 416         self.assertEqual(2,subMesh.getNodalConnectivityIndex().getNbOfElems());
 417         subConn=[4,7,8,5,4]
 418         subConnIndex=[0,5]
 419         self.assertEqual(subConn[0:5],list(subMesh.getNodalConnectivity().getValues()));
 420         self.assertEqual(subConnIndex[0:2],list(subMesh.getNodalConnectivityIndex().getValues()));
 421         #
 422         ddd=DataArrayInt.New()
 423         ddd.setValues(tab1[0:2],2,1)
 424         ddd.setName("ddd")
 425         subMesh=mesh.buildPartOfMySelfNode(ddd,False);
 426         self.assertEqual("ddd",subMesh.getName())
 427         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
 428         self.assertEqual(2,len(subMesh.getAllTypes()));
 429         self.assertEqual(NORM_TRI3,subMesh.getAllTypes()[0]);
 430         self.assertEqual(NORM_QUAD4,subMesh.getAllTypes()[1]);
 431         self.assertEqual(3,subMesh.getNumberOfCells());
 432         self.assertEqual(14,subMesh.getNodalConnectivity().getNbOfElems());
 433         self.assertEqual(4,subMesh.getNodalConnectivityIndex().getNbOfElems());
 434         subConn2=[3,4,5,2,4,6,7,4,3,4,7,8,5,4]
 435         subConnIndex2=[0,4,9,14]
 436         self.assertEqual(subConn2[0:14],list(subMesh.getNodalConnectivity().getValues()));
 437         self.assertEqual(subConnIndex2[0:4],list(subMesh.getNodalConnectivityIndex().getValues()));
 438         #testing the case where length of tab2 is greater than max number of node per cell.
 439         tab2=[0,3,2,1,4,5,6]
 440         subMesh=mesh.buildPartOfMySelfNode(tab2[0:7],True);
 441         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
 442         self.assertEqual(2,len(subMesh.getAllTypes()));
 443         self.assertEqual(NORM_TRI3,subMesh.getAllTypes()[0]);
 444         self.assertEqual(NORM_QUAD4,subMesh.getAllTypes()[1]);
 445         self.assertEqual(3,subMesh.getNumberOfCells());
 446         pass
 447
 448     def testZipCoords(self):
 449         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
 450         self.assertEqual(2,len(mesh.getAllTypes()));
 451         self.assertEqual(2,mesh.getSpaceDimension());
 452         self.assertEqual(9,mesh.getNumberOfNodes());
 453         self.assertEqual(5,mesh.getNumberOfCells());
 454         oldConn=mesh.getNodalConnectivity().getValues()[0:mesh.getNodalConnectivity().getNbOfElems()];
 455         oldConnIndex=mesh.getNodalConnectivityIndex().getValues()[0:mesh.getNumberOfCells()+1]
 456         oldCoords=mesh.getCoords();
 457         mesh.zipCoords();
 458         self.assertEqual(2,len(mesh.getAllTypes()));
 459         self.assertEqual(2,mesh.getSpaceDimension());
 460         self.assertEqual(9,mesh.getNumberOfNodes());
 461         self.assertEqual(5,mesh.getNumberOfCells());
 462         self.assertEqual(mesh.getCoords().getValues()[0:2*9],oldCoords.getValues());
 463         self.assertEqual(list(oldConn),list(mesh.getNodalConnectivity().getValues()));
 464         self.assertEqual(list(oldConnIndex),list(mesh.getNodalConnectivityIndex().getValues()));
 465         #
 466         tab1=[0,4]
 467         subMesh=mesh.buildPartOfMySelf(tab1,True);
 468         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
 469         traducer=subMesh.zipCoordsTraducer();
 470         expectedTraducer=[0, 1, -1, 2, 3, 4, -1, 5, 6]
 471         self.assertEqual(expectedTraducer,list(traducer.getValues()));
 472         self.assertEqual(NORM_QUAD4,subMesh.getAllTypes()[0]);
 473         self.assertEqual(2,subMesh.getNumberOfCells());
 474         subConn=[4,0,2,3,1,4,5,6,4,3]
 475         subConnIndex=[0,5,10]
 476         self.assertEqual(7,subMesh.getNumberOfNodes());
 477         self.assertEqual(10,subMesh.getNodalConnectivity().getNbOfElems());
 478         self.assertEqual(3,subMesh.getNodalConnectivityIndex().getNbOfElems());
 479         self.assertEqual(subConn,list(subMesh.getNodalConnectivity().getValues()));
 480         self.assertEqual(subConnIndex,list(subMesh.getNodalConnectivityIndex().getValues()));
 481         #
 482         subMesh=mesh.buildPartOfMySelf(tab1,False);
 483         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
 484         self.assertEqual(NORM_QUAD4,subMesh.getAllTypes()[0]);
 485         self.assertEqual(2,subMesh.getNumberOfCells());
 486         self.assertEqual(7,subMesh.getNumberOfNodes());
 487         self.assertEqual(10,subMesh.getNodalConnectivity().getNbOfElems());
 488         self.assertEqual(3,subMesh.getNodalConnectivityIndex().getNbOfElems());
 489         self.assertEqual(subConn,list(subMesh.getNodalConnectivity().getValues()));
 490         self.assertEqual(subConnIndex,list(subMesh.getNodalConnectivityIndex().getValues()));
 491         pass
 492
 493     def testZipConnectivity(self):
 494         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
 495         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
 496         cells1=[2,3,4]
 497         m3=m2.buildPartOfMySelf(cells1,True);
 498         self.assertTrue(isinstance(m3,MEDCouplingUMesh))
 499         m4=MEDCouplingDataForTest.build2DSourceMesh_1();
 500         m5=MEDCouplingUMesh.MergeUMeshes(m1,m3);
 501         m6=MEDCouplingUMesh.MergeUMeshes(m5,m4);
 502         #
 503         self.assertEqual(10,m6.getNumberOfCells());
 504         self.assertEqual(22,m6.getNumberOfNodes());
 505         (arr,areNodesMerged,newNbOfNodes)=m6.mergeNodes(1e-13);
 506         self.assertTrue(areNodesMerged);
 507         self.assertEqual(10,m6.getNumberOfCells());
 508         self.assertEqual(9,m6.getNumberOfNodes());
 509         #
 510         arr=m6.zipConnectivityTraducer(0);
 511         self.assertEqual(7,m6.getNumberOfCells());
 512         m7=m6.clone(True);
 513         arr=m6.zipConnectivityTraducer(0);
 514         self.assertTrue(m7.isEqual(m6,1e-12));
 515         self.assertEqual(7,m6.getNumberOfCells());
 516         pass
 517
 518     def testEqualMesh(self):
 519         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
 520         mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
 521         #
 522         self.assertTrue(mesh1.isEqual(mesh1,1e-12));
 523         #
 524         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
 525         self.assertTrue(mesh2.isEqual(mesh1,1e-12));
 526         pt=mesh2.getCoords().getValues();
 527         tmp=pt[1]
 528         mesh2.getCoords().setIJ(0,1,5.999);
 529         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
 530         self.assertTrue(not mesh2.isEqual(mesh1,1e-12));
 531         mesh2.getCoords().setIJ(0,1,tmp);
 532         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
 533         self.assertTrue(mesh2.isEqual(mesh1,1e-12));
 534         #
 535         pt2=mesh1.getNodalConnectivity().getValues();
 536         mesh1.getNodalConnectivity().setIJ(5,0,int(pt2[5])+1);
 537         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
 538         self.assertTrue(not mesh2.isEqual(mesh1,1e-12));
 539         mesh1.getNodalConnectivity().setIJ(5,0,int(pt2[5]));
 540         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
 541         self.assertTrue(mesh2.isEqual(mesh1,1e-12));
 542         #
 543         pt2=mesh1.getNodalConnectivityIndex().getValues();
 544         mesh1.getNodalConnectivityIndex().setIJ(1,0,int(pt2[1]+1));
 545         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
 546         self.assertTrue(not mesh2.isEqual(mesh1,1e-12));
 547         mesh1.getNodalConnectivityIndex().setIJ(1,0,int(pt2[1]));
 548         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
 549         self.assertTrue(mesh2.isEqual(mesh1,1e-12));
 550         #
 551         tmp3=mesh1.getName();
 552         mesh1.setName("lllll");
 553         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
 554         self.assertTrue(not mesh2.isEqual(mesh1,1e-12));
 555         mesh1.setName(tmp3);
 556         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
 557         self.assertTrue(mesh2.isEqual(mesh1,1e-12));
 558         #
 559         tmp3=mesh2.getCoords().getInfoOnComponent(1);
 560         mesh2.getCoords().setInfoOnComponent(1,"kkkkkk");
 561         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
 562         self.assertTrue(not mesh2.isEqual(mesh1,1e-12));
 563         mesh2.getCoords().setInfoOnComponent(1,tmp3);
 564         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
 565         self.assertTrue(mesh2.isEqual(mesh1,1e-12));
 566         pass
 567
 568     def testEqualFieldDouble(self):
 569         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
 570         mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
 571         #
 572         fieldOnCells1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
 573         fieldOnCells1.setMesh(mesh1);
 574         fieldOnCells2=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
 575         fieldOnCells2.setMesh(mesh2);
 576         #
 577         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 578         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 579         #
 580         fieldOnNodes1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
 581         self.assertTrue(not fieldOnCells1.isEqual(fieldOnNodes1,1e-12,1e-15));
 582         self.assertTrue(not fieldOnNodes1.isEqual(fieldOnCells1,1e-12,1e-15));
 583         #
 584         fieldOnCells2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
 585         self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 586         self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 587         fieldOnCells1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
 588         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 589         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 590         fieldOnCells1.setTime(4.,6,7);
 591         self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 592         self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 593         fieldOnCells2.setTime(4.,6,7);
 594         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 595         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 596         fieldOnCells1.setName("Power");
 597         self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 598         self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 599         fieldOnCells2.setName("Power");
 600         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 601         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 602         #
 603         fieldOnCells1.setMesh(mesh1);
 604         self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 605         self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 606         fieldOnCells2.setMesh(mesh1);
 607         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 608         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 609         arr=DataArrayDouble.New();
 610         arr.setName("popo");
 611         arr.setValues(mesh1.getNumberOfCells()*3*[6.],mesh1.getNumberOfCells(),3);
 612         fieldOnCells1.setArray(arr);
 613         self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 614         self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 615         fieldOnCells2.setArray(arr);
 616         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 617         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 618         #
 619         arr2=arr.deepCpy();
 620         fieldOnCells2.setArray(arr2);
 621         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 622         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 623         arr.setIJ(1,2,6.1);
 624         self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 625         self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 626         arr.setIJ(1,2,6.);
 627         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 628         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 629         arr2.setName("popo2");
 630         self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 631         self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 632         #
 633         arr2.setName("popo");
 634         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 635         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 636         #
 637         arr2.setInfoOnComponent(2,"jjj");
 638         self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 639         self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 640         arr.setInfoOnComponent(2,"jjj");
 641         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 642         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 643         pass
 644
 645     def testNatureChecking(self):
 646         field=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
 647         field.setNature(Integral);
 648         field.setNature(ConservativeVolumic);
 649         field.setNature(IntegralGlobConstraint);
 650         field=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
 651         field.setNature(ConservativeVolumic);
 652         self.assertRaises(InterpKernelException,field.setNature,Integral);
 653         self.assertRaises(InterpKernelException,field.setNature,IntegralGlobConstraint);
 654         pass
 655
 656     def testBuildSubMeshData(self):
 657         targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1()
 658         #check buildSubMesh on field on cells
 659         fieldCells=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
 660         fieldCells.setMesh(targetMesh);
 661         elts=[1,2,4]
 662         ret1,di=fieldCells.buildSubMeshData(elts);
 663         self.assertTrue(isinstance(ret1,MEDCouplingUMesh))
 664         self.assertEqual(3,ret1.getNumberOfCells());
 665         self.assertEqual(9,ret1.getNumberOfNodes());
 666         self.assertEqual(3,di.getNumberOfTuples());
 667         self.assertEqual(1,di.getNumberOfComponents());
 668         toCheck=di.getValues();
 669         self.assertTrue(elts,toCheck);
 670         #check buildSubMesh on field on nodes
 671         fieldNodes=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
 672         fieldNodes.setMesh(targetMesh);
 673         ret2,di=fieldNodes.buildSubMeshData(elts);
 674         self.assertTrue(isinstance(ret2,MEDCouplingUMesh))
 675         self.assertEqual(3,ret2.getNumberOfCells());
 676         self.assertEqual(6,ret2.getNumberOfNodes());
 677         self.assertEqual(6,di.getNumberOfTuples());
 678         self.assertEqual(1,di.getNumberOfComponents());
 679         toCheck=di.getValues();
 680         expected=[1,2,4,5,7,8]
 681         self.assertEqual(expected,list(toCheck));
 682         pass
 683
 684     def testExtrudedMesh1(self):
 685         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
 686         ext=MEDCouplingExtrudedMesh.New(mesh3D,mesh2D,1);
 687         self.assertEqual(18,ext.getNumberOfCells());
 688         self.assertEqual(60,ext.getNumberOfNodes());
 689         ids3D=ext.getMesh3DIds();
 690         ids3DExpected=[5,4,3,2,1,0, 11,10,9,8,7,6, 17,16,15,14,13,12]
 691         self.assertEqual(18,ids3D.getNumberOfTuples());
 692         self.assertEqual(1,ids3D.getNumberOfComponents());
 693         self.assertEqual(ids3DExpected,list(ids3D.getValues()));
 694         mesh1D=ext.getMesh1D();
 695         self.assertEqual(4,mesh1D.getNumberOfNodes());
 696         self.assertEqual(3,mesh1D.getNumberOfCells());
 697         mesh1DExpected=[0.66666666666666663, 1.4583333333333333, 0, 0.66666666666666663,
 698                         1.4583333333333333, 1, 0.66666666666666663, 1.4583333333333333,
 699                         2, 0.66666666666666663, 1.4583333333333333, 3]
 700         mesh1DCoords=mesh1D.getCoords();
 701         self.assertEqual(4,mesh1DCoords.getNumberOfTuples());
 702         self.assertEqual(3,mesh1DCoords.getNumberOfComponents());
 703         self.assertEqual(mesh1DExpected,mesh1DCoords.getValues());
 704         conn1D=mesh1D.getNodalConnectivity();
 705         self.assertEqual(9,conn1D.getNumberOfTuples());
 706         self.assertEqual(1,conn1D.getNumberOfComponents());
 707         conn1DExpected=[1,0,1,1,1,2,1,2,3]
 708         self.assertEqual(conn1DExpected,list(conn1D.getValues()));
 709         pass
 710
 711     def testExtrudedMesh3(self):
 712         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
 713         m1.changeSpaceDimension(3);
 714         m2=MEDCouplingDataForTest.buildCU1DMesh_U();
 715         m2.changeSpaceDimension(3);
 716         center=[0.,0.,0.]
 717         vector=[0.,1.,0.]
 718         m2.rotate(center,vector,-pi/2.);
 719         m3=m1.buildExtrudedMesh(m2,0);
 720         #
 721         m4=MEDCouplingExtrudedMesh.New(m3,m1,0);
 722         self.assertEqual(15,m4.getNumberOfCells());
 723         self.assertEqual(5,m4.getMesh2D().getNumberOfCells());
 724         self.assertEqual(3,m4.getMesh1D().getNumberOfCells());
 725         m3DIds=m4.getMesh3DIds().getValues();
 726         self.assertEqual(range(15),list(m3DIds));
 727         #some random in cells to check that extrusion alg find it correctly
 728         expected1=[1,3,2,0,6,5,7,10,11,8,12,9,14,13,4]
 729         m3.renumberCells(expected1,False);
 730         m4=MEDCouplingExtrudedMesh.New(m3,m1,0);
 731         self.assertEqual(15,m4.getNumberOfCells());
 732         self.assertEqual(5,m4.getMesh2D().getNumberOfCells());
 733         self.assertEqual(3,m4.getMesh1D().getNumberOfCells());
 734         m3DIds=m4.getMesh3DIds().getValues();
 735         self.assertEqual(expected1,list(m3DIds));
 736         #play with polygons and polyedrons
 737         cells=[2,3]
 738         m1.convertToPolyTypes(cells);
 739         m3=m1.buildExtrudedMesh(m2,0);
 740         self.assertEqual(NORM_HEXA8,m3.getTypeOfCell(0));
 741         self.assertEqual(NORM_PENTA6,m3.getTypeOfCell(1));
 742         self.assertEqual(NORM_POLYHED,m3.getTypeOfCell(2));
 743         self.assertEqual(NORM_POLYHED,m3.getTypeOfCell(3));
 744         self.assertEqual(NORM_HEXA8,m3.getTypeOfCell(4));
 745         m3.renumberCells(expected1,False);
 746         m4=MEDCouplingExtrudedMesh.New(m3,m1,0);
 747         self.assertEqual(15,m4.getNumberOfCells());
 748         self.assertEqual(5,m4.getMesh2D().getNumberOfCells());
 749         self.assertEqual(3,m4.getMesh1D().getNumberOfCells());
 750         m3DIds=m4.getMesh3DIds().getValues();
 751         self.assertEqual(expected1,list(m3DIds));
 752         pass
 753
 754     def testExtrudedMesh4(self):
 755         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
 756         cells=[2,4];
 757         m1.convertToPolyTypes(cells);
 758         m1.changeSpaceDimension(3);
 759         m2=MEDCouplingDataForTest.buildCU1DMesh_U();
 760         m2.changeSpaceDimension(3);
 761         center=[0.,0.,0.]
 762         vector=[0.,1.,0.]
 763         m2.rotate(center,vector,-pi/2.);
 764         m3=m1.buildExtrudedMesh(m2,0);
 765         expected1=[1,3,2,0,6,5,7,10,11,8,12,9,14,13,4]
 766         rexpected1=[3, 0, 2, 1, 14, 5, 4, 6, 9, 11, 7, 8, 10, 13, 12]
 767         m3.renumberCells(expected1,False);
 768         m4=MEDCouplingExtrudedMesh.New(m3,m1,0);
 769         self.assertEqual(NORM_HEXA8,m4.getTypeOfCell(0));
 770         self.assertEqual(NORM_HEXA8,m4.getTypeOfCell(1));
 771         self.assertEqual(NORM_POLYHED,m4.getTypeOfCell(2));
 772         self.assertEqual(NORM_PENTA6,m4.getTypeOfCell(7));
 773         f=m4.getMeasureField(True);
 774         arr=f.getArray();
 775         self.assertEqual(15,arr.getNumberOfTuples());
 776         self.assertEqual(1,arr.getNumberOfComponents());
 777         arrPtr=arr.getValues();
 778         expected2=[0.075,0.0375,0.0375,0.075,0.075,
 779                    0.1125,0.05625,0.05625,0.1125,0.1125,
 780                    0.0625,0.03125,0.03125,0.0625,0.0625]
 781         for i in xrange(15):
 782             self.assertAlmostEqual(expected2[rexpected1[i]],arrPtr[i],16);
 783             pass
 784         m5=m4.build3DUnstructuredMesh();
 785         self.assertTrue(m5.isEqual(m3,1e-12));
 786         f=m5.getMeasureField(True);
 787         f.setMesh(m4)
 788         self.assertTrue(isinstance(f.getMesh(),MEDCouplingExtrudedMesh))
 789         arr=f.getArray();
 790         arrPtr=arr.getValues();
 791         for i in xrange(15):
 792             self.assertAlmostEqual(expected2[rexpected1[i]],arrPtr[i],15);
 793             pass
 794         pass
 795
 796     def testFindCommonNodes(self):
 797         targetMesh=MEDCouplingDataForTest.build3DTargetMesh_1();
 798         comm,commI=targetMesh.findCommonNodes(1e-10,-1);
 799         self.assertEqual(1,commI.getNumberOfTuples());
 800         self.assertEqual(0,comm.getNumberOfTuples());
 801         o2n,newNbOfNodes=targetMesh.buildNewNumberingFromCommonNodesFormat(comm,commI);
 802         self.assertEqual(27,newNbOfNodes);
 803         self.assertEqual(27,o2n.getNumberOfTuples());
 804         o2nExp1=range(27)
 805         self.assertEqual(o2nExp1,list(o2n.getValues()));
 806         #
 807         targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
 808         self.assertEqual(31,targetMesh.getNumberOfNodes());
 809         comm,commI=targetMesh.findCommonNodes(1e-10);# testing default parameter
 810         self.assertEqual(3,commI.getNumberOfTuples());
 811         self.assertEqual(6,comm.getNumberOfTuples());
 812         commExpected=[1,27,28,29,23,30]
 813         commIExpected=[0,4,6]
 814         self.assertEqual(commExpected,list(comm.getValues()));
 815         self.assertEqual(commIExpected,list(commI.getValues()));
 816         o2n,newNbOfNodes=targetMesh.buildNewNumberingFromCommonNodesFormat(comm,commI);
 817         self.assertEqual(31,o2n.getNumberOfTuples());
 818         self.assertEqual(27,newNbOfNodes);
 819         o2nExp2=[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,
 820                  21,22,23,24,25,26,1,1,1,23]
 821         self.assertEqual(o2nExp2,list(o2n.getValues()));
 822         #
 823         targetMesh=MEDCouplingDataForTest.build3DTargetMesh_1();
 824         time=targetMesh.getTimeOfThis();
 825         o2n,areNodesMerged,newNbOfNodes=targetMesh.mergeNodes(1e-10);
 826         targetMesh.updateTime();
 827         self.assertEqual(time,targetMesh.getTimeOfThis());
 828         self.assertTrue(not areNodesMerged);
 829         #
 830         targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
 831         time=targetMesh.getTimeOfThis();
 832         o2n,areNodesMerged,newNbOfNodes=targetMesh.mergeNodes(1e-10);
 833         targetMesh.updateTime();
 834         self.assertTrue(time!=targetMesh.getTimeOfThis());
 835         self.assertTrue(areNodesMerged);
 836         connExp=[18,0,1,4,3,9,10,13,12, 18,1,2,5,4,10,11,14,13, 18,3,4,7,6,12,13,16,15,
 837                  18,4,5,8,7,13,14,17,16,
 838                  18,9,10,13,12,18,19,22,21, 18,10,11,14,13,19,20,23,22, 18,12,13,16,15,21,22,25,24,
 839                  18,13,14,17,16,22,23,26,25]
 840         self.assertEqual(72,targetMesh.getNodalConnectivity().getNumberOfTuples());
 841         self.assertEqual(connExp,list(targetMesh.getNodalConnectivity().getValues()));
 842         self.assertEqual(27,targetMesh.getCoords().getNumberOfTuples());
 843         coordsExp=[ 0., 0., 0., 50., 0., 0. , 200., 0., 0.  , 0., 50., 0., 50., 50., 0. ,
 844                     200., 50., 0.,   0., 200., 0., 50., 200., 0. , 200., 200., 0. ,
 845                     0., 0., 50., 50., 0., 50. , 200., 0., 50.  , 0., 50., 50., 50.,
 846                     50., 50. , 200., 50., 50.,   0., 200., 50., 50., 200., 50. ,
 847                     200., 200., 50. , 0., 0., 200., 50., 0., 200. , 200., 0., 200.
 848                     , 0., 50., 200., 50., 50., 200. , 200., 50., 200.,
 849                     0., 200., 200., 50., 200., 200. , 200., 200., 200. ]
 850         self.assertEqual(coordsExp,targetMesh.getCoords().getValues());
 851         # 2D
 852         targetMesh=MEDCouplingDataForTest.build2DTargetMeshMergeNode_1();
 853         self.assertEqual(18,targetMesh.getNumberOfNodes());
 854         time=targetMesh.getTimeOfThis();
 855         o2n,areNodesMerged,newNbOfNodes=targetMesh.mergeNodes(1e-10);
 856         self.assertTrue(time!=targetMesh.getTimeOfThis());
 857         self.assertTrue(areNodesMerged);
 858         self.assertEqual(9,targetMesh.getNumberOfNodes());
 859         connExp2=[4,0,4,3,1, 3,1,3,2, 3,3,5,2, 4,4,6,7,3, 4,7,8,5,3]
 860         self.assertEqual(23,targetMesh.getNodalConnectivity().getNumberOfTuples());
 861         self.assertEqual(connExp2,list(targetMesh.getNodalConnectivity().getValues()));
 862         coordsExp2=[-0.3,-0.3, 0.2,-0.3, 0.7,-0.3, 0.2,0.2, -0.3,0.2, 0.7,0.2, -0.3,0.7, 0.2,0.7, 0.7,0.7]
 863         self.assertEqual(9,targetMesh.getCoords().getNumberOfTuples());
 864         self.assertEqual(coordsExp2,targetMesh.getCoords().getValues());
 865         pass
 866
 867     def testCheckButterflyCells(self):
 868         sourceMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
 869         cells=sourceMesh.checkButterflyCells();
 870         self.assertEqual(0,len(cells));
 871         conn=sourceMesh.getNodalConnectivity()
 872         tmp=conn.getIJ(15,0)
 873         conn.setIJ(15,0,conn.getIJ(16,0))
 874         conn.setIJ(16,0,tmp)
 875         cells=sourceMesh.checkButterflyCells();
 876         self.assertEqual(1,len(cells));
 877         self.assertEqual([3],cells.getValues());
 878         tmp=conn.getIJ(15,0)
 879         conn.setIJ(15,0,conn.getIJ(16,0))
 880         conn.setIJ(16,0,tmp)
 881         cells=sourceMesh.checkButterflyCells();
 882         self.assertEqual(0,len(cells));
 883         # 3D surf
 884         sourceMesh=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
 885         cells=sourceMesh.checkButterflyCells();
 886         self.assertEqual(0,len(cells));
 887         conn=sourceMesh.getNodalConnectivity()
 888         tmp=conn.getIJ(15,0)
 889         conn.setIJ(15,0,conn.getIJ(16,0))
 890         conn.setIJ(16,0,tmp)
 891         cells=sourceMesh.checkButterflyCells();
 892         self.assertEqual(1,len(cells));
 893         self.assertEqual([3],cells.getValues());
 894         tmp=conn.getIJ(15,0)
 895         conn.setIJ(15,0,conn.getIJ(16,0))
 896         conn.setIJ(16,0,tmp)
 897         cells=sourceMesh.checkButterflyCells();
 898         self.assertEqual(0,len(cells));
 899         pass
 900
 901     def testMergeMesh1(self):
 902         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
 903         m2=MEDCouplingDataForTest.build2DSourceMesh_1();
 904         vec=[1.,0.]
 905         m2.translate(vec);
 906         m3=m1.mergeMyselfWith(m2);
 907         self.assertTrue(isinstance(m3,MEDCouplingUMesh));
 908         m3.checkCoherency();
 909         m4=MEDCouplingDataForTest.build2DTargetMeshMerged_1();
 910         self.assertTrue(m3.isEqual(m4,1.e-12));
 911         da,isMerged,newNbOfNodes=m3.mergeNodes(1.e-12);
 912         self.assertEqual(11,m3.getNumberOfNodes());
 913         self.assertTrue(isMerged);
 914         pass
 915
 916     def testMergeMeshOnSameCoords1(self):
 917         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
 918         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
 919         cells=range(5);
 920         m2.convertToPolyTypes(cells);
 921         m1.tryToShareSameCoords(m2,1e-12);
 922         m3=MEDCouplingDataForTest.build2DTargetMesh_1();
 923         m3.tryToShareSameCoords(m2,1e-12);
 924         meshes=[m1,m2,m3]
 925         m4=MEDCouplingUMesh.MergeUMeshesOnSameCoords(meshes);
 926         m4.checkCoherency();
 927         self.assertEqual(15,m4.getNumberOfCells());
 928         cells1=[0,1,2,3,4]
 929         m1_1=m4.buildPartOfMySelf(cells1,True);
 930         m1_1.setName(m1.getName());
 931         self.assertTrue(m1.isEqual(m1_1,1e-12));
 932         cells2=[5,6,7,8,9]
 933         m2_1=m4.buildPartOfMySelf(cells2,True);
 934         m2_1.setName(m2.getName());
 935         self.assertTrue(m2.isEqual(m2_1,1e-12));
 936         cells3=[10,11,12,13,14]
 937         m3_1=m4.buildPartOfMySelf(cells3,True);
 938         m3_1.setName(m3.getName());
 939         self.assertTrue(m3.isEqual(m3_1,1e-12));
 940         pass
 941
 942     def testMergeField1(self):
 943         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
 944         m2=MEDCouplingDataForTest.build2DSourceMesh_1();
 945         vec=[1.,0.]
 946         m2.translate(vec);
 947         f1=m1.getMeasureField(True);
 948         f2=m2.getMeasureField(True);
 949         f3=MEDCouplingFieldDouble.MergeFields(f1,f2);
 950         f3.checkCoherency();
 951         m4=MEDCouplingDataForTest.build2DTargetMeshMerged_1();
 952         self.assertTrue(f3.getMesh().isEqual(m4,1.e-12));
 953         name=f3.getName();
 954         self.assertEqual(name,"MeasureOfMesh_");
 955         self.assertEqual(f3.getTypeOfField(),ON_CELLS);
 956         self.assertEqual(f3.getTimeDiscretization(),ONE_TIME);
 957         self.assertEqual(1,f3.getNumberOfComponents());
 958         self.assertEqual(7,f3.getNumberOfTuples());
 959         values=[0.25,0.125,0.125,0.25,0.25,0.5,0.5]
 960         tmp=f3.getArray().getValues();
 961         self.assertEqual(len(values),len(tmp))
 962         for i in xrange(7):
 963             self.assertTrue(abs(values[i]-tmp[i])<1e-12)
 964             pass
 965         pass
 966
 967     def testFillFromAnalytic(self):
 968         m=MEDCouplingDataForTest.build2DTargetMesh_1();
 969         m.setTime(3.4,5,6); m.setTimeUnit("us");
 970         f1=m.fillFromAnalytic(ON_CELLS,1,"x+y");
 971         self.assertAlmostEqual(3.4,f1.getTime()[0],12) ; self.assertEqual(5,f1.getTime()[1]) ; self.assertEqual(6,f1.getTime()[2])
 972         self.assertEqual("us",f1.getTimeUnit())
 973         f1.checkCoherency();
 974         self.assertEqual(f1.getTypeOfField(),ON_CELLS);
 975         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
 976         self.assertEqual(1,f1.getNumberOfComponents());
 977         self.assertEqual(5,f1.getNumberOfTuples());
 978         values1=[-0.1,0.23333333333333336,0.56666666666666665,0.4,0.9]
 979         tmp=f1.getArray().getValues();
 980         self.assertEqual(len(values1),len(tmp))
 981         for i in xrange(len(tmp)):
 982             self.assertTrue(abs(tmp[i]-values1[i])<1.e-12)
 983             pass
 984         #
 985         f1=m.fillFromAnalytic(ON_NODES,1,"x+y");
 986         f1.checkCoherency();
 987         self.assertEqual(f1.getTypeOfField(),ON_NODES);
 988         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
 989         self.assertEqual(1,f1.getNumberOfComponents());
 990         self.assertEqual(9,f1.getNumberOfTuples());
 991         values2=[-0.6,-0.1,0.4,-0.1,0.4,0.9,0.4,0.9,1.4]
 992         tmp=f1.getArray().getValues();
 993         self.assertEqual(len(values2),len(tmp))
 994         for i in xrange(len(tmp)):
 995             self.assertTrue(abs(tmp[i]-values2[i])<1.e-12)
 996             pass
 997         #
 998         f1=m.fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+(2*(x+y))*JVec");
 999         f1.checkCoherency();
1000         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1001         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1002         self.assertEqual(2,f1.getNumberOfComponents());
1003         self.assertEqual(9,f1.getNumberOfTuples());
1004         values3=[-0.6,-1.2,-0.1,-0.2,0.4,0.8,-0.1,-0.2,0.4,0.8,0.9,1.8,0.4,0.8,0.9,1.8,1.4,2.8]
1005         tmp=f1.getArray().getValues();
1006         self.assertEqual(len(values3),len(tmp))
1007         for i in xrange(len(tmp)):
1008             self.assertTrue(abs(tmp[i]-values3[i])<1.e-12)
1009             pass
1010         values4=f1.accumulate();
1011         self.assertEqual(2,len(values4))
1012         self.assertTrue(abs(3.6-values4[0])<1.e-12);
1013         self.assertTrue(abs(7.2-values4[1])<1.e-12);
1014         values4=f1.integral(True);
1015         self.assertEqual(2,len(values4))
1016         self.assertTrue(abs(0.5-values4[0])<1.e-12);
1017         self.assertTrue(abs(1.-values4[1])<1.e-12);
1018         #
1019         self.assertRaises(InterpKernelException,m.fillFromAnalytic,ON_NODES,1,"1./(x-0.2)");
1020         pass
1021
1022     def testFillFromAnalytic2(self):
1023         m=MEDCouplingDataForTest.build2DTargetMesh_1();
1024         f1=m.fillFromAnalytic(ON_CELLS,1,"y+x");
1025         f1.checkCoherency();
1026         self.assertEqual(f1.getTypeOfField(),ON_CELLS);
1027         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1028         self.assertEqual(1,f1.getNumberOfComponents());
1029         self.assertEqual(5,f1.getNumberOfTuples());
1030         values1=[-0.1,0.23333333333333336,0.56666666666666665,0.4,0.9]
1031         tmp=f1.getArray().getValues();
1032         self.assertEqual(len(values1),len(tmp))
1033         for i in xrange(len(values1)):
1034             self.assertTrue(abs(values1[i]-tmp[i])<1.e-12);
1035             pass
1036         #
1037         f1=m.fillFromAnalytic(ON_NODES,1,"y+2*x");
1038         f1.checkCoherency();
1039         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1040         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1041         self.assertEqual(1,f1.getNumberOfComponents());
1042         self.assertEqual(9,f1.getNumberOfTuples());
1043         values2=[-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1]
1044         tmp=f1.getArray().getValues();
1045         self.assertEqual(len(values2),len(tmp))
1046         for i in xrange(len(values2)):
1047             self.assertTrue(abs(values2[i]-tmp[i])<1.e-12);
1048             pass
1049         f1=m.fillFromAnalytic(ON_NODES,1,"2.*x+y");
1050         f1.checkCoherency();
1051         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1052         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1053         self.assertEqual(1,f1.getNumberOfComponents());
1054         self.assertEqual(9,f1.getNumberOfTuples());
1055         tmp=f1.getArray().getValues();
1056         values2Bis=[-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1]
1057         self.assertEqual(len(values2Bis),len(tmp))
1058         for i in xrange(len(values2Bis)):
1059             self.assertTrue(abs(values2Bis[i]-tmp[i])<1.e-12);
1060             pass
1061         #
1062         f1=m.fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+2*(x+y)*JVec");
1063         f1.checkCoherency();
1064         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1065         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1066         self.assertEqual(2,f1.getNumberOfComponents());
1067         self.assertEqual(9,f1.getNumberOfTuples());
1068         values3=[-0.6,-1.2,-0.1,-0.2,0.4,0.8,-0.1,-0.2,0.4,0.8,0.9,1.8,0.4,0.8,0.9,1.8,1.4,2.8]
1069         tmp=f1.getArray().getValues();
1070         self.assertEqual(len(values3),len(tmp))
1071         for i in xrange(len(values3)):
1072             self.assertTrue(abs(values3[i]-tmp[i])<1.e-12);
1073             pass
1074         values4=f1.accumulate();
1075         self.assertTrue(abs(3.6-values4[0])<1.e-12);
1076         self.assertTrue(abs(7.2-values4[1])<1.e-12);
1077         values4=f1.integral(True);
1078         self.assertTrue(abs(0.5-values4[0])<1.e-12);
1079         self.assertTrue(abs(1.-values4[1])<1.e-12);
1080         pass
1081
1082     def testApplyFunc(self):
1083         m=MEDCouplingDataForTest.build2DTargetMesh_1();
1084         f1=m.fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+(2*(x+y))*JVec");
1085         f1.checkCoherency();
1086         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1087         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1088         self.assertEqual(2,f1.getNumberOfComponents());
1089         self.assertEqual(9,f1.getNumberOfTuples());
1090         f1.applyFunc(1,"x+y");
1091         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1092         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1093         self.assertEqual(1,f1.getNumberOfComponents());
1094         self.assertEqual(9,f1.getNumberOfTuples());
1095         values1=[-1.8,-0.3,1.2,-0.3,1.2,2.7,1.2,2.7,4.2]
1096         tmp=f1.getArray().getValues();
1097         self.assertEqual(len(values1),len(tmp))
1098         for i in xrange(len(tmp)):
1099             self.assertTrue(abs(tmp[i]-values1[i])<1.e-12)
1100             pass
1101         pass
1102
1103     def testApplyFunc2(self):
1104         m=MEDCouplingDataForTest.build2DTargetMesh_1();
1105         f1=m.fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+2*(x+y)*JVec");
1106         f1.checkCoherency();
1107         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1108         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1109         self.assertEqual(2,f1.getNumberOfComponents());
1110         self.assertEqual(9,f1.getNumberOfTuples());
1111         #
1112         f2=f1.clone(True);
1113         self.assertRaises(InterpKernelException, f2.applyFunc, 1, "a+b+c+d");
1114         self.assertRaises(InterpKernelException, f2.applyFunc, 1, "a/0");
1115         self.assertRaises(InterpKernelException, f2.applyFunc, "a/0");
1116         f2.applyFunc("abs(u)^2.4+2*u");
1117         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1118         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1119         self.assertEqual(2,f1.getNumberOfComponents());
1120         self.assertEqual(9,f1.getNumberOfTuples());
1121         values2=[-0.9065304805418678, -0.85105859001709905, -0.19601892829446504, -0.37898777756476987,
1122                  0.91090317490482353, 2.1853504664669781, -0.19601892829446504, -0.37898777756476987,
1123                  0.91090317490482353, 2.1853504664669781, 2.5765725275664879, 7.6987743736515295,
1124                  0.91090317490482353, 2.1853504664669781, 2.5765725275664879, 7.6987743736515295,
1125                  5.0423700574830965, 17.435300118916864]
1126         tmp=f2.getArray().getValues();
1127         self.assertEqual(len(tmp),len(values2))
1128         for i in xrange(len(tmp)):
1129             self.assertTrue(abs(tmp[i]-values2[i])<1.e-12)
1130             pass
1131         #
1132         f1.applyFunc(1,"x+y");
1133         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1134         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1135         self.assertEqual(1,f1.getNumberOfComponents());
1136         self.assertEqual(9,f1.getNumberOfTuples());
1137         values1=[-1.8,-0.3,1.2,-0.3,1.2,2.7,1.2,2.7,4.2]
1138         tmp=f1.getArray().getValues();
1139         self.assertEqual(len(tmp),len(values1))
1140         for i in xrange(len(tmp)):
1141             self.assertTrue(abs(tmp[i]-values1[i])<1.e-12)
1142             pass
1143         pass
1144
1145     def testOperationsOnFields(self):
1146         m=MEDCouplingDataForTest.build2DTargetMesh_1();
1147         f1=m.fillFromAnalytic(ON_NODES,1,"x+y");
1148         f2=m.fillFromAnalytic(ON_NODES,1,"x+y");
1149         f1.checkCoherency();
1150         f2.checkCoherency();
1151         f3=f1+f2;
1152         f3.checkCoherency();
1153         self.assertEqual(f3.getTypeOfField(),ON_NODES);
1154         self.assertEqual(f3.getTimeDiscretization(),ONE_TIME);
1155         values1=[-1.2,-0.2,0.8,-0.2,0.8,1.8,0.8,1.8,2.8]
1156         tmp=f3.getArray().getValues();
1157         self.assertEqual(len(values1),len(tmp))
1158         for i in xrange(len(tmp)):
1159             self.assertTrue(abs(tmp[i]-values1[i])<1.e-12)
1160             pass
1161         #
1162         f3=f1*f2;
1163         f3.checkCoherency();
1164         self.assertEqual(f3.getTypeOfField(),ON_NODES);
1165         self.assertEqual(f3.getTimeDiscretization(),ONE_TIME);
1166         values2=[0.36,0.01,0.16,0.01,0.16,0.81,0.16,0.81,1.96]
1167         tmp=f3.getArray().getValues();
1168         self.assertEqual(len(values2),len(tmp))
1169         for i in xrange(len(tmp)):
1170             self.assertTrue(abs(tmp[i]-values2[i])<1.e-12)
1171             pass
1172         #
1173         f3=f1+f2;
1174         f4=f1-f3;
1175         f4.checkCoherency();
1176         self.assertEqual(f4.getTypeOfField(),ON_NODES);
1177         self.assertEqual(f4.getTimeDiscretization(),ONE_TIME);
1178         values3=[0.6,0.1,-0.4,0.1,-0.4,-0.9,-0.4,-0.9,-1.4]
1179         tmp=f4.getArray().getValues();
1180         self.assertEqual(len(values3),len(tmp))
1181         for i in xrange(len(tmp)):
1182             self.assertTrue(abs(tmp[i]-values3[i])<1.e-12)
1183             pass
1184         #
1185         f3=f1+f2;
1186         f4=f3/f2;
1187         f4.checkCoherency();
1188         self.assertEqual(f4.getTypeOfField(),ON_NODES);
1189         self.assertEqual(f4.getTimeDiscretization(),ONE_TIME);
1190         tmp=f4.getArray().getValues();
1191         for i in xrange(len(tmp)):
1192             self.assertTrue(abs(tmp[i]-2.)<1.e-12)
1193             pass
1194         #
1195         f4=f2.buildNewTimeReprFromThis(NO_TIME,False);
1196         f4.checkCoherency();
1197         self.assertEqual(f4.getTypeOfField(),ON_NODES);
1198         self.assertEqual(f4.getTimeDiscretization(),NO_TIME);
1199         self.assertRaises(InterpKernelException,f1.__add__,f4);
1200         f5=f4.buildNewTimeReprFromThis(ONE_TIME,False);
1201         self.assertEqual(f5.getTypeOfField(),ON_NODES);
1202         self.assertEqual(f5.getTimeDiscretization(),ONE_TIME);
1203         f3=f1+f5;
1204         tmp=f3.getArray().getValues();
1205         values4=[-1.2,-0.2,0.8,-0.2,0.8,1.8,0.8,1.8,2.8]
1206         self.assertEqual(len(values3),len(tmp))
1207         for i in xrange(len(tmp)):
1208             self.assertTrue(abs(tmp[i]-values4[i])<1.e-12)
1209             pass
1210         #
1211         f4=f2.buildNewTimeReprFromThis(NO_TIME,True);
1212         f4.checkCoherency();
1213         self.assertEqual(f4.getTypeOfField(),ON_NODES);
1214         self.assertEqual(f4.getTimeDiscretization(),NO_TIME);
1215         self.assertRaises(InterpKernelException,f1.__add__,f4);
1216         f5=f4.buildNewTimeReprFromThis(ONE_TIME,True);
1217         self.assertEqual(f5.getTypeOfField(),ON_NODES);
1218         self.assertEqual(f5.getTimeDiscretization(),ONE_TIME);
1219         f3=f1+f5;
1220         tmp=f3.getArray().getValues();
1221         values5=[-1.2,-0.2,0.8,-0.2,0.8,1.8,0.8,1.8,2.8]
1222         self.assertEqual(len(values5),len(tmp))
1223         for i in xrange(len(tmp)):
1224             self.assertTrue(abs(tmp[i]-values5[i])<1.e-12)
1225             pass
1226         pass
1227
1228     def testOperationsOnFields2(self):
1229         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1230         m.setTime(3.4,5,6); m.setTimeUnit("us");
1231         f1=m.fillFromAnalytic(ON_NODES,1,"x+y+z");
1232         f2=m.fillFromAnalytic(ON_NODES,1,"a*a+b+c*c");
1233         f3=f1/f2;
1234         f3.checkCoherency();
1235         self.assertEqual(f3.getTypeOfField(),ON_NODES);
1236         self.assertEqual(f3.getTimeDiscretization(),ONE_TIME);
1237         expected1=[-2.4999999999999991, 1.2162162162162162, 0.77868852459016391,
1238                    0.7407407407407407, 1.129032258064516, 0.81632653061224492,
1239                    0.86538461538461531, 1.0919540229885056, 0.84302325581395343]
1240         self.assertEqual(1,f3.getNumberOfComponents());
1241         self.assertEqual(9,f3.getNumberOfTuples());
1242         val=f3.getArray().getValues();
1243         for i in xrange(9):
1244             self.assertTrue(abs(expected1[i]-val[i])<1.e-12);
1245         #
1246         f1=m.buildOrthogonalField();
1247         self.assertAlmostEqual(3.4,f1.getTime()[0],12) ; self.assertEqual(5,f1.getTime()[1]) ; self.assertEqual(6,f1.getTime()[2])
1248         self.assertEqual("us",f1.getTimeUnit())
1249         f2=m.fillFromAnalytic(ON_CELLS,1,"x");
1250         f3=f1*f2;
1251         expected2=[-0.035355339059327376,0.,0.035355339059327376, 0.2592724864350674,0.,-0.2592724864350674, 0.37712361663282529,0.,-0.37712361663282529, -0.035355339059327376,0.,0.035355339059327376, 0.31819805153394637,0.,-0.31819805153394637]
1252         val=f3.getArray().getValues();
1253         for i in xrange(15):
1254             self.assertTrue(abs(expected2[i]-val[i])<1.e-12);
1255             pass
1256         #
1257         f3=f2*f1;
1258         val=f3.getArray().getValues();
1259         for i in xrange(15):
1260             self.assertTrue(abs(expected2[i]-val[i])<1.e-12);
1261             pass
1262         pass
1263
1264     def testOperationsOnFields3(self):
1265         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1266         f1=m.fillFromAnalytic(ON_NODES,1,"x+y+z");
1267         f2=m.fillFromAnalytic(ON_NODES,1,"a*a+b+c*c");
1268         f1/=f2
1269         f1.checkCoherency();
1270         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1271         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1272         expected1=[-2.4999999999999991, 1.2162162162162162, 0.77868852459016391,
1273                    0.7407407407407407, 1.129032258064516, 0.81632653061224492,
1274                    0.86538461538461531, 1.0919540229885056, 0.84302325581395343]
1275         self.assertEqual(1,f1.getNumberOfComponents());
1276         self.assertEqual(9,f1.getNumberOfTuples());
1277         val=f1.getArray().getValues();
1278         for i in xrange(9):
1279             self.assertTrue(abs(expected1[i]-val[i])<1.e-12);
1280             pass
1281         #
1282         f1=m.buildOrthogonalField();
1283         f2=m.fillFromAnalytic(ON_CELLS,1,"x");
1284         f1*=f2
1285         expected2=[-0.035355339059327376,0.,0.035355339059327376, 0.2592724864350674,0.,-0.2592724864350674, 0.37712361663282529,0.,-0.37712361663282529, -0.035355339059327376,0.,0.035355339059327376, 0.31819805153394637,0.,-0.31819805153394637]
1286         val=f1.getArray().getValues();
1287         for i in xrange(15):
1288             self.assertTrue(abs(expected2[i]-val[i])<1.e-12);
1289             pass
1290         #
1291         f1=m.buildOrthogonalField();
1292         # to avoid valgrind leaks
1293         # self.assertRaises(InterpKernelException,f2.__imul__,f1);
1294         pass
1295
1296     def testOperationsOnFields4(self):
1297         m=MEDCouplingDataForTest.build2DTargetMesh_1();
1298         nbOfCells=m.getNumberOfCells();
1299         f1=MEDCouplingFieldDouble.New(ON_CELLS,CONST_ON_TIME_INTERVAL);
1300         f1.setMesh(m);
1301         array=DataArrayDouble.New();
1302         f1.setArray(array);
1303         self.assertRaises(InterpKernelException,f1.setEndArray,array);
1304         self.assertRaises(InterpKernelException,f1.getEndArray);
1305         arr1=[0.,10.,20.,1.,11.,21.,2.,12.,22.,3.,13.,23.,4.,14.,24.]
1306         arr2=[5.,15.,25.,6.,16.,26.,7.,17.,27.,8.,18.,28.,9.,19.,29.]
1307         array.setValues(arr1,nbOfCells,3);
1308         f1.setStartTime(2.,0,0);
1309         f1.setEndTime(3.,0,0);
1310         f1.checkCoherency();
1311         pos=[0.3,-0.2]
1312         res=f1.getValueOn(pos);
1313         self.assertTrue(abs(arr1[3]-res[0])<1.e-12);
1314         self.assertTrue(abs(arr1[4]-res[1])<1.e-12);
1315         self.assertTrue(abs(arr1[5]-res[2])<1.e-12);
1316         res=None
1317         res=f1.getValueOn(pos,2.2);
1318         self.assertTrue(abs(arr1[3]-res[0])<1.e-12);
1319         self.assertTrue(abs(arr1[4]-res[1])<1.e-12);
1320         self.assertTrue(abs(arr1[5]-res[2])<1.e-12);
1321         res=None
1322         self.assertRaises(InterpKernelException,f1.getValueOn,pos,3.2)
1323         f2=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
1324         f2.setMesh(m);
1325         f2.setArray(f1.getArray());
1326         f2.setStartTime(2.,3,0);
1327         f2.setEndTime(4.,13,0);
1328         self.assertRaises(InterpKernelException,f2.checkCoherency)
1329         array2=DataArrayDouble.New();
1330         array2.setValues(arr2,nbOfCells,3);
1331         f2.setEndArray(array2);
1332         f2.checkCoherency();
1333         #
1334         res=None
1335         res=f2.getValueOn(pos,3.21);
1336         self.assertTrue(abs(4.025-res[0])<1.e-12);
1337         self.assertTrue(abs(14.025-res[1])<1.e-12);
1338         self.assertTrue(abs(24.025-res[2])<1.e-12);
1339         f3=f2.clone(True);
1340         self.assertTrue(f2.isEqual(f3,1e-12,1e-12));
1341         f3.getEndArray().setIJ(0,0,5.001);
1342         self.assertTrue(not f2.isEqual(f3,1e-12,1e-12));
1343         self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1344         f3.setStartTime(2.1,3,0);
1345         self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1346         f3.setStartTime(2.,3,0);
1347         self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1348         f3.setStartTime(2.,4,0);
1349         self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1350         f3.setStartTime(2.,3,1);
1351         self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1352         f3.setStartTime(2.,3,0);
1353         self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1354         f3.setEndTime(4.1,13,0);
1355         self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1356         f3.setEndTime(4.,13,0);
1357         self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1358         f3.setEndTime(4.,14,0);
1359         self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1360         f3.setEndTime(4.,13,1);
1361         self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1362         f3.setEndTime(4.,13,0);
1363         self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1364         f4=f2+f2
1365         res=None
1366         res=f4.getValueOn(pos,3.21);
1367         self.assertTrue(abs(8.05-res[0])<1.e-12);
1368         self.assertTrue(abs(28.05-res[1])<1.e-12);
1369         self.assertTrue(abs(48.05-res[2])<1.e-12);
1370         f4+=f2;
1371         res=None
1372         res=f4.getValueOn(pos,3.21);
1373         self.assertTrue(abs(12.075-res[0])<1.e-12);
1374         self.assertTrue(abs(42.075-res[1])<1.e-12);
1375         self.assertTrue(abs(72.075-res[2])<1.e-12);
1376         pass
1377
1378     def testMergeNodesOnField(self):
1379         targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
1380         f1=targetMesh.fillFromAnalytic(ON_NODES,1,"x+y+z");
1381         f1.mergeNodes(1e-10);
1382         #
1383         targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
1384         f1=targetMesh.fillFromAnalytic(ON_NODES,1,"x+y+z");
1385         tmp=f1.getArray()
1386         tmp.setIJ(0,0,1000.);
1387         f1.mergeNodes(1e-10);
1388         #
1389         targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
1390         f1=targetMesh.fillFromAnalytic(ON_NODES,1,"x+y+z");
1391         tmp=f1.getArray()
1392         tmp.setIJ(1,0,1000.);
1393         self.assertRaises(InterpKernelException,f1.mergeNodes,1.e-10)
1394         pass
1395
1396     def testCheckConsecutiveCellTypes(self):
1397         sourceMesh=MEDCouplingDataForTest.build2DSourceMesh_1();
1398         targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1399         self.assertTrue(sourceMesh.checkConsecutiveCellTypes());
1400         order1=[NORM_TRI3,NORM_QUAD4]
1401         order2=[NORM_QUAD4,NORM_TRI3]
1402         self.assertTrue(not targetMesh.checkConsecutiveCellTypes());
1403         self.assertTrue(not targetMesh.checkConsecutiveCellTypesAndOrder(order1));
1404         self.assertTrue(not targetMesh.checkConsecutiveCellTypesAndOrder(order2));
1405         da=targetMesh.getRenumArrForConsecutiveCellTypesSpec(order1);
1406         self.assertEqual(5,da.getNumberOfTuples());
1407         self.assertEqual(1,da.getNumberOfComponents());
1408         expected1=[2,0,1,3,4]
1409         self.assertTrue(expected1==list(da.getValues()));
1410         da=targetMesh.getRenumArrForConsecutiveCellTypesSpec(order2);
1411         self.assertEqual(5,da.getNumberOfTuples());
1412         self.assertEqual(1,da.getNumberOfComponents());
1413         expected2=[0,3,4,1,2]
1414         self.assertTrue(expected2==list(da.getValues()));
1415         renumber1=[4,0,1,2,3]
1416         targetMesh.renumberCells(renumber1,False);
1417         self.assertTrue(targetMesh.checkConsecutiveCellTypes());
1418         self.assertTrue(targetMesh.checkConsecutiveCellTypesAndOrder(order1));
1419         self.assertTrue(not targetMesh.checkConsecutiveCellTypesAndOrder(order2));
1420         pass
1421
1422     def testRearrange2ConsecutiveCellTypes(self):
1423         m1_1=MEDCouplingDataForTest.build2DSourceMesh_1();
1424         m2_1=MEDCouplingDataForTest.build2DTargetMesh_1();
1425         arr1=m1_1.rearrange2ConsecutiveCellTypes();
1426         m1_2=MEDCouplingDataForTest.build2DSourceMesh_1();
1427         self.assertTrue(m1_2.isEqual(m1_1,1e-12));
1428         expected1=[0,1]
1429         self.assertEqual(2,arr1.getNumberOfTuples());
1430         self.assertEqual(1,arr1.getNumberOfComponents());
1431         self.assertEqual(expected1,arr1.getValues());
1432         expected2=[0,3,4,1,2]
1433         arr1=m2_1.rearrange2ConsecutiveCellTypes();
1434         self.assertEqual(5,arr1.getNumberOfTuples());
1435         self.assertEqual(1,arr1.getNumberOfComponents());
1436         self.assertEqual(expected2,list(arr1.getValues()));
1437         m2_2=MEDCouplingDataForTest.build2DTargetMesh_1();
1438         self.assertEqual(5,arr1.getNumberOfTuples());
1439         self.assertEqual(1,arr1.getNumberOfComponents());
1440         self.assertEqual(expected2,list(arr1.getValues()));
1441         self.assertTrue(not m2_2.isEqual(m2_1,1e-12));
1442         m2_2.renumberCells(expected2,False);
1443         self.assertTrue(m2_2.isEqual(m2_1,1e-12));
1444         pass
1445
1446     def testSplitByType(self):
1447         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1448         v=m1.splitByType();
1449         self.assertEqual(3,len(v));
1450         m2=MEDCouplingUMesh.MergeUMeshesOnSameCoords(v);
1451         m2.setName(m1.getName());
1452         self.assertTrue(m1.isEqual(m2,1.e-12));
1453         pass
1454
1455     def testFuseUMeshesOnSameCoords(self):
1456         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
1457         cells1=[2,3,4]
1458         m3=m2.buildPartOfMySelf(cells1,True);
1459         self.assertTrue(isinstance(m3,MEDCouplingUMesh))
1460         cells2=[1,2,4]
1461         m4=m2.buildPartOfMySelf(cells2,True);
1462         self.assertTrue(isinstance(m4,MEDCouplingUMesh))
1463         cells3=[1,2]
1464         m5=m2.buildPartOfMySelf(cells3,True);
1465         self.assertTrue(isinstance(m5,MEDCouplingUMesh))
1466         meshes=[m3,m4,m5]
1467         #
1468         m7,corr=MEDCouplingUMesh.FuseUMeshesOnSameCoords(meshes,0);
1469         self.assertEqual(4,m7.getNumberOfCells());
1470         self.assertEqual(3,len(corr));
1471         expectedVals1=[3,3,2]
1472         expectedVals2=[[0,1,2],[3,0,2],[3,0]]
1473         for i in xrange(3):
1474             arr=corr[i];
1475             self.assertEqual(1,arr.getNumberOfComponents());
1476             nbOfVals=expectedVals1[i];
1477             self.assertEqual(nbOfVals,arr.getNumberOfTuples());
1478             vals=arr.getValues();
1479             self.assertEqual(expectedVals2[i],list(vals));
1480             pass
1481         arr2,fidsOfGroups=DataArrayInt.MakePartition(corr,m7.getNumberOfCells());
1482         fidExp=[5,1,3,4]
1483         fidsGrp=[[1,3,5],[3,4,5],[4,5]]
1484         self.assertEqual(3,len(fidsOfGroups));
1485         self.assertEqual(1,arr2.getNumberOfComponents());
1486         self.assertEqual(4,arr2.getNumberOfTuples());
1487         self.assertEqual(fidExp,list(arr2.getValues()));
1488         for i in xrange(3):
1489             nbOfVals=expectedVals1[i];
1490             self.assertEqual(list(fidsOfGroups[i]),fidsGrp[i]);
1491             pass
1492         pass
1493
1494     def testFuseUMeshesOnSameCoords2(self):
1495         m1,m2=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
1496         part1=[2,3,6,4,10]
1497         m3=m1.buildPartOfMySelf(part1,True);
1498         part2=[5,6,4,7]
1499         m4=m1.buildPartOfMySelf(part2,True);
1500         meshes=[m1,m3,m3,m4]
1501         m5,corr=MEDCouplingUMesh.FuseUMeshesOnSameCoords(meshes,0);
1502         self.assertEqual(18,m5.getNumberOfCells());
1503         exp2=[
1504             [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17],
1505             [2,3,6,4,10],
1506             [2,3,6,4,10],
1507             [5,6,4,7]]
1508         i=0;
1509         for it in corr:
1510             self.assertEqual(exp2[i],list(it.getValues()));
1511             i+=1
1512             pass
1513         pass
1514
1515     def testBuildOrthogonalField(self):
1516         targetMesh=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1517         field=targetMesh.buildOrthogonalField();
1518         expected=[0.70710678118654746,0.,-0.70710678118654746]
1519         self.assertEqual(5,field.getNumberOfTuples());
1520         self.assertEqual(3,field.getNumberOfComponents());
1521         vals=field.getArray().getValues();
1522         for i in xrange(15):
1523             self.assertTrue(abs(expected[i%3]-vals[i])<1e-12);
1524         # testing
1525         targetCoords=[0.,0.,0.,0.5,0.,0.5,1.,0.,1.,0.,1.,0.]
1526         targetConn=[0,1,2,3]
1527         targetMesh=MEDCouplingUMesh.New();
1528         targetMesh.setMeshDimension(2);
1529         targetMesh.allocateCells(1);
1530         targetMesh.insertNextCell(NORM_QUAD4,targetConn[0:4])
1531         targetMesh.finishInsertingCells();
1532         myCoords=DataArrayDouble.New();
1533         myCoords.setValues(targetCoords,4,3);
1534         targetMesh.setCoords(myCoords);
1535         field=targetMesh.buildOrthogonalField();
1536         self.assertEqual(1,field.getNumberOfTuples());
1537         self.assertEqual(3,field.getNumberOfComponents());
1538         vals=field.getArray().getValues();
1539         self.assertTrue(abs(-0.70710678118654746-vals[0])<1e-12);
1540         self.assertTrue(abs(0.-vals[1])<1e-12);
1541         self.assertTrue(abs(0.70710678118654746-vals[2])<1e-12);
1542         pass
1543
1544     def testGetCellsContainingPoint(self):
1545         targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1546         pos=[0.,0.,0.4,0.4,0.,0.4,0.1,0.1,0.25,0.,0.65,0.]
1547         #2D basic
1548         t1,t2=targetMesh.getCellsContainingPoints(pos,6,1e-12);
1549         self.assertEqual(6,t1.getNumberOfTuples());
1550         self.assertEqual(1,t1.getNumberOfComponents());
1551         self.assertEqual(7,t2.getNumberOfTuples());
1552         self.assertEqual(1,t2.getNumberOfComponents());
1553         expectedValues1=[0,4,3,0,1,2]
1554         expectedValues2=[0,1,2,3,4,5,6]
1555         self.assertEqual(list(t1.getValues()),expectedValues1);
1556         self.assertEqual(list(t2.getValues()),expectedValues2);
1557         #2D with no help of bounding box.
1558         center=[0.2,0.2]
1559         MEDCouplingPointSet.Rotate2DAlg(center,0.78539816339744830962,6,pos);
1560         targetMesh.rotate(center,0.78539816339744830962);
1561         t1=None
1562         t2=None
1563         t1,t2=targetMesh.getCellsContainingPoints(pos,1e-12);
1564         self.assertEqual(6,t1.getNumberOfTuples());
1565         self.assertEqual(7,t2.getNumberOfTuples());
1566         self.assertEqual(list(t1.getValues()),expectedValues1);
1567         self.assertEqual(list(t2.getValues()),expectedValues2);
1568         t1,t2=targetMesh.getCellsContainingPoints(DataArrayDouble.New(pos,6,2),1e-12);
1569         self.assertEqual(6,t1.getNumberOfTuples());
1570         self.assertEqual(7,t2.getNumberOfTuples());
1571         self.assertEqual(list(t1.getValues()),expectedValues1);
1572         self.assertEqual(list(t2.getValues()),expectedValues2);
1573         self.assertRaises(InterpKernelException,targetMesh.getCellsContainingPoints,DataArrayDouble.New(pos,4,3),1e-12);
1574         #2D outside
1575         pos1bis=[-0.3303300858899107,-0.11819805153394641]
1576         self.assertEqual(-1,targetMesh.getCellContainingPoint(pos1bis,1e-12));
1577         #test limits 2D
1578         targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1579         pos2=[0.2,-0.05]
1580         t1=None
1581         t1=targetMesh.getCellsContainingPoint(pos2,1e-12)
1582         self.assertEqual(2,len(t1));
1583         expectedValues3=[0,1]
1584         self.assertEqual(list(t1.getValues()),expectedValues3);
1585         pos3=[0.2,0.2]
1586         t1=None
1587         t1=targetMesh.getCellsContainingPoint(pos3,1e-12);
1588         self.assertEqual(5,len(t1));
1589         expectedValues4=[0,1,2,3,4]
1590         self.assertEqual(list(t1.getValues()),expectedValues4);
1591         self.assertEqual(0,targetMesh.getCellContainingPoint(pos3,1e-12));
1592         #3D
1593         targetMesh=MEDCouplingDataForTest.build3DTargetMesh_1();
1594         pos4=[25.,25.,25.]
1595         self.assertEqual(0,targetMesh.getCellContainingPoint(pos4,1e-12));
1596         pos5=[50.,50.,50.]
1597         t1=None
1598         t1=targetMesh.getCellsContainingPoint(pos5,1e-12);
1599         self.assertEqual(8,len(t1));
1600         expectedValues5=[0,1,2,3,4,5,6,7]
1601         self.assertEqual(list(t1.getValues()),expectedValues5);
1602         pos6=[0., 50., 0.]
1603         t1=None
1604         t1=targetMesh.getCellsContainingPoint(pos6,1e-12);
1605         self.assertEqual(2,len(t1));
1606         expectedValues6=[0,2]
1607         self.assertEqual(list(t1.getValues()),expectedValues6);
1608         #3D outside
1609         pos7=[-1.0,-1.0,0.]
1610         self.assertEqual(-1,targetMesh.getCellContainingPoint(pos7,1e-12));
1611         #3D outside 2
1612         center2=[0.,0.,0.]
1613         vec2=[0.,-1.,0.]
1614         targetMesh.rotate(center2,vec2,0.78539816339744830962);
1615         pos8=[-25.,25.,12.]
1616         self.assertEqual(-1,targetMesh.getCellContainingPoint(pos8,1e-12));
1617         pass
1618
1619     def testGetValueOn1(self):
1620         targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1621         fieldOnCells=MEDCouplingFieldDouble.New(ON_CELLS);
1622         nbOfCells=targetMesh.getNumberOfCells();
1623         fieldOnCells.setMesh(targetMesh);
1624         array=DataArrayDouble.New();
1625         tmp=2*nbOfCells*[None]
1626         for i in xrange(nbOfCells):
1627             tmp[2*i]=7.+float(i);
1628             tmp[2*i+1]=17.+float(i)
1629             pass
1630         array.setValues(tmp,nbOfCells,2);
1631         fieldOnCells.setArray(array);
1632         #
1633         pos1=[0.25,0.]
1634         res=fieldOnCells.getValueOn(pos1);
1635         self.assertEqual(2,len(res))
1636         self.assertTrue(abs(8.-res[0])<1e-12);
1637         self.assertTrue(abs(18.-res[1])<1e-12);
1638         #
1639         #
1640         targetMesh=MEDCouplingDataForTest.build2DSourceMesh_1();
1641         fieldOnNodes=MEDCouplingFieldDouble.New(ON_NODES);
1642         nbOfNodes=targetMesh.getNumberOfNodes();
1643         fieldOnNodes.setMesh(targetMesh);
1644         array=DataArrayDouble.New();
1645         tmp=2*nbOfNodes*[None]
1646         for i in xrange(nbOfNodes):
1647             tmp[2*i]=17.+float(i);
1648             tmp[2*i+1]=27.+float(i)
1649             pass
1650         array.setValues(tmp,nbOfNodes,2);
1651         fieldOnNodes.setArray(array);
1652         #
1653         pos2=[-0.13333333333333333,-0.13333333333333333]
1654         res=None
1655         res=fieldOnNodes.getValueOn(pos2);
1656         self.assertEqual(2,len(res))
1657         self.assertTrue(abs(17.5-res[0])<1e-12);
1658         self.assertTrue(abs(27.5-res[1])<1e-12);
1659         pos3=[0.033333333333333326,0.36666666666666664]
1660         res=None
1661         res=fieldOnNodes.getValueOn(pos3);
1662         self.assertEqual(2,len(res))
1663         self.assertTrue(abs(18.666666666666667-res[0])<1e-12);
1664         self.assertTrue(abs(28.666666666666667-res[1])<1e-12);
1665         pass
1666
1667     def testCMesh0(self):
1668         mesh=MEDCouplingCMesh.New();
1669         meshEmpty=mesh.clone(True);
1670         self.assertTrue(meshEmpty.isEqual(mesh, 1e-12));
1671
1672         coordsX=DataArrayDouble.New();
1673         arrX=[ -1., 1., 2., 4. ]
1674         coordsX.setValues(arrX, 4, 1);
1675         coordsY=DataArrayDouble.New();
1676         arrY=[ -2., 2., 4., 8. ]
1677         coordsY.setValues(arrY, 4, 1);
1678         coordsZ=DataArrayDouble.New();
1679         arrZ=[ -3., 3., 6., 12. ]
1680         coordsZ.setValues(arrZ, 4, 1);
1681         mesh.setCoords(coordsX, coordsY, coordsZ);
1682         #
1683         fieldOnNodes=mesh.fillFromAnalytic(ON_NODES, 1, "x+y/2.+z/3.");
1684         self.assertEqual(1, fieldOnNodes.getNumberOfComponents());
1685         self.assertEqual(64, fieldOnNodes.getNumberOfTuples());
1686         expected1=[-3., -1., 0., 2., -1., 1., 2., 4., 0., 2., 3., 5., 2., 4., 5., 7., -1., 1., 2.,
1687                     4., 1., 3., 4., 6., 2., 4., 5., 7., 4., 6., 7., 9., 0., 2., 3., 5., 2., 4., 5.,
1688                     7., 3., 5., 6., 8., 5., 7., 8., 10., 2., 4., 5.,
1689                     7., 4., 6., 7., 9., 5., 7., 8., 10., 7., 9., 10., 12.];
1690
1691         val=fieldOnNodes.getArray().getValues();
1692         for i in xrange(64):
1693           self.assertAlmostEqual(expected1[i], val[i], 12)
1694         res=fieldOnNodes.getValueOnPos(1, 3, 2);
1695         self.assertAlmostEqual(7., res[0], 12);
1696         #
1697         fieldOnCells=mesh.fillFromAnalytic(ON_CELLS, 1, "x+y/2.+z/3.");
1698         self.assertEqual(1, fieldOnCells.getNumberOfComponents());
1699         self.assertEqual(27, fieldOnCells.getNumberOfTuples());
1700         val=fieldOnCells.getArray().getValues();
1701         expected2=[0, 1.5, 3, 1.5, 3, 4.5, 3, 4.5, 6, 1.5, 3, 4.5, 3, 4.5,
1702                     6, 4.5, 6, 7.5, 3, 4.5, 6, 4.5, 6, 7.5, 6, 7.5, 9];
1703         for i in xrange(27):
1704           self.assertAlmostEqual(expected2[i], val[i], 12);
1705         #res=fieldOnCells.getValueOnPos(1,2,1);
1706         #self.assertAlmostEqual(6.,res,12);
1707         #
1708         meshDeepCopy=mesh.deepCpy();
1709         meshClone=mesh.clone(False);
1710
1711         meshEmpty.copyTinyStringsFrom(mesh);
1712         #no data in meshEmpty, expected False
1713         self.assertTrue(not meshEmpty.isEqual(mesh, 1e-12));
1714
1715         self.assertTrue(meshDeepCopy.isEqual(mesh, 1e-12));
1716         meshDeepCopy.copyTinyStringsFrom(mesh);
1717         self.assertTrue(meshDeepCopy.isEqual(mesh, 1e-12));
1718         self.assertTrue(meshClone.isEqual(mesh, 1e-12));
1719
1720         self.assertEqual(CARTESIAN, mesh.getType());
1721         self.assertEqual(CARTESIAN, meshEmpty.getType());
1722         self.assertEqual(CARTESIAN, meshDeepCopy.getType());
1723         self.assertEqual(CARTESIAN, meshClone.getType());
1724         pass
1725
1726     def testCMesh1(self):
1727         mesh1=MEDCouplingCMesh.New();
1728         coordsX1=DataArrayDouble.New();
1729         arrX1=[ -1., 1., 2., 4. ]
1730         coordsX1.setValues(arrX1, 4, 1);
1731         coordsY1=DataArrayDouble.New();
1732         arrY1=[ -2., 2., 4., 8. ]
1733         coordsY1.setValues(arrY1, 4, 1);
1734         coordsZ1=DataArrayDouble.New();
1735         arrZ1=[ -3., 3., 6., 12. ]
1736         coordsZ1.setValues(arrZ1, 4, 1);
1737         mesh1.setCoords(coordsX1, coordsY1, coordsZ1);
1738
1739         mesh2=MEDCouplingCMesh.New();
1740         coordsX2=DataArrayDouble.New();
1741         arrX2=[ -1., 1., 2., 4. ]
1742         coordsX2.setValues(arrX2, 4, 1);
1743         coordsY2=DataArrayDouble.New();
1744         arrY2=[ -2., 2., 4., 8. ]
1745         coordsY2.setValues(arrY2, 4, 1);
1746         coordsZ2=DataArrayDouble.New();
1747         arrZ2=[ -3., 3., 6., 12.+1e-6 ]
1748         coordsZ2.setValues(arrZ2, 4, 1);
1749         mesh2.setCoords(coordsX2, coordsY2, coordsZ2);
1750
1751         mesh3=MEDCouplingCMesh.New();
1752         coordsX3=DataArrayDouble.New();
1753         arrX3=[-1.]
1754         coordsX3.setValues(arrX3, 1, 1);
1755         coordsY3=DataArrayDouble.New();
1756         arrY3=[-2.]
1757         coordsY3.setValues(arrY3, 1, 1);
1758         coordsZ3=DataArrayDouble.New();
1759         arrZ3=[-3.]
1760         coordsZ3.setValues(arrZ3, 1, 1);
1761         mesh3.setCoords(coordsX3, coordsY3, coordsZ3);
1762
1763         self.assertEqual(3, mesh1.getSpaceDimension());
1764         self.assertEqual(3, mesh1.getMeshDimension());
1765
1766         self.assertTrue(not mesh1.isEqual(mesh2, 1e-12));
1767         self.assertTrue(not mesh2.isEqual(mesh1, 1e-12));
1768         self.assertTrue(not mesh2.isEqualWithoutConsideringStr(mesh1, 1e-12));
1769         self.assertTrue(mesh1.isEqual(mesh2, 1e-5));
1770         self.assertTrue(not mesh1.isEqual(mesh2, 1e-7));
1771
1772         self.assertRaises(InterpKernelException, mesh3.checkCoherency1, 1e-12);
1773         mesh1.checkCoherency2(1e-12);
1774         self.assertEqual(NORM_HEXA8, mesh1.getTypeOfCell(1));
1775
1776         self.assertEqual(NORM_HEXA8, mesh1.getAllGeoTypes()[0]);
1777         self.assertEqual(27, mesh1.getNumberOfCellsWithType(NORM_HEXA8));
1778         self.assertRaises(InterpKernelException, mesh1.getNumberOfCellsWithType, NORM_QUAD4);
1779
1780         coo=mesh1.getCoordinatesOfNode(0);
1781         self.assertEqual(3, len(coo));
1782         self.assertAlmostEqual(-1., coo[0], 14);
1783         self.assertAlmostEqual(-2., coo[1], 14);
1784         self.assertAlmostEqual(-3., coo[2], 14);
1785         coo=mesh1.getCoordinatesOfNode(63);
1786         self.assertEqual(3, len(coo));
1787         self.assertAlmostEqual(4., coo[0], 14);
1788         self.assertAlmostEqual(8., coo[1], 14);
1789         self.assertAlmostEqual(12., coo[2], 14);
1790
1791         a=str(mesh1)
1792         repr=mesh1.simpleRepr();
1793         repr=mesh1.advancedRepr();
1794         self.assertTrue("Cartesian" in repr);
1795         self.assertTrue("Number of components : 1" in repr);
1796         self.assertTrue("Number of tuples : 4" in repr);
1797         self.assertTrue("Z Array :" in repr);
1798         pass
1799
1800     def testCMesh2(self):
1801         mesh1=MEDCouplingCMesh.New();
1802         coordsX1=DataArrayDouble.New();
1803         arrX1=[ -1., 1., 2., 4. ]
1804         coordsX1.setValues(arrX1, 4, 1);
1805         coordsY1=DataArrayDouble.New();
1806         arrY1=[ -2., 2., 4., 8. ]
1807         coordsY1.setValues(arrY1, 4, 1);
1808         coordsZ1=DataArrayDouble.New();
1809         arrZ1=[ -3., 3., 6., 12. ]
1810         coordsZ1.setValues(arrZ1, 4, 1);
1811         mesh1.setCoords(coordsX1, coordsY1, coordsZ1);
1812
1813         dis=mesh1.getDistributionOfTypes();
1814         self.assertEqual(1, len(dis));
1815         self.assertEqual(NORM_HEXA8, dis[0][0]);
1816         self.assertEqual(27, dis[0][1]);
1817         self.assertEqual(0, dis[0][2]);
1818
1819         idsPerType=[]
1820         self.assertRaises(InterpKernelException, mesh1.checkTypeConsistencyAndContig, dis, idsPerType);
1821         dis[0][2]=-1;
1822         idsPerType=[]
1823         self.assertTrue(not mesh1.checkTypeConsistencyAndContig(dis, idsPerType));
1824         dis[0][0]=NORM_QUAD4;
1825         self.assertRaises(InterpKernelException, mesh1.checkTypeConsistencyAndContig, dis, idsPerType);
1826         dis[0][0]=NORM_HEXA8;
1827         dis[0][2]=0;
1828         ids=DataArrayInt.New();
1829         ids.alloc(10, 1);
1830         ids.fillWithValue(111);
1831         idsPerType=[ids];
1832         check=mesh1.checkTypeConsistencyAndContig(dis, idsPerType);
1833         self.assertTrue(check);
1834         self.assertTrue(check.isEqual(ids));
1835
1836         code, idsInPflPerType, pfls=mesh1.splitProfilePerType(ids);
1837         self.assertEqual(3, len(code));
1838         self.assertEqual(NORM_HEXA8, code[0]);
1839         self.assertEqual(27, code[1]);
1840         self.assertEqual(0, code[2]);
1841         self.assertEqual(1, len(idsInPflPerType));
1842         self.assertEqual(1, len(pfls));
1843         self.assertTrue(idsInPflPerType[0].isEqual(ids));
1844         self.assertTrue(pfls[0].isEqual(ids));
1845
1846         cells1=[0, 1, 25, 26]
1847         partMesh1=mesh1.buildPart(cells1)
1848         self.assertTrue(isinstance(partMesh1,MEDCouplingMesh))
1849         self.assertEqual(4, partMesh1.getNumberOfCellsWithType(NORM_HEXA8));
1850         self.assertEqual(64, mesh1.getNumberOfNodes());
1851         self.assertEqual(64, partMesh1.getNumberOfNodes());
1852
1853         cells2=[25, 26]
1854         partMesh2, arr1=mesh1.buildPartAndReduceNodes(cells2)
1855         self.assertTrue(isinstance(partMesh2,MEDCouplingUMesh))
1856         self.assertEqual(2,partMesh2.getNumberOfCellsWithType(NORM_HEXA8));
1857         self.assertEqual(12,partMesh2.getNumberOfNodes());
1858
1859         cells3=[2, 3]
1860         partMesh3, arr2=partMesh1.buildPartAndReduceNodes(cells3)
1861         self.assertTrue(isinstance(partMesh3,MEDCouplingUMesh))
1862         self.assertEqual(2, partMesh3.getNumberOfCellsWithType(NORM_HEXA8));
1863         self.assertEqual(12, partMesh3.getNumberOfNodes());
1864
1865         self.assertRaises(InterpKernelException, mesh1.simplexize, 0);
1866         self.assertRaises(InterpKernelException, mesh1.getMeasureFieldOnNode, True);
1867
1868         #double bbox1[6];
1869         #double bbox2[6];
1870         bbox1=mesh1.getBoundingBox(); #[(-1.0, 4.0), (-2.0, 8.0), (-3.0, 12.0)]
1871         bbox2=partMesh1.getBoundingBox();
1872         self.assertTrue(bbox1==bbox2);
1873         bbox1=partMesh3.getBoundingBox();
1874         bbox2=partMesh2.getBoundingBox();
1875         self.assertTrue(bbox1==bbox2);
1876
1877         self.assertRaises(InterpKernelException, mesh1.buildOrthogonalField);
1878         mesh2d=MEDCouplingCMesh.New();
1879         mesh2d.setCoords(coordsX1, coordsY1);
1880         f1=mesh2d.buildOrthogonalField();
1881
1882         pass
1883
1884     def testScale(self):
1885         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1886         pos=[0.2,0.2]
1887         mesh.scale(pos,0.5);
1888         expected1=[-0.05,-0.05, 0.2,-0.05, 0.45,-0.05, -0.05,0.2, 0.2,0.2, 0.45,0.2,
1889                    -0.05,0.45, 0.2,0.45, 0.45,0.45]
1890         val=mesh.getCoords().getValues();
1891         self.assertEqual(18,len(val))
1892         for i in xrange(18):
1893             self.assertTrue(abs(expected1[i]-val[i])<1e-12);
1894             pass
1895         pass
1896
1897     def testTryToShareSameCoords(self):
1898         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
1899         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
1900         self.assertTrue(m1.getCoords().getHiddenCppPointer()!=m2.getCoords().getHiddenCppPointer());
1901         m1.tryToShareSameCoords(m2,1e-12);
1902         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1903         m1.tryToShareSameCoords(m2,1e-12);
1904         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1905         m2.tryToShareSameCoords(m1,1e-12);
1906         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1907         #
1908         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
1909         m2=MEDCouplingDataForTest.build2DTargetMesh_2();
1910         self.assertTrue(m1.getCoords().getHiddenCppPointer()!=m2.getCoords().getHiddenCppPointer());
1911         m1.tryToShareSameCoords(m2,1e-12);
1912         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1913         m1.tryToShareSameCoords(m2,1e-12);
1914         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1915         m2.tryToShareSameCoords(m1,1e-12);
1916         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1917         #
1918         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
1919         m2=MEDCouplingDataForTest.build2DSourceMesh_1();
1920         self.assertTrue(m1.getCoords().getHiddenCppPointer()!=m2.getCoords().getHiddenCppPointer());
1921         self.assertRaises(InterpKernelException,m1.tryToShareSameCoords,m2,1e-12)
1922         pass
1923
1924     def testFindNodeOnPlane(self):
1925         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
1926         pt=[300.,300.,0.]
1927         v=[0.,0.,2.]
1928         n=mesh.findNodesOnPlane(pt,v,1e-12);
1929         self.assertEqual(9,len(n));
1930         m3dSurf=mesh.buildFacePartOfMySelfNode(n,True);
1931         self.assertTrue(isinstance(m3dSurf,MEDCouplingUMesh))
1932         me=MEDCouplingExtrudedMesh.New(mesh,m3dSurf,0);
1933         da=me.getMesh3DIds();
1934         self.assertEqual(8,me.getNumberOfCells());
1935         expected=[0,1,2,3,4,5,6,7]
1936         val=da.getValues();
1937         self.assertEqual(expected,list(val));
1938         #
1939         m3dSurf=mesh.buildFacePartOfMySelfNode(n,True);
1940         self.assertTrue(isinstance(m3dSurf,MEDCouplingUMesh))
1941         me=MEDCouplingExtrudedMesh.New(mesh,m3dSurf,0);
1942         da=me.getMesh3DIds();
1943         self.assertEqual(8,me.getNumberOfCells());
1944         expected=[0,1,2,3,4,5,6,7]
1945         val=da.getValues();
1946         self.assertEqual(expected,list(val));
1947         pass
1948
1949     def testRenumberCells(self):
1950         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1951         m2=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1952         self.assertTrue(m.isEqual(m2,0));
1953         arr=[12,3,25,2,26]
1954         m.renumberCells(arr,True);
1955         self.assertTrue(not m.isEqual(m2,0));
1956         self.assertEqual(NORM_QUAD4,m.getTypeOfCell(0));
1957         self.assertEqual(NORM_TRI3,m.getTypeOfCell(1));
1958         self.assertEqual(NORM_QUAD4,m.getTypeOfCell(2));
1959         self.assertEqual(NORM_TRI3,m.getTypeOfCell(3));
1960         self.assertEqual(NORM_QUAD4,m.getTypeOfCell(4));
1961         arr2=[5,-1,-5,4,8]
1962         m.renumberCells(arr2,True);
1963         self.assertTrue(m.isEqual(m2,0));
1964         pass
1965
1966     def testChangeSpaceDimension(self):
1967         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1968         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
1969         #
1970         self.assertEqual(3,m1.getSpaceDimension());
1971         m1.changeSpaceDimension(2);
1972         self.assertEqual(2,m1.getSpaceDimension());
1973         m1.setName(m2.getName());
1974         self.assertTrue(m1.isEqual(m2,1e-12));
1975         m1.changeSpaceDimension(3);
1976         self.assertEqual(3,m1.getSpaceDimension());
1977         expected=[-0.3,-0.3,0., 0.2,-0.3,0., 0.7,-0.3,0., -0.3,0.2,0., 0.2,0.2,0., 0.7,0.2,0., -0.3,0.7,0., 0.2,0.7,0., 0.7,0.7,0.]
1978         val=m1.getCoords().getValues();
1979         for i in xrange(27):
1980             self.assertTrue(abs(expected[i]-val[i])<1e-14);
1981             pass
1982         pass
1983
1984     def testGaussPointField1(self):
1985         _a=0.446948490915965;
1986         _b=0.091576213509771;
1987         _p1=0.11169079483905;
1988         _p2=0.0549758718227661;
1989         refCoo1=[ 0.,0., 1.,0., 0.,1. ]
1990         gsCoo1=[ 2*_b-1, 1-4*_b, 2*_b-1, 2.07*_b-1, 1-4*_b,
1991                  2*_b-1, 1-4*_a, 2*_a-1, 2*_a-1, 1-4*_a, 2*_a-1, 2*_a-1 ]
1992         wg1=[ 4*_p2, 4*_p2, 4*_p2, 4*_p1, 4*_p1, 4*_p1 ]
1993         _refCoo1=refCoo1
1994         _gsCoo1=gsCoo1
1995         _wg1=wg1
1996         #
1997         m=MEDCouplingDataForTest.build2DTargetMesh_1();
1998         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,NO_TIME);
1999         f.setMesh(m);
2000         self.assertEqual(5,f.getNumberOfMeshPlacesExpected());
2001         self.assertEqual(0,f.getNbOfGaussLocalization());
2002         f.setGaussLocalizationOnType(NORM_TRI3,_refCoo1,_gsCoo1,_wg1);
2003         f.setGaussLocalizationOnType(NORM_TRI3,_refCoo1,_gsCoo1,_wg1); # not a bug only to check that it works well
2004         self.assertRaises(InterpKernelException,f.setGaussLocalizationOnType,NORM_QUAD4,_refCoo1,_gsCoo1,_wg1)
2005         self.assertEqual(1,f.getNbOfGaussLocalization());
2006         refCoo2=[ 0.,0., 1.,0., 1.,1., 0.,1. ]
2007         _refCoo2=refCoo2
2008         _gsCoo1=_gsCoo1[0:4]
2009         _wg1=_wg1[0:2]
2010         f.setGaussLocalizationOnType(NORM_QUAD4,_refCoo2,_gsCoo1,_wg1);
2011         self.assertEqual(2,f.getNbOfGaussLocalization());
2012         array=DataArrayDouble.New();
2013         ptr=18*2*[None]
2014         for i in xrange(18*2):
2015             ptr[i]=float(i+1)
2016         array.setValues(ptr,18,2);
2017         ptr=array.getPointer();
2018         f.setArray(array);
2019         f.setName("MyFirstFieldOnGaussPoint");
2020         f.checkCoherency();
2021         self.assertAlmostEqual(27.,f.getIJK(2,5,0),14);
2022         self.assertAlmostEqual(16.,f.getIJK(1,5,1),14);
2023         #
2024         f.clearGaussLocalizations();
2025         self.assertEqual(0,f.getNbOfGaussLocalization());
2026         self.assertRaises(InterpKernelException,f.checkCoherency);
2027         ids1=[0,1,3,4]
2028         self.assertRaises(InterpKernelException,f.setGaussLocalizationOnCells,ids1,_refCoo2,_gsCoo1,_wg1);
2029         self.assertEqual(0,f.getNbOfGaussLocalization());
2030         ids2=[0,4]
2031         f.setGaussLocalizationOnCells(ids2,_refCoo2,_gsCoo1,_wg1);
2032         self.assertEqual(1,f.getNbOfGaussLocalization());
2033         self.assertEqual(0,f.getGaussLocalizationIdOfOneCell(0));
2034         self.assertRaises(InterpKernelException,f.getGaussLocalizationIdOfOneCell,1);
2035         ids3=[1,2]
2036         f.setGaussLocalizationOnCells(ids3,_refCoo1,_gsCoo1,_wg1);
2037         self.assertEqual(2,f.getNbOfGaussLocalization());
2038         self.assertEqual(0,f.getGaussLocalizationIdOfOneCell(0));
2039         self.assertEqual(1,f.getGaussLocalizationIdOfOneCell(1));
2040         self.assertEqual(1,f.getGaussLocalizationIdOfOneCell(2));
2041         self.assertRaises(InterpKernelException,f.checkCoherency);#<- cell 3 has no localization
2042         ids4=[3]
2043         _gsCoo2=_gsCoo1;
2044         _wg2=_wg1;
2045         _gsCoo2[0]=0.8888777776666;
2046         _wg2[0]=0.1234567892377;
2047         f.setGaussLocalizationOnCells(ids4,_refCoo2,_gsCoo2,_wg2);
2048         self.assertEqual(3,f.getNbOfGaussLocalization());
2049         tmpIds=f.getCellIdsHavingGaussLocalization(0);
2050         self.assertEqual(ids2,list(tmpIds.getValues()));
2051         self.assertRaises(InterpKernelException,f.checkCoherency);#<- it's always not ok because undelying array not with the good size.
2052         array2=f.getArray().substr(0,10);
2053         f.setArray(array2);
2054         f.checkCoherency();#<- here it is OK
2055         f2=f.clone(True);
2056         self.assertTrue(f.isEqual(f2,1e-14,1e-14));
2057         gl1=f2.getGaussLocalization(0);
2058         tmp=gl1.getGaussCoord(1,1);
2059         self.assertAlmostEqual(2.07*_b-1,tmp,14);
2060         gl1.setGaussCoord(1,1,0.07);
2061         self.assertTrue(not f.isEqual(f2,1e-14,1e-14));
2062         gl1.setGaussCoord(1,1,tmp);
2063         self.assertTrue(f.isEqual(f2,1e-14,1e-14));
2064         f2.checkCoherency();
2065         pass
2066
2067     def testGaussPointNEField1(self):
2068         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2069         f=MEDCouplingFieldDouble.New(ON_GAUSS_NE,NO_TIME);
2070         f.setMesh(m);
2071         self.assertEqual(5,f.getNumberOfMeshPlacesExpected());
2072         f.setName("MyFirstFieldOnNE");
2073         f.setDescription("MyDescriptionNE");
2074         array=DataArrayDouble.New();
2075         tmp=18*2*[None]
2076         for i in xrange(18*2):
2077             tmp[i]=float(i+7)
2078             pass
2079         array.setValues(tmp,18,2);
2080         ptr=array.getPointer();
2081         f.setArray(array);
2082         #
2083         f.checkCoherency();
2084         f2=f.clone(True);
2085         self.assertTrue(f.isEqual(f2,1e-14,1e-14));
2086         self.assertAlmostEqual(21.,f.getIJK(2,0,0),14);
2087         self.assertAlmostEqual(18.,f.getIJK(1,1,1),14);
2088         pass
2089
2090     def testCellOrientation1(self):
2091         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2092         vec=[0.,0.,-1.]
2093         self.assertRaises(InterpKernelException,m.are2DCellsNotCorrectlyOriented,vec,False);
2094         m.changeSpaceDimension(3);
2095         res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2096         self.assertTrue(len(res1)==0);
2097         vec[2]=1.;
2098         res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2099         self.assertEqual(5,len(res1));
2100         #
2101         vec[2]=-1.;
2102         # connectivity inversion
2103         conn=m.getNodalConnectivity().getValues();
2104         tmp=conn[11];
2105         conn[11]=conn[12];
2106         conn[12]=tmp;
2107         m.getNodalConnectivity().setValues(conn,len(conn),1)
2108         res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2109         self.assertEqual(1,len(res1));
2110         self.assertEqual(2,res1.getValues()[0]);
2111         m.orientCorrectly2DCells(vec,False);
2112         res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2113         self.assertTrue(len(res1)==0);
2114         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
2115         m2.changeSpaceDimension(3);
2116         self.assertTrue(m.isEqual(m2,1e-12));
2117         pass
2118
2119     def testCellOrientation2(self):
2120         m2,m1=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
2121         res1=m2.arePolyhedronsNotCorrectlyOriented();
2122         self.assertEqual(6,len(res1));
2123         m2.orientCorrectlyPolyhedrons();
2124         res1=m2.arePolyhedronsNotCorrectlyOriented();
2125         self.assertTrue(len(res1)==0);
2126         m2.checkCoherency();
2127         self.assertEqual(18,m2.getNumberOfCells());
2128         cellIds2=[0,6,12]
2129         m2.convertToPolyTypes(cellIds2);
2130         m2.orientCorrectlyPolyhedrons();
2131         res1=m2.arePolyhedronsNotCorrectlyOriented();
2132         self.assertTrue(len(res1)==0);
2133         f2=m2.getMeasureField(False);
2134         f2Ptr=f2.getArray().getValues();
2135         #Test to check global reverse in MEDCouplingUMesh::tryToCorrectPolyhedronOrientation
2136         m3=MEDCouplingDataForTest.build2DTargetMesh_1();
2137         vec=[0.,0.,1.]
2138         m3.changeSpaceDimension(3);
2139         ids2=[0,1,2,3,4]
2140         m3.convertToPolyTypes(ids2);
2141         m3.orientCorrectly2DCells(vec,False);
2142         m4=MEDCouplingDataForTest.buildCU1DMesh_U();
2143         m4.changeSpaceDimension(3);
2144         center=[0.,0.,0.]
2145         vector=[0.,1.,0.]
2146         m4.rotate(center,vector,-pi/2.);
2147         m5=m3.buildExtrudedMesh(m4,0);
2148         res1=m5.arePolyhedronsNotCorrectlyOriented();
2149         self.assertEqual(15,len(res1));
2150         m5.orientCorrectlyPolyhedrons();
2151         res1=m5.arePolyhedronsNotCorrectlyOriented();
2152         self.assertTrue(len(res1)==0);
2153         f3=m5.getMeasureField(False);
2154         self.assertEqual(15,f3.getArray().getNumberOfTuples());
2155         self.assertEqual(1,f3.getNumberOfComponents());
2156         f3Ptr=f3.getArray().getValues();
2157         expected1=[0.075,0.0375,0.0375,0.075,0.075, 0.1125,0.05625,0.05625,0.1125,0.1125, 0.0625,0.03125,0.03125,0.0625,0.0625];
2158         for i in xrange(15):
2159             self.assertTrue(abs(expected1[i]-f3Ptr[i])<1e-12);
2160             pass
2161         f4=m5.getBarycenterAndOwner();
2162         self.assertEqual(15,f4.getNumberOfTuples());
2163         self.assertEqual(3,f4.getNumberOfComponents());
2164         f4Ptr=f4.getValues();
2165         expected2=[-0.05,-0.05,0.15, 0.3666666666666667,-0.13333333333333333,0.15, 0.53333333333333333,0.033333333333333333,0.15, -0.05,0.45,0.15, 0.45,0.45,0.15,-0.05,-0.05,0.525, 0.3666666666666667,-0.13333333333333333,0.525, 0.53333333333333333,0.033333333333333333,0.525, -0.05,0.45,0.525, 0.45,0.45,0.525,-0.05,-0.05,0.875, 0.3666666666666667,-0.13333333333333333,0.875, 0.53333333333333333,0.033333333333333333,0.875, -0.05,0.45,0.875, 0.45,0.45,0.875];
2166         for i in xrange(45):
2167             self.assertTrue(abs(expected2[i]-f4Ptr[i])<1e-12);
2168             pass
2169         pass
2170
2171     def testPolyhedronBarycenter(self):
2172         connN=[0,3,2,1, -1, 4,5,6,7, -1, 0,4,7,3, -1, 3,7,6,2, -1, 2,6,5,1, -1, 1,5,4,0];
2173         coords=[0.,0.,0., 1.,0.,0., 1.,1.,0., 0.,1.,0., 0.,0.,1., 1.,0.,1., 1.,1.,1., 0.,1.,1., 0.5, 0.5, 0.5];
2174         meshN=MEDCouplingUMesh.New();
2175         meshN.setName("ForBary");
2176         meshN.setMeshDimension(3);
2177         meshN.allocateCells(4);
2178         meshN.insertNextCell(NORM_POLYHED,29,connN[0:29])
2179         meshN.finishInsertingCells();
2180         myCoords=DataArrayDouble.New();
2181         myCoords.setValues(coords,9,3);
2182         meshN.setCoords(myCoords);
2183         meshN.checkCoherency();
2184         #
2185         res1=meshN.arePolyhedronsNotCorrectlyOriented();
2186         meshN.orientCorrectlyPolyhedrons();
2187         self.assertTrue(len(res1)==0);
2188         da=meshN.getBarycenterAndOwner();
2189         self.assertEqual(1,da.getNumberOfTuples());
2190         self.assertEqual(3,da.getNumberOfComponents());
2191         daPtr=da.getValues();
2192         ref=meshN.getCoords().getValues()[24:];
2193         for i in xrange(3):
2194             self.assertTrue(abs(ref[i]-daPtr[i])<1e-12);
2195             pass
2196         #
2197         center=[0.,0.,0.]
2198         vec=[0.,2.78,0.]
2199         da=meshN.getBarycenterAndOwner();
2200         daPtr=da.getValues();
2201         ref=meshN.getCoords().getValues()[24:];
2202         for i in xrange(3):
2203             self.assertTrue(abs(ref[i]-daPtr[i])<1e-12);
2204             pass
2205         #
2206         meshN.rotate(center,vec,pi/7.);
2207         meshN.translate(vec);
2208         da=meshN.getBarycenterAndOwner();
2209         daPtr=da.getValues();
2210         ref=meshN.getCoords().getValues()[24:];
2211         for i in xrange(3):
2212             self.assertTrue(abs(ref[i]-daPtr[i])<1e-12);
2213             pass
2214         #
2215         center2=[1.12,3.45,6.78]
2216         vec2=[4.5,9.3,2.8]
2217         meshN.rotate(center2,vec2,e);
2218         meshN.translate(vec2);
2219         da=meshN.getBarycenterAndOwner();
2220         daPtr=da.getValues();
2221         ref=meshN.getCoords().getValues()[24:];
2222         for i in xrange(3):
2223             self.assertTrue(abs(ref[i]-daPtr[i])<1e-10);
2224             pass
2225         pass
2226
2227     def testNormL12Integ1D(self):
2228         m1=MEDCouplingDataForTest.build1DTargetMesh_3();
2229         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2230         f1.setMesh(m1);
2231         array=DataArrayDouble.New();
2232         arr=[-5.23,15.45,-25.56,6.67,-16.78,26.89,-7.91,17.23,-27.43,8.21,-18.63,28.72]
2233         array.setValues(arr,m1.getNumberOfCells(),3);
2234         f1.setArray(array);
2235         #
2236         f3=m1.getBarycenterAndOwner();
2237         self.assertEqual(4,f3.getNumberOfTuples());
2238         self.assertEqual(1,f3.getNumberOfComponents());
2239         expected9=[0.75,5.105,0.8,5.155]
2240         ptr=f3.getValues();
2241         for i in xrange(4):
2242             self.assertTrue(abs(expected9[i]-ptr[i])<1e-12);
2243             pass
2244         #
2245         f2=m1.getMeasureField(False);
2246         self.assertEqual(4,f2.getArray().getNumberOfTuples());
2247         self.assertEqual(1,f2.getNumberOfComponents());
2248         expected1=[0.5,0.21,-0.6,-0.31]
2249         ptr=f2.getArray().getValues();
2250         for i in xrange(4):
2251             self.assertTrue(abs(expected1[i]-ptr[i])<1e-12);
2252             pass
2253         expected2=[0.5,0.21,0.6,0.31]
2254         f2=m1.getMeasureField(True);
2255         ptr=f2.getArray().getValues();
2256         for i in xrange(4):
2257             self.assertTrue(abs(expected2[i]-ptr[i])<1e-12);
2258             pass
2259         #integral
2260         self.assertTrue(4,f1.getNumberOfTuples())
2261         res=f1.integral(False);
2262         self.assertTrue(3,len(res))
2263         expected3=[0.9866,-0.3615,0.4217]
2264         for i in xrange(3):
2265             self.assertTrue(abs(expected3[i]-res[i])<1e-12);
2266             pass
2267         self.assertTrue(abs(expected3[0]-f1.integral(0,False))<1e-12);
2268         self.assertTrue(abs(expected3[1]-f1.integral(1,False))<1e-12);
2269         self.assertTrue(abs(expected3[2]-f1.integral(2,False))<1e-12);
2270         res=f1.integral(True);
2271         expected4=[-3.4152,8.7639,-14.6879]
2272         for i in xrange(3):
2273             self.assertTrue(abs(expected4[i]-res[i])<1e-12);
2274             pass
2275         #normL1
2276         res=f1.normL1();
2277         self.assertTrue(3,len(res))
2278         expected5=[6.979506172839505, 16.89018518518518, 27.02969135802469]
2279         for i in xrange(3):
2280             self.assertTrue(abs(expected5[i]-res[i])<1e-12);
2281             pass
2282         self.assertTrue(abs(expected5[0]-f1.normL1(0))<1e-12);
2283         self.assertTrue(abs(expected5[1]-f1.normL1(1))<1e-12);
2284         self.assertTrue(abs(expected5[2]-f1.normL1(2))<1e-12);
2285         #normL2
2286         res=f1.normL2();
2287         self.assertTrue(3,len(res))
2288         expected7=[7.090910979452395, 16.9275542960123, 27.053271464160858]
2289         for i in xrange(3):
2290             self.assertTrue(abs(expected7[i]-res[i])<1e-9);
2291             pass
2292         self.assertTrue(abs(expected7[0]-f1.normL2(0))<1e-9);
2293         self.assertTrue(abs(expected7[1]-f1.normL2(1))<1e-9);
2294         self.assertTrue(abs(expected7[2]-f1.normL2(2))<1e-9);
2295         #buildMeasureField
2296         f4=f1.buildMeasureField(False);
2297         self.assertTrue(abs(-0.2-f4.accumulate(0))<1e-12);
2298         f4=f1.buildMeasureField(True);
2299         self.assertTrue(abs(1.62-f4.accumulate(0))<1e-12);
2300         # Testing with 2D Curve
2301         m1=MEDCouplingDataForTest.build2DCurveTargetMesh_3();
2302         f2=m1.getMeasureField(False);
2303         self.assertEqual(4,f2.getArray().getNumberOfTuples());
2304         self.assertEqual(1,f2.getNumberOfComponents());
2305         ptr=f2.getArray().getValues();
2306         for i in xrange(4):
2307             self.assertTrue(abs(sqrt(2.)*expected2[i]-ptr[i])<1e-12);
2308             pass
2309         f2=m1.getMeasureField(True);
2310         self.assertEqual(4,f2.getArray().getNumberOfTuples());
2311         self.assertEqual(1,f2.getNumberOfComponents());
2312         ptr=f2.getArray().getValues();
2313         for i in xrange(4):
2314             self.assertTrue(abs(expected2[i]*sqrt(2.)-ptr[i])<1e-12);
2315             pass
2316         #bary
2317         f3=m1.getBarycenterAndOwner();
2318         self.assertEqual(4,f3.getNumberOfTuples());
2319         self.assertEqual(2,f3.getNumberOfComponents());
2320         expected10=[0.75,0.75,5.105,5.105,0.8,0.8,5.155,5.155]
2321         ptr=f3.getValues();
2322         for i in xrange(8):
2323             self.assertTrue(abs(expected10[i]-ptr[i])<1e-12);
2324             pass
2325         #
2326         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2327         f1.setMesh(m1);
2328         array=DataArrayDouble.New();
2329         array.setValues(arr,m1.getNumberOfCells(),3);
2330         f1.setArray(array);
2331         res=f1.integral(False);
2332         for i in xrange(3):
2333             self.assertTrue(abs(sqrt(2.)*expected4[i]-res[i])<1e-12);
2334             pass
2335         res=f1.integral(True);
2336         for i in xrange(3):
2337             self.assertTrue(abs(sqrt(2.)*expected4[i]-res[i])<1e-12);
2338             pass
2339         res=f1.normL1();
2340         for i in xrange(3):
2341             self.assertTrue(abs(expected5[i]-res[i])<1e-12);
2342             pass
2343         res=f1.normL2();
2344         for i in xrange(3):
2345             self.assertTrue(abs(expected7[i]-res[i])<1e-12);
2346             pass
2347         pass
2348
2349     def testAreaBary2D(self):
2350         m1=MEDCouplingDataForTest.build2DTargetMesh_3();
2351         f1=m1.getMeasureField(False);
2352         self.assertEqual(10,f1.getArray().getNumberOfTuples());
2353         self.assertEqual(1,f1.getNumberOfComponents());
2354         expected1=[-0.5,-1,-1.5,-0.5,-1,  0.5,1,1.5,0.5,1]
2355         ptr=f1.getArray().getValues();
2356         for i in xrange(10):
2357             self.assertTrue(abs(expected1[i]-ptr[i])<1e-12);
2358             pass
2359         f1=m1.getMeasureField(True);
2360         ptr=f1.getArray().getValues();
2361         for i in xrange(10):
2362             self.assertTrue(abs(abs(expected1[i])-ptr[i])<1e-12);
2363             pass
2364         f2=m1.getBarycenterAndOwner();
2365         self.assertEqual(10,f2.getNumberOfTuples());
2366         self.assertEqual(2,f2.getNumberOfComponents());
2367         expected2=[0.5,0.3333333333333333,0.5,0.5,0.5,0.77777777777777777,0.5,0.3333333333333333,0.5,0.5,0.5,0.3333333333333333,0.5,0.5,0.5,0.77777777777777777,0.5,0.3333333333333333,0.5,0.5]
2368         ptr=f2.getValues();
2369         for i in xrange(20):
2370             self.assertTrue(abs(expected2[i]-ptr[i])<1e-12);
2371             pass
2372         m1.changeSpaceDimension(3);
2373         f1=m1.getMeasureField(False);
2374         self.assertEqual(10,f1.getArray().getNumberOfTuples());
2375         self.assertEqual(1,f1.getNumberOfComponents());
2376         ptr=f1.getArray().getValues();
2377         for i in xrange(10):
2378             self.assertTrue(abs(abs(expected1[i])-ptr[i])<1e-12);
2379             pass
2380         f2=m1.getBarycenterAndOwner();
2381         self.assertEqual(10,f2.getNumberOfTuples());
2382         self.assertEqual(3,f2.getNumberOfComponents());
2383         ptr=f2.getValues();
2384         expected3=[0.5,0.3333333333333333,0.,0.5,0.5,0.,0.5,0.77777777777777777,0.,0.5,0.3333333333333333,0.,0.5,0.5,0., 0.5,0.3333333333333333,0.,0.5,0.5,0.,0.5,0.77777777777777777,0.,0.5,0.3333333333333333,0.,0.5,0.5,0.]
2385         for i in xrange(30):
2386             self.assertTrue(abs(expected3[i]-ptr[i])<1e-12);
2387             pass
2388         pass
2389
2390     def testAreaBary3D(self):
2391         coords=[ 0.241310763507 , 0.0504777305619 , 0.0682283524903 , 0.252501053866 , -0.0625176732937 , 0.137272639894 ,
2392                  0.152262663601 , 0.241816569527 , 0.133812556197 , 0.18047750211 , -0.0789949051358 , 0.339098173401 ,
2393                  0.151741971857 , 0.238885278571 , 0.137715037333 , 0.242532155481 , -0.0928169086456 , 0.0678043417367 ,
2394                  0.240941965335 , -0.015461491464 , 0.0617186345825 , 0.24127650112 , 0.0499427876717 , 0.0679634099148 ,
2395                  -0.145828917428 , 0.206291632565 , 0.0310071927543 , 0.0125651775307 , 0.266262085828 , 0.105228430543 ,
2396                  -0.0994066533286 , 0.233224271238 , 0.0572213839567 , -0.0951345338317 , 0.234819509426 , 0.0592126284538 ,
2397                  0.136580574205 , -0.205486212579 , 0.0572866072014 , 0.0637270784978 , -0.168886355238 , 0.446614057077 ,
2398                  0.041337157151 , -0.213402568198 , 0.372407095999 , 0.0411601970268 , -0.202387875756 , 0.411334979491 ,
2399                  -0.108355701857 , 0.193636239335 , 0.204886756738 , 0.00639779029829 , 0.155296981517 , 0.252585892979 ,
2400                  0.0262473111702 , -0.112919732543 , 0.424286639249 ,-0.224103052733 , -0.139430015438 , -0.0122352295701 ,
2401                 -0.0312760589481 , -0.274272003594 , 0.0323959636568 , -0.166663422532 , -0.217754445175 , 0.00392109070364 ,
2402                  -0.30586619777 , -0.0475168041091 , -0.0144585228182 , -0.280881480586 , 0.135571293538 , 0.00623923647986 ,
2403                  -0.25548538234 , 0.156819217766 , 0.0645277879769 , -0.131567009284 , 0.184133752309 , 0.206021802753 ,
2404                  -0.196204010965 , 0.151602971681 , 0.212974777736 , -0.183713879463 , 0.0802946639531 , 0.260115662599 ,
2405                  -0.244241178767 , -0.0738873389604 , 0.144590565817 , -0.155804057829 , -0.164892720025 , 0.210613950558 ,
2406                  -0.170950800428 , -0.215099334026 , 0.00610122860092 , -0.30552634869 , -0.0490020791904 , -0.0132786533145 ,
2407                  0.271831011884 , 0.15105657296 , 0.0230534827908 , 0.281919192283 , 0.0898544306288 , -0.0625201489143 ,
2408                  0.260240727276 , -0.0120688706637 , -0.0532316588626 , 0.244947737722 , 0.0197984684293 , 0.0309341209233 ,
2409                  0.23439631578 , 0.229825279875 , 0.0508520585381 , 0.160921316875 , 0.265078502128 , 0.121716560626 ,
2410                  -0.315088694175 , 0.0747700471918 , -0.245836615071 , -0.327728781776 , 0.0857114674649 , -0.239431905957 ,
2411                  -0.308385460634 , 0.145142997084 , -0.149886828433 , 0.0488236045164 , 0.309462801914 , 0.0849169148265 ,
2412                 -0.0244964803395 , 0.33145611751 , -0.0476415818061 , 0.0060567994229 , 0.32418412014 , 0.0367779543812 ,
2413                  -0.0950221448063 , 0.236675326003 , 0.0572594453983 , 0.248723023186 , 0.0886648784791 , -0.176629430538 ,
2414                  0.116796984 , 0.256596599567 , -0.292863523603 , 0.118024552914 , 0.229154257843 , -0.34233232501 ,
2415                  0.217507892549 , -0.0417822335742 , -0.176771782888 , -0.224429321304 , 0.0125595300114 , -0.362064725588 ,
2416                  0.0937301100955 , -0.0500824832657 , -0.299713548444 , -0.244162220397 , 0.0383853931293 , -0.389856984411 ,
2417                  -0.0281989366102 , 0.097392811563 , -0.458244577284 , -0.385010847162 , 0.10122766194 , -0.140052859922 ,
2418                  -0.377936358012 , 0.110875172128 , -0.176207095463 , 0.244483045556 , -0.0991073977045 , 0.0575134372934 ,
2419                 0.262605120167 , -0.100243191645 , -0.0495620806935 , 0.240306880972 , -0.136153701579 , -0.114745281696 ,
2420                  0.215763176129 , -0.0836766059189 , -0.183249640616 , 0.237870396603 , -0.132449578286 , -0.121598854639 ,
2421                  -0.0637683083097 , -0.27921020214 , -0.149112321992 , -0.0856211014977 , -0.2973233473 , -0.0446878139589 ,
2422                  0.104675342288 , -0.0625908305324 , -0.290346256534 , 0.0248264249186 , -0.247797708548 , -0.165830884019 ,
2423                  0.0719302438309 , -0.178468260473 , -0.211432157345 , 0.142871843159 , -0.208769948542 , 0.0454101128246 ,
2424                  0.167803379307 , -0.207851396623 , -0.088802726124 , 0.12868717152 , -0.230920439715 , 0.00760508389036 ,
2425                  -0.0372812069535 , -0.286740286332 , 0.00963701291166 ]
2426
2427         connN = [ #polyhedron 0
2428             0 , 1 , 3 , 4 , 2 , -1 , 1 , 5 , 6 , 7 , 0 , -1 , 0 , 7 , 8 , 10 , 11 , 9 , 2 , -1 , 1 , 5 , 12 , 14 , 15 , 13 , 3 , -1 , 16 , 9 , 2 , 4 , 17 , -1
2429             , 4 , 3 , 13 , 18 , 17 , -1 , 5 , 6 , 19 , 21 , 20 , 12 , -1 , 6 , 7 , 8 , 23 , 22 , 19 , -1 , 23 , 24 , 10 , 8 , -1 , 25 , 11 , 9 , 16 , -1
2430             , 24 , 26 , 25 , 11 , 10 , -1 , 12 , 14 , 20 , -1 , 27 , 28 , 29 , 15 , 13 , 18 , -1 , 14 , 15 , 29 , 30 , 21 , 20 , -1 , 26 , 27 , 18 , 17 , 16 , 25 , -1
2431             , 22 , 19 , 21 , 30 , 31 , -1 , 22 , 31 , 28 , 27 , 26 , 24 , 23 , -1 , 31 , 30 , 29 , 28,
2432             # polyhedron 1
2433             0 , 7 , 8 , 10 , 11 , 9 , 2 , -1 , 32 , 0 , 7 , 35 , 34 , 33 , -1 , 32 , 0 , 2 , 37 , 36 , -1 , 35 , 7 , 8 , 40 , 39 , 38 , -1
2434             , 2 , 37 , 41 , 9 , -1 , 40 , 8 , 10 , 44 , 43 , 42 , -1 , 41 , 9 , 11 , 44 , 43 , -1 , 44 , 11 , 10 , -1 , 32 , 33 , 45 , 47 , 46 , 36 , -1
2435             , 33 , 34 , 48 , 45 , -1 , 35 , 34 , 48 , 50 , 49 , 38 , -1 , 41 , 43 , 42 , 46 , 36 , 37 , -1 , 38 , 39 , 51 , 49 , -1
2436             , 39 , 40 , 42 , 46 , 47 , 52 , 51 , -1 , 45 , 47 , 52 , 50 , 48 , -1 , 52 , 51 , 49 , 50,
2437             # polyhedron 2
2438             6 , 7 , 8 , 23 , 22 , 19 , -1 , 6 , 35 , 7 , -1 , 6 , 35 , 38 , 19 , -1 , 35 , 7 , 8 , 40 , 39 , 38 , -1 , 53 , 22 , 19 , 38 , 39 , 54 , -1
2439             , 23 , 53 , 54 , 40 , 8 , -1 , 53 , 22 , 23 , -1 , 39 , 54 , 40,
2440             # polyhedron 3
2441             35 , 34 , 48 , 50 , 49 , 38 , -1 , 6 , 35 , 34 , 56 , 55 , 5 , -1 , 6 , 35 , 38 , 19 , -1 , 34 , 56 , 57 , 59 , 58 , 48 , -1
2442             , 60 , 61 , 21 , 19 , 38 , 49 , -1 , 62 , 50 , 48 , 58 , -1 , 60 , 63 , 64 , 62 , 50 , 49 , -1 , 5 , 6 , 19 , 21 , 20 , 12 , -1
2443             , 55 , 5 , 12 , 65 , -1 , 66 , 67 , 65 , 55 , 56 , 57 , -1 , 63 , 66 , 57 , 59 , 64 , -1 , 64 , 62 , 58 , 59 , -1
2444             , 60 , 63 , 66 , 67 , 68 , 61 , -1 , 61 , 68 , 20 , 21 , -1 , 67 , 68 , 20 , 12 , 65]
2445
2446         barys = [ -0.0165220465527 , -0.0190922868195 , 0.158882733414 ,
2447                   0.0287618656076 , 0.135874379934 , -0.14601588119 ,
2448                   -0.147128055553 , 0.0465995097041 , -0.049391174453 ,
2449                   -0.00142506732317 , -0.0996953090351 , -0.115159183132 ]
2450         meshN=MEDCouplingUMesh.New();
2451         meshN.setName("ForBary");
2452         meshN.setMeshDimension(3);
2453         meshN.allocateCells(4);
2454         meshN.insertNextCell(NORM_POLYHED,113,connN);
2455         meshN.insertNextCell(NORM_POLYHED,99,connN[113:]);
2456         meshN.insertNextCell(NORM_POLYHED,43,connN[212:]);
2457         meshN.insertNextCell(NORM_POLYHED,92,connN[255:]);
2458         meshN.finishInsertingCells();
2459         myCoords=DataArrayDouble.New();
2460         myCoords.setValues(coords,69,3);
2461         meshN.setCoords(myCoords);
2462         meshN.checkCoherency();
2463         res1=meshN.arePolyhedronsNotCorrectlyOriented();
2464         meshN.orientCorrectlyPolyhedrons();
2465         res1=meshN.arePolyhedronsNotCorrectlyOriented();
2466         self.assertTrue(len(res1)==0);
2467         #
2468         da=meshN.getBarycenterAndOwner();
2469         self.assertEqual(4,da.getNumberOfTuples());
2470         self.assertEqual(3,da.getNumberOfComponents());
2471         daPtr=da.getValues();
2472         for i in xrange(12):
2473             self.assertTrue(abs(barys[i]-daPtr[i])<1e-12);
2474             pass
2475         pass
2476
2477     def testRenumberCellsForFields(self):
2478         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2479         f=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2480         f.setMesh(m);
2481         arr=DataArrayDouble.New();
2482         nbOfCells=m.getNumberOfCells();
2483         values1=[7.,107.,10007.,8.,108.,10008.,9.,109.,10009.,10.,110.,10010.,11.,111.,10011.]
2484         arr.setValues(values1,nbOfCells,3);
2485         f.setArray(arr);
2486         renumber1=[3,1,0,4,2]
2487         loc=[-0.05,-0.05, 0.55,-0.25, 0.55,0.15, -0.05,0.45, 0.45,0.45]
2488         for j in xrange(5):
2489             res=f.getValueOn(loc[2*j:2*j+2]);
2490             for i in xrange(3):
2491                 self.assertTrue(abs(values1[i+3*j]-res[i])<1e-12);
2492                 pass
2493             pass
2494         f.renumberCells(renumber1,False);
2495         ptr=f.getArray().getValues();
2496         expected1=[9.,109.,10009.,8.,108.,10008.,11.,111.,10011.,7.,107.,10007.,10.,110.,10010.]
2497         for i in xrange(15):
2498             self.assertTrue(abs(expected1[i]-ptr[i])<1e-12);
2499             pass
2500         #check that fields remains the same geometrically
2501         for j in xrange(5):
2502             res=f.getValueOn(loc[2*j:2*(j+1)]);
2503             for i in xrange(3):
2504                 self.assertTrue(abs(values1[i+3*j]-res[i])<1e-12);
2505                 pass
2506             pass
2507         #On gauss
2508         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,NO_TIME);
2509         f.setMesh(m);
2510         _a=0.446948490915965;
2511         _b=0.091576213509771;
2512         _p1=0.11169079483905;
2513         _p2=0.0549758718227661;
2514         refCoo1=[ 0.,0., 1.,0., 0.,1. ]
2515         gsCoo1=[ 2*_b-1, 1-4*_b, 2*_b-1, 2.07*_b-1, 1-4*_b, 2*_b-1, 1-4*_a, 2*_a-1, 2*_a-1, 1-4*_a, 2*_a-1, 2*_a-1 ];
2516         wg1=[ 4*_p2, 4*_p2, 4*_p2, 4*_p1, 4*_p1, 4*_p1 ]
2517         _refCoo1=refCoo1[0:6];
2518         _gsCoo1=gsCoo1[0:12];
2519         _wg1=wg1[0:6];
2520         f.setGaussLocalizationOnType(NORM_TRI3,_refCoo1,_gsCoo1,_wg1);
2521         refCoo2=[ 0.,0., 1.,0., 1.,1., 0.,1. ]
2522         _refCoo2=refCoo2[0:8];
2523         _gsCoo1=_gsCoo1[0:4]
2524         _wg1=_wg1[0:2]
2525         f.setGaussLocalizationOnType(NORM_QUAD4,_refCoo2,_gsCoo1,_wg1);
2526         arr=DataArrayDouble.New();
2527         values2=[1.,1001.,2.,1002., 11.,1011.,12.,1012.,13.,1013.,14.,1014.,15.,1015.,16.,1016., 21.,1021.,22.,1022.,23.,1023.,24.,1024.,25.,1025.,26.,1026., 31.,1031.,32.,1032., 41.,1041.,42.,1042.]
2528         arr.setValues(values2,18,2);
2529         f.setArray(arr);
2530         f.checkCoherency();
2531         fCpy=f.clone(True);
2532         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2533         f.renumberCells(renumber1,False);
2534         self.assertTrue(not f.isEqual(fCpy,1e-12,1e-12));
2535         expected2=[21.,1021.,22.,1022.,23.,1023.,24.,1024.,25.,1025.,26.,1026., 11.,1011.,12.,1012.,13.,1013.,14.,1014.,15.,1015.,16.,1016., 41.,1041.,42.,1042., 1.,1001.,2.,1002., 31.,1031.,32.,1032.]
2536         ptr=f.getArray().getValues();
2537         for i in xrange(36):
2538             self.assertTrue(abs(expected2[i]-ptr[i])<1e-12);
2539             pass
2540         renumber2=[2,1,4,0,3]
2541         f.renumberCells(renumber2,False);
2542         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2543         #GaussNE
2544         f=MEDCouplingFieldDouble.New(ON_GAUSS_NE,NO_TIME);
2545         f.setMesh(m);
2546         arr=DataArrayDouble.New();
2547         values3=[1.,1001.,2.,1002.,3.,1003.,4.,1004., 11.,1011.,12.,1012.,13.,1013., 21.,1021.,22.,1022.,23.,1023., 31.,1031.,32.,1032.,33.,1033.,34.,1034., 41.,1041.,42.,1042.,43.,1043.,44.,1044.]
2548         arr.setValues(values3,18,2);
2549         f.setArray(arr);
2550         f.checkCoherency();
2551         fCpy=f.clone(True);
2552         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2553         f.renumberCells(renumber1,False);
2554         self.assertTrue(not f.isEqual(fCpy,1e-12,1e-12));
2555         expected3=[21.,1021.,22.,1022.,23.,1023.,11.,1011.,12.,1012.,13.,1013.,41.,1041.,42.,1042.,43.,1043.,44.,1044.,1.,1001.,2.,1002.,3.,1003.,4.,1004.,31.,1031.,32.,1032.,33.,1033.,34.,1034.]
2556         ptr=f.getArray().getValues();
2557         for i in xrange(36):
2558             self.assertTrue(abs(expected3[i]-ptr[i])<1e-12);
2559             pass
2560         f.renumberCells(renumber2,False);#perform reverse operation of renumbering to check that the resulting field is equal.
2561         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2562         #
2563         pass
2564
2565     def testRenumberNodesForFields(self):
2566         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2567         f=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
2568         f.setMesh(m);
2569         self.assertEqual(9,f.getNumberOfMeshPlacesExpected());
2570         arr=DataArrayDouble.New();
2571         nbOfNodes=m.getNumberOfNodes();
2572         values1=[7.,107.,10007.,8.,108.,10008.,9.,109.,10009.,10.,110.,10010.,11.,111.,10011.,12.,112.,10012.,13.,113.,10013.,14.,114.,10014.,15.,115.,10015.]
2573         arr.setValues(values1,nbOfNodes,3);
2574         f.setArray(arr);
2575         f.checkCoherency();
2576         renumber1=[0,4,1,3,5,2,6,7,8]
2577         loc=[0.5432,-0.2432, 0.5478,0.1528]
2578         expected1=[9.0272, 109.0272, 10009.0272, 11.4124,111.4124,10011.4124]
2579         for j in xrange(2):
2580             res=f.getValueOn(loc[2*j:2*j+2]);
2581             for i in xrange(3):
2582                 self.assertTrue(abs(expected1[i+3*j]-res[i])<1e-12);
2583                 pass
2584             pass
2585         fCpy=f.clone(True);
2586         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2587         f.renumberNodes(renumber1);
2588         self.assertTrue(not f.isEqual(fCpy,1e-12,1e-12));
2589         for j in xrange(2):
2590             res=f.getValueOn(loc[2*j:2*j+2]);
2591             for i in xrange(3):
2592                 self.assertTrue(abs(expected1[i+3*j]-res[i])<1e-12);
2593                 pass
2594             pass
2595         expected2=[7.,107.,10007.,9.,109.,10009.,12.,112.,10012.,10.,110.,10010.,8.,108.,10008.,11.,111.,10011.,13.,113.,10013.,14.,114.,10014.,15.,115.,10015.]
2596         for i in xrange(27):
2597             self.assertTrue(abs(expected2[i]-f.getArray().getValues()[i])<1e-12);
2598             pass
2599         renumber2=[0,2,5,3,1,4,6,7,8]
2600         f.renumberNodes(renumber2);
2601         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2602         pass
2603
2604     def testConvertQuadraticCellsToLinear(self):
2605         mesh=MEDCouplingDataForTest.build2DTargetMesh_3();
2606         mesh.checkCoherency();
2607         types=mesh.getAllTypes();
2608         types.sort()
2609         self.assertEqual(5,len(types));
2610         expected1=[NORM_POLYGON, NORM_TRI3, NORM_QUAD4, NORM_TRI6, NORM_QUAD8]
2611         expected1.sort()
2612         self.assertEqual(expected1,types);
2613         self.assertTrue(mesh.isPresenceOfQuadratic());
2614         self.assertEqual(62,mesh.getMeshLength());
2615         f1=mesh.getMeasureField(False);
2616         #
2617         mesh.convertQuadraticCellsToLinear();
2618         self.assertTrue(not mesh.isPresenceOfQuadratic());
2619         #
2620         mesh.checkCoherency();
2621         f2=mesh.getMeasureField(False);
2622         self.assertTrue(f1.getArray().isEqual(f2.getArray(),1e-12));
2623         self.assertEqual(48,mesh.getMeshLength());
2624         types2=mesh.getAllTypes();
2625         types2.sort()
2626         self.assertEqual(3,len(types2));
2627         expected2=[NORM_POLYGON, NORM_TRI3, NORM_QUAD4]
2628         expected2.sort()
2629         self.assertEqual(expected2,types2);
2630         pass
2631
2632     def testCheckGeoEquivalWith(self):
2633         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2634         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2635         #First test mesh1
2636         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh1,0,1e-12);#deepEqual
2637         self.assertTrue(cellCor==None);
2638         self.assertTrue(nodeCor==None);
2639         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh1,1,1e-12);#fastEqual
2640         self.assertTrue(cellCor==None);
2641         self.assertTrue(nodeCor==None);
2642         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh1,10,1e-12);#deepEqual with geo permutations
2643         self.assertTrue(cellCor==None);
2644         self.assertTrue(nodeCor==None);
2645         #Second test mesh1 and mesh2 are 2 different meshes instance
2646         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,0,1e-12);#deepEqual
2647         self.assertTrue(cellCor==None);
2648         self.assertTrue(nodeCor==None);
2649         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,1,1e-12);#fastEqual
2650         self.assertTrue(cellCor==None);
2651         self.assertTrue(nodeCor==None);
2652         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);#deepEqual with geo permutations
2653         self.assertTrue(cellCor==None);
2654         self.assertTrue(nodeCor==None);
2655         #Third test : cell permutation by keeping the first the middle and the last as it is.
2656         renum=[0,2,1,3,4,5,6,8,7,9]
2657         mesh2.renumberCells(renum,False);
2658         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12);#deepEqual fails
2659         self.assertTrue(cellCor==None);
2660         self.assertTrue(nodeCor==None);
2661         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,1,1e-12);#fastEqual do not see anything
2662         self.assertTrue(cellCor==None);
2663         self.assertTrue(nodeCor==None);
2664         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);#deepEqual with geo permutations
2665         self.assertTrue(cellCor);
2666         self.assertEqual(10,cellCor.getNumberOfTuples());
2667         self.assertEqual(1,cellCor.getNumberOfComponents());
2668         self.assertEqual(renum,list(cellCor.getValues()))
2669         self.assertTrue(nodeCor==None);
2670         cellCor=0;
2671         self.assertTrue(nodeCor==None);
2672         a,b=mesh1.checkDeepEquivalWith(mesh2,0,1e-12);
2673         self.assertEqual(renum,list(a.getValues()))
2674         self.assertTrue(b==None);
2675         mesh2.setCoords(mesh1.getCoords())
2676         a=mesh1.checkDeepEquivalOnSameNodesWith(mesh2,0,1e-12);
2677         self.assertEqual(renum,list(a.getValues()))
2678         #4th test : cell and node permutation by keeping the first the middle and the last as it is.
2679         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2680         renum2=[0,2,1,3,4,5,6,8,7,9,10]
2681         mesh2.renumberCells(renum,False);
2682         mesh2.renumberNodes(renum2,11);
2683         cellCor=None
2684         nodeCor=None
2685         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12);#deepEqual fails
2686         self.assertTrue(cellCor==None);
2687         self.assertTrue(nodeCor==None);
2688         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,1,1e-12);#fastEqual do not see anything
2689         self.assertTrue(cellCor==None);
2690         self.assertTrue(nodeCor==None);
2691         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);#deepEqual with geo permutations
2692         self.assertTrue(cellCor);
2693         self.assertEqual(10,cellCor.getNumberOfTuples());
2694         self.assertEqual(1,cellCor.getNumberOfComponents());
2695         self.assertEqual(renum,list(cellCor.getValues()))
2696         self.assertTrue(nodeCor);
2697         self.assertEqual(11,nodeCor.getNumberOfTuples());
2698         self.assertEqual(1,nodeCor.getNumberOfComponents());
2699         self.assertEqual(renum2,list(nodeCor.getValues()))
2700         cellCor=0;
2701         nodeCor=0;
2702         #5th test : modification of the last cell to check fastCheck detection.
2703         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2704         renum3=[0,2,1,3,4,5,6,8,9,7]
2705         mesh2.renumberCells(renum3,False);
2706         mesh2.renumberNodes(renum2,11);
2707         cellCor=None
2708         nodeCor=None
2709         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12)
2710         self.assertTrue(cellCor==None);
2711         self.assertTrue(nodeCor==None);
2712         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,1,1e-12)
2713         self.assertTrue(cellCor==None);
2714         self.assertTrue(nodeCor==None);
2715         cellCor,nodeCor=mesh2.checkGeoEquivalWith(mesh1,10,1e-12);#deepEqual with geo permutations
2716         self.assertTrue(cellCor!=None);
2717         self.assertEqual(10,cellCor.getNumberOfTuples());
2718         self.assertEqual(1,cellCor.getNumberOfComponents());
2719         self.assertEqual(renum3,list(cellCor.getValues()))
2720         self.assertTrue(nodeCor!=None);
2721         self.assertEqual(11,nodeCor.getNumberOfTuples());
2722         self.assertEqual(1,nodeCor.getNumberOfComponents());
2723         self.assertEqual(renum2,list(nodeCor.getValues()));
2724         pass
2725
2726     def testCheckGeoEquivalWith2(self):
2727         mesh1=MEDCouplingDataForTest.build2DTargetMesh_4();
2728         mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
2729         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);
2730         self.assertEqual(None,cellCor);
2731         self.assertNotEqual(None,nodeCor);
2732         expected1=[0, 1, 3, 4, 5, 6, 7, 8, 9]
2733         for i in xrange(9):
2734             self.assertEqual(expected1[i],nodeCor.getIJ(i,0));
2735             pass
2736         pass
2737
2738     def testCopyTinyStringsFromOnFields(self):
2739         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2740         nbOfCells=m.getNumberOfCells();
2741         f=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
2742         f.setMesh(m);
2743         self.assertEqual(5,f.getNumberOfMeshPlacesExpected());
2744         f.setName("a");
2745         f.setDescription("b");
2746         a1=DataArrayDouble.New();
2747         a1.alloc(nbOfCells,2);
2748         a1.fillWithZero();
2749         a1.setInfoOnComponent(0,"c");
2750         a1.setInfoOnComponent(1,"d");
2751         a2=a1.deepCpy();
2752         a2.setInfoOnComponent(0,"e");
2753         a2.setInfoOnComponent(1,"f");
2754         f.setArray(a1);
2755         f.setEndArray(a2);
2756         f.setEndTime(3.,3,4);
2757         m.setName("g");
2758         m.getCoords().setInfoOnComponent(0,"h");
2759         m.getCoords().setInfoOnComponent(1,"i");
2760         m.getCoords().setInfoOnComponent(2,"j");
2761         #
2762         f.checkCoherency();
2763         f2=f.clone(True);
2764         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2765         f2.setName("smth");
2766         self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2767         f2.copyTinyStringsFrom(f);
2768         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2769         f2.setDescription("GGG");
2770         self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2771         f2.copyTinyStringsFrom(f);
2772         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2773         f2.getArray().setInfoOnComponent(0,"mmmm");
2774         self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2775         f2.copyTinyStringsFrom(f);
2776         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2777         f2.getEndArray().setInfoOnComponent(1,"mmmm");
2778         self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2779         f2.copyTinyStringsFrom(f);
2780         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2781         m2=m.clone(True);
2782         self.assertTrue(m2.isEqual(m,1e-12));
2783         m2.setName("123");
2784         self.assertTrue(not m2.isEqual(m,1e-12));
2785         m2.copyTinyStringsFrom(m);
2786         self.assertTrue(m2.isEqual(m,1e-12));
2787         m2.getCoords().setInfoOnComponent(1,"eee");
2788         self.assertTrue(not m2.isEqual(m,1e-12));
2789         m2.copyTinyStringsFrom(m);
2790         self.assertTrue(m2.isEqual(m,1e-12));
2791         pass
2792
2793     def testTryToShareSameCoordsPermute(self):
2794         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2795         m2=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2796         #self.assertTrue(m.getCoords()!=m2.getCoords());
2797         m.tryToShareSameCoordsPermute(m2,1e-12);
2798         #self.assertTrue(m.getCoords()==m2.getCoords());
2799         self.assertTrue(m2.isEqual(m,1e-12));
2800         renum1=[1,2,0,5,8,7,4,3,6]
2801         r1=DataArrayInt.New()
2802         r1.setValues(renum1,len(renum1),1)
2803         m.renumberNodes(r1,9);
2804         #self.assertTrue(m.getCoords()!=m2.getCoords());
2805         self.assertTrue(not m2.isEqual(m,1e-12));
2806         m.tryToShareSameCoordsPermute(m2,1e-12);
2807         #self.assertTrue(m.getCoords()==m2.getCoords());
2808         self.assertTrue(m2.isEqual(m,1e-12));
2809         pass
2810
2811     def testTryToShareSameCoordsPermute2(self):
2812         m1=MEDCouplingDataForTest.build2DTargetMesh_4();
2813         targetCoords=[-0.3,-0.3, 0.2,-0.3, -0.3,0.2, 0.2,0.2 ]
2814         targetConn=[0,2,3,1]
2815         m2=MEDCouplingUMesh.New();
2816         m2.setMeshDimension(2);
2817         m2.allocateCells(1);
2818         m2.insertNextCell(NORM_QUAD4,targetConn[0:4])
2819         m2.finishInsertingCells();
2820         myCoords=DataArrayDouble.New();
2821         myCoords.setValues(targetCoords,4,2);
2822         m2.setCoords(myCoords);
2823         m2.checkCoherency();
2824         m1.checkCoherency();
2825         #
2826         expected1=[0.25,0.125,0.125,0.25,0.25]
2827         f1=m1.getMeasureField(False);
2828         f2=m2.getMeasureField(False);
2829         self.assertEqual(5,f1.getArray().getNumberOfTuples());
2830         self.assertEqual(1,f2.getArray().getNumberOfTuples());
2831         for i in xrange(5):
2832             self.assertAlmostEqual(expected1[i],f1.getIJ(i,0),12);
2833             pass
2834         self.assertAlmostEqual(expected1[0],f2.getIJ(0,0),12);
2835         self.assertRaises(InterpKernelException,m1.tryToShareSameCoordsPermute,m2,1e-12);# <- here in this order the sharing is impossible.
2836         # Let's go for deeper test of tryToShareSameCoordsPermute
2837         m2.tryToShareSameCoordsPermute(m1,1e-12);
2838         f1=m1.getMeasureField(False);
2839         f2=m2.getMeasureField(False);
2840         self.assertEqual(5,f1.getArray().getNumberOfTuples());
2841         self.assertEqual(1,f2.getArray().getNumberOfTuples());
2842         for i in xrange(5):
2843             self.assertAlmostEqual(expected1[i],f1.getIJ(i,0),12);
2844             pass
2845         self.assertAlmostEqual(expected1[0],f2.getIJ(0,0),12);
2846         pass
2847
2848     def testChangeUnderlyingMesh1(self):
2849         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2850         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2851         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2852         f1.setMesh(mesh1);
2853         array=DataArrayDouble.New();
2854         arr=[7., 107., 8., 108., 9., 109., 10., 110., 11., 111., 12., 112., 13., 113., 14., 114., 15., 115., 16., 116.]
2855         array.setValues(arr,mesh1.getNumberOfCells(),2);
2856         f1.setArray(array);
2857         #
2858         renum=[0,2,1,3,4,5,6,8,7,9]
2859         mesh2.renumberCells(renum,False);
2860         #self.assertTrue(f1.getMesh()==mesh1);
2861         f1.changeUnderlyingMesh(mesh1,10,1e-12);# nothing done only to check that nothing done.
2862         #self.assertTrue(f1.getMesh()==mesh1);
2863         f1.changeUnderlyingMesh(mesh2,10,1e-12);
2864         #self.assertTrue(f1.getMesh()==mesh2);
2865         expected1=[7.,107.,9.,109.,8.,108.,10.,110.,11.,111.,12.,112.,13.,113.,15.,115.,14.,114.,16.,116.]
2866         for i in xrange(20):
2867             self.assertAlmostEqual(expected1[i],f1.getArray().getIJ(0,i),12);
2868             pass
2869         #
2870         f1=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
2871         f1.setMesh(mesh1);
2872         array=DataArrayDouble.New();
2873         arr2=[7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.,17.,117.]
2874         array.setValues(arr2,mesh1.getNumberOfNodes(),2);
2875         f1.setArray(array);
2876         #
2877         renum2=[0,2,10,3,4,5,6,8,7,9,1]
2878         mesh2.renumberNodes(renum2,11);
2879         #self.assertTrue(f1.getMesh()==mesh1);
2880         f1.changeUnderlyingMesh(mesh2,10,1e-12);
2881         #self.assertTrue(f1.getMesh()==mesh2);
2882         expected2=[7.,107.,17.,117.,8.,108.,10.,110.,11.,111.,12.,112.,13.,113.,15.,115.,14.,114.,16.,116.,9.,109.]
2883         for i in xrange(22):
2884             self.assertAlmostEqual(expected2[i],f1.getArray().getIJ(0,i),12);
2885             pass
2886         pass
2887
2888     def testGetMaxValue1(self):
2889         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2890         nbOfCells=m.getNumberOfCells();
2891         f=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
2892         f.setMesh(m);
2893         a1=DataArrayDouble.New();
2894         val1=[3.,4.,5.,6.,7.]
2895         a1.setValues(val1,nbOfCells,1);
2896         a2=DataArrayDouble.New();
2897         val2=[0.,1.,2.,8.,7.]
2898         a2.setValues(val2,nbOfCells,1);
2899         f.setArray(a1);
2900         f.setEndArray(a2);
2901         f.setEndTime(3.,3,4);
2902         f.checkCoherency();
2903         #
2904         self.assertAlmostEqual(8.,f.getMaxValue(),14);
2905         self.assertAlmostEqual(0.,f.getMinValue(),14);
2906         self.assertAlmostEqual(5.,f.getAverageValue(),14);
2907         self.assertAlmostEqual(5.125,f.getWeightedAverageValue(0,True),14);
2908         a1.setIJ(0,2,9.5);
2909         self.assertAlmostEqual(9.5,f.getMaxValue(),14);
2910         self.assertAlmostEqual(0.,f.getMinValue(),14);
2911         a2.setIJ(0,0,9.);
2912         self.assertAlmostEqual(9.5,f.getMaxValue(),14);
2913         self.assertAlmostEqual(1.,f.getMinValue(),14);
2914         pass
2915
2916     def testSubstractInPlaceDM1(self):
2917         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2918         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2919         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2920         f1.setMesh(mesh1);
2921         array=DataArrayDouble.New();
2922         arr=[7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.]
2923         array.setValues(arr,mesh1.getNumberOfCells(),2);
2924         f1.setArray(array);
2925         #
2926         self.assertEqual(10,f1.getNumberOfTuples());
2927         self.assertEqual(2,f1.getNumberOfComponents());
2928         self.assertEqual(20,f1.getNumberOfValues());
2929         #
2930         renum=[0,2,3,1,4,5,6,8,7,9]
2931         mesh2.renumberCells(renum,False);
2932         #
2933         f2=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2934         f2.setMesh(mesh2);
2935         array=DataArrayDouble.New();
2936         arr2=[7.1,107.1,10.1,110.1,8.1,108.1,9.1,109.1,11.1,111.1,12.1,112.1,13.1,113.1,15.1,115.1,14.1,114.1,16.1,116.1]
2937         array.setValues(arr2,mesh2.getNumberOfCells(),2);
2938         f2.setArray(array);
2939         #
2940         f1.substractInPlaceDM(f2,10,1e-12);
2941         f1.applyFunc(1,"abs(x+y+0.2)");
2942         self.assertAlmostEqual(0.,f1.getMaxValue(),13);
2943         pass
2944
2945     def testDotCrossProduct1(self):
2946         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2947         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
2948         f1.setTime(2.3,5,6);
2949         f1.setMesh(mesh1);
2950         array=DataArrayDouble.New();
2951         arr1=[7.,107.,207.,8.,108.,208.,9.,109.,209.,10.,110.,210.,11.,111.,211.,12.,112.,212.,13.,113.,213.,14.,114.,214.,15.,115.,215.,16.,116.,216.]
2952         array.setValues(arr1,mesh1.getNumberOfCells(),3);
2953         f1.setArray(array);
2954         f2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
2955         f2.setTime(7.8,4,5);
2956         f2.setMesh(mesh1);
2957         array=DataArrayDouble.New();
2958         arr2=[1.,2.,3.,4.,5.,6.,7.,8.,9.,10.,11.,12.,13.,14.,15.,16.,17.,18.,19.,20.,21.,22.,23.,24.,25.,26.,27.,28.,29.,30.]
2959         array.setValues(arr2,mesh1.getNumberOfCells(),3);
2960         f2.setArray(array);
2961         #
2962         f3=f1.dot(f2);
2963         expected1=[842.,1820.,2816.,3830.,4862.,5912.,6980.,8066.,9170.,10292.]
2964         for i in xrange(10):
2965             self.assertAlmostEqual(expected1[i],f3.getIJ(i,0),9);
2966             pass
2967         #
2968         f4=f1.crossProduct(f2);
2969         expected2=[-93., 186., -93., -392., 784., -392., -691., 1382., -691., -990., 1980., -990., -1289., 2578., -1289., -1588., 3176., -1588., -1887., 3774., -1887., -2186., 4372., -2186., -2485., 4970., -2485., -2784., 5568., -2784.]
2970         for i in xrange(30):
2971             self.assertAlmostEqual(expected2[i],f4.getIJ(0,i),9);
2972             pass
2973         pass
2974
2975     def testMinMaxFields1(self):
2976         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2977         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
2978         f1.setTime(2.3,5,6);
2979         f1.setMesh(mesh1);
2980         array=DataArrayDouble.New();
2981         arr1=[7.,107.,207.,8.,108.,208.,9.,109.,209.,10.,110.,210.,11.,111.,211.,12.,112.,212.,13.,113.,213.,14.,114.,214.,15.,115.,215.,16.,116.,216.]
2982         array.setValues(arr1,mesh1.getNumberOfCells(),3);
2983         f1.setArray(array);
2984         f2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
2985         f2.setTime(7.8,4,5);
2986         f2.setMesh(mesh1);
2987         array=DataArrayDouble.New();
2988         arr2=[6.,108.,206.,9.,107.,209.,8.,110.,208.,11.,109.,211.,10.,112.,210.,13.,111.,213.,12.,114.,212.,15.,113.,215.,14.,116.,214.,17.,115.,217.]
2989         array.setValues(arr2,mesh1.getNumberOfCells(),3);
2990         f2.setArray(array);
2991         #
2992         f3=f1.max(f2);
2993         expected1=[7.,108.,207.,9.,108.,209.,9.,110.,209.,11.,110.,211.,11.,112.,211.,13.,112.,213.,13.,114.,213.,15.,114.,215.,15.,116.,215.,17.,116.,217.]
2994         for i in xrange(30):
2995             self.assertAlmostEqual(expected1[i],f3.getIJ(0,i),9);
2996             pass
2997         #
2998         f4=f1.min(f2);
2999         expected2=[6.,107.,206.,8.,107.,208.,8.,109.,208.,10.,109.,210.,10.,111.,210.,12.,111.,212.,12.,113.,212.,14.,113.,214.,14.,115.,214.,16.,115.,216.]
3000         for i in xrange(30):
3001             self.assertAlmostEqual(expected2[i],f4.getIJ(0,i),9);
3002             pass
3003         #
3004         pass
3005
3006     def testApplyLin1(self):
3007         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
3008         f1=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
3009         f1.setMesh(mesh1);
3010         array=DataArrayDouble.New();
3011         arr=[7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.]
3012         array.setValues(arr,mesh1.getNumberOfCells(),2);
3013         f1.setArray(array);
3014         #
3015         f1.applyLin(2.,3.,0);
3016         expected1=[17.,107.,19.,108.,21.,109.,23.,110.,25.,111.,27.,112.,29.,113.,31.,114.,33.,115.,35.,116.]
3017         for i in xrange(20):
3018             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),9);
3019             pass
3020         #
3021         arr2=[2.,102.,3.,103.,4.,104.,5.,105.,6.,106.,7.,107.,8.,108.,9.,109.,10.,110.,11.,111.]
3022         array=DataArrayDouble.New();
3023         array.setValues(arr2,mesh1.getNumberOfCells(),2);
3024         f1.setEndArray(array);
3025         #
3026         f1.applyLin(4.,5.,1);
3027         #
3028         expected2=[17.,433.,19.,437.,21.,441.,23.,445.,25.,449.,27.,453.,29.,457.,31.,461.,33.,465.,35.,469.]
3029         for i in xrange(20):
3030             self.assertAlmostEqual(expected2[i],f1.getIJ(0,i),9);
3031             pass
3032         expected3=[2.,413.,3.,417.,4.,421.,5.,425.,6.,429.,7.,433.,8.,437.,9.,441.,10.,445.,11.,449.]
3033         for i in xrange(20):
3034             self.assertAlmostEqual(expected3[i],f1.getEndArray().getIJ(0,i),9);
3035             pass
3036         #
3037         pass
3038
3039     def testGetIdsInRange1(self):
3040         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
3041         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3042         f1.setTime(2.3,5,6);
3043         f1.setMesh(mesh1);
3044         array=DataArrayDouble.New();
3045         arr1=[2.,8.,6.,5.,11.,7.,9.,3.,10.,4.]
3046         array.setValues(arr1,mesh1.getNumberOfCells(),1);
3047         f1.setArray(array);
3048         #
3049         f1.checkCoherency();
3050         da=f1.getIdsInRange(2.9,7.1);
3051         self.failUnlessEqual(5,da.getNbOfElems());
3052         expected1=[2,3,5,7,9]
3053         self.failUnlessEqual(expected1,list(da.getValues()));
3054         da=f1.getIdsInRange(8.,12.);
3055         self.failUnlessEqual(4,da.getNbOfElems());
3056         expected2=[1,4,6,8]
3057         self.failUnlessEqual(expected2,list(da.getValues()));
3058         #
3059         pass
3060
3061     def testBuildSubPart1(self):
3062         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3063         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3064         f1.setTime(2.3,5,6);
3065         f1.setMesh(mesh1);
3066         array=DataArrayDouble.New();
3067         arr1=[3.,103.,4.,104.,5.,105.,6.,106.,7.,107.]
3068         array.setValues(arr1,mesh1.getNumberOfCells(),2);
3069         f1.setArray(array);
3070         #
3071         part1=[2,1,4]
3072         f2=f1[part1];
3073         f2.zipCoords()
3074         self.failUnlessEqual(3,f2.getNumberOfTuples());
3075         self.failUnlessEqual(2,f2.getNumberOfComponents());
3076         expected1=[5.,105.,4.,104.,7.,107.]
3077         for i in xrange(6):
3078             self.assertAlmostEqual(f2.getIJ(0,i),expected1[i],12);
3079             pass
3080         self.failUnlessEqual(3,f2.getMesh().getNumberOfCells());
3081         self.failUnlessEqual(6,f2.getMesh().getNumberOfNodes());
3082         self.failUnlessEqual(2,f2.getMesh().getSpaceDimension());
3083         self.failUnlessEqual(2,f2.getMesh().getMeshDimension());
3084         m2C=f2.getMesh();
3085         self.failUnlessEqual(13,m2C.getMeshLength());
3086         expected2=[0.2, -0.3, 0.7, -0.3, 0.2, 0.2, 0.7, 0.2, 0.2, 0.7, 0.7, 0.7]
3087         for i in xrange(12):
3088             self.assertAlmostEqual(expected2[i],m2C.getCoords().getIJ(0,i),12);
3089             pass
3090         expected3=[3,2,3,1,3,0,2,1,4,4,5,3,2]
3091         self.failUnlessEqual(expected3,list(m2C.getNodalConnectivity().getValues()));
3092         expected4=[0,4,8,13]
3093         self.failUnlessEqual(expected4,list(m2C.getNodalConnectivityIndex().getValues()));
3094         # Test with field on nodes.
3095         f1=MEDCouplingFieldDouble.New(ON_NODES,ONE_TIME);
3096         f1.setTime(2.3,5,6);
3097         f1.setMesh(mesh1);
3098         array=DataArrayDouble.New();
3099         arr2=[3.,103.,4.,104.,5.,105.,6.,106.,7.,107.,8.,108.,9.,109.,10.,110.,11.,111.]
3100         array.setValues(arr2,mesh1.getNumberOfNodes(),2);
3101         f1.setArray(array);
3102         part2=[1,2]
3103         f2=f1.buildSubPart(part2);
3104         self.failUnlessEqual(4,f2.getNumberOfTuples());
3105         self.failUnlessEqual(2,f2.getNumberOfComponents());
3106         expected5=[4.,104.,5.,105.,7.,107.,8.,108.]
3107         for i in xrange(8):
3108             self.assertAlmostEqual(f2.getIJ(0,i),expected5[i],12);
3109             pass
3110         self.failUnlessEqual(2,f2.getMesh().getNumberOfCells());
3111         self.failUnlessEqual(4,f2.getMesh().getNumberOfNodes());
3112         self.failUnlessEqual(2,f2.getMesh().getSpaceDimension());
3113         self.failUnlessEqual(2,f2.getMesh().getMeshDimension());
3114         m2C=f2.getMesh();
3115         self.failUnlessEqual(8,m2C.getMeshLength());
3116         for i in xrange(8):#8 is not an error
3117             self.assertAlmostEqual(expected2[i],m2C.getCoords().getIJ(0,i),12);
3118             pass
3119         self.failUnlessEqual(expected3[:4],list(m2C.getNodalConnectivity().getValues())[4:]);
3120         self.failUnlessEqual(expected3[4:8],list(m2C.getNodalConnectivity().getValues())[:4]);
3121         self.failUnlessEqual(expected4[:3],list(m2C.getNodalConnectivityIndex().getValues()));
3122         #idem previous because nodes of cell#4 are not fully present in part3
3123         part3=[1,2]
3124         arrr=DataArrayInt.New();
3125         arrr.setValues(part3,2,1);
3126         f2=f1.buildSubPart(arrr);
3127         self.failUnlessEqual(4,f2.getNumberOfTuples());
3128         self.failUnlessEqual(2,f2.getNumberOfComponents());
3129         for i in xrange(8):
3130             self.assertAlmostEqual(f2.getIJ(0,i),expected5[i],12);
3131             pass
3132         self.failUnlessEqual(2,f2.getMesh().getNumberOfCells());
3133         self.failUnlessEqual(4,f2.getMesh().getNumberOfNodes());
3134         self.failUnlessEqual(2,f2.getMesh().getSpaceDimension());
3135         self.failUnlessEqual(2,f2.getMesh().getMeshDimension());
3136         m2C=f2.getMesh();
3137         self.failUnlessEqual(8,m2C.getMeshLength());
3138         for i in xrange(8):#8 is not an error
3139             self.assertAlmostEqual(expected2[i],m2C.getCoords().getIJ(0,i),12);
3140             pass
3141         self.failUnlessEqual(expected3[:4],list(m2C.getNodalConnectivity().getValues())[4:8]);
3142         self.failUnlessEqual(expected3[4:8],list(m2C.getNodalConnectivity().getValues())[:4]);
3143         self.failUnlessEqual(expected4[:3],list(m2C.getNodalConnectivityIndex().getValues()));
3144         #
3145         part4=[1,2,4]
3146         f2=f1.buildSubPart(part4);
3147         self.failUnlessEqual(6,f2.getNumberOfTuples());
3148         self.failUnlessEqual(2,f2.getNumberOfComponents());
3149         expected6=[4.,104.,5.,105.,7.,107.,8.,108.,10.,110.,11.,111.]
3150         for i in xrange(12):
3151             self.assertAlmostEqual(f2.getIJ(0,i),expected6[i],12);
3152             pass
3153         self.failUnlessEqual(3,f2.getMesh().getNumberOfCells());
3154         self.failUnlessEqual(6,f2.getMesh().getNumberOfNodes());
3155         self.failUnlessEqual(2,f2.getMesh().getSpaceDimension());
3156         self.failUnlessEqual(2,f2.getMesh().getMeshDimension());
3157         m2C=f2.getMesh();
3158         self.failUnlessEqual(13,m2C.getMeshLength());
3159         for i in xrange(12):
3160             self.assertAlmostEqual(expected2[i],m2C.getCoords().getIJ(0,i),12);
3161             pass
3162         self.failUnlessEqual(expected3[0:4],list(m2C.getNodalConnectivity().getValues())[4:8]);
3163         self.failUnlessEqual(expected3[4:8],list(m2C.getNodalConnectivity().getValues())[0:4]);
3164         self.failUnlessEqual(expected3[8:13],list(m2C.getNodalConnectivity().getValues())[8:13]);
3165         self.failUnlessEqual(expected4,list(m2C.getNodalConnectivityIndex().getValues()));
3166         pass
3167
3168     def testDoublyContractedProduct1(self):
3169         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3170         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3171         f1.setMesh(mesh1);
3172         array=DataArrayDouble.New();
3173         arr1=[7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5]
3174         array.setValues(arr1,mesh1.getNumberOfCells(),6);
3175         f1.setArray(array);
3176         f1.checkCoherency();
3177         #
3178         f2=f1.doublyContractedProduct();
3179         f2.checkCoherency();
3180         self.assertEqual(1,f2.getNumberOfComponents());
3181         self.assertEqual(5,f2.getNumberOfTuples());
3182         for i in xrange(5):
3183             self.assertAlmostEqual(3906.56,f2.getIJ(i,0),9);
3184             pass
3185         #
3186         pass
3187
3188     def testDeterminant1(self):
3189         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3190         f1=MEDCouplingFieldDouble.New(ON_CELLS,CONST_ON_TIME_INTERVAL);
3191         f1.setTime(2.3,5,6);
3192         f1.setEndTime(3.8,7,3);
3193         f1.setMesh(mesh1);
3194         array=DataArrayDouble.New();
3195         arr1=[1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5]
3196         array.setValues(arr1,mesh1.getNumberOfCells(),4);
3197         f1.setArray(array);
3198         #4 components
3199         f1.checkCoherency();
3200         f2=f1.determinant();
3201         f2.checkCoherency();
3202         self.assertEqual(CONST_ON_TIME_INTERVAL,f2.getTimeDiscretization());
3203         self.assertEqual(1,f2.getNumberOfComponents());
3204         self.assertEqual(5,f2.getNumberOfValues());
3205         for i in xrange(5):
3206             self.assertAlmostEqual(-2.42,f2.getIJ(i,0),13);
3207             pass
3208         #6 components multi arrays with end array not defined
3209         f1=MEDCouplingFieldDouble.New(ON_NODES,LINEAR_TIME);
3210         f1.setTime(2.3,5,6);
3211         f1.setEndTime(3.8,7,3);
3212         f1.setMesh(mesh1);
3213         array=DataArrayDouble.New();
3214         arr2=[1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7,
3215               1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7]
3216         array.setValues(arr2,mesh1.getNumberOfNodes(),6);
3217         f1.setArray(array);
3218         self.assertRaises(InterpKernelException,f1.checkCoherency);#no end array specified !
3219         #
3220         f2=f1.determinant();
3221         self.assertEqual(LINEAR_TIME,f2.getTimeDiscretization());
3222         self.assertEqual(1,f2.getArray().getNumberOfComponents());
3223         self.assertEqual(9,f2.getNumberOfTuples());
3224         for i in xrange(9):
3225             self.assertAlmostEqual(137.335,f2.getIJ(i,0),10);
3226             pass
3227         #6 components multi arrays with end array defined
3228         array=DataArrayDouble.New();
3229         arr3=[7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5,
3230               7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5]
3231         array.setValues(arr3,mesh1.getNumberOfNodes(),6);
3232         f1.setEndArray(array);
3233         f1.checkCoherency();
3234         f2=f1.determinant();
3235         f2.checkCoherency();
3236         self.assertEqual(LINEAR_TIME,f2.getTimeDiscretization());
3237         self.assertEqual(1,f2.getNumberOfComponents());
3238         self.assertEqual(9,f2.getNumberOfTuples());
3239         time2,it,order=f2.getTime()
3240         self.assertAlmostEqual(2.3,time2,12);
3241         self.assertEqual(5,it);
3242         self.assertEqual(6,order);
3243         time2,it,order=f2.getEndTime()
3244         self.assertAlmostEqual(3.8,time2,12);
3245         self.assertEqual(7,it);
3246         self.assertEqual(3,order);
3247         for i in xrange(9):
3248             self.assertAlmostEqual(137.335,f2.getIJ(i,0),10);
3249             self.assertAlmostEqual(1289.685,f2.getEndArray().getIJ(i,0),9);
3250             pass
3251         #9 components
3252         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3253         f1.setTime(7.8,10,2);
3254         f1.setMesh(mesh1);
3255         array=DataArrayDouble.New();
3256         arr4=[1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1]
3257         array.setValues(arr4,mesh1.getNumberOfCells(),9);
3258         f1.setArray(array);
3259         #
3260         f1.checkCoherency();
3261         f2=f1.determinant();
3262         f2.checkCoherency();
3263         self.assertEqual(ONE_TIME,f2.getTimeDiscretization());
3264         self.assertEqual(1,f2.getNumberOfComponents());
3265         self.assertEqual(5,f2.getNumberOfTuples());
3266         time2,it,order=f2.getTime()
3267         self.assertAlmostEqual(7.8,time2,12);
3268         self.assertEqual(10,it);
3269         self.assertEqual(2,order);
3270         for i in xrange(5):
3271             self.assertAlmostEqual(3.267,f2.getIJ(i,0),13);
3272             pass
3273         pass
3274
3275     def testEigenValues1(self):
3276         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3277         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3278         f1.setMesh(mesh1);
3279         array=DataArrayDouble.New();
3280         arr1=[1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7]
3281         array.setValues(arr1,mesh1.getNumberOfCells(),6);
3282         f1.setArray(array);
3283         f1.checkCoherency();
3284         #
3285         f2=f1.eigenValues();
3286         f2.checkCoherency();
3287         self.assertEqual(3,f2.getNumberOfComponents());
3288         self.assertEqual(5,f2.getNumberOfTuples());
3289         expected1=[13.638813677891717,-4.502313844635971,-2.2364998332557486]
3290         for i in xrange(5):
3291             self.assertAlmostEqual(expected1[0],f2.getIJ(i,0),13);
3292             self.assertAlmostEqual(expected1[1],f2.getIJ(i,1),13);
3293             self.assertAlmostEqual(expected1[2],f2.getIJ(i,2),13);
3294             pass
3295         pass
3296
3297     def testEigenVectors1(self):
3298         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3299         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3300         f1.setMesh(mesh1);
3301         array=DataArrayDouble.New();
3302         arr1=[1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7]
3303         array.setValues(arr1,mesh1.getNumberOfCells(),6);
3304         f1.setArray(array);
3305         f1.checkCoherency();
3306         #
3307         f2=f1.eigenVectors();
3308         f2.checkCoherency();
3309         self.assertEqual(9,f2.getNumberOfComponents());
3310         self.assertEqual(5,f2.getNumberOfTuples());
3311         expected1=[0.5424262364180696, 0.5351201064614425, 0.6476266283176001,#eigenvect 0
3312                    0.7381111277307373, 0.06458838384003074, -0.6715804522117897,#eigenvect 1
3313                    -0.4012053603397987, 0.8423032781211455, -0.3599436712889738#eigenvect 2
3314                    ]
3315         for i in xrange(5):
3316             self.assertAlmostEqual(expected1[0],f2.getIJ(i,0),13);
3317             self.assertAlmostEqual(expected1[1],f2.getIJ(i,1),13);
3318             self.assertAlmostEqual(expected1[2],f2.getIJ(i,2),13);
3319             self.assertAlmostEqual(expected1[3],f2.getIJ(i,3),13);
3320             self.assertAlmostEqual(expected1[4],f2.getIJ(i,4),13);
3321             self.assertAlmostEqual(expected1[5],f2.getIJ(i,5),13);
3322             self.assertAlmostEqual(expected1[6],f2.getIJ(i,6),13);
3323             self.assertAlmostEqual(expected1[7],f2.getIJ(i,7),13);
3324             self.assertAlmostEqual(expected1[8],f2.getIJ(i,8),13);
3325             pass
3326         #
3327         pass
3328
3329     def testInverse1(self):
3330         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3331         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3332         f1.setMesh(mesh1);
3333         array=DataArrayDouble.New();
3334         arr1=[1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1]
3335         array.setValues(arr1,mesh1.getNumberOfCells(),9);
3336         f1.setArray(array);
3337         f1.checkCoherency();
3338         #
3339         f2=f1.inverse();
3340         f2.checkCoherency();
3341         self.assertEqual(9,f2.getNumberOfComponents());
3342         self.assertEqual(5,f2.getNumberOfTuples());
3343         expected1=[-2.6538108356290113, 2.855831037649208, -1.1111111111111067, 3.461891643709813, -4.775022956841121, 2.2222222222222143, -1.1111111111111054, 2.222222222222214, -1.1111111111111072]
3344         for i in xrange(5):
3345             self.assertAlmostEqual(expected1[0],f2.getIJ(i,0),13);
3346             self.assertAlmostEqual(expected1[1],f2.getIJ(i,1),13);
3347             self.assertAlmostEqual(expected1[2],f2.getIJ(i,2),13);
3348             self.assertAlmostEqual(expected1[3],f2.getIJ(i,3),13);
3349             self.assertAlmostEqual(expected1[4],f2.getIJ(i,4),13);
3350             self.assertAlmostEqual(expected1[5],f2.getIJ(i,5),13);
3351             self.assertAlmostEqual(expected1[6],f2.getIJ(i,6),13);
3352             self.assertAlmostEqual(expected1[7],f2.getIJ(i,7),13);
3353             self.assertAlmostEqual(expected1[8],f2.getIJ(i,8),13);
3354             pass
3355         #
3356         array=DataArrayDouble.New();
3357         arr3=[7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5]
3358         array.setValues(arr3,mesh1.getNumberOfCells(),6);
3359         f1.setArray(array);
3360         f1.checkCoherency();
3361         #
3362         f2=f1.inverse();
3363         f2.checkCoherency();
3364         self.assertEqual(6,f2.getNumberOfComponents());
3365         self.assertEqual(5,f2.getNumberOfTuples());
3366         expected3=[-0.3617705098531818, -0.8678630828458127, -0.026843764174972983, 0.5539957431465833, 0.13133439560823013, -0.05301294502145887]
3367         for i in xrange(5):
3368             self.assertAlmostEqual(expected3[0],f2.getIJ(i,0),13);
3369             self.assertAlmostEqual(expected3[1],f2.getIJ(i,1),13);
3370             self.assertAlmostEqual(expected3[2],f2.getIJ(i,2),13);
3371             self.assertAlmostEqual(expected3[3],f2.getIJ(i,3),13);
3372             self.assertAlmostEqual(expected3[4],f2.getIJ(i,4),13);
3373             self.assertAlmostEqual(expected3[5],f2.getIJ(i,5),13);
3374             pass
3375         #
3376         array=DataArrayDouble.New();
3377         arr2=[1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5]
3378         array.setValues(arr2,mesh1.getNumberOfCells(),4);
3379         f1.setArray(array);
3380         f1.checkCoherency();
3381         #
3382         f2=f1.inverse();
3383         f2.checkCoherency();
3384         self.assertEqual(4,f2.getNumberOfComponents());
3385         self.assertEqual(5,f2.getNumberOfTuples());
3386         expected2=[-1.8595041322314059, 0.9504132231404963, 1.404958677685951, -0.49586776859504156]
3387         for i in xrange(5):
3388             self.assertAlmostEqual(expected2[0],f2.getIJ(i,0),13);
3389             self.assertAlmostEqual(expected2[1],f2.getIJ(i,1),13);
3390             self.assertAlmostEqual(expected2[2],f2.getIJ(i,2),13);
3391             self.assertAlmostEqual(expected2[3],f2.getIJ(i,3),13);
3392             pass
3393         #
3394         pass
3395
3396     def testTrace1(self):
3397         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3398         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3399         f1.setMesh(mesh1);
3400         array=DataArrayDouble.New();
3401         arr1=[1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1]
3402         array.setValues(arr1,mesh1.getNumberOfCells(),9);
3403         f1.setArray(array);
3404         f1.checkCoherency();
3405         #
3406         f2=f1.trace();
3407         f2.checkCoherency();
3408         self.assertEqual(1,f2.getNumberOfComponents());
3409         self.assertEqual(5,f2.getNumberOfTuples());
3410         for i in xrange(5):
3411             self.assertAlmostEqual(15.9,f2.getIJ(i,0),13);
3412             pass
3413         #
3414         array=DataArrayDouble.New();
3415         arr3=[7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5]
3416         array.setValues(arr3,mesh1.getNumberOfCells(),6);
3417         f1.setArray(array);
3418         f1.checkCoherency();
3419         #
3420         f2=f1.trace();
3421         f2.checkCoherency();
3422         self.assertEqual(1,f2.getNumberOfComponents());
3423         self.assertEqual(5,f2.getNumberOfTuples());
3424         for i in xrange(5):
3425             self.assertAlmostEqual(25.8,f2.getIJ(i,0),13);
3426             pass
3427         #
3428         array=DataArrayDouble.New();
3429         arr2=[1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5]
3430         array.setValues(arr2,mesh1.getNumberOfCells(),4);
3431         f1.setArray(array);
3432         f1.checkCoherency();
3433         #
3434         f2=f1.trace();
3435         f2.checkCoherency();
3436         self.assertEqual(1,f2.getNumberOfComponents());
3437         self.assertEqual(5,f2.getNumberOfTuples());
3438         for i in xrange(5):
3439             self.assertAlmostEqual(5.7,f2.getIJ(i,0),13);
3440             pass
3441         #
3442         pass
3443
3444     def testDeviator1(self):
3445         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3446         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3447         f1.setMesh(mesh1);
3448         array=DataArrayDouble.New();
3449         arr1=[1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7]
3450         array.setValues(arr1,mesh1.getNumberOfCells(),6);
3451         f1.setArray(array);
3452         f1.checkCoherency();
3453         #
3454         f2=f1.deviator();
3455         f2.checkCoherency();
3456         self.assertEqual(6,f2.getNumberOfComponents());
3457         self.assertEqual(5,f2.getNumberOfTuples());
3458         expected1=[-1.1,0.,1.1,4.5,5.6,6.7]
3459         for i in xrange(5):
3460             self.assertAlmostEqual(expected1[0],f2.getIJ(i,0),13);
3461             self.assertAlmostEqual(expected1[1],f2.getIJ(i,1),13);
3462             self.assertAlmostEqual(expected1[2],f2.getIJ(i,2),13);
3463             self.assertAlmostEqual(expected1[3],f2.getIJ(i,3),13);
3464             self.assertAlmostEqual(expected1[4],f2.getIJ(i,4),13);
3465             self.assertAlmostEqual(expected1[5],f2.getIJ(i,5),13);
3466             pass
3467         #
3468         pass
3469
3470     def testMagnitude1(self):
3471         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3472         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3473         f1.setMesh(mesh1);
3474         array=DataArrayDouble.New();
3475         arr1=[1.2,2.3,3.4,4.5,5.6, 1.2,2.3,3.4,4.5,5.6, 1.2,2.3,3.4,4.5,5.6, 1.2,2.3,3.4,4.5,5.6, 1.2,2.3,3.4,4.5,5.6]
3476         array.setValues(arr1,mesh1.getNumberOfCells(),5);
3477         f1.setArray(array);
3478         f1.checkCoherency();
3479         #
3480         f2=f1.magnitude();
3481         f2.checkCoherency();
3482         self.assertEqual(1,f2.getNumberOfComponents());
3483         self.assertEqual(5,f2.getNumberOfTuples());
3484         for i in xrange(5):
3485             self.assertAlmostEqual(8.3606219864313918,f2.getIJ(i,0),13);
3486             pass
3487         #
3488         pass
3489
3490     def testMaxPerTuple1(self):
3491         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3492         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3493         f1.setMesh(mesh1);
3494         array=DataArrayDouble.New();
3495         arr1=[1.2,2.3,3.4,4.5,5.6, 1.2,3.4,4.5,5.6,2.3, 3.4,4.5,5.6,1.2,2.3, 5.6,1.2,2.3,3.4,4.5, 4.5,5.6,1.2,2.3,3.4]
3496         array.setValues(arr1,mesh1.getNumberOfCells(),5);
3497         f1.setArray(array);
3498         f1.checkCoherency();
3499         #
3500         f2=f1.maxPerTuple();
3501         f2.checkCoherency();
3502         self.assertEqual(1,f2.getNumberOfComponents());
3503         self.assertEqual(5,f2.getNumberOfTuples());
3504         for i in xrange(5):
3505             self.assertAlmostEqual(5.6,f2.getIJ(i,0),13);
3506             pass
3507         #
3508         pass
3509
3510     def testChangeNbOfComponents(self):
3511         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3512         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3513         f1.setMesh(mesh1);
3514         array=DataArrayDouble.New();
3515         arr1=[1.2,2.3,3.4,4.5,5.6, 1.2,3.4,4.5,5.6,2.3, 3.4,4.5,5.6,1.2,2.3, 5.6,1.2,2.3,3.4,4.5, 4.5,5.6,1.2,2.3,3.4]
3516         array.setValues(arr1,mesh1.getNumberOfCells(),5);
3517         f1.setArray(array);
3518         f1.checkCoherency();
3519         #
3520         f1.changeNbOfComponents(3,7.77);
3521         f1.checkCoherency();
3522         self.assertEqual(3,f1.getNumberOfComponents());
3523         self.assertEqual(5,f1.getNumberOfTuples());
3524         expected1=[1.2,2.3,3.4, 1.2,3.4,4.5, 3.4,4.5,5.6, 5.6,1.2,2.3, 4.5,5.6,1.2]
3525         for i in xrange(15):
3526             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),13);
3527             pass
3528         f1.changeNbOfComponents(4,7.77);
3529         f1.checkCoherency();
3530         self.assertEqual(4,f1.getNumberOfComponents());
3531         self.assertEqual(5,f1.getNumberOfTuples());
3532         expected2=[1.2,2.3,3.4,7.77, 1.2,3.4,4.5,7.77, 3.4,4.5,5.6,7.77, 5.6,1.2,2.3,7.77, 4.5,5.6,1.2,7.77]
3533         for i in xrange(20):
3534             self.assertAlmostEqual(expected2[i],f1.getIJ(0,i),13);
3535             pass
3536         #
3537         pass
3538
3539     def testSortPerTuple1(self):
3540         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3541         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3542         f1.setMesh(mesh1);
3543         array=DataArrayDouble.New();
3544         arr1=[1.2,2.3,3.4,4.5,5.6, 1.2,3.4,4.5,5.6,2.3, 3.4,4.5,5.6,1.2,2.3, 5.6,1.2,2.3,3.4,4.5, 4.5,5.6,1.2,2.3,3.4]
3545         array.setValues(arr1,mesh1.getNumberOfCells(),5);
3546         f1.setArray(array);
3547         f1.checkCoherency();
3548         #
3549         f1.sortPerTuple(True);
3550         f1.checkCoherency();
3551         self.assertEqual(5,f1.getNumberOfComponents());
3552         self.assertEqual(5,f1.getNumberOfTuples());
3553         for i in xrange(5):
3554             self.assertAlmostEqual(arr1[0],f1.getIJ(i,0),13);
3555             self.assertAlmostEqual(arr1[1],f1.getIJ(i,1),13);
3556             self.assertAlmostEqual(arr1[2],f1.getIJ(i,2),13);
3557             self.assertAlmostEqual(arr1[3],f1.getIJ(i,3),13);
3558             self.assertAlmostEqual(arr1[4],f1.getIJ(i,4),13);
3559             pass
3560         #
3561         f1.sortPerTuple(False);
3562         f1.checkCoherency();
3563         self.assertEqual(5,f1.getNumberOfComponents());
3564         self.assertEqual(5,f1.getNumberOfTuples());
3565         for i in xrange(5):
3566             self.assertAlmostEqual(arr1[4],f1.getIJ(i,0),13);
3567             self.assertAlmostEqual(arr1[3],f1.getIJ(i,1),13);
3568             self.assertAlmostEqual(arr1[2],f1.getIJ(i,2),13);
3569             self.assertAlmostEqual(arr1[1],f1.getIJ(i,3),13);
3570             self.assertAlmostEqual(arr1[0],f1.getIJ(i,4),13);
3571             pass
3572         #
3573         pass
3574
3575     def testIsEqualWithoutConsideringStr1(self):
3576         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3577         mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
3578         #
3579         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3580         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3581         mesh2.setName("rr");
3582         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
3583         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3584         da1,da2=mesh1.checkGeoEquivalWith(mesh2,2,1e-12);
3585         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12);
3586         mesh2.setName("");
3587         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3588         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3589         mesh2.getCoords().setInfoOnComponent(0,"tty");
3590         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
3591         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3592         mesh2.getCoords().setInfoOnComponent(0,"");
3593         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3594         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3595         mesh2.getCoords().setInfoOnComponent(1,"tty");
3596         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
3597         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3598         mesh2.getCoords().setInfoOnComponent(1,"");
3599         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3600         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3601         tmp=mesh2.getCoords().getIJ(0,3);
3602         mesh2.getCoords().setIJ(0,3,9999.);
3603         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
3604         self.assertTrue(not mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3605         mesh2.getCoords().setIJ(0,3,tmp);
3606         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3607         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3608         tmp2=mesh2.getNodalConnectivity().getIJ(0,4);
3609         mesh2.getNodalConnectivity().setIJ(0,4,0);
3610         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
3611         self.assertTrue(not mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3612         mesh2.getNodalConnectivity().setIJ(0,4,tmp2);
3613         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3614         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3615         #
3616         f1=mesh1.getMeasureField(True);
3617         f2=mesh2.getMeasureField(True);
3618         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
3619         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3620         f2.setName("ftest");
3621         self.assertTrue(not f1.isEqual(f2,1e-12,1e-12));
3622         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3623         f1.setName("ftest");
3624         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
3625         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3626         #
3627         f2.getArray().setInfoOnComponent(0,"eee");
3628         self.assertTrue(not f1.isEqual(f2,1e-12,1e-12));
3629         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3630         f2.getArray().setInfoOnComponent(0,"");
3631         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
3632         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3633         #
3634         f2.getArray().setIJ(1,0,0.123);
3635         self.assertTrue(not f1.isEqual(f2,1e-12,1e-12));
3636         self.assertTrue(not f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3637         f2.getArray().setIJ(1,0,0.125);
3638         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
3639         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3640         #
3641         pass
3642
3643     def testGetNodeIdsOfCell1(self):
3644         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3645         li=mesh1.getNodeIdsOfCell(1)
3646         expected1=[1, 4, 2]
3647         self.assertEqual(expected1,list(li))
3648         li=mesh1.getCoordinatesOfNode(4)
3649         self.assertEqual(2,len(li))
3650         self.assertAlmostEqual(0.2,li[0],13);
3651         self.assertAlmostEqual(0.2,li[1],13);
3652         li=mesh1.getCoords().getValuesAsTuple()
3653         self.assertEqual(9,len(li))
3654         li2=mesh1.getNodalConnectivityIndex().getValuesAsTuple()
3655         self.assertEqual(6,len(li2))
3656         pass
3657
3658     def testGetEdgeRatioField1(self):
3659         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
3660         m1.setTime(3.4,5,6); m1.setTimeUnit("us");
3661         f1=m1.getEdgeRatioField();
3662         self.assertAlmostEqual(3.4,f1.getTime()[0],12) ; self.assertEqual(5,f1.getTime()[1]) ; self.assertEqual(6,f1.getTime()[2])
3663         self.assertEqual("us",f1.getTimeUnit())
3664         self.assertEqual(m1.getNumberOfCells(),f1.getNumberOfTuples());
3665         self.assertEqual(5,f1.getNumberOfTuples());
3666         self.assertEqual(1,f1.getNumberOfComponents());
3667         expected1=[1.,1.4142135623730951, 1.4142135623730951,1.,1.]
3668         for i in xrange(5):
3669             self.assertAlmostEqual(expected1[i],f1.getIJ(i,0),14);
3670             pass
3671         #
3672         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
3673         f1=m1.getEdgeRatioField();
3674         self.assertEqual(m1.getNumberOfCells(),f1.getNumberOfTuples());
3675         self.assertEqual(5,f1.getNumberOfTuples());
3676         self.assertEqual(1,f1.getNumberOfComponents());
3677         expected2=[1.4142135623730951, 1.7320508075688772, 1.7320508075688772, 1.4142135623730951, 1.4142135623730951]
3678         for i in xrange(5):
3679             self.assertAlmostEqual(expected2[i],f1.getIJ(i,0),14);
3680             pass
3681         pass
3682
3683     def testFillFromAnalytic3(self):
3684         m=MEDCouplingDataForTest.build2DTargetMesh_1()
3685         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME)
3686         self.assertRaises(InterpKernelException,f1.fillFromAnalytic,1,"y+x");
3687         f1.setMesh(m)
3688         f1.setName("myField");
3689         f1.fillFromAnalytic(1,"y+x");
3690         f1.checkCoherency();
3691         self.assertEqual(f1.getName(),"myField");
3692         self.assertEqual(f1.getTypeOfField(),ON_CELLS);
3693         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
3694         self.assertEqual(1,f1.getNumberOfComponents());
3695         self.assertEqual(5,f1.getNumberOfTuples());
3696         values1=[-0.1,0.23333333333333336,0.56666666666666665,0.4,0.9]
3697         tmp=f1.getArray().getValues();
3698         self.assertEqual(len(values1),len(tmp))
3699         for i in xrange(len(values1)):
3700             self.assertTrue(abs(values1[i]-tmp[i])<1.e-12);
3701             pass
3702         #
3703         f1=MEDCouplingFieldDouble.New(ON_NODES,CONST_ON_TIME_INTERVAL)
3704         f1.setMesh(m)
3705         f1.fillFromAnalytic(1,"y+2*x");
3706         f1.setEndTime(1.2,3,4);
3707         f1.checkCoherency();
3708         self.assertEqual(f1.getTypeOfField(),ON_NODES);
3709         self.assertEqual(f1.getTimeDiscretization(),CONST_ON_TIME_INTERVAL);
3710         self.assertEqual(1,f1.getNumberOfComponents());
3711         self.assertEqual(9,f1.getNumberOfTuples());
3712         values2=[-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1]
3713         tmp=f1.getArray().getValues();
3714         self.assertEqual(len(values2),len(tmp))
3715         for i in xrange(len(values2)):
3716             self.assertTrue(abs(values2[i]-tmp[i])<1.e-12);
3717             pass
3718         f1=MEDCouplingFieldDouble.New(ON_NODES,LINEAR_TIME);
3719         f1.setMesh(m)
3720         f1.fillFromAnalytic(1,"2.*x+y");
3721         f1.setEndTime(1.2,3,4);
3722         f1.checkCoherency();
3723         self.assertEqual(f1.getTypeOfField(),ON_NODES);
3724         self.assertEqual(f1.getTimeDiscretization(),LINEAR_TIME);
3725         self.assertEqual(1,f1.getNumberOfComponents());
3726         self.assertEqual(9,f1.getNumberOfTuples());
3727         tmp=f1.getArray().getValues();
3728         values2Bis=[-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1]
3729         self.assertEqual(len(values2Bis),len(tmp))
3730         for i in xrange(len(values2Bis)):
3731             self.assertTrue(abs(values2Bis[i]-tmp[i])<1.e-12);
3732             pass
3733         tmp=f1.getEndArray().getValues();
3734         self.assertEqual(len(values2Bis),len(tmp))
3735         for i in xrange(len(values2Bis)):
3736             self.assertTrue(abs(values2Bis[i]-tmp[i])<1.e-12);
3737             pass
3738         #
3739         f1=MEDCouplingFieldDouble.New(ON_NODES,ONE_TIME);
3740         f1.setMesh(m)
3741         f1.fillFromAnalytic(2,"(x+y)*IVec+2*(x+y)*JVec");
3742         f1.checkCoherency();
3743         self.assertEqual(f1.getTypeOfField(),ON_NODES);
3744         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
3745         self.assertEqual(2,f1.getNumberOfComponents());
3746         self.assertEqual(9,f1.getNumberOfTuples());
3747         values3=[-0.6,-1.2,-0.1,-0.2,0.4,0.8,-0.1,-0.2,0.4,0.8,0.9,1.8,0.4,0.8,0.9,1.8,1.4,2.8]
3748         tmp=f1.getArray().getValues();
3749         self.assertEqual(len(values3),len(tmp))
3750         for i in xrange(len(values3)):
3751             self.assertTrue(abs(values3[i]-tmp[i])<1.e-12);
3752             pass
3753         values4=f1.accumulate();
3754         self.assertTrue(abs(3.6-values4[0])<1.e-12);
3755         self.assertTrue(abs(7.2-values4[1])<1.e-12);
3756         values4=f1.integral(True);
3757         self.assertTrue(abs(0.5-values4[0])<1.e-12);
3758         self.assertTrue(abs(1.-values4[1])<1.e-12);
3759         #
3760         f1=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
3761         f1.setMesh(m);
3762         self.assertRaises(InterpKernelException,f1.fillFromAnalytic,1,"1./(x-0.2)");
3763         pass
3764
3765     def testFieldDoubleOpEqual1(self):
3766         m=MEDCouplingDataForTest.build2DTargetMesh_1();
3767         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3768         self.assertRaises(InterpKernelException,f1.assign,0.07);
3769         f1.setMesh(m);
3770         f1.assign(0.07);
3771         f1.checkCoherency();
3772         self.assertEqual(1,f1.getNumberOfComponents());
3773         self.assertEqual(5,f1.getNumberOfTuples());
3774         for i in xrange(5):
3775             self.assertAlmostEqual(0.07,f1.getIJ(i,0),16);
3776             pass
3777         f1.assign(0.09);
3778         f1.checkCoherency();
3779         self.assertEqual(1,f1.getNumberOfComponents());
3780         self.assertEqual(5,f1.getNumberOfTuples());
3781         for i in xrange(5):
3782             self.assertAlmostEqual(0.09,f1.getIJ(i,0),16);
3783             pass
3784         #
3785         f1=MEDCouplingFieldDouble.New(ON_NODES,LINEAR_TIME);
3786         f1.setEndTime(4.5,2,3);
3787         f1.setMesh(m);
3788         f1.assign(0.08);
3789         f1.checkCoherency();
3790         self.assertEqual(1,f1.getNumberOfComponents());
3791         self.assertEqual(9,f1.getNumberOfTuples());
3792         for i in xrange(9):
3793             self.assertAlmostEqual(0.08,f1.getIJ(i,0),16);
3794             pass
3795         self.assertEqual(1,f1.getEndArray().getNumberOfComponents());
3796         self.assertEqual(9,f1.getEndArray().getNumberOfTuples());
3797         for i in xrange(9):
3798             self.assertAlmostEqual(0.08,f1.getEndArray().getIJ(i,0),16);
3799             pass
3800         pass
3801
3802     def testAreaBary3D2(self):
3803         coordsForHexa8=[-75.45749305371, 180.95495078401, 39.515472018008,
3804                         -9.755591679144, 23.394927935279, 5.108794294848,
3805                         14.337630157832, 61.705351002702, 160.42422501908,
3806                         -27.273893776752, 167.567731083961, 192.830034145464,
3807                         99.857193154796,264.499264735586,-8.287335493412,
3808                         144.939882761126,156.38626563134,-31.896173894226,
3809                         161.34096835726,182.4654895809,73.832387065572,
3810                         132.680430393685,255.37973247196,96.15235602819];
3811         volHexa8=3258520.29637466;
3812         baryHexa8=[43.925705821778, 155.31893955289, 65.874418109644]
3813
3814         coordsForPenta6=[-68.199829618726,178.938498373416,62.608505919588,
3815                          8.461744647847,76.653979804423,165.00018874933,
3816                          -27.273893776752,167.567731083961,192.830034145464,
3817                          106.586501038965,262.629609408327,13.124533008813,
3818                          155.465082847275,197.414118382622,78.408350795821,
3819                          132.680430393685,255.37973247196,96.15235602819];
3820         volPenta6=944849.868507338;
3821         baryPenta6=[39.631002313543,182.692711783428,106.98540473964]
3822
3823         coordsForPyra5=[132.680430393685,255.37973247196,96.15235602819,
3824                         -27.273893776752,167.567731083961,192.830034145464,
3825                         8.461744647847,76.653979804423,165.00018874933,
3826                         155.465082847275,197.414118382622,78.408350795821,
3827                         -68.199829618726,178.938498373416,62.608505919588];
3828         volPyra5=756943.92980254;
3829         baryPyra5=[29.204294116618,172.540129749156,118.01035951483]
3830         mesh=MEDCouplingUMesh.New("Bary3D2",3);
3831         coo=DataArrayDouble.New();
3832         tmp=coordsForHexa8+coordsForPenta6+coordsForPyra5
3833         coo.setValues(tmp,19,3);
3834         mesh.setCoords(coo);
3835         #
3836         tmpConn=[0,1,2,3,4,5,6,7]
3837         mesh.allocateCells(3);
3838         self.assertRaises(InterpKernelException,mesh.insertNextCell,NORM_HEXA8,9,tmpConn[0:8])
3839         mesh.insertNextCell(NORM_HEXA8,tmpConn[0:8])
3840         mesh.insertNextCell(NORM_PENTA6,6,[i+8 for i in tmpConn])
3841         mesh.insertNextCell(NORM_PYRA5,5,[i+14 for i in tmpConn])
3842         mesh.finishInsertingCells();
3843         mesh.checkCoherency();
3844         mesh.mergeNodes(1e-7)
3845         self.assertEqual(12,mesh.getNumberOfNodes());
3846         vols=mesh.getMeasureField(True);
3847         self.assertEqual(3,vols.getNumberOfTuples());
3848         self.assertEqual(1,vols.getNumberOfComponents());
3849         self.assertAlmostEqual(volHexa8,vols.getIJ(0,0),6);
3850         self.assertAlmostEqual(volPenta6,vols.getIJ(1,0),7);
3851         self.assertAlmostEqual(volPyra5,vols.getIJ(2,0),7);
3852         bary=mesh.getBarycenterAndOwner();
3853         self.assertEqual(3,bary.getNumberOfTuples());
3854         self.assertEqual(3,bary.getNumberOfComponents());
3855         self.assertAlmostEqual(baryHexa8[0],bary.getIJ(0,0),11);
3856         self.assertAlmostEqual(baryHexa8[1],bary.getIJ(0,1),11);
3857         self.assertAlmostEqual(baryHexa8[2],bary.getIJ(0,2),11);
3858         self.assertAlmostEqual(baryPenta6[0],bary.getIJ(1,0),11);
3859         self.assertAlmostEqual(baryPenta6[1],bary.getIJ(1,1),11);
3860         self.assertAlmostEqual(baryPenta6[2],bary.getIJ(1,2),11);
3861         self.assertAlmostEqual(baryPyra5[0],bary.getIJ(2,0),11);
3862         self.assertAlmostEqual(baryPyra5[1],bary.getIJ(2,1),11);
3863         self.assertAlmostEqual(baryPyra5[2],bary.getIJ(2,2),11);
3864         pass
3865
3866     def testGetMeasureFieldCMesh1(self):
3867         m=MEDCouplingCMesh.New();
3868         da=DataArrayDouble.New();
3869         discX=[2.3,3.4,5.8,10.2]
3870         discY=[12.3,23.4,45.8]
3871         discZ=[-0.7,1.2,1.25,2.13,2.67]
3872         da.setValues(discX,4,1);
3873         m.setCoordsAt(0,da);
3874         m.checkCoherency();
3875         self.assertEqual(4,m.getNumberOfNodes());
3876         self.assertEqual(3,m.getNumberOfCells());
3877         self.assertEqual(1,m.getSpaceDimension());
3878         f=m.getMeasureField(True);
3879         self.assertEqual(3,f.getNumberOfTuples());
3880         self.assertEqual(1,f.getNumberOfComponents());
3881         expected1=[1.1,2.4,4.4]
3882         for i in xrange(3):
3883             self.assertAlmostEqual(expected1[i],f.getIJ(i,0),12);
3884             pass
3885         coords=m.getCoordinatesAndOwner();
3886         self.assertEqual(4,coords.getNumberOfTuples());
3887         self.assertEqual(1,coords.getNumberOfComponents());
3888         for i in xrange(4):
3889             self.assertAlmostEqual(discX[i],coords.getIJ(i,0),12);
3890             pass
3891         coords=m.getBarycenterAndOwner();
3892         self.assertEqual(3,coords.getNumberOfTuples());
3893         self.assertEqual(1,coords.getNumberOfComponents());
3894         expected1_3=[2.85,4.6,8.]
3895         for i in xrange(3):
3896             self.assertAlmostEqual(expected1_3[i],coords.getIJ(i,0),12);
3897             pass
3898         #
3899         da=DataArrayDouble.New();
3900         da.setValues(discY,3,1);
3901         m.setCoordsAt(1,da);
3902         m.checkCoherency();
3903         self.assertEqual(12,m.getNumberOfNodes());
3904         self.assertEqual(6,m.getNumberOfCells());
3905         self.assertEqual(2,m.getSpaceDimension());
3906         f=m.getMeasureField(True);
3907         self.assertEqual(6,f.getNumberOfTuples());
3908         self.assertEqual(1,f.getNumberOfComponents());
3909         expected2=[12.21,26.64,48.84,24.64,53.76,98.56]
3910         for i in xrange(6):
3911             self.assertAlmostEqual(expected2[i],f.getIJ(i,0),12);
3912             pass
3913         coords=m.getCoordinatesAndOwner();
3914         self.assertEqual(12,coords.getNumberOfTuples());
3915         self.assertEqual(2,coords.getNumberOfComponents());
3916         expected2_2=[2.3,12.3,3.4,12.3,5.8,12.3,10.2,12.3, 2.3,23.4,3.4,23.4,5.8,23.4,10.2,23.4, 2.3,45.8,3.4,45.8,5.8,45.8,10.2,45.8]
3917         for i in xrange(24):
3918             self.assertAlmostEqual(expected2_2[i],coords.getIJ(0,i),12);
3919             pass
3920         coords=m.getBarycenterAndOwner();
3921         self.assertEqual(6,coords.getNumberOfTuples());
3922         self.assertEqual(2,coords.getNumberOfComponents());
3923         expected2_3=[2.85,17.85,4.6,17.85,8.,17.85, 2.85,34.6,4.6,34.6,8.,34.6]
3924         for i in xrange(12):
3925             self.assertAlmostEqual(expected2_3[i],coords.getIJ(0,i),12);
3926             pass
3927         #
3928         da=DataArrayDouble.New();
3929         da.setValues(discZ,5,1);
3930         m.setCoordsAt(2,da);
3931         m.checkCoherency();
3932         self.assertEqual(60,m.getNumberOfNodes());
3933         self.assertEqual(24,m.getNumberOfCells());
3934         self.assertEqual(3,m.getSpaceDimension());
3935         f=m.getMeasureField(True);
3936         self.assertEqual(24,f.getNumberOfTuples());
3937         self.assertEqual(1,f.getNumberOfComponents());
3938         expected3=[23.199, 50.616, 92.796, 46.816, 102.144, 187.264, 0.6105, 1.332, 2.442, 1.232, 2.688, 4.928, 10.7448, 23.4432, 42.9792, 21.6832, 47.3088, 86.7328, 6.5934, 14.3856, 26.3736, 13.3056, 29.0304, 53.2224]
3939         for i in xrange(24):
3940             self.assertAlmostEqual(expected3[i],f.getIJ(i,0),12);
3941             pass
3942         coords=m.getCoordinatesAndOwner();
3943         self.assertEqual(60,coords.getNumberOfTuples());
3944         self.assertEqual(3,coords.getNumberOfComponents());
3945         expected3_2=[
3946             2.3,12.3,-0.7, 3.4,12.3,-0.7, 5.8,12.3,-0.7, 10.2,12.3,-0.7, 2.3,23.4,-0.7, 3.4,23.4,-0.7, 5.8,23.4,-0.7, 10.2,23.4,-0.7, 2.3,45.8,-0.7, 3.4,45.8,-0.7, 5.8,45.8,-0.7, 10.2,45.8,-0.7,
3947             2.3,12.3,1.2, 3.4,12.3,1.2, 5.8,12.3,1.2, 10.2,12.3,1.2, 2.3,23.4,1.2, 3.4,23.4,1.2, 5.8,23.4,1.2, 10.2,23.4,1.2, 2.3,45.8,1.2, 3.4,45.8,1.2, 5.8,45.8,1.2, 10.2,45.8,1.2,
3948             2.3,12.3,1.25, 3.4,12.3,1.25, 5.8,12.3,1.25, 10.2,12.3,1.25, 2.3,23.4,1.25, 3.4,23.4,1.25, 5.8,23.4,1.25, 10.2,23.4,1.25, 2.3,45.8,1.25, 3.4,45.8,1.25, 5.8,45.8,1.25, 10.2,45.8,1.25,
3949             2.3,12.3,2.13, 3.4,12.3,2.13, 5.8,12.3,2.13, 10.2,12.3,2.13, 2.3,23.4,2.13, 3.4,23.4,2.13, 5.8,23.4,2.13, 10.2,23.4,2.13, 2.3,45.8,2.13, 3.4,45.8,2.13, 5.8,45.8,2.13, 10.2,45.8,2.13,
3950             2.3,12.3,2.67, 3.4,12.3,2.67, 5.8,12.3,2.67, 10.2,12.3,2.67, 2.3,23.4,2.67, 3.4,23.4,2.67, 5.8,23.4,2.67, 10.2,23.4,2.67, 2.3,45.8,2.67, 3.4,45.8,2.67, 5.8,45.8,2.67, 10.2,45.8,2.67];
3951         for i in xrange(180):
3952             self.assertAlmostEqual(expected3_2[i],coords.getIJ(0,i),12);
3953             pass
3954         coords=m.getBarycenterAndOwner();
3955         self.assertEqual(24,coords.getNumberOfTuples());
3956         self.assertEqual(3,coords.getNumberOfComponents());
3957         expected3_3=[
3958             2.85,17.85,0.25,4.6,17.85,0.25,8.,17.85,0.25, 2.85,34.6,0.25,4.6,34.6,0.25,8.,34.6,0.25,
3959             2.85,17.85,1.225,4.6,17.85,1.225,8.,17.85,1.225, 2.85,34.6,1.225,4.6,34.6,1.225,8.,34.6,1.225,
3960             2.85,17.85,1.69,4.6,17.85,1.69,8.,17.85,1.69, 2.85,34.6,1.69,4.6,34.6,1.69,8.,34.6,1.69,
3961             2.85,17.85,2.4,4.6,17.85,2.4,8.,17.85,2.4, 2.85,34.6,2.4,4.6,34.6,2.4,8.,34.6,2.4];
3962         for i in xrange(72):
3963             self.assertAlmostEqual(expected3_3[i],coords.getIJ(0,i),12);
3964             pass
3965         pass
3966
3967     def testFieldDoubleZipCoords1(self):
3968         m=MEDCouplingDataForTest.build2DTargetMeshMergeNode_1();
3969         f=m.fillFromAnalytic(ON_NODES,2,"x*2.");
3970         f.getArray().setInfoOnComponent(0,"titi");
3971         f.getArray().setInfoOnComponent(1,"tutu");
3972         f.checkCoherency();
3973         self.assertEqual(18,f.getNumberOfTuples());
3974         self.assertEqual(2,f.getNumberOfComponents());
3975         expected1=[-0.6, -0.6, 0.4, 0.4, 1.4, 1.4, -0.6, -0.6, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 1.4, 1.4, -0.6, -0.6, 0.4, 0.4, 1.4, 1.4, -0.6, -0.6, 1.4, 1.4, -0.6, -0.6, 0.4, 0.4, 1.4, 1.4, 0.4, 0.4]
3976         for i in xrange(36):
3977             self.assertAlmostEqual(expected1[i],f.getIJ(0,i),12);
3978             pass
3979         self.assertTrue(f.zipCoords());
3980         f.checkCoherency();
3981         expected2=[-0.6, -0.6, 1.4, 1.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 1.4, 1.4, -0.6, -0.6, 0.4, 0.4, 1.4, 1.4, 1.4, 1.4, -0.6, -0.6, 0.4, 0.4, 1.4, 1.4, 0.4, 0.4]
3982         for i in xrange(30):
3983             self.assertAlmostEqual(expected2[i],f.getIJ(0,i),12);
3984             pass
3985         self.assertTrue(not f.zipCoords());
3986         f.checkCoherency();
3987         for i in xrange(30):
3988             self.assertAlmostEqual(expected2[i],f.getIJ(0,i),12);
3989             pass
3990         self.assertTrue(f.getArray().getInfoOnComponent(0)=="titi");
3991         self.assertTrue(f.getArray().getInfoOnComponent(1)=="tutu");
3992         pass
3993
3994     def testFieldDoubleZipConnectivity1(self):
3995         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
3996         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
3997         cells1=[2,3,4]
3998         m3_1=m2.buildPartOfMySelf(cells1,True);
3999         m3=m3_1;
4000         m4=MEDCouplingDataForTest.build2DSourceMesh_1();
4001         m5=MEDCouplingUMesh.MergeUMeshes(m1,m3);
4002         m6=MEDCouplingUMesh.MergeUMeshes(m5,m4);
4003         #
4004         self.assertEqual(10,m6.getNumberOfCells());
4005         self.assertEqual(22,m6.getNumberOfNodes());
4006         arr,areNodesMerged,newNbOfNodes=m6.mergeNodes(1e-13);
4007         self.assertEqual(9,m6.getNumberOfNodes());
4008         f=m6.fillFromAnalytic(ON_CELLS,2,"x");
4009         f2=m6.fillFromAnalytic(ON_NODES,2,"x");
4010         self.assertEqual(10,f.getNumberOfTuples());
4011         self.assertEqual(2,f.getNumberOfComponents());
4012         expected1=[-0.05, -0.05, 0.3666666666666667, 0.3666666666666667, 0.53333333333333321, 0.53333333333333321,
4013                    -0.05, -0.05, 0.45, 0.45, 0.53333333333333321, 0.53333333333333321, -0.05, -0.05, 0.45, 0.45,
4014                    0.36666666666666659, 0.36666666666666659, 0.033333333333333326, 0.033333333333333326];
4015         for i in xrange(20):
4016             self.assertAlmostEqual(expected1[i],f.getIJ(0,i),12);
4017             pass
4018         f.getArray().setInfoOnComponent(0,"titi");
4019         f.getArray().setInfoOnComponent(1,"tutu");
4020         f.checkCoherency();
4021         self.assertTrue(f.zipConnectivity(0));
4022         expected2=[-0.05, -0.05, 0.3666666666666667, 0.3666666666666667, 0.53333333333333321, 0.53333333333333321,
4023                    -0.05, -0.05, 0.45, 0.45, 0.36666666666666659, 0.36666666666666659, 0.033333333333333326, 0.033333333333333326];
4024         self.assertEqual(7,f.getNumberOfTuples());
4025         self.assertEqual(2,f.getNumberOfComponents());
4026         for i in xrange(14):
4027             self.assertAlmostEqual(expected2[i],f.getIJ(0,i),12);
4028             pass
4029         self.assertTrue(f.getArray().getInfoOnComponent(0)=="titi");
4030         self.assertTrue(f.getArray().getInfoOnComponent(1)=="tutu");
4031         self.assertTrue(not f.zipConnectivity(0));
4032         #
4033         expected3=[-0.3, -0.3, 0.2, 0.2, 0.7, 0.7, -0.3, -0.3, 0.2, 0.2, 0.7, 0.7,
4034                    -0.3, -0.3, 0.2, 0.2, 0.7, 0.7];
4035         self.assertEqual(9,f2.getNumberOfTuples());
4036         self.assertEqual(2,f2.getNumberOfComponents());
4037         for i in xrange(18):
4038             self.assertAlmostEqual(expected3[i],f2.getIJ(0,i),12);
4039             pass
4040         self.assertTrue(f2.zipConnectivity(0));
4041         self.assertEqual(9,f2.getNumberOfTuples());
4042         self.assertEqual(2,f2.getNumberOfComponents());
4043         for i in xrange(18):
4044             self.assertAlmostEqual(expected3[i],f2.getIJ(0,i),12);
4045             pass
4046         pass
4047
4048     def testDaDoubleRenumber1(self):
4049         a=DataArrayDouble.New();
4050         arr1=[1.1,11.1,2.1,12.1,3.1,13.1,4.1,14.1,5.1,15.1,6.1,16.1,7.1,17.1]
4051         a.setValues(arr1,7,2);
4052         a.setInfoOnComponent(0,"toto");
4053         a.setInfoOnComponent(1,"tata");
4054         #
4055         arr2=[3,1,0,6,5,4,2]
4056         b=a.renumber(arr2);
4057         self.assertEqual(7,b.getNumberOfTuples());
4058         self.assertEqual(2,b.getNumberOfComponents());
4059         self.assertTrue(b.getInfoOnComponent(0)=="toto");
4060         self.assertTrue(b.getInfoOnComponent(1)=="tata");
4061         expected1=[3.1, 13.1, 2.1, 12.1, 7.1, 17.1, 1.1, 11.1, 6.1, 16.1, 5.1, 15.1, 4.1, 14.1]
4062         for i in xrange(14):
4063             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
4064             pass
4065         #
4066         c=DataArrayInt.New();
4067         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4068         c.setValues(arr3,7,2);
4069         c.setInfoOnComponent(0,"toto");
4070         c.setInfoOnComponent(1,"tata");
4071         d=c.renumber(arr2);
4072         self.assertEqual(7,d.getNumberOfTuples());
4073         self.assertEqual(2,d.getNumberOfComponents());
4074         self.assertTrue(d.getInfoOnComponent(0)=="toto");
4075         self.assertTrue(d.getInfoOnComponent(1)=="tata");
4076         expected2=[3, 13, 2, 12, 7, 17, 1, 11, 6, 16, 5, 15, 4, 14]
4077         for i in xrange(14):
4078             self.assertEqual(expected2[i],d.getIJ(0,i));
4079             pass
4080         pass
4081
4082     def testDaDoubleRenumberAndReduce1(self):
4083         a=DataArrayDouble.New();
4084         arr1=[1.1,11.1,2.1,12.1,3.1,13.1,4.1,14.1,5.1,15.1,6.1,16.1,7.1,17.1]
4085         a.setValues(arr1,7,2);
4086         a.setInfoOnComponent(0,"toto");
4087         a.setInfoOnComponent(1,"tata");
4088         #
4089         arr2=[2,-1,1,-1,0,4,3]
4090         b=a.renumberAndReduce(arr2,5);
4091         self.assertEqual(5,b.getNumberOfTuples());
4092         self.assertEqual(2,b.getNumberOfComponents());
4093         self.assertTrue(b.getInfoOnComponent(0)=="toto");
4094         self.assertTrue(b.getInfoOnComponent(1)=="tata");
4095         expected1=[5.1,15.1,3.1,13.1,1.1,11.1,7.1,17.1,6.1,16.1]
4096         for i in xrange(10):
4097             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
4098             pass
4099         #
4100         c=DataArrayInt.New();
4101         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4102         c.setValues(arr3,7,2);
4103         c.setInfoOnComponent(0,"toto");
4104         c.setInfoOnComponent(1,"tata");
4105         d=c.renumberAndReduce(arr2,5);
4106         self.assertEqual(5,d.getNumberOfTuples());
4107         self.assertEqual(2,d.getNumberOfComponents());
4108         self.assertTrue(d.getInfoOnComponent(0)=="toto");
4109         self.assertTrue(d.getInfoOnComponent(1)=="tata");
4110         expected2=[5,15,3,13,1,11,7,17,6,16]
4111         for i in xrange(10):
4112             self.assertEqual(expected2[i],d.getIJ(0,i));
4113             pass
4114         pass
4115
4116     def testDaDoubleRenumberInPlace1(self):
4117         a=DataArrayDouble.New();
4118         arr1=[1.1,11.1,2.1,12.1,3.1,13.1,4.1,14.1,5.1,15.1,6.1,16.1,7.1,17.1]
4119         a.setValues(arr1,7,2);
4120         #
4121         arr2=[3,1,0,6,5,4,2]
4122         a.renumberInPlace(arr2);
4123         self.assertEqual(7,a.getNumberOfTuples());
4124         self.assertEqual(2,a.getNumberOfComponents());
4125         expected1=[3.1, 13.1, 2.1, 12.1, 7.1, 17.1, 1.1, 11.1, 6.1, 16.1, 5.1, 15.1, 4.1, 14.1]
4126         for i in xrange(14):
4127             self.assertAlmostEqual(expected1[i],a.getIJ(0,i),14);
4128             pass
4129         #
4130         c=DataArrayInt.New();
4131         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4132         c.setValues(arr3,7,2);
4133         c.renumberInPlace(arr2);
4134         self.assertEqual(7,c.getNumberOfTuples());
4135         self.assertEqual(2,c.getNumberOfComponents());
4136         expected2=[3, 13, 2, 12, 7, 17, 1, 11, 6, 16, 5, 15, 4, 14]
4137         for i in xrange(14):
4138             self.assertEqual(expected2[i],c.getIJ(0,i));
4139             pass
4140         pass
4141
4142     def testDaDoubleRenumberR1(self):
4143         a=DataArrayDouble.New();
4144         arr1=[1.1,11.1,2.1,12.1,3.1,13.1,4.1,14.1,5.1,15.1,6.1,16.1,7.1,17.1]
4145         a.setValues(arr1,7,2);
4146         a.setInfoOnComponent(0,"toto");
4147         a.setInfoOnComponent(1,"tata");
4148         #
4149         arr2=[3,1,0,6,5,4,2]
4150         b=a.renumberR(arr2);
4151         self.assertEqual(7,b.getNumberOfTuples());
4152         self.assertEqual(2,b.getNumberOfComponents());
4153         self.assertTrue(b.getInfoOnComponent(0)=="toto");
4154         self.assertTrue(b.getInfoOnComponent(1)=="tata");
4155         expected1=[4.1, 14.1, 2.1, 12.1, 1.1, 11.1, 7.1, 17.1, 6.1, 16.1, 5.1, 15.1, 3.1, 13.1]
4156         for i in xrange(14):
4157             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
4158             pass
4159         #
4160         c=DataArrayInt.New();
4161         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4162         c.setValues(arr3,7,2);
4163         c.setInfoOnComponent(0,"toto");
4164         c.setInfoOnComponent(1,"tata");
4165         d=c.renumberR(arr2);
4166         self.assertEqual(7,d.getNumberOfTuples());
4167         self.assertEqual(2,d.getNumberOfComponents());
4168         self.assertTrue(d.getInfoOnComponent(0)=="toto");
4169         self.assertTrue(d.getInfoOnComponent(1)=="tata");
4170         expected2=[4, 14, 2, 12, 1, 11, 7, 17, 6, 16, 5, 15, 3, 13]
4171         for i in xrange(14):
4172             self.assertEqual(expected2[i],d.getIJ(0,i));
4173             pass
4174         pass
4175
4176     def testDaDoubleRenumberInPlaceR1(self):
4177         a=DataArrayDouble.New();
4178         arr1=[1.1,11.1,2.1,12.1,3.1,13.1,4.1,14.1,5.1,15.1,6.1,16.1,7.1,17.1]
4179         a.setValues(arr1,7,2);
4180         #
4181         arr2=[3,1,0,6,5,4,2]
4182         a.renumberInPlaceR(arr2);
4183         self.assertEqual(7,a.getNumberOfTuples());
4184         self.assertEqual(2,a.getNumberOfComponents());
4185         expected1=[4.1, 14.1, 2.1, 12.1, 1.1, 11.1, 7.1, 17.1, 6.1, 16.1, 5.1, 15.1, 3.1, 13.1]
4186         for i in xrange(14):
4187             self.assertAlmostEqual(expected1[i],a.getIJ(0,i),14);
4188             pass
4189         #
4190         c=DataArrayInt.New();
4191         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4192         c.setValues(arr3,7,2);
4193         c.renumberInPlaceR(arr2);
4194         self.assertEqual(7,c.getNumberOfTuples());
4195         self.assertEqual(2,c.getNumberOfComponents());
4196         expected2=[4, 14, 2, 12, 1, 11, 7, 17, 6, 16, 5, 15, 3, 13]
4197         for i in xrange(14):
4198             self.assertEqual(expected2[i],c.getIJ(0,i));
4199             pass
4200         pass
4201
4202     def testDaDoubleSelectByTupleId1(self):
4203         a=DataArrayDouble.New();
4204         arr1=[1.1,11.1,2.1,12.1,3.1,13.1,4.1,14.1,5.1,15.1,6.1,16.1,7.1,17.1]
4205         a.setValues(arr1,7,2);
4206         a.setInfoOnComponent(0,"toto");
4207         a.setInfoOnComponent(1,"tata");
4208         #
4209         arr2=[4,2,0,6,5]
4210         b=a.selectByTupleId(arr2);
4211         self.assertEqual(5,b.getNumberOfTuples());
4212         self.assertEqual(2,b.getNumberOfComponents());
4213         self.assertTrue(b.getInfoOnComponent(0)=="toto");
4214         self.assertTrue(b.getInfoOnComponent(1)=="tata");
4215         expected1=[5.1,15.1,3.1,13.1,1.1,11.1,7.1,17.1,6.1,16.1]
4216         for i in xrange(10):
4217             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
4218             pass
4219         #
4220         c=DataArrayInt.New();
4221         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4222         c.setValues(arr3,7,2);
4223         c.setInfoOnComponent(0,"toto");
4224         c.setInfoOnComponent(1,"tata");
4225         d=c.selectByTupleId(arr2);
4226         self.assertEqual(5,d.getNumberOfTuples());
4227         self.assertEqual(2,d.getNumberOfComponents());
4228         self.assertTrue(d.getInfoOnComponent(0)=="toto");
4229         self.assertTrue(d.getInfoOnComponent(1)=="tata");
4230         expected2=[5,15,3,13,1,11,7,17,6,16]
4231         for i in xrange(10):
4232             self.assertEqual(expected2[i],d.getIJ(0,i));
4233             pass
4234         pass
4235
4236     def testDaDoubleGetMinMaxValues1(self):
4237         a=DataArrayDouble.New();
4238         arr1=[2.34,4.56,-6.77,4.55,4.56,2.24,2.34,1.02,4.56]
4239         a.setValues(arr1,9,1);
4240         m,where=a.getMaxValue();
4241         self.assertEqual(1,where);
4242         self.assertAlmostEqual(4.56,m,12);
4243         m,ws=a.getMaxValue2();
4244         self.assertAlmostEqual(4.56,m,12);
4245         self.assertEqual(3,ws.getNumberOfTuples());
4246         self.assertEqual(1,ws.getNumberOfComponents());
4247         expected1=[1,4,8]
4248         for i in xrange(3):
4249             self.assertEqual(expected1[i],ws.getIJ(i,0));
4250             pass
4251         a=DataArrayDouble.New();
4252         arr2=[-2.34,-4.56,6.77,-4.55,-4.56,-2.24,-2.34,-1.02,-4.56]
4253         a.setValues(arr2,9,1);
4254         m,where=a.getMinValue();
4255         self.assertEqual(1,where);
4256         self.assertAlmostEqual(-4.56,m,12);
4257         m,ws=a.getMinValue2();
4258         self.assertAlmostEqual(-4.56,m,12);
4259         self.assertEqual(3,ws.getNumberOfTuples());
4260         self.assertEqual(1,ws.getNumberOfComponents());
4261         for i in xrange(3):
4262             self.assertEqual(expected1[i],ws.getIJ(i,0));
4263             pass
4264         pass
4265
4266     def testFieldDoubleGetMinMaxValues2(self):
4267         m2,m1=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
4268         self.assertEqual(18,m2.getNumberOfCells());
4269         arr1=[8.71,4.53,-12.41,8.71,-8.71,8.7099,4.55,8.71,5.55,6.77,-1e-200,4.55,8.7099,0.,1.23,0.,2.22,8.71]
4270         f=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
4271         a=DataArrayDouble.New();
4272         a.setValues(arr1,18,1);
4273         f.setArray(a);
4274         f.setMesh(m2);
4275         #
4276         f.checkCoherency();
4277         m=f.getMaxValue();
4278         self.assertAlmostEqual(8.71,m,12);
4279         m,ws=f.getMaxValue2();
4280         self.assertAlmostEqual(8.71,m,12);
4281         self.assertEqual(4,ws.getNumberOfTuples());
4282         self.assertEqual(1,ws.getNumberOfComponents());
4283         expected1=[0,3,7,17]
4284         for i in xrange(4):
4285             self.assertEqual(expected1[i],ws.getIJ(i,0));
4286             pass
4287         #
4288         arr2=[-8.71,-4.53,12.41,-8.71,8.71,-8.7099,-4.55,-8.71,-5.55,-6.77,1e-200,-4.55,-8.7099,0.,-1.23,0.,-2.22,-8.71]
4289         a.setValues(arr2,18,1);
4290         f.checkCoherency();
4291         m=f.getMinValue();
4292         self.assertAlmostEqual(-8.71,m,12);
4293         m,ws=f.getMinValue2();
4294         self.assertAlmostEqual(-8.71,m,12);
4295         self.assertEqual(4,ws.getNumberOfTuples());
4296         self.assertEqual(1,ws.getNumberOfComponents());
4297         for i in xrange(4):
4298             self.assertEqual(expected1[i],ws.getIJ(i,0));
4299             pass
4300         pass
4301
4302     def testBuildUnstructuredCMesh1(self):
4303         m=MEDCouplingCMesh.New();
4304         da=DataArrayDouble.New();
4305         discX=[2.3,3.4,5.8,10.2]
4306         discY=[12.3,23.4,45.8]
4307         discZ=[-0.7,1.2,1.25,2.13,2.67]
4308         da.setValues(discX,4,1);
4309         m.setCoordsAt(0,da);
4310         m.checkCoherency();
4311         self.assertEqual(0,m.getCellContainingPoint([2.4],1e-12));
4312         self.assertEqual(1,m.getCellContainingPoint([3.7],1e-12));
4313         self.assertEqual(2,m.getCellContainingPoint([5.9],1e-12));
4314         self.assertEqual(-1,m.getCellContainingPoint([10.3],1e-12));
4315         self.assertEqual(-1,m.getCellContainingPoint([1.3],1e-12));
4316         #
4317         m2=m.buildUnstructured();
4318         m2.checkCoherency();
4319         f1=m.getMeasureField(False);
4320         f2=m2.getMeasureField(False);
4321         self.assertTrue(isinstance(f1.getMesh(),MEDCouplingCMesh))
4322         self.assertEqual(f1.getNumberOfTuples(),3);
4323         self.assertEqual(f2.getNumberOfTuples(),3);
4324         self.assertEqual(1,m2.getMeshDimension());
4325         self.assertEqual(1,m2.getSpaceDimension());
4326         for i in xrange(3):
4327             self.assertAlmostEqual(f1.getIJ(i,0),f2.getIJ(i,0),10);
4328             pass
4329         da=DataArrayDouble.New();
4330         da.setValues(discY,3,1);
4331         m.setCoordsAt(1,da);
4332         #
4333         m2=m.buildUnstructured();
4334         m2.checkCoherency();
4335         f1=m.getMeasureField(False);
4336         f2=m2.getMeasureField(False);
4337         self.assertEqual(f1.getNumberOfTuples(),6);
4338         self.assertEqual(f2.getNumberOfTuples(),6);
4339         self.assertEqual(2,m2.getMeshDimension());
4340         self.assertEqual(2,m2.getSpaceDimension());
4341         for i in xrange(6):
4342             self.assertAlmostEqual(f1.getIJ(i,0),f2.getIJ(i,0),10);
4343             pass
4344         #
4345         da=DataArrayDouble.New();
4346         da.setValues(discZ,5,1);
4347         m.setCoordsAt(2,da);
4348         m2=m.buildUnstructured();
4349         m2.checkCoherency();
4350         f1=m.getMeasureField(False);
4351         f2=m2.getMeasureField(False);
4352         self.assertEqual(f1.getNumberOfTuples(),24);
4353         self.assertEqual(f2.getNumberOfTuples(),24);
4354         self.assertEqual(3,m2.getMeshDimension());
4355         self.assertEqual(3,m2.getSpaceDimension());
4356         for i in xrange(24):
4357             self.assertAlmostEqual(f1.getIJ(i,0),f2.getIJ(i,0),10);
4358             pass
4359         #
4360         pos1=[5.,30.,2.]
4361         self.assertEqual(16,m.getCellContainingPoint(pos1,1e-12));
4362         #
4363         elems=m2.getCellsInBoundingBox([3.5,6.,12.2,25.,0.,1.5],1e-7)
4364         self.assertEqual([1, 2, 4, 5, 7, 8, 10, 11, 13, 14, 16, 17],elems.getValues())
4365         #
4366         pt=[2.4,12.7,-3.4]
4367         m.scale(pt,3.7);
4368         m3=m.buildUnstructured();
4369         m2.scale(pt,3.7);
4370         self.assertTrue(m3.isEqual(m2,1e-12));
4371         pass
4372
4373     def testDataArrayIntInvertO2NNO21(self):
4374         arr1=[2,0,4,1,5,3]
4375         da=DataArrayInt.New();
4376         da.setValues(arr1,6,1);
4377         da2=da.invertArrayO2N2N2O(6);
4378         self.assertEqual(6,da2.getNumberOfTuples());
4379         self.assertEqual(1,da2.getNumberOfComponents());
4380         expected1=[1,3,0,5,2,4]
4381         for i in xrange(6):
4382             self.assertEqual(expected1[i],da2.getIJ(i,0));
4383             pass
4384         da3=da2.invertArrayN2O2O2N(6);
4385         for i in xrange(6):
4386             self.assertEqual(arr1[i],da3.getIJ(i,0));
4387             pass
4388         #
4389         arr2=[3,-1,5,4,-1,0,-1,1,2,-1]
4390         da=DataArrayInt.New();
4391         da.setValues(arr2,10,1);
4392         da2=da.invertArrayO2N2N2O(6);
4393         self.assertEqual(6,da2.getNumberOfTuples());
4394         self.assertEqual(1,da2.getNumberOfComponents());
4395         expected2=[5,7,8,0,3,2]
4396         for i in xrange(6):
4397             self.assertEqual(expected2[i],da2.getIJ(i,0));
4398             pass
4399         da3=da2.invertArrayN2O2O2N(10);
4400         for i in xrange(10):
4401             self.assertEqual(arr2[i],da3.getIJ(i,0));
4402             pass
4403         pass
4404
4405     def testKeepSetSelectedComponent1(self):
4406         arr1=[1.,2.,3.,4., 11.,12.,13.,14., 21.,22.,23.,24., 31.,32.,33.,34., 41.,42.,43.,44.]
4407         a1=DataArrayDouble.New();
4408         a1.setValues(arr1,5,4);
4409         expp=[21.,22.,23.,24.]
4410         self.assertEqual(4,len(a1.getTuple(2)));
4411         for i in xrange(4):
4412             self.assertAlmostEqual(expp[i],a1.getTuple(2)[i],12)
4413             pass
4414         a1.setInfoOnComponent(0,"aaaa");
4415         a1.setInfoOnComponent(1,"bbbb");
4416         a1.setInfoOnComponent(2,"cccc");
4417         a1.setInfoOnComponent(3,"dddd");
4418         arr2V=[1,2,1,2,0,0]
4419         a2=a1.keepSelectedComponents(arr2V);
4420         self.assertEqual(6,a2.getNumberOfComponents());
4421         self.assertEqual(5,a2.getNumberOfTuples());
4422         self.assertTrue(a2.getInfoOnComponent(0)=="bbbb");
4423         self.assertTrue(a2.getInfoOnComponent(1)=="cccc");
4424         self.assertTrue(a2.getInfoOnComponent(2)=="bbbb");
4425         self.assertTrue(a2.getInfoOnComponent(3)=="cccc");
4426         self.assertTrue(a2.getInfoOnComponent(4)=="aaaa");
4427         self.assertTrue(a2.getInfoOnComponent(5)=="aaaa");
4428         expected1=[2.,3.,2.,3.,1.,1., 12.,13.,12.,13.,11.,11., 22.,23.,22.,23.,21.,21., 32.,33.,32.,33.,31.,31., 42.,43.,42.,43.,41.,41.]
4429         for i in xrange(30):
4430             self.assertAlmostEqual(expected1[i],a2.getIJ(0,i),14);
4431             pass
4432         a3=a1.convertToIntArr();
4433         self.assertEqual([21,22,23,24],a3.getTuple(2))
4434         a4=a3.keepSelectedComponents(arr2V);
4435         self.assertEqual(6,a4.getNumberOfComponents());
4436         self.assertEqual(5,a4.getNumberOfTuples());
4437         self.assertTrue(a4.getInfoOnComponent(0)=="bbbb");
4438         self.assertTrue(a4.getInfoOnComponent(1)=="cccc");
4439         self.assertTrue(a4.getInfoOnComponent(2)=="bbbb");
4440         self.assertTrue(a4.getInfoOnComponent(3)=="cccc");
4441         self.assertTrue(a4.getInfoOnComponent(4)=="aaaa");
4442         self.assertTrue(a4.getInfoOnComponent(5)=="aaaa");
4443         for i in xrange(30):
4444             self.assertEqual(int(expected1[i]),a4.getIJ(0,i));
4445             pass
4446         # setSelectedComponents
4447         arr3V=[3,2]
4448         a5=a1.keepSelectedComponents(arr3V);
4449         a5.setInfoOnComponent(0,"eeee");
4450         a5.setInfoOnComponent(1,"ffff");
4451         arr4V=[1,2]
4452         a2.setSelectedComponents(a5,arr4V);
4453         self.assertEqual(6,a2.getNumberOfComponents());
4454         self.assertEqual(5,a2.getNumberOfTuples());
4455         self.assertTrue(a2.getInfoOnComponent(0)=="bbbb");
4456         self.assertTrue(a2.getInfoOnComponent(1)=="eeee");
4457         self.assertTrue(a2.getInfoOnComponent(2)=="ffff");
4458         self.assertTrue(a2.getInfoOnComponent(3)=="cccc");
4459         self.assertTrue(a2.getInfoOnComponent(4)=="aaaa");
4460         self.assertTrue(a2.getInfoOnComponent(5)=="aaaa");
4461         expected2=[2.,4.,3.,3.,1.,1., 12.,14.,13.,13.,11.,11., 22.,24.,23.,23.,21.,21., 32.,34.,33.,33.,31.,31., 42.,44.,43.,43.,41.,41.]
4462         for i in xrange(30):
4463             self.assertAlmostEqual(expected2[i],a2.getIJ(0,i),14);
4464             pass
4465         a6=a5.convertToIntArr();
4466         a6.setInfoOnComponent(0,"eeee");
4467         a6.setInfoOnComponent(1,"ffff");
4468         a4.setSelectedComponents(a6,arr4V);
4469         self.assertEqual(6,a4.getNumberOfComponents());
4470         self.assertEqual(5,a4.getNumberOfTuples());
4471         self.assertTrue(a4.getInfoOnComponent(0)=="bbbb");
4472         self.assertTrue(a4.getInfoOnComponent(1)=="eeee");
4473         self.assertTrue(a4.getInfoOnComponent(2)=="ffff");
4474         self.assertTrue(a4.getInfoOnComponent(3)=="cccc");
4475         self.assertTrue(a4.getInfoOnComponent(4)=="aaaa");
4476         self.assertTrue(a4.getInfoOnComponent(5)=="aaaa");
4477         for i in xrange(30):
4478             self.assertEqual(int(expected2[i]),a4.getIJ(0,i));
4479             pass
4480         # test of throw
4481         arr5V=[2,3,6]
4482         arr6V=[2,7,5]
4483         arr7V=[2,1,4,6]
4484         self.assertRaises(InterpKernelException,a2.keepSelectedComponents,arr5V);
4485         self.assertRaises(InterpKernelException,a2.keepSelectedComponents,arr6V);
4486         self.assertRaises(InterpKernelException,a2.setSelectedComponents,a1,arr7V);
4487         arr7V=arr7V[0:3]
4488         self.assertRaises(InterpKernelException,a2.setSelectedComponents,a1,arr7V);
4489         #
4490         pass
4491
4492     def testKeepSetSelectedComponent2(self):
4493         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
4494         arr1=[1.,2.,3.,4., 11.,12.,13.,14., 21.,22.,23.,24., 31.,32.,33.,34., 41.,42.,43.,44.]
4495         a1=DataArrayDouble.New();
4496         a1.setValues(arr1,5,4);
4497         a1.setInfoOnComponent(0,"aaaa");
4498         a1.setInfoOnComponent(1,"bbbb");
4499         a1.setInfoOnComponent(2,"cccc");
4500         a1.setInfoOnComponent(3,"dddd");
4501         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
4502         f1.setTime(2.3,4,5);
4503         f1.setMesh(m1);
4504         f1.setName("f1");
4505         f1.setArray(a1);
4506         f1.checkCoherency();
4507         #
4508         arr2V=[1,2,1,2,0,0]
4509         f2=f1.keepSelectedComponents(arr2V);
4510         self.assertTrue(f2.getTimeDiscretization()==ONE_TIME);
4511         t,dt,it=f2.getTime()
4512         self.assertAlmostEqual(2.3,t,13);
4513         self.assertEqual(4,dt);
4514         self.assertEqual(5,it);
4515         f2.checkCoherency();
4516         self.assertEqual(6,f2.getNumberOfComponents());
4517         self.assertEqual(5,f2.getNumberOfTuples());
4518         self.assertTrue(f2.getArray().getInfoOnComponent(0)=="bbbb");
4519         self.assertTrue(f2.getArray().getInfoOnComponent(1)=="cccc");
4520         self.assertTrue(f2.getArray().getInfoOnComponent(2)=="bbbb");
4521         self.assertTrue(f2.getArray().getInfoOnComponent(3)=="cccc");
4522         self.assertTrue(f2.getArray().getInfoOnComponent(4)=="aaaa");
4523         self.assertTrue(f2.getArray().getInfoOnComponent(5)=="aaaa");
4524         expected1=[2.,3.,2.,3.,1.,1., 12.,13.,12.,13.,11.,11., 22.,23.,22.,23.,21.,21., 32.,33.,32.,33.,31.,31., 42.,43.,42.,43.,41.,41.]
4525         for i in xrange(30):
4526             self.assertAlmostEqual(expected1[i],f2.getIJ(0,i),14);
4527             pass
4528         #setSelectedComponents
4529         arr3V=[3,2]
4530         f5=f1.keepSelectedComponents(arr3V);
4531         f5.setTime(6.7,8,9);
4532         f5.getArray().setInfoOnComponent(0,"eeee");
4533         f5.getArray().setInfoOnComponent(1,"ffff");
4534         f5.checkCoherency();
4535         arr4V=[1,2]
4536         f2.setSelectedComponents(f5,arr4V);
4537         self.assertEqual(6,f2.getNumberOfComponents());
4538         self.assertEqual(5,f2.getNumberOfTuples());
4539         f2.checkCoherency();
4540         t,dt,it=f2.getTime()
4541         self.assertAlmostEqual(2.3,t,13);
4542         self.assertEqual(4,dt);
4543         self.assertEqual(5,it);
4544         self.assertTrue(f2.getArray().getInfoOnComponent(0)=="bbbb");
4545         self.assertTrue(f2.getArray().getInfoOnComponent(1)=="eeee");
4546         self.assertTrue(f2.getArray().getInfoOnComponent(2)=="ffff");
4547         self.assertTrue(f2.getArray().getInfoOnComponent(3)=="cccc");
4548         self.assertTrue(f2.getArray().getInfoOnComponent(4)=="aaaa");
4549         self.assertTrue(f2.getArray().getInfoOnComponent(5)=="aaaa");
4550         expected2=[2.,4.,3.,3.,1.,1., 12.,14.,13.,13.,11.,11., 22.,24.,23.,23.,21.,21., 32.,34.,33.,33.,31.,31., 42.,44.,43.,43.,41.,41.]
4551         for i in xrange(30):
4552             self.assertAlmostEqual(expected2[i],f2.getIJ(0,i),14);
4553             pass
4554         #
4555         pass
4556
4557     def testElementaryDAThrowAndSpecialCases(self):
4558         da=DataArrayInt.New();
4559         self.assertRaises(InterpKernelException, da.checkAllocated);
4560         self.assertRaises(InterpKernelException, da.fillWithValue, 1);
4561         self.assertRaises(InterpKernelException, da.iota, 1);
4562         da.alloc(7,1);
4563         da.fillWithValue(11); #11,11,11,11...
4564         da.iota(10); #10,11,12,13...
4565
4566         db=DataArrayInt.New();
4567         db.alloc(7,2);
4568
4569         dbl2=DataArrayDouble.New();
4570         dbl2.alloc(7,2);
4571         self.assertRaises(InterpKernelException, dbl2.isUniform, 10., 1e-15);
4572         self.assertRaises(InterpKernelException, dbl2.sort);
4573         self.assertRaises(InterpKernelException, dbl2.iota, 10.);
4574
4575         dbl=DataArrayDouble.New();
4576         #DataArrayDouble not allocated yet
4577         self.assertRaises(InterpKernelException, dbl.iota, 10.);
4578         self.assertRaises(InterpKernelException, dbl.isUniform, 10., 1e-15);
4579         self.assertRaises(InterpKernelException, dbl.sort);
4580         self.assertRaises(InterpKernelException, dbl.fromNoInterlace);
4581         self.assertRaises(InterpKernelException, dbl.toNoInterlace);
4582
4583         dbl.alloc(7,1);
4584         dbl.iota(10.);
4585         self.assertTrue(not dbl.isUniform(10.,1e-15));
4586         dbl.sort();
4587         self.assertTrue(dbl.isMonotonic(True, .99));
4588         self.assertTrue(dbl.isMonotonic(True, -.99));
4589         self.assertTrue(not dbl.isMonotonic(True, 1.1));
4590         self.assertTrue(not dbl.isMonotonic(True, -1.1));
4591         dbl.reverse();
4592         self.assertTrue(dbl.isMonotonic(False, .99));
4593         self.assertTrue(not dbl.isMonotonic(False, 1.1));
4594         self.assertTrue(not dbl.isMonotonic(False, -1.1));
4595
4596         dc=DataArrayInt.New();
4597         dc.alloc(14,1);
4598
4599         dd=DataArrayDouble.New();
4600         self.assertRaises(InterpKernelException, dd.checkAllocated);
4601         self.assertRaises(InterpKernelException, dd.fillWithValue, 1.);
4602         self.assertRaises(InterpKernelException, dd.iota, 1.);
4603         self.assertTrue(not ((dd.repr().find("No data"))==-1));
4604
4605         dd.alloc(0,1); #Allocated but nbOfElements==0!
4606         self.assertTrue(not ((dd.repr().find("Number of tuples : 0"))==-1));
4607         self.assertTrue(not ((dd.repr().find("Empty Data"))==-1));
4608         dd.fillWithValue(11); #?!...ok
4609         dd.iota(10); #?!...ok
4610         self.assertTrue(dd.isMonotonic(True, 1.));  #nothing is monotonic
4611         self.assertTrue(dd.isMonotonic(False, 1.));
4612
4613         self.assertRaises(InterpKernelException, db.copyStringInfoFrom, da);
4614         self.assertRaises(InterpKernelException, db.copyStringInfoFrom, da);
4615         cIds=[2,2]
4616         self.assertRaises(InterpKernelException, da.copyPartOfStringInfoFrom, db, cIds);
4617         cIds[0]=1;
4618         cIds[0]=-1;
4619         self.assertRaises(InterpKernelException, da.copyPartOfStringInfoFrom, db, cIds);
4620
4621         info=["infoOfOneComponent"]*2;
4622         self.assertRaises(InterpKernelException, da.setInfoOnComponents, info);
4623         self.assertRaises(InterpKernelException, da.setInfoOnComponent, 1, info[0]);
4624         db.setInfoOnComponents(info);
4625
4626         self.assertRaises(InterpKernelException, da.getInfoOnComponent, -1);
4627         self.assertRaises(InterpKernelException, da.getInfoOnComponent, 2);
4628         self.assertTrue(db.getInfoOnComponent(1)==db.getInfoOnComponent(0));
4629         self.assertRaises(InterpKernelException, db.getVarOnComponent, -1);
4630         self.assertRaises(InterpKernelException, db.getVarOnComponent, 2);
4631         self.assertRaises(InterpKernelException, db.getUnitOnComponent, -1);
4632         self.assertRaises(InterpKernelException, db.getUnitOnComponent, 2);
4633
4634         self.assertTrue(da.GetVarNameFromInfo("varname unit ")=="varname unit ");
4635         self.assertTrue(da.GetVarNameFromInfo("varname]unit[")=="varname]unit[");
4636         self.assertTrue(da.GetVarNameFromInfo("[unit]")=="");
4637         self.assertTrue(da.GetVarNameFromInfo("varname [unit]")=="varname");
4638
4639         self.assertTrue(da.GetUnitFromInfo("varname unit ")=="");
4640         self.assertTrue(da.GetUnitFromInfo("varname]unit[")=="");
4641         self.assertTrue(da.GetUnitFromInfo("[unit]")=="unit");
4642         self.assertTrue(da.GetUnitFromInfo("varname [unit]")=="unit");
4643
4644         self.assertRaises(InterpKernelException, da.checkNbOfTuplesAndComp, db, "theMessageInThrow");
4645         self.assertRaises(InterpKernelException, da.checkNbOfTuplesAndComp, dc, "theMessageInThrow");
4646         self.assertRaises(InterpKernelException, db.checkNbOfTuplesAndComp, dc, "theMessageInThrow");
4647
4648         self.assertRaises(InterpKernelException, da.checkNbOfTuplesAndComp, 7, 2, "theMessageInThrow");
4649         da.checkNbOfTuplesAndComp(7,1,"theMessageInThrow");
4650
4651         self.assertRaises(InterpKernelException, db.checkNbOfElems, 7*2+1, "theMessageInThrow");
4652         db.checkNbOfElems(7*2,"theMessageInThrow");
4653
4654         self.assertRaises(InterpKernelException, db.GetNumberOfItemGivenBES, 10, 9, 1, "theMessageInThrow");
4655         self.assertRaises(InterpKernelException, db.GetNumberOfItemGivenBES, 0, 1, -1, "theMessageInThrow");
4656         self.assertEqual(10,db.GetNumberOfItemGivenBES(0,10,1,"theMessageInThrow"));
4657         self.assertEqual(5,db.GetNumberOfItemGivenBES(0,10,2,"theMessageInThrow"));
4658         self.assertEqual(6,db.GetNumberOfItemGivenBES(0,11,2,"theMessageInThrow"));
4659
4660         self.assertTrue(not ((da.repr().find("Number of components : 1"))==-1));
4661         self.assertTrue(not ((dd.repr().find("Number of components : 1"))==-1));
4662         self.assertTrue(not ((dbl.repr().find("Number of components : 1"))==-1));
4663
4664         self.assertTrue(not ((da.reprZip().find("Number of components : 1"))==-1));
4665         self.assertTrue(not ((dd.reprZip().find("Number of components : 1"))==-1));
4666         self.assertTrue(not ((dbl.reprZip().find("Number of components : 1"))==-1));
4667
4668         self.assertRaises(InterpKernelException, dbl.selectByTupleId2, 0, 1, -1);
4669         self.assertRaises(InterpKernelException, dbl.substr, -1, 1);
4670         self.assertRaises(InterpKernelException, dbl.substr, 8, 1);
4671         self.assertRaises(InterpKernelException, dbl.substr, 0, 8);
4672         self.assertRaises(InterpKernelException, dbl.meldWith, dd);
4673
4674         self.assertRaises(InterpKernelException, dbl.setPartOfValuesAdv, dbl2, da); #dbl dbl2 not have the same number of components
4675         self.assertRaises(InterpKernelException, dbl.setPartOfValuesAdv, dd, da);  #da tuple selector DataArrayInt instance not have exactly 2 components
4676
4677         dbl3=DataArrayDouble.New();
4678         dbl3.alloc(6,2);
4679         dbl3.fillWithValue(11.);
4680         #bad number of components
4681         self.assertRaises(InterpKernelException, dbl3.getMaxValue);
4682         self.assertRaises(InterpKernelException, dd.getMaxValue);
4683         self.assertRaises(InterpKernelException, dbl3.getMinValue);
4684         self.assertRaises(InterpKernelException, dd.getMinValue);
4685         self.assertRaises(InterpKernelException, dbl3.getAverageValue);
4686         self.assertRaises(InterpKernelException, dd.getAverageValue);
4687         self.assertRaises(InterpKernelException, dd.accumulate, 100);
4688         self.assertRaises(InterpKernelException, dbl.fromPolarToCart);
4689         self.assertRaises(InterpKernelException, dbl3.fromCylToCart);
4690         self.assertRaises(InterpKernelException, dbl3.fromSpherToCart);
4691         self.assertRaises(InterpKernelException, dbl3.doublyContractedProduct);
4692         self.assertRaises(InterpKernelException, dbl3.determinant);
4693         self.assertRaises(InterpKernelException, dbl3.eigenValues);
4694         self.assertRaises(InterpKernelException, dbl3.eigenVectors);
4695         self.assertRaises(InterpKernelException, dbl3.inverse);
4696         self.assertRaises(InterpKernelException, dbl3.trace);
4697         self.assertRaises(InterpKernelException, dbl3.deviator);
4698
4699         dbl3.setIJ(5,1,12.);
4700         self.assertTrue(dbl3.getMaxValueInArray()==12.);
4701         self.assertTrue(dbl3.getMinValueInArray()==11.);
4702
4703         db.fillWithValue(100); #bad Ids
4704         self.assertRaises(InterpKernelException, dbl3.setPartOfValuesAdv, dbl2, db);
4705         db.fillWithValue(-1); #bad Ids
4706         self.assertRaises(InterpKernelException, dbl3.setPartOfValuesAdv, dbl2, db);
4707         db.fillWithValue(6); #bad Ids for dbl3
4708         self.assertRaises(InterpKernelException, dbl3.setPartOfValuesAdv, dbl2, db);
4709
4710         dbl3.checkNoNullValues();
4711         dbl3.setIJ(5,0,0.);
4712         self.assertRaises(InterpKernelException, dbl3.checkNoNullValues);
4713         self.assertRaises(InterpKernelException, dbl3.applyInv, 1.);  #div by zero
4714         self.assertRaises(InterpKernelException, dbl2.getIdsInRange, 1., 2.);
4715         a=[]
4716         self.assertRaises(InterpKernelException, DataArrayDouble_Aggregate, a);
4717         self.assertRaises(InterpKernelException, DataArrayDouble_Meld, a);
4718
4719         a=[dbl2,dbl]; #Nb of components mismatch
4720         self.assertRaises(InterpKernelException, DataArrayDouble_Aggregate, a);
4721
4722         self.assertRaises(InterpKernelException, DataArrayDouble_Dot, dbl2, dbl);
4723
4724         self.assertRaises(InterpKernelException, DataArrayDouble_CrossProduct, dbl2, dbl); #Nb of components mismatch
4725         self.assertRaises(InterpKernelException, DataArrayDouble_CrossProduct, dbl2, dbl2); #Nb of components must be equal to 3
4726         dbl4=DataArrayDouble.New();
4727         dbl4.alloc(6,3);
4728         dbl5=DataArrayDouble.New();
4729         dbl5.alloc(7,3);
4730         self.assertRaises(InterpKernelException, DataArrayDouble_CrossProduct, dbl4, dbl5); #Nb of tuples mismatch
4731
4732         a[0]=dbl4; #Nb of tuple mismatch
4733         a[1]=dbl5; #Nb of tuple mismatch
4734         self.assertRaises(InterpKernelException, DataArrayDouble_Meld, a);
4735         self.assertRaises(InterpKernelException, DataArrayDouble_Dot, dbl4, dbl5);
4736         pass
4737
4738     def testDAIGetIdsEqual1(self):
4739         tab1=[5,-2,-4,-2,3,2,-2];
4740         da=DataArrayInt.New();
4741         da.setValues(tab1,7,1);
4742         da2=da.getIdsEqual(-2);
4743         self.assertEqual(3,da2.getNumberOfTuples());
4744         self.assertEqual(1,da2.getNumberOfComponents());
4745         expected1=[1,3,6];
4746         self.assertEqual(expected1,da2.getValues());
4747         pass
4748
4749     def testDAIGetIdsEqualList1(self):
4750         tab1=[5,-2,-4,-2,3,2,-2];
4751         da=DataArrayInt.New();
4752         da.setValues(tab1,7,1);
4753         da2=da.getIdsEqualList([3,-2,0]);
4754         self.assertEqual(4,da2.getNumberOfTuples());
4755         self.assertEqual(1,da2.getNumberOfComponents());
4756         expected1=[1,3,4,6];
4757         self.assertEqual(expected1,da2.getValues());
4758         pass
4759
4760     def testDAFromNoInterlace1(self):
4761         tab1=[1,11,21,31,41,2,12,22,32,42,3,13,23,33,43]
4762         da=DataArrayInt.New();
4763         da.setValues(tab1,5,3);
4764         da2=da.fromNoInterlace();
4765         expected1=[1,2,3,11,12,13,21,22,23,31,32,33,41,42,43]
4766         self.assertEqual(5,da2.getNumberOfTuples());
4767         self.assertEqual(3,da2.getNumberOfComponents());# it's not a bug. Avoid to have 1 million components !
4768         self.assertEqual(expected1,da2.getValues());
4769         da3=da.convertToDblArr();
4770         da4=da3.fromNoInterlace();
4771         self.assertEqual(5,da4.getNumberOfTuples());
4772         self.assertEqual(3,da4.getNumberOfComponents());# it's not a bug. Avoid to have 1 million components !
4773         for i in xrange(15):
4774             self.assertAlmostEqual(expected1[i],da4.getIJ(0,i),14);
4775             pass
4776         pass
4777
4778     def testDAToNoInterlace1(self):
4779         tab1=[1,2,3,11,12,13,21,22,23,31,32,33,41,42,43]
4780         da=DataArrayInt.New();
4781         da.setValues(tab1,5,3);
4782         da2=da.toNoInterlace();
4783         expected1=[1,11,21,31,41,2,12,22,32,42,3,13,23,33,43]
4784         self.assertEqual(5,da2.getNumberOfTuples());
4785         self.assertEqual(3,da2.getNumberOfComponents());# it's not a bug. Avoid to have 1 million components !
4786         self.assertEqual(expected1,da2.getValues());
4787         da3=da.convertToDblArr();
4788         da4=da3.toNoInterlace();
4789         self.assertEqual(5,da4.getNumberOfTuples());
4790         self.assertEqual(3,da4.getNumberOfComponents());# it's not a bug. Avoid to have 1 million components !
4791         for i in xrange(15):
4792             self.assertAlmostEqual(expected1[i],da4.getIJ(0,i),14);
4793             pass
4794         pass
4795
4796     def testDAIsUniform1(self):
4797         tab1=[1,1,1,1,1]
4798         da=DataArrayInt.New();
4799         da.setValues(tab1,5,1);
4800         self.assertTrue(da.isUniform(1));
4801         da.setIJ(2,0,2);
4802         self.assertTrue(not da.isUniform(1));
4803         da.setIJ(2,0,1);
4804         self.assertTrue(da.isUniform(1));
4805         da2=da.convertToDblArr();
4806         self.assertTrue(da2.isUniform(1.,1.e-12));
4807         da2.setIJ(1,0,1.+1.e-13);
4808         self.assertTrue(da2.isUniform(1.,1.e-12));
4809         da2.setIJ(1,0,1.+1.e-11);
4810         self.assertTrue(not da2.isUniform(1.,1.e-12));
4811         pass
4812
4813     def testDADFromPolarToCart1(self):
4814         tab1=[2.,0.2,2.5,0.7]
4815         da=DataArrayDouble.New();
4816         da.setValues(tab1,2,2);
4817         da2=da.fromPolarToCart();
4818         expected1=[1.9601331556824833,0.39733866159012243, 1.9121054682112213,1.6105442180942275]
4819         for i in xrange(4):
4820             self.assertAlmostEqual(expected1[i],da2.getIJ(0,i),13);
4821             pass
4822         pass
4823
4824     def testDADFromCylToCart1(self):
4825         tab1=[2.,0.2,4.,2.5,0.7,9.]
4826         da=DataArrayDouble.New();
4827         da.setValues(tab1,2,3);
4828         da2=da.fromCylToCart();
4829         expected1=[1.9601331556824833,0.39733866159012243,4., 1.9121054682112213,1.6105442180942275,9.]
4830         for i in xrange(6):
4831             self.assertAlmostEqual(expected1[i],da2.getIJ(0,i),13);
4832             pass
4833         pass
4834
4835     def testDADFromSpherToCart1(self):
4836         tab1=[2.,0.2,0.3,2.5,0.7,0.8]
4837         da=DataArrayDouble.New();
4838         da.setValues(tab1,2,3);
4839         da2=da.fromSpherToCart();
4840         expected1=[0.37959212195737485,0.11742160338765303,1.9601331556824833, 1.1220769624465328,1.1553337045129035,1.9121054682112213]
4841         for i in xrange(6):
4842             self.assertAlmostEqual(expected1[i],da2.getIJ(0,i),13);
4843             pass
4844         pass
4845
4846     def testUnPolyze1(self):
4847         elts=[0,1,2,3,4,5,6,7]
4848         eltsV=elts;
4849         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
4850         mesh.convertToPolyTypes(eltsV);
4851         mesh.unPolyze();
4852         mesh2=MEDCouplingDataForTest.build3DTargetMesh_1();
4853         mesh.checkCoherency();
4854         self.assertTrue(mesh.isEqual(mesh2,1e-12));
4855         mesh.convertToPolyTypes(eltsV);
4856         self.assertTrue(not mesh.isEqual(mesh2,1e-12));
4857         mesh.getNodalConnectivity().setIJ(0,6,10);
4858         mesh.getNodalConnectivity().setIJ(0,7,9);
4859         mesh.getNodalConnectivity().setIJ(0,8,12);
4860         mesh.getNodalConnectivity().setIJ(0,9,13);
4861         mesh.unPolyze();
4862         self.assertTrue(mesh.isEqual(mesh2,1e-12));
4863         mesh.convertToPolyTypes(eltsV);
4864         mesh.getNodalConnectivity().setIJ(0,6,12);
4865         mesh.getNodalConnectivity().setIJ(0,7,13);
4866         mesh.getNodalConnectivity().setIJ(0,8,10);
4867         mesh.getNodalConnectivity().setIJ(0,9,9);
4868         mesh.unPolyze();
4869         self.assertTrue(mesh.isEqual(mesh2,1e-12));
4870         mesh.convertToPolyTypes(eltsV);
4871         mesh.getNodalConnectivity().setIJ(0,6,12);
4872         mesh.getNodalConnectivity().setIJ(0,7,10);
4873         mesh.getNodalConnectivity().setIJ(0,8,13);
4874         mesh.getNodalConnectivity().setIJ(0,9,9);
4875         mesh.unPolyze();
4876         self.assertTrue(not mesh.isEqual(mesh2,1e-12));
4877         # Test for 2D mesh
4878         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
4879         mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
4880         eltsV=eltsV[:5];
4881         mesh.convertToPolyTypes(eltsV);
4882         self.assertTrue(not mesh.isEqual(mesh2,1e-12));
4883         mesh.unPolyze();
4884         self.assertTrue(mesh.isEqual(mesh2,1e-12));
4885         pass
4886
4887     def testConvertDegeneratedCells1(self):
4888         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
4889         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]
4890         mesh.allocateCells(4);
4891         mesh.insertNextCell(NORM_HEXA8,8,conn[0:8])
4892         mesh.insertNextCell(NORM_HEXA8,8,conn[8:16])
4893         mesh.insertNextCell(NORM_HEXA8,8,conn[16:24])
4894         mesh.insertNextCell(NORM_HEXA8,8,conn[24:32])
4895         mesh.finishInsertingCells();
4896         mesh.checkCoherency();
4897         self.assertEqual(4,mesh.getNumberOfCells());
4898         self.assertEqual(NORM_HEXA8,mesh.getTypeOfCell(0));
4899         self.assertEqual(NORM_HEXA8,mesh.getTypeOfCell(1));
4900         self.assertEqual(NORM_HEXA8,mesh.getTypeOfCell(2));
4901         self.assertEqual(NORM_HEXA8,mesh.getTypeOfCell(3));
4902         f1=mesh.getMeasureField(True);
4903         mesh.convertDegeneratedCells();
4904         mesh.checkCoherency();
4905         f2=mesh.getMeasureField(True);
4906         self.assertEqual(4,mesh.getNumberOfCells());
4907         self.assertEqual(NORM_PENTA6,mesh.getTypeOfCell(0));
4908         self.assertEqual(NORM_PYRA5,mesh.getTypeOfCell(1));
4909         self.assertEqual(NORM_TETRA4,mesh.getTypeOfCell(2));
4910         self.assertEqual(NORM_PYRA5,mesh.getTypeOfCell(3));
4911         for i in xrange(4):
4912             self.assertAlmostEqual(f1.getArray().getIJ(0,i),f2.getArray().getIJ(0,i),5);
4913             pass
4914         pass
4915
4916     def testGetNodeIdsNearPoints1(self):
4917         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
4918         coords=mesh.getCoords();
4919         tmp=DataArrayDouble.New();
4920         vals=[0.2,0.2,0.1,0.2,0.2,0.2]
4921         tmp.setValues(vals,3,2);
4922         tmp2=DataArrayDouble.Aggregate(coords,tmp);
4923         mesh.setCoords(tmp2);
4924         pts=[0.2,0.2,0.1,0.3,-0.3,0.7]
4925         c=mesh.getNodeIdsNearPoint(pts[:2],1e-7);
4926         self.assertEqual([4,9,11],c.getValues());
4927         c,cI=mesh.getNodeIdsNearPoints(pts,3,1e-7);
4928         self.assertEqual([0,3,3,4],cI.getValues());
4929         self.assertEqual([4,9,11,6],c.getValues());
4930         c,cI=mesh.getNodeIdsNearPoints(pts,1e-7);
4931         self.assertEqual([0,3,3,4],cI.getValues());
4932         self.assertEqual([4,9,11,6],c.getValues());
4933         c,cI=mesh.getNodeIdsNearPoints(DataArrayDouble.New(pts,3,2),1e-7);
4934         self.assertEqual([0,3,3,4],cI.getValues());
4935         self.assertEqual([4,9,11,6],c.getValues());
4936         self.assertRaises(InterpKernelException,mesh.getNodeIdsNearPoints,DataArrayDouble.New(pts,2,3),1e-7);
4937         pass
4938
4939     def testFieldCopyTinyAttrFrom1(self):
4940         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
4941         f1.setName("f1");
4942         f1.setTimeTolerance(1.e-5);
4943         f1.setDescription("f1Desc");
4944         f1.setTime(1.23,4,5);
4945         f2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
4946         f2.setName("f2");
4947         f2.setDescription("f2Desc");
4948         f2.setTime(6.78,9,10);
4949         f2.setTimeTolerance(4.556e-12);
4950         #
4951         f1.copyTinyAttrFrom(f2);
4952         self.assertAlmostEqual(4.556e-12,f1.getTimeTolerance(),24);
4953         t,dt,it=f1.getTime()
4954         self.assertAlmostEqual(6.78,t,12);
4955         self.assertEqual(9,dt);
4956         self.assertEqual(10,it);
4957         self.assertTrue(f1.getName()=="f1");#name unchanged
4958         self.assertTrue(f1.getDescription()=="f1Desc");#description unchanged
4959         #
4960         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
4961         f1.setName("f1");
4962         f1.setTimeTolerance(1.e-5);
4963         f1.setDescription("f1Desc");
4964         f2=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
4965         f2.setName("f2");
4966         f2.setDescription("f2Desc");
4967         f2.setTimeTolerance(4.556e-12);
4968         #
4969         f1.copyTinyAttrFrom(f2);
4970         self.assertAlmostEqual(4.556e-12,f1.getTimeTolerance(),24);
4971         self.assertTrue(f1.getName()=="f1");#name unchanged
4972         self.assertTrue(f1.getDescription()=="f1Desc");#description unchanged
4973         #
4974         f1=MEDCouplingFieldDouble.New(ON_CELLS,CONST_ON_TIME_INTERVAL);
4975         f1.setName("f1");
4976         f1.setTimeTolerance(1.e-5);
4977         f1.setDescription("f1Desc");
4978         f1.setTime(1.23,4,5);
4979         f1.setEndTime(5.43,2,1);
4980         f2=MEDCouplingFieldDouble.New(ON_CELLS,CONST_ON_TIME_INTERVAL);
4981         f2.setName("f2");
4982         f2.setDescription("f2Desc");
4983         f2.setTimeTolerance(4.556e-12);
4984         f2.setTime(6.78,9,10);
4985         f2.setEndTime(10.98,7,6);
4986         #
4987         f1.copyTinyAttrFrom(f2);
4988         self.assertAlmostEqual(4.556e-12,f1.getTimeTolerance(),24);
4989         self.assertTrue(f1.getName()=="f1");#name unchanged
4990         self.assertTrue(f1.getDescription()=="f1Desc");#description unchanged
4991         t,dt,it=f1.getTime()
4992         self.assertAlmostEqual(6.78,t,12);
4993         self.assertEqual(9,dt);
4994         self.assertEqual(10,it);
4995         t,dt,it=f1.getEndTime()
4996         self.assertAlmostEqual(10.98,t,12);
4997         self.assertEqual(7,dt);
4998         self.assertEqual(6,it);
4999         #
5000         f1=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
5001         f1.setName("f1");
5002         f1.setTimeTolerance(1.e-5);
5003         f1.setDescription("f1Desc");
5004         f1.setTime(1.23,4,5);
5005         f1.setEndTime(5.43,2,1);
5006         f2=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
5007         f2.setName("f2");
5008         f2.setDescription("f2Desc");
5009         f2.setTimeTolerance(4.556e-12);
5010         f2.setTime(6.78,9,10);
5011         f2.setEndTime(10.98,7,6);
5012         #
5013         f1.copyTinyAttrFrom(f2);
5014         self.assertAlmostEqual(4.556e-12,f1.getTimeTolerance(),24);
5015         self.assertTrue(f1.getName()=="f1");#name unchanged
5016         self.assertTrue(f1.getDescription()=="f1Desc");#description unchanged
5017         t,dt,it=f1.getTime()
5018         self.assertAlmostEqual(6.78,t,12);
5019         self.assertEqual(9,dt);
5020         self.assertEqual(10,it);
5021         t,dt,it=f1.getEndTime()
5022         self.assertAlmostEqual(10.98,t,12);
5023         self.assertEqual(7,dt);
5024         self.assertEqual(6,it);
5025         pass
5026
5027     def testExtrudedMesh5(self):
5028         coo1=[0.,1.,2.,3.5]
5029         a=DataArrayDouble.New();
5030         a.setValues(coo1,4,1);
5031         b=MEDCouplingCMesh.New();
5032         b.setCoordsAt(0,a);
5033         c=b.buildUnstructured();
5034         self.assertEqual(1,c.getSpaceDimension());
5035         c.changeSpaceDimension(2);
5036         #
5037         d=DataArrayDouble.New();
5038         d.alloc(13,1);
5039         d.iota();
5040         e=MEDCouplingCMesh.New();
5041         e.setCoordsAt(0,d);
5042         f=e.buildUnstructured();
5043         g=f.getCoords().applyFunc(2,"3.5*IVec+x/6*3.14159265359*JVec");
5044         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 !
5045         h=g.fromPolarToCart();
5046         f.setCoords(h);
5047         i=c.buildExtrudedMesh(f,1);
5048         self.assertEqual(52,i.getNumberOfNodes());
5049         tmp,tmp2,tmp3=i.mergeNodes(1e-9);
5050         self.assertTrue(tmp2);
5051         self.assertEqual(37,tmp3);
5052         i.convertDegeneratedCells();
5053         i.checkCoherency();
5054         self.assertEqual(36,i.getNumberOfCells());
5055         self.assertEqual(37,i.getNumberOfNodes());
5056         self.assertEqual(12,i.getNumberOfCellsWithType(NORM_TRI3));
5057         self.assertEqual(24,i.getNumberOfCellsWithType(NORM_QUAD4));
5058         expected1=[0.25,0.75,2.0625]
5059         j=i.getMeasureField(True);
5060         for ii in xrange(12):
5061             for k in xrange(3):
5062                 self.assertAlmostEqual(expected1[k],j.getIJ(0,ii*3+k),10);
5063                 pass
5064             pass
5065         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]
5066         m=i.getBarycenterAndOwner();
5067         for i in xrange(72):
5068             self.assertAlmostEqual(expected2[i],m.getIJ(0,i),10);
5069             pass
5070         #
5071         pass
5072
5073     def testExtrudedMesh6(self):
5074         coo1=[0.,1.,2.,3.5]
5075         a=DataArrayDouble.New();
5076         a.setValues(coo1,4,1);
5077         b=MEDCouplingCMesh.New();
5078         b.setCoordsAt(0,a);
5079         c=b.buildUnstructured();
5080         self.assertEqual(1,c.getSpaceDimension());
5081         c.changeSpaceDimension(2);
5082         #
5083         d=DataArrayDouble.New();
5084         d.alloc(5,1);
5085         d.iota();
5086         e=MEDCouplingCMesh.New();
5087         e.setCoordsAt(0,d);
5088         f=e.buildUnstructured();
5089         d2=f.getCoords().applyFunc("x*x/2");
5090         f.setCoords(d2);
5091         f.changeSpaceDimension(2);
5092         #
5093         center=[0.,0.]
5094         f.rotate(center,None,pi/3);
5095         g=c.buildExtrudedMesh(f,0);
5096         g.checkCoherency();
5097         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 ]
5098         f1=g.getMeasureField(True);
5099         for i in xrange(12):
5100             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),12);
5101             pass
5102         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]
5103         f2=g.getBarycenterAndOwner();
5104         for i in xrange(24):
5105             self.assertAlmostEqual(expected2[i],f2.getIJ(0,i),12);
5106             pass
5107         pass
5108
5109     def testExtrudedMesh7(self):
5110         coo1=[0.,1.,2.,3.5]
5111         a=DataArrayDouble.New();
5112         a.setValues(coo1,4,1);
5113         b=MEDCouplingCMesh.New();
5114         b.setCoordsAt(0,a);
5115         c=b.buildUnstructured();
5116         self.assertEqual(1,c.getSpaceDimension());
5117         c.changeSpaceDimension(2);
5118         #
5119         d=DataArrayDouble.New();
5120         d.alloc(13,1);
5121         d.iota();
5122         e=MEDCouplingCMesh.New();
5123         e.setCoordsAt(0,d);
5124         f=e.buildUnstructured();
5125         g=f.getCoords().applyFunc(2,"3.5*IVec+x/6*3.14159265359*JVec");
5126         h=g.fromPolarToCart();
5127         f.setCoords(h);
5128         i=c.buildExtrudedMesh(f,1);
5129         self.assertEqual(52,i.getNumberOfNodes());
5130         tmp,tmp2,tmp3=i.mergeNodes(1e-9);
5131         self.assertTrue(tmp2);
5132         self.assertEqual(37,tmp3);
5133         i.convertDegeneratedCells();
5134         vec1=[10.,0]
5135         i.translate(vec1);
5136         g2=h.applyFunc(3,"13.5/3.5*x*IVec+0*JVec+13.5/3.5*y*KVec");
5137         f.setCoords(g2);
5138         i.changeSpaceDimension(3);
5139         i3=i.buildExtrudedMesh(f,1);
5140         f2=i3.getMeasureField(True);
5141         tmp,tmp2,tmp3=i.mergeNodes(1e-9);
5142         self.assertTrue(tmp2);
5143         self.assertEqual(444,tmp3);
5144         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]
5145         for ii in xrange(12):
5146             for jj in xrange(36):
5147                 self.assertAlmostEqual(expected1[jj],f2.getIJ(0,ii*36+jj),9);
5148                 pass
5149         #
5150         pass
5151
5152     def testSimplexize1(self):
5153         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5154         m.convertToPolyTypes([3]);
5155         da=m.simplexize(0);
5156         self.assertEqual(7,da.getNumberOfTuples());
5157         self.assertEqual(1,da.getNumberOfComponents());
5158         expected2=[0,0,1,2,3,4,4]
5159         for i in xrange(7):
5160             self.assertEqual(expected2[i],da.getIJ(i,0));
5161             pass
5162         m.checkCoherency();
5163         self.assertEqual(7,m.getNumberOfCells());
5164         self.assertEqual(NORM_TRI3,m.getTypeOfCell(0));
5165         self.assertEqual(NORM_TRI3,m.getTypeOfCell(1));
5166         self.assertEqual(NORM_TRI3,m.getTypeOfCell(2));
5167         self.assertEqual(NORM_TRI3,m.getTypeOfCell(3));
5168         self.assertEqual(NORM_POLYGON,m.getTypeOfCell(4));
5169         self.assertEqual(NORM_TRI3,m.getTypeOfCell(5));
5170         self.assertEqual(NORM_TRI3,m.getTypeOfCell(6));
5171         expected1=[0.125,0.125,0.125,0.125,0.25,0.125,0.125]
5172         f=m.getMeasureField(False);
5173         for i in xrange(7):
5174             self.assertAlmostEqual(expected1[i]*sqrt(2.),f.getIJ(i,0),10);
5175             pass
5176         types=m.getAllTypes();
5177         self.assertEqual([NORM_TRI3,NORM_POLYGON],types);
5178         #
5179         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5180         m.convertToPolyTypes([3]);
5181         da=m.simplexize(1);
5182         self.assertEqual(7,da.getNumberOfTuples());
5183         self.assertEqual(1,da.getNumberOfComponents());
5184         for i in xrange(7):
5185             self.assertEqual(expected2[i],da.getIJ(i,0));
5186             pass
5187         m.checkCoherency();
5188         types=m.getAllTypes();
5189         self.assertEqual([NORM_TRI3,NORM_POLYGON],types);
5190         self.assertEqual(7,m.getNumberOfCells());
5191         self.assertEqual(NORM_TRI3,m.getTypeOfCell(0));
5192         self.assertEqual(NORM_TRI3,m.getTypeOfCell(1));
5193         self.assertEqual(NORM_TRI3,m.getTypeOfCell(2));
5194         self.assertEqual(NORM_TRI3,m.getTypeOfCell(3));
5195         self.assertEqual(NORM_POLYGON,m.getTypeOfCell(4));
5196         self.assertEqual(NORM_TRI3,m.getTypeOfCell(5));
5197         self.assertEqual(NORM_TRI3,m.getTypeOfCell(6));
5198         f=m.getMeasureField(False);
5199         for i in xrange(7):
5200             self.assertAlmostEqual(expected1[i]*sqrt(2.),f.getIJ(i,0),10);
5201             pass
5202         pass
5203
5204     def testSimplexize2(self):
5205         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5206         m.convertToPolyTypes([3]);
5207         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
5208         f1.setMesh(m);
5209         arr=DataArrayDouble.New();
5210         arr1=[10.,110.,20.,120.,30.,130.,40.,140.,50.,150.]
5211         arr.setValues(arr1,5,2);
5212         f1.setArray(arr);
5213         #
5214         f1.checkCoherency();
5215         self.assertTrue(f1.simplexize(0));
5216         f1.checkCoherency();
5217         expected1=[10.,110.,10.,110.,20.,120.,30.,130.,40.,140.,50.,150.,50.,150.]
5218         for i in xrange(14):
5219             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),10);
5220             pass
5221         self.assertTrue(not f1.simplexize(0));
5222         for i in xrange(14):
5223             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),10);
5224             pass
5225         #
5226         pass
5227
5228     def testDAMeld1(self):
5229         da1=DataArrayDouble.New();
5230         da1.alloc(7,2);
5231         da2=DataArrayDouble.New();
5232         da2.alloc(7,1);
5233         #
5234         da1.fillWithValue(7.);
5235         da2.iota(0.);
5236         da3=da2.applyFunc(3,"10*x*IVec+100*x*JVec+1000*x*KVec");
5237         #
5238         da1.setInfoOnComponent(0,"c0da1");
5239         da1.setInfoOnComponent(1,"c1da1");
5240         da3.setInfoOnComponent(0,"c0da3");
5241         da3.setInfoOnComponent(1,"c1da3");
5242         da3.setInfoOnComponent(2,"c2da3");
5243         #
5244         da1C=da1.deepCpy();
5245         da1.meldWith(da3);
5246         self.assertEqual(5,da1.getNumberOfComponents());
5247         self.assertEqual(7,da1.getNumberOfTuples());
5248         self.assertTrue(da1.getInfoOnComponent(0)=="c0da1");
5249         self.assertTrue(da1.getInfoOnComponent(1)=="c1da1");
5250         self.assertTrue(da1.getInfoOnComponent(2)=="c0da3");
5251         self.assertTrue(da1.getInfoOnComponent(3)=="c1da3");
5252         self.assertTrue(da1.getInfoOnComponent(4)=="c2da3");
5253         #
5254         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.]
5255         for i in xrange(35):
5256             self.assertAlmostEqual(expected1[i],da1.getIJ(0,i),10);
5257             pass
5258         #
5259         dai1=da1C.convertToIntArr();
5260         dai3=da3.convertToIntArr();
5261         dai1.meldWith(dai3);
5262         self.assertEqual(5,dai1.getNumberOfComponents());
5263         self.assertEqual(7,dai1.getNumberOfTuples());
5264         self.assertTrue(dai1.getInfoOnComponent(0)=="c0da1");
5265         self.assertTrue(dai1.getInfoOnComponent(1)=="c1da1");
5266         self.assertTrue(dai1.getInfoOnComponent(2)=="c0da3");
5267         self.assertTrue(dai1.getInfoOnComponent(3)=="c1da3");
5268         self.assertTrue(dai1.getInfoOnComponent(4)=="c2da3");
5269         for i in xrange(35):
5270             self.assertEqual(int(expected1[i]),dai1.getIJ(0,i));
5271             pass
5272         # test of static method DataArrayDouble::meld
5273         da4=DataArrayDouble.Meld(da1C,da3);
5274         tmp=DataArrayDouble.Meld([da1C,da3]);
5275         self.assertTrue(da4.isEqual(tmp,1e-10))
5276         self.assertEqual(5,da4.getNumberOfComponents());
5277         self.assertEqual(7,da4.getNumberOfTuples());
5278         self.assertTrue(da4.getInfoOnComponent(0)=="c0da1");
5279         self.assertTrue(da4.getInfoOnComponent(1)=="c1da1");
5280         self.assertTrue(da4.getInfoOnComponent(2)=="c0da3");
5281         self.assertTrue(da4.getInfoOnComponent(3)=="c1da3");
5282         self.assertTrue(da4.getInfoOnComponent(4)=="c2da3");
5283         for i in xrange(35):
5284             self.assertAlmostEqual(expected1[i],da4.getIJ(0,i),10);
5285             pass
5286         # test of static method DataArrayInt::meld
5287         dai1=da1C.convertToIntArr();
5288         dai4=DataArrayInt.Meld(dai1,dai3);
5289         tmp=DataArrayInt.Meld([dai1,dai3]);
5290         self.assertTrue(dai4.isEqual(tmp))
5291         self.assertEqual(5,dai4.getNumberOfComponents());
5292         self.assertEqual(7,dai4.getNumberOfTuples());
5293         self.assertTrue(dai4.getInfoOnComponent(0)=="c0da1");
5294         self.assertTrue(dai4.getInfoOnComponent(1)=="c1da1");
5295         self.assertTrue(dai4.getInfoOnComponent(2)=="c0da3");
5296         self.assertTrue(dai4.getInfoOnComponent(3)=="c1da3");
5297         self.assertTrue(dai4.getInfoOnComponent(4)=="c2da3");
5298         for i in xrange(35):
5299             self.assertEqual(int(expected1[i]),dai4.getIJ(0,i));
5300             pass
5301         pass
5302
5303     def testFieldMeld1(self):
5304         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5305         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
5306         f1.setMesh(m);
5307         da1=DataArrayDouble.New();
5308         arr1=[12.,23.,34.,45.,56.]
5309         da1.setValues(arr1,5,1);
5310         da1.setInfoOnComponent(0,"aaa");
5311         f1.setArray(da1);
5312         f1.setTime(3.4,2,1);
5313         f1.checkCoherency();
5314         #
5315         f2=f1.deepCpy();
5316         f2.setMesh(f1.getMesh());
5317         f2.checkCoherency();
5318         f2.changeNbOfComponents(2,5.);
5319         f2.assign(5.);
5320         f2.getArray().setInfoOnComponent(0,"bbb");
5321         f2.getArray().setInfoOnComponent(1,"ccc");
5322         f2.checkCoherency();
5323         #
5324         f3=MEDCouplingFieldDouble.MeldFields(f2,f1);
5325         f3.checkCoherency();
5326         self.assertEqual(5,f3.getNumberOfTuples());
5327         self.assertEqual(3,f3.getNumberOfComponents());
5328         self.assertTrue(f3.getArray().getInfoOnComponent(0)=="bbb");
5329         self.assertTrue(f3.getArray().getInfoOnComponent(1)=="ccc");
5330         self.assertTrue(f3.getArray().getInfoOnComponent(2)=="aaa");
5331         expected1=[5.,5.,12.,5.,5.,23.,5.,5.,34.,5.,5.,45.,5.,5.,56.]
5332         for i in xrange(15):
5333             self.assertAlmostEqual(expected1[i],f3.getIJ(0,i),12);
5334             pass
5335         time,dt,it=f3.getTime();
5336         self.assertAlmostEqual(3.4,time,14);
5337         self.assertEqual(2,dt);
5338         self.assertEqual(1,it);
5339         #
5340         f4=f2.buildNewTimeReprFromThis(NO_TIME,False);
5341         f5=f1.buildNewTimeReprFromThis(NO_TIME,False);
5342         f6=MEDCouplingFieldDouble.MeldFields(f4,f5);
5343         f6.checkCoherency();
5344         self.assertEqual(5,f6.getNumberOfTuples());
5345         self.assertEqual(3,f6.getNumberOfComponents());
5346         self.assertTrue(f6.getArray().getInfoOnComponent(0)=="bbb");
5347         self.assertTrue(f6.getArray().getInfoOnComponent(1)=="ccc");
5348         self.assertTrue(f6.getArray().getInfoOnComponent(2)=="aaa");
5349         for i in xrange(15):
5350             self.assertAlmostEqual(expected1[i],f6.getIJ(0,i),12);
5351             pass
5352         #
5353         pass
5354
5355     def testMergeNodes2(self):
5356         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5357         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
5358         vec=[0.002,0.]
5359         m2.translate(vec);
5360         #
5361         m3=MEDCouplingUMesh.MergeUMeshes([m1,m2]);
5362         da,b,newNbOfNodes=m3.mergeNodes2(0.01);
5363         self.assertEqual(9,m3.getNumberOfNodes());
5364         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]
5365         for i in xrange(18):
5366             self.assertAlmostEqual(expected1[i],m3.getCoords().getIJ(0,i),13);
5367             pass
5368         #
5369         pass
5370
5371     def testMergeField2(self):
5372         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5373         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
5374         f1.setMesh(m);
5375         arr=DataArrayDouble.New();
5376         arr.alloc(5,2);
5377         arr.fillWithValue(2.);
5378         f1.setArray(arr);
5379         f2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
5380         f2.setMesh(m);
5381         arr=DataArrayDouble.New();
5382         arr.alloc(5,2);
5383         arr.fillWithValue(5.);
5384         f2.setArray(arr);
5385         f3=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
5386         f3.setMesh(m);
5387         arr=DataArrayDouble.New();
5388         arr.alloc(5,2);
5389         arr.fillWithValue(7.);
5390         f3.setArray(arr);
5391         #
5392         f4=MEDCouplingFieldDouble.MergeFields([f1,f2,f3]);
5393         self.assertEqual(15,f4.getMesh().getNumberOfCells());
5394         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.]
5395         for i in xrange(30):
5396             self.assertAlmostEqual(expected1[i],f4.getIJ(0,i),13);
5397             pass
5398         #
5399         pass
5400
5401     def testDAIBuildComplement1(self):
5402         a=DataArrayInt.New();
5403         tab=[3,1,7,8]
5404         a.setValues(tab,4,1);
5405         b=a.buildComplement(12);
5406         self.assertEqual(8,b.getNumberOfTuples());
5407         self.assertEqual(1,b.getNumberOfComponents());
5408         expected1=[0,2,4,5,6,9,10,11]
5409         for i in xrange(8):
5410             self.assertEqual(expected1[i],b.getIJ(0,i));
5411             pass
5412         pass
5413
5414     def testDAIBuildUnion1(self):
5415         a=DataArrayInt.New();
5416         tab1=[3,1,7,8]
5417         a.setValues(tab1,4,1);
5418         c=DataArrayInt.New();
5419         tab2=[5,3,0,18,8]
5420         c.setValues(tab2,5,1);
5421         b=a.buildUnion(c);
5422         self.assertEqual(7,b.getNumberOfTuples());
5423         self.assertEqual(1,b.getNumberOfComponents());
5424         expected1=[0,1,3,5,7,8,18]
5425         for i in xrange(7):
5426             self.assertEqual(expected1[i],b.getIJ(0,i));
5427             pass
5428         b=DataArrayInt.BuildUnion([a,c]);
5429         self.assertEqual(7,b.getNumberOfTuples());
5430         self.assertEqual(1,b.getNumberOfComponents());
5431         expected1=[0,1,3,5,7,8,18]
5432         for i in xrange(7):
5433             self.assertEqual(expected1[i],b.getIJ(0,i));
5434             pass
5435         pass
5436
5437     def testDAIBuildIntersection1(self):
5438         a=DataArrayInt.New();
5439         tab1=[3,1,7,8]
5440         a.setValues(tab1,4,1);
5441         c=DataArrayInt.New();
5442         tab2=[5,3,0,18,8]
5443         c.setValues(tab2,5,1);
5444         b=a.buildIntersection(c);
5445         self.assertEqual(2,b.getNumberOfTuples());
5446         self.assertEqual(1,b.getNumberOfComponents());
5447         expected1=[3,8]
5448         for i in xrange(2):
5449             self.assertEqual(expected1[i],b.getIJ(0,i));
5450             pass
5451         b=DataArrayInt.BuildIntersection([a,c]);
5452         self.assertEqual(2,b.getNumberOfTuples());
5453         self.assertEqual(1,b.getNumberOfComponents());
5454         expected1=[3,8]
5455         for i in xrange(2):
5456             self.assertEqual(expected1[i],b.getIJ(0,i));
5457             pass
5458         pass
5459
5460     def testDAIDeltaShiftIndex1(self):
5461         a=DataArrayInt.New();
5462         tab=[1,3,6,7,7,9,15]
5463         a.setValues(tab,7,1);
5464         b=a.deltaShiftIndex();
5465         self.assertEqual(6,b.getNumberOfTuples());
5466         self.assertEqual(1,b.getNumberOfComponents());
5467         expected1=[2,3,1,0,2,6]
5468         for i in xrange(6):
5469             self.assertEqual(expected1[i],b.getIJ(0,i));
5470             pass
5471         pass
5472
5473     def testDaDoubleSelectByTupleIdSafe1(self):
5474         a=DataArrayDouble.New();
5475         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]
5476         a.setValues(arr1,7,2);
5477         a.setInfoOnComponent(0,"toto");
5478         a.setInfoOnComponent(1,"tata");
5479         #
5480         arr2=[4,2,0,6,5]
5481         b=a.selectByTupleIdSafe(arr2);
5482         self.assertEqual(5,b.getNumberOfTuples());
5483         self.assertEqual(2,b.getNumberOfComponents());
5484         self.assertTrue(b.getInfoOnComponent(0)=="toto");
5485         self.assertTrue(b.getInfoOnComponent(1)=="tata");
5486         expected1=[5.1,15.1,3.1,13.1,1.1,11.1,7.1,17.1,6.1,16.1]
5487         for i in xrange(10):
5488             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
5489             pass
5490         arr4=[4,-1,0,6,5]
5491         self.assertRaises(InterpKernelException,a.selectByTupleIdSafe,arr4);
5492         arr5=[4,2,0,6,7]
5493         self.assertRaises(InterpKernelException,a.selectByTupleIdSafe,arr5);
5494         #
5495         c=DataArrayInt.New();
5496         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
5497         c.setValues(arr3,7,2);
5498         c.setInfoOnComponent(0,"toto");
5499         c.setInfoOnComponent(1,"tata");
5500         d=c.selectByTupleIdSafe(arr2);
5501         self.assertEqual(5,d.getNumberOfTuples());
5502         self.assertEqual(2,d.getNumberOfComponents());
5503         self.assertTrue(d.getInfoOnComponent(0)=="toto");
5504         self.assertTrue(d.getInfoOnComponent(1)=="tata");
5505         expected2=[5,15,3,13,1,11,7,17,6,16]
5506         for i in xrange(10):
5507             self.assertEqual(expected2[i],d.getIJ(0,i));
5508             pass
5509         self.assertRaises(InterpKernelException,c.selectByTupleIdSafe,arr4);
5510         self.assertRaises(InterpKernelException,c.selectByTupleIdSafe,arr5);
5511         pass
5512
5513     def testAreCellsIncludedIn1(self):
5514         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5515         pt=[1,3]
5516         m2=m.buildPartOfMySelf(pt,True);
5517         ret,tmp=m.areCellsIncludedIn(m2,0)
5518         self.assertTrue(ret);
5519         self.assertEqual(2,tmp.getNumberOfTuples());
5520         self.assertEqual(1,tmp.getNumberOfComponents());
5521         self.assertEqual(pt[0],tmp.getIJ(0,0));
5522         self.assertEqual(pt[1],tmp.getIJ(0,1));
5523         ret,tmp=m2.areCellsIncludedIn(m,0)
5524         self.assertTrue(not ret);
5525         m3=MEDCouplingUMesh.MergeUMeshesOnSameCoords(m,m2)
5526         c,cI=m3.findCommonCells(2,m.getNumberOfCells())
5527         self.assertTrue(c.isEqual(DataArrayInt([1,5,3,6])))
5528         self.assertTrue(cI.isEqual(DataArrayInt([0,2,4])))
5529         pass
5530
5531     def testSwigErrorProtection1(self):
5532         m=MEDCouplingDataForTest.build3DTargetMesh_1();
5533         m.rotate([0.,0.,0.],[0.3,0.6,1.2],0.37)
5534         m.rotate([0.,0.,0.],[0.3,6,1.2],0.37)
5535         self.assertRaises(InterpKernelException,m.rotate,[0.,0.,0.],(0.3,6,"1.2"),0.37)
5536         self.assertRaises(InterpKernelException,m.rotate,[0.,"0.",0.],[0.3,0.6,1.2],0.37)
5537         self.assertRaises(InterpKernelException,m.rotate,[0.,0.,0.],[0.3,'0.6',1.2],0.37)
5538         m2=m.buildPartOfMySelf([2,5],True)
5539         m3=m.buildPartOfMySelf((2,5),True)
5540         self.assertTrue(m2.isEqual(m3,1e-12))
5541         self.assertRaises(InterpKernelException,m.buildPartOfMySelf,[2,5.],True)
5542         da1=m.getCoords().keepSelectedComponents([1])
5543         da2=m.getCoords().keepSelectedComponents((1,))
5544         self.assertTrue(da1.isEqual(da2,1e-12))
5545         self.assertRaises(InterpKernelException,m.getCoords().keepSelectedComponents,["1"])
5546         pass
5547
5548     def testDAIBuildSubstraction1(self):
5549         a=DataArrayInt.New()
5550         aa=[2,3,6,8,9]
5551         a.setValues(aa,5,1)
5552         b=DataArrayInt.New()
5553         bb=[1,3,5,9,11]
5554         b.setValues(bb,5,1)
5555         self.assertEqual([2,6,8],a.buildSubstraction(b).getValues())
5556         pass
5557
5558     def testBuildOrthogonalField2(self):
5559         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5560         d1=DataArrayInt.New();
5561         d2=DataArrayInt.New();
5562         d3=DataArrayInt.New();
5563         d4=DataArrayInt.New();
5564         m1=m.buildDescendingConnectivity(d1,d2,d3,d4);
5565         #
5566         f1=m1.buildOrthogonalField();
5567         da1=f1.getArray();
5568         self.assertEqual(2,da1.getNumberOfComponents());
5569         self.assertEqual(13,da1.getNumberOfTuples());
5570         #
5571         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.];
5572         for i in xrange(26):
5573             self.assertAlmostEqual(expected1[i],da1.getIJ(0,i),14);
5574             pass
5575         pass
5576
5577     def testSwigErrorProtection2(self):
5578         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5579         coo=m.getCoords()
5580         c=m.getNodalConnectivity()
5581         ci=m.getNodalConnectivityIndex()
5582         del m
5583         self.assertEqual(2,coo.getNumberOfComponents());
5584         self.assertEqual(6,ci.getNumberOfTuples());
5585         self.assertEqual(23,c.getNumberOfTuples());
5586         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5587         f=m.getMeasureField(True)
5588         c=f.getArray()
5589         del f
5590         self.assertEqual(1,c.getNumberOfComponents());
5591         m=MEDCouplingCMesh.New()
5592         x=DataArrayDouble.New()
5593         x.setValues([1.,2.,4.],3,1)
5594         m.setCoordsAt(0,x)
5595         del x
5596         xx=m.getCoordsAt(0)
5597         del m
5598         self.assertEqual(3,xx.getNumberOfTuples());
5599         #
5600         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5601         f=m.getMeasureField(True)
5602         m2=f.getMesh()
5603         del m
5604         del f
5605         self.assertEqual(5,m2.getNumberOfCells());
5606         pass
5607
5608     def testUMInsertNextCell1(self):
5609         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 ]
5610         targetConn=[0,3,4,1, 1,4,2, 4,5,2, 6,7,4,3, 7,8,5,4]
5611         targetMesh=MEDCouplingUMesh.New();
5612         targetMesh.allocateCells(5);
5613         self.assertRaises(InterpKernelException,targetMesh.insertNextCell,NORM_QUAD4,4,targetConn[0:4])
5614         targetMesh.setMeshDimension(2);
5615         targetMesh.insertNextCell(NORM_QUAD4,4,targetConn[0:4])
5616         self.assertRaises(InterpKernelException,targetMesh.insertNextCell,NORM_TETRA4,4,targetConn[0:4])
5617         self.assertRaises(InterpKernelException,targetMesh.insertNextCell,NORM_SEG2,2,targetConn[0:2])
5618         self.assertRaises(InterpKernelException,targetMesh.insertNextCell,NORM_POINT1,1,targetConn[0:1])
5619         targetMesh.insertNextCell(NORM_TRI3,3,targetConn[4:7])
5620         targetMesh.insertNextCell(NORM_TRI3,3,targetConn[7:10])
5621         targetMesh.insertNextCell(NORM_QUAD4,4,targetConn[10:14])
5622         targetMesh.insertNextCell(NORM_QUAD4,4,targetConn[14:18])
5623         targetMesh.finishInsertingCells();
5624         myCoords=DataArrayDouble.New();
5625         myCoords.setValues(targetCoords,9,2);
5626         targetMesh.setCoords(myCoords);
5627         targetMesh.checkCoherency();
5628         pass
5629
5630     def testFieldOperatorDivDiffComp1(self):
5631         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5632         m1,d0,d1,d2,d3=m.buildDescendingConnectivity();
5633         #
5634         f1=m1.buildOrthogonalField();
5635         arr1=[2.,3.,4.,5.,6.,7.,8.,9.,10.,11.,12.,13.,14.]
5636         arr=DataArrayDouble.New();
5637         arr.setValues(arr1,13,1);
5638         f2=MEDCouplingFieldDouble.New(ON_CELLS);
5639         f2.setArray(arr);
5640         f2.setMesh(m1);
5641         f2.checkCoherency();
5642         #
5643         f3=f1/f2;
5644         self.assertRaises(InterpKernelException,f2.__div__,f1)
5645         f3.checkCoherency();
5646         f1/=f2;
5647         #self.assertRaises(InterpKernelException,f2.__idiv__,f1) # mem leaks
5648         self.assertTrue(f1.isEqual(f3,1e-10,1e-10));
5649         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]
5650         for i in xrange(26):
5651             self.assertAlmostEqual(expected1[i],f3.getIJ(0,i),10);
5652             pass
5653         pass
5654
5655     def testDARearrange1(self):
5656         da1=DataArrayInt.New();
5657         da1.alloc(12,1);
5658         da1.iota(0);
5659         #
5660         self.assertEqual(12,da1.getNbOfElems());
5661         self.assertEqual(1,da1.getNumberOfComponents());
5662         self.assertEqual(12,da1.getNumberOfTuples());
5663         da1.rearrange(4);
5664         self.assertEqual(12,da1.getNbOfElems());
5665         self.assertEqual(4,da1.getNumberOfComponents());
5666         self.assertEqual(3,da1.getNumberOfTuples());
5667         for i in xrange(12):
5668             self.assertEqual(i,da1.getIJ(0,i));
5669         #
5670         da1.rearrange(6);
5671         self.assertEqual(12,da1.getNbOfElems());
5672         self.assertEqual(6,da1.getNumberOfComponents());
5673         self.assertEqual(2,da1.getNumberOfTuples());
5674         for i in xrange(12):
5675             self.assertEqual(i,da1.getIJ(0,i));
5676         #
5677         self.assertRaises(InterpKernelException,da1.rearrange,7);
5678         #
5679         da1.rearrange(12);
5680         self.assertEqual(12,da1.getNbOfElems());
5681         self.assertEqual(12,da1.getNumberOfComponents());
5682         self.assertEqual(1,da1.getNumberOfTuples());
5683         for i in xrange(12):
5684             self.assertEqual(i,da1.getIJ(0,i));
5685         #
5686         da1.rearrange(3);
5687         self.assertEqual(12,da1.getNbOfElems());
5688         self.assertEqual(3,da1.getNumberOfComponents());
5689         self.assertEqual(4,da1.getNumberOfTuples());
5690         for i in xrange(12):
5691             self.assertEqual(i,da1.getIJ(0,i));
5692         #double
5693         da2=da1.convertToDblArr();
5694         st=da2.getHiddenCppPointer()
5695         #
5696         self.assertEqual(12,da2.getNbOfElems());
5697         self.assertEqual(3,da2.getNumberOfComponents());
5698         self.assertEqual(4,da2.getNumberOfTuples());
5699         da2.rearrange(4);
5700         self.assertEqual(12,da2.getNbOfElems());
5701         self.assertEqual(4,da2.getNumberOfComponents());
5702         self.assertEqual(3,da2.getNumberOfTuples());
5703         for i in xrange(12):
5704             self.assertAlmostEqual(float(i),da2.getIJ(0,i),14);
5705         #
5706         da2.rearrange(6);
5707         self.assertEqual(12,da2.getNbOfElems());
5708         self.assertEqual(6,da2.getNumberOfComponents());
5709         self.assertEqual(2,da2.getNumberOfTuples());
5710         for i in xrange(12):
5711             self.assertAlmostEqual(float(i),da2.getIJ(0,i),14);
5712         #
5713         self.assertRaises(InterpKernelException,da2.rearrange,7);
5714         #
5715         da2.rearrange(1);
5716         self.assertEqual(st,da2.getHiddenCppPointer())
5717         self.assertEqual(12,da2.getNbOfElems());
5718         self.assertEqual(1,da2.getNumberOfComponents());
5719         self.assertEqual(12,da2.getNumberOfTuples());
5720         for i in xrange(12):
5721             self.assertAlmostEqual(float(i),da2.getIJ(0,i),14);
5722         #
5723         da2.rearrange(3);
5724         self.assertEqual(12,da2.getNbOfElems());
5725         self.assertEqual(3,da2.getNumberOfComponents());
5726         self.assertEqual(4,da2.getNumberOfTuples());
5727         for i in xrange(12):
5728             self.assertAlmostEqual(float(i),da2.getIJ(0,i),14);
5729         pass
5730
5731     def testDARearrange2(self):
5732         da1=DataArrayInt.New();
5733         arr=[1,2,3,2,2,3,5,1,5,5,2,2]
5734         da1.setValues(arr,4,3);
5735         s=da1.getDifferentValues();
5736         expected1=DataArrayInt([1,2,3,5])
5737         self.assertTrue(expected1.isEqual(s));
5738         pass
5739
5740     def testSwigErrorProtection3(self):
5741         da=DataArrayInt.New()
5742         da.setValues([1,2,3,4,0,0,0,0,0,0,0,0],4,3)
5743         self.assertEqual([1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0],da.getValues())
5744         self.assertEqual(3,da.getNumberOfComponents());
5745         self.assertEqual(4,da.getNumberOfTuples());
5746         da=DataArrayInt.New()
5747         da.setValues(((1,2,3),(4,4,3),(0,0,0),(0,0,0)),4,3)
5748         self.assertEqual([1, 2, 3, 4, 4, 3, 0, 0, 0, 0, 0, 0],da.getValues())
5749         self.assertEqual(3,da.getNumberOfComponents());
5750         self.assertEqual(4,da.getNumberOfTuples());
5751         da.setValues((10*[1]+290*[2])[:12],4,3)
5752         self.assertEqual(10*[1]+[2,2],da.getValues())
5753         self.assertEqual(3,da.getNumberOfComponents());
5754         self.assertEqual(4,da.getNumberOfTuples());
5755         #
5756         da=DataArrayDouble.New()
5757         da.setValues([1,2,3.,4,0,0,0,0,0,0,0,0],4,3)
5758         self.assertEqual([1., 2., 3., 4., 0., 0., 0., 0., 0., 0., 0., 0.],da.getValues())
5759         self.assertEqual(3,da.getNumberOfComponents());
5760         self.assertEqual(4,da.getNumberOfTuples());
5761         da=DataArrayDouble.New()
5762         da.setValues(((1,2,3),(4.,4,3),(0,0,0),(0,0,0)),4,3)
5763         self.assertEqual([1., 2., 3., 4., 4., 3., 0., 0., 0., 0., 0., 0.],da.getValues())
5764         self.assertEqual(3,da.getNumberOfComponents());
5765         self.assertEqual(4,da.getNumberOfTuples());
5766         da.setValues((10*[1]+290*[2])[:12],4,3)
5767         self.assertEqual(10*[1.]+[2.,2.],da.getValues())
5768         self.assertEqual(3,da.getNumberOfComponents());
5769         self.assertEqual(4,da.getNumberOfTuples());
5770         pass
5771
5772     def testDAIBuildPermutationArr1(self):
5773         a=DataArrayInt.New()
5774         a.setValues([4,5,6,7,8],5,1)
5775         b=DataArrayInt.New()
5776         b.setValues([5,4,8,6,7],5,1)
5777         c=a.buildPermutationArr(b)
5778         self.assertEqual([1,0,4,2,3],c.getValues())
5779         self.assertTrue(a.isEqualWithoutConsideringStrAndOrder(b))
5780         b.setIJ(0,0,9)
5781         self.assertTrue(not a.isEqualWithoutConsideringStrAndOrder(b))
5782         self.assertRaises(InterpKernelException,a.buildPermutationArr,b)
5783         a.setIJ(3,0,4)
5784         b.setIJ(0,0,5)
5785         b.setIJ(4,0,4)#a==[4,5,6,4,8] and b==[5,4,8,6,4]
5786         self.assertTrue(a.isEqualWithoutConsideringStrAndOrder(b))
5787         c=a.buildPermutationArr(b)
5788         self.assertEqual([1,3,4,2,3],c.getValues())
5789         d=b.convertToDblArr()
5790         expect3=[4,4,5,6,8]
5791         b.sort()
5792         self.assertEqual(expect3,b.getValues())
5793         d.sort()
5794         self.assertEqual(5,d.getNumberOfTuples());
5795         self.assertEqual(1,d.getNumberOfComponents());
5796         for i in xrange(5):
5797             self.assertAlmostEqual(float(expect3[i]),d.getIJ(i,0),14);
5798             pass
5799         pass
5800
5801     def testAreCellsIncludedIn2(self):
5802         myName="Vitoo";
5803         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5804         m2=m.buildPartOfMySelf([],True);
5805         self.assertEqual(0,m2.getNumberOfCells());
5806         self.assertEqual(3,m2.getSpaceDimension());
5807         self.assertEqual(2,m2.getMeshDimension());
5808         m2.setName(myName);
5809         test,tmp=m.areCellsIncludedIn(m2,0)
5810         self.assertTrue(test);
5811         self.assertEqual(myName,tmp.getName());
5812         self.assertEqual(0,tmp.getNumberOfTuples())
5813         self.assertEqual(1,tmp.getNumberOfComponents())
5814         pass
5815
5816     def testUMeshGetPartBarycenterAndOwner1(self):
5817         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5818         part1=[1,0,4];
5819         part=DataArrayInt.New();
5820         part.setValues(part1,3,1);
5821         b=m1.getPartBarycenterAndOwner(part);
5822         self.assertEqual(2,b.getNumberOfComponents());
5823         self.assertEqual(3,b.getNumberOfTuples());
5824         expected1=[0.36666666666666665,-0.13333333333333333,-0.05,-0.05,0.45,0.45];
5825         for i in xrange(6):
5826             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
5827             pass
5828         pass
5829
5830     def testUMeshGetPartMeasureField1(self):
5831         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5832         part1=[1,0,4];
5833         part=DataArrayInt.New();
5834         part.setValues(part1,3,1);
5835         b=m1.getPartMeasureField(True,part);
5836         self.assertEqual(1,b.getNumberOfComponents());
5837         self.assertEqual(3,b.getNumberOfTuples());
5838         expected1=[0.125,0.25,0.25];
5839         for i in xrange(3):
5840             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
5841             pass
5842         pass
5843
5844     def testUMeshBuildPartOrthogonalField1(self):
5845         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5846         m1.changeSpaceDimension(3);
5847         part1=[1,0,4];
5848         part=DataArrayInt.New();
5849         part.setValues(part1,3,1);
5850         b=m1.buildPartOrthogonalField(part);
5851         self.assertEqual(3,b.getArray().getNumberOfComponents());
5852         self.assertEqual(3,b.getArray().getNumberOfTuples());
5853         expected1=[0.,0.,-1.,0.,0.,-1.,0.,0.,-1.];
5854         for i in xrange(9):
5855             self.assertAlmostEqual(expected1[i],b.getArray().getIJ(0,i),14);
5856             pass
5857         pass
5858
5859     def testUMeshGetTypesOfPart1(self):
5860         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5861         part1=[0,3,4];
5862         p1=DataArrayInt.New()
5863         p1.setValues(part1,3,1)
5864         s=m1.getTypesOfPart(p1);
5865         self.assertEqual([NORM_QUAD4],s);
5866         part2=[2,2,2,1];
5867         p2=DataArrayInt.New()
5868         p2.setValues(part2,4,1)
5869         s=m1.getTypesOfPart(p2);
5870         self.assertEqual([NORM_TRI3],s);
5871         part3=[3,2,1];
5872         p3=DataArrayInt.New()
5873         p3.setValues(part3,3,1)
5874         s=m1.getTypesOfPart(p3);
5875         self.assertEqual(s,[NORM_TRI3,NORM_QUAD4]);
5876         pass
5877
5878     def testUMeshKeepCellIdsByType1(self):
5879         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5880         part1=[0,3,4]
5881         p1=DataArrayInt.New()
5882         p1.setValues(part1,3,1)
5883         p1.setName("p1")
5884         a=m1.keepCellIdsByType(NORM_TRI3,p1);
5885         self.assertEqual("p1",a.getName())
5886         self.assertEqual(1,a.getNumberOfComponents());
5887         self.assertEqual(0,a.getNumberOfTuples());
5888         #
5889         part2=[3,2,0,2,4]
5890         p2=DataArrayInt.New()
5891         p2.setValues(part2,5,1)
5892         p2.setName("p2")
5893         a=m1.keepCellIdsByType(NORM_TRI3,p2);
5894         self.assertEqual("p2",a.getName())
5895         self.assertEqual(1,a.getNumberOfComponents());
5896         self.assertEqual(2,a.getNumberOfTuples());
5897         self.assertEqual(2,a.getIJ(0,0));
5898         self.assertEqual(2,a.getIJ(1,0));
5899         #
5900         a=m1.keepCellIdsByType(NORM_QUAD4,p2);
5901         self.assertEqual("p2",a.getName())
5902         self.assertEqual(1,a.getNumberOfComponents());
5903         self.assertEqual(3,a.getNumberOfTuples());
5904         self.assertEqual(3,a.getIJ(0,0));
5905         self.assertEqual(0,a.getIJ(1,0));
5906         self.assertEqual(4,a.getIJ(2,0));
5907         pass
5908
5909     def testSwigErrorDaIntSelectByTupleId1(self):
5910         a=DataArrayInt.New();
5911         arr1=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
5912         a.setValues(arr1,7,2);
5913         a.setInfoOnComponent(0,"toto");
5914         a.setInfoOnComponent(1,"tata");
5915         #
5916         arr2=[4,2,0,6,5]
5917         b=a.selectByTupleId(arr2);
5918         self.assertEqual(5,b.getNumberOfTuples());
5919         self.assertEqual(2,b.getNumberOfComponents());
5920         self.assertTrue(b.getInfoOnComponent(0)=="toto");
5921         self.assertTrue(b.getInfoOnComponent(1)=="tata");
5922         expected1=[5,15,3,13,1,11,7,17,6,16]
5923         self.assertEqual(expected1,b.getValues())
5924         #
5925         a2=DataArrayInt.New()
5926         a2.setValues(arr2,5,1)
5927         b=a.selectByTupleId(a2);
5928         self.assertEqual(5,b.getNumberOfTuples());
5929         self.assertEqual(2,b.getNumberOfComponents());
5930         self.assertTrue(b.getInfoOnComponent(0)=="toto");
5931         self.assertTrue(b.getInfoOnComponent(1)=="tata");
5932         expected1=[5,15,3,13,1,11,7,17,6,16]
5933         self.assertEqual(expected1,b.getValues())
5934         pass
5935
5936     def testSwigErrorRenum(self):
5937         da=DataArrayDouble.New()
5938         da.setValues([7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.],10,2)
5939         d=DataArrayInt.New()
5940         d.setValues([0,2,3,1,4,5,6,8,7,9],10,1)
5941         da.renumberInPlace(d)
5942         da.renumber(d)
5943         pass
5944
5945     def testSwigGetItem1(self):
5946         da=DataArrayInt.New()
5947         da.alloc(16,3)
5948         da.rearrange(1)
5949         da.iota(7)
5950         da.rearrange(3)
5951         da.setInfoOnComponent(0,"X [m]")
5952         da.setInfoOnComponent(1,"Y [m]")
5953         da.setInfoOnComponent(2,"Z [km]")
5954         da2=da[5:-1]
5955         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())
5956         da2=da[4]
5957         self.assertEqual([19, 20, 21],da2.getValues())
5958         try:
5959             da2=da[4:17]
5960         except InterpKernelException as e:
5961             self.assertTrue(True)
5962         else:
5963             self.assertTrue(False)
5964             pass
5965         da2=da[5:-2,2]
5966         self.assertEqual([24, 27, 30, 33, 36, 39, 42, 45, 48],da2.getValues())
5967         da2=da[5:8,:]
5968         self.assertEqual([22, 23, 24, 25, 26, 27, 28, 29, 30],da2.getValues())
5969         da2=da[:]
5970         self.assertTrue(da2.isEqual(da))
5971         da2=da[:,:]
5972         self.assertTrue(da2.isEqual(da))
5973         try:
5974             da2=da[:,:,:]
5975         except InterpKernelException as e:
5976             self.assertTrue(True)
5977         else:
5978             self.assertTrue(False)
5979             pass
5980         try:
5981             da2=da[5:8,-2]
5982         except InterpKernelException as e:
5983             self.assertTrue(True)
5984         else:
5985             self.assertTrue(False)
5986             pass
5987         da2=da[5:8,:-2]
5988         self.assertEqual([22, 25, 28],da2.getValues())
5989         try:
5990             da2=da[5:-18,2]
5991         except InterpKernelException as e:
5992             self.assertTrue(True)
5993         else:
5994             self.assertTrue(False)
5995             pass
5996         da2=da[5:5,2]
5997         self.assertEqual([],da2.getValues())
5998         pass
5999
6000     def testSwigGetItem2(self):
6001         da=DataArrayDouble.New()
6002         da.alloc(16,3)
6003         da.rearrange(1)
6004         da.iota(7)
6005         da.rearrange(3)
6006         da.setInfoOnComponent(0,"X [m]")
6007         da.setInfoOnComponent(1,"Y [m]")
6008         da.setInfoOnComponent(2,"Z [km]")
6009         da2=da[5:-1]
6010         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())
6011         da2=da[4]
6012         self.assertEqual([19., 20., 21],da2.getValues())
6013         try:
6014             da2=da[4:17]
6015         except InterpKernelException as e:
6016             self.assertTrue(True)
6017         else:
6018             self.assertTrue(False)
6019             pass
6020         da2=da[5:-2,2]
6021         self.assertEqual([24., 27., 30., 33., 36., 39., 42., 45., 48.],da2.getValues())
6022         da2=da[5:8,:]
6023         self.assertEqual([22., 23., 24., 25., 26., 27., 28., 29., 30.],da2.getValues())
6024         da2=da[:]
6025         self.assertTrue(da2.isEqual(da,1e-12))
6026         da2=da[:,:]
6027         self.assertTrue(da2.isEqual(da,1e-12))
6028         try:
6029             da2=da[:,:,:]
6030         except InterpKernelException as e:
6031             self.assertTrue(True)
6032         else:
6033             self.assertTrue(False)
6034             pass
6035         try:
6036             da2=da[5:8,-2]
6037         except InterpKernelException as e:
6038             self.assertTrue(True)
6039         else:
6040             self.assertTrue(False)
6041             pass
6042         da2=da[5:8,:-2]
6043         self.assertEqual([22., 25., 28.],da2.getValues())
6044         try:
6045             da2=da[5:-18,2]
6046         except InterpKernelException as e:
6047             self.assertTrue(True)
6048         else:
6049             self.assertTrue(False)
6050             pass
6051         da2=da[5:5,2]
6052         self.assertEqual([],da2.getValues())
6053         pass
6054
6055     def testSwigSetItem1(self):
6056         da=DataArrayInt.New()
6057         da.alloc(20,1)
6058         da.iota(7)
6059         da.rearrange(5)
6060         da.setInfoOnComponent(0,"X [m]") ; da.setInfoOnComponent(1,"Y [km]") ; da.setInfoOnComponent(2,"Y [m]")
6061         da.setInfoOnComponent(3,"Z [W]") ; da.setInfoOnComponent(4,"ZZ [km]") ;
6062         da[:,2]=3
6063         self.assertEqual([7, 8, 3, 10, 11, 12, 13, 3, 15, 16, 17, 18, 3, 20, 21, 22, 23, 3, 25, 26],da.getValues())
6064         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6065         da[2]=3
6066         self.assertEqual([7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 3, 3, 3, 3, 3, 22, 23, 24, 25, 26],da.getValues())
6067         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6068         da[[0,3]]=-1
6069         self.assertEqual([-1, -1, -1, -1, -1, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, -1, -1, -1, -1, -1],da.getValues())
6070         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6071         da[:,[1,3,4]]=-3
6072         self.assertEqual([7, -3, 9, -3, -3, 12, -3, 14, -3, -3, 17, -3, 19, -3, -3, 22, -3, 24, -3, -3],da.getValues())
6073         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6074         da2=DataArrayInt.New() ; da2.setValues([0,2,3],3,1)
6075         da[da2]=-7
6076         self.assertEqual([-7, -7, -7, -7, -7, 12, 13, 14, 15, 16, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7],da.getValues())
6077         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6078         da[da2,-2:]=-7
6079         self.assertEqual([7, 8, 9, -7, -7, 12, 13, 14, 15, 16, 17, 18, 19, -7, -7, 22, 23, 24, -7, -7],da.getValues())
6080         # Let's test with DAI right hand side
6081         da1=DataArrayInt.New()
6082         da1.setValues([25,26,27,125,126,127],2,3)
6083         #
6084         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6085         da[-2:,1:4]=da1
6086         self.assertEqual([7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 25, 26, 27, 21, 22, 125, 126, 127, 26],da.getValues())
6087         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6088         da[1:,3]=[225,226,227]
6089         self.assertEqual([7, 8, 9, 10, 11, 12, 13, 14, 225, 16, 17, 18, 19, 226, 21, 22, 23, 24, 227, 26],da.getValues())
6090         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6091         da[1,2:]=[225,226,227]
6092         self.assertEqual([7, 8, 9, 10, 11, 12, 13, 225, 226, 227, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26],da.getValues())
6093         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6094         da[da2,-2:]=[88,99,1010,1111,1212,1313]
6095         self.assertEqual([7, 8, 9, 88, 99, 12, 13, 14, 15, 16, 17, 18, 19, 1010, 1111, 22, 23, 24, 1212, 1313],da.getValues())
6096         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6097         da3=DataArrayInt.New(); da3.setValues([88,99,1010,1111,1212,1313],3,2)
6098         da[da2,-2:]=da3
6099         self.assertEqual([7, 8, 9, 88, 99, 12, 13, 14, 15, 16, 17, 18, 19, 1010, 1111, 22, 23, 24, 1212, 1313],da.getValues())
6100         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6101         da[da2,[0,2]]=da3
6102         self.assertEqual([88, 8, 99, 10, 11, 12, 13, 14, 15, 16, 1010, 18, 1111, 20, 21, 1212, 23, 1313, 25, 26],da.getValues())
6103         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6104         da[da2,0:3:2]=da3
6105         self.assertEqual([88, 8, 99, 10, 11, 12, 13, 14, 15, 16, 1010, 18, 1111, 20, 21, 1212, 23, 1313, 25, 26],da.getValues())
6106         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6107         da[da2,0:3:2]=-8
6108         self.assertEqual([-8, 8, -8, 10, 11, 12, 13, 14, 15, 16, -8, 18, -8, 20, 21, -8, 23, -8, 25, 26],da.getValues())
6109         pass
6110
6111     def testSwigSetItem2(self):
6112         da=DataArrayDouble.New()
6113         da.alloc(20,1)
6114         da.iota(7)
6115         da.rearrange(5)
6116         da.setInfoOnComponent(0,"X [m]") ; da.setInfoOnComponent(1,"Y [km]") ; da.setInfoOnComponent(2,"Y [m]")
6117         da.setInfoOnComponent(3,"Z [W]") ; da.setInfoOnComponent(4,"ZZ [km]") ;
6118         da[:,2]=3.
6119         self.assertEqual([7., 8., 3., 10., 11., 12., 13., 3., 15., 16., 17., 18., 3., 20., 21., 22., 23., 3., 25., 26.],da.getValues())
6120         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6121         da[2]=3.
6122         self.assertEqual([7., 8., 9., 10., 11., 12., 13., 14., 15., 16., 3., 3., 3., 3., 3., 22., 23., 24., 25., 26.],da.getValues())
6123         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6124         da[[0,3]]=-1.
6125         self.assertEqual([-1., -1., -1., -1., -1., 12., 13., 14., 15., 16., 17., 18., 19., 20., 21., -1., -1., -1., -1., -1.],da.getValues())
6126         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6127         da[:,[1,3,4]]=-3.
6128         self.assertEqual([7., -3., 9., -3., -3., 12., -3., 14., -3., -3., 17., -3., 19., -3., -3., 22., -3., 24., -3., -3.],da.getValues())
6129         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6130         da2=DataArrayInt.New() ; da2.setValues([0,2,3],3,1)
6131         da[da2]=-7.
6132         self.assertEqual([-7., -7., -7., -7., -7., 12., 13., 14., 15., 16., -7., -7., -7., -7., -7., -7., -7., -7., -7., -7.],da.getValues())
6133         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6134         da[da2,-2:]=-7
6135         self.assertEqual([7., 8., 9., -7., -7., 12., 13., 14., 15., 16., 17., 18., 19., -7., -7., 22., 23., 24., -7., -7.],da.getValues())
6136         # Let's test with DAI right hand side
6137         da1=DataArrayDouble.New()
6138         da1.setValues([25,26,27,125,126,127],2,3)
6139         #
6140         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6141         da[-2:,1:4]=da1
6142         self.assertEqual([7., 8., 9., 10., 11., 12., 13., 14., 15., 16., 17., 25., 26., 27., 21., 22., 125., 126., 127., 26.],da.getValues())
6143         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6144         da[1:,3]=[225.,226.,227.]
6145         self.assertEqual([7., 8., 9., 10., 11., 12., 13., 14., 225., 16., 17., 18., 19., 226., 21., 22., 23., 24., 227., 26.],da.getValues())
6146         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6147         da[1,2:]=[225,226,227]
6148         self.assertEqual([7., 8., 9., 10., 11., 12., 13., 225., 226., 227., 17., 18., 19., 20., 21., 22., 23., 24., 25., 26.],da.getValues())
6149         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6150         da[da2,-2:]=[88,99,1010,1111,1212,1313]
6151         self.assertEqual([7., 8., 9., 88., 99., 12., 13., 14., 15., 16., 17., 18., 19., 1010., 1111., 22., 23., 24., 1212., 1313.],da.getValues())
6152         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6153         da3=DataArrayDouble.New(); da3.setValues([88,99,1010,1111,1212,1313],3,2)
6154         da[da2,-2:]=da3
6155         self.assertEqual([7., 8., 9., 88., 99., 12., 13., 14., 15., 16., 17., 18., 19., 1010., 1111., 22., 23., 24., 1212., 1313.],da.getValues())
6156         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6157         da[da2,[0,2]]=da3
6158         self.assertEqual([88., 8., 99., 10., 11., 12., 13., 14., 15., 16., 1010., 18., 1111., 20., 21., 1212., 23., 1313., 25., 26.],da.getValues())
6159         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6160         da[da2,0:3:2]=da3
6161         self.assertEqual([88., 8., 99., 10., 11., 12., 13., 14., 15., 16., 1010., 18., 1111., 20., 21., 1212., 23., 1313., 25., 26.],da.getValues())
6162         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6163         da[da2,0:3:2]=-8.
6164         self.assertEqual([-8., 8., -8., 10., 11., 12., 13., 14., 15., 16., -8., 18., -8., 20., 21., -8., 23., -8., 25., 26.],da.getValues())
6165         pass
6166
6167     def testSwigDADOp(self):
6168         da=DataArrayDouble.New()
6169         da.alloc(12,1)
6170         da.iota(7.)
6171         da1=DataArrayDouble.New()
6172         da1.alloc(12,1)
6173         da1.iota(8.)
6174         da2=da+da1
6175         self.assertEqual([15., 17., 19., 21., 23., 25., 27., 29., 31., 33., 35., 37.],da2.getValues())
6176         da2=da+3
6177         da3=3+da
6178         self.assertTrue(da2.isEqual(da3,1e-12))
6179         da2=da-1.
6180         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())
6181         da2=1-da
6182         self.assertEqual([-6.0, -7.0, -8.0, -9.0, -10.0, -11.0, -12.0, -13.0, -14.0, -15.0, -16.0, -17.0],da2.getValues())
6183         da2=da*3
6184         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())
6185         da2=3.*da
6186         self.assertEqual([21.0, 24.0, 27.0, 30.0, 33.0, 36.0, 39.0, 42.0, 45.0, 48.0, 51.0, 54.0],da2.getValues())
6187         da2=da*da1
6188         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())
6189         da2=da/4.
6190         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())
6191         da3=4./da
6192         da4=da3*da2
6193         self.assertTrue(da4.isUniform(1.,1e-12))
6194         st1=da.getHiddenCppPointer()
6195         da+=1
6196         st2=da.getHiddenCppPointer()
6197         self.assertEqual(st1,st2)
6198         self.assertTrue(da.isEqual(da1,1e-12))
6199         da-=8
6200         st2=da.getHiddenCppPointer()
6201         self.assertEqual(st1,st2)
6202         self.assertEqual(range(12),da.getValues())
6203         da+=da1
6204         st2=da.getHiddenCppPointer()
6205         self.assertEqual(st1,st2)
6206         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())
6207         da*=0.5
6208         st2=da.getHiddenCppPointer()
6209         self.assertEqual(st1,st2)
6210         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())
6211         da*=da1
6212         st2=da.getHiddenCppPointer()
6213         self.assertEqual(st1,st2)
6214         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())
6215         da/=da1
6216         self.assertEqual(st1,st2)
6217         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())
6218         da/=2
6219         st2=da.getHiddenCppPointer()
6220         self.assertEqual(st1,st2)
6221         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())
6222         da.rearrange(3)
6223         da5=DataArrayDouble.New()
6224         da5.setValues([5.,4.,3.,2.],4,1)
6225         da*=da5 # it works with unmathing number of compo
6226         st2=da.getHiddenCppPointer()
6227         self.assertEqual(st1,st2)
6228         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())
6229         #
6230         da.alloc(30,1)
6231         da.iota(7.)
6232         da.rearrange(3)
6233         ids=DataArrayInt.New()
6234         ids.setValues([3,4,7],3,1)
6235         da[ids,:]=[5.,8.,9.]
6236         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())
6237         #
6238         da.rearrange(1) ; da.iota(7) ; da.rearrange(3)
6239         da[ids,[1,2]]=[5,8]
6240         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())
6241         pass
6242
6243     def testSwigDAIOp(self):
6244         da=DataArrayInt.New()
6245         da.alloc(12,1)
6246         da.iota(7)
6247         da1=DataArrayInt.New()
6248         da1.alloc(12,1)
6249         da1.iota(8)
6250         da2=da+da1
6251         self.assertEqual([15,17,19,21,23,25,27,29,31,33,35,37],da2.getValues())
6252         da2=da+3
6253         da3=3+da
6254         self.assertTrue(da2.isEqual(da3))
6255         da2=da-1
6256         self.assertEqual([6,7,8,9,10,11,12,13,14,15,16,17],da2.getValues())
6257         da2=1-da
6258         self.assertEqual([-6,-7,-8,-9,-10,-11,-12,-13,-14,-15,-16,-17],da2.getValues())
6259         da2=da*3
6260         self.assertEqual([21,24,27,30,33,36,39,42,45,48,51,54.0],da2.getValues())
6261         da2=3*da
6262         self.assertEqual([21,24,27,30,33,36,39,42,45,48,51,54.0],da2.getValues())
6263         da2=da*da1
6264         self.assertEqual([56,72,90,110,132,156,182,210,240,272,306,342.0],da2.getValues())
6265         da2=da/4
6266         self.assertEqual([1,2,2,2,2,3,3,3,3,4,4,4],da2.getValues())
6267         da3=4/da
6268         da4=da3*da2
6269         self.assertTrue(da4.isUniform(0))
6270         st1=da.getHiddenCppPointer()
6271         da+=1
6272         st2=da.getHiddenCppPointer()
6273         self.assertEqual(st1,st2)
6274         self.assertTrue(da.isEqual(da1))
6275         da-=8
6276         st2=da.getHiddenCppPointer()
6277         self.assertEqual(st1,st2)
6278         self.assertEqual(range(12),da.getValues())
6279         da+=da1
6280         st2=da.getHiddenCppPointer()
6281         self.assertEqual(st1,st2)
6282         self.assertEqual([8,10,12,14,16,18,20,22,24,26,28,30],da.getValues())
6283         da/=2
6284         st2=da.getHiddenCppPointer()
6285         self.assertEqual(st1,st2)
6286         self.assertEqual([4,5,6,7,8,9,10,11,12,13,14,15],da.getValues())
6287         da*=da1
6288         st2=da.getHiddenCppPointer()
6289         self.assertEqual(st1,st2)
6290         self.assertEqual([32,45,60,77,96,117,140,165,192,221,252,285],da.getValues())
6291         da/=da1
6292         self.assertEqual(st1,st2)
6293         self.assertEqual([4,5,6,7,8,9,10,11,12,13,14,15],da.getValues())
6294         da/=2
6295         st2=da.getHiddenCppPointer()
6296         self.assertEqual(st1,st2)
6297         self.assertEqual([2,2, 3,3, 4,4, 5,5, 6,6, 7,7],da.getValues())
6298         da.rearrange(3)
6299         da5=DataArrayInt.New()
6300         da5.setValues([5,4,3,2],4,1)
6301         da*=da5 # it works with unmathing number of compo
6302         st2=da.getHiddenCppPointer()
6303         self.assertEqual(st1,st2)
6304         self.assertEqual([10,10, 15,12,16,16,15,15, 18,12,14,14],da.getValues())
6305         da%=6
6306         st2=da.getHiddenCppPointer()
6307         self.assertEqual(st1,st2)
6308         self.assertEqual([4,4,3,0,4,4,3,3,0,0,2,2],da.getValues())
6309         #
6310         da.alloc(30,1)
6311         da.iota(7)
6312         da.rearrange(3)
6313         ids=DataArrayInt.New()
6314         ids.setValues([3,4,7],3,1)
6315         da[ids,:]=[5,8,9]
6316         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())
6317         #
6318         da.rearrange(1) ; da.iota(7) ; da.rearrange(3)
6319         da[ids,[1,2]]=[5,8]
6320         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())
6321         pass
6322
6323     def testSwigDAIOp2(self):
6324         da=DataArrayInt.New()
6325         st=da.getHiddenCppPointer()
6326         da.alloc(10,3)
6327         da.rearrange(1)
6328         da.iota(0)
6329         da.rearrange(3)
6330         da[:,1]+=4
6331         da[-2:,2]+=10
6332         da[-2:,2]+=10
6333         da[:,2]+=da[:,0]
6334         da[da[0],:]=7
6335         self.assertEqual(st,da.getHiddenCppPointer())
6336         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])
6337         pass
6338
6339     def testSwigDAIOp3(self):
6340         da=DataArrayInt.New()
6341         self.assertRaises(InterpKernelException,da.__len__)
6342         self.assertRaises(InterpKernelException,da.__int__)
6343         for elt in da:
6344             self.assertTrue(False)
6345             pass
6346         da.alloc(12,3)
6347         da.rearrange(1) ; da.fillWithZero()
6348         l1=list(da)
6349         self.assertEqual(36,len(da));
6350         da.rearrange(3)
6351         tmp=da[0]
6352         self.assertRaises(InterpKernelException,tmp.__int__)
6353         self.assertEqual(12,len(da));
6354         l=list(da)
6355         for elt in enumerate(l):
6356             elt[1][2]=elt[0]
6357             pass
6358         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]
6359         self.assertEqual(ref,da.getValues());
6360         da.rearrange(1)
6361         l=[int(elt) for elt in l1]
6362         self.assertEqual(ref,da.getValues());
6363         self.assertEqual(11,int(da[-1:]))
6364         pass
6365
6366     def testSwigDADOp3(self):
6367         da=DataArrayDouble.New()
6368         self.assertRaises(InterpKernelException,da.__len__)
6369         self.assertRaises(InterpKernelException,da.__float__)
6370         for elt in da:
6371             self.assertTrue(False)
6372             pass
6373         da.alloc(12,3)
6374         da.rearrange(1) ; da.fillWithZero()
6375         l1=list(da)
6376         self.assertEqual(36,len(da));
6377         da.rearrange(3)
6378         tmp=da[0]
6379         self.assertRaises(InterpKernelException,tmp.__float__)
6380         self.assertEqual(12,len(da));
6381         l=list(da)
6382         for elt in enumerate(l):
6383             elt[1][2]=elt[0]
6384             pass
6385         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.]
6386         self.assertEqual(ref,da.getValues());
6387         da.rearrange(1)
6388         l=[float(elt) for elt in l1]
6389         self.assertEqual(ref,da.getValues());
6390         self.assertEqual(11.,float(da[-1:]))
6391         pass
6392
6393     def testSwigDataArrayIntIterator1(self):
6394         da=DataArrayInt.New()
6395         da.alloc(12,1)
6396         da.iota(2)
6397         da.rearrange(3)
6398         # __getitem__ testing
6399         li=[]
6400         for it in da:
6401             li+=it[1:]
6402             pass
6403         self.assertEqual([3, 4, 6, 7, 9, 10, 12, 13],li)
6404         li=[]
6405         for it in da:
6406             li+=[it[-1]]
6407             pass
6408         self.assertEqual([4, 7, 10, 13],li)
6409         li=[]
6410         for it in da:
6411             li+=it[[2,1,0]]
6412             pass
6413         self.assertEqual([4, 3, 2, 7, 6, 5, 10, 9, 8, 13, 12, 11],li)
6414         # __setitem__ testing
6415         da3=da.deepCpy()
6416         da2=DataArrayInt.New()
6417         da2.alloc(12,1)
6418         da2.iota(2002)
6419         da2.rearrange(3)
6420         it2=da2.__iter__()
6421         i=0
6422         for it in da:
6423             pt=it2.next()
6424             it[:]=pt
6425             pass
6426         self.assertTrue(da.isEqual(da2))
6427         da=da3
6428         da3=da.deepCpy()
6429         #
6430         for it in da:
6431             it[:]=5
6432             pass
6433         da.rearrange(1)
6434         self.assertTrue(da.isUniform(5))
6435         da=da3
6436         da3=da.deepCpy()
6437         #
6438         for it in da:
6439             it[:]=[8,9,12]
6440             pass
6441         self.assertEqual([8, 9, 12, 8, 9, 12, 8, 9, 12, 8, 9, 12],da.getValues())
6442         da=da3
6443         da3=da.deepCpy()
6444         #
6445         for it in da:
6446             it[2]=[7]
6447             pass
6448         self.assertEqual([2, 3, 7, 5, 6, 7, 8, 9, 7, 11, 12, 7],da.getValues())
6449         pass
6450
6451     def testSwigDataArrayDoubleIterator1(self):
6452         da=DataArrayDouble.New()
6453         da.alloc(12,1)
6454         da.iota(2)
6455         da.rearrange(3)
6456         # __getitem__ testing
6457         li=[]
6458         for it in da:
6459             li+=it[1:]
6460             pass
6461         self.assertEqual([3, 4, 6, 7, 9, 10, 12, 13],li)
6462         li=[]
6463         for it in da:
6464             li+=[it[-1]]
6465             pass
6466         self.assertEqual([4, 7, 10, 13],li)
6467         li=[]
6468         for it in da:
6469             li+=it[[2,1,0]]
6470             pass
6471         self.assertEqual([4, 3, 2, 7, 6, 5, 10, 9, 8, 13, 12, 11],li)
6472         # __setitem__ testing
6473         da3=da.deepCpy()
6474         da2=DataArrayDouble.New()
6475         da2.alloc(12,1)
6476         da2.iota(2002)
6477         da2.rearrange(3)
6478         it2=da2.__iter__()
6479         i=0
6480         for it in da:
6481             pt=it2.next()
6482             it[:]=pt
6483             pass
6484         self.assertTrue(da.isEqual(da2,1e-12))
6485         da=da3
6486         da3=da.deepCpy()
6487         #
6488         for it in da:
6489             it[:]=5
6490             pass
6491         da.rearrange(1)
6492         self.assertTrue(da.isUniform(5,1e-12))
6493         da=da3
6494         da3=da.deepCpy()
6495         #
6496         for it in da:
6497             it[:]=[8,9,12]
6498             pass
6499         self.assertEqual([8, 9, 12, 8, 9, 12, 8, 9, 12, 8, 9, 12],da.getValues())
6500         da=da3
6501         da3=da.deepCpy()
6502         #
6503         for it in da:
6504             it[2]=[7]
6505             pass
6506         self.assertEqual([2, 3, 7, 5, 6, 7, 8, 9, 7, 11, 12, 7],da.getValues())
6507         pass
6508
6509     def testSwigUMeshIterator1(self):
6510         m=MEDCouplingDataForTest.build2DTargetMesh_1()
6511         li1=[]
6512         li2=[]
6513         for cell in m:
6514             li1+=cell.getAllConn()[1:]
6515             li2+=[cell.getType()]
6516             pass
6517         self.assertEqual(li1,[0, 3, 4, 1, 1, 4, 2, 4, 5, 2, 6, 7, 4, 3, 7, 8, 5, 4])
6518         self.assertEqual(li2,[4, 3, 3, 4, 4])
6519         pass
6520
6521     def testSwigUMeshIterator2(self):
6522         m=MEDCouplingDataForTest.build2DTargetMesh_1()
6523         self.assertRaises(InterpKernelException,m.cellsByType);
6524         m.rearrange2ConsecutiveCellTypes()
6525         li1=[]
6526         li2=[]
6527         li3=[]
6528         for cellsByType in m.cellsByType():
6529             li1.append(cellsByType.getType())
6530             li2.append(cellsByType.getNumberOfElems())
6531             temp=[]
6532             for cell in cellsByType:
6533                 t=[None,None]
6534                 t[0]=cell.getType()
6535                 t[1]=cell.getAllConn()[1:]
6536                 temp.append(t)
6537                 pass
6538             li3.append(temp)
6539             pass
6540         self.assertEqual(li1,[4, 3])
6541         self.assertEqual(li2,[3, 2])
6542         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)]]])
6543         pass
6544
6545     def testDAIAggregateMulti1(self):
6546         a=DataArrayInt.New()
6547         a.setValues(range(4),2,2)
6548         a.setName("aa")
6549         b=DataArrayInt.New()
6550         b.setValues(range(6),3,2)
6551         c=DataArrayInt.Aggregate([a,b])
6552         self.assertEqual(range(4)+range(6),c.getValues())
6553         self.assertEqual("aa",c.getName())
6554         self.assertEqual(5,c.getNumberOfTuples())
6555         self.assertEqual(2,c.getNumberOfComponents())
6556         pass
6557
6558     def testMergeUMeshes2(self):
6559         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6560         m2=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6561         m3=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6562         #
6563         vec1=[0,2,3]
6564         m2_2=m2.buildPartOfMySelf(vec1,False);
6565         vec2=[1,1]
6566         m3_2=m3.buildPartOfMySelf(vec2,False);
6567         #
6568         ms=[m1,m2_2,m3_2];
6569         #
6570         self.assertRaises(InterpKernelException,MEDCouplingUMesh.MergeUMeshes,ms+[None]);
6571         self.assertRaises(InterpKernelException,MEDCouplingUMesh.MergeUMeshes,ms+[3.4])
6572         m4=MEDCouplingUMesh.MergeUMeshes(ms);
6573         m4.checkCoherency();
6574         self.assertEqual(10,m4.getNumberOfCells());
6575         self.assertEqual(20,m4.getNumberOfNodes());
6576         self.assertEqual(45,m4.getMeshLength());
6577         m4bis=MEDCouplingMesh.MergeMeshes(ms);
6578         self.assertTrue(m4.isEqual(m4bis,1e-12))
6579         del m4bis
6580         #
6581         vec3=[0,1,2,3,4]
6582         m4_1=m4.buildPartOfMySelf(vec3,False);
6583         m4_1.setName(m1.getName());
6584         self.assertTrue(m4_1.isEqual(m1,1e-12));
6585         #
6586         vec4=[5,6,7]
6587         m4_2=m4.buildPartOfMySelf(vec4,False);
6588         cellCor,nodeCor=m4_2.checkGeoEquivalWith(m2_2,10,1e-12);
6589         #
6590         vec5=[8,9]
6591         m4_3=m4.buildPartOfMySelf(vec5,False);
6592         self.assertEqual(2,m4_3.getNumberOfCells());
6593         self.assertEqual(3,m4_3.getNumberOfNodes());
6594         m3_2.zipCoords();
6595         m4_3.setName(m3_2.getName());
6596         self.assertTrue(m4_3.isEqual(m3_2,1e-12));
6597         #
6598         pass
6599
6600     def testBuild0DMeshFromCoords1(self):
6601         sourceCoords=[-0.3,-0.3,0., 0.7,-0.3,0., -0.3,0.7,0., 0.7,0.7,0.]
6602         coo=DataArrayDouble.New();
6603         coo.setValues(sourceCoords,4,3);
6604         coo.setName("My0D");
6605         m=MEDCouplingUMesh.Build0DMeshFromCoords(coo);
6606         m.checkCoherency();
6607         self.assertEqual(4,m.getNumberOfNodes());
6608         self.assertEqual(4,m.getNumberOfCells());
6609         self.assertEqual(3,m.getSpaceDimension());
6610         self.assertEqual(0,m.getMeshDimension());
6611         types1=m.getAllTypes();
6612         self.assertEqual([NORM_POINT1],types1);
6613         for i in xrange(4):
6614             conn=m.getNodeIdsOfCell(i);
6615             self.assertEqual([i],conn);
6616             self.assertTrue(NORM_POINT1==m.getTypeOfCell(i));
6617             pass
6618         self.assertEqual(m.getName(),"My0D");
6619         pass
6620
6621     def testDescriptionInMeshTimeUnit1(self):
6622         text1="totoTTEDD";
6623         m=MEDCouplingDataForTest.build2DTargetMesh_1();
6624         m.setDescription(text1);
6625         self.assertEqual(m.getDescription(),text1);
6626         m2=m.deepCpy();
6627         self.assertTrue(m.isEqual(m2,1e-12));
6628         self.assertEqual(m2.getDescription(),text1);
6629         m2.setDescription("ggg");
6630         self.assertTrue(not m.isEqual(m2,1e-12));
6631         #
6632         f=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
6633         f.setTimeUnit(text1);
6634         self.assertEqual(f.getTimeUnit(),text1);
6635         f2=f.deepCpy();
6636         self.assertEqual(f2.getTimeUnit(),text1);
6637         #
6638         pass
6639
6640     def testMultiFields1(self):
6641         mfs=MEDCouplingDataForTest.buildMultiFields_1();
6642         ms=mfs.getMeshes();
6643         dms,refs=mfs.getDifferentMeshes()
6644         das=mfs.getArrays();
6645         das2,refs2=mfs.getDifferentArrays()
6646         self.assertEqual(5,len(mfs.getFields()))
6647         self.assertEqual(1,len(mfs.getFields()[0].getArrays()));
6648         self.assertEqual(2,len(mfs.getFields()[1].getArrays()));
6649         self.assertEqual(1,len(mfs.getFields()[2].getArrays()));
6650         self.assertEqual(1,len(mfs.getFields()[3].getArrays()));
6651         self.assertEqual(1,len(mfs.getFields()[4].getArrays()));
6652         self.assertEqual(5,len(ms));
6653         self.assertEqual(2,len(dms));
6654         self.assertEqual(6,len(das));
6655         self.assertEqual(5,len(das2));
6656         mfs2=mfs.deepCpy();
6657         self.assertTrue(mfs.isEqual(mfs2,1e-12,1e-12))
6658         pass
6659
6660     def testFieldOverTime1(self):
6661         fs=MEDCouplingDataForTest.buildMultiFields_2();
6662         self.assertRaises(InterpKernelException,MEDCouplingFieldOverTime.New,fs);
6663         f4bis=fs[4].buildNewTimeReprFromThis(ONE_TIME,False);
6664         fs[4]=f4bis;
6665         self.assertRaises(InterpKernelException,MEDCouplingFieldOverTime.New,fs);
6666         f4bis.setTime(2.7,20,21);
6667         fot=MEDCouplingFieldOverTime.New(fs);
6668         dt=fot.getDefinitionTimeZone();
6669         hs=dt.getHotSpotsTime();
6670         self.assertEqual(6,len(hs));
6671         expected1=[0.2,0.7,1.2,1.35,1.7,2.7]
6672         for i in xrange(6):
6673             self.assertAlmostEqual(expected1[i],hs[i],12);
6674             pass
6675         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(0.2);
6676         self.assertEqual(0,meshId);
6677         self.assertEqual(0,arrId);
6678         self.assertEqual(0,arrIdInField);
6679         self.assertEqual(0,fieldId);
6680         #
6681         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(0.7);
6682         self.assertEqual(0,meshId);
6683         self.assertEqual(1,arrId);
6684         self.assertEqual(0,arrIdInField);
6685         self.assertEqual(1,fieldId);
6686         #
6687         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeLeft(1.2);#**** WARNING left here
6688         self.assertEqual(0,meshId);
6689         self.assertEqual(2,arrId);
6690         self.assertEqual(1,arrIdInField);
6691         self.assertEqual(1,fieldId);
6692         #
6693         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(1.2);#**** WARNING right again here
6694         self.assertEqual(1,meshId);
6695         self.assertEqual(3,arrId);
6696         self.assertEqual(0,arrIdInField);
6697         self.assertEqual(2,fieldId);
6698         #
6699         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(1.35);
6700         self.assertEqual(1,meshId);
6701         self.assertEqual(3,arrId);
6702         self.assertEqual(0,arrIdInField);
6703         self.assertEqual(2,fieldId);
6704         #
6705         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(1.7);
6706         self.assertEqual(0,meshId);
6707         self.assertEqual(3,arrId);
6708         self.assertEqual(0,arrIdInField);
6709         self.assertEqual(3,fieldId);
6710         #
6711         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(2.7);
6712         self.assertEqual(1,meshId);
6713         self.assertEqual(4,arrId);
6714         self.assertEqual(0,arrIdInField);
6715         self.assertEqual(4,fieldId);
6716         #
6717         dt2=MEDCouplingDefinitionTime();
6718         self.assertTrue(not dt2.isEqual(dt));
6719         dt2.assign(dt);
6720         dt2.assign(dt);#to check memory management
6721         self.assertTrue(dt2.isEqual(dt));
6722         #
6723         dt3=MEDCouplingDefinitionTime();
6724         #
6725         pass
6726
6727     def testDAICheckAndPreparePermutation1(self):
6728         vals1=[9,10,0,6,4,11,3,7];
6729         expect1=[5,6,0,3,2,7,1,4];
6730         vals2=[9,10,0,6,10,11,3,7];
6731         da=DataArrayInt.New();
6732         da.setValues(vals1,8,1);
6733         da2=da.checkAndPreparePermutation();
6734         self.assertEqual(8,da2.getNumberOfTuples());
6735         self.assertEqual(1,da2.getNumberOfComponents());
6736         for i in xrange(8):
6737             self.assertEqual(expect1[i],da2.getIJ(i,0));
6738             pass
6739         #
6740         da=DataArrayInt.New();
6741         da.alloc(8,1);
6742         da.iota(0);
6743         da2=da.checkAndPreparePermutation();
6744         self.assertEqual(8,da2.getNumberOfTuples());
6745         self.assertEqual(1,da2.getNumberOfComponents());
6746         self.assertTrue(da2.isIdentity());
6747         #
6748         da=DataArrayInt.New();
6749         da.alloc(8,1);
6750         da.setValues(vals2,8,1);
6751         self.assertRaises(InterpKernelException,da.checkAndPreparePermutation);
6752         pass
6753
6754     def testDAIChangeSurjectiveFormat1(self):
6755         vals1=[0,3,2,3,2,2,1,2]
6756         expected1=[0,1,2,6,8]
6757         expected2=[0,  6,  2,4,5,7,  1,3]
6758         da=DataArrayInt.New();
6759         da.setValues(vals1,8,1);
6760         #
6761         da2,da2I=da.changeSurjectiveFormat(4);
6762         self.assertEqual(5,da2I.getNumberOfTuples());
6763         self.assertEqual(8,da2.getNumberOfTuples());
6764         self.assertEqual(expected1,da2I.getValues());
6765         self.assertEqual(expected2,da2.getValues());
6766         #
6767         self.assertRaises(InterpKernelException,da.changeSurjectiveFormat,3);
6768         #
6769         pass
6770
6771     def testUMeshGetCellIdsLyingOnNodes1(self):
6772         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6773         nodeIds1=[1,2,3,4,6]
6774         nodeIds2=[6,7]
6775         da=m.getCellIdsLyingOnNodes(nodeIds1,True);
6776         self.assertEqual(1,da.getNumberOfTuples());
6777         self.assertEqual(1,da.getNumberOfComponents());
6778         self.assertEqual(1,da.getIJ(0,0));
6779         da2=DataArrayInt.New()
6780         da2.setValues(nodeIds2,2,1)
6781         da=m.getCellIdsLyingOnNodes(da2,False);
6782         self.assertEqual(2,da.getNumberOfTuples());
6783         self.assertEqual(1,da.getNumberOfComponents());
6784         self.assertEqual(3,da.getIJ(0,0));
6785         self.assertEqual(4,da.getIJ(1,0));
6786         pass
6787
6788     def testUMeshFindCellIdsOnBoundary1(self):
6789         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6790         da5=m.findCellIdsOnBoundary();
6791         self.assertEqual(5,da5.getNumberOfTuples());
6792         self.assertTrue(da5.isIdentity());
6793         pass
6794
6795     def testMeshSetTime1(self):
6796         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6797         m2=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6798         #
6799         self.assertTrue(m1.isEqual(m2,1e-12));
6800         m1.setTime(3.14,6,7);
6801         tmp3,tmp1,tmp2=m1.getTime();
6802         self.assertEqual(6,tmp1);
6803         self.assertEqual(7,tmp2);
6804         self.assertAlmostEqual(3.14,tmp3,12);
6805         self.assertTrue(not m1.isEqual(m2,1e-12));
6806         m2.setTime(3.14,6,7);
6807         self.assertTrue(m1.isEqual(m2,1e-12));
6808         m1.setTimeUnit("ms");
6809         self.assertTrue(m1.getTimeUnit()=="ms");
6810         m1.setTimeUnit("us");
6811         self.assertTrue(m1.getTimeUnit()=="us");
6812         self.assertTrue(not m1.isEqual(m2,1e-12));
6813         m2.setTimeUnit("us");
6814         self.assertTrue(m1.isEqual(m2,1e-12));
6815         m2.setTime(3.14,6,8);
6816         self.assertTrue(not m1.isEqual(m2,1e-12));
6817         m2.setTime(3.14,7,7);
6818         self.assertTrue(not m1.isEqual(m2,1e-12));
6819         m2.setTime(3.15,6,7);
6820         self.assertTrue(not m1.isEqual(m2,1e-12));
6821         #
6822         m1.setTime(10.34,55,12);
6823         m3=m1.deepCpy();
6824         self.assertTrue(m1.isEqual(m3,1e-12));
6825         tmp3,tmp1,tmp2=m3.getTime();
6826         self.assertEqual(55,tmp1);
6827         self.assertEqual(12,tmp2);
6828         self.assertAlmostEqual(10.34,tmp3,12);
6829         #
6830         # testing CMesh
6831         coo1=[0.,1.,2.,3.5]
6832         a=DataArrayDouble.New();
6833         a.setValues(coo1,4,1);
6834         b=MEDCouplingCMesh.New();
6835         b.setCoordsAt(0,a);
6836         #
6837         b.setTime(5.67,8,100);
6838         tmp3,tmp1,tmp2=b.getTime();
6839         self.assertEqual(8,tmp1);
6840         self.assertEqual(100,tmp2);
6841         self.assertAlmostEqual(5.67,tmp3,12);
6842         c=b.deepCpy();
6843         self.assertTrue(c.isEqual(b,1e-12));
6844         tmp3,tmp1,tmp2=c.getTime();
6845         self.assertEqual(8,tmp1);
6846         self.assertEqual(100,tmp2);
6847         self.assertAlmostEqual(5.67,tmp3,12);
6848         pass
6849
6850     def testApplyFuncTwo1(self):
6851         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6852         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
6853         f1.setMesh(m1);
6854         #
6855         vals=[1.,11.,21.,2.,12.,22.,3.,13.,23.,4.,14.,24.,5.,15.,25.]
6856         da=DataArrayDouble.New();
6857         da.setValues(vals,5,3);
6858         f1.setArray(da);
6859         #
6860         self.assertRaises(InterpKernelException,da.applyFunc2,1,"y+z");
6861         da.setInfoOnComponent(0,"x [m]");
6862         da.setInfoOnComponent(1,"y [mm]");
6863         da.setInfoOnComponent(2,"z [km]");
6864
6865         self.assertRaises(InterpKernelException, da.applyFunc2, 1, "x+y+zz+zzz");
6866         self.assertRaises(InterpKernelException, da.applyFunc2, 1, "toto(x+y)");
6867         self.assertRaises(InterpKernelException, da.applyFunc2, 1, "x/0");
6868
6869         da2=da.applyFunc2(1,"y+z");
6870         self.assertEqual(1,da2.getNumberOfComponents());
6871         self.assertEqual(5,da2.getNumberOfTuples());
6872         expected1=[32.,34.,36.,38.,40.]
6873         for i in xrange(5):
6874             self.assertAlmostEqual(expected1[i],da2.getIJ(0,i),12);
6875             pass
6876         da2=da.applyFunc(1,"y+z");
6877         expected2=[12.,14.,16.,18.,20.]
6878         for i in xrange(5):
6879             self.assertAlmostEqual(expected2[i],da2.getIJ(0,i),12);
6880             pass
6881         #
6882         self.assertEqual(3,f1.getNumberOfComponents());
6883         self.assertEqual(5,f1.getNumberOfTuples());
6884         f1.applyFunc2(1,"y+z");
6885         self.assertEqual(1,f1.getNumberOfComponents());
6886         self.assertEqual(5,f1.getNumberOfTuples());
6887         for i in xrange(5):
6888             self.assertAlmostEqual(expected1[i],f1.getArray().getIJ(0,i),12);
6889             pass
6890         #
6891         pass
6892
6893     def testApplyFuncThree1(self):
6894         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6895         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
6896         f1.setMesh(m1);
6897         #
6898         vals=[1.,11.,21.,2.,12.,22.,3.,13.,23.,4.,14.,24.,5.,15.,25.]
6899         da=DataArrayDouble.New();
6900         da.setValues(vals,5,3);
6901         f1.setArray(da);
6902         #
6903         vs=3*[None];
6904         vs[0]="x"; vs[1]="Y"; vs[2]="z";
6905         self.assertRaises(InterpKernelException, da.applyFunc3, 1, vs, "y+z");
6906         self.assertRaises(InterpKernelException, da.applyFunc3, 1, vs, "x+Y+z+zz+zzz");
6907         self.assertRaises(InterpKernelException, da.applyFunc3, 1, vs, "x/0");
6908         vs[1]="y";
6909         da2=da.applyFunc3(1,vs,"y+z");
6910         expected1=[32.,34.,36.,38.,40.]
6911         for i in xrange(5):
6912             self.assertAlmostEqual(expected1[i],da2.getIJ(0,i),12);
6913             pass
6914         self.assertRaises(InterpKernelException, da.applyFunc3, 1, ["x","y","z","a"],"x+a")
6915         f1.setArray(da);
6916         self.assertEqual(3,f1.getNumberOfComponents());
6917         self.assertEqual(5,f1.getNumberOfTuples());
6918         f1.applyFunc3(1,vs,"y+z");
6919         self.assertEqual(1,f1.getNumberOfComponents());
6920         self.assertEqual(5,f1.getNumberOfTuples());
6921         for i in xrange(5):
6922             self.assertAlmostEqual(expected1[i],f1.getArray().getIJ(0,i),12);
6923             pass
6924         pass
6925
6926     def testFillFromAnalyticTwo1(self):
6927         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6928         m1.setTime(3.4,5,6); m1.setTimeUnit("us");
6929         self.assertRaises(InterpKernelException,m1.fillFromAnalytic2,ON_NODES,1,"y+z");
6930         m1.getCoords().setInfoOnComponent(0,"x [m]");
6931         m1.getCoords().setInfoOnComponent(1,"y");
6932         m1.getCoords().setInfoOnComponent(2,"z");
6933         f1=m1.fillFromAnalytic2(ON_NODES,1,"y+z");
6934         self.assertAlmostEqual(3.4,f1.getTime()[0],12) ; self.assertEqual(5,f1.getTime()[1]) ; self.assertEqual(6,f1.getTime()[2])
6935         self.assertEqual("us",f1.getTimeUnit())
6936         self.assertEqual(1,f1.getNumberOfComponents());
6937         self.assertEqual(9,f1.getNumberOfTuples());
6938         expected1=[0.2, 0.7, 1.2, 0.7, 1.2, 1.7, 1.2, 1.7, 2.2]
6939         for i in xrange(9):
6940             self.assertAlmostEqual(expected1[i],f1.getArray().getIJ(0,i),12);
6941             pass
6942         pass
6943
6944     def testFillFromAnalyticThree1(self):
6945         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6946         m1.setTime(3.4,5,6); m1.setTimeUnit("us");
6947         vs=3*[None];
6948         vs[0]="x"; vs[1]="Y"; vs[2]="z";
6949         self.assertRaises(InterpKernelException,m1.fillFromAnalytic3,ON_NODES,1,vs,"y+z");
6950         vs[1]="y";
6951         f1=m1.fillFromAnalytic3(ON_NODES,1,vs,"y+z");
6952         self.assertAlmostEqual(3.4,f1.getTime()[0],12) ; self.assertEqual(5,f1.getTime()[1]) ; self.assertEqual(6,f1.getTime()[2])
6953         self.assertEqual("us",f1.getTimeUnit())
6954         self.assertEqual(1,f1.getNumberOfComponents());
6955         self.assertEqual(9,f1.getNumberOfTuples());
6956         expected1=[0.2, 0.7, 1.2, 0.7, 1.2, 1.7, 1.2, 1.7, 2.2]
6957         for i in xrange(9):
6958             self.assertAlmostEqual(expected1[i],f1.getArray().getIJ(0,i),12);
6959             pass
6960         pass
6961
6962     def testDAUnitVar1(self):
6963         da=DataArrayDouble.New();
6964         da.alloc(1,3);
6965         da.setInfoOnComponent(0,"XPS [m]");
6966         st1=da.getVarOnComponent(0);
6967         self.assertTrue(st1=="XPS");
6968         st2=da.getUnitOnComponent(0);
6969         self.assertTrue(st2=="m");
6970         #
6971         da.setInfoOnComponent(0,"XPS         [m]");
6972         st1=da.getVarOnComponent(0);
6973         self.assertTrue(st1=="XPS");
6974         st2=da.getUnitOnComponent(0);
6975         self.assertTrue(st2=="m");
6976         #
6977         da.setInfoOnComponent(0,"XPP         [m]");
6978         st1=da.getVarOnComponent(0);
6979         self.assertTrue(st1=="XPP");
6980         st2=da.getUnitOnComponent(0);
6981         self.assertTrue(st2=="m");
6982         #
6983         da.setInfoOnComponent(0,"XPP kdep  kefer   [ m  ]");
6984         st1=da.getVarOnComponent(0);
6985         self.assertTrue(st1=="XPP kdep  kefer");
6986         st2=da.getUnitOnComponent(0);
6987         self.assertTrue(st2==" m  ");
6988         #
6989         da.setInfoOnComponent(0,"     XPP k[  dep  k]efer   [ m^ 2/s^3*kJ  ]");
6990         st1=da.getVarOnComponent(0);
6991         self.assertTrue(st1=="     XPP k[  dep  k]efer");
6992         st2=da.getUnitOnComponent(0);
6993         self.assertTrue(st2==" m^ 2/s^3*kJ  ");
6994         #
6995         da.setInfoOnComponent(0,"     XPP kefer   ");
6996         st1=da.getVarOnComponent(0);
6997         self.assertTrue(st1=="     XPP kefer   ");
6998         st2=da.getUnitOnComponent(0);
6999         self.assertTrue(st2=="");
7000         #
7001         da.setInfoOnComponent(0,"temperature( bof)");
7002         st1=da.getVarOnComponent(0);
7003         self.assertTrue(st1=="temperature( bof)");
7004         st2=da.getUnitOnComponent(0);
7005         self.assertTrue(st2=="");
7006         #
7007         da.setInfoOnComponent(0,"kkk [m]");
7008         da.setInfoOnComponent(1,"ppp   [m^2/kJ]");
7009         da.setInfoOnComponent(2,"abcde   [MW/s]");
7010         #
7011         vs=da.getVarsOnComponent();
7012         self.assertEqual(3,len(vs));
7013         self.assertTrue(vs[0]=="kkk");
7014         self.assertTrue(vs[1]=="ppp");
7015         self.assertTrue(vs[2]=="abcde");
7016         vs=da.getUnitsOnComponent();
7017         self.assertEqual(3,len(vs));
7018         self.assertTrue(vs[0]=="m");
7019         self.assertTrue(vs[1]=="m^2/kJ");
7020         self.assertTrue(vs[2]=="MW/s");
7021         pass
7022
7023     def testGaussCoordinates1(self):
7024         #Testing 1D cell types
7025         m1=MEDCouplingDataForTest.build1DMultiTypes_1();
7026         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,ONE_TIME);
7027         f.setMesh(m1);
7028         wg1=[0.3];
7029         gsCoo1=[0.2];
7030         refCoo1=[-1.0,1.0];
7031         f.setGaussLocalizationOnType(NORM_SEG2,refCoo1,gsCoo1,wg1);
7032         wg2=wg1;
7033         gsCoo2=[0.2];
7034         refCoo2=[-1.0,1.0,0.0];
7035         f.setGaussLocalizationOnType(NORM_SEG3,refCoo2,gsCoo2,wg2);
7036         #
7037         resToTest=f.getLocalizationOfDiscr();
7038         self.assertEqual(3,resToTest.getNumberOfComponents());
7039         self.assertEqual(2,resToTest.getNumberOfTuples());
7040         expected1=[0.6,0.6,0.6, 0.6,0.6,0.6]
7041         for i in xrange(6):
7042             self.assertAlmostEqual(expected1[i],resToTest.getIJ(0,i),14);
7043             pass
7044         #
7045         #Testing 2D cell types
7046         m2=MEDCouplingDataForTest.build2DMultiTypes_1();
7047         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,ONE_TIME);
7048         f.setMesh(m2);
7049         wg3=[0.3,0.3];
7050         tria3CooGauss=[ 0.1, 0.8, 0.2, 0.7 ]
7051         gsCoo3=tria3CooGauss
7052         tria3CooRef=[ 0.0, 0.0, 1.0 , 0.0, 0.0, 1.0 ]
7053         refCoo3=tria3CooRef;
7054         f.setGaussLocalizationOnType(NORM_TRI3,refCoo3,gsCoo3,wg3);
7055         wg4=[0.3,0.3,0.3];
7056         tria6CooGauss=[ 0.3, 0.2, 0.2, 0.1, 0.2, 0.4 ]
7057         gsCoo4=tria6CooGauss;
7058         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]
7059         refCoo4=tria6CooRef;
7060         f.setGaussLocalizationOnType(NORM_TRI6,refCoo4,gsCoo4,wg4);
7061         wg5=[0.3,0.3,0.3,0.3];
7062         quad4CooGauss=[ 0.3, 0.2, 0.2, 0.1, 0.2, 0.4, 0.15, 0.27 ]
7063         gsCoo5=quad4CooGauss;
7064         quad4CooRef=[-1.0, 1.0, -1.0, -1.0, 1.0, -1.0, 1.0, 1.0]
7065         refCoo5=quad4CooRef;
7066         f.setGaussLocalizationOnType(NORM_QUAD4,refCoo5,gsCoo5,wg5);
7067         wg6=[0.3,0.3,0.3,0.3];
7068         quad8CooGauss=[ 0.34, 0.16, 0.21, 0.3, 0.23, 0.4, 0.14, 0.37 ]
7069         gsCoo6=quad8CooGauss;
7070         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]
7071         refCoo6=quad8CooRef;
7072         f.setGaussLocalizationOnType(NORM_QUAD8,refCoo6,gsCoo6,wg6);
7073         #
7074         resToTest=f.getLocalizationOfDiscr();
7075         self.assertEqual(3,resToTest.getNumberOfComponents());
7076         self.assertEqual(13,resToTest.getNumberOfTuples());#2+3+4+4 gauss points for resp TRI3,TRI6,QUAD4,QUAD8
7077         expected2=[5.1,1.55,0.0, 4.7,1.65,0.0,
7078                    2.32,1.52,0.0, 1.6,1.32,0.0, 3.52,1.26,0.0,#TRI6
7079                    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
7080                    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
7081         for i in xrange(39):
7082             self.assertAlmostEqual(expected2[i],resToTest.getIJ(0,i),14);
7083             pass
7084         #
7085         #Testing 3D cell types
7086         m3=MEDCouplingDataForTest.build3DMultiTypes_1();
7087         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,ONE_TIME);
7088         f.setMesh(m3);
7089         #
7090         wg7=[0.3];
7091         tetra4CooGauss=[0.34, 0.16, 0.21]
7092         gsCoo7=tetra4CooGauss;
7093         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]
7094         refCoo7=tetra4CooRef;
7095         f.setGaussLocalizationOnType(NORM_TETRA4,refCoo7,gsCoo7,wg7);
7096         wg8=[0.3];
7097         tetra10CooGauss=[0.2, 0.3, 0.1]
7098         gsCoo8=tetra10CooGauss;
7099         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]
7100         refCoo8=tetra10CooRef;
7101         f.setGaussLocalizationOnType(NORM_TETRA10,refCoo8,gsCoo8,wg8);
7102         wg9=[0.3];
7103         pyra5CooGauss=[0.2, 0.3, 0.1]
7104         gsCoo9=pyra5CooGauss;
7105         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]
7106         refCoo9=pyra5CooRef;
7107         f.setGaussLocalizationOnType(NORM_PYRA5,refCoo9,gsCoo9,wg9);
7108         wg10=[0.3];
7109         pyra13CooGauss=[0.1, 0.2, 0.7]
7110         gsCoo10=pyra13CooGauss;
7111         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]
7112         refCoo10=pyra13CooRef;
7113         f.setGaussLocalizationOnType(NORM_PYRA13,refCoo10,gsCoo10,wg10);
7114         wg11=[0.3];
7115         penta6CooGauss=[0.2, 0.3, 0.1]
7116         gsCoo11=penta6CooGauss;
7117         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]
7118         refCoo11=penta6CooRef;
7119         f.setGaussLocalizationOnType(NORM_PENTA6,refCoo11,gsCoo11,wg11);
7120         wg12=[0.3];
7121         penta15CooGauss=[0.2, 0.3,0.15]
7122         gsCoo12=penta15CooGauss;
7123         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]
7124         refCoo12=penta15CooRef;
7125         f.setGaussLocalizationOnType(NORM_PENTA15,refCoo12,gsCoo12,wg12);
7126         wg13=[0.3];
7127         hexa8CooGauss=[0.2,0.3,0.15]
7128         gsCoo13=hexa8CooGauss;
7129         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]
7130         refCoo13=hexa8CooRef;
7131         f.setGaussLocalizationOnType(NORM_HEXA8,refCoo13,gsCoo13,wg13);
7132         wg14=[0.3];
7133         hexa20CooGauss=[0.11,0.3,0.55]
7134         gsCoo14=hexa20CooGauss;
7135         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]
7136         refCoo14=hexa20CooRef;
7137         f.setGaussLocalizationOnType(NORM_HEXA20,refCoo14,gsCoo14,wg14);
7138         #
7139         resToTest=f.getLocalizationOfDiscr();
7140         self.assertEqual(3,resToTest.getNumberOfComponents());
7141         self.assertEqual(8,resToTest.getNumberOfTuples());#2+3+4+4 gauss points for resp TRI3,TRI6,QUAD4,QUAD8
7142         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]
7143         for i in xrange(24):
7144             self.assertAlmostEqual(expected3[i],resToTest.getIJ(0,i),14);
7145             pass
7146         #
7147         pass
7148
7149     def testP2Localization1(self):
7150         m=MEDCouplingUMesh.New("testP2",2);
7151         coords=[0.,2.,3.5,0.,4.5,1.5,1.2,0.32,3.4,1.,2.1,2.4]
7152         conn=[0,1,2,3,4,5]
7153         coo=DataArrayDouble.New();
7154         coo.setValues(coords,6,2);
7155         m.setCoords(coo);
7156         m.allocateCells(1);
7157         m.insertNextCell(NORM_TRI6,6,conn[0:6])
7158         m.finishInsertingCells();
7159         #
7160         f=MEDCouplingFieldDouble.New(ON_NODES,ONE_TIME);
7161         f.setMesh(m);
7162         da=DataArrayDouble.New();
7163         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]
7164         da.setValues(vals1,6,3);
7165         f.setArray(da);
7166         #
7167         loc=[2.27,1.3]
7168         locs=f.getValueOnMulti(loc);
7169         expected1=[6.0921164547752236, 7.1921164547752232, 8.2921164547752255]
7170         for i in xrange(3):
7171             self.assertAlmostEqual(expected1[i],locs.getIJ(0,i),12);
7172             pass
7173         pass
7174
7175     def testP2Localization2(self):
7176         m=MEDCouplingUMesh.New("testP2_2",3);
7177         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]
7178         conn=[0,1,2,3,4,5,6,7,8,9]
7179         coo=DataArrayDouble.New();
7180         coo.setValues(coords,10,3);
7181         m.setCoords(coo);
7182         m.allocateCells(1);
7183         m.insertNextCell(NORM_TETRA10,10,conn[0:10])
7184         m.finishInsertingCells();
7185         #
7186         f=MEDCouplingFieldDouble.New(ON_NODES,ONE_TIME);
7187         f.setMesh(m);
7188         da=DataArrayDouble.New();
7189         vals1=[1.1,2.1,3.1,4.1,5.2,6.2,7.2,8.2,9.2,10.2]
7190         da.setValues(vals1,10,1);
7191         f.setArray(da);
7192         #
7193         loc=[0.64637931739890486, -0.16185896817550552, 0.22678966365273748]
7194         locs=f.getValueOnMulti(loc);
7195         expected1=[10.0844021968047]
7196         for i in xrange(1):
7197             self.assertAlmostEqual(expected1[i],locs.getIJ(0,i),12);
7198             pass
7199         pass
7200
7201     def testGetValueOn2(self):
7202         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7203         f=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
7204         f.setMesh(m);
7205         arr=DataArrayDouble.New();
7206         nbOfCells=m.getNumberOfCells();
7207         f.setArray(arr);
7208         values1=[7.,107.,10007.,8.,108.,10008.,9.,109.,10009.,10.,110.,10010.,11.,111.,10011.]
7209         arr.setValues(values1,nbOfCells,3);
7210         loc=[-0.05,-0.05, 0.55,-0.25, 0.55,0.15, -0.05,0.45, 0.45,0.45]
7211         f.checkCoherency();
7212         locs=f.getValueOnMulti(loc);
7213         self.assertEqual(5,locs.getNumberOfTuples());
7214         self.assertEqual(3,locs.getNumberOfComponents());
7215         for j in xrange(15):
7216             self.assertAlmostEqual(values1[j],locs.getIJ(0,j),12);
7217             pass
7218         # Testing ON_NODES
7219         f=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
7220         f.setMesh(m);
7221         arr=DataArrayDouble.New();
7222         nbOfNodes=m.getNumberOfNodes();
7223         f.setArray(arr);
7224         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.]
7225         arr.setValues(values2,nbOfNodes,3);
7226         loc2=[0.5432,-0.2432, 0.5478,0.1528, 0.5432,-0.2432, 0.5432,-0.2432]
7227         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]
7228         f.checkCoherency();
7229         loc3=DataArrayDouble.New()
7230         loc3.setValues(loc2,4,2);
7231         locs=f.getValueOnMulti(loc3);
7232         self.assertEqual(4,locs.getNumberOfTuples());
7233         self.assertEqual(3,locs.getNumberOfComponents());
7234         for i in xrange(12):
7235             self.assertAlmostEqual(expected2[i],locs.getIJ(0,i),12);
7236             pass
7237         #
7238         pass
7239
7240     def testDAIGetIdsNotEqual1(self):
7241         d=DataArrayInt.New();
7242         vals1=[2,3,5,6,8,5,5,6,1,-5]
7243         d.setValues(vals1,10,1);
7244         d2=d.getIdsNotEqual(5);
7245         self.assertEqual(7,d2.getNumberOfTuples());
7246         self.assertEqual(1,d2.getNumberOfComponents());
7247         expected1=[0,1,3,4,7,8,9]
7248         for i in xrange(7):
7249             self.assertEqual(expected1[i],d2.getIJ(0,i));
7250             pass
7251         d.rearrange(2);
7252         self.assertRaises(InterpKernelException,d.getIdsNotEqual,5);
7253         vals2=[-4,5,6]
7254         vals3=vals2;
7255         d.rearrange(1);
7256         d3=d.getIdsNotEqualList(vals3);
7257         self.assertEqual(5,d3.getNumberOfTuples());
7258         self.assertEqual(1,d3.getNumberOfComponents());
7259         expected2=[0,1,4,8,9]
7260         for i in xrange(5):
7261             self.assertEqual(expected2[i],d3.getIJ(0,i));
7262             pass
7263         pass
7264
7265     def testDAIComputeOffsets1(self):
7266         d=DataArrayInt.New();
7267         vals1=[3,5,1,2,0,8]
7268         expected1=[0,3,8,9,11,11]
7269         d.setValues(vals1,6,1);
7270         d.computeOffsets();
7271         self.assertEqual(6,d.getNumberOfTuples());
7272         self.assertEqual(1,d.getNumberOfComponents());
7273         for i in xrange(6):
7274             self.assertEqual(expected1[i],d.getIJ(0,i));
7275             pass
7276         pass
7277
7278     def testUMeshHexagonPrism1(self):
7279         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,
7280                 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];
7281         conn=[1,2,3,4,5,0,7,8,9,10,11,6]
7282         mesh=MEDCouplingUMesh.New("MyFirstHexagonalPrism",3);
7283         coo=DataArrayDouble.New();
7284         coo.setValues(coords,12,3);
7285         mesh.setCoords(coo);
7286         mesh.allocateCells(1);
7287         mesh.insertNextCell(NORM_HEXGP12,12,conn[0:12])
7288         mesh.finishInsertingCells();
7289         #
7290         mesh.checkCoherency();
7291         vols=mesh.getMeasureField(False);
7292         self.assertEqual(1,vols.getNumberOfTuples());
7293         self.assertEqual(1,vols.getNumberOfComponents());
7294         self.assertAlmostEqual(-5.196152422706632,vols.getIJ(0,0),12);
7295         bary=mesh.getBarycenterAndOwner();
7296         self.assertEqual(1,bary.getNumberOfTuples());
7297         self.assertEqual(3,bary.getNumberOfComponents());
7298         expected1=[0.,0.,1.]
7299         for i in xrange(3):
7300             self.assertAlmostEqual(expected1[i],bary.getIJ(0,i),12);
7301             pass
7302         d1=DataArrayInt.New();
7303         d2=DataArrayInt.New();
7304         d3=DataArrayInt.New();
7305         d4=DataArrayInt.New();
7306         m2=mesh.buildDescendingConnectivity(d1,d2,d3,d4);
7307         self.assertEqual(8,m2.getNumberOfCells());
7308         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]];
7309         expected2=[NORM_POLYGON, NORM_POLYGON, NORM_QUAD4, NORM_QUAD4, NORM_QUAD4, NORM_QUAD4, NORM_QUAD4, NORM_QUAD4];
7310         expected3=[6,6,4,4,4,4,4,4]
7311         for i in xrange(8):
7312             self.assertTrue(m2.getTypeOfCell(i)==expected2[i]);
7313             v=m2.getNodeIdsOfCell(i);
7314             self.assertTrue(len(v)==expected3[i]);
7315             self.assertEqual(expected4[i],v);
7316         #
7317         mesh.convertAllToPoly();
7318         self.assertTrue(NORM_POLYHED==mesh.getTypeOfCell(0));
7319         mesh.unPolyze();
7320         self.assertTrue(NORM_HEXGP12==mesh.getTypeOfCell(0));
7321         self.assertEqual(13,mesh.getMeshLength());
7322         #
7323         pass
7324
7325     def testDADCheckIsMonotonic(self):
7326         da=DataArrayDouble.New();
7327         da.setValues([-1.,1.01,2.03,6.],2,2);
7328         self.assertRaises(InterpKernelException,da.isMonotonic,True,1e-12);
7329         da.rearrange(1);
7330         self.assertTrue(da.isMonotonic(True,1e-12));
7331         da.checkMonotonic(True,1e-12);
7332         da.setIJ(2,0,6.1);
7333         self.assertTrue(not da.isMonotonic(True,1e-12));
7334         self.assertRaises(InterpKernelException,da.checkMonotonic,True,1e-12);
7335         da.setIJ(2,0,5.99);
7336         self.assertTrue(da.isMonotonic(True,1e-12));
7337         self.assertTrue(not da.isMonotonic(True,1e-1));
7338         pass
7339
7340     def testCheckCoherencyDeeper1(self):
7341         m=MEDCouplingDataForTest.build3DSourceMesh_1();
7342         m.checkCoherency();
7343         m.checkCoherency1();
7344         m.getNodalConnectivity().setIJ(8,0,-1);
7345         m.checkCoherency();
7346         self.assertRaises(InterpKernelException,m.checkCoherency1);
7347         m.getNodalConnectivity().setIJ(8,0,-6);
7348         m.checkCoherency();
7349         self.assertRaises(InterpKernelException,m.checkCoherency1);
7350         m.getNodalConnectivity().setIJ(8,0,9);#9>=NbOfNodes
7351         m.checkCoherency();
7352         self.assertRaises(InterpKernelException,m.checkCoherency1);
7353         m.getNodalConnectivity().setIJ(8,0,8);#OK
7354         m.checkCoherency();
7355         m.checkCoherency1();
7356         elts=[1,5]
7357         m.convertToPolyTypes(elts);
7358         m.checkCoherency();
7359         m.checkCoherency1();
7360         m.getNodalConnectivity().setIJ(2,0,9);#9>=NbOfNodes
7361         m.checkCoherency();
7362         self.assertRaises(InterpKernelException,m.checkCoherency1);
7363         m.getNodalConnectivity().setIJ(2,0,-3);
7364         m.checkCoherency();
7365         self.assertRaises(InterpKernelException,m.checkCoherency1);
7366         m.getNodalConnectivity().setIJ(2,0,-1);
7367         m.checkCoherency();
7368         self.assertRaises(InterpKernelException,m.checkCoherency1);#Throw because cell#0 is not a polyhedron
7369         m.getNodalConnectivity().setIJ(2,0,4);
7370         m.checkCoherency();
7371         m.checkCoherency1();
7372         m.getNodalConnectivity().setIJ(7,0,-1);
7373         m.checkCoherency();
7374         m.checkCoherency1();#OK because we are in polyhedron connec
7375         m.getNodalConnectivity().setIJ(36,0,14);
7376         m.checkCoherency();
7377         self.assertRaises(InterpKernelException,m.checkCoherency1);#Throw beacause now cell 5 is a TETRA4 (14) so mimatch of number index and static type.
7378         pass
7379
7380     def testUnPolyze2(self):
7381         m=MEDCouplingUMesh.New("jjj",3);
7382         coo=DataArrayDouble.New();
7383         coo.alloc(4,3);
7384         coo.rearrange(1);
7385         coo.iota(0);
7386         coo.rearrange(3);
7387         m.setCoords(coo);
7388         m.allocateCells(2);
7389         m.insertNextCell(NORM_TETRA4,4,[0,1,2,3]);
7390         m.insertNextCell(NORM_TETRA4,4,[0,1,2,3]);
7391         m.finishInsertingCells();
7392         m2=MEDCouplingUMesh.MergeUMeshesOnSameCoords(4*[m]);
7393         m2.convertToPolyTypes([2]);
7394         m2.unPolyze();
7395         self.assertEqual(NORM_TETRA4,m2.getTypeOfCell(2));
7396         self.assertEqual(40,m2.getMeshLength());
7397         temp2=m2.getNodeIdsOfCell(2);
7398         self.assertEqual(temp2,[0,1,2,3]);
7399         m2.checkCoherency1();
7400         m3=m2.deepCpy();
7401         m2.unPolyze();
7402         self.assertTrue(m3.isEqual(m2,1e-12));
7403         pass
7404
7405     def testDACpyFrom1(self):
7406         d=DataArrayDouble.New();
7407         d.alloc(12,1);
7408         d.iota(14.);
7409         d.rearrange(3);
7410         d.setName("Toto");
7411         d.setInfoOnComponent(0,"X [m]");
7412         d.setInfoOnComponent(1,"Y [m]");
7413         d.setInfoOnComponent(2,"Z [m]");
7414         #
7415         d1=DataArrayDouble.New();
7416         self.assertTrue(not d.isEqual(d1,1e-12));
7417         d1.cpyFrom(d);
7418         self.assertTrue(d.isEqual(d1,1e-12));
7419         d1.cpyFrom(d);
7420         self.assertTrue(d.isEqual(d1,1e-12));
7421         d1.rearrange(2);
7422         self.assertTrue(not d.isEqual(d1,1e-12));
7423         d1.cpyFrom(d);
7424         self.assertTrue(d.isEqual(d1,1e-12));
7425         #
7426         d2=d.convertToIntArr();
7427         d4=DataArrayInt.New();
7428         self.assertTrue(not d2.isEqual(d4));
7429         d4.cpyFrom(d2);
7430         self.assertTrue(d2.isEqual(d4));
7431         d4.cpyFrom(d2);
7432         self.assertTrue(d2.isEqual(d4));
7433         d4.rearrange(2);
7434         self.assertTrue(not d2.isEqual(d4));
7435         d4.cpyFrom(d2);
7436         self.assertTrue(d2.isEqual(d4));
7437         pass
7438
7439     def testDAITransformWithIndArr1(self):
7440         tab1=[17,18,22,19]
7441         tab2=[0,1,1,3,3,0,1,3,2,2,3,0]
7442         expected=[17,18,18,19,19,17,18,19,22,22,19,17]
7443         d=DataArrayInt.New();
7444         d.setValues(tab1,4,1);
7445         d1=DataArrayInt.New();
7446         d1.setValues(tab2,12,1);
7447         d2=d1[:]
7448         #
7449         d1.transformWithIndArr(d);
7450         self.assertEqual(12,d1.getNumberOfTuples());
7451         self.assertEqual(1,d1.getNumberOfComponents());
7452         for i in xrange(12):
7453             self.assertEqual(expected[i],d1.getIJ(i,0));
7454             pass
7455         #
7456         d1=d2
7457         d1.transformWithIndArr(tab1)
7458         self.assertEqual(12,d1.getNumberOfTuples());
7459         self.assertEqual(1,d1.getNumberOfComponents());
7460         for i in xrange(12):
7461             self.assertEqual(expected[i],d1.getIJ(i,0));
7462             pass
7463         pass
7464
7465     def testDAIBuildPermArrPerLevel1(self):
7466         arr=[2,0,1,1,0,1,2,0,1,1,0,0]
7467         expected1=[10,0,5,6,1,7,11,2,8,9,3,4]
7468         da=DataArrayInt.New();
7469         da.setValues(arr,12,1);
7470         da2=da.buildPermArrPerLevel();
7471         self.assertEqual(12,da2.getNumberOfTuples());
7472         self.assertEqual(1,da2.getNumberOfComponents());
7473         for i in xrange(12):
7474             self.assertEqual(expected1[i],da2.getIJ(i,0));
7475             pass
7476         pass
7477
7478     def testDAIOperations1(self):
7479         arr1=[-1,-2,4,7,3,2,6,6,4,3,0,1]
7480         da=DataArrayInt.New();
7481         da.setValues(arr1,4,3);
7482         da1=DataArrayInt.New();
7483         da1.alloc(12,1);
7484         da1.iota(2);
7485         self.assertRaises(InterpKernelException,DataArrayInt.Add,da,da1);#not same number of tuples/Components
7486         da1.rearrange(3);
7487         da2=DataArrayInt.Add(da,da1);
7488         self.assertEqual(4,da2.getNumberOfTuples());
7489         self.assertEqual(3,da2.getNumberOfComponents());
7490         expected1=[1,1,8,12,9,9,14,15,14,14,12,14]
7491         for i in xrange(12):
7492             self.assertEqual(expected1[i],da2.getIJ(0,i));
7493             pass
7494         da1.substractEqual(da);
7495         expected2=[3,5,0,-2,3,5,2,3,6,8,12,12]
7496         for i in xrange(12):
7497             self.assertEqual(expected2[i],da1.getIJ(0,i));
7498             pass
7499         da1.rearrange(1); da1.iota(2); da1.rearrange(3);
7500         da1.addEqual(da);
7501         for i in xrange(12):
7502             self.assertEqual(expected1[i],da1.getIJ(0,i));
7503             pass
7504         da1.rearrange(1); da1.iota(2); da1.rearrange(3);
7505         da2=DataArrayInt.Multiply(da,da1);
7506         self.assertEqual(4,da2.getNumberOfTuples());
7507         self.assertEqual(3,da2.getNumberOfComponents());
7508         expected3=[-2,-6,16,35,18,14,48,54,40,33,0,13]
7509         for i in xrange(12):
7510             self.assertEqual(expected3[i],da2.getIJ(0,i));
7511             pass
7512         da.divideEqual(da1);
7513         self.assertEqual(4,da.getNumberOfTuples());
7514         self.assertEqual(3,da.getNumberOfComponents());
7515         expected4=[0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0]
7516         for i in xrange(12):
7517             self.assertEqual(expected4[i],da.getIJ(0,i));
7518             pass
7519         da.setValues(arr1,4,3);
7520         da1.multiplyEqual(da);
7521         self.assertEqual(4,da1.getNumberOfTuples());
7522         self.assertEqual(3,da1.getNumberOfComponents());
7523         for i in xrange(12):
7524             self.assertEqual(expected3[i],da1.getIJ(0,i));
7525             pass
7526         da1.rearrange(1); da1.iota(2); da1.rearrange(3);
7527         da2=DataArrayInt.Divide(da,da1);
7528         self.assertEqual(4,da2.getNumberOfTuples());
7529         self.assertEqual(3,da2.getNumberOfComponents());
7530         for i in xrange(12):
7531             self.assertEqual(expected4[i],da2.getIJ(0,i));
7532             pass
7533         da1.applyInv(321);
7534         self.assertEqual(4,da1.getNumberOfTuples());
7535         self.assertEqual(3,da1.getNumberOfComponents());
7536         expected5=[160,107,80,64,53,45,40,35,32,29,26,24]
7537         for i in xrange(12):
7538             self.assertEqual(expected5[i],da1.getIJ(0,i));
7539             pass
7540         da1.applyDivideBy(2);
7541         self.assertEqual(4,da1.getNumberOfTuples());
7542         self.assertEqual(3,da1.getNumberOfComponents());
7543         expected6=[80,53,40,32,26,22,20,17,16,14,13,12]
7544         for i in xrange(12):
7545             self.assertEqual(expected6[i],da1.getIJ(0,i));
7546             pass
7547         expected7=[3,4,5,4,5,1,6,3,2,0,6,5]
7548         da1.applyModulus(7);
7549         for i in xrange(12):
7550             self.assertEqual(expected7[i],da1.getIJ(0,i));
7551             pass
7552         da1.applyLin(1,1);
7553         expected8=[3,3,3,3,3,1,3,3,0,0,3,3]
7554         da1.applyRModulus(3);
7555         for i in xrange(12):
7556             self.assertEqual(expected8[i],da1.getIJ(0,i));
7557             pass
7558         pass
7559
7560     def testEmulateMEDMEMBDC1(self):
7561         m,m1=MEDCouplingDataForTest.buildPointe_1();
7562         m2,da1,da2,da3,da4,da5,da0=m.emulateMEDMEMBDC(m1)
7563         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]
7564         expected1=[1,32,29,23,41,36]
7565         self.assertEqual(47,da0.getNumberOfTuples());
7566         self.assertEqual(1,da0.getNumberOfComponents());
7567         for i in xrange(47):
7568             self.assertEqual(expected0[i],da0.getIJ(0,i));
7569             pass
7570         self.assertEqual(6,da5.getNumberOfTuples());
7571         self.assertEqual(1,da5.getNumberOfComponents());
7572         for i in xrange(6):
7573             self.assertEqual(expected1[i],da5.getIJ(0,i));
7574             pass
7575         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]
7576         self.assertEqual(70,da1.getNumberOfTuples());
7577         self.assertEqual(1,da1.getNumberOfComponents());
7578         for i in xrange(70):
7579             self.assertEqual(expected2[i],da1.getIJ(0,i));
7580             pass
7581         expected3=[0,4,8,12,16,20,24,28,32,36,40,44,48,53,58,64,70]
7582         self.assertEqual(17,da2.getNumberOfTuples());
7583         self.assertEqual(1,da2.getNumberOfComponents());
7584         for i in xrange(17):
7585             self.assertEqual(expected3[i],da2.getIJ(0,i));
7586             pass
7587         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]
7588         #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];
7589         self.assertEqual(48,da4.getNumberOfTuples());
7590         self.assertEqual(1,da4.getNumberOfComponents());
7591         for i in xrange(48):
7592             self.assertEqual(expected4[i],da4.getIJ(0,i));
7593             pass
7594         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]
7595         self.assertEqual(70,da3.getNumberOfTuples());
7596         self.assertEqual(1,da3.getNumberOfComponents());
7597         for i in xrange(70):
7598             self.assertEqual(expected5[i],da3.getIJ(0,i));
7599             pass
7600         pass
7601
7602     def testGetLevArrPerCellTypes1(self):
7603         m,m1=MEDCouplingDataForTest.buildPointe_1();
7604         m1,d0,d1,d2,d3=m.buildDescendingConnectivity();
7605         order=[NORM_TRI3,NORM_QUAD4];
7606         da0,da1=m1.getLevArrPerCellTypes(order);
7607         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]
7608         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]
7609         self.assertEqual(47,da0.getNumberOfTuples());
7610         self.assertEqual(1,da0.getNumberOfComponents());
7611         for i in xrange(47):
7612             self.assertEqual(expected0[i],da0.getIJ(0,i));
7613             pass
7614         self.assertEqual(2,da1.getNumberOfTuples());
7615         self.assertEqual(1,da1.getNumberOfComponents());
7616         self.assertEqual(36,da1.getIJ(0,0));#36 TRI3
7617         self.assertEqual(11,da1.getIJ(1,0));#11 QUAD4
7618         #
7619         da2=da0.buildPermArrPerLevel();
7620         #
7621         self.assertEqual(47,da2.getNumberOfTuples());
7622         self.assertEqual(1,da2.getNumberOfComponents());
7623         for i in xrange(47):
7624             self.assertEqual(expected1[i],da2.getIJ(0,i));
7625             pass
7626         pass
7627
7628     def testSortCellsInMEDFileFrmt1(self):
7629         m,m1=MEDCouplingDataForTest.buildPointe_1();
7630         m2=m.deepCpy()
7631         da=DataArrayInt.New()
7632         da.setValues([0,1,2,14,3,12,4,5,15,6,7,8,9,10,11,13],16,1)
7633         daa=da.invertArrayN2O2O2N(16)
7634         m.renumberCells(daa,False)
7635         da2=m.sortCellsInMEDFileFrmt()
7636         self.assertEqual(da2.getValues(),[0,1,2,14,3,12,4,5,15,6,7,8,9,10,11,13])
7637         self.assertTrue(m.isEqual(m2,1e-12))
7638         self.assertTrue(da.isEqual(da2))
7639         pass
7640
7641     def testBuildPartAndReduceNodes1(self):
7642         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7643         arr=[1,0]
7644         m2,da=m.buildPartAndReduceNodes(arr);
7645         self.assertEqual(5,m2.getNumberOfNodes());
7646         self.assertEqual(2,m2.getNumberOfCells());
7647         f=m2.getMeasureField(True);
7648         self.assertAlmostEqual(0.125,f.getArray().getIJ(0,0),12);
7649         self.assertAlmostEqual(0.25,f.getArray().getIJ(1,0),12);
7650         #
7651         arr2=DataArrayInt.New()
7652         arr2.setValues(arr,2,1)
7653         m2,da=m.buildPartAndReduceNodes(arr2);
7654         self.assertEqual(5,m2.getNumberOfNodes());
7655         self.assertEqual(2,m2.getNumberOfCells());
7656         f=m2.getMeasureField(True);
7657         self.assertAlmostEqual(0.125,f.getArray().getIJ(0,0),12);
7658         self.assertAlmostEqual(0.25,f.getArray().getIJ(1,0),12);
7659         pass
7660
7661     def testDAITransformWithIndArrR1(self):
7662         tab1=[2,4,5,3,6,7]
7663         tab2=[-1,-1,0,1,2,3,4,5,-1,-1,-1,-1]
7664         expected=[0,3,1,2,4,5]
7665         d=DataArrayInt.New();
7666         d.setValues(tab1,6,1);
7667         d1=DataArrayInt.New();
7668         d1.setValues(tab2,12,1);
7669         d2=d1[:]
7670         #
7671         d3=d.transformWithIndArrR(d1);
7672         self.assertEqual(6,d3.getNumberOfTuples());
7673         self.assertEqual(1,d3.getNumberOfComponents());
7674         for i in xrange(6):
7675             self.assertEqual(expected[i],d3.getIJ(i,0));
7676             pass
7677         #
7678         d1=d2
7679         d3=d.transformWithIndArrR(tab2)
7680         self.assertEqual(6,d3.getNumberOfTuples());
7681         self.assertEqual(1,d3.getNumberOfComponents());
7682         for i in xrange(6):
7683             self.assertEqual(expected[i],d3.getIJ(i,0));
7684             pass
7685         pass
7686
7687     def testDAISplitByValueRange1(self):
7688         val1=[6,5,0,3,2,7,8,1,4]
7689         val2=[0,4,9]
7690         d=DataArrayInt.New();
7691         d.setValues(val1,9,1);
7692         e,f,g=d.splitByValueRange(val2);
7693         self.assertEqual(9,e.getNumberOfTuples());
7694         self.assertEqual(1,e.getNumberOfComponents());
7695         self.assertEqual(9,f.getNumberOfTuples());
7696         self.assertEqual(1,f.getNumberOfComponents());
7697         self.assertEqual(2,g.getNumberOfTuples());
7698         self.assertEqual(1,g.getNumberOfComponents());
7699         #
7700         expected1=[1,1,0,0,0,1,1,0,1]
7701         expected2=[2,1,0,3,2,3,4,1,0]
7702         for i in xrange(9):
7703             self.assertEqual(expected1[i],e.getIJ(i,0));
7704             self.assertEqual(expected2[i],f.getIJ(i,0));
7705             pass
7706         self.assertEqual(0,g.getIJ(0,0));
7707         self.assertEqual(1,g.getIJ(1,0));
7708         #
7709         d.setIJ(6,0,9);
7710         self.assertRaises(InterpKernelException,d.splitByValueRange,val2);
7711         pass
7712
7713     def testUMeshSplitProfilePerType1(self):
7714         val0=[2,0,1,3,4]
7715         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7716         m.renumberCells(val0,False);
7717         #
7718         val1=[0,2,3]
7719         d=DataArrayInt.New();
7720         d.setValues(val1,3,1);
7721         d.setName("sup")
7722         code,idsInPflPerType,pfls=m.splitProfilePerType(d);
7723         self.assertEqual(6,len(code));
7724         self.assertEqual(2,len(idsInPflPerType));
7725         expected1=[3,1,0, 4,2,1]
7726         for i in xrange(6):
7727             self.assertEqual(expected1[i],code[i]);
7728             pass
7729         self.assertEqual(2,len(idsInPflPerType));
7730         self.assertEqual(1,idsInPflPerType[0].getNumberOfTuples());
7731         self.assertEqual(0,idsInPflPerType[0].getIJ(0,0));
7732         self.assertEqual(2,idsInPflPerType[1].getNumberOfTuples());
7733         self.assertEqual(1,idsInPflPerType[1].getIJ(0,0));
7734         self.assertEqual(2,idsInPflPerType[1].getIJ(1,0));
7735         #
7736         self.assertEqual(2,len(pfls));
7737         self.assertEqual("sup",pfls[0].getName())
7738         self.assertEqual(1,pfls[0].getNumberOfTuples());
7739         self.assertEqual(0,pfls[0].getIJ(0,0));
7740         self.assertEqual("sup",pfls[1].getName())
7741         self.assertEqual(2,pfls[1].getNumberOfTuples());
7742         self.assertEqual(0,pfls[1].getIJ(0,0));
7743         self.assertEqual(1,pfls[1].getIJ(1,0));
7744         #
7745         val2=[0,2,3,4]
7746         d=DataArrayInt.New();
7747         d.setValues(val2,4,1);
7748         code,idsInPflPerType,pfls=m.splitProfilePerType(d);
7749         self.assertEqual(6,len(code));
7750         self.assertEqual(2,len(idsInPflPerType));
7751         expected2=[3,1,0, 4,3,-1]
7752         for i in xrange(6):
7753             self.assertEqual(expected2[i],code[i]);
7754             pass
7755         self.assertEqual(2,len(idsInPflPerType));
7756         self.assertEqual(1,idsInPflPerType[0].getNumberOfTuples());
7757         self.assertEqual(0,idsInPflPerType[0].getIJ(0,0));
7758         self.assertEqual(3,idsInPflPerType[1].getNumberOfTuples());
7759         self.assertEqual(1,idsInPflPerType[1].getIJ(0,0));
7760         self.assertEqual(2,idsInPflPerType[1].getIJ(1,0));
7761         self.assertEqual(3,idsInPflPerType[1].getIJ(2,0));
7762         #
7763         self.assertEqual(1,len(pfls));
7764         self.assertEqual(1,pfls[0].getNumberOfTuples());
7765         self.assertEqual(0,pfls[0].getIJ(0,0));
7766         #
7767         val3=[1,0,2]
7768         d=DataArrayInt.New();
7769         d.setValues(val3,3,1);
7770         code,idsInPflPerType,pfls=m.splitProfilePerType(d);
7771         self.assertEqual(6,len(code));
7772         self.assertEqual(2,len(idsInPflPerType));
7773         expected3=[3,2,0, 4,1,1]
7774         for i in xrange(6):
7775             self.assertEqual(expected3[i],code[i]);
7776             pass
7777         self.assertEqual(2,len(idsInPflPerType));
7778         self.assertEqual(2,idsInPflPerType[0].getNumberOfTuples());
7779         self.assertEqual(0,idsInPflPerType[0].getIJ(0,0));
7780         self.assertEqual(1,idsInPflPerType[0].getIJ(1,0));
7781         self.assertEqual(1,idsInPflPerType[1].getNumberOfTuples());
7782         self.assertEqual(2,idsInPflPerType[1].getIJ(0,0));
7783         #
7784         self.assertEqual(2,len(pfls));
7785         self.assertEqual(2,pfls[0].getNumberOfTuples());
7786         self.assertEqual(1,pfls[0].getIJ(0,0));
7787         self.assertEqual(0,pfls[0].getIJ(1,0));
7788         self.assertEqual(0,pfls[1].getIJ(0,0));
7789         #
7790         val4=[3,4]
7791         d=DataArrayInt.New();
7792         d.setValues(val4,2,1);
7793         code,idsInPflPerType,pfls=m.splitProfilePerType(d);
7794         self.assertEqual(3,len(code));
7795         self.assertEqual(1,len(idsInPflPerType));
7796         expected4=[4,2,0]
7797         for i in xrange(3):
7798             self.assertEqual(expected4[i],code[i]);
7799             pass
7800         self.assertEqual(1,len(idsInPflPerType));
7801         self.assertEqual(2,idsInPflPerType[0].getNumberOfTuples());
7802         self.assertEqual(0,idsInPflPerType[0].getIJ(0,0));
7803         self.assertEqual(1,idsInPflPerType[0].getIJ(1,0));
7804         #
7805         self.assertEqual(1,len(pfls));
7806         self.assertEqual(2,pfls[0].getNumberOfTuples());
7807         self.assertEqual(1,pfls[0].getIJ(0,0));
7808         self.assertEqual(2,pfls[0].getIJ(1,0));
7809         pass
7810
7811     def testDAIBuildExplicitArrByRanges1(self):
7812         d=DataArrayInt.New();
7813         vals1=[0,2,3]
7814         d.setValues(vals1,3,1);
7815         e=DataArrayInt.New();
7816         vals2=[0,3,6,10,14,20]
7817         e.setValues(vals2,6,1);
7818         #
7819         f=d.buildExplicitArrByRanges(e);
7820         self.assertEqual(11,f.getNumberOfTuples());
7821         self.assertEqual(1,f.getNumberOfComponents());
7822         expected1=[0,1,2,6,7,8,9,10,11,12,13]
7823         for i in xrange(11):
7824             self.assertEqual(expected1[i],f.getIJ(i,0));
7825             pass
7826         pass
7827
7828     def testDAIComputeOffsets2(self):
7829         d=DataArrayInt.New();
7830         vals1=[3,5,1,2,0,8]
7831         expected1=[0,3,8,9,11,11,19]
7832         d.setValues(vals1,6,1);
7833         d.computeOffsets2();
7834         self.assertEqual(7,d.getNumberOfTuples());
7835         self.assertEqual(1,d.getNumberOfComponents());
7836         for i in xrange(7):
7837             self.assertEqual(expected1[i],d.getIJ(0,i));
7838             pass
7839         pass
7840
7841     def testMergeField3(self):
7842         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7843         m.getCoords().setInfoOnComponent(0,"x [m]");
7844         m.getCoords().setInfoOnComponent(1,"z [km]");
7845         m.setName("m");
7846         m.setDescription("desc");
7847         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
7848         f1.setName("f1");
7849         f1.setMesh(m);
7850         arr=DataArrayDouble.New();
7851         arr.alloc(5,2);
7852         arr.setInfoOnComponent(0,"X [m]");
7853         arr.setInfoOnComponent(1,"YY [mm]");
7854         arr.fillWithValue(2.);
7855         f1.setArray(arr);
7856         #
7857         f2=MEDCouplingFieldDouble.MergeFields([f1]);
7858         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
7859         #
7860         pass
7861
7862     def testGetDistributionOfTypes1(self):
7863         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7864         tab1=[2,0,1,3,4]
7865         self.assertRaises(InterpKernelException,m.getDistributionOfTypes);
7866         m.renumberCells(tab1,False);
7867         code=m.getDistributionOfTypes();
7868         self.assertEqual(2,len(code));
7869         self.assertEqual(3,code[0][0]);
7870         self.assertEqual(2,code[0][1]);
7871         self.assertEqual(0,code[0][2]);
7872         self.assertEqual(4,code[1][0]);
7873         self.assertEqual(3,code[1][1]);
7874         self.assertEqual(0,code[1][2]);
7875         pass
7876
7877     def testNorm2_1(self):
7878         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7879         f=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
7880         f.setMesh(m);
7881         #
7882         d=DataArrayDouble.New();
7883         tab=[1.2,1.3,2.2,2.3,3.2,3.3,4.2,4.3,5.2,5.3]
7884         d.setValues(tab,5,2);
7885         f.setArray(d);
7886         f.checkCoherency();
7887         #
7888         self.assertAlmostEqual(11.209371079592289,f.norm2(),14);
7889         #
7890         pass
7891
7892     def testNormMax1(self):
7893         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7894         f=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
7895         f.setMesh(m);
7896         #
7897         d=DataArrayDouble.New();
7898         tab=[2.3,-1.2,6.3,-7.8,2.9,7.7,2.1,0.,3.6,-7.6]
7899         d.setValues(tab,5,2);
7900         f.setArray(d);
7901         f.checkCoherency();
7902         #
7903         self.assertAlmostEqual(7.8,f.normMax(),14);
7904         #
7905         pass
7906
7907     def testFindAndCorrectBadOriented3DExtrudedCells1(self):
7908         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];
7909         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]
7910         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]
7911         invalidCells=[2,3,6,7]
7912         m=MEDCouplingUMesh.New("Example",3);
7913         coo=DataArrayDouble.New();
7914         coo.setValues(coords,38,3);
7915         m.setCoords(coo);
7916         m.allocateCells(8);
7917         m.insertNextCell(NORM_PENTA6,6,conn[0:6])
7918         m.insertNextCell(NORM_PENTA6,6,conn[6:12])
7919         m.insertNextCell(NORM_PENTA6,6,conn[12:18])
7920         m.insertNextCell(NORM_PENTA6,6,conn[18:24])
7921         m.insertNextCell(NORM_HEXA8,8,conn[24:32])
7922         m.insertNextCell(NORM_HEXA8,8,conn[32:40])
7923         m.insertNextCell(NORM_HEXA8,8,conn[40:48])
7924         m.insertNextCell(NORM_HEXA8,8,conn[48:56])
7925         m.finishInsertingCells();
7926         #
7927         v=m.findAndCorrectBadOriented3DExtrudedCells();
7928         self.assertEqual(4,len(v));
7929         self.assertEqual(v.getValues(),invalidCells);
7930         self.assertEqual(connExp,m.getNodalConnectivity().getValues());
7931         self.assertTrue(m.findAndCorrectBadOriented3DExtrudedCells().empty())
7932         #
7933         pass
7934
7935     def testConvertExtrudedPolyhedra1(self):
7936         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]
7937         m=MEDCouplingUMesh.New("Example",3);
7938         coo=DataArrayDouble.New();
7939         coo.alloc(73,3);
7940         coo.rearrange(1); coo.iota(0); coo.rearrange(3);
7941         m.setCoords(coo);
7942         m.allocateCells(9);
7943         m.insertNextCell(NORM_TETRA4,4,conn[0:4])
7944         m.insertNextCell(NORM_HEXA8,8,conn[4:12])
7945         m.insertNextCell(NORM_TETRA4,4,conn[12:16])
7946         m.insertNextCell(NORM_POLYHED,6,conn[16:22])
7947         m.insertNextCell(NORM_PENTA6,6,conn[22:28])
7948         m.insertNextCell(NORM_POLYHED,10,conn[28:38])
7949         m.insertNextCell(NORM_HEXA8,8,conn[38:46])
7950         m.insertNextCell(NORM_HEXGP12,12,conn[46:58])
7951         m.insertNextCell(NORM_POLYHED,14,conn[58:72])
7952         m.finishInsertingCells();
7953         #
7954         m.convertExtrudedPolyhedra();
7955         da=m.getNodalConnectivity();
7956         dai=m.getNodalConnectivityIndex();
7957         self.assertEqual(10,dai.getNbOfElems());
7958         self.assertEqual(159,da.getNbOfElems());
7959         #
7960         expected1=[14, 1, 2, 3, 4,
7961                    18, 5, 6, 7, 8, 9, 10, 11, 12,
7962                    14, 13, 14, 15, 16,
7963                    31, 17, 18, 19, -1, 20, 22, 21, -1, 17, 18, 21, 20, -1, 18, 19, 22, 21, -1, 19, 17, 20, 22,
7964                    16, 23, 24, 25, 26, 27, 28,
7965                    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,
7966                    18, 39, 40, 41, 42, 43, 44, 45, 46,
7967                    22, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
7968                    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];
7969         expected2=[0,5,14,19,42,49,86,95,108,159]
7970         self.assertEqual(expected1,da.getValues());
7971         self.assertEqual(expected2,dai.getValues());
7972         m.checkCoherency2()
7973         pass
7974
7975     def testNonRegressionCopyTinyStrings(self):
7976         m=MEDCouplingDataForTest.build2DTargetMesh_1()
7977         f1=m.getMeasureField(True)
7978         f1.getArray().setInfoOnComponent(0,"P [N/m^2]")
7979         bary=m.getBarycenterAndOwner()
7980         f2=f1.buildNewTimeReprFromThis(NO_TIME,False)
7981         f2.setArray(bary)
7982         self.assertRaises(InterpKernelException,f1.copyTinyAttrFrom,f2)
7983         pass
7984
7985     def testDaDSetPartOfValuesAdv1(self):
7986         tab1=[3.,4.,5., 13.,14.,15., 23.,24.,25., 33.,34.,35., 43.,44.,45., 53.,54.,55.]
7987         tab2=[6.,7.,8., 16.,17.,18., 26.,27.,28.]
7988         tab3=[4,1, 2,2, 3,0]
7989         a=DataArrayDouble.New();
7990         a.setValues(tab1,6,3);
7991         b=DataArrayDouble.New();
7992         b.setValues(tab2,3,3);
7993         c=DataArrayInt.New();
7994         c.setValues(tab3,3,2);
7995         #
7996         a.setPartOfValuesAdv(b,c);
7997         expected1=[3.,4.,5., 13.,14.,15., 26.,27.,28., 6.,7.,8., 16.,17.,18., 53.,54.,55.]
7998         self.assertEqual(expected1,a.getValues());
7999         pass
8000
8001     def testUMeshBuildSetInstanceFromThis1(self):
8002         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
8003         m2=m.buildSetInstanceFromThis(3);
8004         self.assertTrue(m.isEqual(m2,1e-12));
8005         #
8006         m=MEDCouplingUMesh.New("toto",2);
8007         m2=m.buildSetInstanceFromThis(3);
8008         self.assertEqual(0,m2.getNumberOfNodes());
8009         self.assertEqual(0,m2.getNumberOfCells());
8010         pass
8011
8012     def testUMeshMergeMeshesCVW1(self):
8013         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
8014         m2=MEDCouplingUMesh.New("toto",2);
8015         m3=MEDCouplingUMesh.MergeUMeshes([m,m2]);
8016         m3.setName(m.getName());
8017         self.assertTrue(m.isEqual(m3,1e-12));
8018         pass
8019
8020     def testChangeUnderlyingMeshWithCMesh1(self):
8021         mesh=MEDCouplingCMesh.New();
8022         coordsX=DataArrayDouble.New();
8023         arrX=[ -1., 1., 2., 4. ]
8024         coordsX.setValues(arrX,4,1);
8025         coordsY=DataArrayDouble.New();
8026         arrY=[ -2., 2., 4., 8. ]
8027         coordsY.setValues(arrY,4,1);
8028         coordsZ=DataArrayDouble.New();
8029         arrZ=[ -3., 3., 6., 12. ]
8030         coordsZ.setValues(arrZ,4,1);
8031         mesh.setCoords(coordsX,coordsY,coordsZ);
8032         f=mesh.getMeasureField(True)
8033         mesh2=mesh.deepCpy()
8034         for myId in [0,1,2,10,11,12,20,21,22]:
8035             f=mesh.getMeasureField(True)
8036             f.changeUnderlyingMesh(mesh2,myId,1e-12);
8037             pass
8038         mesh2.setName("uuuu")
8039         for myId in [1,2,10,11,12,20,21,22]:
8040             f=mesh.getMeasureField(True)
8041             f.changeUnderlyingMesh(mesh2,myId,1e-12);
8042             pass
8043         pass
8044
8045     def testDADFindCommonTuples1(self):
8046         da=DataArrayDouble.New();
8047         # nbOftuples=1
8048         array1=[2.3,1.2,1.3,2.3,2.301,0.8]
8049         da.setValues(array1,6,1)
8050         c,cI=da.findCommonTuples(1e-2);
8051         expected1=[0,3,4]
8052         expected2=[0,3]
8053         self.assertEqual(3,c.getNbOfElems());
8054         self.assertEqual(2,cI.getNbOfElems());
8055         self.assertEqual(expected1,c.getValues())
8056         self.assertEqual(expected2,cI.getValues())
8057         c,cI=da.findCommonTuples(2e-1)
8058         expected3=[0,3,4,1,2]
8059         expected4=[0,3,5]
8060         self.assertEqual(5,c.getNbOfElems());
8061         self.assertEqual(3,cI.getNbOfElems());
8062         self.assertEqual(expected3,c.getValues())
8063         self.assertEqual(expected4,cI.getValues())
8064         # nbOftuples=2
8065         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]
8066         da.setValues(array2,6,2)
8067         c,cI=da.findCommonTuples(1e-2);
8068         self.assertEqual(3,c.getNbOfElems());
8069         self.assertEqual(2,cI.getNbOfElems());
8070         self.assertEqual(expected1,c.getValues())
8071         self.assertEqual(expected2,cI.getValues())
8072         c,cI=da.findCommonTuples(2e-1)
8073         self.assertEqual(5,c.getNbOfElems());
8074         self.assertEqual(3,cI.getNbOfElems());
8075         self.assertEqual(expected3,c.getValues())
8076         self.assertEqual(expected4,cI.getValues())
8077         # nbOftuples=3
8078         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]
8079         da.setValues(array3,6,3)
8080         c,cI=da.findCommonTuples(1e-2);
8081         self.assertEqual(3,c.getNbOfElems());
8082         self.assertEqual(2,cI.getNbOfElems());
8083         self.assertEqual(expected1,c.getValues())
8084         self.assertEqual(expected2,cI.getValues())
8085         c,cI=da.findCommonTuples(2e-1)
8086         self.assertEqual(5,c.getNbOfElems());
8087         self.assertEqual(3,cI.getNbOfElems());
8088         self.assertEqual(expected3,c.getValues())
8089         self.assertEqual(expected4,cI.getValues())
8090         # nbOftuples=1, no common groups
8091         array11=[2.3,1.2,1.3,2.4,2.5,0.8]
8092         da.setValues(array11,6,1)
8093         c,cI=da.findCommonTuples(1e-2);
8094         self.assertEqual(0,c.getNbOfElems());
8095         self.assertEqual(1,cI.getNbOfElems());
8096         self.assertEqual([0],cI.getValues())
8097
8098         array12=[0.]*(6*4)
8099         da.setValues(array12,6,4) #bad NumberOfComponents
8100         self.assertRaises(InterpKernelException, da.findCommonTuples, 1e-2);
8101         pass
8102
8103     def testDABack1(self):
8104         da=DataArrayDouble.New();
8105         array1=[2.3,1.2,1.3,2.3,2.301,0.8]
8106         da.setValues(array1,6,1);
8107         self.assertAlmostEqual(0.8,da.back(),14);
8108         da.rearrange(2);
8109         self.assertRaises(InterpKernelException,da.back);
8110         da.alloc(0,1);
8111         self.assertRaises(InterpKernelException,da.back);
8112         #
8113         da=DataArrayInt.New();
8114         array2=[4,7,8,2]
8115         da.setValues(array2,4,1);
8116         self.assertEqual(2,da.back());
8117         da.rearrange(2);
8118         self.assertRaises(InterpKernelException,da.back);
8119         da.alloc(0,1);
8120         self.assertRaises(InterpKernelException,da.back);
8121         pass
8122
8123     def testDADGetDifferentValues1(self):
8124         da=DataArrayDouble.New();
8125         array1=[2.3,1.2,1.3,2.3,2.301,0.8]
8126         da.setValues(array1,6,1)
8127         #
8128         expected1=[2.301,1.2,1.3,0.8]
8129         dv=da.getDifferentValues(1e-2);
8130         self.assertEqual(4,dv.getNbOfElems());
8131         for i in xrange(4):
8132             self.assertAlmostEqual(expected1[i],dv.getIJ(i,0),14);
8133             pass
8134         #
8135         dv=da.getDifferentValues(2e-1);
8136         expected2=[2.301,1.3,0.8]
8137         self.assertEqual(3,dv.getNbOfElems());
8138         for i in xrange(3):
8139             self.assertAlmostEqual(expected2[i],dv.getIJ(i,0),14);
8140             pass
8141         pass
8142
8143     def testDAIBuildOld2NewArrayFromSurjectiveFormat2(self):
8144         arr=[0,3, 5,7,9]
8145         arrI=[0,2,5]
8146         a=DataArrayInt.New();
8147         a.setValues(arr,5,1);
8148         b=DataArrayInt.New();
8149         b.setValues(arrI,3,1);
8150         ret,newNbTuple=DataArrayInt.BuildOld2NewArrayFromSurjectiveFormat2(10,a,b);
8151         expected=[0,1,2,0,3,4,5,4,6,4]
8152         self.assertEqual(10,ret.getNbOfElems());
8153         self.assertEqual(7,newNbTuple);
8154         self.assertEqual(1,ret.getNumberOfComponents());
8155         self.assertEqual(expected,ret.getValues());
8156         self.assertRaises(InterpKernelException,DataArrayInt.BuildOld2NewArrayFromSurjectiveFormat2,9,a,b);
8157         pass
8158
8159     def testDADIReverse1(self):
8160         arr=[0,3,5,7,9,2]
8161         a=DataArrayInt.New();
8162         a.setValues(arr,6,1);
8163         self.assertEqual(2,a.back());
8164         a.reverse();
8165         for i in xrange(6):
8166             self.assertEqual(arr[5-i],a.getIJ(i,0));
8167             pass
8168         a.setValues(arr[:-1],5,1);
8169         a.reverse();
8170         for i in xrange(5):
8171             self.assertEqual(arr[4-i],a.getIJ(i,0));
8172             pass
8173         #
8174         arr2=[0.,3.,5.,7.,9.,2.]
8175         b=DataArrayDouble.New();
8176         b.setValues(arr2,6,1);
8177         b.reverse();
8178         for i in xrange(6):
8179             self.assertAlmostEqual(arr2[5-i],b.getIJ(i,0),14);
8180             pass
8181         b.setValues(arr2[:5],5,1);
8182         self.assertAlmostEqual(9.,b.back(),14)
8183         b.reverse();
8184         for i in xrange(5):
8185             self.assertAlmostEqual(arr2[4-i],b.getIJ(i,0),14);
8186             pass
8187         pass
8188
8189     def testGetNodeIdsInUse1(self):
8190         m0=MEDCouplingDataForTest.build2DTargetMesh_1();
8191         CellIds=[1,2]
8192         m1=m0.buildPartOfMySelf(CellIds,True);
8193         arr,newNbOfNodes=m1.getNodeIdsInUse();
8194         expected=[-1,0,1,-1,2,3,-1,-1,-1]
8195         self.assertEqual(4,newNbOfNodes);
8196         self.assertEqual(9,arr.getNbOfElems());
8197         self.assertEqual(expected,arr.getValues());
8198         arr2=arr.invertArrayO2N2N2O(newNbOfNodes);
8199         self.assertEqual(4,arr2.getNbOfElems());
8200         expected2=[1,2,4,5]
8201         self.assertEqual(expected2,arr2.getValues());
8202         pass
8203
8204     def testBuildDescendingConnec2(self):
8205         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
8206         #
8207         mesh2,desc,descIndx,revDesc,revDescIndx=mesh.buildDescendingConnectivity2();
8208         mesh2.checkCoherency();
8209         self.assertEqual(1,mesh2.getMeshDimension());
8210         self.assertEqual(13,mesh2.getNumberOfCells());
8211         self.assertEqual(14,revDescIndx.getNbOfElems()); self.assertEqual(14,revDescIndx.getNumberOfTuples());
8212         self.assertEqual(6,descIndx.getNbOfElems()); self.assertEqual(6,descIndx.getNumberOfTuples());
8213         self.assertEqual(18,desc.getNbOfElems()); self.assertEqual(18,desc.getNumberOfTuples());
8214         self.assertEqual(18,revDesc.getNbOfElems()); self.assertEqual(18,revDesc.getNumberOfTuples());
8215         expected1=[1,2,3,4,-3,5,6, 7,8,-5,9,10,-2,11, 12,13,-7,-10]
8216         self.assertEqual(expected1,desc.getValues());
8217         expected2=[0,4,7,10,14,18]
8218         self.assertEqual(expected2,descIndx.getValues());
8219         expected3=[0,1,3,5,6,8,9,11,12,13,15,16,17,18]
8220         self.assertEqual(expected3,revDescIndx.getValues());
8221         expected4=[0, 0,3, 0,1, 0, 1,2, 1, 2,4, 2, 3, 3,4, 3, 4, 4]
8222         self.assertEqual(expected4,revDesc.getValues());
8223         conn=mesh2.getNodalConnectivity();
8224         connIndex=mesh2.getNodalConnectivityIndex();
8225         expected5=[0,3,6,9,12,15,18,21,24,27,30,33,36,39]
8226         self.assertEqual(expected5,connIndex.getValues());
8227         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]
8228         self.assertEqual(expected6,conn.getValues());
8229         pass
8230
8231     def testIntersect2DMeshesTmp1(self):
8232         m1c=MEDCouplingCMesh.New();
8233         coordsX=DataArrayDouble.New();
8234         arrX=[ -1., 1., 2., 4. ]
8235         coordsX.setValues(arrX,4,1);
8236         m1c.setCoordsAt(0,coordsX);
8237         coordsY=DataArrayDouble.New();
8238         arrY=[ -2., 2., 4., 8. ]
8239         coordsY.setValues(arrY,4,1);
8240         m1c.setCoordsAt(1,coordsY);
8241         m1=m1c.buildUnstructured()
8242         m1bis=m1.buildPartOfMySelf([3,4,5],False)
8243         m2=m1.deepCpy()
8244         m2=m2.buildPartOfMySelf([0,1,2],False)
8245         m2.translate([0.5,0.5])
8246         #
8247         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m1bis,m2,1e-10)
8248         expected1=[0,0,1,1,1,2,2,2]
8249         expected2=[0,-1,0,1,-1,1,2,-1]
8250         self.assertEqual(8,d1.getNumberOfTuples());
8251         self.assertEqual(8,d2.getNumberOfTuples());
8252         self.assertEqual(8,m3.getNumberOfCells());
8253         self.assertEqual(22,m3.getNumberOfNodes());
8254         self.assertEqual(2,m3.getSpaceDimension());
8255         self.assertEqual(expected1,d1.getValues());
8256         self.assertEqual(expected2,d2.getValues());
8257         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]
8258         expected4=[0,5,12,17,22,28,33,38,44]
8259         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]
8260         self.assertEqual(44,m3.getNodalConnectivity().getNumberOfTuples());
8261         self.assertEqual(9,m3.getNodalConnectivityIndex().getNumberOfTuples());
8262         self.assertEqual(expected3,m3.getNodalConnectivity().getValues());
8263         self.assertEqual(expected4,m3.getNodalConnectivityIndex().getValues());
8264         for i in xrange(44):
8265             self.assertAlmostEqual(expected5[i],m3.getCoords().getIJ(0,i),12);
8266             pass
8267         pass
8268
8269     def testFindNodesOnLine1(self):
8270         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
8271         pt=[-0.3,-0.3]
8272         pt2=[0.,0.,0.]
8273         pt3=[-0.3,0.,0.]
8274         vec=[0.,1.]
8275         vec2=[1.,0.,0.]
8276         vec3=[0.,1.,1.]
8277         expected1=[0,3,6]
8278         res=mesh.findNodesOnLine(pt,vec,1e-12);
8279         self.assertEqual(3,len(res));
8280         self.assertEqual(expected1,res.getValues());
8281         #
8282         mesh.changeSpaceDimension(3);
8283         mesh.rotate(pt2,vec2,pi/4.);
8284         res=mesh.findNodesOnLine(pt3,vec3,1e-12);
8285         self.assertEqual(3,len(res));
8286         self.assertEqual(expected1,res.getValues());
8287         pass
8288
8289     def testIntersect2DMeshesTmp2(self):
8290         m1c=MEDCouplingCMesh.New();
8291         coordsX1=DataArrayDouble.New();
8292         arrX1=[ 0., 1., 1.5, 2. ]
8293         coordsX1.setValues(arrX1,4,1);
8294         m1c.setCoordsAt(0,coordsX1);
8295         coordsY1=DataArrayDouble.New();
8296         arrY1=[ 0., 1.5, 3.]
8297         coordsY1.setValues(arrY1,3,1);
8298         m1c.setCoordsAt(1,coordsY1);
8299         m1=m1c.buildUnstructured();
8300         m2c=MEDCouplingCMesh.New();
8301         coordsX2=DataArrayDouble.New();
8302         arrX2=[ 0., 1., 2. ]
8303         coordsX2.setValues(arrX2,3,1);
8304         m2c.setCoordsAt(0,coordsX2);
8305         coordsY2=DataArrayDouble.New();
8306         arrY2=[ 0., 1., 3.]
8307         coordsY2.setValues(arrY2,3,1);
8308         m2c.setCoordsAt(1,coordsY2);
8309         m2=m2c.buildUnstructured();
8310         #
8311         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m1,m2,1e-10)
8312         #
8313         expected1=[0,0,1,1,2,2,3,4,5]
8314         expected2=[0,2,1,3,1,3,2,3,3]
8315         self.assertEqual(9,d1.getNumberOfTuples());
8316         self.assertEqual(9,d2.getNumberOfTuples());
8317         self.assertEqual(9,m3.getNumberOfCells());
8318         self.assertEqual(22,m3.getNumberOfNodes());
8319         self.assertEqual(2,m3.getSpaceDimension());
8320         self.assertEqual(expected1,d1.getValues());
8321         self.assertEqual(expected2,d2.getValues());
8322         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]
8323         expected4=[0,5,10,15,20,25,30,35,40,45]
8324         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]
8325         self.assertEqual(45,m3.getNodalConnectivity().getNumberOfTuples());
8326         self.assertEqual(10,m3.getNodalConnectivityIndex().getNumberOfTuples());
8327         self.assertEqual(expected3,m3.getNodalConnectivity().getValues());
8328         self.assertEqual(expected4,m3.getNodalConnectivityIndex().getValues());
8329         for i in xrange(44):
8330             self.assertAlmostEqual(expected5[i],m3.getCoords().getIJ(0,i),12);
8331             pass
8332         pass
8333
8334     def testBuildPartOfMySelfSafe1(self):
8335         mesh=MEDCouplingDataForTest.build2DTargetMesh_1()
8336         self.assertRaises(InterpKernelException,mesh.buildPartOfMySelf,[0,-1,4,2],True)
8337         self.assertRaises(InterpKernelException,mesh.buildPartOfMySelf,[0,4,5,4],True)
8338         pass
8339
8340     def testIntersect2DMeshesTmp3(self):
8341         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];
8342         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];
8343         m1=MEDCouplingUMesh.New();
8344         m1.setMeshDimension(2);
8345         m1.allocateCells(8);
8346         m1.insertNextCell(NORM_TRI6,6,m1Conn[0:6]);
8347         m1.insertNextCell(NORM_QUAD8,8,m1Conn[6:14]);
8348         m1.insertNextCell(NORM_TRI6,6,m1Conn[14:20]);
8349         m1.insertNextCell(NORM_QUAD8,8,m1Conn[20:28]);
8350         m1.insertNextCell(NORM_TRI6,6,m1Conn[28:34]);
8351         m1.insertNextCell(NORM_QUAD8,8,m1Conn[34:42]);
8352         m1.insertNextCell(NORM_TRI6,6,m1Conn[42:48]);
8353         m1.insertNextCell(NORM_QUAD8,8,m1Conn[48:56]);
8354         m1.finishInsertingCells();
8355         myCoords1=DataArrayDouble.New();
8356         myCoords1.setValues(m1Coords,25,2);
8357         m1.setCoords(myCoords1);
8358         #
8359         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.]
8360         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]
8361         m2=MEDCouplingUMesh.New();
8362         m2.setMeshDimension(2);
8363         m2.allocateCells(8);
8364         for i in xrange(8):
8365             m2.insertNextCell(NORM_QUAD4,4,m2Conn[4*i:4*(i+1)])
8366             pass
8367         m2.finishInsertingCells();
8368         myCoords2=DataArrayDouble.New();
8369         myCoords2.setValues(m2Coords,15,2);
8370         m2.setCoords(myCoords2);
8371         #
8372         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m1,m2,1e-10)
8373         m3.unPolyze()
8374         #
8375         expected1=[0,1,1,1,2,3,3,3,4,5,5,5,6,7,7,7]
8376         expected2=[0,0,1,-1,2,2,3,-1,4,4,5,-1,6,6,7,-1]
8377         self.assertEqual(16,d1.getNumberOfTuples());
8378         self.assertEqual(16,d2.getNumberOfTuples());
8379         self.assertEqual(16,m3.getNumberOfCells());
8380         self.assertEqual(104,m3.getNumberOfNodes());
8381         self.assertEqual(2,m3.getSpaceDimension());
8382         self.assertEqual(expected1,d1.getValues());
8383         self.assertEqual(expected2,d2.getValues());
8384         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]
8385         expected4=[0,7,16,25,34,41,50,59,68,75,84,93,102,109,118,127,136]
8386         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]
8387         self.assertEqual(136,m3.getNodalConnectivity().getNumberOfTuples());
8388         self.assertEqual(17,m3.getNodalConnectivityIndex().getNumberOfTuples());
8389         self.assertEqual(expected3,m3.getNodalConnectivity().getValues());
8390         self.assertEqual(expected4,m3.getNodalConnectivityIndex().getValues());
8391         for i in xrange(208):
8392             self.assertAlmostEqual(expected5[i],m3.getCoords().getIJ(0,i),12);
8393             pass
8394         pass
8395
8396     def testUMeshTessellate2D1(self):
8397         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];
8398         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];
8399         m1=MEDCouplingUMesh.New();
8400         m1.setMeshDimension(2);
8401         m1.allocateCells(8);
8402         m1.insertNextCell(NORM_TRI6,6,m1Conn[0:6]);
8403         m1.insertNextCell(NORM_QUAD8,8,m1Conn[6:14]);
8404         m1.insertNextCell(NORM_TRI6,6,m1Conn[14:20]);
8405         m1.insertNextCell(NORM_QUAD8,8,m1Conn[20:28]);
8406         m1.insertNextCell(NORM_TRI6,6,m1Conn[28:34]);
8407         m1.insertNextCell(NORM_QUAD8,8,m1Conn[34:42]);
8408         m1.insertNextCell(NORM_TRI6,6,m1Conn[42:48]);
8409         m1.insertNextCell(NORM_QUAD8,8,m1Conn[48:56]);
8410         m1.finishInsertingCells();
8411         myCoords1=DataArrayDouble.New();
8412         myCoords1.setValues(m1Coords,25,2);
8413         m1.setCoords(myCoords1);
8414         #
8415         m11=m1.deepCpy();
8416         m11.tessellate2D(1.);
8417         self.assertTrue(m11.getCoords().isEqual(m11.getCoords(),1e-12));
8418         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]
8419         expected2=[0,5,12,17,24,29,36,41,48]
8420         self.assertEqual(48,m11.getNodalConnectivity().getNumberOfTuples());
8421         self.assertEqual(9,m11.getNodalConnectivityIndex().getNumberOfTuples());
8422         self.assertEqual(expected1,m11.getNodalConnectivity().getValues());
8423         self.assertEqual(expected2,m11.getNodalConnectivityIndex().getValues());
8424         #
8425         m12=m1.deepCpy();
8426         m12.tessellate2D(0.5);
8427         self.assertEqual(41,m12.getNumberOfNodes());
8428         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]
8429         expected4=[0,6,15,21,30,36,45,51,60]
8430         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]
8431         for i in xrange(82):
8432             self.assertAlmostEqual(expected5[i],m12.getCoords().getIJ(0,i),12);
8433             pass
8434         self.assertEqual(60,m12.getNodalConnectivity().getNumberOfTuples());
8435         self.assertEqual(9,m12.getNodalConnectivityIndex().getNumberOfTuples());
8436         self.assertEqual(expected3,m12.getNodalConnectivity().getValues());
8437         self.assertEqual(expected4,m12.getNodalConnectivityIndex().getValues());
8438         pass
8439
8440     def testIntersect2DMeshesTmp4(self):
8441         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];
8442         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];
8443         m1=MEDCouplingUMesh.New();
8444         m1.setMeshDimension(2);
8445         m1.allocateCells(8);
8446         m1.insertNextCell(NORM_TRI6,6,m1Conn[0:6]);
8447         m1.insertNextCell(NORM_QUAD8,8,m1Conn[6:14]);
8448         m1.insertNextCell(NORM_TRI6,6,m1Conn[14:20]);
8449         m1.insertNextCell(NORM_QUAD8,8,m1Conn[20:28]);
8450         m1.insertNextCell(NORM_TRI6,6,m1Conn[28:34]);
8451         m1.insertNextCell(NORM_QUAD8,8,m1Conn[34:42]);
8452         m1.insertNextCell(NORM_TRI6,6,m1Conn[42:48]);
8453         m1.insertNextCell(NORM_QUAD8,8,m1Conn[48:56]);
8454         m1.finishInsertingCells();
8455         myCoords1=DataArrayDouble.New();
8456         myCoords1.setValues(m1Coords,25,2);
8457         m1.setCoords(myCoords1);
8458         #
8459         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.]
8460         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]
8461         m2=MEDCouplingUMesh.New();
8462         m2.setMeshDimension(2);
8463         m2.allocateCells(8);
8464         for i in xrange(8):
8465             m2.insertNextCell(NORM_QUAD4,4,m2Conn[4*i:4*(i+1)])
8466             pass
8467         m2.finishInsertingCells();
8468         myCoords2=DataArrayDouble.New();
8469         myCoords2.setValues(m2Coords,15,2);
8470         m2.setCoords(myCoords2);
8471         #
8472         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m2,m1,1e-10)
8473         m3.unPolyze()
8474         #
8475         expected1=[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
8476         expected2=[0,1,1,-1,2,3,3,-1,4,5,5,-1,6,7,7,-1]
8477         self.assertEqual(16,d1.getNumberOfTuples());
8478         self.assertEqual(16,d2.getNumberOfTuples());
8479         self.assertEqual(16,m3.getNumberOfCells());
8480         self.assertEqual(104,m3.getNumberOfNodes());
8481         self.assertEqual(2,m3.getSpaceDimension());
8482         self.assertEqual(expected1,d1.getValues());
8483         self.assertEqual(expected2,d2.getValues());
8484         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]
8485         expected4=[0,7,16,25,34,41,50,59,68,75,84,93,102,109,118,127,136]
8486         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]
8487         self.assertEqual(136,m3.getNodalConnectivity().getNumberOfTuples());
8488         self.assertEqual(17,m3.getNodalConnectivityIndex().getNumberOfTuples());
8489         self.assertEqual(expected3,m3.getNodalConnectivity().getValues());
8490         self.assertEqual(expected4,m3.getNodalConnectivityIndex().getValues());
8491         for i in xrange(208):
8492             self.assertAlmostEqual(expected5[i],m3.getCoords().getIJ(0,i),12);
8493             pass
8494         pass
8495
8496     def testGetCellIdsCrossingPlane1(self):
8497         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
8498         vec=[-0.07,1.,0.07]
8499         origin=[1.524,1.4552,1.74768]
8500         ids1=mesh3D.getCellIdsCrossingPlane(origin,vec,1e-10)
8501         self.assertEqual([1,3,4,7,9,10,13,15,16],ids1.getValues())
8502         vec2=[0.,0.,1.]
8503         ids2=mesh3D.getCellIdsCrossingPlane(origin,vec2,1e-10)
8504         self.assertEqual([6,7,8,9,10,11],ids2.getValues())
8505         pass
8506
8507     def testBuildSlice3D1(self):
8508         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
8509         vec1=[-0.07,1.,0.07]
8510         origin1=[1.524,1.4552,1.74768]
8511         slice1,ids=mesh3D.buildSlice3D(origin1,vec1,1e-10);
8512         expected1=[1,3,4,7,9,10,13,15,16]
8513         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]
8514         expected3=[0,6,11,17,22,27,32,37,42,47]
8515         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.]
8516         self.assertEqual(2,slice1.getMeshDimension());
8517         self.assertEqual(3,slice1.getSpaceDimension());
8518         self.assertEqual(57,slice1.getNumberOfNodes());
8519         self.assertEqual(9,slice1.getNumberOfCells());
8520         self.assertEqual(9,ids.getNumberOfTuples());
8521         self.assertEqual(47,slice1.getNodalConnectivity().getNumberOfTuples());
8522         self.assertEqual(10,slice1.getNodalConnectivityIndex().getNumberOfTuples());
8523         self.assertEqual(expected1,ids.getValues());
8524         self.assertEqual(expected2,slice1.getNodalConnectivity().getValues());
8525         self.assertEqual(expected3,slice1.getNodalConnectivityIndex().getValues());
8526         for i in xrange(171):
8527             self.assertAlmostEqual(expected4[i],slice1.getCoords().getIJ(0,i),12);
8528             pass
8529         # 2nd slice based on already existing nodes of mesh3D.
8530         vec2=[0.,3.,1.]
8531         origin2=[2.5,1.,3.]
8532         slice1,ids=mesh3D.buildSlice3D(origin2,vec2,1e-10);
8533         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]
8534         expected6=[0,5,10,15,21,26,32,38,43,49]
8535         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]
8536         self.assertEqual(2,slice1.getMeshDimension());
8537         self.assertEqual(3,slice1.getSpaceDimension());
8538         self.assertEqual(60,slice1.getNumberOfNodes());
8539         self.assertEqual(9,slice1.getNumberOfCells());
8540         self.assertEqual(9,ids.getNumberOfTuples());
8541         self.assertEqual(49,slice1.getNodalConnectivity().getNumberOfTuples());
8542         self.assertEqual(10,slice1.getNodalConnectivityIndex().getNumberOfTuples());
8543         self.assertEqual(expected1,ids.getValues());
8544         self.assertEqual(expected5,slice1.getNodalConnectivity().getValues());
8545         self.assertEqual(expected6,slice1.getNodalConnectivityIndex().getValues());
8546         for i in xrange(180):
8547             self.assertAlmostEqual(expected7[i],slice1.getCoords().getIJ(0,i),12);
8548             pass
8549         # 3rd slice based on shared face of mesh3D.
8550         vec3=[0.,0.,1.]
8551         origin3=[2.5,1.,2.]
8552         slice1,ids=mesh3D.buildSlice3D(origin3,vec3,1e-10);
8553         expected8=[6,7,8,9,10,11,12,13,14,15,16,17]
8554         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]
8555         expected10=[0,5,12,17,22,29,34,39,46,51,56,63,68]
8556         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.]
8557         self.assertEqual(2,slice1.getMeshDimension());
8558         self.assertEqual(3,slice1.getSpaceDimension());
8559         self.assertEqual(45,slice1.getNumberOfNodes());
8560         self.assertEqual(12,slice1.getNumberOfCells());
8561         self.assertEqual(12,ids.getNumberOfTuples());
8562         self.assertEqual(68,slice1.getNodalConnectivity().getNumberOfTuples());
8563         self.assertEqual(13,slice1.getNodalConnectivityIndex().getNumberOfTuples());
8564         self.assertEqual(expected8,ids.getValues());
8565         self.assertEqual(expected9,slice1.getNodalConnectivity().getValues());
8566         self.assertEqual(expected10,slice1.getNodalConnectivityIndex().getValues());
8567         for i in xrange(135):
8568             self.assertAlmostEqual(expected11[i],slice1.getCoords().getIJ(0,i),12);
8569             pass
8570         pass
8571
8572     def testBuildSlice3DSurf1(self):
8573         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
8574         mesh2D=mesh3D.buildDescendingConnectivity()[0];
8575         vec1=[-0.07,1.,0.07]
8576         origin1=[1.524,1.4552,1.74768]
8577         slice1,ids=mesh2D.buildSlice3DSurf(origin1,vec1,1e-10);
8578         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]
8579         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]
8580         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];
8581         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.]
8582         self.assertEqual(1,slice1.getMeshDimension());
8583         self.assertEqual(3,slice1.getSpaceDimension());
8584         self.assertEqual(57,slice1.getNumberOfNodes());
8585         self.assertEqual(25,slice1.getNumberOfCells());
8586         self.assertEqual(25,ids.getNumberOfTuples());
8587         self.assertEqual(75,slice1.getNodalConnectivity().getNumberOfTuples());
8588         self.assertEqual(26,slice1.getNodalConnectivityIndex().getNumberOfTuples());
8589         self.assertEqual(expected1,ids.getValues());
8590         self.assertEqual(expected2,slice1.getNodalConnectivity().getValues());
8591         self.assertEqual(expected3,slice1.getNodalConnectivityIndex().getValues());
8592         for i in xrange(171):
8593             self.assertAlmostEqual(expected4[i],slice1.getCoords().getIJ(0,i),12);
8594             pass
8595         #
8596         vec2=[0.,0.,1.]
8597         origin2=[2.5,1.,2.]
8598         slice1,ids=mesh2D.buildSlice3DSurf(origin2,vec2,1e-10);
8599         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]
8600         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]
8601         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];
8602         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.]
8603         self.assertEqual(1,slice1.getMeshDimension());
8604         self.assertEqual(3,slice1.getSpaceDimension());
8605         self.assertEqual(45,slice1.getNumberOfNodes());
8606         self.assertEqual(68,slice1.getNumberOfCells());
8607         self.assertEqual(68,ids.getNumberOfTuples());
8608         self.assertEqual(204,slice1.getNodalConnectivity().getNumberOfTuples());
8609         self.assertEqual(69,slice1.getNodalConnectivityIndex().getNumberOfTuples());
8610         self.assertEqual(expected5,ids.getValues());
8611         self.assertEqual(expected6,slice1.getNodalConnectivity().getValues());
8612         self.assertEqual(expected7,slice1.getNodalConnectivityIndex().getValues());
8613         for i in xrange(135):
8614             self.assertAlmostEqual(expected8[i],slice1.getCoords().getIJ(0,i),12);
8615             pass
8616         pass
8617
8618     def testDataArrayDoubleAdvSetting1(self):
8619         data1=[1.,11.,2.,12.,3.,13.,4.,14.,5.,15.,6.,16.,7.,17.]
8620         data2=[8.,38.,9.,39.,0.,30.,11.,41.,12.,42.]
8621         compsCpp=["comp1","comp2"]
8622         da=DataArrayDouble.New();
8623         da.setInfoAndChangeNbOfCompo(compsCpp);
8624         da.setName("da");
8625         da.alloc(7,2);
8626         compsCpp=compsCpp[:-1]
8627         self.assertRaises(InterpKernelException,da.setInfoAndChangeNbOfCompo,compsCpp);
8628         da.setValues(data1,7,2)
8629         #
8630         p=[(0,3),(3,5),(5,7)]
8631         tmp=da.selectByTupleRanges(p);
8632         self.assertTrue(tmp.isEqual(da,1e-14));
8633         p=[(0,2),(3,4),(5,7)]
8634         tmp=da.selectByTupleRanges(p);
8635         expected1=[1.,11.,2.,12.,4.,14.,6.,16.,7.,17.]
8636         self.assertEqual(5,tmp.getNumberOfTuples());
8637         self.assertEqual(2,tmp.getNumberOfComponents());
8638         for i in xrange(10):
8639             self.assertAlmostEqual(expected1[i],tmp.getIJ(0,i),14);
8640             pass
8641         p=[(0,2),(0,2),(5,6)]
8642         tmp=da.selectByTupleRanges(p);
8643         expected2=[1.,11.,2.,12.,1.,11.,2.,12.,6.,16.]
8644         self.assertEqual(5,tmp.getNumberOfTuples());
8645         self.assertEqual(2,tmp.getNumberOfComponents());
8646         for i in xrange(10):
8647             self.assertAlmostEqual(expected2[i],tmp.getIJ(0,i),14);
8648             pass
8649         p=[(0,2),(-1,2),(5,6)]
8650         self.assertRaises(InterpKernelException,da.selectByTupleRanges,p);
8651         p=[(0,2),(0,2),(5,8)]
8652         self.assertRaises(InterpKernelException,da.selectByTupleRanges,p);
8653         #
8654         da2=DataArrayDouble.New();
8655         da2.setValues(data2,5,2);
8656         #
8657         dac=da.deepCpy();
8658         dac.setContigPartOfSelectedValues2(1,da2,2,4,1);
8659         expected3=[1.,11.,0.,30.,11.,41.,4.,14.,5.,15.,6.,16.,7.,17.]
8660         for i in xrange(14):
8661             self.assertAlmostEqual(expected3[i],dac.getIJ(0,i),14);
8662             pass
8663         #
8664         dac=da.deepCpy();
8665         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,3,da2,0,5,1);
8666         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,0,da2,4,6,1);
8667         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,3,da2,5,0,1);
8668         dac.setContigPartOfSelectedValues2(3,da2,1,5,1);
8669         expected4=[1.,11.,2.,12.,3.,13.,9.,39.,0.,30.,11.,41.,12.,42.]
8670         for i in xrange(14):
8671             self.assertAlmostEqual(expected4[i],dac.getIJ(0,i),14);
8672             pass
8673         #
8674         ids=DataArrayInt.New();
8675         ids.alloc(3,1);
8676         dac=da.deepCpy();
8677         ids.setIJ(0,0,2); ids.setIJ(1,0,0); ids.setIJ(2,0,4);
8678         dac.setContigPartOfSelectedValues(2,da2,ids);
8679         expected5=[1.,11.,2.,12.,0.,30.,8.,38.,12.,42.,6.,16.,7.,17.]
8680         for i in xrange(14):
8681             self.assertAlmostEqual(expected5[i],dac.getIJ(0,i),14);
8682             pass
8683         #
8684         dac=da.deepCpy();
8685         ids.setIJ(0,0,2); ids.setIJ(1,0,5); ids.setIJ(2,0,4);
8686         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,1,da2,ids);
8687         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,-1);
8688         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,1,da2,ids);
8689         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,1);
8690         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,5,da2,ids);
8691         #
8692         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,1);
8693         dac=da.deepCpy();
8694         dac.setContigPartOfSelectedValues(4,da2,ids);
8695         expected6=[1.,11.,2.,12.,3.,13.,4.,14.,0.,30.,0.,30.,9.,39.]
8696         for i in xrange(14):
8697             self.assertAlmostEqual(expected6[i],dac.getIJ(0,i),14);
8698             pass
8699         pass
8700
8701     def testDataArrayIntAdvSetting1(self):
8702         data1=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
8703         data2=[8,38,9,39,0,30,11,41,12,42]
8704         compsCpp=["comp1","comp2"]
8705         da=DataArrayInt.New();
8706         da.setInfoAndChangeNbOfCompo(compsCpp);
8707         da.setName("da");
8708         da.alloc(7,2);
8709         compsCpp=compsCpp[:-1]
8710         self.assertRaises(InterpKernelException,da.setInfoAndChangeNbOfCompo,compsCpp);
8711         da.setValues(data1,7,2)
8712         #
8713         p=[(0,3),(3,5),(5,7)]
8714         tmp=da.selectByTupleRanges(p);
8715         self.assertTrue(tmp.isEqual(da));
8716         p=[(0,2),(3,4),(5,7)]
8717         tmp=da.selectByTupleRanges(p);
8718         expected1=[1,11,2,12,4,14,6,16,7,17]
8719         self.assertEqual(5,tmp.getNumberOfTuples());
8720         self.assertEqual(2,tmp.getNumberOfComponents());
8721         for i in xrange(10):
8722             self.assertEqual(expected1[i],tmp.getIJ(0,i));
8723             pass
8724         p=[(0,2),(0,2),(5,6)]
8725         tmp=da.selectByTupleRanges(p);
8726         expected2=[1,11,2,12,1,11,2,12,6,16]
8727         self.assertEqual(5,tmp.getNumberOfTuples());
8728         self.assertEqual(2,tmp.getNumberOfComponents());
8729         for i in xrange(10):
8730             self.assertEqual(expected2[i],tmp.getIJ(0,i));
8731             pass
8732         p=[(0,2),(-1,2),(5,6)]
8733         self.assertRaises(InterpKernelException,da.selectByTupleRanges,p);
8734         p=[(0,2),(0,2),(5,8)]
8735         self.assertRaises(InterpKernelException,da.selectByTupleRanges,p);
8736         #
8737         da2=DataArrayInt.New();
8738         da2.setValues(data2,5,2);
8739         #
8740         dac=da.deepCpy();
8741         dac.setContigPartOfSelectedValues2(1,da2,2,4,1);
8742         expected3=[1,11,0,30,11,41,4,14,5,15,6,16,7,17]
8743         for i in xrange(14):
8744             self.assertEqual(expected3[i],dac.getIJ(0,i));
8745             pass
8746         #
8747         dac=da.deepCpy();
8748         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,3,da2,0,5,1);
8749         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,0,da2,4,6,1);
8750         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,3,da2,5,0,1);
8751         dac.setContigPartOfSelectedValues2(3,da2,1,5,1);
8752         expected4=[1,11,2,12,3,13,9,39,0,30,11,41,12,42]
8753         for i in xrange(14):
8754             self.assertEqual(expected4[i],dac.getIJ(0,i));
8755             pass
8756         #
8757         ids=DataArrayInt.New();
8758         ids.alloc(3,1);
8759         dac=da.deepCpy();
8760         ids.setIJ(0,0,2); ids.setIJ(1,0,0); ids.setIJ(2,0,4);
8761         dac.setContigPartOfSelectedValues(2,da2,ids);
8762         expected5=[1,11,2,12,0,30,8,38,12,42,6,16,7,17]
8763         for i in xrange(14):
8764             self.assertEqual(expected5[i],dac.getIJ(0,i));
8765             pass
8766         #
8767         dac=da.deepCpy();
8768         ids.setIJ(0,0,2); ids.setIJ(1,0,5); ids.setIJ(2,0,4);
8769         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,1,da2,ids);
8770         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,-1);
8771         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,1,da2,ids);
8772         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,1);
8773         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,5,da2,ids);
8774         #
8775         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,1);
8776         dac=da.deepCpy();
8777         dac.setContigPartOfSelectedValues(4,da2,ids);
8778         expected6=[1,11,2,12,3,13,4,14,0,30,0,30,9,39]
8779         for i in xrange(14):
8780             self.assertEqual(expected6[i],dac.getIJ(0,i));
8781             pass
8782         pass
8783
8784     def testBuildDescendingConnec2Of3DMesh1(self):
8785         mesh=MEDCouplingDataForTest.build3DSourceMesh_1();
8786         #
8787         mesh2,desc,descIndx,revDesc,revDescIndx=mesh.buildDescendingConnectivity2();
8788         mesh2.checkCoherency();
8789         self.assertEqual(2,mesh2.getMeshDimension());
8790         self.assertEqual(30,mesh2.getNumberOfCells());
8791         self.assertEqual(31,revDescIndx.getNbOfElems()); self.assertEqual(31,revDescIndx.getNumberOfTuples());
8792         self.assertEqual(13,descIndx.getNbOfElems()); self.assertEqual(13,descIndx.getNumberOfTuples());
8793         self.assertEqual(48,desc.getNbOfElems()); self.assertEqual(48,desc.getNumberOfTuples());
8794         self.assertEqual(48,revDesc.getNbOfElems()); self.assertEqual(48,revDesc.getNumberOfTuples());
8795         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]
8796         self.assertEqual(expected1,desc.getValues());
8797         expected2=[0,4,8,12,16,20,24,28,32,36,40,44,48]
8798         self.assertEqual(expected2,descIndx.getValues());
8799         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]
8800         self.assertEqual(expected3,revDescIndx.getValues());
8801         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]
8802         self.assertEqual(expected4,revDesc.getValues());
8803         conn=mesh2.getNodalConnectivity();
8804         connIndex=mesh2.getNodalConnectivityIndex();
8805         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]
8806         self.assertEqual(expected5,connIndex.getValues());
8807         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]
8808         self.assertEqual(expected6,conn.getValues());
8809         pass
8810
8811     def testAre2DCellsNotCorrectlyOriented1(self):
8812         m1Coords=[1.,1.,-1.,-1.,-1.,-1.,1.,-1.]
8813         m1Conn=[0,3,1,2]
8814         m1=MEDCouplingUMesh.New();
8815         m1.setMeshDimension(2);
8816         m1.allocateCells(1);
8817         m1.insertNextCell(NORM_QUAD4,4,m1Conn[0:4])
8818         m1.finishInsertingCells();
8819         myCoords1=DataArrayDouble.New();
8820         myCoords1.setValues(m1Coords,4,2);
8821         m1.setCoords(myCoords1);
8822         #
8823         vec1=[0.,0.,1.]
8824         for i in xrange(18):
8825             vec2=[3.*cos(pi/9.*i),3.*sin(pi/9.*i)];
8826             m1Cpy=m1.deepCpy();
8827             m1Cpy.translate(vec2);
8828             self.assertRaises(InterpKernelException,m1Cpy.are2DCellsNotCorrectlyOriented,vec1,False);
8829             m1Cpy.changeSpaceDimension(3);
8830             res=m1Cpy.are2DCellsNotCorrectlyOriented(vec1,False)
8831             self.assertEqual([0],res.getValues());
8832             pass
8833         pass
8834
8835     def testDataArrayAbs1(self):
8836         d1=DataArrayDouble.New();
8837         val1=[2.,-3.,-5.,6.,-7.,-8.,9.,10.,-11.,-12.,-13.,-15.]
8838         expected1=[2.,3.,5.,6.,7.,8.,9.,10.,11.,12.,13.,15.]
8839         d1.setValues(val1,6,2);
8840         d2=d1.convertToIntArr();
8841         #
8842         d1.abs();
8843         for i in xrange(12):
8844             self.assertAlmostEqual(expected1[i],d1.getIJ(0,i),14);
8845             pass
8846         #
8847         expected2=[2,3,5,6,7,8,9,10,11,12,13,15]
8848         d2.abs();
8849         for i in xrange(12):
8850             self.assertEqual(expected2[i],d2.getIJ(0,i));
8851             pass
8852         #
8853         pass
8854
8855     # test on 1D
8856     def testGetValueOn3(self):
8857         v=[0.,1.,1.5,2.]
8858         v2=[0.7,1.25,0.,2.,1.5]
8859         disp=[5.,50.,500.,6.,60.,600.,7.,70.,700.,8.,80.,800.]
8860         m=MEDCouplingUMesh.New("myMesh",1)
8861         nbNodes=len(v)
8862         nbCells=nbNodes-1
8863         m.allocateCells(nbCells)
8864         coords=DataArrayDouble.New() ; coords.setValues(v,nbNodes,1)
8865         m.setCoords(coords)
8866         m.insertNextCell(NORM_SEG2,2,[0,1])
8867         m.insertNextCell(NORM_SEG2,2,[2,1])
8868         m.insertNextCell(NORM_SEG2,2,[2,3])
8869         m.finishInsertingCells()
8870         f=MEDCouplingFieldDouble.New(ON_NODES)
8871         f.setMesh(m)
8872         array=DataArrayDouble.New(); array.setValues(disp,m.getNumberOfNodes(),3)
8873         f.setArray(array)
8874         arr1=f.getValueOnMulti(v2)
8875         self.assertEqual(5,arr1.getNumberOfTuples());
8876         self.assertEqual(3,arr1.getNumberOfComponents());
8877         expected1=[5.7,57.,570.,6.5,65.,650.,5.,50.,500.,8.,80.,800.,7.,70.,700.]
8878         for i in xrange(15):
8879             self.assertAlmostEqual(expected1[i],arr1.getIJ(0,i),14);
8880             pass
8881         pass
8882
8883     def testGetNodeIdsOfCell2(self):
8884         m1c=MEDCouplingCMesh.New();
8885         coordsX=DataArrayDouble.New();
8886         arrX=[ -1., 1., 2., 4., 4.5 ]
8887         coordsX.setValues(arrX,5,1);
8888         coordsY=DataArrayDouble.New();
8889         arrY=[ -2., 2., 4., 8.]
8890         coordsY.setValues(arrY,4,1);
8891         coordsZ=DataArrayDouble.New();
8892         arrZ=[ -2., 2., 4.]
8893         coordsZ.setValues(arrZ,3,1);
8894         # test in 1D
8895         m1c.setCoordsAt(0,coordsX);
8896         expected1=[[0,1],[1,2],[2,3],[3,4]]
8897         self.assertEqual(4,m1c.getNumberOfCells())
8898         for i in xrange(m1c.getNumberOfCells()):
8899             self.assertEqual(expected1[i],m1c.getNodeIdsOfCell(i))
8900             pass
8901         # test in 2D
8902         m1c.setCoordsAt(1,coordsY);
8903         self.assertEqual(12,m1c.getNumberOfCells())
8904         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]]
8905         for i in xrange(m1c.getNumberOfCells()):
8906             self.assertEqual(expected2[i],m1c.getNodeIdsOfCell(i))
8907             pass
8908         # test in 3D
8909         m1c.setCoordsAt(2,coordsZ);
8910         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]]
8911         self.assertEqual(24,m1c.getNumberOfCells())
8912         for i in xrange(m1c.getNumberOfCells()):
8913             self.assertEqual(expected3[i],m1c.getNodeIdsOfCell(i))
8914             pass
8915         pass
8916
8917     def testSwigDADOp4(self):
8918         da=DataArrayDouble.New(range(6,30),12,2)
8919         self.assertEqual(12,da.getNumberOfTuples());
8920         self.assertEqual(2,da.getNumberOfComponents());
8921         for i in xrange(24):
8922             self.assertAlmostEqual(da.getIJ(0,i),float(i+6),13)
8923             pass
8924         # operator transpose
8925         da.transpose()
8926         self.assertEqual(2,da.getNumberOfTuples());
8927         self.assertEqual(12,da.getNumberOfComponents());
8928         for i in xrange(24):
8929             self.assertAlmostEqual(da.getIJ(0,i),float(i+6),13)
8930             pass
8931         da.transpose()
8932         # operator __neg__
8933         da2=DataArrayDouble.New(12,1)
8934         da2.iota(0.)
8935         dabis=-da
8936         for i in xrange(24):
8937             self.assertAlmostEqual(dabis.getIJ(0,i),-float(i+6),13)
8938             pass
8939         # operator+=
8940         da+=da2
8941         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.]
8942         for i in xrange(24):
8943             self.assertAlmostEqual(da.getIJ(0,i),expected1[i],13)
8944             pass
8945         da=-dabis
8946         da+=[100.,101.]
8947         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.]
8948         self.assertEqual(12,da.getNumberOfTuples());
8949         self.assertEqual(2,da.getNumberOfComponents());
8950         for i in xrange(24):
8951             self.assertAlmostEqual(da.getIJ(0,i),expected2[i],13)
8952             pass
8953         for pos,elt in enumerate(dabis):
8954             da[pos]+=elt
8955             pass
8956         self.assertEqual(12,da.getNumberOfTuples());
8957         self.assertEqual(2,da.getNumberOfComponents());
8958         for elt in da:
8959             li=elt[:]
8960             self.assertAlmostEqual(li[0],100.,13) ; self.assertAlmostEqual(li[1],101.,13)
8961             pass
8962         # operator-=
8963         da=DataArrayDouble.New(range(6,30),12,2)
8964         da2=DataArrayDouble.New(range(12),12,1)
8965         dabis=-da
8966         da-=da2
8967         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.]
8968         for i in xrange(24):
8969             self.assertAlmostEqual(da.getIJ(0,i),expected1[i],13)
8970             pass
8971         da=-dabis
8972         da-=[100.,101.]
8973         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.]
8974         self.assertEqual(12,da.getNumberOfTuples());
8975         self.assertEqual(2,da.getNumberOfComponents());
8976         for i in xrange(24):
8977             self.assertAlmostEqual(da.getIJ(0,i),expected2[i],13)
8978             pass
8979         for pos,elt in enumerate(dabis):
8980             da[pos]-=elt
8981             pass
8982         self.assertEqual(12,da.getNumberOfTuples());
8983         self.assertEqual(2,da.getNumberOfComponents());
8984         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.]
8985         for i in xrange(24):
8986             self.assertAlmostEqual(da.getIJ(0,i),expected3[i],13)
8987             pass
8988         # operator*=
8989         da=DataArrayDouble.New(range(6,30),12,2)
8990         da2=DataArrayDouble.New(range(12),12,1)
8991         dabis=-da
8992         da*=da2
8993         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.]
8994         for i in xrange(24):
8995             self.assertAlmostEqual(da.getIJ(0,i),expected1[i],13)
8996             pass
8997         da=-dabis
8998         da*=[100.,101.]
8999         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.]
9000         self.assertEqual(12,da.getNumberOfTuples());
9001         self.assertEqual(2,da.getNumberOfComponents());
9002         for i in xrange(24):
9003             self.assertAlmostEqual(da.getIJ(0,i),expected2[i],13)
9004             pass
9005         for pos,elt in enumerate(dabis):
9006             da[pos]*=elt
9007             pass
9008         self.assertEqual(12,da.getNumberOfTuples());
9009         self.assertEqual(2,da.getNumberOfComponents());
9010         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]
9011         for i in xrange(24):
9012             self.assertAlmostEqual(da.getIJ(0,i),expected3[i],13)
9013             pass
9014         # operator/=
9015         da=DataArrayDouble.New(range(6,30),12,2)
9016         da2=DataArrayDouble.New(range(1,13),12,1)
9017         dabis=-da
9018         da/=da2
9019         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]
9020         for i in xrange(24):
9021             self.assertAlmostEqual(da.getIJ(0,i),expected1[i],13)
9022             pass
9023         da=-dabis
9024         da/=[100.,101.]
9025         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]
9026         self.assertEqual(12,da.getNumberOfTuples());
9027         self.assertEqual(2,da.getNumberOfComponents());
9028         for i in xrange(24):
9029             self.assertAlmostEqual(da.getIJ(0,i),expected2[i],13)
9030             pass
9031         for pos,elt in enumerate(dabis):
9032             da[pos]/=elt
9033             pass
9034         self.assertEqual(12,da.getNumberOfTuples());
9035         self.assertEqual(2,da.getNumberOfComponents());
9036         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]
9037         for i in xrange(24):
9038             self.assertAlmostEqual(da.getIJ(0,i),expected3[i],13)
9039             pass
9040         pass
9041
9042     def testSwigDAIOp4(self):
9043         da=DataArrayInt.New(range(6,30),12,2)
9044         self.assertEqual(12,da.getNumberOfTuples());
9045         self.assertEqual(2,da.getNumberOfComponents());
9046         for i in xrange(24):
9047             self.assertEqual(da.getIJ(0,i),i+6)
9048             pass
9049         # operator transpose
9050         da.transpose()
9051         self.assertEqual(2,da.getNumberOfTuples());
9052         self.assertEqual(12,da.getNumberOfComponents());
9053         for i in xrange(24):
9054             self.assertEqual(da.getIJ(0,i),i+6)
9055             pass
9056         da.transpose()
9057         # operator __neg__
9058         da2=DataArrayInt.New(12,1)
9059         da2.iota(0)
9060         dabis=-da
9061         for i in xrange(24):
9062             self.assertEqual(dabis.getIJ(0,i),-(i+6))
9063             pass
9064         # operator+=
9065         da+=da2
9066         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]
9067         for i in xrange(24):
9068             self.assertEqual(da.getIJ(0,i),expected1[i])
9069             pass
9070         da=-dabis
9071         da+=[100,101]
9072         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]
9073         self.assertEqual(12,da.getNumberOfTuples());
9074         self.assertEqual(2,da.getNumberOfComponents());
9075         for i in xrange(24):
9076             self.assertEqual(da.getIJ(0,i),expected2[i])
9077             pass
9078         for pos,elt in enumerate(dabis):
9079             da[pos]+=elt
9080             pass
9081         self.assertEqual(12,da.getNumberOfTuples());
9082         self.assertEqual(2,da.getNumberOfComponents());
9083         for elt in da:
9084             li=elt[:]
9085             self.assertEqual(li[0],100) ; self.assertEqual(li[1],101)
9086             pass
9087         # operator-=
9088         da=DataArrayInt.New(range(6,30),12,2)
9089         da2=DataArrayInt.New(range(12),12,1)
9090         dabis=-da
9091         da-=da2
9092         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]
9093         for i in xrange(24):
9094             self.assertEqual(da.getIJ(0,i),expected1[i])
9095             pass
9096         da=-dabis
9097         da-=[100,101]
9098         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]
9099         self.assertEqual(12,da.getNumberOfTuples());
9100         self.assertEqual(2,da.getNumberOfComponents());
9101         for i in xrange(24):
9102             self.assertEqual(da.getIJ(0,i),expected2[i])
9103             pass
9104         for pos,elt in enumerate(dabis):
9105             da[pos]-=elt
9106             pass
9107         self.assertEqual(12,da.getNumberOfTuples());
9108         self.assertEqual(2,da.getNumberOfComponents());
9109         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]
9110         for i in xrange(24):
9111             self.assertEqual(da.getIJ(0,i),expected3[i])
9112             pass
9113         # operator*=
9114         da=DataArrayInt.New(range(6,30),12,2)
9115         da2=DataArrayInt.New(range(12),12,1)
9116         dabis=-da
9117         da*=da2
9118         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]
9119         for i in xrange(24):
9120             self.assertEqual(da.getIJ(0,i),expected1[i])
9121             pass
9122         da=-dabis
9123         da*=[100,101]
9124         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]
9125         self.assertEqual(12,da.getNumberOfTuples());
9126         self.assertEqual(2,da.getNumberOfComponents());
9127         for i in xrange(24):
9128             self.assertEqual(da.getIJ(0,i),expected2[i])
9129             pass
9130         for pos,elt in enumerate(dabis):
9131             da[pos]*=elt
9132             pass
9133         self.assertEqual(12,da.getNumberOfTuples());
9134         self.assertEqual(2,da.getNumberOfComponents());
9135         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]
9136         for i in xrange(24):
9137             self.assertEqual(da.getIJ(0,i),expected3[i])
9138             pass
9139         # operator/=
9140         da=DataArrayInt.New(range(6,30),12,2)
9141         da2=DataArrayInt.New(range(1,13),12,1)
9142         dabis=-da
9143         da/=da2
9144         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]
9145         for i in xrange(24):
9146             self.assertEqual(da.getIJ(0,i),expected1[i])
9147             pass
9148         da=-dabis
9149         da/=DataArrayInt.New([2,3],1,2)
9150         self.assertEqual(12,da.getNumberOfTuples());
9151         self.assertEqual(2,da.getNumberOfComponents());
9152         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]
9153         for i in xrange(24):
9154             self.assertEqual(da.getIJ(0,i),expected2[i])
9155             pass
9156         pass
9157
9158     def testSwigDADOp5(self):
9159         da=DataArrayDouble.New([5,6,7,8,9,6,7,-2,3,9,8,10])
9160         da.rearrange(3)
9161         da2=DataArrayDouble.New([5.,8.,10.,12])
9162         self.assertEqual(4,da2.getNumberOfTuples());
9163         self.assertEqual(1,da2.getNumberOfComponents());
9164         da3=da+da2
9165         self.assertEqual(4,da3.getNumberOfTuples());
9166         self.assertEqual(3,da3.getNumberOfComponents());
9167         expected1=[10.,11.,12.,16.,17.,14.,17.,8.,13.,21.,20.,22.]
9168         for i in xrange(12):
9169             self.assertAlmostEqual(da3.getIJ(0,i),expected1[i],13)
9170             pass
9171         da3=da2+da
9172         self.assertEqual(4,da3.getNumberOfTuples());
9173         self.assertEqual(3,da3.getNumberOfComponents());
9174         for i in xrange(12):
9175             self.assertAlmostEqual(da3.getIJ(0,i),expected1[i],13)
9176             pass
9177         # Test new API of classmethod DataArrayDouble.New
9178         vals=[5,6,7,8,9,6,7,-2,3,9,8,10]
9179         da=DataArrayDouble.New(vals)
9180         self.assertEqual(12,da.getNumberOfTuples());
9181         self.assertEqual(1,da.getNumberOfComponents());
9182         for i in xrange(12):
9183             self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
9184             pass
9185         da=DataArrayDouble.New(vals,12)
9186         self.assertEqual(12,da.getNumberOfTuples());
9187         self.assertEqual(1,da.getNumberOfComponents());
9188         for i in xrange(12):
9189             self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
9190             pass
9191         da=DataArrayDouble.New(vals,1,12)
9192         self.assertEqual(1,da.getNumberOfTuples());
9193         self.assertEqual(12,da.getNumberOfComponents());
9194         for i in xrange(12):
9195             self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
9196             pass
9197         da=DataArrayDouble.New(vals,6,2)
9198         self.assertEqual(6,da.getNumberOfTuples());
9199         self.assertEqual(2,da.getNumberOfComponents());
9200         for i in xrange(12):
9201             self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
9202             pass
9203         da=DataArrayDouble.New(vals,4,3)
9204         self.assertEqual(4,da.getNumberOfTuples());
9205         self.assertEqual(3,da.getNumberOfComponents());
9206         for i in xrange(12):
9207             self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
9208             pass
9209         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,11);
9210         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,13);
9211         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,5,2);
9212         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,7,2);
9213         pass
9214
9215     def testSwigDADOp6(self):
9216         da=DataArrayInt.New([5,6,7,8,9,6,7,-2,3,9,8,10])
9217         da.rearrange(3)
9218         da2=DataArrayInt.New([5,8,10,12])
9219         self.assertEqual(4,da2.getNumberOfTuples());
9220         self.assertEqual(1,da2.getNumberOfComponents());
9221         da3=da+da2
9222         self.assertEqual(4,da3.getNumberOfTuples());
9223         self.assertEqual(3,da3.getNumberOfComponents());
9224         expected1=[10,11,12,16,17,14,17,8,13,21,20,22]
9225         for i in xrange(12):
9226             self.assertEqual(da3.getIJ(0,i),expected1[i])
9227             pass
9228         da3=da2+da
9229         self.assertEqual(4,da3.getNumberOfTuples());
9230         self.assertEqual(3,da3.getNumberOfComponents());
9231         for i in xrange(12):
9232             self.assertEqual(da3.getIJ(0,i),expected1[i])
9233             pass
9234         da3=da+DataArrayInt.New(da2.getValues())
9235         # Test new API of classmethod DataArrayInt.New
9236         vals=[5,6,7,8,9,6,7,-2,3,9,8,10]
9237         da=DataArrayDouble.New(vals)
9238         self.assertEqual(12,da.getNumberOfTuples());
9239         self.assertEqual(1,da.getNumberOfComponents());
9240         for i in xrange(12):
9241             self.assertEqual(da.getIJ(0,i),vals[i])
9242             pass
9243         da=DataArrayDouble.New(vals,12)
9244         self.assertEqual(12,da.getNumberOfTuples());
9245         self.assertEqual(1,da.getNumberOfComponents());
9246         for i in xrange(12):
9247             self.assertEqual(da.getIJ(0,i),vals[i])
9248             pass
9249         da=DataArrayDouble.New(vals,1,12)
9250         self.assertEqual(1,da.getNumberOfTuples());
9251         self.assertEqual(12,da.getNumberOfComponents());
9252         for i in xrange(12):
9253             self.assertEqual(da.getIJ(0,i),vals[i])
9254             pass
9255         da=DataArrayDouble.New(vals,6,2)
9256         self.assertEqual(6,da.getNumberOfTuples());
9257         self.assertEqual(2,da.getNumberOfComponents());
9258         for i in xrange(12):
9259             self.assertEqual(da.getIJ(0,i),vals[i])
9260             pass
9261         da=DataArrayDouble.New(vals,4,3)
9262         self.assertEqual(4,da.getNumberOfTuples());
9263         self.assertEqual(3,da.getNumberOfComponents());
9264         for i in xrange(12):
9265             self.assertEqual(da.getIJ(0,i),vals[i])
9266             pass
9267         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,11);
9268         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,13);
9269         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,5,2);
9270         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,7,2);
9271         pass
9272
9273     def testSwigDADOp9(self):
9274         l1=[(1.,2.,3),(4.,5.,6.),(7.,8.,9.),[10.,11.,12.]]
9275         da1=DataArrayDouble(l1,4,3)
9276         self.assertEqual(4,da1.getNumberOfTuples());
9277         self.assertEqual(3,da1.getNumberOfComponents());
9278         da2=DataArrayDouble(12) ; da2.iota(1.) ; da2.rearrange(3)
9279         self.assertTrue(da2.isEqual(da1,1e-12))
9280         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,3,4);
9281         da3=DataArrayDouble(l1,4)
9282         self.assertTrue(da3.isEqual(da1,1e-12))
9283         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,3);
9284         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,5);
9285         l1=[(1.,2.,3),(4.,(5.),((6.))),(7.,8.,9.),[10.,11.,12.]]
9286         da1=DataArrayDouble(l1,4,3)
9287         self.assertEqual(4,da1.getNumberOfTuples());
9288         self.assertEqual(3,da1.getNumberOfComponents());
9289         da2=DataArrayDouble(12) ; da2.iota(1.) ; da2.rearrange(3)
9290         self.assertTrue(da2.isEqual(da1,1e-12))
9291         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,3,4);
9292         da3=DataArrayDouble(l1,4)
9293         self.assertTrue(da3.isEqual(da1,1e-12))
9294         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,3);
9295         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,5);
9296         #
9297         l1=[(1,2,3),(4,5,6),(7,8,9),[10,11,12]]
9298         da1=DataArrayInt(l1,4,3)
9299         self.assertEqual(4,da1.getNumberOfTuples());
9300         self.assertEqual(3,da1.getNumberOfComponents());
9301         da2=DataArrayInt(12) ; da2.iota(1) ; da2.rearrange(3)
9302         self.assertTrue(da2.isEqual(da1))
9303         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,3,4);
9304         da3=DataArrayInt(l1,4)
9305         self.assertTrue(da3.isEqual(da1))
9306         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,3);
9307         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,5);
9308         l1=[(1,[2],3),(4,[(5)],6),((([7])),8,9),[10,11,12]]
9309         da1=DataArrayInt(l1,4,3)
9310         self.assertEqual(4,da1.getNumberOfTuples());
9311         self.assertEqual(3,da1.getNumberOfComponents());
9312         da2=DataArrayInt(12) ; da2.iota(1) ; da2.rearrange(3)
9313         self.assertTrue(da2.isEqual(da1))
9314         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,3,4);
9315         da3=DataArrayInt(l1,4)
9316         self.assertTrue(da3.isEqual(da1))
9317         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,3);
9318         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,5);
9319         pass
9320
9321     def testRenumberNodesInConn1(self):
9322         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. ]
9323         mesh2DConn=[1,4,2, 4,5,2, 0,3,4,1, 6,7,4,3, 7,8,5,4]
9324         mesh2D=MEDCouplingUMesh.New("mesh",2);
9325         mesh2D.allocateCells(5);
9326         mesh2D.insertNextCell(NORM_TRI3,3,mesh2DConn[0:3])
9327         mesh2D.insertNextCell(NORM_TRI3,3,mesh2DConn[3:6])
9328         mesh2D.insertNextCell(NORM_QUAD4,4,mesh2DConn[6:10])
9329         mesh2D.insertNextCell(NORM_QUAD4,4,mesh2DConn[10:14])
9330         mesh2D.insertNextCell(NORM_QUAD4,4,mesh2DConn[14:18])
9331         mesh2D.finishInsertingCells();
9332         myCoords=DataArrayDouble.New(mesh2DCoords,9,3);
9333         mesh2D.setCoords(myCoords);
9334         mesh2D.checkCoherency();
9335         #
9336         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. ]
9337         mesh3DConn=[0,1,2,3,4,5,6,7]
9338         mesh3D=MEDCouplingUMesh.New("mesh",3);
9339         mesh3D.allocateCells(1);
9340         mesh3D.insertNextCell(NORM_HEXA8,8,mesh3DConn[:])
9341         mesh3D.finishInsertingCells();
9342         myCoords3D=DataArrayDouble.New(mesh3DCoords,8,3);
9343         mesh3D.setCoords(myCoords3D);
9344         mesh3D.checkCoherency();
9345         #
9346         mesh3D_2=mesh3D.deepCpy();
9347         mesh2D_2=mesh2D.deepCpy();
9348         mesh3D_4=mesh3D.deepCpy();
9349         mesh2D_4=mesh2D.deepCpy();
9350         oldNbOf3DNodes=mesh3D.getNumberOfNodes();
9351         renumNodes=DataArrayInt.New();
9352         renumNodes.alloc(mesh2D.getNumberOfNodes(),1);
9353         renumNodes.iota(oldNbOf3DNodes);
9354         coo=DataArrayDouble.Aggregate(mesh3D.getCoords(),mesh2D.getCoords());
9355         mesh3D.setCoords(coo);
9356         mesh2D.setCoords(coo);
9357         mesh2DCpy=mesh2D.deepCpy()
9358         mesh2D_3=mesh2D.deepCpy();
9359         mesh2D_3.shiftNodeNumbersInConn(oldNbOf3DNodes);
9360         mesh2D.renumberNodesInConn(renumNodes);
9361         mesh2DCpy.renumberNodesInConn(renumNodes.getValues());
9362         self.assertTrue(mesh2D.isEqual(mesh2DCpy,1e-12))
9363         self.assertTrue(mesh2D.isEqual(mesh2D_3,1e-12))
9364         #
9365         da1,da2=mesh3D.checkGeoEquivalWith(mesh3D_2,10,1e-12);
9366         self.assertTrue(da1==None);
9367         self.assertEqual(8,da2.getNumberOfTuples());
9368         self.assertEqual(1,da2.getNumberOfComponents());
9369         expected1=[8,11,12,9,4,5,6,7]
9370         for i in xrange(8):
9371             self.assertEqual(expected1[i],da2.getIJ(i,0));
9372             pass
9373         #
9374         da1,da2=mesh2D.checkGeoEquivalWith(mesh2D_2,10,1e-12);
9375         self.assertTrue(da1==None);
9376         self.assertEqual(9,da2.getNumberOfTuples());
9377         self.assertEqual(1,da2.getNumberOfComponents());
9378         for i in xrange(9):
9379             self.assertEqual(8+i,da2.getIJ(i,0));
9380             pass
9381         #
9382         mesh2D_5=mesh2D_4.deepCpy();
9383         mesh2D_5.translate([1.,0.,0.]);
9384         meshes=[mesh3D_4,mesh2D_4,mesh2D_5];
9385         MEDCouplingUMesh.PutUMeshesOnSameAggregatedCoords(meshes);
9386         self.assertTrue(mesh3D_4.getCoords().getHiddenCppPointer()==mesh2D_4.getCoords().getHiddenCppPointer());
9387         self.assertTrue(mesh2D_4.getCoords().getHiddenCppPointer()==mesh2D_5.getCoords().getHiddenCppPointer());
9388         mesh3D_4.checkCoherency(); mesh2D_4.checkCoherency(); mesh2D_5.checkCoherency();
9389         self.assertEqual(26,mesh3D_4.getNumberOfNodes());
9390         self.assertEqual(3,mesh3D_4.getSpaceDimension());
9391         self.assertEqual(9,mesh3D_4.getNodalConnectivity().getNumberOfTuples());
9392         self.assertEqual(23,mesh2D_4.getNodalConnectivity().getNumberOfTuples());
9393         self.assertEqual(23,mesh2D_5.getNodalConnectivity().getNumberOfTuples());
9394         expected2=[18,0,1,2,3,4,5,6,7]
9395         expected3=[3,9,12,10, 3,12,13,10, 4,8,11,12,9, 4,14,15,12,11, 4,15,16,13,12]
9396         expected4=[3,18,21,19, 3,21,22,19, 4,17,20,21,18, 4,23,24,21,20, 4,24,25,22,21]
9397         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]
9398         self.assertEqual(expected2,mesh3D_4.getNodalConnectivity().getValues());
9399         self.assertEqual(expected3,mesh2D_4.getNodalConnectivity().getValues());
9400         self.assertEqual(expected4,mesh2D_5.getNodalConnectivity().getValues());
9401         for i in xrange(78):
9402             self.assertAlmostEqual(expected5[i],mesh3D_4.getCoords().getIJ(0,i),12);
9403             pass
9404         #
9405         MEDCouplingUMesh.MergeNodesOnUMeshesSharingSameCoords(meshes,1e-12);
9406         mesh3D_4.checkCoherency(); mesh2D_4.checkCoherency(); mesh2D_5.checkCoherency();
9407         self.assertTrue(mesh3D_4.getCoords().getHiddenCppPointer()==mesh2D_4.getCoords().getHiddenCppPointer());
9408         self.assertTrue(mesh2D_4.getCoords().getHiddenCppPointer()==mesh2D_5.getCoords().getHiddenCppPointer());
9409         self.assertEqual(19,mesh3D_4.getNumberOfNodes());
9410         self.assertEqual(3,mesh3D_4.getSpaceDimension());
9411         self.assertEqual(9,mesh3D_4.getNodalConnectivity().getNumberOfTuples());
9412         self.assertEqual(23,mesh2D_4.getNodalConnectivity().getNumberOfTuples());
9413         self.assertEqual(23,mesh2D_5.getNodalConnectivity().getNumberOfTuples());
9414         expected6=[18,0,1,2,3,4,5,6,7]
9415         expected7=[3,3,2,8, 3,2,9,8, 4,0,1,2,3, 4,10,11,2,1, 4,11,12,9,2]
9416         expected8=[3,13,15,14, 3,15,16,14, 4,8,9,15,13, 4,12,17,15,9, 4,17,18,16,15]
9417         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.,
9418                     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.,
9419                     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.]
9420         self.assertEqual(expected6,mesh3D_4.getNodalConnectivity().getValues());
9421         self.assertEqual(expected7,mesh2D_4.getNodalConnectivity().getValues());
9422         self.assertEqual(expected8,mesh2D_5.getNodalConnectivity().getValues());
9423         for i in xrange(57):
9424             self.assertAlmostEqual(expected9[i],mesh3D_4.getCoords().getIJ(0,i),12);
9425             pass
9426         #
9427         pass
9428
9429     def testComputeNeighborsOfCells1(self):
9430         m=MEDCouplingDataForTest.build2DTargetMesh_1();
9431         d1,d2=m.computeNeighborsOfCells();
9432         self.assertEqual(6,d2.getNumberOfTuples());
9433         self.assertEqual(10,d1.getNumberOfTuples());
9434         expected1=[0,2,4,6,8,10]
9435         expected2=[3,1,0,2,4,1,4,0,2,3]
9436         self.assertEqual(expected1,d2.getValues());
9437         self.assertEqual(expected2,d1.getValues());
9438         pass
9439
9440     def testCheckButterflyCellsBug1(self):
9441         mesh2DCoords=[323.85,120.983748908684,317.5,131.982271536747,336.55,120.983748908686,330.2,131.982271536751,323.85,142.98079416481]
9442         mesh2DConn=[4,1,0,2,3]
9443         mesh2D=MEDCouplingUMesh.New("mesh",2);
9444         mesh2D.allocateCells(1);
9445         mesh2D.insertNextCell(NORM_POLYGON,5,mesh2DConn[0:5])
9446         mesh2D.finishInsertingCells();
9447         myCoords=DataArrayDouble.New(mesh2DCoords,5,2);
9448         mesh2D.setCoords(myCoords);
9449         mesh2D.checkCoherency();
9450         #
9451         v=mesh2D.checkButterflyCells();
9452         self.assertTrue(v.empty());
9453         pass
9454
9455     def testDataArrayIntRange1(self):
9456         d=DataArrayInt.Range(2,17,7);
9457         expected1=[2,9,16]
9458         self.assertEqual(3,d.getNumberOfTuples());
9459         self.assertEqual(1,d.getNumberOfComponents());
9460         self.assertEqual(expected1,d.getValues());
9461         #
9462         d=DataArrayInt.Range(2,23,7);
9463         self.assertEqual(3,d.getNumberOfTuples());
9464         self.assertEqual(1,d.getNumberOfComponents());
9465         self.assertEqual(expected1,d.getValues());
9466         #
9467         d=DataArrayInt.Range(2,24,7);
9468         expected2=[2,9,16,23]
9469         self.assertEqual(4,d.getNumberOfTuples());
9470         self.assertEqual(1,d.getNumberOfComponents());
9471         self.assertEqual(expected2,d.getValues());
9472         #
9473         d=DataArrayInt.Range(24,2,-7);
9474         expected3=[24,17,10,3]
9475         self.assertEqual(4,d.getNumberOfTuples());
9476         self.assertEqual(1,d.getNumberOfComponents());
9477         self.assertEqual(expected3,d.getValues());
9478         #
9479         d=DataArrayInt.Range(23,2,-7);
9480         expected4=[23,16,9]
9481         self.assertEqual(3,d.getNumberOfTuples());
9482         self.assertEqual(1,d.getNumberOfComponents());
9483         self.assertEqual(expected4,d.getValues());
9484         #
9485         d=DataArrayInt.Range(23,22,-7);
9486         self.assertEqual(1,d.getNumberOfTuples());
9487         self.assertEqual(1,d.getNumberOfComponents());
9488         self.assertEqual(23,d.getIJ(0,0));
9489         #
9490         d=DataArrayInt.Range(22,23,7);
9491         self.assertEqual(1,d.getNumberOfTuples());
9492         self.assertEqual(1,d.getNumberOfComponents());
9493         self.assertEqual(22,d.getIJ(0,0));
9494         #
9495         d=DataArrayInt.Range(22,22,7);
9496         self.assertEqual(0,d.getNumberOfTuples());
9497         self.assertEqual(1,d.getNumberOfComponents());
9498         #
9499         d=DataArrayInt.Range(22,22,-7);
9500         self.assertEqual(0,d.getNumberOfTuples());
9501         self.assertEqual(1,d.getNumberOfComponents());
9502         #
9503         self.assertRaises(InterpKernelException,DataArrayInt.Range,22,23,-7);
9504         self.assertRaises(InterpKernelException,DataArrayInt.Range,23,22,7);
9505         self.assertRaises(InterpKernelException,DataArrayInt.Range,23,22,0);
9506         self.assertRaises(InterpKernelException,DataArrayInt.Range,22,23,0);
9507         pass
9508
9509     def testSwigUMeshGetItem1(self):
9510         m=MEDCouplingDataForTest.build2DTargetMesh_1();
9511         subMesh=m.buildPartOfMySelf([1,3],True);
9512         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
9513         m1=m[[1,3]]
9514         self.assertTrue(isinstance(m1,MEDCouplingUMesh))
9515         m2=m[(1,3)]
9516         self.assertTrue(isinstance(m2,MEDCouplingUMesh))
9517         m3=m[1::2]
9518         self.assertTrue(isinstance(m3,MEDCouplingUMesh))
9519         m4=m[DataArrayInt.New([1,3])]
9520         m5_1=m[1]
9521         self.assertTrue(isinstance(m5_1,MEDCouplingUMesh))
9522         m5_2=m[3]
9523         self.assertTrue(isinstance(m5_2,MEDCouplingUMesh))
9524         m5=MEDCouplingUMesh.MergeUMeshesOnSameCoords([m5_1,m5_2]);
9525         m5.setName(subMesh.getName())
9526         self.assertTrue(isinstance(m4,MEDCouplingUMesh))
9527         self.assertTrue(subMesh.isEqual(m1,1e-12))
9528         self.assertTrue(subMesh.isEqual(m2,1e-12))
9529         self.assertTrue(subMesh.isEqual(m3,1e-12))
9530         self.assertTrue(subMesh.isEqual(m4,1e-12))
9531         self.assertTrue(subMesh.isEqual(m5,1e-12))
9532         self.assertRaises(InterpKernelException,m.buildPartOfMySelf,[1,5],True);
9533         pass
9534
9535     def testSwigGetItem3(self):
9536         da=DataArrayInt.New([4,5,6])
9537         self.assertEqual(5,da[1])
9538         self.assertRaises(InterpKernelException,da.__getitem__,-1)
9539         self.assertRaises(InterpKernelException,da.__getitem__,3)
9540         da=DataArrayInt.New([4,5,6,7,8,9],2,3)
9541         self.assertEqual(9,da[1,2])
9542         da=DataArrayDouble.New([4.1,5.2,6.3])
9543         self.assertAlmostEqual(5.2,da[1],12)
9544         self.assertRaises(InterpKernelException,da.__getitem__,-1)
9545         self.assertRaises(InterpKernelException,da.__getitem__,3)
9546         da=DataArrayDouble.New([4.12,5.12,6.12,7.12,8.12,9.12],2,3)
9547         self.assertAlmostEqual(9.12,da[1,2],12)
9548         pass
9549
9550     def testSwigDADISub1(self):
9551         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
9552         bary=mesh3D.getBarycenterAndOwner()
9553         bary=bary[:,:2]
9554         pts=bary.getDifferentValues(1e-12)
9555         expected=[[0,6,12],[1,7,13],[2,8,14],[3,9,15],[4,10,16],[5,11,17]]
9556         for pos,pt in enumerate(pts):
9557             bary2=bary[:,:2]
9558             bary2[:]-=pt
9559             norm=bary2.magnitude()
9560             self.assertEqual(expected[pos],norm.getIdsInRange(-1.,1e-5).getValues())
9561             pass
9562         expected2=[[3.,54.],[-141.,180.],[21.,54.],[39.,72.],[-15.,90.],[21.,90.]]
9563         for pos,pt in enumerate(pts):
9564             bary2=bary[:,:2]
9565             bary2[:]+=pt
9566             self.assertAlmostEqual(expected2[pos][0],bary2.accumulate()[0],12);
9567             self.assertAlmostEqual(expected2[pos][1],bary2.accumulate()[1],12);
9568             pass
9569         expected3=[[-3.,22.5],[45.,337.5],[-9., 22.5],[-15.,67.5],[3.,112.5],[-9.,112.5]]
9570         for pos,pt in enumerate(pts):
9571             bary2=bary[:,:2]
9572             bary2[:]*=pt
9573             self.assertAlmostEqual(expected3[pos][0],bary2.accumulate()[0],12);
9574             self.assertAlmostEqual(expected3[pos][1],bary2.accumulate()[1],12);
9575             pass
9576         expected4=[[-12.,90.],[0.8,6.],[-4,90.],[-2.4,30.],[12.,18],[-4,18.]]
9577         for pos,pt in enumerate(pts):
9578             bary2=bary[:,:2]
9579             bary2[:]/=pt
9580             self.assertAlmostEqual(expected4[pos][0],bary2.accumulate()[0],12);
9581             self.assertAlmostEqual(expected4[pos][1],bary2.accumulate()[1],12);
9582             pass
9583         #
9584         d=DataArrayInt.New([1,2,0,1,0,2],3,2)
9585         e=DataArrayInt.New([1,11,101,2,12,102,3,13,103,4,14,104],4,3)
9586         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]]
9587         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]]
9588         for pos,tup in enumerate(d):
9589             f=e[:]
9590             self.assertTrue(isinstance(f,DataArrayInt))
9591             f[tup]=77
9592             self.assertEqual(expected5[pos],f.getValues())
9593             self.assertEqual(6*[77],f[tup].getValues())
9594             f=e[:]
9595             f[:,tup]=77
9596             self.assertEqual(expected6[pos],f.getValues())
9597             self.assertEqual(8*[77],f[:,tup].getValues())
9598             pass
9599         #
9600         e=e.convertToDblArr()
9601         for pos,tup in enumerate(d):
9602             f=e[:]
9603             self.assertTrue(isinstance(f,DataArrayDouble))
9604             f[tup]=77.
9605             self.assertEqual(expected5[pos],f.convertToIntArr().getValues())
9606             self.assertEqual(6*[77],f[tup].convertToIntArr().getValues())
9607             f=e[:]
9608             f[:,tup]=77.
9609             self.assertEqual(expected6[pos],f.convertToIntArr().getValues())
9610             self.assertEqual(8*[77],f[:,tup].convertToIntArr().getValues())
9611             pass
9612         pass
9613
9614     def testDataArrayDoubleGetMinMaxPerComponent1(self):
9615         values1=[1.,2.,3.,-0.9,2.1,3.,1.3,1.7,3.,1.,1.8,3.]
9616         d1=DataArrayDouble.New();
9617         self.assertRaises(InterpKernelException,d1.getMinMaxPerComponent)
9618         d1=DataArrayDouble.New(values1,4,3);
9619         res=d1.getMinMaxPerComponent();
9620         self.assertTrue(isinstance(res,list))
9621         self.assertEqual(3,len(res))
9622         for i in xrange(3):
9623             self.assertTrue(isinstance(res[i],tuple))
9624             self.assertEqual(2,len(res[i]))
9625             pass
9626         expected1=[-0.9,1.3,1.7,2.1,3.,3.]
9627         for i in xrange(6):
9628             self.assertAlmostEqual(expected1[i],res[i/2][i%2],14)
9629             pass
9630         #
9631         d1.rearrange(2);
9632         res=d1.getMinMaxPerComponent();
9633         self.assertTrue(isinstance(res,list))
9634         self.assertEqual(2,len(res))
9635         for i in xrange(2):
9636             self.assertTrue(isinstance(res[i],tuple))
9637             self.assertEqual(2,len(res[i]))
9638             pass
9639         expected2=[1.,3.,-0.9,3.]
9640         for i in xrange(4):
9641             self.assertAlmostEqual(expected2[i],res[i/2][i%2],14)
9642             pass
9643         #
9644         d1.rearrange(1);
9645         res=d1.getMinMaxPerComponent();
9646         self.assertTrue(isinstance(res,list))
9647         self.assertEqual(1,len(res))
9648         for i in xrange(1):
9649             self.assertTrue(isinstance(res[i],tuple))
9650             self.assertEqual(2,len(res[i]))
9651             pass
9652         expected3=[-0.9,3.]
9653         for i in xrange(2):
9654             self.assertAlmostEqual(expected3[i],res[i/2][i%2],14)
9655             pass
9656         pass
9657
9658     def testDataArrayIntGetHashCode1(self):
9659         d1=DataArrayInt.New(range(3545))
9660         d2=DataArrayInt.New(range(3545))
9661         self.assertEqual(d2.getHashCode(),d1.getHashCode())
9662         self.assertEqual(232341068,d1.getHashCode())
9663         d1[886]=6
9664         self.assertEqual(232340188,d1.getHashCode())
9665         pass
9666
9667     def testZipConnectivityPol1(self):
9668         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
9669         cells1=[2,3,4]
9670         m2_1=m1.buildPartOfMySelf(cells1,True);
9671         m2=m2_1
9672         self.assertTrue(isinstance(m2,MEDCouplingUMesh))
9673         # no permutation policy 0
9674         isOk,arr=m1.areCellsIncludedIn(m2,0)
9675         self.assertTrue(isOk);
9676         self.assertEqual(3,arr.getNumberOfTuples());
9677         self.assertEqual(1,arr.getNumberOfComponents());
9678         self.assertEqual(cells1,arr.getValues())
9679         # no permutation policy 1
9680         isOk,arr=m1.areCellsIncludedIn(m2,1)
9681         self.assertTrue(isOk);
9682         self.assertEqual(3,arr.getNumberOfTuples());
9683         self.assertEqual(1,arr.getNumberOfComponents());
9684         self.assertEqual(cells1,arr.getValues())
9685         # no permutation policy 2
9686         isOk,arr=m1.areCellsIncludedIn(m2,2)
9687         self.assertTrue(isOk);
9688         self.assertEqual(3,arr.getNumberOfTuples());
9689         self.assertEqual(1,arr.getNumberOfComponents());
9690         self.assertEqual(cells1,arr.getValues())
9691         # some modification into m2
9692         modif1=[2,4,5]
9693         m2.getNodalConnectivity()[1:4]=modif1
9694         #policy 0 fails because cell0 in m2 has same orientation be not same connectivity
9695         expected1=[5,3,4]
9696         isOk,arr=m1.areCellsIncludedIn(m2,0)
9697         self.assertTrue(not isOk);
9698         self.assertEqual(3,arr.getNumberOfTuples());
9699         self.assertEqual(1,arr.getNumberOfComponents());
9700         self.assertEqual(expected1,arr.getValues())
9701         #policy 1 succeeds because cell0 in m2 has not exactly the same conn
9702         isOk,arr=m1.areCellsIncludedIn(m2,1)
9703         self.assertTrue(isOk);
9704         self.assertEqual(3,arr.getNumberOfTuples());
9705         self.assertEqual(1,arr.getNumberOfComponents());
9706         self.assertEqual(cells1,arr.getValues())
9707         #policy 2 succeeds because cell0 in m2 has same nodes in connectivity
9708         isOk,arr=m1.areCellsIncludedIn(m2,2)
9709         self.assertTrue(isOk);
9710         self.assertEqual(3,arr.getNumberOfTuples());
9711         self.assertEqual(1,arr.getNumberOfComponents());
9712         self.assertEqual(cells1,arr.getValues())
9713         #some new modification into m2
9714         modif2=[2,5,4]
9715         m2.getNodalConnectivity()[1:4]=modif2
9716         #policy 0 fails because cell0 in m2 has not exactly the same conn
9717         isOk,arr=m1.areCellsIncludedIn(m2,0)
9718         self.assertTrue(not isOk);
9719         self.assertEqual(3,arr.getNumberOfTuples());
9720         self.assertEqual(1,arr.getNumberOfComponents());
9721         self.assertEqual(expected1,arr.getValues())
9722         #policy 1 fails too because cell0 in m2 has not same orientation
9723         isOk,arr=m1.areCellsIncludedIn(m2,1)
9724         self.assertTrue(not isOk);
9725         self.assertEqual(3,arr.getNumberOfTuples());
9726         self.assertEqual(1,arr.getNumberOfComponents());
9727         self.assertEqual(expected1,arr.getValues())
9728         #policy 2 succeeds because cell0 in m2 has same nodes in connectivity
9729         isOk,arr=m1.areCellsIncludedIn(m2,2)
9730         self.assertTrue(isOk);
9731         self.assertEqual(3,arr.getNumberOfTuples());
9732         self.assertEqual(1,arr.getNumberOfComponents());
9733         self.assertEqual(cells1,arr.getValues())
9734         # Now 1D
9735         cells2=[3,2]
9736         m1=MEDCouplingDataForTest.build1DSourceMesh_2();
9737         m2_1=m1.buildPartOfMySelf(cells2,True);
9738         m2=m2_1
9739         self.assertTrue(isinstance(m2,MEDCouplingUMesh))
9740         # no permutation policy 0
9741         isOk,arr=m1.areCellsIncludedIn(m2,0)
9742         self.assertTrue(isOk);
9743         self.assertEqual(2,arr.getNumberOfTuples());
9744         self.assertEqual(1,arr.getNumberOfComponents());
9745         self.assertEqual(cells2,arr.getValues())
9746         # no permutation policy 1
9747         isOk,arr=m1.areCellsIncludedIn(m2,1)
9748         self.assertTrue(isOk);
9749         self.assertEqual(2,arr.getNumberOfTuples());
9750         self.assertEqual(1,arr.getNumberOfComponents());
9751         self.assertEqual(cells2,arr.getValues())
9752         # no permutation policy 2
9753         isOk,arr=m1.areCellsIncludedIn(m2,2)
9754         self.assertTrue(isOk);
9755         self.assertEqual(2,arr.getNumberOfTuples());
9756         self.assertEqual(1,arr.getNumberOfComponents());
9757         self.assertEqual(cells2,arr.getValues())
9758         # some modification into m2
9759         modif3=[4,3]
9760         m2.getNodalConnectivity()[1:3]=modif3
9761         #policy 0 fails because cell0 in m2 has not exactly the same conn
9762         expected2=[4,2]
9763         isOk,arr=m1.areCellsIncludedIn(m2,0)
9764         self.assertTrue(not isOk);
9765         self.assertEqual(2,arr.getNumberOfTuples());
9766         self.assertEqual(1,arr.getNumberOfComponents());
9767         self.assertEqual(expected2,arr.getValues())
9768         #policy 1 fails too because cell0 in m2 has not same orientation
9769         isOk,arr=m1.areCellsIncludedIn(m2,1)
9770         self.assertTrue(not isOk);
9771         self.assertEqual(2,arr.getNumberOfTuples());
9772         self.assertEqual(1,arr.getNumberOfComponents());
9773         self.assertEqual(expected2,arr.getValues())
9774         #policy 2 succeeds because cell0 in m2 has same nodes in connectivity
9775         isOk,arr=m1.areCellsIncludedIn(m2,2)
9776         self.assertTrue(isOk);
9777         self.assertEqual(2,arr.getNumberOfTuples());
9778         self.assertEqual(1,arr.getNumberOfComponents());
9779         self.assertEqual(cells2,arr.getValues())
9780         pass
9781
9782     def toSeeIfDaIIopsAreOK(self,d):
9783         d+=5
9784         d*=6
9785         d/=3
9786         d-=2
9787         d%=7
9788         pass
9789
9790     def testSwigDAIOp5(self):
9791         d=DataArrayInt.New([4,5,6,10,3,-1],2,3)
9792         self.toSeeIfDaIIopsAreOK(d)
9793         dExp=DataArrayInt.New([2,4,6,0,0,6],2,3)
9794         self.assertTrue(d.isEqual(dExp));
9795         pass
9796
9797     def toSeeIfDaDIopsAreOK(self,d):
9798         d+=5
9799         d*=6
9800         d/=3
9801         d-=2
9802         pass
9803
9804     def testSwigDADOp7(self):
9805         d=DataArrayDouble.New([4.,5.,6.,10.,3.,-1.],2,3)
9806         self.toSeeIfDaDIopsAreOK(d)
9807         dExp=DataArrayDouble.New([16.,18.,20.,28.,14.,6.],2,3)
9808         self.assertTrue(d.isEqual(dExp,1e-14));
9809         pass
9810
9811     def testConvexEnvelop2D1(self):
9812         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]
9813         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]
9814         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]
9815         #
9816         m=MEDCouplingUMesh.New("convexhull",2);
9817         m.allocateCells(331);
9818         for i in xrange(331):
9819             m.insertNextCell(NORM_POLYGON,conn[connI[i]:connI[i+1]]);
9820             pass
9821         m.finishInsertingCells();
9822         coordsDa=DataArrayDouble.New(coords,331,2);
9823         m.setCoords(coordsDa);
9824         m.checkCoherency();
9825         #
9826         da=m.convexEnvelop2D();
9827         m.checkCoherency()
9828         self.assertEqual(coordsDa.getHiddenCppPointer(),m.getCoords().getHiddenCppPointer())
9829         daC=da.buildComplement(m.getNumberOfCells());
9830         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]);
9831         self.assertTrue(expected2.isEqual(daC));
9832         #
9833         vals=m.getMeasureField(ON_CELLS).getArray()
9834         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]
9835         vals-=DataArrayDouble.New(ref)
9836         vals.abs()
9837         theTest=vals.getIdsInRange(-1.,1e-7)
9838         self.assertTrue(theTest.isIdentity())
9839         self.assertEqual(331,len(theTest))
9840         pass
9841
9842     def testSwigDAIOp8(self):
9843         da=DataArrayInt.New([7,5,6,7,8,9,9,10,12,13,47,15])
9844         self.assertTrue(7 in da)
9845         self.assertTrue(47 in da)
9846         self.assertTrue(15 in da)
9847         self.assertEqual(0,da.index(7))
9848         self.assertEqual(10,da.index(47))
9849         self.assertTrue(14 not in da)
9850         self.assertEqual(5,da.search([9,9]))
9851         self.assertEqual(-1,da.search([5,8]))
9852         da.rearrange(2)
9853         self.assertTrue([47,16] not in da)
9854         self.assertTrue([5,6] not in da)
9855         self.assertTrue([6,7] in da)
9856         self.assertEqual(4,da.index([12,13]))
9857         pass
9858
9859     def testDataArraySort1(self):
9860         arr=DataArrayInt.New();
9861         self.assertRaises(InterpKernelException,arr.sort,True)
9862         self.assertRaises(InterpKernelException,arr.sort,False)
9863         values=[2,1,6,5,4,7]
9864         arr.alloc(3,2);
9865         self.assertRaises(InterpKernelException,arr.sort,True)
9866         self.assertRaises(InterpKernelException,arr.sort,False)
9867         arr.rearrange(1);
9868         arr.setValues(values,6,1)
9869         arr1=arr.deepCpy();
9870         arr2=arr.deepCpy();
9871         arr1.sort(True);
9872         expected1=[1,2,4,5,6,7]
9873         self.assertEqual(6,arr1.getNumberOfTuples());
9874         self.assertEqual(1,arr1.getNumberOfComponents());
9875         self.assertEqual(expected1,arr1.getValues());
9876         arr2.sort(False);
9877         expected2=[7,6,5,4,2,1]
9878         self.assertEqual(6,arr2.getNumberOfTuples());
9879         self.assertEqual(1,arr2.getNumberOfComponents());
9880         self.assertTrue(expected2,arr2.getValues());
9881         #
9882         ard=DataArrayDouble.New();
9883         self.assertRaises(InterpKernelException,ard.sort,True)
9884         self.assertRaises(InterpKernelException,ard.sort,False)
9885         valuesD=[2.,1.,6.,5.,4.,7.]
9886         ard.alloc(3,2);
9887         self.assertRaises(InterpKernelException,ard.sort,True)
9888         self.assertRaises(InterpKernelException,ard.sort,False)
9889         ard.rearrange(1);
9890         ard.setValues(valuesD,6,1)
9891         ard1=ard.deepCpy();
9892         ard2=ard.deepCpy();
9893         ard1.sort(True);
9894         expected3=[1.,2.,4.,5.,6.,7.]
9895         self.assertEqual(6,ard1.getNumberOfTuples());
9896         self.assertEqual(1,ard1.getNumberOfComponents());
9897         for i in xrange(6):
9898             self.assertAlmostEqual(expected3[i],ard1.getIJ(i,0),12)
9899             pass
9900         ard2.sort(False);
9901         expected4=[7.,6.,5.,4.,2.,1.]
9902         self.assertEqual(6,ard2.getNumberOfTuples());
9903         self.assertEqual(1,ard2.getNumberOfComponents());
9904         for i in xrange(6):
9905             self.assertAlmostEqual(expected4[i],ard2.getIJ(i,0),12)
9906             pass
9907         pass
9908
9909     def testPartitionBySpreadZone1(self):
9910         m=MEDCouplingDataForTest.build2DTargetMesh_1();
9911         m4=MEDCouplingUMesh.MergeUMeshes([m,m[-3:],m[0:2]]);
9912         m4.renumberCells([5,2,9,6,4,7,0,1,3,8]);
9913         #
9914         v2=m4.partitionBySpreadZone();
9915         self.assertTrue(3,len(v2));
9916         self.assertTrue(v2[0].isEqual(DataArrayInt.New([0,1,7])))
9917         self.assertTrue(v2[1].isEqual(DataArrayInt.New([2,4,5,6,9])))
9918         self.assertTrue(v2[2].isEqual(DataArrayInt.New([3,8])))
9919         #
9920         m5=m4.buildSpreadZonesWithPoly();
9921         self.assertEqual(3,m5.getNumberOfCells());
9922         self.assertTrue(m5.getCoords().getHiddenCppPointer()==m4.getCoords().getHiddenCppPointer());
9923         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())
9924         self.assertEqual([0,8,17,23],m5.getNodalConnectivityIndex().getValues())
9925         #
9926         pass
9927
9928     def testGiveCellsWithType1(self):
9929         expected0=[1,2]
9930         expected1=[0,3,4]
9931         m=MEDCouplingDataForTest.build2DTargetMesh_1();
9932         da=m.giveCellsWithType(NORM_TRI3);
9933         self.assertEqual(2,da.getNumberOfTuples());
9934         self.assertEqual(1,da.getNumberOfComponents());
9935         self.assertEqual(expected0,da.getValues())
9936         #
9937         da=m.giveCellsWithType(NORM_QUAD4);
9938         self.assertEqual(3,da.getNumberOfTuples());
9939         self.assertEqual(1,da.getNumberOfComponents());
9940         self.assertEqual(expected1,da.getValues())
9941         #
9942         da=m.giveCellsWithType(NORM_TRI6);
9943         self.assertEqual(0,da.getNumberOfTuples());
9944         self.assertEqual(1,da.getNumberOfComponents());
9945         #
9946         self.assertRaises(InterpKernelException,m.giveCellsWithType,NORM_SEG2)
9947         self.assertRaises(InterpKernelException,m.giveCellsWithType,NORM_HEXA8)
9948         pass
9949
9950     def testSwigDAOp1(self):
9951         d=DataArrayDouble.New(5,2)
9952         d.rearrange(1) ; d.iota(2.) ; d.rearrange(2)
9953         d.setInfoOnComponents(["X [m]","Y [m]"])
9954         d.setName("AName")
9955         #
9956         d1=d+[8,9]
9957         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))
9958         d1bis=DataArrayDouble.New([8,9],1,2)+d
9959         self.assertTrue(d1bis.isEqual(d1,1e-12))
9960         d1ter=[8,9]+d
9961         self.assertTrue(d1ter.isEqual(d1,1e-12))
9962         #
9963         d2=d1-[8,9]
9964         self.assertTrue(d2.isEqual(d,1e-12))
9965         self.assertRaises(InterpKernelException,d1.__rsub__,[8,9])#[8,9]-d1
9966         #
9967         d3=d*[8,9]
9968         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))
9969         d3bis=DataArrayDouble.New([8,9],1,2)*d
9970         self.assertTrue(d3bis.isEqual(d3,1e-12))
9971         d3ter=[8,9]*d
9972         self.assertTrue(d3ter.isEqual(d3,1e-12))
9973         #
9974         d4=d3/[8,9]
9975         self.assertTrue(d4.isEqual(d,1e-12))
9976         #
9977         d=DataArrayInt.New(5,2)
9978         d.rearrange(1) ; d.iota(2) ; d.rearrange(2)
9979         d.setInfoOnComponents(["X [m]","Y [m]"])
9980         d.setName("AName")
9981         #
9982         d1=d+[8,9]
9983         self.assertEqual(d1.getValues(),[10,12,12,14,14,16,16,18,18,20])
9984         d1bis=DataArrayInt.New([8,9],1,2)+d
9985         self.assertTrue(d1bis.isEqual(d1))
9986         d1ter=[8,9]+d
9987         self.assertTrue(d1ter.isEqual(d1))
9988         #
9989         d2=d1-[8,9]
9990         self.assertTrue(d2.isEqual(d))
9991         self.assertRaises(InterpKernelException,d1.__rsub__,[8,9])
9992         #
9993         d3=d*[8,9]
9994         self.assertEqual(d3.getValues(),[16,27,32,45,48,63,64,81,80,99])
9995         d3bis=DataArrayInt.New([8,9],1,2)*d
9996         self.assertTrue(d3bis.isEqual(d3))
9997         d3ter=[8,9]*d
9998         self.assertTrue(d3ter.isEqual(d3))
9999         #
10000         d4=d3/[8,9]
10001         self.assertTrue(d4.isEqual(d))
10002         #
10003         d5=d%[4,5]
10004         self.assertEqual(d5.getValues(),[2,3,0,0,2,2,0,4,2,1])
10005         pass
10006
10007     def testSwigSelectTupleId2DAIBug1(self):
10008         da=DataArrayInt.New([0,1,2,3,12,13,4,5,6,7,14,15,8,9,10,11,16,17])
10009         self.assertEqual([2,6,10],da[2::6].getValues())
10010         self.assertEqual([0,4,8],da[::6].getValues())
10011         self.assertEqual([5,9],da[7::6].getValues())
10012         self.assertEqual([5],da[7:-5:6].getValues())
10013         pass
10014
10015     def testSwigCpp5Safe1(self):
10016         m=MEDCouplingUMesh.New("toto",2)
10017         coords=DataArrayDouble.New([0.,0.,1.,0.,1.,1.,0.,1.],4,2)
10018         m.setCoords(coords)
10019         vecs=DataArrayDouble.New([2.,3.,4.,5.,6.,7.],3,2)
10020         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]]
10021         for pos,vec in enumerate(vecs):
10022             m2=m.deepCpy()
10023             m2.translate(vec)
10024             self.assertTrue(m2.getCoords().isEqual(DataArrayDouble.New(expected1[pos],4,2),1e-12))
10025             pass
10026         for pos,vec in enumerate(vecs):
10027             m2=m.deepCpy()
10028             m2.translate(vec.buildDADouble())
10029             self.assertTrue(m2.getCoords().isEqual(DataArrayDouble.New(expected1[pos],4,2),1e-12))
10030             pass
10031         pass
10032
10033     def testSwigBugNonRegressionZipDA(self):
10034         angles=map(lambda x:pi/3*x,xrange(6))
10035         radius=3
10036         #
10037         dad=DataArrayDouble.New(6, 2)
10038         dad[:,0]=radius
10039         dad[:,1]=angles
10040         #
10041         dad2=dad.fromPolarToCart()
10042         dads=[dad2.deepCpy() for elt in 7*[None]]
10043         #
10044         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.)]]
10045         for d,t in zip(dads,translationToPerform):
10046             d+=t
10047             pass
10048         for elt in dads:
10049             self.assertTrue(not dad2.isEqual(elt,1e-12))
10050             pass
10051         for d,t in zip(dads,translationToPerform):
10052             d-=t
10053             pass
10054         for elt in dads:
10055             self.assertTrue(dad2.isEqual(elt,1e-12))
10056             pass
10057         pass
10058
10059     def testBuildSlice3D2(self):
10060         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
10061         vec1=[-0.07,1.,0.07]
10062         origin1=[1.524,1.4552,1.74768]
10063         slice1,ids=mesh3D.buildSlice3D(origin1,vec1,1e-10);
10064         f=MEDCouplingFieldDouble(ON_CELLS,ONE_TIME)
10065         f.setTime(4.5,6,7) ; f.setMesh(mesh3D)
10066         arr=DataArrayDouble(mesh3D.getNumberOfCells(),2)
10067         arr.rearrange(1) ; arr.iota(2.) ; arr.rearrange(2)
10068         f.setArray(arr)
10069         f.checkCoherency()
10070         expected1=DataArrayInt([1,3,4,7,9,10,13,15,16])
10071         self.assertTrue(expected1.isEqual(ids))
10072         arr2=arr[expected1]
10073         #
10074         f2=f.extractSlice3D(origin1,vec1,1e-10)
10075         self.assertTrue(f2.getArray().isEqual(arr2,1e-12));
10076         self.assertTrue(slice1.isEqual(f2.getMesh(),1e-12))
10077         self.assertEqual(6,f2.getTime()[1]) ; self.assertEqual(7,f2.getTime()[2])
10078         self.assertAlmostEqual(4.5,f2.getTime()[0],12);
10079         pass
10080
10081     def testComputeTupleIdsToSelectFromCellIds1(self):
10082         m=MEDCouplingDataForTest.build2DTargetMesh_3()
10083         f=MEDCouplingFieldDouble.New(ON_GAUSS_NE,NO_TIME);
10084         f.setMesh(m);
10085         arr=DataArrayDouble(52,2) ; arr.rearrange(1) ; arr.iota(7.) ; arr.rearrange(2)
10086         f.setArray(arr)
10087         #
10088         f2=f.buildSubPart([1,5,9])
10089         f2.checkCoherency()
10090         cI=m.computeNbOfNodesPerCell()
10091         cI.computeOffsets2()
10092         sel=DataArrayInt([1,5,9])
10093         res=sel.buildExplicitArrByRanges(cI)
10094         arr2=arr[res]
10095         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))
10096         self.assertTrue(arr2.isEqual(f2.getArray(),1e-12))
10097         pass
10098
10099     def testComputeSkin1(self):
10100         arrX=DataArrayDouble([2.,3.4,5.6,7.7,8.0]) ; arrY=DataArrayDouble([2.,3.4,5.6,7.7,9.0,14.2])
10101         cmesh=MEDCouplingCMesh() ; cmesh.setCoordsAt(0,arrX) ; cmesh.setCoordsAt(1,arrY)
10102         umesh=cmesh.buildUnstructured()
10103         #
10104         skin=umesh.computeSkin()
10105         self.assertEqual(18,skin.getNumberOfCells())
10106         self.assertEqual(1,skin.getMeshDimension())
10107         self.assertTrue(skin.getCoords().getHiddenCppPointer()==umesh.getCoords().getHiddenCppPointer())
10108         self.assertEqual([0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48,51,54],skin.getNodalConnectivityIndex().getValues())
10109         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())
10110         ids=skin.computeFetchedNodeIds()
10111         self.assertEqual([0,1,2,3,4,5,9,10,14,15,19,20,24,25,26,27,28,29],ids.getValues())
10112         part=umesh.buildFacePartOfMySelfNode(ids,True)
10113         part.setName(skin.getName());
10114         self.assertTrue(part.isEqual(skin,1e-12))
10115         part2=part[1::2]
10116         part[::2]=part2
10117         self.assertTrue(not part.isEqual(skin,1e-12))
10118         trad=part.zipConnectivityTraducer(0)
10119         self.assertEqual(9,part.getNumberOfCells())
10120         self.assertEqual([0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8],trad.getValues())
10121         pass
10122
10123     def testUMeshSetPartOfMySelf2(self):
10124         # resize with explicit ids list
10125         m=MEDCouplingDataForTest.build2DTargetMesh_1()
10126         self.assertEqual([3,4],m.getAllTypes())
10127         part=m[[0,3,4]]
10128         part.simplexize(0)
10129         part2=part[[1,2,5]]
10130         m[[0,3,4]]=part2
10131         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())
10132         self.assertEqual([0,4,8,12,16,20],m.getNodalConnectivityIndex().getValues())
10133         self.assertEqual([3],m.getAllTypes())
10134         # no resize with explicit ids list
10135         m=MEDCouplingDataForTest.build2DTargetMesh_1()
10136         part=m[[0,3]]
10137         part.convertAllToPoly()
10138         m[[3,4]]=part
10139         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())
10140         self.assertEqual([0,5,9,13,18,23],m.getNodalConnectivityIndex().getValues())
10141         self.assertEqual([3,4,5],m.getAllTypes())
10142         # resize with range ids
10143         m=MEDCouplingDataForTest.build2DTargetMesh_1()
10144         part=m[3:]
10145         m[1:3]=part
10146         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())
10147         self.assertEqual([0,5,10,15,20,25],m.getNodalConnectivityIndex().getValues())
10148         self.assertEqual([4],m.getAllTypes())
10149         # no resize with range ids
10150         m=MEDCouplingDataForTest.build2DTargetMesh_1()
10151         part=m[0::3]
10152         part.convertAllToPoly()
10153         m[3:]=part
10154         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())
10155         self.assertEqual([0,5,9,13,18,23],m.getNodalConnectivityIndex().getValues())
10156         self.assertEqual([3,4,5],m.getAllTypes())
10157         # no resize with range ids negative direction
10158         m=MEDCouplingDataForTest.build2DTargetMesh_1()
10159         part=m[3::-3]
10160         part.convertAllToPoly()
10161         m[:-3:-1]=part
10162         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())
10163         self.assertEqual([0,5,9,13,18,23],m.getNodalConnectivityIndex().getValues())
10164         self.assertEqual([3,4,5],m.getAllTypes())
10165         pass
10166
10167     def testUnPolyze3(self):
10168         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]
10169         conn=[1,2,5,4,-1,4,3,0,1,-1,2,0,3,5,-1,0,2,1,-1,4,5,3]
10170         m=MEDCouplingUMesh.New("a mesh",3);
10171         m.allocateCells(1);
10172         m.insertNextCell(NORM_POLYHED,22,conn[0:22])
10173         m.finishInsertingCells();
10174         coords=DataArrayDouble(coord,6,3);
10175         m.setCoords(coords);
10176         m.checkCoherency();
10177         #
10178         vol=m.getMeasureField(ON_CELLS);
10179         self.assertEqual(1,vol.getArray().getNumberOfTuples());
10180         self.assertAlmostEqual(0.5,vol.getArray().getIJ(0,0),12)
10181         #
10182         m.unPolyze();
10183         #
10184         self.assertEqual([NORM_PENTA6],m.getAllTypes())
10185         self.assertTrue(DataArrayInt([0,7]).isEqual(m.getNodalConnectivityIndex()))
10186         self.assertTrue(DataArrayInt([16,0,2,1,3,5,4]).isEqual(m.getNodalConnectivity()))
10187         #
10188         vol=m.getMeasureField(ON_CELLS);
10189         self.assertEqual(1,vol.getArray().getNumberOfTuples());
10190         self.assertAlmostEqual(0.5,vol.getArray().getIJ(0,0),12)
10191         pass
10192
10193     def testKrSpatialDiscretization1(self):
10194         srcPointCoordsX=[0.8401877171547095, 0.7830992237586059, 0.9116473579367843, 0.335222755714889, 0.2777747108031878, 0.4773970518621602, 0.3647844727918433, 0.9522297251747128, 0.6357117279599009, 0.1416025553558034]
10195         srcFieldValsOnPoints=[2.129892434968836, 2.295320474540621, 1.931948594981134, 2.728013590937196, 2.715603240418478, 2.661778472822935, 2.695696990104364, 1.893710234970982, 2.529628016549284, 2.728432341300668]
10196         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]
10197         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]
10198         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])
10199         #
10200         nbOfInputPoints=10;
10201         f=MEDCouplingFieldDouble.New(ON_NODES_KR,ONE_TIME);
10202         srcArrX=DataArrayDouble.New(srcPointCoordsX,nbOfInputPoints,1);
10203         cmesh=MEDCouplingCMesh.New("aMesh");
10204         cmesh.setCoordsAt(0,srcArrX);
10205         umesh=cmesh.buildUnstructured();
10206         f.setMesh(umesh);
10207         srcVals=DataArrayDouble.New(srcFieldValsOnPoints,nbOfInputPoints,1);
10208         f.setArray(srcVals);
10209         f.checkCoherency();
10210         #
10211         res0=f.getValueOn(targetPointCoordsX[:1]);
10212         self.assertAlmostEqual(targetFieldValsExpected[0],res0[0],10)
10213         #
10214         valuesToTest=f.getValueOnMulti(targetPointCoordsX);
10215         self.assertEqual(40,valuesToTest.getNumberOfTuples());
10216         self.assertEqual(1,valuesToTest.getNumberOfComponents());
10217         for i in xrange(40):
10218             self.assertAlmostEqual(targetFieldValsExpected[i],valuesToTest.getIJ(i,0),10)
10219             pass
10220         fd=f.getDiscretization()
10221         del f
10222         self.assertTrue(isinstance(fd,MEDCouplingFieldDiscretizationKriging))
10223         coeffs,isDrift=fd.computeVectorOfCoefficients(umesh,srcVals)
10224         self.assertEqual(2,isDrift)
10225         self.assertTrue(coeffsExpected.isEqual(coeffs,1e-8))
10226         #
10227         pass
10228
10229     def testDuplicateEachTupleNTimes1(self):
10230         d=DataArrayDouble.New([9.,8.,7.,6.],4,1) ; d.setInfoOnComponents(["mass [kg]"]) ; d.setName("aname")
10231         d2=d.duplicateEachTupleNTimes(3)
10232         self.assertTrue(d2.isEqualWithoutConsideringStr(DataArrayDouble.New([9.,9.,9.,8.,8.,8.,7.,7.,7.,6.,6.,6.],4*3,1),1e-14))
10233         self.assertEqual("aname",d2.getName())
10234         self.assertEqual(["mass [kg]"],d2.getInfoOnComponents())
10235         #
10236         d=DataArrayInt.New([9,8,7,6],4,1) ; d.setInfoOnComponents(["mass [kg]"]) ; d.setName("aname")
10237         d2=d.duplicateEachTupleNTimes(3)
10238         self.assertTrue(d2.isEqualWithoutConsideringStr(DataArrayInt.New([9,9,9,8,8,8,7,7,7,6,6,6],4*3,1)))
10239         self.assertEqual("aname",d2.getName())
10240         self.assertEqual(["mass [kg]"],d2.getInfoOnComponents())
10241         pass
10242
10243     def testSwigComputeTupleIdsNearTuples1(self):
10244         da=DataArrayDouble([5.,6.,-5.,-6.,5.,-6.,-5.,6.,5.,6.],5,2)
10245         arr,arrI=da.computeTupleIdsNearTuples(DataArrayDouble([5.,-6.,5.,6.,-5.,-6.],3,2),1e-10)
10246         self.assertEqual([2,0,4,1],arr.getValues())
10247         self.assertEqual([0,1,3,4],arrI.getValues())
10248         arr,arrI=da.computeTupleIdsNearTuples([5.,-6.,5.,6.,-5.,-6.],1e-10)
10249         self.assertEqual([2,0,4,1],arr.getValues())
10250         self.assertEqual([0,1,3,4],arrI.getValues())
10251         expected0=[[2],[0,4],[1]]
10252         expected1=[[0,1],[0,2],[0,1]]
10253         for pos,it in enumerate(DataArrayDouble([5.,-6.,5.,6.,-5.,-6.],3,2)):
10254             arr,arrI=da.computeTupleIdsNearTuples(it,1e-10)
10255             self.assertEqual(expected0[pos],arr.getValues())
10256             self.assertEqual(expected1[pos],arrI.getValues())
10257             pass
10258         pass
10259
10260     def testSwigDataTupleIOp1(self):
10261         d=DataArrayDouble(10,1)
10262         d.iota(7.)
10263         for elt in d:
10264             elt+=2.
10265             pass
10266         toTest=DataArrayDouble([9.0,10.0,11.0,12.0,13.0,14.0,15.0,16.0,17.0,18.0])
10267         self.assertTrue(toTest.isEqual(d,1e-12))
10268         for elt in d:
10269             elt-=2.
10270             pass
10271         toTest=DataArrayDouble([7.0,8.0,9.0,10.0,11.0,12.0,13.0,14.0,15.0,16.0])
10272         self.assertTrue(toTest.isEqual(d,1e-12))
10273         for elt in d:
10274             elt*=2.
10275             pass
10276         toTest=DataArrayDouble([14.0,16.0,18.0,20.0,22.0,24.0,26.0,28.0,30.0,32.0])
10277         self.assertTrue(toTest.isEqual(d,1e-12))
10278         for elt in d:
10279             elt/=2.
10280             pass
10281         toTest=DataArrayDouble([7.0,8.0,9.0,10.0,11.0,12.0,13.0,14.0,15.0,16.0])
10282         self.assertTrue(toTest.isEqual(d,1e-12))
10283         #
10284         d=DataArrayInt(10,1)
10285         d.iota(7)
10286         for elt in d:
10287             elt+=2
10288             pass
10289         self.assertEqual(d.getValues(),[9,10,11,12,13,14,15,16,17,18])
10290         for elt in d:
10291             elt-=2
10292             pass
10293         self.assertEqual(d.getValues(),[7,8,9,10,11,12,13,14,15,16])
10294         for elt in d:
10295             elt*=2
10296             pass
10297         self.assertEqual(d.getValues(),[14,16,18,20,22,24,26,28,30,32])
10298         for elt in d:
10299             elt/=2
10300             pass
10301         self.assertEqual(d.getValues(),[7,8,9,10,11,12,13,14,15,16])
10302         for elt in d:
10303             elt%=3
10304             pass
10305         self.assertEqual(d.getValues(),[1,2,0,1,2,0,1,2,0,1])
10306         pass
10307
10308     def testIntersect2DMeshesTmp5(self):
10309         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)
10310         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)
10311         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)
10312         #
10313         m1=MEDCouplingUMesh.New("Fix",2);
10314         m1.setCoords(coords);
10315         m1.setConnectivity(conn,connI,True);
10316         #
10317         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)
10318         # connectivity
10319         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);
10320         conn.setName("");
10321         connI=DataArrayInt([0,9,18,27,36,45,54,63,72],9)
10322         m2=MEDCouplingUMesh.New("Mobile",2);
10323         m2.setCoords(coords);
10324         m2.setConnectivity(conn,connI,True);
10325         #
10326         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m1,m2,1e-10);
10327         self.assertEqual(105,m3.getNumberOfCells());
10328         self.assertEqual(105,d1.getNumberOfTuples());
10329         self.assertEqual(105,d2.getNumberOfTuples());
10330         self.assertEqual(704,m3.getNumberOfNodes());
10331         #
10332         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]
10333         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]
10334         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]
10335         f3=m3.getMeasureField(ON_CELLS).getArray().getValues();
10336         for i in xrange(105):
10337             self.assertAlmostEqual(areaExpected[i],f3[i],10)
10338             pass
10339         self.assertEqual(expected1,d1.getValues())
10340         self.assertEqual(expected2,d2.getValues())
10341         pass
10342
10343     def testDAIBuildUnique1(self):
10344         d=DataArrayInt([1,2,2,3,3,3,3,4,5,5,7,7,7,19])
10345         e=d.buildUnique()
10346         self.assertTrue(e.isEqual(DataArrayInt([1,2,3,4,5,7,19])))
10347         pass
10348
10349     def testDAIPartitionByDifferentValues1(self):
10350         d=DataArrayInt([1,0,1,2,0,2,2,-3,2])
10351         expected=[[-3,[7]],[0,[1,4]],[1,[0,2]],[2,[3,5,6,8]]]
10352         for i,elt in enumerate(zip(*d.partitionByDifferentValues())):
10353             self.assertEqual(expected[i][0],elt[1])
10354             self.assertEqual(expected[i][1],elt[0].getValues())
10355             pass
10356         pass
10357
10358     def testFieldGaussMultiDiscPerType1(self):
10359         coords=DataArrayDouble([0.,0.,0.,1.,1.,1.,1.,0.,0.,0.5,0.5,1.,1.,0.5,0.5,0.],8,2)
10360         mQ8=MEDCouplingUMesh("",2) ; mQ8.setCoords(coords)
10361         mQ8.allocateCells(1)
10362         mQ8.insertNextCell(NORM_QUAD8,range(8))
10363         mQ8.finishInsertingCells()
10364         mQ4=MEDCouplingUMesh("",2) ; mQ4.setCoords(coords)
10365         mQ4.allocateCells(1)
10366         mQ4.insertNextCell(NORM_QUAD4,range(4))
10367         mQ4.finishInsertingCells()
10368         mT3=MEDCouplingUMesh("",2) ; mT3.setCoords(coords)
10369         mT3.allocateCells(1)
10370         mT3.insertNextCell(NORM_TRI3,range(3))
10371         mT3.finishInsertingCells()
10372
10373         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.]]
10374         ms=2*[mQ4]+7*[mQ8]+11*[mT3]
10375         ms[:]=(elt.deepCpy() for elt in ms)
10376         for m,t in zip(ms,tr):
10377             d=m.getCoords() ; d+= t
10378             pass
10379         m=MEDCouplingUMesh.MergeUMeshes(ms)
10380         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,NO_TIME)
10381         f.setMesh(m)
10382         # throw because cell 0,1 are QUAD4 and cell 3 is QUAD8
10383         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])
10384         f.setGaussLocalizationOnCells([0,1],[0.,0.,1.,0.,1.,1.,0.,1.],[0.3,0.3,0.7,0.7],[0.8,0.2])
10385         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])
10386         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])
10387         f.setGaussLocalizationOnCells([9,10,11,12,13],[0.,0.,1.,0.,1.,1.],[0.4,0.4],[1.])
10388         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])
10389         self.assertEqual(46,f.getNumberOfTuplesExpected())
10390         vals=DataArrayDouble.New(46*3,1) ; vals.iota(7.7) ; vals.rearrange(3)
10391         f.setArray(vals)
10392         f.checkCoherency()
10393         #f.getLocalizationOfDiscr()
10394         self.assertRaises(InterpKernelException,f.getGaussLocalizationIdOfOneType,NORM_QUAD8) #throw because several loc
10395         self.assertEqual([1,2],f.getGaussLocalizationIdsOfOneType(NORM_QUAD8))
10396         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())
10397         fc=f[[1,2,3,8]]
10398         fc.checkCoherency()
10399         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))
10400         fc.renumberCells([3,2,0,1])
10401         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))
10402         fc.getArray()
10403         pass
10404
10405     def testSwigRotate(self):
10406         d=DataArrayDouble([1.,2.,3.,4.,6.,5.],2,3)
10407         MEDCouplingPointSet.Rotate3DAlg([0.,0.,0.],[0.,1.,0.],1.5707963267948966,d)
10408         self.assertTrue(d.isEqual(DataArrayDouble([3.,2.,-1.,5.,6.,-4.],2,3),1e-12))
10409         d=DataArrayDouble([1.,2.,3.,4.,6.,5.],3,2)
10410         MEDCouplingPointSet.Rotate2DAlg([0.,0.],1.5707963267948966,d)
10411         self.assertTrue(d.isEqual(DataArrayDouble([-2.,1.,-4.,3.,-5.,6.],3,2),1e-12))
10412         pass
10413
10414     def testSwigCMeshProtection(self):
10415         cm=MEDCouplingCMesh()
10416         self.assertRaises(InterpKernelException,cm.setCoordsAt,0,DataArrayDouble([4.,4.5,6.,7.],2,2))
10417         self.assertRaises(InterpKernelException,cm.setCoords,DataArrayDouble([4.,4.5,6.,7.],2,2))
10418         pass
10419
10420     def testSwigCellsInBoundingBox1(self):
10421         m3D=MEDCouplingDataForTest.build3DExtrudedUMesh_1()[0]
10422         self.assertTrue(m3D.getCellsInBoundingBox([(0,3),(0,3),(0,1)],-1e-12).isEqual(DataArrayInt([0,1,2,3,4,5])))
10423         self.assertRaises(InterpKernelException,m3D.getCellsInBoundingBox,[(0,3,0),(3,0,1)],-1e-12)
10424         pass
10425
10426     def testDAICheckMonotonic1(self):
10427         data1=[-1,0,2,2,4,5]
10428         data2=[6,2,0,-8,-9,-56]
10429         data3=[-1,0,3,2,4,6]
10430         data4=[7,5,2,3,0,-6]
10431         d=DataArrayInt.New(data1);
10432         self.assertTrue(d.isMonotonic(True));
10433         self.assertTrue(not d.isMonotonic(False));
10434         d.checkMonotonic(True);
10435         self.assertRaises(InterpKernelException,d.checkMonotonic,False)
10436         d=DataArrayInt.New(data2);
10437         self.assertTrue(d.isMonotonic(False));
10438         self.assertTrue(not d.isMonotonic(True));
10439         d.checkMonotonic(False);
10440         self.assertRaises(InterpKernelException,d.checkMonotonic,True)
10441         d=DataArrayInt.New(data3);
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(data4);
10447         self.assertTrue(not d.isMonotonic(False));
10448         self.assertTrue(not d.isMonotonic(True));
10449         self.assertRaises(InterpKernelException,d.checkMonotonic,True)
10450         self.assertRaises(InterpKernelException,d.checkMonotonic,False)
10451         d=DataArrayInt.New(0,1)
10452         self.assertTrue(d.isMonotonic(True));
10453         self.assertTrue(d.isMonotonic(False));
10454         d.checkMonotonic(True);
10455         d.checkMonotonic(False);
10456         d=DataArrayInt.New(data4,3,2);#throw because nbComp!=1
10457         self.assertRaises(InterpKernelException,d.isMonotonic,True)
10458         self.assertRaises(InterpKernelException,d.isMonotonic,False)
10459         self.assertRaises(InterpKernelException,d.checkMonotonic,True)
10460         self.assertRaises(InterpKernelException,d.checkMonotonic,False)
10461         pass
10462
10463     def testSwigDASetItemOnEmpty1(self):
10464         d=DataArrayInt(0,1)
10465         isThrow=False
10466         try:
10467             d[0:1000:2]=4
10468         except InterpKernelException as e:
10469             isThrow=True
10470             pass
10471         self.assertTrue(isThrow)
10472         d[:]=4
10473         d[::2]=5
10474         #
10475         d=DataArrayDouble(0,1)
10476         isThrow=False
10477         try:
10478             d[0:1000:2]=4
10479         except InterpKernelException as e:
10480             isThrow=True
10481             pass
10482         self.assertTrue(isThrow)
10483         d[:]=4
10484         d[::2]=5
10485         d=DataArrayInt([],0,1)
10486         d2=DataArrayInt(0)
10487         self.assertTrue(d2.isEqual(d))
10488         d=DataArrayDouble([],0,1)
10489         d2=DataArrayDouble(0)
10490         self.assertTrue(d2.isEqual(d,1e-12))
10491         pass
10492
10493     def testSwigDAITransformWithIndArr1(self):
10494         arr=DataArrayInt([0,4,5,1])
10495         d=DataArrayInt([7,8,9,10])
10496         self.assertRaises(InterpKernelException,arr.transformWithIndArr,d)
10497         pass
10498
10499     def testIntersect2DMeshesTmp6(self):
10500         # coordinates
10501         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);
10502         # connectivity
10503         conn=DataArrayInt.New([8,0,3,5,1,4,6,7,2])
10504         connI=DataArrayInt.New([0,9]);
10505         m1=MEDCouplingUMesh.New("Fixe",2);
10506         m1.setCoords(coords);
10507         m1.setConnectivity(conn,connI,True);
10508         #
10509         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);
10510         # connectivity
10511         conn=DataArrayInt.New([8,0,1,2,3,4,5,6,7,8,3,2,8,9,6,10,11,12]);
10512         connI=DataArrayInt.New([0,9,18]);
10513         #
10514         m2=MEDCouplingUMesh.New("Mobile",2);
10515         m2.setCoords(coords);
10516         m2.setConnectivity(conn,connI,True);
10517         #
10518         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m1,m2,1e-10);
10519         self.assertTrue(d1.isEqual(DataArrayInt([0,0,0,0])));
10520         self.assertTrue(d2.isEqual(DataArrayInt([0,1,-1,-1])));
10521         self.assertEqual(4,m3.getNumberOfCells());
10522         self.assertEqual(4,d1.getNumberOfTuples());
10523         self.assertEqual(4,d2.getNumberOfTuples());
10524         self.assertEqual(43,m3.getNumberOfNodes());
10525         dI,areMerged,newNbOfNodes=m3.mergeNodes(1e-12)
10526         self.assertEqual(35,m3.getNumberOfNodes());
10527         m3.zipCoords();
10528         self.assertEqual(23,m3.getNumberOfNodes());
10529         #
10530         f=m3.getMeasureField(True);
10531         valuesExpected=DataArrayDouble([1.6603638692585716,5.747555728471923,129.68907101754394,7.4162714498559694])
10532         self.assertTrue(f.getArray().isEqual(valuesExpected,1e-12))
10533         pass
10534
10535     def testDAPushBack(self):
10536         d=DataArrayDouble(0,1)
10537         for i in xrange(8):
10538             d.pushBackSilent(i)
10539             pass
10540         self.assertEqual(d.getNumberOfTuples(),8)
10541         self.assertEqual(d.getNbOfElemAllocated(),8)
10542         d.pushBackSilent(4.44)
10543         self.assertEqual(d.getNumberOfTuples(),9)
10544         self.assertEqual(d.getNbOfElemAllocated(),16)
10545         self.assertTrue(d.isEqual(DataArrayDouble([0.,1.,2.,3.,4.,5.,6.,7.,4.44]),1e-12))
10546         e=d.deepCpy()
10547         self.assertEqual(e.getNumberOfTuples(),9)
10548         self.assertEqual(e.getNbOfElemAllocated(),9)
10549         self.assertTrue(e.isEqual(DataArrayDouble([0.,1.,2.,3.,4.,5.,6.,7.,4.44]),1e-12))
10550         self.assertAlmostEqual(d.popBackSilent(),4.44,12)
10551         self.assertEqual(d.getNumberOfTuples(),8)
10552         self.assertEqual(d.getNbOfElemAllocated(),16)
10553         self.assertTrue(d.isEqual(DataArrayDouble([0.,1.,2.,3.,4.,5.,6.,7.]),1e-12))
10554         f=DataArrayDouble()
10555         f.reserve(1000)
10556         f.pushBackSilent(4.)
10557         self.assertTrue(f.isEqual(DataArrayDouble([4.]),1e-12))
10558         self.assertEqual(f.getNumberOfTuples(),1)
10559         self.assertEqual(f.getNbOfElemAllocated(),1000)
10560         ff=f[:]
10561         self.assertTrue(ff.isEqual(DataArrayDouble([4.]),1e-12))
10562         self.assertEqual(ff.getNumberOfTuples(),1)
10563         self.assertEqual(ff.getNbOfElemAllocated(),1)
10564         d=DataArrayDouble()
10565         d.pushBackSilent(4.44)
10566         d.pushBackSilent(5.55)
10567         d.pushBackSilent(6.66)
10568         self.assertTrue(d.isEqual(DataArrayDouble([4.44,5.55,6.66]),1e-12))
10569         #
10570         d=DataArrayInt(0,1)
10571         for i in xrange(8):
10572             d.pushBackSilent(i)
10573             pass
10574         self.assertEqual(d.getNumberOfTuples(),8)
10575         self.assertEqual(d.getNbOfElemAllocated(),8)
10576         d.pushBackSilent(444)
10577         self.assertEqual(d.getNumberOfTuples(),9)
10578         self.assertEqual(d.getNbOfElemAllocated(),16)
10579         self.assertTrue(d.isEqual(DataArrayInt([0,1,2,3,4,5,6,7,444])))
10580         e=d.deepCpy()
10581         self.assertEqual(e.getNumberOfTuples(),9)
10582         self.assertEqual(e.getNbOfElemAllocated(),9)
10583         self.assertTrue(e.isEqual(DataArrayInt([0,1,2,3,4,5,6,7,444])))
10584         self.assertEqual(d.popBackSilent(),444)
10585         self.assertEqual(d.getNumberOfTuples(),8)
10586         self.assertEqual(d.getNbOfElemAllocated(),16)
10587         self.assertTrue(d.isEqual(DataArrayInt([0,1,2,3,4,5,6,7])))
10588         f=DataArrayInt()
10589         f.reserve(1000)
10590         f.pushBackSilent(4)
10591         self.assertTrue(f.isEqual(DataArrayInt([4])))
10592         self.assertEqual(f.getNumberOfTuples(),1)
10593         self.assertEqual(f.getNbOfElemAllocated(),1000)
10594         ff=f[:]
10595         self.assertTrue(ff.isEqual(DataArrayInt([4])))
10596         self.assertEqual(ff.getNumberOfTuples(),1)
10597         self.assertEqual(ff.getNbOfElemAllocated(),1)
10598         d=DataArrayInt()
10599         d.pushBackSilent(444)
10600         d.pushBackSilent(555)
10601         d.pushBackSilent(666)
10602         self.assertTrue(d.isEqual(DataArrayInt([444,555,666])))
10603         #
10604         d=DataArrayInt()
10605         d.alloc(10,1)
10606         d.setInfoOnComponent(0,"ABC")
10607         d.setName("dEf")
10608         d.iota(7)
10609         e=DataArrayInt([7,8,9,10,11,12,13,14,15,16]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
10610         self.assertEqual(10,d.getNbOfElemAllocated())
10611         d.pushBackSilent(55)
10612         e=DataArrayInt([7,8,9,10,11,12,13,14,15,16,55]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
10613         self.assertEqual(20,d.getNbOfElemAllocated())
10614         d.reserve(4)
10615         e=DataArrayInt([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
10616         self.assertEqual(4,d.getNbOfElemAllocated())
10617         d.pushBackSilent(5)
10618         e=DataArrayInt([7,8,9,10,5]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
10619         self.assertEqual(8,d.getNbOfElemAllocated())
10620         self.assertEqual(5,d.popBackSilent())
10621         e=DataArrayInt([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
10622         self.assertEqual(8,d.getNbOfElemAllocated())
10623         self.assertRaises(OverflowError,d.reserve,-1)
10624         e=DataArrayInt([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
10625         self.assertEqual(8,d.getNbOfElemAllocated())
10626         d.reserve(0)
10627         e=DataArrayInt([]) ; e.setInfoOnComponent(0,"ABC") ; e.setName("dEf") ; self.assertTrue(d.isEqual(e))
10628         self.assertEqual(0,d.getNbOfElemAllocated())
10629         #
10630         d=DataArrayDouble()
10631         d.alloc(10,1)
10632         d.setInfoOnComponent(0,"ABC")
10633         d.setName("dEf")
10634         d.iota(7)
10635         e=DataArrayDouble([7,8,9,10,11,12,13,14,15,16]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
10636         self.assertEqual(10,d.getNbOfElemAllocated())
10637         d.pushBackSilent(55)
10638         e=DataArrayDouble([7,8,9,10,11,12,13,14,15,16,55]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
10639         self.assertEqual(20,d.getNbOfElemAllocated())
10640         d.reserve(4)
10641         e=DataArrayDouble([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
10642         self.assertEqual(4,d.getNbOfElemAllocated())
10643         d.pushBackSilent(5)
10644         e=DataArrayDouble([7,8,9,10,5]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
10645         self.assertEqual(8,d.getNbOfElemAllocated())
10646         self.assertEqual(5.,d.popBackSilent())
10647         e=DataArrayDouble([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
10648         self.assertEqual(8,d.getNbOfElemAllocated())
10649         self.assertRaises(OverflowError,d.reserve,-1)
10650         e=DataArrayDouble([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
10651         self.assertEqual(8,d.getNbOfElemAllocated())
10652         d.reserve(0)
10653         e=DataArrayDouble([]) ; e.setInfoOnComponent(0,"ABC") ; e.setName("dEf") ; self.assertTrue(d.isEqual(e,1e-14))
10654         self.assertEqual(0,d.getNbOfElemAllocated())
10655         pass
10656
10657     def testDAIBuildSubstractionOptimized1(self):
10658         da1=DataArrayInt.New([1,3,5,6,7,9,13])
10659         da2=DataArrayInt.New([3,5,9])
10660         da3=DataArrayInt.New([1,3,5])
10661         da4=DataArrayInt.New([1,3,5,6,7,9,13])
10662         #
10663         a=da1.buildSubstractionOptimized(da2);
10664         self.assertTrue(a.isEqual(DataArrayInt([1,6,7,13])));
10665         #
10666         a=da1.buildSubstractionOptimized(da3);
10667         self.assertTrue(a.isEqual(DataArrayInt([6,7,9,13])));
10668         #
10669         a=da1.buildSubstractionOptimized(da4);
10670         self.assertTrue(a.isEqual(DataArrayInt([])));
10671         pass
10672
10673     def testDAIIsStrictlyMonotonic1(self):
10674         da1=DataArrayInt.New([1,3,5,6,7,9,13])
10675         self.assertTrue(da1.isStrictlyMonotonic(True));
10676         da1.checkStrictlyMonotonic(True);
10677         self.assertTrue(da1.isMonotonic(True));
10678         da1.checkMonotonic(True);
10679         self.assertTrue(not da1.isStrictlyMonotonic(False));
10680         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,False)
10681         self.assertTrue(not da1.isMonotonic(False));
10682         self.assertRaises(InterpKernelException,da1.checkMonotonic,False)
10683         #
10684         da1=DataArrayInt.New([1,3,5,6,6,9,13])
10685         self.assertTrue(not da1.isStrictlyMonotonic(True));
10686         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,True)
10687         self.assertTrue(da1.isMonotonic(True));
10688         da1.checkMonotonic(True);
10689         self.assertTrue(not da1.isStrictlyMonotonic(False));
10690         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,False)
10691         self.assertTrue(not da1.isMonotonic(False));
10692         self.assertRaises(InterpKernelException,da1.checkMonotonic,False)
10693         #
10694         da1=DataArrayInt.New([1,3,5,6,5,9,13])
10695         self.assertTrue(not da1.isStrictlyMonotonic(True));
10696         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,True)
10697         self.assertTrue(not da1.isMonotonic(True));
10698         self.assertRaises(InterpKernelException,da1.checkMonotonic,True)
10699         self.assertTrue(not da1.isStrictlyMonotonic(False));
10700         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,False)
10701         self.assertTrue(not da1.isMonotonic(False));
10702         self.assertRaises(InterpKernelException,da1.checkMonotonic,False)
10703         #
10704         da1=DataArrayInt.New([13,9,7,6,5,3,1])
10705         self.assertTrue(not da1.isStrictlyMonotonic(True));
10706         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,True)
10707         self.assertTrue(not da1.isMonotonic(True));
10708         self.assertRaises(InterpKernelException,da1.checkMonotonic,True)
10709         self.assertTrue(da1.isStrictlyMonotonic(False));
10710         da1.checkStrictlyMonotonic(False);
10711         self.assertTrue(da1.isMonotonic(False));
10712         da1.checkMonotonic(False);
10713         #
10714         da1=DataArrayInt.New([13,9,6,6,5,3,1])
10715         self.assertTrue(not da1.isStrictlyMonotonic(True));
10716         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,True)
10717         self.assertTrue(not da1.isMonotonic(True));
10718         self.assertRaises(InterpKernelException,da1.checkMonotonic,True)
10719         self.assertTrue(not da1.isStrictlyMonotonic(False));
10720         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,False)
10721         self.assertTrue(da1.isMonotonic(False));
10722         da1.checkMonotonic(False);
10723         #
10724         da1=DataArrayInt.New([13,9,5,6,5,3,1])
10725         self.assertTrue(not da1.isStrictlyMonotonic(True));
10726         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,True)
10727         self.assertTrue(not da1.isMonotonic(True));
10728         self.assertRaises(InterpKernelException,da1.checkMonotonic,True)
10729         self.assertTrue(not da1.isStrictlyMonotonic(False));
10730         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,False)
10731         self.assertTrue(not da1.isMonotonic(False));
10732         self.assertRaises(InterpKernelException,da1.checkMonotonic,False)
10733         #
10734         da1=DataArrayInt.New([])
10735         self.assertTrue(da1.isStrictlyMonotonic(True));
10736         da1.checkStrictlyMonotonic(True);
10737         self.assertTrue(da1.isMonotonic(True));
10738         da1.checkMonotonic(True);
10739         self.assertTrue(da1.isStrictlyMonotonic(False));
10740         da1.checkStrictlyMonotonic(False);
10741         self.assertTrue(da1.isMonotonic(False));
10742         da1.checkMonotonic(False);
10743         #
10744         da1=DataArrayInt.New([13])
10745         self.assertTrue(da1.isStrictlyMonotonic(True));
10746         da1.checkStrictlyMonotonic(True);
10747         self.assertTrue(da1.isMonotonic(True));
10748         da1.checkMonotonic(True);
10749         self.assertTrue(da1.isStrictlyMonotonic(False));
10750         da1.checkStrictlyMonotonic(False);
10751         self.assertTrue(da1.isMonotonic(False));
10752         da1.checkMonotonic(False);
10753         pass
10754
10755     def testFindAndCorrectBadOriented3DCells1(self):
10756         nbOfDisc=20
10757         vects=([0,0,-1],[0.3,0.7,0.2],[-0.3,0.7,0.2],[-0.3,-0.7,0.2])
10758         #
10759         m0=MEDCouplingUMesh("m",3) ; m0.allocateCells(0); m0.insertNextCell(NORM_TETRA4,[0,1,2,3]); #Well oriented
10760         m1=MEDCouplingUMesh("m",3) ; m1.allocateCells(0); m1.insertNextCell(NORM_PYRA5,[0,1,2,3,4]); #Well oriented
10761         m2=MEDCouplingUMesh("m",3) ; m2.allocateCells(0); m2.insertNextCell(NORM_PENTA6,[0,1,2,3,4,5]); #Well oriented
10762         m3=MEDCouplingUMesh("m",3) ; m3.allocateCells(0); m3.insertNextCell(NORM_HEXA8,[0,1,2,3,4,5,6,7]); #Well oriented
10763         m4=MEDCouplingUMesh("m",3) ; m4.allocateCells(0)
10764         self.assertRaises(InterpKernelException,m4.insertNextCell,NORM_HEXGP12,[0,1,2,3,4,5,6,7,8,9,10,11,12]);
10765         m4.insertNextCell(NORM_HEXGP12,[0,1,2,3,4,5,6,7,8,9,10,11]); #Well oriented
10766         c0=DataArrayDouble([0.,0.,0.,0.,1.,0.,1.,0.,0.,0.,0.,1.],4,3) ; m0.setCoords(c0)
10767         c1=DataArrayDouble([0.,0.,0.,0.,1.,0.,1.,1.,0.,1.,0.,0.,0.,0.,1.],5,3) ; m1.setCoords(c1)
10768         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)
10769         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)
10770         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)
10771         m=MEDCouplingMesh.MergeMeshes([m0,m1,m2,m3,m4])
10772         expected1=DataArrayDouble([0.16666666666666666,0.3333333333333333,0.5,1.,1.])
10773         for v in vects:
10774             for i in xrange(nbOfDisc):
10775                 mm=m.deepCpy()
10776                 mm.rotate([0.,0.,0.],[0.3,0.7,0.2],float(i)/float(nbOfDisc)*2*pi)
10777                 mm2=mm.deepCpy()
10778                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
10779                 self.assertTrue(mm.findAndCorrectBadOriented3DCells().empty())
10780                 self.assertTrue(mm.isEqual(mm2,1e-14))
10781                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
10782                 mm.convertAllToPoly()
10783                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
10784                 pass
10785             pass
10786         #
10787         mOK=m.deepCpy()
10788         m0=MEDCouplingUMesh("m",3) ; m0.allocateCells(0); m0.insertNextCell(NORM_TETRA4,[0,2,1,3]); #Not well oriented
10789         m1=MEDCouplingUMesh("m",3) ; m1.allocateCells(0); m1.insertNextCell(NORM_PYRA5,[0,1,2,3,4]); #Well oriented
10790         m2=MEDCouplingUMesh("m",3) ; m2.allocateCells(0); m2.insertNextCell(NORM_PENTA6,[0,1,2,3,4,5]); #Well oriented
10791         m3=MEDCouplingUMesh("m",3) ; m3.allocateCells(0); m3.insertNextCell(NORM_HEXA8,[0,3,2,1,4,7,6,5]); #Not well oriented
10792         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
10793         m0.setCoords(c0) ; m1.setCoords(c1) ; m2.setCoords(c2) ; m3.setCoords(c3) ; m4.setCoords(c4)
10794         m=MEDCouplingMesh.MergeMeshes([m0,m1,m2,m3,m4])
10795         expected2=DataArrayDouble([-0.16666666666666666,0.3333333333333333,0.5,-1.,-1.])
10796         for v in vects:
10797             for i in xrange(nbOfDisc):
10798                 mm=m.deepCpy()
10799                 mm.rotate([0.,0.,0.],[0.3,0.7,0.2],float(i)/float(nbOfDisc)*2*pi)
10800                 mm2=mm.deepCpy() ; mm3=mm.deepCpy() ; mm3.convertAllToPoly()
10801                 self.assertTrue(mm3.getMeasureField(False).getArray().isEqual(expected2,1e-14))
10802                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected2,1e-14))
10803                 self.assertTrue(mm.findAndCorrectBadOriented3DCells().isEqual(DataArrayInt([0,3,4])))
10804                 mOK.setCoords(mm.getCoords())
10805                 self.assertTrue(mm.isEqual(mOK,1e-14))
10806                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
10807                 mmm=mm.deepCpy()
10808                 self.assertTrue(mmm.findAndCorrectBadOriented3DCells().empty())
10809                 mm.convertAllToPoly()
10810                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
10811                 pass
10812             pass
10813         #
10814         m0=MEDCouplingUMesh("m",3) ; m0.allocateCells(0); m0.insertNextCell(NORM_TETRA4,[0,1,2,3]); #Well oriented
10815         m1=MEDCouplingUMesh("m",3) ; m1.allocateCells(0); m1.insertNextCell(NORM_PYRA5,[0,3,2,1,4]); #Not well oriented
10816         m2=MEDCouplingUMesh("m",3) ; m2.allocateCells(0); m2.insertNextCell(NORM_PENTA6,[0,2,1,3,5,4]); #Not well oriented
10817         m3=MEDCouplingUMesh("m",3) ; m3.allocateCells(0); m3.insertNextCell(NORM_HEXA8,[0,1,2,3,4,5,6,7]); #Well oriented
10818         m4=MEDCouplingUMesh("m",3) ; m4.allocateCells(0); m4.insertNextCell(NORM_HEXGP12,range(12)); #Well oriented
10819         m0.setCoords(c0) ; m1.setCoords(c1) ; m2.setCoords(c2) ; m3.setCoords(c3) ; m4.setCoords(c4)
10820         m=MEDCouplingMesh.MergeMeshes([m0,m1,m2,m3,m4])
10821         expected3=DataArrayDouble([0.16666666666666666,-0.3333333333333333,-0.5,1.,1.])
10822         for v in vects:
10823             for i in xrange(nbOfDisc):
10824                 mm=m.deepCpy()
10825                 mm.rotate([0.,0.,0.],[0.3,0.7,0.2],float(i)/float(nbOfDisc)*2*pi)
10826                 mm2=mm.deepCpy() ; mm3=mm.deepCpy() ; mm3.convertAllToPoly()
10827                 self.assertTrue(mm3.getMeasureField(False).getArray().isEqual(expected3,1e-14))
10828                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected3,1e-14))
10829                 self.assertTrue(mm.findAndCorrectBadOriented3DCells().isEqual(DataArrayInt([1,2])))
10830                 mOK.setCoords(mm.getCoords())
10831                 self.assertTrue(mm.isEqual(mOK,1e-14))
10832                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
10833                 mmm=mm.deepCpy()
10834                 self.assertTrue(mmm.findAndCorrectBadOriented3DCells().empty())
10835                 mm.convertAllToPoly()
10836                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
10837                 pass
10838             pass
10839         pass
10840
10841     def testSwig2CellOrientation1(self):
10842         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)
10843         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]]
10844         for i in xrange(256):
10845             mesh=MEDCouplingUMesh("FluidMesh_1",3);
10846             mesh.allocateCells(0)
10847             conn2=[elt[:] for elt in conn]
10848             code=bin(i)[2:] ; code='0'*(8-len(code))+code
10849             for face,rev in zip(conn2,code):
10850                 if bool(int(rev)):
10851                     face.reverse()
10852                     pass
10853                 pass
10854             conn3=[elt+[-1] for elt in conn2]
10855             conn3=sum(conn3,[])[:-1]
10856             mesh.insertNextCell(NORM_POLYHED,conn3)
10857             mesh.setCoords(coords)
10858             mesh.orientCorrectlyPolyhedrons()
10859             self.assertTrue(mesh.getBarycenterAndOwner().isEqual(DataArrayDouble([-0.10803,0.,0.3385],1,3),1e-12))
10860             pass
10861         pass
10862
10863     def testSwig2CheckConsecutiveCellTypesForMEDFileFrmt1(self):
10864         m1=MEDCouplingUMesh("",2) ; m1.allocateCells(0)
10865         m1.insertNextCell(NORM_QUAD4,[0,1,2,3])
10866         m1.insertNextCell(NORM_TRI3,[0,1,2])
10867         d=DataArrayDouble(4,3) ; d[:]=0.
10868         m1.setCoords(d)
10869         self.assertTrue(m1.checkConsecutiveCellTypes())
10870         self.assertTrue(not m1.checkConsecutiveCellTypesForMEDFileFrmt())
10871         m1.renumberCells([1,0])
10872         self.assertTrue(m1.checkConsecutiveCellTypes())
10873         self.assertTrue(m1.checkConsecutiveCellTypesForMEDFileFrmt())
10874         pass
10875
10876     def testSwig2DAAccumulate1(self):
10877         d=DataArrayInt(10) ; d.iota(0)
10878         self.assertEqual([45],d.accumulate())
10879         self.assertEqual(45,d.accumulate(0))
10880         d=DataArrayInt(30) ; d.iota(0) ; d.rearrange(3)
10881         self.assertEqual([135,145,155],d.accumulate())
10882         self.assertEqual(135,d.accumulate(0))
10883         self.assertEqual(145,d.accumulate(1))
10884         self.assertEqual(155,d.accumulate(2))
10885         d=DataArrayDouble(10) ; d.iota(0.)
10886         self.assertEqual([45.],d.accumulate())
10887         self.assertEqual(45.,d.accumulate(0))
10888         d=DataArrayDouble(30) ; d.iota(0) ; d.rearrange(3)
10889         self.assertEqual([135.,145.,155.],d.accumulate())
10890         self.assertEqual(135.,d.accumulate(0))
10891         self.assertEqual(145.,d.accumulate(1))
10892         self.assertEqual(155.,d.accumulate(2))
10893         pass
10894
10895     def testSwig2UMeshDistanceToMesh1(self):
10896         m=MEDCouplingUMesh("toto",2)
10897         coords=DataArrayDouble([2.3,3.4,5.6,6.5,-4.3,3.2,-9.8,7.6,-5.4],3,3)
10898         m.setCoords(coords)
10899         m.allocateCells(0)
10900         m.insertNextCell(NORM_TRI3,[0,1,2])
10901         a,b,c=m.distanceToPoint([-0.335,2.27,1.21])
10902         self.assertEqual(0,b) ; self.assertEqual(0,c)
10903         self.assertAlmostEqual(0.022360988100374124,a,14);
10904         a,b,c=m.distanceToPoint(DataArrayDouble([-0.335,2.27,1.21],1,3))
10905         self.assertEqual(0,b) ; self.assertEqual(0,c)
10906         self.assertAlmostEqual(0.022360988100374124,a,14);
10907         a,b=coords.distanceToTuple([-0.335,2.27,1.21])
10908         self.assertAlmostEqual(5.243302871282566,a,14)
10909         self.assertEqual(0,b)
10910         #
10911         m=MEDCouplingUMesh("toto",2)
10912         coords=DataArrayDouble([0.,0.,0., 8.,0.,0., 8.,8.,0., 0.,8.,0.],4,3)
10913         m.setCoords(coords)
10914         m.allocateCells(0)
10915         m.insertNextCell(NORM_QUAD4,[0,1,2,3])
10916         m.checkCoherency2()
10917         self.assertEqual([4,0,1,2,3],m.getNodalConnectivity().getValues())
10918         a,b,c=m.distanceToPoint([5.,2.,0.1])
10919         self.assertAlmostEqual(0.1,a,14) ; self.assertEqual(0,b) ; self.assertEqual(1,c)
10920         a,b,c=m.distanceToPoint([5.,-2.,4.])
10921         self.assertAlmostEqual(sqrt(2*2+4*4),a,14) ; self.assertEqual(0,b) ; self.assertEqual(1,c)
10922         m.allocateCells(0)
10923         m.insertNextCell(NORM_POLYGON,[0,1,2,3])
10924         m.checkCoherency2()
10925         self.assertEqual([5,0,1,2,3],m.getNodalConnectivity().getValues())
10926         a,b,c=m.distanceToPoint([11.,3.,4.])
10927         self.assertAlmostEqual(sqrt(3*3+4*4),a,14) ; self.assertEqual(0,b) ; self.assertEqual(1,c)
10928         a,b,c=m.distanceToPoint([4.,12.,5.])
10929         self.assertAlmostEqual(sqrt(4*4+5*5),a,14) ; self.assertEqual(0,b) ; self.assertEqual(2,c)
10930         d=DataArrayDouble([-1.2,3.,2.],1,3)
10931         for elt in d:
10932             a,b,c=m.distanceToPoint(d)
10933             self.assertAlmostEqual(sqrt(1.2*1.2+2*2),a,14) ; self.assertEqual(0,b) ; self.assertEqual(0,c)
10934             pass
10935         #
10936         m=MEDCouplingUMesh("toto",1)
10937         coords=DataArrayDouble([0.,0.,4.,0.,0.,4.],3,2) ; m.setCoords(coords)
10938         m.allocateCells(0) ; m.insertNextCell(NORM_SEG2,[0,1]) ; m.insertNextCell(NORM_SEG2,[1,2])
10939         a,b,c=m.distanceToPoint([-0.1,4.1])
10940         self.assertAlmostEqual(0.14142135623730925,a,14) ; self.assertEqual(-1,b) ; self.assertEqual(2,c)
10941         a,b,c=m.distanceToPoint([0.,3.9])
10942         self.assertAlmostEqual(0.07071067811865482,a,14) ; self.assertEqual(1,b) ; self.assertEqual(2,c)
10943         pass
10944
10945     def testSwig2NonRegressionPartitionBySpreadZone1(self):
10946         m=MEDCouplingCMesh()
10947         arr=DataArrayDouble(6) ; arr.iota(0.)
10948         m.setCoords(arr,arr,arr)
10949         m=m.buildUnstructured()
10950         mPart=m[50,80,85,87,92,122]
10951         zones=mPart.partitionBySpreadZone()
10952         self.assertEqual(4,len(zones))
10953         self.assertTrue(zones[0].isEqual(DataArrayInt([0])))
10954         self.assertTrue(zones[1].isEqual(DataArrayInt([1,2])))
10955         self.assertTrue(zones[2].isEqual(DataArrayInt([3,4])))
10956         self.assertTrue(zones[3].isEqual(DataArrayInt([5])))
10957         #
10958         n,ni=m.computeNeighborsOfCells()
10959         a,b=MEDCouplingUMesh.ComputeSpreadZoneGraduallyFromSeed(0,n,ni)
10960         self.assertEqual(13,b) ; self.assertEqual(125,len(a)) ; self.assertTrue(a.isIdentity())
10961         a,b=MEDCouplingUMesh.ComputeSpreadZoneGraduallyFromSeed([1],n,ni)
10962         self.assertEqual(12,b) ; self.assertEqual(125,len(a)) ; self.assertTrue(a.isIdentity())
10963         a,b=MEDCouplingUMesh.ComputeSpreadZoneGraduallyFromSeed((2,),n,ni)
10964         self.assertEqual(11,b) ; self.assertEqual(125,len(a)) ; self.assertTrue(a.isIdentity())
10965         a,b=MEDCouplingUMesh.ComputeSpreadZoneGraduallyFromSeed(DataArrayInt([3]),n,ni)
10966         self.assertEqual(12,b) ; self.assertEqual(125,len(a)) ; self.assertTrue(a.isIdentity())
10967         pass
10968
10969     def testSwigUMeshInsertNextCell1(self):
10970         m=MEDCouplingUMesh("toto",2)
10971         #
10972         coords=DataArrayDouble([0.,0.,1.,1.,1.,0.]) ; m.setCoords(coords)
10973         da=DataArrayInt([0,1,2])
10974         m.allocateCells(0)
10975         for i in xrange(5):
10976             m.insertNextCell(NORM_TRI3,da)
10977             pass
10978         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])))
10979         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4,8,12,16,20])))
10980         #
10981         da=DataArrayInt([0,1,2,3])
10982         m.allocateCells(0)
10983         for i in xrange(5):
10984             m.insertNextCell(NORM_TRI3,3,da)
10985             pass
10986         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])))
10987         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4,8,12,16,20])))
10988         #
10989         da=DataArrayInt([0,1])
10990         m.allocateCells(0)
10991         self.assertRaises(InterpKernelException,m.insertNextCell,NORM_TRI3,3,da)
10992         #
10993         da=DataArrayInt([0,1,2,0,1,3,0,1,4,0,1,5,0,1,6],5,3)
10994         m.allocateCells(0)
10995         for t in da:
10996             m.insertNextCell(NORM_TRI3,t)
10997             pass
10998         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])))
10999         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4,8,12,16,20])))
11000         self.assertRaises(InterpKernelException,m.insertNextCell,NORM_TRI3,None)
11001         pass
11002
11003     def testSwigCurveLinearMesh1(self):
11004         m=MEDCouplingCurveLinearMesh("toto")
11005         m.setNodeGridStructure([2,3])
11006         coords=DataArrayDouble([0.,0., 2.,0., 0.,1., 1.9,1.1, 0.3,1.9, 2.2,2.1],6,2)
11007         m.setCoords(coords)
11008         m.checkCoherency()
11009         m0=m.deepCpy()
11010         self.assertTrue(m0.isEqual(m,1e-12))
11011         m.getCoords().setInfoOnComponents(["X [m]","Y [m]"])
11012         self.assertTrue(not m0.isEqual(m,1e-12))
11013         m0=m.deepCpy()
11014         self.assertTrue(m0.isEqual(m,1e-12))
11015         self.assertEqual(m.getNodeGridStructure(),(2,3))
11016         pass
11017
11018     def testSimplexize3(self):
11019         m=MEDCouplingUMesh("toto",3)
11020         m.allocateCells(0)
11021         m.insertNextCell(NORM_TETRA4,[0,1,2,3])
11022         m.insertNextCell(NORM_HEXA8,[4,5,6,7,8,9,10,11])
11023         m.insertNextCell(NORM_HEXA8,[12,13,14,15,16,17,18,19])
11024         m.insertNextCell(NORM_TETRA4,[20,21,22,23])
11025         c1=DataArrayDouble([0.,0.,0.,0.,1.,0.,1.,0.,0.,0.,0.,1.],4,3)
11026         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.]
11027         c3=c2+[2.,0.,0.]
11028         c4=c1+[6.,0.,0.]
11029         c=DataArrayDouble.Aggregate([c1,c2,c3,c4])
11030         m.setCoords(c)
11031         m.checkCoherency2()
11032         #
11033         m1=m.deepCpy()
11034         d1=m1.simplexize(PLANAR_FACE_5)
11035         m1.checkCoherency2()
11036         vol1=m1.getMeasureField(ON_CELLS).getArray()
11037         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))
11038         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])
11039         self.assertEqual(m1.getNodalConnectivityIndex().getValues(),[0,5,10,15,20,25,30,35,40,45,50,55,60])
11040         self.assertTrue(d1.isEqual(DataArrayInt([0,1,1,1,1,1,2,2,2,2,2,3])))
11041         #
11042         m2=m.deepCpy()
11043         d2=m2.simplexize(PLANAR_FACE_6)
11044         m2.checkCoherency2()
11045         vol2=m2.getMeasureField(ON_CELLS).getArray()
11046         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))
11047         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])
11048         self.assertEqual(m2.getNodalConnectivityIndex().getValues(),[0,5,10,15,20,25,30,35,40,45,50,55,60,65,70])
11049         self.assertTrue(d2.isEqual(DataArrayInt([0,1,1,1,1,1,1,2,2,2,2,2,2,3])))
11050         pass
11051
11052     def testSwig2CurveLinearMesh2(self):
11053         c=MEDCouplingCMesh()
11054         #2D
11055         arr1=DataArrayDouble([0,1,3,7])
11056         arr2=DataArrayDouble([0,1,1.5])
11057         c.setCoords(arr1,arr2)
11058         u=c.buildUnstructured()
11059         coo=u.getCoords()
11060         cl=MEDCouplingCurveLinearMesh()
11061         cl.setCoords(coo)
11062         cl.setNodeGridStructure([4,3])
11063         cl.checkCoherency2()
11064         li1=[1.,2.,4.,0.5,1.,2.]
11065         self.assertTrue(cl.getMeasureField(False).getArray().isEqual(DataArrayDouble(li1),1e-14))
11066         self.assertTrue(u.getMeasureField(False).getArray().isEqual(DataArrayDouble(li1),1e-14))
11067         li1_1=[0.5,0.5,2.,0.5,5.,0.5,0.5,1.25,2.,1.25,5.,1.25]
11068         self.assertTrue(cl.getBarycenterAndOwner().isEqual(DataArrayDouble(li1_1,6,2),1e-14))
11069         self.assertTrue(u.getBarycenterAndOwner().isEqual(DataArrayDouble(li1_1,6,2),1e-14))
11070         #3D
11071         c.setCoords(arr1,arr2,arr2)
11072         u=c.buildUnstructured()
11073         coo=u.getCoords()
11074         cl=MEDCouplingCurveLinearMesh()
11075         cl.setCoords(coo)
11076         cl.setNodeGridStructure([4,3,3])
11077         cl.checkCoherency2()
11078         li2=[1.,2.,4.,0.5, 1.,2.,0.5,1.,2.,0.25,0.5,1.]
11079         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]
11080         self.assertTrue(cl.getMeasureField(False).getArray().isEqual(DataArrayDouble(li2),1e-14))
11081         self.assertTrue(u.getMeasureField(False).getArray().isEqual(DataArrayDouble(li2),1e-14))
11082         self.assertTrue(cl.getBarycenterAndOwner().isEqual(DataArrayDouble(li2_1,12,3),1e-14))
11083         self.assertTrue(u.getBarycenterAndOwner().isEqual(DataArrayDouble(li2_1,12,3),1e-14))
11084         #1D spaceDim 1
11085         coo=DataArrayDouble(5) ; coo.iota(0.)
11086         coo=coo*coo
11087         cl.setCoords(coo)
11088         cl.setNodeGridStructure([5])
11089         cl.checkCoherency2()
11090         li3=[1.,3.,5.,7.]
11091         li3_1=[0.5,2.5,6.5,12.5]
11092         self.assertTrue(cl.getMeasureField(False).getArray().isEqual(DataArrayDouble(li3),1e-14))
11093         self.assertTrue(cl.buildUnstructured().getMeasureField(False).getArray().isEqual(DataArrayDouble(li3),1e-14))
11094         self.assertTrue(cl.getBarycenterAndOwner().isEqual(DataArrayDouble(li3_1),1e-14))
11095         self.assertTrue(cl.buildUnstructured().getBarycenterAndOwner().isEqual(DataArrayDouble(li3_1),1e-14))
11096         #1D spaceDim 2
11097         coo=DataArrayDouble.Meld(coo,coo)
11098         cl.setCoords(coo)
11099         cl.checkCoherency2()
11100         li4=[sqrt(2.)*elt for elt in [1.,3.,5.,7.]]
11101         li4_1=[0.5,0.5,2.5,2.5,6.5,6.5,12.5,12.5]
11102         self.assertTrue(cl.getMeasureField(False).getArray().isEqual(DataArrayDouble(li4),1e-14))
11103         self.assertTrue(cl.buildUnstructured().getMeasureField(False).getArray().isEqual(DataArrayDouble(li4),1e-14))
11104         self.assertTrue(cl.getBarycenterAndOwner().isEqual(DataArrayDouble(li4_1,4,2),1e-14))
11105         self.assertTrue(cl.buildUnstructured().getBarycenterAndOwner().isEqual(DataArrayDouble(li4_1,4,2),1e-14))
11106         pass
11107
11108     def testSwig2CurveLinearMeshNonRegression1(self):
11109         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)
11110         m=MEDCouplingCurveLinearMesh("toto")
11111         m.setCoords(coords)
11112         m.setNodeGridStructure([3,3,3])
11113         #
11114         vol=m.getMeasureField(False).getArray()
11115         self.assertTrue(vol.isEqual(DataArrayDouble([0.11450000709295281, 0.10583334351579375,0.11149999939029423,0.08866666863113633, 0.1404166805123294,0.1250000135352219,0.1270833433481557,0.13258334288001067]),1e-12))
11116         self.assertTrue(vol.isEqual(m.buildUnstructured().getMeasureField(False).getArray(),1e-12))
11117         #
11118         self.assertTrue(m.getBarycenterAndOwner().isEqual(m.buildUnstructured().getBarycenterAndOwner(),1e-12))
11119         pass
11120
11121     def testSwig2NonRegressionDASetSelectedComponents1(self):
11122         da=DataArrayDouble.New([1.,2.,3.,4.,5.,6.],3,2)
11123         dv=DataArrayDouble.New();
11124         dv.alloc(4,4)
11125         dv.fillWithZero()
11126         # da has less tuples than dv
11127         dv.setSelectedComponents(da,[1,0])
11128         #
11129         self.assertTrue(dv.isEqual(DataArrayDouble([2.,1.,0.,0.,4.,3.,0.,0.,6.,5.,0.,0.,0.,0.,0.,0.],4,4),1e-14))
11130         #
11131         da=DataArrayInt.New([1,2,3,4,5,6],3,2)
11132         dv=DataArrayInt.New();
11133         dv.alloc(4,4)
11134         dv.fillWithZero()
11135         # da has less tuples than dv
11136         dv.setSelectedComponents(da,[1,0])
11137         #
11138         self.assertTrue(dv.isEqual(DataArrayInt([2,1,0,0,4,3,0,0,6,5,0,0,0,0,0,0],4,4)))
11139         pass
11140
11141     def testSwigSetItem3(self):
11142         # 1-2
11143         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11144         d[3]=[1,2]
11145         self.assertTrue(d.isEqual(DataArrayDouble([0,0,0,0,0,0,1,2,0,0,0,0],6,2),1e-14))
11146         # 2-2 false
11147         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11148         d[[5,3,2]]=[1,2]
11149         self.assertTrue(d.isEqual(DataArrayDouble([0,0,0,0,1,2,1,2,0,0,1,2],6,2),1e-14))
11150         # 3-2 false
11151         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11152         d[:]=[1,2]
11153         self.assertTrue(d.isEqual(DataArrayDouble([1,2,1,2,1,2,1,2,1,2,1,2],6,2),1e-14))
11154         # 4-2 false
11155         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11156         d[DataArrayInt([0,3,4])]=[1,2]
11157         self.assertTrue(d.isEqual(DataArrayDouble([1,2,0,0,0,0,1,2,1,2,0,0],6,2),1e-14))
11158         # 5-2
11159         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11160         d[5,1]=[7]
11161         self.assertTrue(d.isEqual(DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,7],6,2),1e-14))
11162         # 6-2 false
11163         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11164         d[[3,5],1]=[7]
11165         self.assertTrue(d.isEqual(DataArrayDouble([0,0,0,0,0,0,0,7,0,0,0,7],6,2),1e-14))
11166         # 7-2 false
11167         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11168         d[:-1:2,1]=[7]
11169         self.assertTrue(d.isEqual(DataArrayDouble([0,7,0,0,0,7,0,0,0,7,0,0],6,2),1e-14))
11170         # 8-2 false
11171         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11172         d[DataArrayInt([0,3,4]),1]=[7]
11173         self.assertTrue(d.isEqual(DataArrayDouble([0,7,0,0,0,0,0,7,0,7,0,0],6,2),1e-14))
11174         # 9-2
11175         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11176         d[3,[1,0]]=[7,8]
11177         self.assertTrue(d.isEqual(DataArrayDouble([0,0,0,0,0,0,8,7,0,0,0,0],6,2),1e-14))
11178         # 10-2 false
11179         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11180         d[[1,3,4],[1,0]]=[7,8]
11181         self.assertTrue(d.isEqual(DataArrayDouble([0,0,8,7,0,0,8,7,8,7,0,0],6,2),1e-14))
11182         # 11-2 false
11183         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11184         d[1::2,[1,0]]=[7,8]
11185         self.assertTrue(d.isEqual(DataArrayDouble([0,0,8,7,0,0,8,7,0,0,8,7],6,2),1e-14))
11186         # 12-2 false
11187         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11188         d[DataArrayInt([1,4]),[1,0]]=[7,8]
11189         self.assertTrue(d.isEqual(DataArrayDouble([0,0,8,7,0,0,0,0,8,7,0,0],6,2),1e-14))
11190         # 13-2
11191         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11192         d[1,:-1]=[9]
11193         self.assertTrue(d.isEqual(DataArrayDouble([0,0,9,0,0,0,0,0,0,0,0,0],6,2),1e-14))
11194         # 14-2 false
11195         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11196         d[[1,4,5],:]=[7,8]
11197         self.assertTrue(d.isEqual(DataArrayDouble([0,0,7,8,0,0,0,0,7,8,7,8],6,2),1e-14))
11198         # 15-2 false
11199         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11200         d[1::2,:]=[3,9]
11201         self.assertTrue(d.isEqual(DataArrayDouble([0,0,3,9,0,0,3,9,0,0,3,9],6,2),1e-14))
11202         # 1-2
11203         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11204         d[3]=[1,2]
11205         self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,0,0,1,2,0,0,0,0],6,2)))
11206         # 2-2 false
11207         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11208         d[[5,3,2]]=[1,2]
11209         self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,1,2,1,2,0,0,1,2],6,2)))
11210         # 3-2 false
11211         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11212         d[:]=[1,2]
11213         self.assertTrue(d.isEqual(DataArrayInt([1,2,1,2,1,2,1,2,1,2,1,2],6,2)))
11214         # 4-2 false
11215         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11216         d[DataArrayInt([0,3,4])]=[1,2]
11217         self.assertTrue(d.isEqual(DataArrayInt([1,2,0,0,0,0,1,2,1,2,0,0],6,2)))
11218         # 5-2
11219         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11220         d[5,1]=[7]
11221         self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,7],6,2)))
11222         # 6-2 false
11223         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11224         d[[3,5],1]=[7]
11225         self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,0,0,0,7,0,0,0,7],6,2)))
11226         # 7-2 false
11227         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11228         d[:-1:2,1]=[7]
11229         self.assertTrue(d.isEqual(DataArrayInt([0,7,0,0,0,7,0,0,0,7,0,0],6,2)))
11230         # 8-2 false
11231         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11232         d[DataArrayInt([0,3,4]),1]=[7]
11233         self.assertTrue(d.isEqual(DataArrayInt([0,7,0,0,0,0,0,7,0,7,0,0],6,2)))
11234         # 9-2
11235         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11236         d[3,[1,0]]=[7,8]
11237         self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,0,0,8,7,0,0,0,0],6,2)))
11238         # 10-2 false
11239         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11240         d[[1,3,4],[1,0]]=[7,8]
11241         self.assertTrue(d.isEqual(DataArrayInt([0,0,8,7,0,0,8,7,8,7,0,0],6,2)))
11242         # 11-2 false
11243         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11244         d[1::2,[1,0]]=[7,8]
11245         self.assertTrue(d.isEqual(DataArrayInt([0,0,8,7,0,0,8,7,0,0,8,7],6,2)))
11246         # 12-2 false
11247         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11248         d[DataArrayInt([1,4]),[1,0]]=[7,8]
11249         self.assertTrue(d.isEqual(DataArrayInt([0,0,8,7,0,0,0,0,8,7,0,0],6,2)))
11250         # 13-2
11251         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11252         d[1,:-1]=[9]
11253         self.assertTrue(d.isEqual(DataArrayInt([0,0,9,0,0,0,0,0,0,0,0,0],6,2)))
11254         # 14-2 false
11255         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11256         d[[1,4,5],:]=[7,8]
11257         self.assertTrue(d.isEqual(DataArrayInt([0,0,7,8,0,0,0,0,7,8,7,8],6,2)))
11258         # 15-2 false
11259         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11260         d[1::2,:]=[3,9]
11261         self.assertTrue(d.isEqual(DataArrayInt([0,0,3,9,0,0,3,9,0,0,3,9],6,2)))
11262         pass
11263
11264     def testSwig2ConvertLinearCellsToQuadratic1(self):
11265         coordsExp=DataArrayDouble([-0.3,-0.3,0.2,-0.3,0.7,-0.3,-0.3,0.2,0.2,0.2,0.7,0.2,-0.3,0.7,0.2,0.7,0.7,0.7,-0.3,-0.05,-0.05,0.2,0.2,-0.05,-0.05,-0.3,0.45,-0.05,0.45,-0.3,0.45,0.2,0.7,-0.05,-0.05,0.7,0.2,0.45,-0.3,0.45,0.45,0.7,0.7,0.45],22,2)
11266         # 2D
11267         m2D=MEDCouplingDataForTest.build2DTargetMesh_1()
11268         m2D.convertLinearCellsToQuadratic(0)
11269         m2D.checkCoherency1()
11270         self.assertEqual(m2D.getNodalConnectivity().getValues(),[8,0,3,4,1,9,10,11,12,6,1,4,2,11,13,14,6,4,5,2,15,16,13,8,6,7,4,3,17,18,10,19,8,7,8,5,4,20,21,15,18])
11271         self.assertEqual(m2D.getNodalConnectivityIndex().getValues(),[0,9,16,23,32,41])
11272         self.assertTrue(m2D.getCoords().isEqual(coordsExp,1e-14))
11273         # 1D
11274         m1D=MEDCouplingDataForTest.build2DTargetMesh_1().buildDescendingConnectivity()[0]
11275         m1D.convertLinearCellsToQuadratic(0)
11276         m1D.checkCoherency1()
11277         self.assertEqual(m1D.getNodalConnectivity().getValues(),[2,0,3,9,2,3,4,10,2,4,1,11,2,1,0,12,2,4,2,13,2,2,1,14,2,4,5,15,2,5,2,16,2,6,7,17,2,7,4,18,2,3,6,19,2,7,8,20,2,8,5,21])
11278         self.assertEqual(m1D.getNodalConnectivityIndex().getValues(),[0,4,8,12,16,20,24,28,32,36,40,44,48,52])
11279         self.assertTrue(m1D.getCoords().isEqual(coordsExp,1e-14))
11280         # 3D
11281         m2D=MEDCouplingDataForTest.build2DTargetMesh_1()
11282         m2D.changeSpaceDimension(3)
11283         arr=DataArrayDouble(4);  arr.iota(0) ; z=MEDCouplingCMesh() ; z.setCoords(arr)
11284         m1D=z.buildUnstructured() ; m1D.setCoords(arr.changeNbOfComponents(3,0.))
11285         m1D.getCoords()[:]=m1D.getCoords()[:,[1,2,0]]
11286         cooTmp=m2D.getCoords()[:]
11287         m3D=m2D.buildExtrudedMesh(m1D,0)
11288         m3D.convertLinearCellsToQuadratic(0)
11289         m3D.checkCoherency1()
11290         # check of new m3D content
11291         coordsExp2=[coordsExp.changeNbOfComponents(3,i) for i in xrange(4)]
11292         coordsExp3=[DataArrayDouble.Meld(cooTmp[:,[0,1]],cooTmp[:,2]+(0.5+float(i))) for i in xrange(3)]
11293         coordsExp4=DataArrayDouble.Aggregate([coordsExp2[0],coordsExp3[0],coordsExp2[1],coordsExp3[1],coordsExp2[2],coordsExp3[2],coordsExp2[3]])
11294         c=DataArrayDouble.Aggregate(m3D.getCoords(),coordsExp4)
11295         self.assertEqual(len(coordsExp4),115)
11296         self.assertEqual(len(m3D.getCoords()),115)
11297         a,b=c.findCommonTuples(1e-14)
11298         self.assertEqual(len(b),len(coordsExp4)+1)
11299         e,f=DataArrayInt.BuildOld2NewArrayFromSurjectiveFormat2(2*115,a,b)
11300         self.assertEqual(f,115)
11301         self.assertTrue(e.isEqual(DataArrayInt([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,0,1,2,3,4,5,6,7,8,36,37,38,39,48,49,53,54,58,59,60,66,67,44,47,52,45,46,57,64,65,70,9,10,11,12,13,14,15,16,17,40,41,42,43,50,51,55,56,61,62,63,68,69,75,78,81,76,77,84,88,89,92,18,19,20,21,22,23,24,25,26,71,72,73,74,79,80,82,83,85,86,87,90,91,97,100,103,98,99,106,110,111,114,27,28,29,30,31,32,33,34,35,93,94,95,96,101,102,104,105,107,108,109,112,113])))
11302         self.assertTrue(DataArrayInt([30,0,3,4,1,9,12,13,10,36,37,38,39,40,41,42,43,44,45,46,47,25,1,4,2,10,13,11,38,48,49,42,50,51,47,46,52,25,4,5,2,13,14,11,53,54,48,55,56,50,46,57,52,30,6,7,4,3,15,16,13,12,58,59,37,60,61,62,41,63,64,65,46,45,30,7,8,5,4,16,17,14,13,66,67,53,59,68,69,55,62,65,70,57,46,30,9,12,13,10,18,21,22,19,40,41,42,43,71,72,73,74,75,76,77,78,25,10,13,11,19,22,20,42,50,51,73,79,80,78,77,81,25,13,14,11,22,23,20,55,56,50,82,83,79,77,84,81,30,15,16,13,12,24,25,22,21,61,62,41,63,85,86,72,87,88,89,77,76,30,16,17,14,13,25,26,23,22,68,69,55,62,90,91,82,86,89,92,84,77,30,18,21,22,19,27,30,31,28,71,72,73,74,93,94,95,96,97,98,99,100,25,19,22,20,28,31,29,73,79,80,95,101,102,100,99,103,25,22,23,20,31,32,29,82,83,79,104,105,101,99,106,103,30,24,25,22,21,33,34,31,30,85,86,72,87,107,108,94,109,110,111,99,98,30,25,26,23,22,34,35,32,31,90,91,82,86,112,113,104,108,111,114,106,99]).isEqual(m3D.getNodalConnectivity()))
11303         self.assertTrue(DataArrayInt([0,21,37,53,74,95,116,132,148,169,190,211,227,243,264,285]).isEqual(m3D.getNodalConnectivityIndex()))
11304         # testing explode3DMeshTo1D
11305         m3DSlice0=m3D[:5]
11306         m3DSlice0.zipCoords()
11307         a,b,c,d,e=m3DSlice0.explode3DMeshTo1D()
11308         self.assertTrue(b.isEqual(DataArrayInt([0,1,2,3,4,5,6,7,8,9,10,11,2,12,13,6,14,15,11,10,16,17,18,12,19,20,14,10,21,16,22,23,1,24,25,26,5,27,28,29,10,9,30,31,17,23,32,33,19,26,29,34,21,10])))
11309         self.assertTrue(c.isEqual(DataArrayInt([0,12,21,30,42,54])))
11310         self.assertTrue(d.isEqual(DataArrayInt([0,0,3,0,1,0,0,0,3,0,1,0,0,0,3,0,1,2,3,4,0,1,1,2,1,1,2,1,1,2,2,4,2,2,4,2,2,4,3,3,4,3,3,3,4,3,3,3,4,4,4,4,4,4])))
11311         self.assertTrue(e.isEqual(DataArrayInt([0,1,3,5,6,7,9,11,12,13,15,20,22,24,25,27,28,30,32,33,35,36,38,39,41,42,43,45,46,47,49,50,51,52,53,54])))
11312         self.assertTrue(a.getNodalConnectivity().isEqual(DataArrayInt([2,0,3,18,2,3,4,19,2,4,1,20,2,1,0,21,2,9,12,22,2,12,13,23,2,13,10,24,2,10,9,25,2,0,9,26,2,3,12,27,2,4,13,28,2,1,10,29,2,4,2,30,2,2,1,31,2,13,11,32,2,11,10,33,2,2,11,34,2,4,5,35,2,5,2,36,2,13,14,37,2,14,11,38,2,5,14,39,2,6,7,40,2,7,4,41,2,3,6,42,2,15,16,43,2,16,13,44,2,12,15,45,2,6,15,46,2,7,16,47,2,7,8,48,2,8,5,49,2,16,17,50,2,17,14,51,2,8,17,52])))
11313         self.assertTrue(a.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4,8,12,16,20,24,28,32,36,40,44,48,52,56,60,64,68,72,76,80,84,88,92,96,100,104,108,112,116,120,124,128,132,136,140])))
11314         self.assertTrue(a.getCoords().isEqual(DataArrayDouble([-0.3,-0.3,0.0,0.2,-0.3,0.0,0.7,-0.3,0.0,-0.3,0.2,0.0,0.2,0.2,0.0,0.7,0.2,0.0,-0.3,0.7,0.0,0.2,0.7,0.0,0.7,0.7,0.0,-0.3,-0.3,1.0,0.2,-0.3,1.0,0.7,-0.3,1.0,-0.3,0.2,1.0,0.2,0.2,1.0,0.7,0.2,1.0,-0.3,0.7,1.0,0.2,0.7,1.0,0.7,0.7,1.0,-0.3,-0.05,0.0,-0.05,0.2,0.0,0.2,-0.05,0.0,-0.05,-0.3,0.0,-0.3,-0.05,1.0,-0.05,0.2,1.0,0.2,-0.05,1.0,-0.05,-0.3,1.0,-0.3,-0.3,0.5,-0.3,0.2,0.5,0.2,0.2,0.5,0.2,-0.3,0.5,0.45,-0.05,0.0,0.45,-0.3,0.0,0.45,-0.05,1.0,0.45,-0.3,1.0,0.7,-0.3,0.5,0.45,0.2,0.0,0.7,-0.05,0.0,0.45,0.2,1.0,0.7,-0.05,1.0,0.7,0.2,0.5,-0.05,0.7,0.0,0.2,0.45,0.0,-0.3,0.45,0.0,-0.05,0.7,1.0,0.2,0.45,1.0,-0.3,0.45,1.0,-0.3,0.7,0.5,0.2,0.7,0.5,0.45,0.7,0.0,0.7,0.45,0.0,0.45,0.7,1.0,0.7,0.45,1.0,0.7,0.7,0.5],53,3),1e-14))
11315         pass
11316
11317     def testSwig2DataArrayPushBackValsSilent1(self):
11318         d=DataArrayDouble()
11319         d.pushBackValsSilent([4,5,6])
11320         self.assertTrue(d.isEqual(DataArrayDouble([4.,5.,6.]),1e-14))
11321         e=DataArrayDouble([1,2,3],1,3)
11322         for t in e: d.pushBackValsSilent(t)
11323         self.assertTrue(d.isEqual(DataArrayDouble([4.,5.,6.,1.,2.,3.]),1e-14))
11324         d.pushBackValsSilent(DataArrayDouble([9,10.]))
11325         self.assertTrue(d.isEqual(DataArrayDouble([4.,5.,6.,1.,2.,3.,9.,10.]),1e-14))
11326         d.pushBackValsSilent(DataArrayDouble(0,1))
11327         self.assertTrue(d.isEqual(DataArrayDouble([4.,5.,6.,1.,2.,3.,9.,10.]),1e-14))
11328         e=DataArrayDouble([1,2,3],3,1)
11329         for t in e: d.pushBackValsSilent(t)
11330         self.assertTrue(d.isEqual(DataArrayDouble([4.,5.,6.,1.,2.,3.,9.,10.,1.,2.,3.]),1e-14))
11331         d.pushBackValsSilent(77)
11332         self.assertTrue(d.isEqual(DataArrayDouble([4.,5.,6.,1.,2.,3.,9.,10.,1.,2.,3.,77.]),1e-14))
11333         #
11334         d=DataArrayInt()
11335         d.pushBackValsSilent([4,5,6])
11336         self.assertTrue(d.isEqual(DataArrayInt([4,5,6])))
11337         e=DataArrayInt([1,2,3],1,3)
11338         for t in e: d.pushBackValsSilent(t)
11339         self.assertTrue(d.isEqual(DataArrayInt([4,5,6,1,2,3])))
11340         d.pushBackValsSilent(DataArrayInt([9,10]))
11341         self.assertTrue(d.isEqual(DataArrayInt([4,5,6,1,2,3,9,10])))
11342         d.pushBackValsSilent(DataArrayInt(0,1))
11343         self.assertTrue(d.isEqual(DataArrayInt([4,5,6,1,2,3,9,10])))
11344         e=DataArrayInt([1,2,3],3,1)
11345         for t in e: d.pushBackValsSilent(t)
11346         self.assertTrue(d.isEqual(DataArrayInt([4,5,6,1,2,3,9,10,1,2,3])))
11347         d.pushBackValsSilent(77)
11348         self.assertTrue(d.isEqual(DataArrayInt([4,5,6,1,2,3,9,10,1,2,3,77])))
11349         pass
11350
11351     def testSwig2ConvertLinearCellsToQuadratic2(self):
11352         m2D=MEDCouplingDataForTest.build2DTargetMesh_1()
11353         ret=m2D.convertLinearCellsToQuadratic(1)
11354         self.assertTrue(ret.isIdentity())
11355         self.assertEqual(5,len(ret))
11356         m2D.checkCoherency1()
11357         coordsExp=DataArrayDouble([-0.3,-0.3,0.2,-0.3,0.7,-0.3,-0.3,0.2,0.2,0.2,0.7,0.2,-0.3,0.7,0.2,0.7,0.7,0.7,-0.3,-0.05,-0.05,0.2,0.2,-0.05,-0.05,-0.3,0.45,-0.05,0.45,-0.3,0.45,0.2,0.7,-0.05,-0.05,0.7,0.2,0.45,-0.3,0.45,0.45,0.7,0.7,0.45,-0.05,-0.05,0.3666666666666667,-0.1333333333333333,0.5333333333333332,0.03333333333333334,-0.05,0.45,0.45,0.45],27,2)
11358         self.assertTrue(m2D.getCoords().isEqual(coordsExp,1e-14))
11359         self.assertTrue(m2D.getNodalConnectivity().isEqual(DataArrayInt([9,0,3,4,1,9,10,11,12,22,7,1,4,2,11,13,14,23,7,4,5,2,15,16,13,24,9,6,7,4,3,17,18,10,19,25,9,7,8,5,4,20,21,15,18,26])))
11360         self.assertTrue(m2D.getNodalConnectivityIndex().isEqual(DataArrayInt([0,10,18,26,36,46])))
11361         #
11362         m2D=MEDCouplingDataForTest.build2DTargetMesh_1()[(0,3)] ; m2D.zipCoords()
11363         m2D.changeSpaceDimension(3)
11364         arr=DataArrayDouble(3);  arr.iota(0) ; z=MEDCouplingCMesh() ; z.setCoords(arr)
11365         m1D=z.buildUnstructured() ; m1D.setCoords(arr.changeNbOfComponents(3,0.))
11366         m1D.getCoords()[:]=m1D.getCoords()[:,[1,2,0]]
11367         cooTmp=m2D.getCoords()[:]
11368         m3D=m2D.buildExtrudedMesh(m1D,0)
11369         ret=m3D.convertLinearCellsToQuadratic(1)
11370         self.assertTrue(ret.isIdentity())
11371         self.assertEqual(4,len(ret))
11372         m3D.checkCoherency1()
11373         coordsExp2=DataArrayDouble([-0.3,-0.3,0.0,0.2,-0.3,0.0,-0.3,0.2,0.0,0.2,0.2,0.0,-0.3,0.7,0.0,0.2,0.7,0.0,-0.3,-0.3,1.0,0.2,-0.3,1.0,-0.3,0.2,1.0,0.2,0.2,1.0,-0.3,0.7,1.0,0.2,0.7,1.0,-0.3,-0.3,2.0,0.2,-0.3,2.0,-0.3,0.2,2.0,0.2,0.2,2.0,-0.3,0.7,2.0,0.2,0.7,2.0,-0.3,-0.05,0.0,-0.05,0.2,0.0,0.2,-0.05,0.0,-0.05,-0.3,0.0,-0.3,-0.05,1.0,-0.05,0.2,1.0,0.2,-0.05,1.0,-0.05,-0.3,1.0,-0.3,-0.3,0.5,-0.3,0.2,0.5,0.2,0.2,0.5,0.2,-0.3,0.5,-0.05,0.7,0.0,0.2,0.45,0.0,-0.3,0.45,0.0,-0.05,0.7,1.0,0.2,0.45,1.0,-0.3,0.45,1.0,-0.3,0.7,0.5,0.2,0.7,0.5,-0.3,-0.05,2.0,-0.05,0.2,2.0,0.2,-0.05,2.0,-0.05,-0.3,2.0,-0.3,-0.3,1.5,-0.3,0.2,1.5,0.2,0.2,1.5,0.2,-0.3,1.5,-0.05,0.7,2.0,0.2,0.45,2.0,-0.3,0.45,2.0,-0.3,0.7,1.5,0.2,0.7,1.5,-0.05,-0.05,0.0,-0.3,-0.05,0.5,-0.05,0.2,0.5,0.2,-0.05,0.5,-0.05,-0.3,0.5,-0.05,-0.05,1.0,-0.05,0.45,0.0,-0.05,0.7,0.5,0.2,0.45,0.5,-0.3,0.45,0.5,-0.05,0.45,1.0,-0.3,-0.05,1.5,-0.05,0.2,1.5,0.2,-0.05,1.5,-0.05,-0.3,1.5,-0.05,-0.05,2.0,-0.05,0.7,1.5,0.2,0.45,1.5,-0.3,0.45,1.5,-0.05,0.45,2.0,-0.05,-0.05,0.5,-0.05,0.45,0.5,-0.05,-0.05,1.5,-0.05,0.45,1.5],75,3)
11374         self.assertTrue(m3D.getCoords().isEqual(coordsExp2,1e-14))
11375         self.assertTrue(m3D.getNodalConnectivity().isEqual(DataArrayInt([27,0,2,3,1,6,8,9,7,18,19,20,21,22,23,24,25,26,27,28,29,51,52,53,54,55,56,71,27,4,5,3,2,10,11,9,8,30,31,19,32,33,34,23,35,36,37,28,27,57,58,59,53,60,61,72,27,6,8,9,7,12,14,15,13,22,23,24,25,38,39,40,41,42,43,44,45,56,62,63,64,65,66,73,27,10,11,9,8,16,17,15,14,33,34,23,35,46,47,39,48,49,50,44,43,61,67,68,63,69,70,74])))
11376         self.assertTrue(m3D.getNodalConnectivityIndex().isEqual(DataArrayInt([0,28,56,84,112])))
11377         pass
11378
11379     def testSwig2GaussNEIntegral1(self):
11380         m2D=MEDCouplingDataForTest.build2DTargetMesh_1()
11381         m0=m2D[0] ; m0.zipCoords()
11382         m1=m2D[[1,2]] ; m1.zipCoords()
11383         m2=m2D[[3,4]] ; m2.zipCoords()
11384         m0.convertLinearCellsToQuadratic(1)
11385         m1.convertLinearCellsToQuadratic(0)
11386         m2.convertLinearCellsToQuadratic(1)
11387         m=MEDCouplingUMesh.MergeUMeshes([m0,m1,m2])
11388         m.mergeNodes(1e-12)
11389         f=MEDCouplingFieldDouble(ON_GAUSS_NE)
11390         f.setMesh(m)
11391         arr=DataArrayDouble([1.1,2.2,3.3,4.4,5.5,6.6,7.7,8.8,9.9,
11392                              11.1,12.2,13.3,14.4,15.5,16.6,
11393                              21.1,22.2,23.3,24.4,25.5,26.6,
11394                              31.1,32.2,33.3,34.4,35.5,36.6,37.7,38.8,39.9,
11395                              41.1,42.2,43.3,44.4,45.5,46.6,47.7,48.8,49.9])
11396         arr2=DataArrayDouble(len(arr),2)
11397         arr2[:,0]=arr ; arr2[:,1]=arr+100
11398         f.setArray(arr2)
11399         f.checkCoherency()
11400         res=f.integral(False)
11401         # a=25./81 ; b=40./81 ; c=64./81
11402         # p1=0.11169079483905 ; p2=0.0549758718227661
11403         # 1st compo
11404         # c0=(a*(1.1+2.2+3.3+4.4)+b*(5.5+6.6+7.7+8.8)+c*9.9)*0.25/3.9999999999999978 ; c0=1.5837962962962973
11405         # c1=(p2*(11.1+12.2+13.3)+p1*(14.4+15.5+16.6))*0.125/0.4999999999854482 ; c1=1.8014347172346943
11406         # c2=(p2*(21.1+22.2+23.3)+p1*(24.4+25.5+26.6))*0.125/0.4999999999854482 ; c2=3.0514347172346943
11407         # c3=(a*(31.1+32.2+33.3+34.4)+b*(35.5+36.6+37.7+38.8)+c*39.9)*0.25/3.9999999999999978 ; c3=9.0837962962963
11408         # c4=(a*(41.1+42.2+43.3+44.4)+b*(45.5+46.6+47.7+48.8)+c*49.9)*0.25/3.9999999999999978 ; c4=11.583796296296303
11409         # c0+c1+c2+c3+c4=27.104258323358287
11410         integExp0=27.104258323358287
11411         self.assertAlmostEqual(res[0],integExp0,13)
11412         # 2nd compo
11413         # c0=(a*(101.1+102.2+103.3+104.4)+b*(105.5+106.6+107.7+108.8)+c*109.9)*0.25/3.9999999999999978 ; c0=26.58379629629631
11414         # c1=(p2*(111.1+112.2+113.3)+p1*(114.4+115.5+116.6))*0.125/0.4999999999854482 ; c1=14.301434717234699
11415         # c2=(p2*(121.1+122.2+123.3)+p1*(124.4+125.5+126.6))*0.125/0.4999999999854482 ; c2=15.5514347172347
11416         # c3=(a*(131.1+132.2+133.3+134.4)+b*(135.5+136.6+137.7+138.8)+c*139.9)*0.25/3.9999999999999978 ; c3=34.08379629629631
11417         # c4=(a*(141.1+142.2+143.3+144.4)+b*(145.5+146.6+147.7+148.8)+c*149.9)*0.25/3.9999999999999978 ; c4=36.58379629629632
11418         # c0+c1+c2+c3+c4=127.10425832335835
11419         integExp1=127.10425832335835
11420         self.assertAlmostEqual(res[1],integExp1,12)
11421         meas=f.getDiscretization().getMeasureField(f.getMesh(),False)
11422         intPerTuple=meas*f
11423         res2=intPerTuple.accumulate()
11424         self.assertAlmostEqual(res2[0],integExp0,13)
11425         self.assertAlmostEqual(res2[1],integExp1,12)
11426         #
11427         meas2=f.buildMeasureField(False)
11428         intPerTuple=meas2*f
11429         res3=intPerTuple.accumulate()
11430         self.assertAlmostEqual(res3[0],integExp0,13)
11431         self.assertAlmostEqual(res3[1],integExp1,12)
11432         #
11433         res4=f.getWeightedAverageValue(False) # res4==res2 because sum of area of mesh is equal to 1
11434         self.assertAlmostEqual(res4[0],integExp0,13)
11435         self.assertAlmostEqual(res4[1],integExp1,12)
11436         #
11437         m.scale([0,0],2.)
11438         #
11439         res5=f.getWeightedAverageValue() # res4==res4 because weighted average is not sensitive to the scaling
11440         self.assertAlmostEqual(res5[0],integExp0,13)
11441         self.assertAlmostEqual(res5[1],integExp1,12)
11442         meas3=f.buildMeasureField(False)
11443         delta=4*meas2.getArray()-meas3.getArray()
11444         delta.abs()
11445         self.assertTrue(delta.isUniform(0.,1e-16))
11446         res6=f.integral(False)
11447         self.assertAlmostEqual(res6[0],4.*integExp0,12)
11448         self.assertAlmostEqual(res6[1],4.*integExp1,11)
11449         pass
11450
11451     def testSwig2SlowDADFindClosestTupleId(self):
11452         nbPts=[10,]
11453         for nbPt in nbPts:
11454             d=DataArrayDouble(nbPt) ; d.iota() ; d*=1./(nbPt-1)
11455             c=MEDCouplingCMesh() ; c.setCoords(d,d) ; m=c.buildUnstructured() ; pts=m.getCoords() ; del m
11456             #
11457             d0=DataArrayDouble((nbPt-1)*(nbPt-1)) ; d0.iota() ; d0*=(3./((nbPt-1)*(nbPt-1))) ; d0=d0.applyFunc("exp(x)-1")
11458             d1=DataArrayDouble((nbPt-1)*(nbPt-1)) ; d1.iota()
11459             d2=DataArrayDouble.Meld(d0,d1) ; d2=d2.fromPolarToCart() ; d2+=[0.32,0.73]
11460             ids=pts.findClosestTupleId(d2)
11461             #print "Start of costly computation"
11462             idsExpected=DataArrayInt(len(d2))
11463             tmp=1e300
11464             for i,elt in enumerate(d2):
11465                 l,m=(pts-elt).magnitude().getMinValue()
11466                 idsExpected.setIJSilent(i,0,m)
11467                 if l<tmp:
11468                     tmp=l ; tmp1=m ; tmp2=i
11469                     pass
11470                 pass
11471             #print "End of costly computation"
11472             self.assertTrue(idsExpected.isEqual(ids))
11473             a,b,c=pts.minimalDistanceTo(d2)
11474             self.assertEqual(tmp,a)
11475             self.assertEqual(tmp1,b)
11476             self.assertEqual(tmp2,c)
11477             #
11478             l=[d2[:,i] for i in [0,1]]
11479             for elt in l: elt.reverse()
11480             d2i=DataArrayDouble.Meld(l)
11481             ids1=pts.findClosestTupleId(d2i)
11482             idsExpectedI=idsExpected.deepCpy() ; idsExpectedI.reverse()
11483             self.assertTrue(idsExpectedI.isEqual(ids1))
11484             #
11485             l=[pts[:,i] for i in [0,1]]
11486             for elt in l: elt.reverse()
11487             ptsi=DataArrayDouble.Meld(l)
11488             ids2=ptsi.findClosestTupleId(d2)
11489             idsExpected2=nbPt*nbPt-1-ids
11490             self.assertTrue(idsExpected2.isEqual(ids2))
11491             #
11492             ids3=ptsi.findClosestTupleId(d2i)
11493             idsExpected3=idsExpected2.deepCpy() ; idsExpected3.reverse()
11494             self.assertTrue(idsExpected3.isEqual(ids3))
11495             pass
11496
11497     def testSwig2DataArrayAsciiChar1(self):
11498         alpha=DataArrayInt(26) ; alpha.iota(ord("A"))
11499         d=DataArrayAsciiChar(alpha.getValues(),2,13)
11500         d.setInfoOnComponents(["c%i"%(v) for v in xrange(13)])
11501         self.assertEqual('ABCDEFGHIJKLM',d.getTuple(0))
11502         self.assertEqual('NOPQRSTUVWXYZ',d.getTuple(1))
11503         self.assertEqual(2,d.getNumberOfTuples())
11504         self.assertEqual(26,d.getNbOfElems())
11505         self.assertEqual(13,d.getNumberOfComponents())
11506         dd=d.deepCpy()
11507         self.assertTrue(d.isEqual(dd))
11508         dd.setIJ(0,3,'d')
11509         self.assertTrue(not d.isEqual(dd))
11510         d.setIJ(0,3,ord('d'))
11511         self.assertTrue(d.isEqual(dd))
11512         d.rearrange(1)
11513         d.reserve(20)
11514         self.assertEqual(20,d.getNumberOfTuples())
11515         self.assertEqual(20,d.getNbOfElems())
11516         self.assertEqual(1,d.getNumberOfComponents())
11517         #
11518         d0=DataArrayAsciiChar([ord('a')],1,1)
11519         self.assertEqual('a',d0.asciiCharValue())
11520         self.assertTrue(not d0.empty())
11521         d0=DataArrayAsciiChar(0,3)
11522         self.assertTrue(d0.empty())
11523         d.pushBackSilent("U") ; d.pushBackSilent("V") ; d.pushBackSilent("W")
11524         self.assertEqual("W",d.popBackSilent())
11525         d.rearrange(2)
11526         self.assertEqual(['AB','Cd','EF','GH','IJ','KL','MN','OP','QR','ST','UV'],d.toStrList())
11527         d.fillWithZero()
11528         self.assertEqual(11*[''],d.toStrList())
11529         d.fillWithValue('T')
11530         self.assertEqual(11*["TT"],d.toStrList())
11531         d.rearrange(1)
11532         self.assertTrue(d.isUniform("T"))
11533         d.rearrange(2)
11534         #
11535         dd.rearrange(2)
11536         dd2=dd.deepCpy()
11537         dd.renumberInPlace([3,1,2,4,0,11,10,9,8,7,5,12,6])
11538         self.assertEqual(dd.toStrList(),['IJ','Cd','EF','AB','GH','UV','YZ','ST','QR','OP','MN','KL','WX'])
11539         dd.renumberInPlaceR([3,1,2,4,0,11,10,9,8,7,5,12,6])
11540         self.assertEqual(['AB','Cd','EF','GH','IJ','KL','MN','OP','QR','ST','UV','WX','YZ'],dd.toStrList())
11541         e=dd.renumber([3,1,2,4,0,11,10,9,8,7,5,12,6])
11542         self.assertEqual(e.toStrList(),['IJ','Cd','EF','AB','GH','UV','YZ','ST','QR','OP','MN','KL','WX'])
11543         e=dd.renumberR([3,1,2,4,0,11,10,9,8,7,5,12,6])
11544         self.assertEqual(e.toStrList(),['GH','Cd','EF','IJ','AB','WX','UV','ST','QR','OP','KL','YZ','MN'])
11545         e=dd.renumberAndReduce([1,1,1,1,1,1,1,2,0,0,0,0,0],3)
11546         self.assertEqual(['YZ','MN','OP'],e.toStrList())
11547         self.assertEqual(['GH','IJ'],dd.selectByTupleIdSafe([3,4]).toStrList())
11548         self.assertEqual(['AB','GH','MN','ST','YZ'],dd.selectByTupleId2(0,13,3).toStrList())
11549         dd3=dd.changeNbOfComponents(3,"G")
11550         self.assertEqual(['ABG','CdG','EFG','GHG','IJG','KLG','MNG','OPG','QRG','STG','UVG','WXG','YZG'],dd3.toStrList())
11551         dd3.rearrange(1) ; self.assertEqual("G",dd3.back()) ; dd3.rearrange(3)
11552         self.assertTrue(dd3.changeNbOfComponents(2,"\0").isEqual(dd))
11553         self.assertEqual(len(dd),13)
11554         d=DataArrayAsciiChar(13,2) ; d.fillWithValue('Y')
11555         dd3.meldWith(d)
11556         self.assertEqual(['ABGYY','CdGYY','EFGYY','GHGYY','IJGYY','KLGYY','MNGYY','OPGYY','QRGYY','STGYY','UVGYY','WXGYY','YZGYY'],dd3.toStrList())
11557         self.assertEqual("d",dd3.getIJ(0,6))
11558         self.assertRaises(InterpKernelException,dd3.getIJSafe,0,6)
11559         self.assertEqual("d",dd3.getIJSafe(1,1))
11560         dd3.rearrange(1)
11561         e=dd3.getIdsEqual("Y")
11562         self.assertTrue(e.isEqual(DataArrayInt([3,4,8,9,13,14,18,19,23,24,28,29,33,34,38,39,43,44,48,49,53,54,58,59,60,63,64])))
11563         e=dd3.getIdsNotEqual("Y")
11564         self.assertTrue(e.isEqual(DataArrayInt([0,1,2,5,6,7,10,11,12,15,16,17,20,21,22,25,26,27,30,31,32,35,36,37,40,41,42,45,46,47,50,51,52,55,56,57,61,62])))
11565         self.assertEqual(("d",6),dd3.getMaxValue())
11566         self.assertEqual(("A",0),dd3.getMinValue())
11567         self.assertEqual(26,dd3.search("LGYYM"))
11568         self.assertEqual(-1,dd3.search("LGYYN"))
11569         dd3.rearrange(5)
11570         self.assertEqual(7,dd3.locateTuple("OPGYY"))
11571         self.assertTrue("OPGYY" in dd3)
11572         self.assertEqual(7,dd3.index("OPGYY"))
11573         self.assertEqual(-1,dd3.locateTuple("OPGYP"))
11574         dd3.rearrange(1)
11575         self.assertEqual(2,dd3.locateValue("OPGYY"))
11576         self.assertTrue(dd3.presenceOfValue("OPGYY"))
11577         self.assertTrue("O" in dd3)
11578         self.assertTrue(not dd3.presenceOfValue("z"))
11579         self.assertTrue("z" not in dd3)
11580         dd3.rearrange(5)
11581         l=list(dd3)
11582         self.assertEqual([e.buildDAAsciiChar().toStrList()[0] for e in list(dd3)],dd3.toStrList())
11583         dd3.reAlloc(5)
11584         dd4=DataArrayChar.Aggregate(dd3,dd3)
11585         self.assertEqual(['ABGYY','CdGYY','EFGYY','GHGYY','IJGYY','ABGYY','CdGYY','EFGYY','GHGYY','IJGYY'],dd4.toStrList())
11586         dd5=DataArrayChar.Aggregate([dd4,dd3,dd4])
11587         self.assertEqual(['ABGYY','CdGYY','EFGYY','GHGYY','IJGYY','ABGYY','CdGYY','EFGYY','GHGYY','IJGYY','ABGYY','CdGYY','EFGYY','GHGYY','IJGYY','ABGYY','CdGYY','EFGYY','GHGYY','IJGYY','ABGYY','CdGYY','EFGYY','GHGYY','IJGYY'],dd5.toStrList())
11588         # getitem,__iter__,__setitem__
11589         a=list(dd3)
11590         self.assertEqual("ABGYY",str(a[0]))
11591         dd4=dd3[::2]
11592         self.assertEqual(['ABGYY','EFGYY','IJGYY'],dd4.toStrList())
11593         dd4=dd3[(3,2,1)]
11594         self.assertEqual(['GHGYY','EFGYY','CdGYY'],dd4.toStrList())
11595         dd4=dd3[:]
11596         dd4[::2]=["12","345","67890"]
11597         self.assertEqual(['12   ','CdGYY','345  ','GHGYY','67890'],dd4.toStrList())
11598         dd4=dd3[:]
11599         dd4[[1,2]]=" "
11600         self.assertEqual(['ABGYY','     ','     ','GHGYY','IJGYY'],dd4.toStrList())
11601         dd4=dd3[:]
11602         dd4[4]='12345'
11603         self.assertEqual(['ABGYY','CdGYY','EFGYY','GHGYY','12345'],dd4.toStrList())
11604         dd4[0]=dd4[1]
11605         self.assertEqual(['CdGYY','CdGYY','EFGYY','GHGYY','12345'],dd4.toStrList())
11606         dd4=DataArrayAsciiChar(["abc","de","fghi"])
11607         self.assertEqual(['abc ','de  ','fghi'],dd4.toStrList())
11608         dd4=DataArrayAsciiChar(["abc","de","fghi"],"t")
11609         self.assertEqual(['abct','dett','fghi'],dd4.toStrList())
11610         pass
11611
11612     def testSwig2GaussNELocalizationOfDiscValues(self):
11613         m=MEDCouplingDataForTest.build2DTargetMesh_3()[[0,1,3,4,5,6,8,9]] # suppression of polygons
11614         f=MEDCouplingFieldDouble(ON_GAUSS_NE)
11615         f.setMesh(m)
11616         loc=f.getLocalizationOfDiscr()
11617         self.assertEqual(42,len(loc))
11618         self.assertTrue(loc.isEqual(DataArrayDouble([0.,0.,1.,0.,0.5,1.,0.,0.,1.,0.,1.,1.,0.,1.,0.,0.,1.,0.,0.5,1.,0.5,0.,0.75,0.5,0.25,0.5,0.,0.,1.,0.,1.,1.,0.,1.,0.5,0.,1.,0.5,0.5,1.,0.,0.5,0.,0.,0.5,1.,1.,0.,0.,0.,0.,1.,1.,1.,1.,0.,0.,0.,0.5,1.,1.,0.,0.25,0.5,0.75,0.5,0.5,0.,0.,0.,0.,1.,1.,1.,1.,0.,0.,0.5,0.5,1.,1.,0.5,0.5,0.],42,2),1e-13))
11619         m.changeSpaceDimension(3)
11620         m.getCoords()[:,2]=7.
11621         loc=f.getLocalizationOfDiscr()
11622         self.assertEqual(42,len(loc))
11623         self.assertTrue(loc.isEqual(DataArrayDouble([0.,0.,7.,1.,0.,7.,0.5,1.,7.,0.,0.,7.,1.,0.,7.,1.,1.,7.,0.,1.,7.,0.,0.,7.,1.,0.,7.,0.5,1.,7.,0.5,0.,7.,0.75,0.5,7.,0.25,0.5,7.,0.,0.,7.,1.,0.,7.,1.,1.,7.,0.,1.,7.,0.5,0.,7.,1.,0.5,7.,0.5,1.,7.,0.,0.5,7.,0.,0.,7.,0.5,1.,7.,1.,0.,7.,0.,0.,7.,0.,1.,7.,1.,1.,7.,1.,0.,7.,0.,0.,7.,0.5,1.,7.,1.,0.,7.,0.25,0.5,7.,0.75,0.5,7.,0.5,0.,7.,0.,0.,7.,0.,1.,7.,1.,1.,7.,1.,0.,7.,0.,0.5,7.,0.5,1.,7.,1.,0.5,7.,0.5,0.,7.],42,3),1e-13))
11624         pass
11625
11626     def testSwig2GaussMeasureAndIntegral(self):
11627         ft=MEDCouplingDataForTest.buildFieldOnGauss_1()
11628         mea=ft.buildMeasureField(False)
11629         mea.checkCoherency()
11630         self.assertTrue(mea.getArray().isEqual(DataArrayDouble([-0.08504076274779823,-0.06378057206084897,-0.08504076274779869,-0.10630095343474463,-0.12756114412169625,-0.10630095343474734,-0.0637805720608491,-0.0850407627477968,-0.1063009534347449,-0.0850407627477994,-0.10630095343474809,-0.1275611441216954,-0.037205333702161475,-0.037205333702161475,-0.037205333702161475,-0.037205333702161475,-0.047835429045636084,-0.047835429045636084,-0.047835429045636084,-0.047835429045636084,-0.05846552438911087,-0.05846552438911087,-0.05846552438911087,-0.05846552438911087,-0.037205333702161725,-0.037205333702161725,-0.037205333702161725,-0.037205333702161725,-0.047835429045635834,-0.047835429045635834,-0.047835429045635834,-0.047835429045635834,-0.05846552438911058,-0.05846552438911058,-0.05846552438911058,-0.05846552438911058,-0.03879154890291829,-0.03879154890291829,-0.03879154890291829,-0.04120270848015563,-0.04120270848015563,-0.04120270848015563,-0.03393028948486933,-0.03393028948486933,-0.03393028948486933,-0.03151955746491709,-0.03151955746491709,-0.03151955746491709,-0.02424752187358276,-0.02424752187358276,-0.02424752187358276,-0.026657914642918758,-0.026657914642918758,-0.026657914642918758,-0.04120270848015456,-0.04120270848015456,-0.04120270848015456,-0.03879154890291757,-0.03879154890291757,-0.03879154890291757,-0.031519557464916595,-0.031519557464916595,-0.031519557464916595,-0.03393028948487046,-0.03393028948487046,-0.03393028948487046,-0.0266579146429191,-0.0266579146429191,-0.0266579146429191,-0.024247521873582645,-0.024247521873582645,-0.024247521873582645,-0.01851718920904466,-0.01851718920904466,-0.01851718920904466,-0.01851718920904466,-0.029627502734471456,-0.029627502734471456,-0.029627502734471456,-0.029627502734471456,-0.04740400437515433,-0.015150427534672922,-0.015150427534672922,-0.015150427534672922,-0.015150427534672922,-0.024240684055476674,-0.024240684055476674,-0.024240684055476674,-0.024240684055476674,-0.038785094488762675,-0.011783665860301345,-0.011783665860301345,-0.011783665860301345,-0.011783665860301345,-0.018853865376482152,-0.018853865376482152,-0.018853865376482152,-0.018853865376482152,-0.030166184602371443,-0.018517189209044892,-0.018517189209044892,-0.018517189209044892,-0.018517189209044892,-0.029627502734471827,-0.029627502734471827,-0.029627502734471827,-0.029627502734471827,-0.04740400437515492,-0.015150427534672776,-0.015150427534672776,-0.015150427534672776,-0.015150427534672776,-0.02424068405547644,-0.02424068405547644,-0.02424068405547644,-0.02424068405547644,-0.03878509448876231,-0.011783665860301277,-0.011783665860301277,-0.011783665860301277,-0.011783665860301277,-0.01885386537648204,-0.01885386537648204,-0.01885386537648204,-0.01885386537648204,-0.030166184602371266]),1e-14))
11631         f=MEDCouplingFieldDouble(ft)
11632         arr=DataArrayDouble(126,2)
11633         arr[:,0]=range(126)
11634         arr[:,1]=range(126)
11635         arr[:,1]+=1000
11636         f.setArray(arr)
11637         f.checkCoherency()
11638         self.assertTrue(DataArrayDouble(f.integral(False)).isEqual(DataArrayDouble([-211.66121638700983,-4863.9563007698835]),1e-12))
11639         self.assertTrue(DataArrayDouble(f.getWeightedAverageValue()).isEqual(DataArrayDouble([45.496085813113595,1045.496085813114]),1e-12))
11640         self.assertTrue(DataArrayDouble(f.normL1()).isEqual(DataArrayDouble([45.49608581311362,1045.496085813114]),1e-12))
11641         self.assertTrue(DataArrayDouble(f.normL2()).isEqual(DataArrayDouble([58.16846378340898,1046.1241521947334]),1e-12))
11642         pass
11643
11644     def testSwig2FieldDiscretizationComputeMeshRestrictionFromTupleIds1(self):
11645         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1()
11646         f=MEDCouplingFieldDouble(ON_GAUSS_NE)
11647         f.setMesh(m)
11648         a,b=f.getDiscretization().computeMeshRestrictionFromTupleIds(f.getMesh(),[3,4,5,6,8,9,10,14,15,16,17])
11649         self.assertTrue(a.isEqual(DataArrayInt([1,4])))
11650         self.assertTrue(b.isEqual(DataArrayInt([4,5,6,14,15,16,17])))
11651         a,b=f.getDiscretization().computeMeshRestrictionFromTupleIds(f.getMesh(),DataArrayInt([0,1,2,3,5,7,8,9,10,11,12,18]))
11652         self.assertTrue(a.isEqual(DataArrayInt([0,2])))
11653         self.assertTrue(b.isEqual(DataArrayInt([0,1,2,3,7,8,9])))
11654         #
11655         f=MEDCouplingFieldDouble(ON_CELLS)
11656         f.setMesh(m)
11657         a,b=f.getDiscretization().computeMeshRestrictionFromTupleIds(f.getMesh(),[3,4])
11658         self.assertTrue(a.isEqual(DataArrayInt([3,4])))
11659         self.assertTrue(b.isEqual(DataArrayInt([3,4])))
11660         #
11661         f=MEDCouplingFieldDouble(ON_NODES)
11662         f.setMesh(m)
11663         a,b=f.getDiscretization().computeMeshRestrictionFromTupleIds(f.getMesh(),[1,2,3,4])
11664         self.assertTrue(a.isEqual(DataArrayInt([1])))
11665         self.assertTrue(b.isEqual(DataArrayInt([1,2,4])))
11666         #
11667         f=MEDCouplingDataForTest.buildFieldOnGauss_1()
11668         a,b=f.getDiscretization().computeMeshRestrictionFromTupleIds(f.getMesh(),[0,11,12,13,14,15,17,18,19,36,37,38,115,117,118,119,120,121,122,123,124,125])
11669         self.assertTrue(a.isEqual(DataArrayInt([0,11,12,18,35])))
11670         self.assertTrue(b.isEqual(DataArrayInt([0,11,12,13,14,15,36,37,38,117,118,119,120,121,122,123,124,125])))
11671         #
11672         d=DataArrayInt([0,3,7,9,15,18])
11673         e=DataArrayInt([0,1,2,3,7,8,15,16,17])
11674         a,b=d.searchRangesInListOfIds(e)
11675         self.assertTrue(a.isEqual(DataArrayInt([0,2,4])))
11676         self.assertTrue(b.isEqual(DataArrayInt([0,1,2,7,8,15,16,17])))
11677         pass
11678
11679     def testSwig2BigMem(self):
11680         if MEDCouplingSizeOfVoidStar()==64:
11681             d=DataArrayAsciiChar(223456789,16)
11682             self.assertTrue(d.getNumberOfTuples(),223456789)
11683             self.assertTrue(d.getNumberOfComponents(),16)
11684             d.setIJ(223456788,5,"r")
11685             self.assertTrue(d.getIJ(223456788,5),'r')
11686             d[223456787]="1234567890123456"
11687             self.assertTrue(d[223456787],'1234567890123456')
11688             self.assertRaises(InterpKernelException,d.rearrange,1)# fails because it would lead to nb of tuples > 2147483647
11689             pass
11690         pass
11691
11692     def testSwig2DAReverseMultiCompo1(self):
11693         d=DataArrayDouble(6,2)
11694         d[:,0]=range(6)
11695         d[:,1]=range(10,16)
11696         d.reverse()
11697         self.assertTrue(d.isEqual(DataArrayDouble([5.,15.,4.,14.,3.,13.,2.,12.,1.,11.,0.,10.],6,2),1e-14))
11698         d=DataArrayDouble(7,2)
11699         d[:,0]=range(7)
11700         d[:,1]=range(10,17)
11701         d.reverse()
11702         self.assertTrue(d.isEqual(DataArrayDouble([6.,16.,5.,15.,4.,14.,3.,13.,2.,12.,1.,11.,0.,10.],7,2),1e-14))
11703         #
11704         d=DataArrayInt(6,2)
11705         d[:,0]=range(6)
11706         d[:,1]=range(10,16)
11707         d.reverse()
11708         self.assertTrue(d.isEqual(DataArrayInt([5,15,4,14,3,13,2,12,1,11,0,10],6,2)))
11709         d=DataArrayInt(7,2)
11710         d[:,0]=range(7)
11711         d[:,1]=range(10,17)
11712         d.reverse()
11713         self.assertTrue(d.isEqual(DataArrayInt([6,16,5,15,4,14,3,13,2,12,1,11,0,10],7,2)))
11714         pass
11715
11716     def testSwigDAPow1(self):
11717         d=DataArrayInt(10)
11718         d.iota(0)
11719         d1=d.deepCpy()
11720         d.setIJ(2,0,-2)
11721         self.assertTrue((d**2).isEqual(DataArrayInt([0,1,4,9,16,25,36,49,64,81])))
11722         self.assertTrue((d**3).isEqual(DataArrayInt([0,1,-8,27,64,125,216,343,512,729])))
11723         for elt in [d]:
11724             elt**=2
11725             pass
11726         self.assertTrue(d.isEqual(DataArrayInt([0,1,4,9,16,25,36,49,64,81])))
11727         self.assertTrue((d1[:4]**d1[:4]).isEqual(DataArrayInt([1,1,4,27])))
11728         self.assertTrue((3**d1[:4]).isEqual(DataArrayInt([1,3,9,27])))
11729         d2=d1[:4]
11730         d2**=d2
11731         self.assertTrue(d2.isEqual(DataArrayInt([1,1,4,27])))
11732         self.assertRaises(InterpKernelException,d2.__pow__,-1)#non supporting negative pow in DataArrayInt.__pow__
11733         self.assertRaises(InterpKernelException,d2.__ipow__,-1)#non supporting negative pow in DataArrayInt.__pow__
11734         #
11735         d=DataArrayDouble(10)
11736         d.iota(0)
11737         d1=d.deepCpy()
11738         d.setIJ(2,0,-2.)
11739         self.assertTrue((d**2).isEqual(DataArrayDouble([0,1,4,9,16,25,36,49,64,81]),1e-12))
11740         self.assertTrue((d**3).isEqual(DataArrayDouble([0,1,-8,27,64,125,216,343,512,729]),1e-12))
11741         self.assertRaises(InterpKernelException,d.__pow__,3.1)#3.1 is double not integer -> not supporting negative values in d
11742         for elt in [d]:
11743             elt**=2
11744             pass
11745         self.assertTrue(d.isEqual(DataArrayDouble([0,1,4,9,16,25,36,49,64,81]),1e-12))
11746         self.assertTrue((d1[:4]**d1[:4]).isEqual(DataArrayDouble([1,1,4,27]),1e-12))
11747         self.assertTrue((3**d1[:4]).isEqual(DataArrayDouble([1,3,9,27]),1e-12))
11748         d2=d1[:4]
11749         d2**=d2
11750         self.assertTrue(d2.isEqual(DataArrayDouble([1,1,4,27]),1e-12))
11751         d2**=-0.5
11752         self.assertTrue(d2.isEqual(DataArrayDouble([1,1,1./2,1./sqrt(27.)]),1e-14))
11753         d3=-1./d1[1:5]
11754         self.assertTrue((3**d3).isEqual(DataArrayDouble([0.3333333333333333,0.5773502691896257,0.6933612743506348,0.7598356856515925]),1e-14))
11755         d4=d3.deepCpy() ; d4.abs()
11756         self.assertTrue((d4**d3).isEqual(DataArrayDouble([1.,sqrt(2.),1.4422495703074083,sqrt(2.)]),1e-14))
11757         d4**=d3
11758         self.assertTrue(d4.isEqual(DataArrayDouble([1.,sqrt(2.),1.4422495703074083,sqrt(2.)]),1e-14))
11759         pass
11760
11761     def testSwig2Baryenter3DForCellsWithVolumeZero1(self):
11762         coo=DataArrayDouble([0.,0.,0.,1.,0.,0.,0.,1.,0.],3,3)
11763         m2=MEDCouplingUMesh("mesh",2)
11764         m2.allocateCells(0)
11765         m2.insertNextCell(NORM_POLYGON,[0,1,2])
11766         m2.setCoords(coo)
11767         m2.checkCoherency1()
11768         #
11769         coo2=DataArrayDouble([0.,0.,0.,0.,0.,0.,0.,0.,2.],3,3)
11770         m1=MEDCouplingUMesh("mesh",1)
11771         m1.allocateCells(0)
11772         m1.insertNextCell(NORM_SEG2,[0,1])
11773         m1.insertNextCell(NORM_SEG2,[1,2])
11774         m1.setCoords(coo2)
11775         m1.checkCoherency1()
11776         #
11777         m3=m2.buildExtrudedMesh(m1,0)
11778         m3.insertNextCell(NORM_POLYHED,[3,4,5,-1,8,7,6,-1,4,3,6,7,-1,5,4,7,8,-1,5,4,-1,3,5,8,6])# addition of face #4 with null surface
11779         self.assertTrue(m3.getBarycenterAndOwner().isEqual(DataArrayDouble([0.3333333333333333,0.3333333333333333,0.,0.3333333333333333,0.3333333333333333,1.,0.3333333333333333,0.3333333333333333,1.],3,3),1e-13))
11780         m4,a,b,c,d=m3.buildDescendingConnectivity()
11781         self.assertTrue(m4.getBarycenterAndOwner().isEqual(DataArrayDouble([0.3333333333333333,0.3333333333333333,0.,0.3333333333333333,0.3333333333333333,0.,0.5,0.,0.,0.5,0.5,0.,0.,0.5,0.,0.3333333333333333,0.3333333333333333,2.,0.5,0.,1.,0.5,0.5,1.,0.,0.5,1.,0.5,0.5,0.],10,3),1e-13))
11782         pass
11783
11784     def testSwigRepr1(self):
11785         d=DataArrayDouble()
11786         self.assertTrue(len(d.__repr__())<100)
11787         d.alloc(1000,0) ; self.assertTrue(len(d.__repr__())<100)
11788         for i in xrange(100):
11789             d.alloc(i,1) ; d.iota(1.1234567890123456) ; d*=1e123
11790             self.assertTrue(len(d.__repr__())<500)
11791             pass
11792         for i in xrange(50):
11793             d.alloc(i,2) ; d.rearrange(1) ; d.iota(1.1234567890123456) ; d.rearrange(2) ; d*=1e123
11794             self.assertTrue(len(d.__repr__())<500)
11795             pass
11796         d.alloc(4000,1) ; d.iota() ; self.assertTrue(len(d.__repr__())<500)
11797         for i in xrange(2,4):
11798             d.alloc(362880,1) ; d.iota() ; d.rearrange(i) ; self.assertTrue(len(d.__repr__())<500)
11799             pass
11800         d.alloc(0,9)
11801         self.assertTrue(len(d.__repr__())<100)
11802         #
11803         d=DataArrayInt()
11804         self.assertTrue(len(d.__repr__())<100)
11805         d.alloc(1000,0) ; self.assertTrue(len(d.__repr__())<100)
11806         for i in xrange(100):
11807             d.alloc(i,1) ; d.iota(123456789)
11808             self.assertTrue(len(d.__repr__())<500)
11809             pass
11810         for i in xrange(50):
11811             d.alloc(i,2) ; d.rearrange(1) ; d.iota(123456789) ; d.rearrange(2)
11812             self.assertTrue(len(d.__repr__())<500)
11813             pass
11814         d.alloc(4000,1) ; d.iota() ; self.assertTrue(len(d.__repr__())<500)
11815         for i in xrange(2,10):
11816             d.alloc(362880,1) ; d.iota() ; d.rearrange(i) ; self.assertTrue(len(d.__repr__())<500)
11817             pass
11818         d.alloc(0,9)
11819         self.assertTrue(len(d.__repr__())<100)
11820         #
11821         d=DataArrayAsciiChar()
11822         d.alloc(1000,0) ; self.assertTrue(len(d.__repr__())<100)
11823         d.alloc(2,16) ; d[:]='1234567890ABCDEF'
11824         self.assertTrue(len(d.__repr__())<500)
11825         d.alloc(2000,16) ; d[:]='1234567890ABCDEF'
11826         self.assertTrue(len(d.__repr__())<500)
11827         d.alloc(0,16) ; d[:]='1234567890ABCDEF'
11828         self.assertTrue(len(d.__repr__())<100)
11829         #
11830         d=DataArrayByte()
11831         self.assertTrue(len(d.__repr__())<100)
11832         d.alloc(1000,0) ; self.assertTrue(len(d.__repr__())<100)
11833         d.alloc(0,16) ; self.assertTrue(len(d.__repr__())<100)
11834         d.alloc(5,1) ; d.fillWithValue(127)
11835         self.assertTrue(len(d.__repr__())<200)
11836         d.alloc(1000,1) ; d.fillWithValue(127)
11837         self.assertTrue(len(d.__repr__())<500)
11838         d.alloc(1000,3) ; d.fillWithValue(127)
11839         self.assertTrue(len(d.__repr__())<500)
11840         pass
11841
11842     def testSwig2MeshComputeIsoBarycenterOfNodesPerCell1(self):
11843         coo=DataArrayDouble([26.17509821414239,5.0374,200.,26.175098214142388,-5.0374,200.,17.450065476094927,20.1496,200.,8.725032738047464,25.187,200.,43.62516369023732,5.0374,200.,34.90013095218986,10.0748,200.,34.900130952189855,-10.0748,200.,43.625163690237315,-5.0374,200.,26.175098214142402,25.187,200.,26.175098214142395,35.2618,200.,17.45006547609493,40.2992,200.,8.725032738047469,35.2618,200.,26.17509821414239,5.0374,200.,26.175098214142388,-5.0374,200.,17.450065476094927,20.1496,200.,8.725032738047464,25.187,200.,43.62516369023732,5.0374,200.,34.90013095218986,10.0748,200.,34.900130952189855,-10.0748,200.,43.625163690237315,-5.0374,200.,26.175098214142402,25.187,200.,26.175098214142395,35.2618,200.,17.45006547609493,40.2992,200.,8.725032738047469,35.2618,200.],24,3)
11844         m=MEDCouplingUMesh.New("toto",3)
11845         m.allocateCells(0)
11846         m.insertNextCell(NORM_POLYHED,[4,5,0,1,6,7,-1,19,18,13,12,17,16,-1,5,4,16,17,-1,0,5,17,12,-1,1,0,12,13,-1,6,1,13,18,-1,7,6,18,19,-1,4,7,19,16])
11847         m.insertNextCell(NORM_POLYHED,[9,10,11,3,2,8,-1,20,14,15,23,22,21,-1,10,9,21,22,-1,11,10,22,23,-1,3,11,23,15,-1,2,3,15,14,-1,8,2,14,20,-1,9,8,20,21])
11848         m.setCoords(coo)
11849         m.checkCoherency1()
11850         #
11851         dReference=DataArrayDouble([(34.900130952189848,0.,200),(17.450065476094931,30.2244,200.)])
11852         self.assertTrue(m.computeIsoBarycenterOfNodesPerCell().isEqual(dReference,1e-12))
11853         m.getNodalConnectivity().setIJ(87,0,24)
11854         self.assertRaises(InterpKernelException,m.computeIsoBarycenterOfNodesPerCell)
11855         m.getNodalConnectivity().setIJ(87,0,-2)
11856         self.assertRaises(InterpKernelException,m.computeIsoBarycenterOfNodesPerCell)
11857         m.getNodalConnectivity().setIJ(87,0,21)# put again 21 as at the beginning
11858         #
11859         self.assertTrue(m.unPolyze())
11860         self.assertEqual([NORM_HEXGP12],m.getAllTypes())
11861         self.assertTrue(m.computeIsoBarycenterOfNodesPerCell().isEqual(dReference,1e-12))
11862         m.getNodalConnectivity().setIJ(25,0,24)
11863         self.assertRaises(InterpKernelException,m.computeIsoBarycenterOfNodesPerCell)
11864         m.getNodalConnectivity().setIJ(25,0,-1)
11865         self.assertRaises(InterpKernelException,m.computeIsoBarycenterOfNodesPerCell)
11866         pass
11867
11868     def testSwig2NonRegressionBugDescHexa20(self):
11869         coo=DataArrayDouble([0.,0.,0.,1.23,0.,0.,0.615,0.,0.,0.,2.1,0.,0.615,2.1,0.,1.23,2.1,0.,1.23,1.05,0.,0.,1.05,0.,0.,0.,2.16,1.23,0.,2.16,1.23,2.1,2.16,0.,2.1,2.16,0.,0.,4.32,0.615,0.,4.32,1.23,0.,4.32,1.23,1.05,4.32,1.23,2.1,4.32,0.615,2.1,4.32,0.,2.1,4.32,0.,1.05,4.32],20,3)
11870         m=MEDCouplingUMesh('mesh',3)
11871         m.allocateCells(0)
11872         m.insertNextCell(NORM_HEXA20,[0,3,5,1,12,18,16,14,7,4,6,2,19,17,15,13,8,11,10,9])
11873         m.setCoords(coo)
11874         m.checkCoherency1()
11875         #
11876         a,b,c,d,e=m.buildDescendingConnectivity()
11877         m2=MEDCouplingUMesh('mesh',2)
11878         m2.allocateCells(0)
11879         m2.setCoords(coo)
11880         conn2=[[0,3,5,1,7,4,6,2],[12,14,16,18,13,15,17,19],[0,12,18,3,8,19,11,7],[3,18,16,5,11,17,10,4],[5,16,14,1,10,15,9,6],[1,14,12,0,9,13,8,2]]
11881         for i in xrange(6):
11882             m2.insertNextCell(NORM_QUAD8,conn2[i])
11883             pass
11884         self.assertTrue(m2.isEqual(a,1e-12))
11885         self.assertTrue(b.isEqual(DataArrayInt([0,1,2,3,4,5])))
11886         self.assertTrue(c.isEqual(DataArrayInt([0,6])))
11887         self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,0,0])))
11888         self.assertTrue(e.isEqual(DataArrayInt([0,1,2,3,4,5,6])))
11889         #
11890         m.convertQuadraticCellsToLinear() ; m.zipCoords()
11891         m.convertLinearCellsToQuadratic(1)
11892         #
11893         coo2=DataArrayDouble([0.,0.,0.,1.23,0.,0.,0.,2.1,0.,1.23,2.1,0.,0.,0.,4.32,1.23,0.,4.32,1.23,2.1,4.32,0.,2.1,4.32,0.,1.05,0.,0.615,2.1,0.,1.23,1.05,0.,0.615,0.,0.,0.,1.05,4.32,0.615,2.1,4.32,1.23,1.05,4.32,0.615,0.,4.32,0.,0.,2.16,0.,2.1,2.16,1.23,2.1,2.16,1.23,0.,2.16,0.615,1.05,0.,0.,1.05,2.16,0.615,2.1,2.16,1.23,1.05,2.16,0.615,0.,2.16,0.615,1.05,4.32,0.615,1.05,2.16],27,3)
11894         m3=MEDCouplingUMesh("mesh",3)
11895         m3.allocateCells(1)
11896         m3.insertNextCell(NORM_HEXA27,[0,2,3,1,4,7,6,5,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26])
11897         m3.setCoords(coo2)
11898         self.assertTrue(m3.isEqual(m,1e-12))
11899         #
11900         a,b,c,d,e=m.buildDescendingConnectivity()
11901         conn4=[[0,2,3,1,8,9,10,11,20],[4,5,6,7,15,14,13,12,25],[0,4,7,2,16,12,17,8,21],[2,7,6,3,17,13,18,9,22],[3,6,5,1,18,14,19,10,23],[1,5,4,0,19,15,16,11,24]]
11902         m4=MEDCouplingUMesh("mesh",2)
11903         m4.allocateCells(0)
11904         for i in xrange(6):
11905             m4.insertNextCell(NORM_QUAD9,conn4[i])
11906             pass
11907         m4.setCoords(coo2)
11908         self.assertTrue(m4.isEqual(a,1e-12))
11909         self.assertTrue(b.isEqual(DataArrayInt([0,1,2,3,4,5])))
11910         self.assertTrue(c.isEqual(DataArrayInt([0,6])))
11911         self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,0,0])))
11912         self.assertTrue(e.isEqual(DataArrayInt([0,1,2,3,4,5,6])))
11913         pass
11914
11915     def setUp(self):
11916         pass
11917     pass
11918
11919 unittest.main()