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 datetime import datetime
  25 from MEDCouplingDataForTest import MEDCouplingDataForTest
  26 import rlcompleter,readline # this line has to be here, ot ensure a usability of MEDCoupling/MEDLoader. B4 removing it please notify to anthony.geay@cea.fr
  27
  28 class MEDCouplingBasicsTest(unittest.TestCase):
  29     def testArray2(self):
  30         arr=DataArrayDouble.New()
  31         arr.setValues([12.,11.,10.,9.,8.,7.,6.,5.,4.,3.,2.,1.],3,4)
  32         arr.setInfoOnComponent(0,"ggg");
  33         arr.setInfoOnComponent(1,"hhhh");
  34         arr.setInfoOnComponent(2,"jj");
  35         arr.setInfoOnComponent(3,"kkkkkk");
  36         arr2=arr.convertToIntArr();
  37         arr3=arr2.convertToDblArr();
  38         self.assertTrue(arr.isEqual(arr3,1e-14))
  39         pass
  40
  41     def testArray3(self):
  42         arr1=DataArrayInt.New();
  43         arr1Ref=[0,10,1,11,2,12,3,13,4,14,5,15,6,16]
  44         arr1.setValues(arr1Ref,7,2);
  45         self.assertEqual(7,arr1.getNumberOfTuples());
  46         self.assertEqual(2,arr1.getNumberOfComponents());
  47         self.assertEqual(arr1Ref,list(arr1.getValues()));
  48         arr2=arr1.substr(3);
  49         self.assertEqual(4,arr2.getNumberOfTuples());
  50         self.assertEqual(2,arr2.getNumberOfComponents());
  51         self.assertEqual(arr1Ref[6:],list(arr2.getValues()));
  52         arr3=arr1.substr(2,5);
  53         self.assertEqual(3,arr3.getNumberOfTuples());
  54         self.assertEqual(2,arr3.getNumberOfComponents());
  55         self.assertEqual(arr1Ref[4:10],list(arr3.getValues()));
  56         #
  57         arr4=DataArrayDouble.New();
  58         arr4Ref=[0.8,10.8,1.9,11.9,2.1,12.1,3.2,13.2,4.3,14.3,5.4,15.4,6.5,16.5]
  59         arr4.setValues(arr4Ref,7,2);
  60         self.assertEqual(7,arr4.getNumberOfTuples());
  61         self.assertEqual(2,arr4.getNumberOfComponents());
  62         tmp=arr4.getValues()
  63         for i in xrange(14):
  64             self.assertTrue(abs(arr4Ref[i]-tmp[i])<1e-14);
  65             pass
  66         arr5=arr4.substr(3);
  67         self.assertEqual(4,arr5.getNumberOfTuples());
  68         self.assertEqual(2,arr5.getNumberOfComponents());
  69         tmp=arr5.getValues()
  70         for i in xrange(8):
  71             self.assertTrue(abs(arr4Ref[6+i]-tmp[i])<1e-14);
  72             pass
  73         arr6=arr4.substr(2,5);
  74         self.assertEqual(3,arr6.getNumberOfTuples());
  75         self.assertEqual(2,arr6.getNumberOfComponents());
  76         tmp=arr6.getValues()
  77         for i in xrange(6):
  78             self.assertTrue(abs(arr4Ref[4+i]-tmp[i])<1e-14);
  79             pass
  80         pass
  81
  82     def testMesh(self):
  83         tab4=[1, 2, 8, 7, 2, 3, 9, 8, 3,
  84               4, 10, 9, 4, 5, 11, 10, 5,
  85               0, 6, 11, 0, 1, 7, 6 ]
  86         nbOfNodes=12
  87         nbOfCells=6
  88         coords=[ 0.024155, 0.04183768725682622, -0.305, 0.04831000000000001, -1.015761910347357e-17,
  89                  -0.305, 0.09662000000000001, -1.832979297858306e-18, -0.305, 0.120775, 0.04183768725682623,
  90                  -0.305, 0.09662000000000001, 0.08367537451365245, -0.305, 0.04831000000000001, 0.08367537451365246,
  91                  -0.305, 0.024155, 0.04183768725682622, -0.2863, 0.04831000000000001, -1.015761910347357e-17, -0.2863,
  92                  0.09662000000000001, -1.832979297858306e-18, -0.2863, 0.120775, 0.04183768725682623, -0.2863, 0.09662000000000001,
  93                  0.08367537451365245, -0.2863, 0.04831000000000001, 0.08367537451365246, -0.2863 ]
  94         self.assertEqual(MEDCouplingMesh.GetNumberOfNodesOfGeometricType(NORM_TRI3),3)
  95         self.assertTrue(MEDCouplingMesh.IsStaticGeometricType(NORM_TRI3))
  96         self.assertTrue(MEDCouplingMesh.IsLinearGeometricType(NORM_TRI3))
  97         self.assertEqual(MEDCouplingMesh.GetDimensionOfGeometricType(NORM_TRI3),2)
  98         self.assertEqual(MEDCouplingMesh.GetReprOfGeometricType(NORM_TRI3),"NORM_TRI3")
  99         self.assertRaises(InterpKernelException,MEDCouplingMesh.GetNumberOfNodesOfGeometricType,NORM_POLYGON)
 100         self.assertTrue(not MEDCouplingMesh.IsStaticGeometricType(NORM_POLYGON))
 101         self.assertTrue(MEDCouplingMesh.IsLinearGeometricType(NORM_POLYGON))
 102         self.assertEqual(MEDCouplingMesh.GetDimensionOfGeometricType(NORM_POLYGON),2)
 103         self.assertEqual(MEDCouplingMesh.GetReprOfGeometricType(NORM_POLYGON),"NORM_POLYGON")
 104         self.assertEqual(MEDCouplingMesh.GetNumberOfNodesOfGeometricType(NORM_TRI6),6)
 105         self.assertTrue(MEDCouplingMesh.IsStaticGeometricType(NORM_TRI6))
 106         self.assertTrue(not MEDCouplingMesh.IsLinearGeometricType(NORM_TRI6))
 107         self.assertEqual(MEDCouplingMesh.GetDimensionOfGeometricType(NORM_TRI6),2)
 108         self.assertEqual(MEDCouplingMesh.GetReprOfGeometricType(NORM_TRI6),"NORM_TRI6")
 109         mesh=MEDCouplingUMesh.New()
 110         mesh.setMeshDimension(2)
 111         mesh.allocateCells(8);
 112         mesh.setName("mesh1")
 113         self.assertTrue(mesh.getName()=="mesh1")
 114         for i in range(nbOfCells):
 115             mesh.insertNextCell(NORM_QUAD4,4,tab4[4*i:4*(i+1)]);
 116             pass
 117         mesh.finishInsertingCells()
 118         self.assertTrue(mesh.getNumberOfCells()==nbOfCells)
 119         self.assertTrue(mesh.getNodalConnectivity().getNbOfElems()==30)
 120         self.assertTrue(mesh.getNodalConnectivityIndex().getNbOfElems()==nbOfCells+1)
 121         myCoords=DataArrayDouble.New()
 122         myCoords.setValues(coords,nbOfNodes,3);
 123         self.assertTrue(myCoords.getIJ(3,2)==-0.305)
 124         mesh.setCoords(myCoords);
 125         mesh.checkCoherency();
 126         self.assertTrue(mesh.getAllTypes()==[4])
 127         myFalseConn=DataArrayInt.New()
 128         myFalseConn.setValues(tab4,6,4)
 129         self.assertTrue(myFalseConn.getIJ(1,1)==3)
 130         #
 131         field=MEDCouplingFieldDouble.New(ON_CELLS)
 132         field.setMesh(mesh)
 133         field.setNature(Integral)
 134         myCoords=DataArrayDouble.New()
 135         sampleTab=[]
 136         for i in range(nbOfCells*9):
 137             sampleTab.append(float(i))
 138         myCoords.setValues(sampleTab,nbOfCells,9);
 139         field.setArray(myCoords)
 140         self.assertTrue(3==mesh.getSpaceDimension())
 141         field.checkCoherency()
 142         mesh2=mesh.clone(False)
 143         mesh3=mesh.clone(True)
 144         mesh3=0
 145         mesh2=0
 146         ## deep full recursively copy of field -> both field and mesh underneath copied
 147         field2=field.clone(True)
 148         field2.setMesh(field.getMesh().clone(True))
 149         mesh3=mesh.clone(True)
 150         field3=mesh3.fillFromAnalytic(ON_CELLS,2,"x*IVec+(y+z)*JVec")
 151         field3.applyFunc("u*u*u+cos(u)")
 152         pass
 153
 154     def testMeshPointsCloud(self):
 155         targetCoords=[-0.3,-0.3,0.5, 0.2,-0.3,1., 0.7,-0.3,1.5,
 156                       -0.3,0.2,0.5, 0.2,0.2,1., 0.7,0.2,1.5, -0.3,0.7,0.5, 0.2,0.7,1., 0.7,0.7,1.5]
 157         targetMesh=MEDCouplingUMesh.New();
 158         targetMesh.setMeshDimension(0);
 159         targetMesh.allocateCells(8);
 160         targetMesh.insertNextCell(NORM_POINT1,1,[0]);
 161         targetMesh.insertNextCell(NORM_POINT1,1,[1]);
 162         targetMesh.insertNextCell(NORM_POINT1,1,[2]);
 163         targetMesh.insertNextCell(NORM_POINT1,1,[3]);
 164         targetMesh.insertNextCell(NORM_POINT1,1,[4]);
 165         targetMesh.insertNextCell(NORM_POINT1,1,[5]);
 166         targetMesh.insertNextCell(NORM_POINT1,1,[7]);
 167         targetMesh.insertNextCell(NORM_POINT1,1,[6]);
 168         targetMesh.finishInsertingCells();
 169         self.assertRaises(InterpKernelException,targetMesh.checkCoherency);
 170         myCoords=DataArrayDouble.New();
 171         myCoords.setValues(targetCoords,9,3);
 172         targetMesh.setCoords(myCoords);
 173         self.assertEqual(targetMesh.getSpaceDimension(),3)
 174         self.assertEqual(targetMesh.getNumberOfCells(),8)
 175         self.assertEqual(targetMesh.getNumberOfNodes(),9)
 176         self.assertEqual(targetMesh.getMeshDimension(),0)
 177         pass
 178
 179     def testMeshM1D(self):
 180         meshM1D=MEDCouplingUMesh.New();
 181         self.assertRaises(InterpKernelException,meshM1D.getMeshDimension);
 182         self.assertRaises(InterpKernelException,meshM1D.getNumberOfNodes);
 183         self.assertRaises(InterpKernelException,meshM1D.getNumberOfCells);
 184         self.assertRaises(InterpKernelException,meshM1D.setMeshDimension,-2)
 185         self.assertRaises(InterpKernelException,meshM1D.setMeshDimension,-10)
 186         meshM1D.setMeshDimension(-1);
 187         meshM1D.checkCoherency();
 188         self.assertEqual(meshM1D.getMeshDimension(),-1);
 189         self.assertEqual(meshM1D.getNumberOfCells(),1);
 190         self.assertRaises(InterpKernelException,meshM1D.getNumberOfNodes);
 191         self.assertRaises(InterpKernelException,meshM1D.getSpaceDimension);
 192         cpy=meshM1D.clone(True);
 193         self.assertTrue(cpy.isEqual(meshM1D,1e-12));
 194         fieldOnCells=MEDCouplingFieldDouble.New(ON_CELLS);
 195         fieldOnCells.setMesh(meshM1D);
 196         array=DataArrayDouble.New();
 197         array.setValues(6*[7.],1,6);
 198         fieldOnCells.setArray(array);
 199         fieldOnCells.checkCoherency();
 200         pass
 201
 202     def testDeepCopy(self):
 203         array=DataArrayDouble.New();
 204         array.setValues(5*3*[7.],5,3);
 205         self.assertEqual(array.getIJ(3,2),7.);
 206         array2=array.deepCpy();
 207         self.assertEqual(array2.getIJ(3,2),7.)
 208         #
 209         array3=DataArrayInt.New();
 210         array3.setValues(5*3*[17],5,3);
 211         self.assertEqual(array3.getIJ(3,2),17);
 212         array4=array3.deepCpy();
 213         self.assertEqual(array4.getIJ(3,2),17);
 214         pass
 215
 216     def testRevNodal(self):
 217         mesh=MEDCouplingDataForTest.build2DTargetMesh_1()
 218         revNodal,revNodalIndx=mesh.getReverseNodalConnectivity();
 219         revNodalExpected=[0,0,1,1,2,0,3,0,1,2,3,4,2,4,3,3,4,4];
 220         revNodalIndexExpected=[0,1,3,5,7,12,14,15,17,18];
 221         self.assertEqual(revNodal.getNbOfElems(),18)
 222         self.assertEqual(revNodalIndx.getNbOfElems(),10)
 223         self.assertEqual(list(revNodal.getValues()),revNodalExpected)
 224         self.assertEqual(list(revNodalIndx.getValues()),revNodalIndexExpected)
 225         pass
 226
 227     def testConvertToPolyTypes(self):
 228         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
 229         elts=[1,3];
 230         mesh.convertToPolyTypes(elts);
 231         mesh.checkCoherency();
 232         self.assertEqual(5,mesh.getNumberOfCells());
 233         self.assertEqual(23,mesh.getNodalConnectivity().getNumberOfTuples());
 234         expected1=[4, 0, 3, 4, 1, 5, 1, 4, 2, 3, 4, 5, 2, 5, 6, 7, 4, 3, 4, 7, 8, 5, 4]
 235         self.assertEqual(expected1,list(mesh.getNodalConnectivity().getValues()));
 236         #
 237         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
 238         mesh.convertToPolyTypes(elts);
 239         mesh.checkCoherency();
 240         self.assertEqual(8,mesh.getNumberOfCells());
 241         self.assertEqual(114,mesh.getNodalConnectivity().getNumberOfTuples());
 242         mesh.convertToPolyTypes(elts);
 243         mesh.checkCoherency();
 244         self.assertEqual(8,mesh.getNumberOfCells());
 245         self.assertEqual(114,mesh.getNodalConnectivity().getNumberOfTuples());
 246         pass
 247
 248     def testDescConn2D(self):
 249         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
 250         desc=DataArrayInt.New();
 251         descIndx=DataArrayInt.New();
 252         revDesc=DataArrayInt.New();
 253         revDescIndx=DataArrayInt.New();
 254         mesh2=mesh.buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
 255         mesh2.checkCoherency();
 256         self.assertEqual(1,mesh2.getMeshDimension());
 257         self.assertEqual(13,mesh2.getNumberOfCells());
 258         self.assertEqual(14,revDescIndx.getNbOfElems()); self.assertEqual(14,revDescIndx.getNumberOfTuples());
 259         self.assertEqual(6,descIndx.getNbOfElems()); self.assertEqual(6,descIndx.getNumberOfTuples());
 260         self.assertEqual(18,desc.getNbOfElems()); self.assertEqual(18,desc.getNumberOfTuples());
 261         self.assertEqual(18,revDesc.getNbOfElems()); self.assertEqual(18,revDesc.getNumberOfTuples());
 262         expected1=[0,1,2,3, 2,4,5, 6,7,4, 8,9,1,10, 11,12,6,9];
 263         self.assertEqual(expected1,list(desc.getValues()));
 264         expected2=[0,4,7,10,14,18];
 265         self.assertEqual(expected2,list(descIndx.getValues()));
 266         expected3=[0,1,3,5,6,8,9,11,12,13,15,16,17,18];
 267         self.assertEqual(expected3,list(revDescIndx.getValues()));
 268         expected4=[0, 0,3, 0,1, 0, 1,2, 1, 2,4, 2, 3, 3,4, 3, 4, 4];
 269         self.assertEqual(expected4,list(revDesc.getValues()));
 270         conn=mesh2.getNodalConnectivity();
 271         connIndex=mesh2.getNodalConnectivityIndex();
 272         expected5=[0,3,6,9,12,15,18,21,24,27,30,33,36,39];
 273         self.assertEqual(expected5,list(connIndex.getValues()));
 274         expected6=[1, 0, 3, 1, 3, 4, 1, 4, 1, 1, 1, 0, 1, 4, 2, 1, 2, 1, 1, 4, 5, 1, 5, 2, 1, 6, 7, 1, 7, 4, 1, 3, 6, 1, 7, 8, 1, 8, 5];
 275         self.assertEqual(expected6,list(conn.getValues()));
 276         #
 277         eltsV=[1,3];
 278         mesh.convertToPolyTypes(eltsV);
 279         mesh.checkCoherency();
 280         #
 281         desc=DataArrayInt.New();
 282         descIndx=DataArrayInt.New();
 283         revDesc=DataArrayInt.New();
 284         revDescIndx=DataArrayInt.New();
 285         #
 286         mesh2=mesh.buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
 287         mesh2.checkCoherency();
 288         self.assertEqual(1,mesh2.getMeshDimension());
 289         self.assertEqual(13,mesh2.getNumberOfCells());
 290         self.assertEqual(14,revDescIndx.getNbOfElems()); self.assertEqual(14,revDescIndx.getNumberOfTuples());
 291         self.assertEqual(6,descIndx.getNbOfElems()); self.assertEqual(6,descIndx.getNumberOfTuples());
 292         self.assertEqual(18,desc.getNbOfElems()); self.assertEqual(18,desc.getNumberOfTuples());
 293         self.assertEqual(18,revDesc.getNbOfElems()); self.assertEqual(18,revDesc.getNumberOfTuples());
 294         self.assertEqual(expected1,list(desc.getValues()));
 295         self.assertEqual(expected2,list(descIndx.getValues()));
 296         self.assertEqual(expected3,list(revDescIndx.getValues()));
 297         self.assertEqual(expected4,list(revDesc.getValues()));
 298         conn=mesh2.getNodalConnectivity();
 299         connIndex=mesh2.getNodalConnectivityIndex();
 300         self.assertEqual(expected5,list(connIndex.getValues()));
 301         self.assertEqual(expected6,list(conn.getValues()));
 302         pass
 303
 304     def testDescConn3D(self):
 305         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
 306         desc=DataArrayInt.New();
 307         descIndx=DataArrayInt.New();
 308         revDesc=DataArrayInt.New();
 309         revDescIndx=DataArrayInt.New();
 310         #
 311         mesh2=mesh.buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
 312         mesh2.checkCoherency();
 313         self.assertEqual(2,mesh2.getMeshDimension());
 314         self.assertEqual(36,mesh2.getNumberOfCells());
 315         self.assertEqual(37,revDescIndx.getNbOfElems()); self.assertEqual(37,revDescIndx.getNumberOfTuples());
 316         self.assertEqual(9,descIndx.getNbOfElems()); self.assertEqual(9,descIndx.getNumberOfTuples());
 317         self.assertEqual(48,desc.getNbOfElems()); self.assertEqual(48,desc.getNumberOfTuples());
 318         self.assertEqual(48,revDesc.getNbOfElems()); self.assertEqual(48,revDesc.getNumberOfTuples());
 319         expected1=[0, 6, 12, 18, 24, 30, 36, 42, 48]
 320         expected2=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 3, 11, 12, 4, 13, 14, 15, 16, 17, 10, 18, 19, 13, 1, 20, 21, 22, 23, 24, 7, 25, 26, 27, 28, 22, 12, 29, 23, 30, 31, 32, 17, 33, 28, 34, 35, 30]
 321         expected3=[0, 1, 3, 4, 6, 8, 9, 10, 12, 13, 14, 16, 17, 19, 21, 22, 23, 24, 26, 27, 28, 29, 30, 32, 34, 35, 36, 37, 38, 40, 41, 43, 44, 45, 46, 47, 48]
 322         expected4=[0, 0, 4, 0, 0, 1, 0, 2, 0, 1, 1, 5, 1, 1, 1, 3, 2, 2, 6, 2, 3, 2, 2, 3, 3, 7, 3, 3, 4, 4, 4, 5, 4, 6, 4, 5, 5, 5, 5, 7, 6, 6, 7, 6, 6, 7, 7, 7]
 323         expected5=[0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95, 100, 105, 110, 115, 120, 125, 130, 135, 140, 145, 150, 155, 160, 165, 170, 175, 180]
 324         expected6=[4, 0, 1, 4, 3, 4, 9, 12, 13, 10, 4, 0, 9, 10, 1, 4, 1, 10, 13, 4, 4, 4, 13, 12, 3, 4, 3, 12, 9, 0, 4, 1, 2, 5, 4, 4, 10, 13, 14, 11, 4, 1, 10, 11, 2, 4, 2, 11, 14,
 325                    5, 4, 5, 14, 13, 4, 4, 3, 4, 7, 6, 4, 12, 15, 16, 13, 4, 4, 13, 16, 7, 4, 7, 16, 15, 6, 4, 6, 15, 12, 3, 4, 4, 5, 8, 7, 4, 13, 16, 17, 14, 4, 5, 14, 17, 8, 4, 8,
 326                    17, 16, 7, 4, 18, 21, 22, 19, 4, 9, 18, 19, 10, 4, 10, 19, 22, 13, 4, 13, 22, 21, 12, 4, 12, 21, 18, 9, 4, 19, 22, 23, 20, 4, 10, 19, 20, 11, 4, 11, 20, 23, 14, 4,
 327                    14, 23, 22, 13, 4, 21, 24, 25, 22, 4, 13, 22, 25, 16, 4, 16, 25, 24, 15, 4, 15, 24, 21, 12, 4, 22, 25, 26, 23, 4, 14, 23, 26, 17, 4, 17, 26, 25, 16]
 328         expected7=[4, 0, 1, 4, 3, 4, 9, 12, 13, 10, 4, 0, 9, 10, 1, 4, 1, 10, 13, 4, 4, 4, 13, 12, 3, 4, 3, 12, 9, 0, 5, 1, 2, 5, 4, 5, 10, 13, 14, 11, 5, 1, 10, 11, 2, 5, 2, 11, 14,
 329                    5, 5, 5, 14, 13, 4, 4, 3, 4, 7, 6, 4, 12, 15, 16, 13, 4, 4, 13, 16, 7, 4, 7, 16, 15, 6, 4, 6, 15, 12, 3, 5, 4, 5, 8, 7, 5, 13, 16, 17, 14, 5, 5, 14, 17, 8, 5, 8,
 330                    17, 16, 7, 4, 18, 21, 22, 19, 4, 9, 18, 19, 10, 4, 10, 19, 22, 13, 4, 13, 22, 21, 12, 4, 12, 21, 18, 9, 4, 19, 22, 23, 20, 4, 10, 19, 20, 11, 4, 11, 20, 23, 14, 4,
 331                    14, 23, 22, 13, 4, 21, 24, 25, 22, 4, 13, 22, 25, 16, 4, 16, 25, 24, 15, 4, 15, 24, 21, 12, 4, 22, 25, 26, 23, 4, 14, 23, 26, 17, 4, 17, 26, 25, 16]
 332
 333         self.assertEqual(expected1,list(descIndx.getValues()));
 334         self.assertEqual(expected2,list(desc.getValues()));
 335         self.assertEqual(expected3,list(revDescIndx.getValues()));
 336         self.assertEqual(expected4,list(revDesc.getValues()));
 337         self.assertEqual(expected5,list(mesh2.getNodalConnectivityIndex().getValues()));
 338         self.assertEqual(expected6,list(mesh2.getNodalConnectivity().getValues()));
 339         #
 340         eltsV=[1,3]
 341         mesh.convertToPolyTypes(eltsV);
 342         mesh.checkCoherency();
 343         desc=DataArrayInt.New();
 344         descIndx=DataArrayInt.New();
 345         revDesc=DataArrayInt.New();
 346         revDescIndx=DataArrayInt.New();
 347         mesh2=mesh.buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
 348         mesh2.checkCoherency();
 349         self.assertEqual(2,mesh2.getMeshDimension());
 350         self.assertEqual(36,mesh2.getNumberOfCells());
 351         self.assertEqual(37,revDescIndx.getNbOfElems()); self.assertEqual(37,revDescIndx.getNumberOfTuples());
 352         self.assertEqual(9,descIndx.getNbOfElems()); self.assertEqual(9,descIndx.getNumberOfTuples());
 353         self.assertEqual(48,desc.getNbOfElems()); self.assertEqual(48,desc.getNumberOfTuples());
 354         self.assertEqual(48,revDesc.getNbOfElems()); self.assertEqual(48,revDesc.getNumberOfTuples());
 355         self.assertEqual(expected1,list(descIndx.getValues()));
 356         self.assertEqual(expected2,list(desc.getValues()));
 357         self.assertEqual(expected3,list(revDescIndx.getValues()));
 358         self.assertEqual(expected4,list(revDesc.getValues()));
 359         self.assertEqual(expected5,list(mesh2.getNodalConnectivityIndex().getValues()));
 360         self.assertEqual(expected7,list(mesh2.getNodalConnectivity().getValues()));
 361         pass
 362
 363     def testFindBoundaryNodes(self):
 364         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
 365         boundaryNodes=mesh.findBoundaryNodes();
 366         expected1=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26];
 367         self.assertEqual(expected1,boundaryNodes.getValues());
 368         pass
 369
 370     def testBoundaryMesh(self):
 371         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
 372         mesh2=mesh.buildBoundaryMesh(False);
 373         self.assertEqual(24,mesh2.getNumberOfCells());
 374         self.assertEqual(26,mesh2.getNumberOfNodes());
 375         pass
 376
 377     def testBuildPartOfMySelf(self):
 378         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
 379         mesh.setName("Toto");
 380         tab1=[0,4]
 381         tab2=[0,2,3]
 382         #
 383         subMesh=mesh.buildPart(tab1)
 384         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
 385         subMesh=mesh.buildPartOfMySelf(tab1,True);
 386         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
 387         name=subMesh.getName();
 388         self.assertEqual(2,len(mesh.getAllTypes()));
 389         self.assertEqual(NORM_TRI3,mesh.getAllTypes()[0]);
 390         self.assertEqual(NORM_QUAD4,mesh.getAllTypes()[1]);
 391         self.assertEqual(1,len(subMesh.getAllTypes()));
 392         self.assertEqual(NORM_QUAD4,subMesh.getAllTypes()[0]);
 393         self.assertEqual(name,"Toto");
 394         self.assertEqual(2,subMesh.getNumberOfCells());
 395         subConn=[4,0,3,4,1,4,7,8,5,4];
 396         subConnIndex=[0,5,10];
 397         self.assertEqual(10,subMesh.getNodalConnectivity().getNbOfElems());
 398         self.assertEqual(3,subMesh.getNodalConnectivityIndex().getNbOfElems());
 399         self.assertEqual(subConn[0:10],list(subMesh.getNodalConnectivity().getValues()));
 400         self.assertEqual(subConnIndex[0:3],list(subMesh.getNodalConnectivityIndex().getValues()));
 401         #
 402         subMesh=mesh.buildPartOfMySelf(tab2[0:3],True);
 403         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh));
 404         name=subMesh.getName();
 405         self.assertEqual(2,len(subMesh.getAllTypes()));
 406         self.assertEqual(NORM_TRI3,subMesh.getAllTypes()[0]);
 407         self.assertEqual(NORM_QUAD4,subMesh.getAllTypes()[1]);
 408         self.assertEqual(name,"Toto");
 409         self.assertEqual(3,subMesh.getNumberOfCells());
 410         subConn2=[4,0,3,4,1,3,4,5,2,4,6,7,4,3]
 411         subConnIndex2=[0,5,9,14]
 412         self.assertEqual(14,subMesh.getNodalConnectivity().getNbOfElems());
 413         self.assertEqual(4,subMesh.getNodalConnectivityIndex().getNbOfElems());
 414         self.assertEqual(subConn2[0:14],list(subMesh.getNodalConnectivity().getValues()));
 415         self.assertEqual(subConnIndex2[0:4],list(subMesh.getNodalConnectivityIndex().getValues()));
 416         dd=DataArrayInt.New()
 417         dd.alloc(3,1)
 418         dd.iota(0)
 419         dd.setName("coucou")
 420         subMesh=subMesh.buildPartOfMySelf(dd,True);
 421         self.assertEqual("coucou",subMesh.getName());
 422         pass
 423
 424     def testBuildPartOfMySelfNode(self):
 425         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
 426         tab1=[5,7,8,4]
 427         subMesh=mesh.buildPartOfMySelfNode(tab1[0:4],True);
 428         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
 429         self.assertEqual(1,len(subMesh.getAllTypes()));
 430         self.assertEqual(NORM_QUAD4,subMesh.getAllTypes()[0]);
 431         self.assertEqual(1,subMesh.getNumberOfCells());
 432         self.assertEqual(5,subMesh.getNodalConnectivity().getNbOfElems());
 433         self.assertEqual(2,subMesh.getNodalConnectivityIndex().getNbOfElems());
 434         subConn=[4,7,8,5,4]
 435         subConnIndex=[0,5]
 436         self.assertEqual(subConn[0:5],list(subMesh.getNodalConnectivity().getValues()));
 437         self.assertEqual(subConnIndex[0:2],list(subMesh.getNodalConnectivityIndex().getValues()));
 438         #
 439         ddd=DataArrayInt.New()
 440         ddd.setValues(tab1[0:2],2,1)
 441         ddd.setName("ddd")
 442         subMesh=mesh.buildPartOfMySelfNode(ddd,False);
 443         self.assertEqual("ddd",subMesh.getName())
 444         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
 445         self.assertEqual(2,len(subMesh.getAllTypes()));
 446         self.assertEqual(NORM_TRI3,subMesh.getAllTypes()[0]);
 447         self.assertEqual(NORM_QUAD4,subMesh.getAllTypes()[1]);
 448         self.assertEqual(3,subMesh.getNumberOfCells());
 449         self.assertEqual(14,subMesh.getNodalConnectivity().getNbOfElems());
 450         self.assertEqual(4,subMesh.getNodalConnectivityIndex().getNbOfElems());
 451         subConn2=[3,4,5,2,4,6,7,4,3,4,7,8,5,4]
 452         subConnIndex2=[0,4,9,14]
 453         self.assertEqual(subConn2[0:14],list(subMesh.getNodalConnectivity().getValues()));
 454         self.assertEqual(subConnIndex2[0:4],list(subMesh.getNodalConnectivityIndex().getValues()));
 455         #testing the case where length of tab2 is greater than max number of node per cell.
 456         tab2=[0,3,2,1,4,5,6]
 457         subMesh=mesh.buildPartOfMySelfNode(tab2[0:7],True);
 458         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
 459         self.assertEqual(2,len(subMesh.getAllTypes()));
 460         self.assertEqual(NORM_TRI3,subMesh.getAllTypes()[0]);
 461         self.assertEqual(NORM_QUAD4,subMesh.getAllTypes()[1]);
 462         self.assertEqual(3,subMesh.getNumberOfCells());
 463         pass
 464
 465     def testZipCoords(self):
 466         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
 467         self.assertEqual(2,len(mesh.getAllTypes()));
 468         self.assertEqual(2,mesh.getSpaceDimension());
 469         self.assertEqual(9,mesh.getNumberOfNodes());
 470         self.assertEqual(5,mesh.getNumberOfCells());
 471         oldConn=mesh.getNodalConnectivity().getValues()[0:mesh.getNodalConnectivity().getNbOfElems()];
 472         oldConnIndex=mesh.getNodalConnectivityIndex().getValues()[0:mesh.getNumberOfCells()+1]
 473         oldCoords=mesh.getCoords();
 474         mesh.zipCoords();
 475         self.assertEqual(2,len(mesh.getAllTypes()));
 476         self.assertEqual(2,mesh.getSpaceDimension());
 477         self.assertEqual(9,mesh.getNumberOfNodes());
 478         self.assertEqual(5,mesh.getNumberOfCells());
 479         self.assertEqual(mesh.getCoords().getValues()[0:2*9],oldCoords.getValues());
 480         self.assertEqual(list(oldConn),list(mesh.getNodalConnectivity().getValues()));
 481         self.assertEqual(list(oldConnIndex),list(mesh.getNodalConnectivityIndex().getValues()));
 482         #
 483         tab1=[0,4]
 484         subMesh=mesh.buildPartOfMySelf(tab1,True);
 485         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
 486         traducer=subMesh.zipCoordsTraducer();
 487         expectedTraducer=[0, 1, -1, 2, 3, 4, -1, 5, 6]
 488         self.assertEqual(expectedTraducer,list(traducer.getValues()));
 489         self.assertEqual(NORM_QUAD4,subMesh.getAllTypes()[0]);
 490         self.assertEqual(2,subMesh.getNumberOfCells());
 491         subConn=[4,0,2,3,1,4,5,6,4,3]
 492         subConnIndex=[0,5,10]
 493         self.assertEqual(7,subMesh.getNumberOfNodes());
 494         self.assertEqual(10,subMesh.getNodalConnectivity().getNbOfElems());
 495         self.assertEqual(3,subMesh.getNodalConnectivityIndex().getNbOfElems());
 496         self.assertEqual(subConn,list(subMesh.getNodalConnectivity().getValues()));
 497         self.assertEqual(subConnIndex,list(subMesh.getNodalConnectivityIndex().getValues()));
 498         #
 499         subMesh=mesh.buildPartOfMySelf(tab1,False);
 500         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
 501         self.assertEqual(NORM_QUAD4,subMesh.getAllTypes()[0]);
 502         self.assertEqual(2,subMesh.getNumberOfCells());
 503         self.assertEqual(7,subMesh.getNumberOfNodes());
 504         self.assertEqual(10,subMesh.getNodalConnectivity().getNbOfElems());
 505         self.assertEqual(3,subMesh.getNodalConnectivityIndex().getNbOfElems());
 506         self.assertEqual(subConn,list(subMesh.getNodalConnectivity().getValues()));
 507         self.assertEqual(subConnIndex,list(subMesh.getNodalConnectivityIndex().getValues()));
 508         pass
 509
 510     def testZipConnectivity(self):
 511         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
 512         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
 513         cells1=[2,3,4]
 514         m3=m2.buildPartOfMySelf(cells1,True);
 515         self.assertTrue(isinstance(m3,MEDCouplingUMesh))
 516         m4=MEDCouplingDataForTest.build2DSourceMesh_1();
 517         m5=MEDCouplingUMesh.MergeUMeshes(m1,m3);
 518         m6=MEDCouplingUMesh.MergeUMeshes(m5,m4);
 519         #
 520         self.assertEqual(10,m6.getNumberOfCells());
 521         self.assertEqual(22,m6.getNumberOfNodes());
 522         (arr,areNodesMerged,newNbOfNodes)=m6.mergeNodes(1e-13);
 523         self.assertTrue(areNodesMerged);
 524         self.assertEqual(10,m6.getNumberOfCells());
 525         self.assertEqual(9,m6.getNumberOfNodes());
 526         #
 527         arr=m6.zipConnectivityTraducer(0);
 528         self.assertEqual(7,m6.getNumberOfCells());
 529         m7=m6.clone(True);
 530         arr=m6.zipConnectivityTraducer(0);
 531         self.assertTrue(m7.isEqual(m6,1e-12));
 532         self.assertEqual(7,m6.getNumberOfCells());
 533         pass
 534
 535     def testEqualMesh(self):
 536         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
 537         mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
 538         #
 539         self.assertTrue(mesh1.isEqual(mesh1,1e-12));
 540         #
 541         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
 542         self.assertTrue(mesh2.isEqual(mesh1,1e-12));
 543         pt=mesh2.getCoords().getValues();
 544         tmp=pt[1]
 545         mesh2.getCoords().setIJ(0,1,5.999);
 546         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
 547         self.assertTrue(not mesh2.isEqual(mesh1,1e-12));
 548         mesh2.getCoords().setIJ(0,1,tmp);
 549         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
 550         self.assertTrue(mesh2.isEqual(mesh1,1e-12));
 551         #
 552         pt2=mesh1.getNodalConnectivity().getValues();
 553         mesh1.getNodalConnectivity().setIJ(5,0,int(pt2[5])+1);
 554         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
 555         self.assertTrue(not mesh2.isEqual(mesh1,1e-12));
 556         mesh1.getNodalConnectivity().setIJ(5,0,int(pt2[5]));
 557         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
 558         self.assertTrue(mesh2.isEqual(mesh1,1e-12));
 559         #
 560         pt2=mesh1.getNodalConnectivityIndex().getValues();
 561         mesh1.getNodalConnectivityIndex().setIJ(1,0,int(pt2[1]+1));
 562         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
 563         self.assertTrue(not mesh2.isEqual(mesh1,1e-12));
 564         mesh1.getNodalConnectivityIndex().setIJ(1,0,int(pt2[1]));
 565         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
 566         self.assertTrue(mesh2.isEqual(mesh1,1e-12));
 567         #
 568         tmp3=mesh1.getName();
 569         mesh1.setName("lllll");
 570         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
 571         self.assertTrue(not mesh2.isEqual(mesh1,1e-12));
 572         mesh1.setName(tmp3);
 573         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
 574         self.assertTrue(mesh2.isEqual(mesh1,1e-12));
 575         #
 576         tmp3=mesh2.getCoords().getInfoOnComponent(1);
 577         mesh2.getCoords().setInfoOnComponent(1,"kkkkkk");
 578         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
 579         self.assertTrue(not mesh2.isEqual(mesh1,1e-12));
 580         mesh2.getCoords().setInfoOnComponent(1,tmp3);
 581         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
 582         self.assertTrue(mesh2.isEqual(mesh1,1e-12));
 583         pass
 584
 585     def testEqualFieldDouble(self):
 586         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
 587         mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
 588         #
 589         fieldOnCells1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
 590         fieldOnCells1.setMesh(mesh1);
 591         fieldOnCells2=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
 592         fieldOnCells2.setMesh(mesh2);
 593         #
 594         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 595         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 596         #
 597         fieldOnNodes1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
 598         self.assertTrue(not fieldOnCells1.isEqual(fieldOnNodes1,1e-12,1e-15));
 599         self.assertTrue(not fieldOnNodes1.isEqual(fieldOnCells1,1e-12,1e-15));
 600         #
 601         fieldOnCells2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
 602         self.assertEqual(fieldOnCells2.getMesh(),None) # to check that convertMesh wrapping do not raise but return Py_None
 603         self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 604         self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 605         fieldOnCells1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
 606         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 607         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 608         fieldOnCells1.setTime(4.,6,7);
 609         self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 610         self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 611         fieldOnCells2.setTime(4.,6,7);
 612         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 613         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 614         fieldOnCells1.setName("Power");
 615         self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 616         self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 617         fieldOnCells2.setName("Power");
 618         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 619         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 620         #
 621         fieldOnCells1.setMesh(mesh1);
 622         self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 623         self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 624         fieldOnCells2.setMesh(mesh1);
 625         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 626         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 627         arr=DataArrayDouble.New();
 628         arr.setName("popo");
 629         arr.setValues(mesh1.getNumberOfCells()*3*[6.],mesh1.getNumberOfCells(),3);
 630         fieldOnCells1.setArray(arr);
 631         self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 632         self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 633         fieldOnCells2.setArray(arr);
 634         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 635         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 636         #
 637         arr2=arr.deepCpy();
 638         fieldOnCells2.setArray(arr2);
 639         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 640         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 641         arr.setIJ(1,2,6.1);
 642         self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 643         self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 644         arr.setIJ(1,2,6.);
 645         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 646         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 647         arr2.setName("popo2");
 648         self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 649         self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 650         #
 651         arr2.setName("popo");
 652         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 653         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 654         #
 655         arr2.setInfoOnComponent(2,"jjj");
 656         self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 657         self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 658         arr.setInfoOnComponent(2,"jjj");
 659         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 660         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 661         pass
 662
 663     def testNatureChecking(self):
 664         field=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
 665         field.setNature(Integral);
 666         field.setNature(ConservativeVolumic);
 667         field.setNature(IntegralGlobConstraint);
 668         field=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
 669         field.setNature(ConservativeVolumic);
 670         self.assertRaises(InterpKernelException,field.setNature,Integral);
 671         self.assertRaises(InterpKernelException,field.setNature,IntegralGlobConstraint);
 672         pass
 673
 674     def testBuildSubMeshData(self):
 675         targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1()
 676         #check buildSubMesh on field on cells
 677         fieldCells=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
 678         fieldCells.setMesh(targetMesh);
 679         elts=[1,2,4]
 680         ret1,di=fieldCells.buildSubMeshData(elts);
 681         self.assertTrue(isinstance(ret1,MEDCouplingUMesh))
 682         self.assertEqual(3,ret1.getNumberOfCells());
 683         self.assertEqual(9,ret1.getNumberOfNodes());
 684         self.assertEqual(3,di.getNumberOfTuples());
 685         self.assertEqual(1,di.getNumberOfComponents());
 686         toCheck=di.getValues();
 687         self.assertTrue(elts,toCheck);
 688         #check buildSubMesh on field on nodes
 689         fieldNodes=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
 690         fieldNodes.setMesh(targetMesh);
 691         ret2,di=fieldNodes.buildSubMeshData(elts);
 692         self.assertTrue(isinstance(ret2,MEDCouplingUMesh))
 693         self.assertEqual(3,ret2.getNumberOfCells());
 694         self.assertEqual(6,ret2.getNumberOfNodes());
 695         self.assertEqual(6,di.getNumberOfTuples());
 696         self.assertEqual(1,di.getNumberOfComponents());
 697         toCheck=di.getValues();
 698         expected=[1,2,4,5,7,8]
 699         self.assertEqual(expected,list(toCheck));
 700         pass
 701
 702     def testExtrudedMesh1(self):
 703         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
 704         ext=MEDCouplingExtrudedMesh.New(mesh3D,mesh2D,1);
 705         self.assertEqual(18,ext.getNumberOfCells());
 706         self.assertEqual(60,ext.getNumberOfNodes());
 707         ids3D=ext.getMesh3DIds();
 708         ids3DExpected=[5,4,3,2,1,0, 11,10,9,8,7,6, 17,16,15,14,13,12]
 709         self.assertEqual(18,ids3D.getNumberOfTuples());
 710         self.assertEqual(1,ids3D.getNumberOfComponents());
 711         self.assertEqual(ids3DExpected,list(ids3D.getValues()));
 712         mesh1D=ext.getMesh1D();
 713         self.assertEqual(4,mesh1D.getNumberOfNodes());
 714         self.assertEqual(3,mesh1D.getNumberOfCells());
 715         mesh1DExpected=[0.66666666666666663, 1.4583333333333333, 0, 0.66666666666666663,
 716                         1.4583333333333333, 1, 0.66666666666666663, 1.4583333333333333,
 717                         2, 0.66666666666666663, 1.4583333333333333, 3]
 718         mesh1DCoords=mesh1D.getCoords();
 719         self.assertEqual(4,mesh1DCoords.getNumberOfTuples());
 720         self.assertEqual(3,mesh1DCoords.getNumberOfComponents());
 721         self.assertEqual(mesh1DExpected,mesh1DCoords.getValues());
 722         conn1D=mesh1D.getNodalConnectivity();
 723         self.assertEqual(9,conn1D.getNumberOfTuples());
 724         self.assertEqual(1,conn1D.getNumberOfComponents());
 725         conn1DExpected=[1,0,1,1,1,2,1,2,3]
 726         self.assertEqual(conn1DExpected,list(conn1D.getValues()));
 727         pass
 728
 729     def testExtrudedMesh3(self):
 730         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
 731         m1.changeSpaceDimension(3);
 732         m2=MEDCouplingDataForTest.buildCU1DMesh_U();
 733         m2.changeSpaceDimension(3);
 734         center=[0.,0.,0.]
 735         vector=[0.,1.,0.]
 736         m2.rotate(center,vector,-pi/2.);
 737         m3=m1.buildExtrudedMesh(m2,0);
 738         #
 739         m4=MEDCouplingExtrudedMesh.New(m3,m1,0);
 740         self.assertEqual(15,m4.getNumberOfCells());
 741         self.assertEqual(5,m4.getMesh2D().getNumberOfCells());
 742         self.assertEqual(3,m4.getMesh1D().getNumberOfCells());
 743         m3DIds=m4.getMesh3DIds().getValues();
 744         self.assertEqual(range(15),list(m3DIds));
 745         #some random in cells to check that extrusion alg find it correctly
 746         expected1=[1,3,2,0,6,5,7,10,11,8,12,9,14,13,4]
 747         m3.renumberCells(expected1,False);
 748         m4=MEDCouplingExtrudedMesh.New(m3,m1,0);
 749         self.assertEqual(15,m4.getNumberOfCells());
 750         self.assertEqual(5,m4.getMesh2D().getNumberOfCells());
 751         self.assertEqual(3,m4.getMesh1D().getNumberOfCells());
 752         m3DIds=m4.getMesh3DIds().getValues();
 753         self.assertEqual(expected1,list(m3DIds));
 754         #play with polygons and polyedrons
 755         cells=[2,3]
 756         m1.convertToPolyTypes(cells);
 757         m3=m1.buildExtrudedMesh(m2,0);
 758         self.assertEqual(NORM_HEXA8,m3.getTypeOfCell(0));
 759         self.assertEqual(NORM_PENTA6,m3.getTypeOfCell(1));
 760         self.assertEqual(NORM_POLYHED,m3.getTypeOfCell(2));
 761         self.assertEqual(NORM_POLYHED,m3.getTypeOfCell(3));
 762         self.assertEqual(NORM_HEXA8,m3.getTypeOfCell(4));
 763         m3.renumberCells(expected1,False);
 764         m4=MEDCouplingExtrudedMesh.New(m3,m1,0);
 765         self.assertEqual(15,m4.getNumberOfCells());
 766         self.assertEqual(5,m4.getMesh2D().getNumberOfCells());
 767         self.assertEqual(3,m4.getMesh1D().getNumberOfCells());
 768         m3DIds=m4.getMesh3DIds().getValues();
 769         self.assertEqual(expected1,list(m3DIds));
 770         pass
 771
 772     def testExtrudedMesh4(self):
 773         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
 774         cells=[2,4];
 775         m1.convertToPolyTypes(cells);
 776         m1.changeSpaceDimension(3);
 777         m2=MEDCouplingDataForTest.buildCU1DMesh_U();
 778         m2.changeSpaceDimension(3);
 779         center=[0.,0.,0.]
 780         vector=[0.,1.,0.]
 781         m2.rotate(center,vector,-pi/2.);
 782         m3=m1.buildExtrudedMesh(m2,0);
 783         expected1=[1,3,2,0,6,5,7,10,11,8,12,9,14,13,4]
 784         rexpected1=[3, 0, 2, 1, 14, 5, 4, 6, 9, 11, 7, 8, 10, 13, 12]
 785         m3.renumberCells(expected1,False);
 786         m4=MEDCouplingExtrudedMesh.New(m3,m1,0);
 787         self.assertEqual(NORM_HEXA8,m4.getTypeOfCell(0));
 788         self.assertEqual(NORM_HEXA8,m4.getTypeOfCell(1));
 789         self.assertEqual(NORM_POLYHED,m4.getTypeOfCell(2));
 790         self.assertEqual(NORM_PENTA6,m4.getTypeOfCell(7));
 791         f=m4.getMeasureField(True);
 792         arr=f.getArray();
 793         self.assertEqual(15,arr.getNumberOfTuples());
 794         self.assertEqual(1,arr.getNumberOfComponents());
 795         arrPtr=arr.getValues();
 796         expected2=[0.075,0.0375,0.0375,0.075,0.075,
 797                    0.1125,0.05625,0.05625,0.1125,0.1125,
 798                    0.0625,0.03125,0.03125,0.0625,0.0625]
 799         for i in xrange(15):
 800             self.assertAlmostEqual(expected2[rexpected1[i]],arrPtr[i],16);
 801             pass
 802         m5=m4.build3DUnstructuredMesh();
 803         self.assertTrue(m5.isEqual(m3,1e-12));
 804         f=m5.getMeasureField(True);
 805         f.setMesh(m4)
 806         self.assertTrue(isinstance(f.getMesh(),MEDCouplingExtrudedMesh))
 807         arr=f.getArray();
 808         arrPtr=arr.getValues();
 809         for i in xrange(15):
 810             self.assertAlmostEqual(expected2[rexpected1[i]],arrPtr[i],15);
 811             pass
 812         pass
 813
 814     def testFindCommonNodes(self):
 815         targetMesh=MEDCouplingDataForTest.build3DTargetMesh_1();
 816         comm,commI=targetMesh.findCommonNodes(1e-10,-1);
 817         self.assertEqual(1,commI.getNumberOfTuples());
 818         self.assertEqual(0,comm.getNumberOfTuples());
 819         o2n,newNbOfNodes=targetMesh.buildNewNumberingFromCommonNodesFormat(comm,commI);
 820         self.assertEqual(27,newNbOfNodes);
 821         self.assertEqual(27,o2n.getNumberOfTuples());
 822         o2nExp1=range(27)
 823         self.assertEqual(o2nExp1,list(o2n.getValues()));
 824         #
 825         targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
 826         self.assertEqual(31,targetMesh.getNumberOfNodes());
 827         comm,commI=targetMesh.findCommonNodes(1e-10);# testing default parameter
 828         self.assertEqual(3,commI.getNumberOfTuples());
 829         self.assertEqual(6,comm.getNumberOfTuples());
 830         commExpected=[1,27,28,29,23,30]
 831         commIExpected=[0,4,6]
 832         self.assertEqual(commExpected,list(comm.getValues()));
 833         self.assertEqual(commIExpected,list(commI.getValues()));
 834         o2n,newNbOfNodes=targetMesh.buildNewNumberingFromCommonNodesFormat(comm,commI);
 835         self.assertEqual(31,o2n.getNumberOfTuples());
 836         self.assertEqual(27,newNbOfNodes);
 837         o2nExp2=[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,
 838                  21,22,23,24,25,26,1,1,1,23]
 839         self.assertEqual(o2nExp2,list(o2n.getValues()));
 840         #
 841         targetMesh=MEDCouplingDataForTest.build3DTargetMesh_1();
 842         time=targetMesh.getTimeOfThis();
 843         o2n,areNodesMerged,newNbOfNodes=targetMesh.mergeNodes(1e-10);
 844         targetMesh.updateTime();
 845         self.assertEqual(time,targetMesh.getTimeOfThis());
 846         self.assertTrue(not areNodesMerged);
 847         #
 848         targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
 849         time=targetMesh.getTimeOfThis();
 850         o2n,areNodesMerged,newNbOfNodes=targetMesh.mergeNodes(1e-10);
 851         targetMesh.updateTime();
 852         self.assertTrue(time!=targetMesh.getTimeOfThis());
 853         self.assertTrue(areNodesMerged);
 854         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,
 855                  18,4,5,8,7,13,14,17,16,
 856                  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,
 857                  18,13,14,17,16,22,23,26,25]
 858         self.assertEqual(72,targetMesh.getNodalConnectivity().getNumberOfTuples());
 859         self.assertEqual(connExp,list(targetMesh.getNodalConnectivity().getValues()));
 860         self.assertEqual(27,targetMesh.getCoords().getNumberOfTuples());
 861         coordsExp=[ 0., 0., 0., 50., 0., 0. , 200., 0., 0.  , 0., 50., 0., 50., 50., 0. ,
 862                     200., 50., 0.,   0., 200., 0., 50., 200., 0. , 200., 200., 0. ,
 863                     0., 0., 50., 50., 0., 50. , 200., 0., 50.  , 0., 50., 50., 50.,
 864                     50., 50. , 200., 50., 50.,   0., 200., 50., 50., 200., 50. ,
 865                     200., 200., 50. , 0., 0., 200., 50., 0., 200. , 200., 0., 200.
 866                     , 0., 50., 200., 50., 50., 200. , 200., 50., 200.,
 867                     0., 200., 200., 50., 200., 200. , 200., 200., 200. ]
 868         self.assertEqual(coordsExp,targetMesh.getCoords().getValues());
 869         # 2D
 870         targetMesh=MEDCouplingDataForTest.build2DTargetMeshMergeNode_1();
 871         self.assertEqual(18,targetMesh.getNumberOfNodes());
 872         time=targetMesh.getTimeOfThis();
 873         o2n,areNodesMerged,newNbOfNodes=targetMesh.mergeNodes(1e-10);
 874         self.assertTrue(time!=targetMesh.getTimeOfThis());
 875         self.assertTrue(areNodesMerged);
 876         self.assertEqual(9,targetMesh.getNumberOfNodes());
 877         connExp2=[4,0,4,3,1, 3,1,3,2, 3,3,5,2, 4,4,6,7,3, 4,7,8,5,3]
 878         self.assertEqual(23,targetMesh.getNodalConnectivity().getNumberOfTuples());
 879         self.assertEqual(connExp2,list(targetMesh.getNodalConnectivity().getValues()));
 880         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]
 881         self.assertEqual(9,targetMesh.getCoords().getNumberOfTuples());
 882         self.assertEqual(coordsExp2,targetMesh.getCoords().getValues());
 883         pass
 884
 885     def testCheckButterflyCells(self):
 886         sourceMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
 887         cells=sourceMesh.checkButterflyCells();
 888         self.assertEqual(0,len(cells));
 889         conn=sourceMesh.getNodalConnectivity()
 890         tmp=conn.getIJ(15,0)
 891         conn.setIJ(15,0,conn.getIJ(16,0))
 892         conn.setIJ(16,0,tmp)
 893         cells=sourceMesh.checkButterflyCells();
 894         self.assertEqual(1,len(cells));
 895         self.assertEqual([3],cells.getValues());
 896         tmp=conn.getIJ(15,0)
 897         conn.setIJ(15,0,conn.getIJ(16,0))
 898         conn.setIJ(16,0,tmp)
 899         cells=sourceMesh.checkButterflyCells();
 900         self.assertEqual(0,len(cells));
 901         # 3D surf
 902         sourceMesh=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
 903         cells=sourceMesh.checkButterflyCells();
 904         self.assertEqual(0,len(cells));
 905         conn=sourceMesh.getNodalConnectivity()
 906         tmp=conn.getIJ(15,0)
 907         conn.setIJ(15,0,conn.getIJ(16,0))
 908         conn.setIJ(16,0,tmp)
 909         cells=sourceMesh.checkButterflyCells();
 910         self.assertEqual(1,len(cells));
 911         self.assertEqual([3],cells.getValues());
 912         tmp=conn.getIJ(15,0)
 913         conn.setIJ(15,0,conn.getIJ(16,0))
 914         conn.setIJ(16,0,tmp)
 915         cells=sourceMesh.checkButterflyCells();
 916         self.assertEqual(0,len(cells));
 917         pass
 918
 919     def testMergeMesh1(self):
 920         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
 921         m2=MEDCouplingDataForTest.build2DSourceMesh_1();
 922         vec=[1.,0.]
 923         m2.translate(vec);
 924         m3=m1.mergeMyselfWith(m2);
 925         self.assertTrue(isinstance(m3,MEDCouplingUMesh));
 926         m3.checkCoherency();
 927         m4=MEDCouplingDataForTest.build2DTargetMeshMerged_1();
 928         self.assertTrue(m3.isEqual(m4,1.e-12));
 929         da,isMerged,newNbOfNodes=m3.mergeNodes(1.e-12);
 930         self.assertEqual(11,m3.getNumberOfNodes());
 931         self.assertTrue(isMerged);
 932         pass
 933
 934     def testMergeMeshOnSameCoords1(self):
 935         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
 936         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
 937         cells=range(5);
 938         m2.convertToPolyTypes(cells);
 939         m1.tryToShareSameCoords(m2,1e-12);
 940         m3=MEDCouplingDataForTest.build2DTargetMesh_1();
 941         m3.tryToShareSameCoords(m2,1e-12);
 942         meshes=[m1,m2,m3]
 943         m4=MEDCouplingUMesh.MergeUMeshesOnSameCoords(meshes);
 944         m4.checkCoherency();
 945         self.assertEqual(15,m4.getNumberOfCells());
 946         cells1=[0,1,2,3,4]
 947         m1_1=m4.buildPartOfMySelf(cells1,True);
 948         m1_1.setName(m1.getName());
 949         self.assertTrue(m1.isEqual(m1_1,1e-12));
 950         cells2=[5,6,7,8,9]
 951         m2_1=m4.buildPartOfMySelf(cells2,True);
 952         m2_1.setName(m2.getName());
 953         self.assertTrue(m2.isEqual(m2_1,1e-12));
 954         cells3=[10,11,12,13,14]
 955         m3_1=m4.buildPartOfMySelf(cells3,True);
 956         m3_1.setName(m3.getName());
 957         self.assertTrue(m3.isEqual(m3_1,1e-12));
 958         pass
 959
 960     def testMergeField1(self):
 961         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
 962         m2=MEDCouplingDataForTest.build2DSourceMesh_1();
 963         vec=[1.,0.]
 964         m2.translate(vec);
 965         f1=m1.getMeasureField(True);
 966         f2=m2.getMeasureField(True);
 967         f3=MEDCouplingFieldDouble.MergeFields(f1,f2);
 968         f3.checkCoherency();
 969         m4=MEDCouplingDataForTest.build2DTargetMeshMerged_1();
 970         self.assertTrue(f3.getMesh().isEqual(m4,1.e-12));
 971         name=f3.getName();
 972         self.assertEqual(name,"MeasureOfMesh_");
 973         self.assertEqual(f3.getTypeOfField(),ON_CELLS);
 974         self.assertEqual(f3.getTimeDiscretization(),ONE_TIME);
 975         self.assertEqual(1,f3.getNumberOfComponents());
 976         self.assertEqual(7,f3.getNumberOfTuples());
 977         values=[0.25,0.125,0.125,0.25,0.25,0.5,0.5]
 978         tmp=f3.getArray().getValues();
 979         self.assertEqual(len(values),len(tmp))
 980         for i in xrange(7):
 981             self.assertTrue(abs(values[i]-tmp[i])<1e-12)
 982             pass
 983         pass
 984
 985     def testFillFromAnalytic(self):
 986         m=MEDCouplingDataForTest.build2DTargetMesh_1();
 987         m.setTime(3.4,5,6); m.setTimeUnit("us");
 988         f1=m.fillFromAnalytic(ON_CELLS,1,"x+y");
 989         self.assertAlmostEqual(3.4,f1.getTime()[0],12) ; self.assertEqual(5,f1.getTime()[1]) ; self.assertEqual(6,f1.getTime()[2])
 990         self.assertEqual("us",f1.getTimeUnit())
 991         f1.checkCoherency();
 992         self.assertEqual(f1.getTypeOfField(),ON_CELLS);
 993         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
 994         self.assertEqual(1,f1.getNumberOfComponents());
 995         self.assertEqual(5,f1.getNumberOfTuples());
 996         values1=[-0.1,0.23333333333333336,0.56666666666666665,0.4,0.9]
 997         tmp=f1.getArray().getValues();
 998         self.assertEqual(len(values1),len(tmp))
 999         for i in xrange(len(tmp)):
1000             self.assertTrue(abs(tmp[i]-values1[i])<1.e-12)
1001             pass
1002         #
1003         f1=m.fillFromAnalytic(ON_NODES,1,"x+y");
1004         f1.checkCoherency();
1005         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1006         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1007         self.assertEqual(1,f1.getNumberOfComponents());
1008         self.assertEqual(9,f1.getNumberOfTuples());
1009         values2=[-0.6,-0.1,0.4,-0.1,0.4,0.9,0.4,0.9,1.4]
1010         tmp=f1.getArray().getValues();
1011         self.assertEqual(len(values2),len(tmp))
1012         for i in xrange(len(tmp)):
1013             self.assertTrue(abs(tmp[i]-values2[i])<1.e-12)
1014             pass
1015         #
1016         f1=m.fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+(2*(x+y))*JVec");
1017         f1.checkCoherency();
1018         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1019         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1020         self.assertEqual(2,f1.getNumberOfComponents());
1021         self.assertEqual(9,f1.getNumberOfTuples());
1022         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]
1023         tmp=f1.getArray().getValues();
1024         self.assertEqual(len(values3),len(tmp))
1025         for i in xrange(len(tmp)):
1026             self.assertTrue(abs(tmp[i]-values3[i])<1.e-12)
1027             pass
1028         values4=f1.accumulate();
1029         self.assertEqual(2,len(values4))
1030         self.assertTrue(abs(3.6-values4[0])<1.e-12);
1031         self.assertTrue(abs(7.2-values4[1])<1.e-12);
1032         values4=f1.integral(True);
1033         self.assertEqual(2,len(values4))
1034         self.assertTrue(abs(0.5-values4[0])<1.e-12);
1035         self.assertTrue(abs(1.-values4[1])<1.e-12);
1036         #
1037         self.assertRaises(InterpKernelException,m.fillFromAnalytic,ON_NODES,1,"1./(x-0.2)");
1038         pass
1039
1040     def testFillFromAnalytic2(self):
1041         m=MEDCouplingDataForTest.build2DTargetMesh_1();
1042         f1=m.fillFromAnalytic(ON_CELLS,1,"y+x");
1043         f1.checkCoherency();
1044         self.assertEqual(f1.getTypeOfField(),ON_CELLS);
1045         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1046         self.assertEqual(1,f1.getNumberOfComponents());
1047         self.assertEqual(5,f1.getNumberOfTuples());
1048         values1=[-0.1,0.23333333333333336,0.56666666666666665,0.4,0.9]
1049         tmp=f1.getArray().getValues();
1050         self.assertEqual(len(values1),len(tmp))
1051         for i in xrange(len(values1)):
1052             self.assertTrue(abs(values1[i]-tmp[i])<1.e-12);
1053             pass
1054         #
1055         f1=m.fillFromAnalytic(ON_NODES,1,"y+2*x");
1056         f1.checkCoherency();
1057         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1058         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1059         self.assertEqual(1,f1.getNumberOfComponents());
1060         self.assertEqual(9,f1.getNumberOfTuples());
1061         values2=[-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1]
1062         tmp=f1.getArray().getValues();
1063         self.assertEqual(len(values2),len(tmp))
1064         for i in xrange(len(values2)):
1065             self.assertTrue(abs(values2[i]-tmp[i])<1.e-12);
1066             pass
1067         f1=m.fillFromAnalytic(ON_NODES,1,"2.*x+y");
1068         f1.checkCoherency();
1069         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1070         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1071         self.assertEqual(1,f1.getNumberOfComponents());
1072         self.assertEqual(9,f1.getNumberOfTuples());
1073         tmp=f1.getArray().getValues();
1074         values2Bis=[-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1]
1075         self.assertEqual(len(values2Bis),len(tmp))
1076         for i in xrange(len(values2Bis)):
1077             self.assertTrue(abs(values2Bis[i]-tmp[i])<1.e-12);
1078             pass
1079         #
1080         f1=m.fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+2*(x+y)*JVec");
1081         f1.checkCoherency();
1082         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1083         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1084         self.assertEqual(2,f1.getNumberOfComponents());
1085         self.assertEqual(9,f1.getNumberOfTuples());
1086         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]
1087         tmp=f1.getArray().getValues();
1088         self.assertEqual(len(values3),len(tmp))
1089         for i in xrange(len(values3)):
1090             self.assertTrue(abs(values3[i]-tmp[i])<1.e-12);
1091             pass
1092         values4=f1.accumulate();
1093         self.assertTrue(abs(3.6-values4[0])<1.e-12);
1094         self.assertTrue(abs(7.2-values4[1])<1.e-12);
1095         values4=f1.integral(True);
1096         self.assertTrue(abs(0.5-values4[0])<1.e-12);
1097         self.assertTrue(abs(1.-values4[1])<1.e-12);
1098         pass
1099
1100     def testApplyFunc(self):
1101         m=MEDCouplingDataForTest.build2DTargetMesh_1();
1102         f1=m.fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+(2*(x+y))*JVec");
1103         f1.checkCoherency();
1104         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1105         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1106         self.assertEqual(2,f1.getNumberOfComponents());
1107         self.assertEqual(9,f1.getNumberOfTuples());
1108         f1.applyFunc(1,"x+y");
1109         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1110         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1111         self.assertEqual(1,f1.getNumberOfComponents());
1112         self.assertEqual(9,f1.getNumberOfTuples());
1113         values1=[-1.8,-0.3,1.2,-0.3,1.2,2.7,1.2,2.7,4.2]
1114         tmp=f1.getArray().getValues();
1115         self.assertEqual(len(values1),len(tmp))
1116         for i in xrange(len(tmp)):
1117             self.assertTrue(abs(tmp[i]-values1[i])<1.e-12)
1118             pass
1119         pass
1120
1121     def testApplyFunc2(self):
1122         m=MEDCouplingDataForTest.build2DTargetMesh_1();
1123         f1=m.fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+2*(x+y)*JVec");
1124         f1.checkCoherency();
1125         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1126         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1127         self.assertEqual(2,f1.getNumberOfComponents());
1128         self.assertEqual(9,f1.getNumberOfTuples());
1129         #
1130         f2=f1.clone(True);
1131         self.assertRaises(InterpKernelException, f2.applyFunc, 1, "a+b+c+d");
1132         self.assertRaises(InterpKernelException, f2.applyFunc, 1, "a/0");
1133         self.assertRaises(InterpKernelException, f2.applyFunc, "a/0");
1134         f2.applyFunc("abs(u)^2.4+2*u");
1135         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1136         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1137         self.assertEqual(2,f1.getNumberOfComponents());
1138         self.assertEqual(9,f1.getNumberOfTuples());
1139         values2=[-0.9065304805418678, -0.85105859001709905, -0.19601892829446504, -0.37898777756476987,
1140                  0.91090317490482353, 2.1853504664669781, -0.19601892829446504, -0.37898777756476987,
1141                  0.91090317490482353, 2.1853504664669781, 2.5765725275664879, 7.6987743736515295,
1142                  0.91090317490482353, 2.1853504664669781, 2.5765725275664879, 7.6987743736515295,
1143                  5.0423700574830965, 17.435300118916864]
1144         tmp=f2.getArray().getValues();
1145         self.assertEqual(len(tmp),len(values2))
1146         for i in xrange(len(tmp)):
1147             self.assertTrue(abs(tmp[i]-values2[i])<1.e-12)
1148             pass
1149         #
1150         f1.applyFunc(1,"x+y");
1151         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1152         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1153         self.assertEqual(1,f1.getNumberOfComponents());
1154         self.assertEqual(9,f1.getNumberOfTuples());
1155         values1=[-1.8,-0.3,1.2,-0.3,1.2,2.7,1.2,2.7,4.2]
1156         tmp=f1.getArray().getValues();
1157         self.assertEqual(len(tmp),len(values1))
1158         for i in xrange(len(tmp)):
1159             self.assertTrue(abs(tmp[i]-values1[i])<1.e-12)
1160             pass
1161         pass
1162
1163     def testOperationsOnFields(self):
1164         m=MEDCouplingDataForTest.build2DTargetMesh_1();
1165         f1=m.fillFromAnalytic(ON_NODES,1,"x+y");
1166         f2=m.fillFromAnalytic(ON_NODES,1,"x+y");
1167         f1.checkCoherency();
1168         f2.checkCoherency();
1169         f3=f1+f2;
1170         f3.checkCoherency();
1171         self.assertEqual(f3.getTypeOfField(),ON_NODES);
1172         self.assertEqual(f3.getTimeDiscretization(),ONE_TIME);
1173         values1=[-1.2,-0.2,0.8,-0.2,0.8,1.8,0.8,1.8,2.8]
1174         tmp=f3.getArray().getValues();
1175         self.assertEqual(len(values1),len(tmp))
1176         for i in xrange(len(tmp)):
1177             self.assertTrue(abs(tmp[i]-values1[i])<1.e-12)
1178             pass
1179         #
1180         f3=f1*f2;
1181         f3.checkCoherency();
1182         self.assertEqual(f3.getTypeOfField(),ON_NODES);
1183         self.assertEqual(f3.getTimeDiscretization(),ONE_TIME);
1184         values2=[0.36,0.01,0.16,0.01,0.16,0.81,0.16,0.81,1.96]
1185         tmp=f3.getArray().getValues();
1186         self.assertEqual(len(values2),len(tmp))
1187         for i in xrange(len(tmp)):
1188             self.assertTrue(abs(tmp[i]-values2[i])<1.e-12)
1189             pass
1190         #
1191         f3=f1+f2;
1192         f4=f1-f3;
1193         f4.checkCoherency();
1194         self.assertEqual(f4.getTypeOfField(),ON_NODES);
1195         self.assertEqual(f4.getTimeDiscretization(),ONE_TIME);
1196         values3=[0.6,0.1,-0.4,0.1,-0.4,-0.9,-0.4,-0.9,-1.4]
1197         tmp=f4.getArray().getValues();
1198         self.assertEqual(len(values3),len(tmp))
1199         for i in xrange(len(tmp)):
1200             self.assertTrue(abs(tmp[i]-values3[i])<1.e-12)
1201             pass
1202         #
1203         f3=f1+f2;
1204         f4=f3/f2;
1205         f4.checkCoherency();
1206         self.assertEqual(f4.getTypeOfField(),ON_NODES);
1207         self.assertEqual(f4.getTimeDiscretization(),ONE_TIME);
1208         tmp=f4.getArray().getValues();
1209         for i in xrange(len(tmp)):
1210             self.assertTrue(abs(tmp[i]-2.)<1.e-12)
1211             pass
1212         #
1213         f4=f2.buildNewTimeReprFromThis(NO_TIME,False);
1214         f4.checkCoherency();
1215         self.assertEqual(f4.getTypeOfField(),ON_NODES);
1216         self.assertEqual(f4.getTimeDiscretization(),NO_TIME);
1217         self.assertRaises(InterpKernelException,f1.__add__,f4);
1218         f5=f4.buildNewTimeReprFromThis(ONE_TIME,False);
1219         self.assertEqual(f5.getTypeOfField(),ON_NODES);
1220         self.assertEqual(f5.getTimeDiscretization(),ONE_TIME);
1221         f3=f1+f5;
1222         tmp=f3.getArray().getValues();
1223         values4=[-1.2,-0.2,0.8,-0.2,0.8,1.8,0.8,1.8,2.8]
1224         self.assertEqual(len(values3),len(tmp))
1225         for i in xrange(len(tmp)):
1226             self.assertTrue(abs(tmp[i]-values4[i])<1.e-12)
1227             pass
1228         #
1229         f4=f2.buildNewTimeReprFromThis(NO_TIME,True);
1230         f4.checkCoherency();
1231         self.assertEqual(f4.getTypeOfField(),ON_NODES);
1232         self.assertEqual(f4.getTimeDiscretization(),NO_TIME);
1233         self.assertRaises(InterpKernelException,f1.__add__,f4);
1234         f5=f4.buildNewTimeReprFromThis(ONE_TIME,True);
1235         self.assertEqual(f5.getTypeOfField(),ON_NODES);
1236         self.assertEqual(f5.getTimeDiscretization(),ONE_TIME);
1237         f3=f1+f5;
1238         tmp=f3.getArray().getValues();
1239         values5=[-1.2,-0.2,0.8,-0.2,0.8,1.8,0.8,1.8,2.8]
1240         self.assertEqual(len(values5),len(tmp))
1241         for i in xrange(len(tmp)):
1242             self.assertTrue(abs(tmp[i]-values5[i])<1.e-12)
1243             pass
1244         pass
1245
1246     def testOperationsOnFields2(self):
1247         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1248         m.setTime(3.4,5,6); m.setTimeUnit("us");
1249         f1=m.fillFromAnalytic(ON_NODES,1,"x+y+z");
1250         f2=m.fillFromAnalytic(ON_NODES,1,"a*a+b+c*c");
1251         f3=f1/f2;
1252         f3.checkCoherency();
1253         self.assertEqual(f3.getTypeOfField(),ON_NODES);
1254         self.assertEqual(f3.getTimeDiscretization(),ONE_TIME);
1255         expected1=[-2.4999999999999991, 1.2162162162162162, 0.77868852459016391,
1256                    0.7407407407407407, 1.129032258064516, 0.81632653061224492,
1257                    0.86538461538461531, 1.0919540229885056, 0.84302325581395343]
1258         self.assertEqual(1,f3.getNumberOfComponents());
1259         self.assertEqual(9,f3.getNumberOfTuples());
1260         val=f3.getArray().getValues();
1261         for i in xrange(9):
1262             self.assertTrue(abs(expected1[i]-val[i])<1.e-12);
1263         #
1264         f1=m.buildOrthogonalField();
1265         self.assertAlmostEqual(3.4,f1.getTime()[0],12) ; self.assertEqual(5,f1.getTime()[1]) ; self.assertEqual(6,f1.getTime()[2])
1266         self.assertEqual("us",f1.getTimeUnit())
1267         f2=m.fillFromAnalytic(ON_CELLS,1,"x");
1268         f3=f1*f2;
1269         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]
1270         val=f3.getArray().getValues();
1271         for i in xrange(15):
1272             self.assertTrue(abs(expected2[i]-val[i])<1.e-12);
1273             pass
1274         #
1275         f3=f2*f1;
1276         val=f3.getArray().getValues();
1277         for i in xrange(15):
1278             self.assertTrue(abs(expected2[i]-val[i])<1.e-12);
1279             pass
1280         pass
1281
1282     def testOperationsOnFields3(self):
1283         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1284         f1=m.fillFromAnalytic(ON_NODES,1,"x+y+z");
1285         f2=m.fillFromAnalytic(ON_NODES,1,"a*a+b+c*c");
1286         f1/=f2
1287         f1.checkCoherency();
1288         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1289         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1290         expected1=[-2.4999999999999991, 1.2162162162162162, 0.77868852459016391,
1291                    0.7407407407407407, 1.129032258064516, 0.81632653061224492,
1292                    0.86538461538461531, 1.0919540229885056, 0.84302325581395343]
1293         self.assertEqual(1,f1.getNumberOfComponents());
1294         self.assertEqual(9,f1.getNumberOfTuples());
1295         val=f1.getArray().getValues();
1296         for i in xrange(9):
1297             self.assertTrue(abs(expected1[i]-val[i])<1.e-12);
1298             pass
1299         #
1300         f1=m.buildOrthogonalField();
1301         f2=m.fillFromAnalytic(ON_CELLS,1,"x");
1302         f1*=f2
1303         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]
1304         val=f1.getArray().getValues();
1305         for i in xrange(15):
1306             self.assertTrue(abs(expected2[i]-val[i])<1.e-12);
1307             pass
1308         #
1309         f1=m.buildOrthogonalField();
1310         # to avoid valgrind leaks
1311         # self.assertRaises(InterpKernelException,f2.__imul__,f1);
1312         pass
1313
1314     def testOperationsOnFields4(self):
1315         m=MEDCouplingDataForTest.build2DTargetMesh_1();
1316         nbOfCells=m.getNumberOfCells();
1317         f1=MEDCouplingFieldDouble.New(ON_CELLS,CONST_ON_TIME_INTERVAL);
1318         f1.setMesh(m);
1319         array=DataArrayDouble.New();
1320         f1.setArray(array);
1321         self.assertRaises(InterpKernelException,f1.setEndArray,array);
1322         self.assertRaises(InterpKernelException,f1.getEndArray);
1323         arr1=[0.,10.,20.,1.,11.,21.,2.,12.,22.,3.,13.,23.,4.,14.,24.]
1324         arr2=[5.,15.,25.,6.,16.,26.,7.,17.,27.,8.,18.,28.,9.,19.,29.]
1325         array.setValues(arr1,nbOfCells,3);
1326         f1.setStartTime(2.,0,0);
1327         f1.setEndTime(3.,0,0);
1328         f1.checkCoherency();
1329         pos=[0.3,-0.2]
1330         res=f1.getValueOn(pos);
1331         self.assertTrue(abs(arr1[3]-res[0])<1.e-12);
1332         self.assertTrue(abs(arr1[4]-res[1])<1.e-12);
1333         self.assertTrue(abs(arr1[5]-res[2])<1.e-12);
1334         res=None
1335         res=f1.getValueOn(pos,2.2);
1336         self.assertTrue(abs(arr1[3]-res[0])<1.e-12);
1337         self.assertTrue(abs(arr1[4]-res[1])<1.e-12);
1338         self.assertTrue(abs(arr1[5]-res[2])<1.e-12);
1339         res=None
1340         self.assertRaises(InterpKernelException,f1.getValueOn,pos,3.2)
1341         f2=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
1342         f2.setMesh(m);
1343         f2.setArray(f1.getArray());
1344         f2.setStartTime(2.,3,0);
1345         f2.setEndTime(4.,13,0);
1346         self.assertRaises(InterpKernelException,f2.checkCoherency)
1347         array2=DataArrayDouble.New();
1348         array2.setValues(arr2,nbOfCells,3);
1349         f2.setEndArray(array2);
1350         f2.checkCoherency();
1351         #
1352         res=None
1353         res=f2.getValueOn(pos,3.21);
1354         self.assertTrue(abs(4.025-res[0])<1.e-12);
1355         self.assertTrue(abs(14.025-res[1])<1.e-12);
1356         self.assertTrue(abs(24.025-res[2])<1.e-12);
1357         f3=f2.clone(True);
1358         self.assertTrue(f2.isEqual(f3,1e-12,1e-12));
1359         f3.getEndArray().setIJ(0,0,5.001);
1360         self.assertTrue(not f2.isEqual(f3,1e-12,1e-12));
1361         self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1362         f3.setStartTime(2.1,3,0);
1363         self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1364         f3.setStartTime(2.,3,0);
1365         self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1366         f3.setStartTime(2.,4,0);
1367         self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1368         f3.setStartTime(2.,3,1);
1369         self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1370         f3.setStartTime(2.,3,0);
1371         self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1372         f3.setEndTime(4.1,13,0);
1373         self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1374         f3.setEndTime(4.,13,0);
1375         self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1376         f3.setEndTime(4.,14,0);
1377         self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1378         f3.setEndTime(4.,13,1);
1379         self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1380         f3.setEndTime(4.,13,0);
1381         self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1382         f4=f2+f2
1383         res=None
1384         res=f4.getValueOn(pos,3.21);
1385         self.assertTrue(abs(8.05-res[0])<1.e-12);
1386         self.assertTrue(abs(28.05-res[1])<1.e-12);
1387         self.assertTrue(abs(48.05-res[2])<1.e-12);
1388         f4+=f2;
1389         res=None
1390         res=f4.getValueOn(pos,3.21);
1391         self.assertTrue(abs(12.075-res[0])<1.e-12);
1392         self.assertTrue(abs(42.075-res[1])<1.e-12);
1393         self.assertTrue(abs(72.075-res[2])<1.e-12);
1394         pass
1395
1396     def testMergeNodesOnField(self):
1397         targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
1398         f1=targetMesh.fillFromAnalytic(ON_NODES,1,"x+y+z");
1399         f1.mergeNodes(1e-10);
1400         #
1401         targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
1402         f1=targetMesh.fillFromAnalytic(ON_NODES,1,"x+y+z");
1403         tmp=f1.getArray()
1404         tmp.setIJ(0,0,1000.);
1405         f1.mergeNodes(1e-10);
1406         #
1407         targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
1408         f1=targetMesh.fillFromAnalytic(ON_NODES,1,"x+y+z");
1409         tmp=f1.getArray()
1410         tmp.setIJ(1,0,1000.);
1411         self.assertRaises(InterpKernelException,f1.mergeNodes,1.e-10)
1412         pass
1413
1414     def testCheckConsecutiveCellTypes(self):
1415         sourceMesh=MEDCouplingDataForTest.build2DSourceMesh_1();
1416         targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1417         self.assertTrue(sourceMesh.checkConsecutiveCellTypes());
1418         order1=[NORM_TRI3,NORM_QUAD4]
1419         order2=[NORM_QUAD4,NORM_TRI3]
1420         self.assertTrue(not targetMesh.checkConsecutiveCellTypes());
1421         self.assertTrue(not targetMesh.checkConsecutiveCellTypesAndOrder(order1));
1422         self.assertTrue(not targetMesh.checkConsecutiveCellTypesAndOrder(order2));
1423         da=targetMesh.getRenumArrForConsecutiveCellTypesSpec(order1);
1424         self.assertEqual(5,da.getNumberOfTuples());
1425         self.assertEqual(1,da.getNumberOfComponents());
1426         expected1=[2,0,1,3,4]
1427         self.assertTrue(expected1==list(da.getValues()));
1428         da=targetMesh.getRenumArrForConsecutiveCellTypesSpec(order2);
1429         self.assertEqual(5,da.getNumberOfTuples());
1430         self.assertEqual(1,da.getNumberOfComponents());
1431         expected2=[0,3,4,1,2]
1432         self.assertTrue(expected2==list(da.getValues()));
1433         renumber1=[4,0,1,2,3]
1434         targetMesh.renumberCells(renumber1,False);
1435         self.assertTrue(targetMesh.checkConsecutiveCellTypes());
1436         self.assertTrue(targetMesh.checkConsecutiveCellTypesAndOrder(order1));
1437         self.assertTrue(not targetMesh.checkConsecutiveCellTypesAndOrder(order2));
1438         pass
1439
1440     def testRearrange2ConsecutiveCellTypes(self):
1441         m1_1=MEDCouplingDataForTest.build2DSourceMesh_1();
1442         m2_1=MEDCouplingDataForTest.build2DTargetMesh_1();
1443         arr1=m1_1.rearrange2ConsecutiveCellTypes();
1444         m1_2=MEDCouplingDataForTest.build2DSourceMesh_1();
1445         self.assertTrue(m1_2.isEqual(m1_1,1e-12));
1446         expected1=[0,1]
1447         self.assertEqual(2,arr1.getNumberOfTuples());
1448         self.assertEqual(1,arr1.getNumberOfComponents());
1449         self.assertEqual(expected1,arr1.getValues());
1450         expected2=[0,3,4,1,2]
1451         arr1=m2_1.rearrange2ConsecutiveCellTypes();
1452         self.assertEqual(5,arr1.getNumberOfTuples());
1453         self.assertEqual(1,arr1.getNumberOfComponents());
1454         self.assertEqual(expected2,list(arr1.getValues()));
1455         m2_2=MEDCouplingDataForTest.build2DTargetMesh_1();
1456         self.assertEqual(5,arr1.getNumberOfTuples());
1457         self.assertEqual(1,arr1.getNumberOfComponents());
1458         self.assertEqual(expected2,list(arr1.getValues()));
1459         self.assertTrue(not m2_2.isEqual(m2_1,1e-12));
1460         m2_2.renumberCells(expected2,False);
1461         self.assertTrue(m2_2.isEqual(m2_1,1e-12));
1462         pass
1463
1464     def testSplitByType(self):
1465         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1466         v=m1.splitByType();
1467         self.assertEqual(3,len(v));
1468         m2=MEDCouplingUMesh.MergeUMeshesOnSameCoords(v);
1469         m2.setName(m1.getName());
1470         self.assertTrue(m1.isEqual(m2,1.e-12));
1471         pass
1472
1473     def testFuseUMeshesOnSameCoords(self):
1474         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
1475         cells1=[2,3,4]
1476         m3=m2.buildPartOfMySelf(cells1,True);
1477         self.assertTrue(isinstance(m3,MEDCouplingUMesh))
1478         cells2=[1,2,4]
1479         m4=m2.buildPartOfMySelf(cells2,True);
1480         self.assertTrue(isinstance(m4,MEDCouplingUMesh))
1481         cells3=[1,2]
1482         m5=m2.buildPartOfMySelf(cells3,True);
1483         self.assertTrue(isinstance(m5,MEDCouplingUMesh))
1484         meshes=[m3,m4,m5]
1485         #
1486         m7,corr=MEDCouplingUMesh.FuseUMeshesOnSameCoords(meshes,0);
1487         self.assertEqual(4,m7.getNumberOfCells());
1488         self.assertEqual(3,len(corr));
1489         expectedVals1=[3,3,2]
1490         expectedVals2=[[0,1,2],[3,0,2],[3,0]]
1491         for i in xrange(3):
1492             arr=corr[i];
1493             self.assertEqual(1,arr.getNumberOfComponents());
1494             nbOfVals=expectedVals1[i];
1495             self.assertEqual(nbOfVals,arr.getNumberOfTuples());
1496             vals=arr.getValues();
1497             self.assertEqual(expectedVals2[i],list(vals));
1498             pass
1499         arr2,fidsOfGroups=DataArrayInt.MakePartition(corr,m7.getNumberOfCells());
1500         fidExp=[5,1,3,4]
1501         fidsGrp=[[1,3,5],[3,4,5],[4,5]]
1502         self.assertEqual(3,len(fidsOfGroups));
1503         self.assertEqual(1,arr2.getNumberOfComponents());
1504         self.assertEqual(4,arr2.getNumberOfTuples());
1505         self.assertEqual(fidExp,list(arr2.getValues()));
1506         for i in xrange(3):
1507             nbOfVals=expectedVals1[i];
1508             self.assertEqual(list(fidsOfGroups[i]),fidsGrp[i]);
1509             pass
1510         pass
1511
1512     def testFuseUMeshesOnSameCoords2(self):
1513         m1,m2=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
1514         part1=[2,3,6,4,10]
1515         m3=m1.buildPartOfMySelf(part1,True);
1516         part2=[5,6,4,7]
1517         m4=m1.buildPartOfMySelf(part2,True);
1518         meshes=[m1,m3,m3,m4]
1519         m5,corr=MEDCouplingUMesh.FuseUMeshesOnSameCoords(meshes,0);
1520         self.assertEqual(18,m5.getNumberOfCells());
1521         exp2=[
1522             [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17],
1523             [2,3,6,4,10],
1524             [2,3,6,4,10],
1525             [5,6,4,7]]
1526         i=0;
1527         for it in corr:
1528             self.assertEqual(exp2[i],list(it.getValues()));
1529             i+=1
1530             pass
1531         pass
1532
1533     def testBuildOrthogonalField(self):
1534         targetMesh=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1535         field=targetMesh.buildOrthogonalField();
1536         expected=[0.70710678118654746,0.,-0.70710678118654746]
1537         self.assertEqual(5,field.getNumberOfTuples());
1538         self.assertEqual(3,field.getNumberOfComponents());
1539         vals=field.getArray().getValues();
1540         for i in xrange(15):
1541             self.assertTrue(abs(expected[i%3]-vals[i])<1e-12);
1542         # testing
1543         targetCoords=[0.,0.,0.,0.5,0.,0.5,1.,0.,1.,0.,1.,0.]
1544         targetConn=[0,1,2,3]
1545         targetMesh=MEDCouplingUMesh.New();
1546         targetMesh.setMeshDimension(2);
1547         targetMesh.allocateCells(1);
1548         targetMesh.insertNextCell(NORM_QUAD4,targetConn[0:4])
1549         targetMesh.finishInsertingCells();
1550         myCoords=DataArrayDouble.New();
1551         myCoords.setValues(targetCoords,4,3);
1552         targetMesh.setCoords(myCoords);
1553         field=targetMesh.buildOrthogonalField();
1554         self.assertEqual(1,field.getNumberOfTuples());
1555         self.assertEqual(3,field.getNumberOfComponents());
1556         vals=field.getArray().getValues();
1557         self.assertTrue(abs(-0.70710678118654746-vals[0])<1e-12);
1558         self.assertTrue(abs(0.-vals[1])<1e-12);
1559         self.assertTrue(abs(0.70710678118654746-vals[2])<1e-12);
1560         pass
1561
1562     def testGetCellsContainingPoint(self):
1563         targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1564         pos=[0.,0.,0.4,0.4,0.,0.4,0.1,0.1,0.25,0.,0.65,0.]
1565         #2D basic
1566         t1,t2=targetMesh.getCellsContainingPoints(pos,6,1e-12);
1567         self.assertEqual(6,t1.getNumberOfTuples());
1568         self.assertEqual(1,t1.getNumberOfComponents());
1569         self.assertEqual(7,t2.getNumberOfTuples());
1570         self.assertEqual(1,t2.getNumberOfComponents());
1571         expectedValues1=[0,4,3,0,1,2]
1572         expectedValues2=[0,1,2,3,4,5,6]
1573         self.assertEqual(list(t1.getValues()),expectedValues1);
1574         self.assertEqual(list(t2.getValues()),expectedValues2);
1575         #2D with no help of bounding box.
1576         center=[0.2,0.2]
1577         MEDCouplingPointSet.Rotate2DAlg(center,0.78539816339744830962,6,pos);
1578         targetMesh.rotate(center,0.78539816339744830962);
1579         t1=None
1580         t2=None
1581         t1,t2=targetMesh.getCellsContainingPoints(pos,1e-12);
1582         self.assertEqual(6,t1.getNumberOfTuples());
1583         self.assertEqual(7,t2.getNumberOfTuples());
1584         self.assertEqual(list(t1.getValues()),expectedValues1);
1585         self.assertEqual(list(t2.getValues()),expectedValues2);
1586         t1,t2=targetMesh.getCellsContainingPoints(DataArrayDouble.New(pos,6,2),1e-12);
1587         self.assertEqual(6,t1.getNumberOfTuples());
1588         self.assertEqual(7,t2.getNumberOfTuples());
1589         self.assertEqual(list(t1.getValues()),expectedValues1);
1590         self.assertEqual(list(t2.getValues()),expectedValues2);
1591         self.assertRaises(InterpKernelException,targetMesh.getCellsContainingPoints,DataArrayDouble.New(pos,4,3),1e-12);
1592         #2D outside
1593         pos1bis=[-0.3303300858899107,-0.11819805153394641]
1594         self.assertEqual(-1,targetMesh.getCellContainingPoint(pos1bis,1e-12));
1595         #test limits 2D
1596         targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1597         pos2=[0.2,-0.05]
1598         t1=None
1599         t1=targetMesh.getCellsContainingPoint(pos2,1e-12)
1600         self.assertEqual(2,len(t1));
1601         expectedValues3=[0,1]
1602         self.assertEqual(list(t1.getValues()),expectedValues3);
1603         pos3=[0.2,0.2]
1604         t1=None
1605         t1=targetMesh.getCellsContainingPoint(pos3,1e-12);
1606         self.assertEqual(5,len(t1));
1607         expectedValues4=[0,1,2,3,4]
1608         self.assertEqual(list(t1.getValues()),expectedValues4);
1609         self.assertEqual(0,targetMesh.getCellContainingPoint(pos3,1e-12));
1610         #3D
1611         targetMesh=MEDCouplingDataForTest.build3DTargetMesh_1();
1612         pos4=[25.,25.,25.]
1613         self.assertEqual(0,targetMesh.getCellContainingPoint(pos4,1e-12));
1614         pos5=[50.,50.,50.]
1615         t1=None
1616         t1=targetMesh.getCellsContainingPoint(pos5,1e-12);
1617         self.assertEqual(8,len(t1));
1618         expectedValues5=[0,1,2,3,4,5,6,7]
1619         self.assertEqual(list(t1.getValues()),expectedValues5);
1620         pos6=[0., 50., 0.]
1621         t1=None
1622         t1=targetMesh.getCellsContainingPoint(pos6,1e-12);
1623         self.assertEqual(2,len(t1));
1624         expectedValues6=[0,2]
1625         self.assertEqual(list(t1.getValues()),expectedValues6);
1626         #3D outside
1627         pos7=[-1.0,-1.0,0.]
1628         self.assertEqual(-1,targetMesh.getCellContainingPoint(pos7,1e-12));
1629         #3D outside 2
1630         center2=[0.,0.,0.]
1631         vec2=[0.,-1.,0.]
1632         targetMesh.rotate(center2,vec2,0.78539816339744830962);
1633         pos8=[-25.,25.,12.]
1634         self.assertEqual(-1,targetMesh.getCellContainingPoint(pos8,1e-12));
1635         pass
1636
1637     def testGetValueOn1(self):
1638         targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1639         fieldOnCells=MEDCouplingFieldDouble.New(ON_CELLS);
1640         nbOfCells=targetMesh.getNumberOfCells();
1641         fieldOnCells.setMesh(targetMesh);
1642         array=DataArrayDouble.New();
1643         tmp=2*nbOfCells*[None]
1644         for i in xrange(nbOfCells):
1645             tmp[2*i]=7.+float(i);
1646             tmp[2*i+1]=17.+float(i)
1647             pass
1648         array.setValues(tmp,nbOfCells,2);
1649         fieldOnCells.setArray(array);
1650         #
1651         pos1=[0.25,0.]
1652         res=fieldOnCells.getValueOn(pos1);
1653         self.assertEqual(2,len(res))
1654         self.assertTrue(abs(8.-res[0])<1e-12);
1655         self.assertTrue(abs(18.-res[1])<1e-12);
1656         #
1657         #
1658         targetMesh=MEDCouplingDataForTest.build2DSourceMesh_1();
1659         fieldOnNodes=MEDCouplingFieldDouble.New(ON_NODES);
1660         nbOfNodes=targetMesh.getNumberOfNodes();
1661         fieldOnNodes.setMesh(targetMesh);
1662         array=DataArrayDouble.New();
1663         tmp=2*nbOfNodes*[None]
1664         for i in xrange(nbOfNodes):
1665             tmp[2*i]=17.+float(i);
1666             tmp[2*i+1]=27.+float(i)
1667             pass
1668         array.setValues(tmp,nbOfNodes,2);
1669         fieldOnNodes.setArray(array);
1670         #
1671         pos2=[-0.13333333333333333,-0.13333333333333333]
1672         res=None
1673         res=fieldOnNodes.getValueOn(pos2);
1674         self.assertEqual(2,len(res))
1675         self.assertTrue(abs(17.5-res[0])<1e-12);
1676         self.assertTrue(abs(27.5-res[1])<1e-12);
1677         pos3=[0.033333333333333326,0.36666666666666664]
1678         res=None
1679         res=fieldOnNodes.getValueOn(pos3);
1680         self.assertEqual(2,len(res))
1681         self.assertTrue(abs(18.666666666666667-res[0])<1e-12);
1682         self.assertTrue(abs(28.666666666666667-res[1])<1e-12);
1683         pass
1684
1685     def testCMesh0(self):
1686         mesh=MEDCouplingCMesh.New();
1687         meshEmpty=mesh.clone(True);
1688         self.assertTrue(meshEmpty.isEqual(mesh, 1e-12));
1689
1690         coordsX=DataArrayDouble.New();
1691         arrX=[ -1., 1., 2., 4. ]
1692         coordsX.setValues(arrX, 4, 1);
1693         coordsY=DataArrayDouble.New();
1694         arrY=[ -2., 2., 4., 8. ]
1695         coordsY.setValues(arrY, 4, 1);
1696         coordsZ=DataArrayDouble.New();
1697         arrZ=[ -3., 3., 6., 12. ]
1698         coordsZ.setValues(arrZ, 4, 1);
1699         mesh.setCoords(coordsX, coordsY, coordsZ);
1700         #
1701         fieldOnNodes=mesh.fillFromAnalytic(ON_NODES, 1, "x+y/2.+z/3.");
1702         self.assertEqual(1, fieldOnNodes.getNumberOfComponents());
1703         self.assertEqual(64, fieldOnNodes.getNumberOfTuples());
1704         expected1=[-3., -1., 0., 2., -1., 1., 2., 4., 0., 2., 3., 5., 2., 4., 5., 7., -1., 1., 2.,
1705                     4., 1., 3., 4., 6., 2., 4., 5., 7., 4., 6., 7., 9., 0., 2., 3., 5., 2., 4., 5.,
1706                     7., 3., 5., 6., 8., 5., 7., 8., 10., 2., 4., 5.,
1707                     7., 4., 6., 7., 9., 5., 7., 8., 10., 7., 9., 10., 12.];
1708
1709         val=fieldOnNodes.getArray().getValues();
1710         for i in xrange(64):
1711           self.assertAlmostEqual(expected1[i], val[i], 12)
1712         res=fieldOnNodes.getValueOnPos(1, 3, 2);
1713         self.assertAlmostEqual(7., res[0], 12);
1714         #
1715         fieldOnCells=mesh.fillFromAnalytic(ON_CELLS, 1, "x+y/2.+z/3.");
1716         self.assertEqual(1, fieldOnCells.getNumberOfComponents());
1717         self.assertEqual(27, fieldOnCells.getNumberOfTuples());
1718         val=fieldOnCells.getArray().getValues();
1719         expected2=[0, 1.5, 3, 1.5, 3, 4.5, 3, 4.5, 6, 1.5, 3, 4.5, 3, 4.5,
1720                     6, 4.5, 6, 7.5, 3, 4.5, 6, 4.5, 6, 7.5, 6, 7.5, 9];
1721         for i in xrange(27):
1722           self.assertAlmostEqual(expected2[i], val[i], 12);
1723         #res=fieldOnCells.getValueOnPos(1,2,1);
1724         #self.assertAlmostEqual(6.,res,12);
1725         #
1726         meshDeepCopy=mesh.deepCpy();
1727         meshClone=mesh.clone(False);
1728
1729         meshEmpty.copyTinyStringsFrom(mesh);
1730         #no data in meshEmpty, expected False
1731         self.assertTrue(not meshEmpty.isEqual(mesh, 1e-12));
1732
1733         self.assertTrue(meshDeepCopy.isEqual(mesh, 1e-12));
1734         meshDeepCopy.copyTinyStringsFrom(mesh);
1735         self.assertTrue(meshDeepCopy.isEqual(mesh, 1e-12));
1736         self.assertTrue(meshClone.isEqual(mesh, 1e-12));
1737
1738         self.assertEqual(CARTESIAN, mesh.getType());
1739         self.assertEqual(CARTESIAN, meshEmpty.getType());
1740         self.assertEqual(CARTESIAN, meshDeepCopy.getType());
1741         self.assertEqual(CARTESIAN, meshClone.getType());
1742         pass
1743
1744     def testCMesh1(self):
1745         mesh1=MEDCouplingCMesh.New();
1746         coordsX1=DataArrayDouble.New();
1747         arrX1=[ -1., 1., 2., 4. ]
1748         coordsX1.setValues(arrX1, 4, 1);
1749         coordsY1=DataArrayDouble.New();
1750         arrY1=[ -2., 2., 4., 8. ]
1751         coordsY1.setValues(arrY1, 4, 1);
1752         coordsZ1=DataArrayDouble.New();
1753         arrZ1=[ -3., 3., 6., 12. ]
1754         coordsZ1.setValues(arrZ1, 4, 1);
1755         mesh1.setCoords(coordsX1, coordsY1, coordsZ1);
1756
1757         mesh2=MEDCouplingCMesh.New();
1758         coordsX2=DataArrayDouble.New();
1759         arrX2=[ -1., 1., 2., 4. ]
1760         coordsX2.setValues(arrX2, 4, 1);
1761         coordsY2=DataArrayDouble.New();
1762         arrY2=[ -2., 2., 4., 8. ]
1763         coordsY2.setValues(arrY2, 4, 1);
1764         coordsZ2=DataArrayDouble.New();
1765         arrZ2=[ -3., 3., 6., 12.+1e-6 ]
1766         coordsZ2.setValues(arrZ2, 4, 1);
1767         mesh2.setCoords(coordsX2, coordsY2, coordsZ2);
1768
1769         mesh3=MEDCouplingCMesh.New();
1770         coordsX3=DataArrayDouble.New();
1771         arrX3=[-1.]
1772         coordsX3.setValues(arrX3, 1, 1);
1773         coordsY3=DataArrayDouble.New();
1774         arrY3=[-2.]
1775         coordsY3.setValues(arrY3, 1, 1);
1776         coordsZ3=DataArrayDouble.New();
1777         arrZ3=[-3.]
1778         coordsZ3.setValues(arrZ3, 1, 1);
1779         mesh3.setCoords(coordsX3, coordsY3, coordsZ3);
1780
1781         self.assertEqual(3, mesh1.getSpaceDimension());
1782         self.assertEqual(3, mesh1.getMeshDimension());
1783
1784         self.assertTrue(not mesh1.isEqual(mesh2, 1e-12));
1785         self.assertTrue(not mesh2.isEqual(mesh1, 1e-12));
1786         self.assertTrue(not mesh2.isEqualWithoutConsideringStr(mesh1, 1e-12));
1787         self.assertTrue(mesh1.isEqual(mesh2, 1e-5));
1788         self.assertTrue(not mesh1.isEqual(mesh2, 1e-7));
1789
1790         self.assertRaises(InterpKernelException, mesh3.checkCoherency1, 1e-12);
1791         mesh1.checkCoherency2(1e-12);
1792         self.assertEqual(NORM_HEXA8, mesh1.getTypeOfCell(1));
1793
1794         self.assertEqual(NORM_HEXA8, mesh1.getAllGeoTypes()[0]);
1795         self.assertEqual(27, mesh1.getNumberOfCellsWithType(NORM_HEXA8));
1796         self.assertRaises(InterpKernelException, mesh1.getNumberOfCellsWithType, NORM_QUAD4);
1797
1798         coo=mesh1.getCoordinatesOfNode(0);
1799         self.assertEqual(3, len(coo));
1800         self.assertAlmostEqual(-1., coo[0], 14);
1801         self.assertAlmostEqual(-2., coo[1], 14);
1802         self.assertAlmostEqual(-3., coo[2], 14);
1803         coo=mesh1.getCoordinatesOfNode(63);
1804         self.assertEqual(3, len(coo));
1805         self.assertAlmostEqual(4., coo[0], 14);
1806         self.assertAlmostEqual(8., coo[1], 14);
1807         self.assertAlmostEqual(12., coo[2], 14);
1808
1809         a=str(mesh1)
1810         repr=mesh1.simpleRepr();
1811         repr=mesh1.advancedRepr();
1812         self.assertTrue("Cartesian" in repr);
1813         self.assertTrue("Number of components : 1" in repr);
1814         self.assertTrue("Number of tuples : 4" in repr);
1815         self.assertTrue("Z Array :" in repr);
1816         pass
1817
1818     def testCMesh2(self):
1819         mesh1=MEDCouplingCMesh.New();
1820         coordsX1=DataArrayDouble.New();
1821         arrX1=[ -1., 1., 2., 4. ]
1822         coordsX1.setValues(arrX1, 4, 1);
1823         coordsY1=DataArrayDouble.New();
1824         arrY1=[ -2., 2., 4., 8. ]
1825         coordsY1.setValues(arrY1, 4, 1);
1826         coordsZ1=DataArrayDouble.New();
1827         arrZ1=[ -3., 3., 6., 12. ]
1828         coordsZ1.setValues(arrZ1, 4, 1);
1829         mesh1.setCoords(coordsX1, coordsY1, coordsZ1);
1830
1831         dis=mesh1.getDistributionOfTypes();
1832         self.assertEqual(1, len(dis));
1833         self.assertEqual(NORM_HEXA8, dis[0][0]);
1834         self.assertEqual(27, dis[0][1]);
1835         self.assertEqual(0, dis[0][2]);
1836
1837         idsPerType=[]
1838         self.assertRaises(InterpKernelException, mesh1.checkTypeConsistencyAndContig, dis, idsPerType);
1839         dis[0][2]=-1;
1840         idsPerType=[]
1841         self.assertTrue(not mesh1.checkTypeConsistencyAndContig(dis, idsPerType));
1842         dis[0][0]=NORM_QUAD4;
1843         self.assertRaises(InterpKernelException, mesh1.checkTypeConsistencyAndContig, dis, idsPerType);
1844         dis[0][0]=NORM_HEXA8;
1845         dis[0][2]=0;
1846         ids=DataArrayInt.New();
1847         ids.alloc(10, 1);
1848         ids.fillWithValue(23);
1849         idsPerType=[ids];
1850         check=mesh1.checkTypeConsistencyAndContig(dis, idsPerType);
1851         self.assertTrue(check);
1852         self.assertTrue(check.isEqual(ids));
1853
1854         code, idsInPflPerType, pfls=mesh1.splitProfilePerType(ids);
1855         self.assertEqual(1, len(code));
1856         self.assertEqual(NORM_HEXA8, code[0][0]);
1857         self.assertEqual(27, code[0][1]);
1858         self.assertEqual(0, code[0][2]);
1859         self.assertEqual(1, len(idsInPflPerType));
1860         self.assertEqual(1, len(pfls));
1861         self.assertTrue(idsInPflPerType[0].isEqual(DataArrayInt([0,1,2,3,4,5,6,7,8,9])));
1862         self.assertTrue(pfls[0].isEqual(ids));
1863
1864         cells1=[0, 1, 25, 26]
1865         partMesh1=mesh1.buildPart(cells1)
1866         self.assertTrue(isinstance(partMesh1,MEDCouplingMesh))
1867         self.assertEqual(4, partMesh1.getNumberOfCellsWithType(NORM_HEXA8));
1868         self.assertEqual(64, mesh1.getNumberOfNodes());
1869         self.assertEqual(64, partMesh1.getNumberOfNodes());
1870
1871         cells2=[25, 26]
1872         partMesh2, arr1=mesh1.buildPartAndReduceNodes(cells2)
1873         self.assertTrue(isinstance(partMesh2,MEDCouplingUMesh))
1874         self.assertEqual(2,partMesh2.getNumberOfCellsWithType(NORM_HEXA8));
1875         self.assertEqual(12,partMesh2.getNumberOfNodes());
1876
1877         cells3=[2, 3]
1878         partMesh3, arr2=partMesh1.buildPartAndReduceNodes(cells3)
1879         self.assertTrue(isinstance(partMesh3,MEDCouplingUMesh))
1880         self.assertEqual(2, partMesh3.getNumberOfCellsWithType(NORM_HEXA8));
1881         self.assertEqual(12, partMesh3.getNumberOfNodes());
1882
1883         self.assertRaises(InterpKernelException, mesh1.simplexize, 0);
1884         self.assertRaises(InterpKernelException, mesh1.getMeasureFieldOnNode, True);
1885
1886         #double bbox1[6];
1887         #double bbox2[6];
1888         bbox1=mesh1.getBoundingBox(); #[(-1.0, 4.0), (-2.0, 8.0), (-3.0, 12.0)]
1889         bbox2=partMesh1.getBoundingBox();
1890         self.assertTrue(bbox1==bbox2);
1891         bbox1=partMesh3.getBoundingBox();
1892         bbox2=partMesh2.getBoundingBox();
1893         self.assertTrue(bbox1==bbox2);
1894
1895         self.assertRaises(InterpKernelException, mesh1.buildOrthogonalField);
1896         mesh2d=MEDCouplingCMesh.New();
1897         mesh2d.setCoords(coordsX1, coordsY1);
1898         f1=mesh2d.buildOrthogonalField();
1899
1900         pass
1901
1902     def testScale(self):
1903         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1904         pos=[0.2,0.2]
1905         mesh.scale(pos,0.5);
1906         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,
1907                    -0.05,0.45, 0.2,0.45, 0.45,0.45]
1908         val=mesh.getCoords().getValues();
1909         self.assertEqual(18,len(val))
1910         for i in xrange(18):
1911             self.assertTrue(abs(expected1[i]-val[i])<1e-12);
1912             pass
1913         pass
1914
1915     def testTryToShareSameCoords(self):
1916         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
1917         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
1918         self.assertTrue(m1.getCoords().getHiddenCppPointer()!=m2.getCoords().getHiddenCppPointer());
1919         m1.tryToShareSameCoords(m2,1e-12);
1920         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1921         m1.tryToShareSameCoords(m2,1e-12);
1922         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1923         m2.tryToShareSameCoords(m1,1e-12);
1924         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1925         #
1926         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
1927         m2=MEDCouplingDataForTest.build2DTargetMesh_2();
1928         self.assertTrue(m1.getCoords().getHiddenCppPointer()!=m2.getCoords().getHiddenCppPointer());
1929         m1.tryToShareSameCoords(m2,1e-12);
1930         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1931         m1.tryToShareSameCoords(m2,1e-12);
1932         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1933         m2.tryToShareSameCoords(m1,1e-12);
1934         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1935         #
1936         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
1937         m2=MEDCouplingDataForTest.build2DSourceMesh_1();
1938         self.assertTrue(m1.getCoords().getHiddenCppPointer()!=m2.getCoords().getHiddenCppPointer());
1939         self.assertRaises(InterpKernelException,m1.tryToShareSameCoords,m2,1e-12)
1940         pass
1941
1942     def testFindNodeOnPlane(self):
1943         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
1944         pt=[300.,300.,0.]
1945         v=[0.,0.,2.]
1946         n=mesh.findNodesOnPlane(pt,v,1e-12);
1947         self.assertEqual(9,len(n));
1948         m3dSurf=mesh.buildFacePartOfMySelfNode(n,True);
1949         self.assertTrue(isinstance(m3dSurf,MEDCouplingUMesh))
1950         me=MEDCouplingExtrudedMesh.New(mesh,m3dSurf,0);
1951         da=me.getMesh3DIds();
1952         self.assertEqual(8,me.getNumberOfCells());
1953         expected=[0,1,2,3,4,5,6,7]
1954         val=da.getValues();
1955         self.assertEqual(expected,list(val));
1956         #
1957         m3dSurf=mesh.buildFacePartOfMySelfNode(n,True);
1958         self.assertTrue(isinstance(m3dSurf,MEDCouplingUMesh))
1959         me=MEDCouplingExtrudedMesh.New(mesh,m3dSurf,0);
1960         da=me.getMesh3DIds();
1961         self.assertEqual(8,me.getNumberOfCells());
1962         expected=[0,1,2,3,4,5,6,7]
1963         val=da.getValues();
1964         self.assertEqual(expected,list(val));
1965         pass
1966
1967     def testRenumberCells(self):
1968         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1969         m2=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1970         self.assertTrue(m.isEqual(m2,0));
1971         arr=[12,3,25,2,26]
1972         m.renumberCells(arr,True);
1973         self.assertTrue(not m.isEqual(m2,0));
1974         self.assertEqual(NORM_QUAD4,m.getTypeOfCell(0));
1975         self.assertEqual(NORM_TRI3,m.getTypeOfCell(1));
1976         self.assertEqual(NORM_QUAD4,m.getTypeOfCell(2));
1977         self.assertEqual(NORM_TRI3,m.getTypeOfCell(3));
1978         self.assertEqual(NORM_QUAD4,m.getTypeOfCell(4));
1979         arr2=[5,-1,-5,4,8]
1980         m.renumberCells(arr2,True);
1981         self.assertTrue(m.isEqual(m2,0));
1982         pass
1983
1984     def testChangeSpaceDimension(self):
1985         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1986         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
1987         #
1988         self.assertEqual(3,m1.getSpaceDimension());
1989         m1.changeSpaceDimension(2);
1990         self.assertEqual(2,m1.getSpaceDimension());
1991         m1.setName(m2.getName());
1992         self.assertTrue(m1.isEqual(m2,1e-12));
1993         m1.changeSpaceDimension(3);
1994         self.assertEqual(3,m1.getSpaceDimension());
1995         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.]
1996         val=m1.getCoords().getValues();
1997         for i in xrange(27):
1998             self.assertTrue(abs(expected[i]-val[i])<1e-14);
1999             pass
2000         pass
2001
2002     def testGaussPointField1(self):
2003         _a=0.446948490915965;
2004         _b=0.091576213509771;
2005         _p1=0.11169079483905;
2006         _p2=0.0549758718227661;
2007         refCoo1=[ 0.,0., 1.,0., 0.,1. ]
2008         gsCoo1=[ 2*_b-1, 1-4*_b, 2*_b-1, 2.07*_b-1, 1-4*_b,
2009                  2*_b-1, 1-4*_a, 2*_a-1, 2*_a-1, 1-4*_a, 2*_a-1, 2*_a-1 ]
2010         wg1=[ 4*_p2, 4*_p2, 4*_p2, 4*_p1, 4*_p1, 4*_p1 ]
2011         _refCoo1=refCoo1
2012         _gsCoo1=gsCoo1
2013         _wg1=wg1
2014         #
2015         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2016         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,NO_TIME);
2017         f.setMesh(m);
2018         self.assertEqual(5,f.getNumberOfMeshPlacesExpected());
2019         self.assertEqual(0,f.getNbOfGaussLocalization());
2020         f.setGaussLocalizationOnType(NORM_TRI3,_refCoo1,_gsCoo1,_wg1);
2021         f.setGaussLocalizationOnType(NORM_TRI3,_refCoo1,_gsCoo1,_wg1); # not a bug only to check that it works well
2022         self.assertRaises(InterpKernelException,f.setGaussLocalizationOnType,NORM_QUAD4,_refCoo1,_gsCoo1,_wg1)
2023         self.assertEqual(1,f.getNbOfGaussLocalization());
2024         refCoo2=[ 0.,0., 1.,0., 1.,1., 0.,1. ]
2025         _refCoo2=refCoo2
2026         _gsCoo1=_gsCoo1[0:4]
2027         _wg1=_wg1[0:2]
2028         f.setGaussLocalizationOnType(NORM_QUAD4,_refCoo2,_gsCoo1,_wg1);
2029         self.assertEqual(2,f.getNbOfGaussLocalization());
2030         array=DataArrayDouble.New();
2031         ptr=18*2*[None]
2032         for i in xrange(18*2):
2033             ptr[i]=float(i+1)
2034         array.setValues(ptr,18,2);
2035         ptr=array.getPointer();
2036         f.setArray(array);
2037         f.setName("MyFirstFieldOnGaussPoint");
2038         f.checkCoherency();
2039         self.assertAlmostEqual(27.,f.getIJK(2,5,0),14);
2040         self.assertAlmostEqual(16.,f.getIJK(1,5,1),14);
2041         #
2042         f.clearGaussLocalizations();
2043         self.assertEqual(0,f.getNbOfGaussLocalization());
2044         self.assertRaises(InterpKernelException,f.checkCoherency);
2045         ids1=[0,1,3,4]
2046         self.assertRaises(InterpKernelException,f.setGaussLocalizationOnCells,ids1,_refCoo2,_gsCoo1,_wg1);
2047         self.assertEqual(0,f.getNbOfGaussLocalization());
2048         ids2=[0,4]
2049         f.setGaussLocalizationOnCells(ids2,_refCoo2,_gsCoo1,_wg1);
2050         self.assertEqual(1,f.getNbOfGaussLocalization());
2051         self.assertEqual(0,f.getGaussLocalizationIdOfOneCell(0));
2052         self.assertRaises(InterpKernelException,f.getGaussLocalizationIdOfOneCell,1);
2053         ids3=[1,2]
2054         f.setGaussLocalizationOnCells(ids3,_refCoo1,_gsCoo1,_wg1);
2055         self.assertEqual(2,f.getNbOfGaussLocalization());
2056         self.assertEqual(0,f.getGaussLocalizationIdOfOneCell(0));
2057         self.assertEqual(1,f.getGaussLocalizationIdOfOneCell(1));
2058         self.assertEqual(1,f.getGaussLocalizationIdOfOneCell(2));
2059         self.assertRaises(InterpKernelException,f.checkCoherency);#<- cell 3 has no localization
2060         ids4=[3]
2061         _gsCoo2=_gsCoo1;
2062         _wg2=_wg1;
2063         _gsCoo2[0]=0.8888777776666;
2064         _wg2[0]=0.1234567892377;
2065         f.setGaussLocalizationOnCells(ids4,_refCoo2,_gsCoo2,_wg2);
2066         self.assertEqual(3,f.getNbOfGaussLocalization());
2067         tmpIds=f.getCellIdsHavingGaussLocalization(0);
2068         self.assertEqual(ids2,list(tmpIds.getValues()));
2069         self.assertRaises(InterpKernelException,f.checkCoherency);#<- it's always not ok because undelying array not with the good size.
2070         array2=f.getArray().substr(0,10);
2071         f.setArray(array2);
2072         f.checkCoherency();#<- here it is OK
2073         f2=f.clone(True);
2074         self.assertTrue(f.isEqual(f2,1e-14,1e-14));
2075         gl1=f2.getGaussLocalization(0);
2076         tmp=gl1.getGaussCoord(1,1);
2077         self.assertAlmostEqual(2.07*_b-1,tmp,14);
2078         gl1.setGaussCoord(1,1,0.07);
2079         self.assertTrue(not f.isEqual(f2,1e-14,1e-14));
2080         gl1.setGaussCoord(1,1,tmp);
2081         self.assertTrue(f.isEqual(f2,1e-14,1e-14));
2082         f2.checkCoherency();
2083         pass
2084
2085     def testGaussPointNEField1(self):
2086         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2087         f=MEDCouplingFieldDouble.New(ON_GAUSS_NE,NO_TIME);
2088         f.setMesh(m);
2089         self.assertEqual(5,f.getNumberOfMeshPlacesExpected());
2090         f.setName("MyFirstFieldOnNE");
2091         f.setDescription("MyDescriptionNE");
2092         array=DataArrayDouble.New();
2093         tmp=18*2*[None]
2094         for i in xrange(18*2):
2095             tmp[i]=float(i+7)
2096             pass
2097         array.setValues(tmp,18,2);
2098         ptr=array.getPointer();
2099         f.setArray(array);
2100         #
2101         f.checkCoherency();
2102         f2=f.clone(True);
2103         self.assertTrue(f.isEqual(f2,1e-14,1e-14));
2104         self.assertAlmostEqual(21.,f.getIJK(2,0,0),14);
2105         self.assertAlmostEqual(18.,f.getIJK(1,1,1),14);
2106         pass
2107
2108     def testCellOrientation1(self):
2109         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2110         vec=[0.,0.,-1.]
2111         self.assertRaises(InterpKernelException,m.are2DCellsNotCorrectlyOriented,vec,False);
2112         m.changeSpaceDimension(3);
2113         res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2114         self.assertTrue(len(res1)==0);
2115         vec[2]=1.;
2116         res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2117         self.assertEqual(5,len(res1));
2118         #
2119         vec[2]=-1.;
2120         # connectivity inversion
2121         conn=m.getNodalConnectivity().getValues();
2122         tmp=conn[11];
2123         conn[11]=conn[12];
2124         conn[12]=tmp;
2125         m.getNodalConnectivity().setValues(conn,len(conn),1)
2126         res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2127         self.assertEqual(1,len(res1));
2128         self.assertEqual(2,res1.getValues()[0]);
2129         m.orientCorrectly2DCells(vec,False);
2130         res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2131         self.assertTrue(len(res1)==0);
2132         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
2133         m2.changeSpaceDimension(3);
2134         self.assertTrue(m.isEqual(m2,1e-12));
2135         pass
2136
2137     def testCellOrientation2(self):
2138         m2,m1=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
2139         res1=m2.arePolyhedronsNotCorrectlyOriented();
2140         self.assertEqual(6,len(res1));
2141         m2.orientCorrectlyPolyhedrons();
2142         res1=m2.arePolyhedronsNotCorrectlyOriented();
2143         self.assertTrue(len(res1)==0);
2144         m2.checkCoherency();
2145         self.assertEqual(18,m2.getNumberOfCells());
2146         cellIds2=[0,6,12]
2147         m2.convertToPolyTypes(cellIds2);
2148         m2.orientCorrectlyPolyhedrons();
2149         res1=m2.arePolyhedronsNotCorrectlyOriented();
2150         self.assertTrue(len(res1)==0);
2151         f2=m2.getMeasureField(False);
2152         f2Ptr=f2.getArray().getValues();
2153         #Test to check global reverse in MEDCouplingUMesh::tryToCorrectPolyhedronOrientation
2154         m3=MEDCouplingDataForTest.build2DTargetMesh_1();
2155         vec=[0.,0.,1.]
2156         m3.changeSpaceDimension(3);
2157         ids2=[0,1,2,3,4]
2158         m3.convertToPolyTypes(ids2);
2159         m3.orientCorrectly2DCells(vec,False);
2160         m4=MEDCouplingDataForTest.buildCU1DMesh_U();
2161         m4.changeSpaceDimension(3);
2162         center=[0.,0.,0.]
2163         vector=[0.,1.,0.]
2164         m4.rotate(center,vector,-pi/2.);
2165         m5=m3.buildExtrudedMesh(m4,0);
2166         res1=m5.arePolyhedronsNotCorrectlyOriented();
2167         self.assertEqual(15,len(res1));
2168         m5.orientCorrectlyPolyhedrons();
2169         res1=m5.arePolyhedronsNotCorrectlyOriented();
2170         self.assertTrue(len(res1)==0);
2171         f3=m5.getMeasureField(False);
2172         self.assertEqual(15,f3.getArray().getNumberOfTuples());
2173         self.assertEqual(1,f3.getNumberOfComponents());
2174         f3Ptr=f3.getArray().getValues();
2175         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];
2176         for i in xrange(15):
2177             self.assertTrue(abs(expected1[i]-f3Ptr[i])<1e-12);
2178             pass
2179         f4=m5.getBarycenterAndOwner();
2180         self.assertEqual(15,f4.getNumberOfTuples());
2181         self.assertEqual(3,f4.getNumberOfComponents());
2182         f4Ptr=f4.getValues();
2183         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];
2184         for i in xrange(45):
2185             self.assertTrue(abs(expected2[i]-f4Ptr[i])<1e-12);
2186             pass
2187         pass
2188
2189     def testPolyhedronBarycenter(self):
2190         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];
2191         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];
2192         meshN=MEDCouplingUMesh.New();
2193         meshN.setName("ForBary");
2194         meshN.setMeshDimension(3);
2195         meshN.allocateCells(4);
2196         meshN.insertNextCell(NORM_POLYHED,29,connN[0:29])
2197         meshN.finishInsertingCells();
2198         myCoords=DataArrayDouble.New();
2199         myCoords.setValues(coords,9,3);
2200         meshN.setCoords(myCoords);
2201         meshN.checkCoherency();
2202         #
2203         res1=meshN.arePolyhedronsNotCorrectlyOriented();
2204         meshN.orientCorrectlyPolyhedrons();
2205         self.assertTrue(len(res1)==0);
2206         da=meshN.getBarycenterAndOwner();
2207         self.assertEqual(1,da.getNumberOfTuples());
2208         self.assertEqual(3,da.getNumberOfComponents());
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         center=[0.,0.,0.]
2216         vec=[0.,2.78,0.]
2217         da=meshN.getBarycenterAndOwner();
2218         daPtr=da.getValues();
2219         ref=meshN.getCoords().getValues()[24:];
2220         for i in xrange(3):
2221             self.assertTrue(abs(ref[i]-daPtr[i])<1e-12);
2222             pass
2223         #
2224         meshN.rotate(center,vec,pi/7.);
2225         meshN.translate(vec);
2226         da=meshN.getBarycenterAndOwner();
2227         daPtr=da.getValues();
2228         ref=meshN.getCoords().getValues()[24:];
2229         for i in xrange(3):
2230             self.assertTrue(abs(ref[i]-daPtr[i])<1e-12);
2231             pass
2232         #
2233         center2=[1.12,3.45,6.78]
2234         vec2=[4.5,9.3,2.8]
2235         meshN.rotate(center2,vec2,e);
2236         meshN.translate(vec2);
2237         da=meshN.getBarycenterAndOwner();
2238         daPtr=da.getValues();
2239         ref=meshN.getCoords().getValues()[24:];
2240         for i in xrange(3):
2241             self.assertTrue(abs(ref[i]-daPtr[i])<1e-10);
2242             pass
2243         pass
2244
2245     def testNormL12Integ1D(self):
2246         m1=MEDCouplingDataForTest.build1DTargetMesh_3();
2247         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2248         f1.setMesh(m1);
2249         array=DataArrayDouble.New();
2250         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]
2251         array.setValues(arr,m1.getNumberOfCells(),3);
2252         f1.setArray(array);
2253         #
2254         f3=m1.getBarycenterAndOwner();
2255         self.assertEqual(4,f3.getNumberOfTuples());
2256         self.assertEqual(1,f3.getNumberOfComponents());
2257         expected9=[0.75,5.105,0.8,5.155]
2258         ptr=f3.getValues();
2259         for i in xrange(4):
2260             self.assertTrue(abs(expected9[i]-ptr[i])<1e-12);
2261             pass
2262         #
2263         f2=m1.getMeasureField(False);
2264         self.assertEqual(4,f2.getArray().getNumberOfTuples());
2265         self.assertEqual(1,f2.getNumberOfComponents());
2266         expected1=[0.5,0.21,-0.6,-0.31]
2267         ptr=f2.getArray().getValues();
2268         for i in xrange(4):
2269             self.assertTrue(abs(expected1[i]-ptr[i])<1e-12);
2270             pass
2271         expected2=[0.5,0.21,0.6,0.31]
2272         f2=m1.getMeasureField(True);
2273         ptr=f2.getArray().getValues();
2274         for i in xrange(4):
2275             self.assertTrue(abs(expected2[i]-ptr[i])<1e-12);
2276             pass
2277         #integral
2278         self.assertTrue(4,f1.getNumberOfTuples())
2279         res=f1.integral(False);
2280         self.assertTrue(3,len(res))
2281         expected3=[0.9866,-0.3615,0.4217]
2282         for i in xrange(3):
2283             self.assertTrue(abs(expected3[i]-res[i])<1e-12);
2284             pass
2285         self.assertTrue(abs(expected3[0]-f1.integral(0,False))<1e-12);
2286         self.assertTrue(abs(expected3[1]-f1.integral(1,False))<1e-12);
2287         self.assertTrue(abs(expected3[2]-f1.integral(2,False))<1e-12);
2288         res=f1.integral(True);
2289         expected4=[-3.4152,8.7639,-14.6879]
2290         for i in xrange(3):
2291             self.assertTrue(abs(expected4[i]-res[i])<1e-12);
2292             pass
2293         #normL1
2294         res=f1.normL1();
2295         self.assertTrue(3,len(res))
2296         expected5=[6.979506172839505, 16.89018518518518, 27.02969135802469]
2297         for i in xrange(3):
2298             self.assertTrue(abs(expected5[i]-res[i])<1e-12);
2299             pass
2300         self.assertTrue(abs(expected5[0]-f1.normL1(0))<1e-12);
2301         self.assertTrue(abs(expected5[1]-f1.normL1(1))<1e-12);
2302         self.assertTrue(abs(expected5[2]-f1.normL1(2))<1e-12);
2303         #normL2
2304         res=f1.normL2();
2305         self.assertTrue(3,len(res))
2306         expected7=[7.090910979452395, 16.9275542960123, 27.053271464160858]
2307         for i in xrange(3):
2308             self.assertTrue(abs(expected7[i]-res[i])<1e-9);
2309             pass
2310         self.assertTrue(abs(expected7[0]-f1.normL2(0))<1e-9);
2311         self.assertTrue(abs(expected7[1]-f1.normL2(1))<1e-9);
2312         self.assertTrue(abs(expected7[2]-f1.normL2(2))<1e-9);
2313         #buildMeasureField
2314         f4=f1.buildMeasureField(False);
2315         self.assertTrue(abs(-0.2-f4.accumulate(0))<1e-12);
2316         f4=f1.buildMeasureField(True);
2317         self.assertTrue(abs(1.62-f4.accumulate(0))<1e-12);
2318         # Testing with 2D Curve
2319         m1=MEDCouplingDataForTest.build2DCurveTargetMesh_3();
2320         f2=m1.getMeasureField(False);
2321         self.assertEqual(4,f2.getArray().getNumberOfTuples());
2322         self.assertEqual(1,f2.getNumberOfComponents());
2323         ptr=f2.getArray().getValues();
2324         for i in xrange(4):
2325             self.assertTrue(abs(sqrt(2.)*expected2[i]-ptr[i])<1e-12);
2326             pass
2327         f2=m1.getMeasureField(True);
2328         self.assertEqual(4,f2.getArray().getNumberOfTuples());
2329         self.assertEqual(1,f2.getNumberOfComponents());
2330         ptr=f2.getArray().getValues();
2331         for i in xrange(4):
2332             self.assertTrue(abs(expected2[i]*sqrt(2.)-ptr[i])<1e-12);
2333             pass
2334         #bary
2335         f3=m1.getBarycenterAndOwner();
2336         self.assertEqual(4,f3.getNumberOfTuples());
2337         self.assertEqual(2,f3.getNumberOfComponents());
2338         expected10=[0.75,0.75,5.105,5.105,0.8,0.8,5.155,5.155]
2339         ptr=f3.getValues();
2340         for i in xrange(8):
2341             self.assertTrue(abs(expected10[i]-ptr[i])<1e-12);
2342             pass
2343         #
2344         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2345         f1.setMesh(m1);
2346         array=DataArrayDouble.New();
2347         array.setValues(arr,m1.getNumberOfCells(),3);
2348         f1.setArray(array);
2349         res=f1.integral(False);
2350         for i in xrange(3):
2351             self.assertTrue(abs(sqrt(2.)*expected4[i]-res[i])<1e-12);
2352             pass
2353         res=f1.integral(True);
2354         for i in xrange(3):
2355             self.assertTrue(abs(sqrt(2.)*expected4[i]-res[i])<1e-12);
2356             pass
2357         res=f1.normL1();
2358         for i in xrange(3):
2359             self.assertTrue(abs(expected5[i]-res[i])<1e-12);
2360             pass
2361         res=f1.normL2();
2362         for i in xrange(3):
2363             self.assertTrue(abs(expected7[i]-res[i])<1e-12);
2364             pass
2365         pass
2366
2367     def testAreaBary2D(self):
2368         m1=MEDCouplingDataForTest.build2DTargetMesh_3();
2369         f1=m1.getMeasureField(False);
2370         self.assertEqual(10,f1.getArray().getNumberOfTuples());
2371         self.assertEqual(1,f1.getNumberOfComponents());
2372         expected1=[-0.5,-1,-1.5,-0.5,-1,  0.5,1,1.5,0.5,1]
2373         ptr=f1.getArray().getValues();
2374         for i in xrange(10):
2375             self.assertTrue(abs(expected1[i]-ptr[i])<1e-12);
2376             pass
2377         f1=m1.getMeasureField(True);
2378         ptr=f1.getArray().getValues();
2379         for i in xrange(10):
2380             self.assertTrue(abs(abs(expected1[i])-ptr[i])<1e-12);
2381             pass
2382         f2=m1.getBarycenterAndOwner();
2383         self.assertEqual(10,f2.getNumberOfTuples());
2384         self.assertEqual(2,f2.getNumberOfComponents());
2385         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]
2386         ptr=f2.getValues();
2387         for i in xrange(20):
2388             self.assertTrue(abs(expected2[i]-ptr[i])<1e-12);
2389             pass
2390         m1.changeSpaceDimension(3);
2391         f1=m1.getMeasureField(False);
2392         self.assertEqual(10,f1.getArray().getNumberOfTuples());
2393         self.assertEqual(1,f1.getNumberOfComponents());
2394         ptr=f1.getArray().getValues();
2395         for i in xrange(10):
2396             self.assertTrue(abs(abs(expected1[i])-ptr[i])<1e-12);
2397             pass
2398         f2=m1.getBarycenterAndOwner();
2399         self.assertEqual(10,f2.getNumberOfTuples());
2400         self.assertEqual(3,f2.getNumberOfComponents());
2401         ptr=f2.getValues();
2402         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.]
2403         for i in xrange(30):
2404             self.assertTrue(abs(expected3[i]-ptr[i])<1e-12);
2405             pass
2406         pass
2407
2408     def testAreaBary3D(self):
2409         coords=[ 0.241310763507 , 0.0504777305619 , 0.0682283524903 , 0.252501053866 , -0.0625176732937 , 0.137272639894 ,
2410                  0.152262663601 , 0.241816569527 , 0.133812556197 , 0.18047750211 , -0.0789949051358 , 0.339098173401 ,
2411                  0.151741971857 , 0.238885278571 , 0.137715037333 , 0.242532155481 , -0.0928169086456 , 0.0678043417367 ,
2412                  0.240941965335 , -0.015461491464 , 0.0617186345825 , 0.24127650112 , 0.0499427876717 , 0.0679634099148 ,
2413                  -0.145828917428 , 0.206291632565 , 0.0310071927543 , 0.0125651775307 , 0.266262085828 , 0.105228430543 ,
2414                  -0.0994066533286 , 0.233224271238 , 0.0572213839567 , -0.0951345338317 , 0.234819509426 , 0.0592126284538 ,
2415                  0.136580574205 , -0.205486212579 , 0.0572866072014 , 0.0637270784978 , -0.168886355238 , 0.446614057077 ,
2416                  0.041337157151 , -0.213402568198 , 0.372407095999 , 0.0411601970268 , -0.202387875756 , 0.411334979491 ,
2417                  -0.108355701857 , 0.193636239335 , 0.204886756738 , 0.00639779029829 , 0.155296981517 , 0.252585892979 ,
2418                  0.0262473111702 , -0.112919732543 , 0.424286639249 ,-0.224103052733 , -0.139430015438 , -0.0122352295701 ,
2419                 -0.0312760589481 , -0.274272003594 , 0.0323959636568 , -0.166663422532 , -0.217754445175 , 0.00392109070364 ,
2420                  -0.30586619777 , -0.0475168041091 , -0.0144585228182 , -0.280881480586 , 0.135571293538 , 0.00623923647986 ,
2421                  -0.25548538234 , 0.156819217766 , 0.0645277879769 , -0.131567009284 , 0.184133752309 , 0.206021802753 ,
2422                  -0.196204010965 , 0.151602971681 , 0.212974777736 , -0.183713879463 , 0.0802946639531 , 0.260115662599 ,
2423                  -0.244241178767 , -0.0738873389604 , 0.144590565817 , -0.155804057829 , -0.164892720025 , 0.210613950558 ,
2424                  -0.170950800428 , -0.215099334026 , 0.00610122860092 , -0.30552634869 , -0.0490020791904 , -0.0132786533145 ,
2425                  0.271831011884 , 0.15105657296 , 0.0230534827908 , 0.281919192283 , 0.0898544306288 , -0.0625201489143 ,
2426                  0.260240727276 , -0.0120688706637 , -0.0532316588626 , 0.244947737722 , 0.0197984684293 , 0.0309341209233 ,
2427                  0.23439631578 , 0.229825279875 , 0.0508520585381 , 0.160921316875 , 0.265078502128 , 0.121716560626 ,
2428                  -0.315088694175 , 0.0747700471918 , -0.245836615071 , -0.327728781776 , 0.0857114674649 , -0.239431905957 ,
2429                  -0.308385460634 , 0.145142997084 , -0.149886828433 , 0.0488236045164 , 0.309462801914 , 0.0849169148265 ,
2430                 -0.0244964803395 , 0.33145611751 , -0.0476415818061 , 0.0060567994229 , 0.32418412014 , 0.0367779543812 ,
2431                  -0.0950221448063 , 0.236675326003 , 0.0572594453983 , 0.248723023186 , 0.0886648784791 , -0.176629430538 ,
2432                  0.116796984 , 0.256596599567 , -0.292863523603 , 0.118024552914 , 0.229154257843 , -0.34233232501 ,
2433                  0.217507892549 , -0.0417822335742 , -0.176771782888 , -0.224429321304 , 0.0125595300114 , -0.362064725588 ,
2434                  0.0937301100955 , -0.0500824832657 , -0.299713548444 , -0.244162220397 , 0.0383853931293 , -0.389856984411 ,
2435                  -0.0281989366102 , 0.097392811563 , -0.458244577284 , -0.385010847162 , 0.10122766194 , -0.140052859922 ,
2436                  -0.377936358012 , 0.110875172128 , -0.176207095463 , 0.244483045556 , -0.0991073977045 , 0.0575134372934 ,
2437                 0.262605120167 , -0.100243191645 , -0.0495620806935 , 0.240306880972 , -0.136153701579 , -0.114745281696 ,
2438                  0.215763176129 , -0.0836766059189 , -0.183249640616 , 0.237870396603 , -0.132449578286 , -0.121598854639 ,
2439                  -0.0637683083097 , -0.27921020214 , -0.149112321992 , -0.0856211014977 , -0.2973233473 , -0.0446878139589 ,
2440                  0.104675342288 , -0.0625908305324 , -0.290346256534 , 0.0248264249186 , -0.247797708548 , -0.165830884019 ,
2441                  0.0719302438309 , -0.178468260473 , -0.211432157345 , 0.142871843159 , -0.208769948542 , 0.0454101128246 ,
2442                  0.167803379307 , -0.207851396623 , -0.088802726124 , 0.12868717152 , -0.230920439715 , 0.00760508389036 ,
2443                  -0.0372812069535 , -0.286740286332 , 0.00963701291166 ]
2444
2445         connN = [ #polyhedron 0
2446             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
2447             , 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
2448             , 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
2449             , 22 , 19 , 21 , 30 , 31 , -1 , 22 , 31 , 28 , 27 , 26 , 24 , 23 , -1 , 31 , 30 , 29 , 28,
2450             # polyhedron 1
2451             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
2452             , 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
2453             , 33 , 34 , 48 , 45 , -1 , 35 , 34 , 48 , 50 , 49 , 38 , -1 , 41 , 43 , 42 , 46 , 36 , 37 , -1 , 38 , 39 , 51 , 49 , -1
2454             , 39 , 40 , 42 , 46 , 47 , 52 , 51 , -1 , 45 , 47 , 52 , 50 , 48 , -1 , 52 , 51 , 49 , 50,
2455             # polyhedron 2
2456             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
2457             , 23 , 53 , 54 , 40 , 8 , -1 , 53 , 22 , 23 , -1 , 39 , 54 , 40,
2458             # polyhedron 3
2459             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
2460             , 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
2461             , 55 , 5 , 12 , 65 , -1 , 66 , 67 , 65 , 55 , 56 , 57 , -1 , 63 , 66 , 57 , 59 , 64 , -1 , 64 , 62 , 58 , 59 , -1
2462             , 60 , 63 , 66 , 67 , 68 , 61 , -1 , 61 , 68 , 20 , 21 , -1 , 67 , 68 , 20 , 12 , 65]
2463
2464         barys = [ -0.0165220465527 , -0.0190922868195 , 0.158882733414 ,
2465                   0.0287618656076 , 0.135874379934 , -0.14601588119 ,
2466                   -0.147128055553 , 0.0465995097041 , -0.049391174453 ,
2467                   -0.00142506732317 , -0.0996953090351 , -0.115159183132 ]
2468         meshN=MEDCouplingUMesh.New();
2469         meshN.setName("ForBary");
2470         meshN.setMeshDimension(3);
2471         meshN.allocateCells(4);
2472         meshN.insertNextCell(NORM_POLYHED,113,connN);
2473         meshN.insertNextCell(NORM_POLYHED,99,connN[113:]);
2474         meshN.insertNextCell(NORM_POLYHED,43,connN[212:]);
2475         meshN.insertNextCell(NORM_POLYHED,92,connN[255:]);
2476         meshN.finishInsertingCells();
2477         myCoords=DataArrayDouble.New();
2478         myCoords.setValues(coords,69,3);
2479         meshN.setCoords(myCoords);
2480         meshN.checkCoherency();
2481         res1=meshN.arePolyhedronsNotCorrectlyOriented();
2482         meshN.orientCorrectlyPolyhedrons();
2483         res1=meshN.arePolyhedronsNotCorrectlyOriented();
2484         self.assertTrue(len(res1)==0);
2485         #
2486         da=meshN.getBarycenterAndOwner();
2487         self.assertEqual(4,da.getNumberOfTuples());
2488         self.assertEqual(3,da.getNumberOfComponents());
2489         daPtr=da.getValues();
2490         for i in xrange(12):
2491             self.assertTrue(abs(barys[i]-daPtr[i])<1e-12);
2492             pass
2493         pass
2494
2495     def testRenumberCellsForFields(self):
2496         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2497         f=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2498         f.setMesh(m);
2499         arr=DataArrayDouble.New();
2500         nbOfCells=m.getNumberOfCells();
2501         values1=[7.,107.,10007.,8.,108.,10008.,9.,109.,10009.,10.,110.,10010.,11.,111.,10011.]
2502         arr.setValues(values1,nbOfCells,3);
2503         f.setArray(arr);
2504         renumber1=[3,1,0,4,2]
2505         loc=[-0.05,-0.05, 0.55,-0.25, 0.55,0.15, -0.05,0.45, 0.45,0.45]
2506         for j in xrange(5):
2507             res=f.getValueOn(loc[2*j:2*j+2]);
2508             for i in xrange(3):
2509                 self.assertTrue(abs(values1[i+3*j]-res[i])<1e-12);
2510                 pass
2511             pass
2512         f.renumberCells(renumber1,False);
2513         ptr=f.getArray().getValues();
2514         expected1=[9.,109.,10009.,8.,108.,10008.,11.,111.,10011.,7.,107.,10007.,10.,110.,10010.]
2515         for i in xrange(15):
2516             self.assertTrue(abs(expected1[i]-ptr[i])<1e-12);
2517             pass
2518         #check that fields remains the same geometrically
2519         for j in xrange(5):
2520             res=f.getValueOn(loc[2*j:2*(j+1)]);
2521             for i in xrange(3):
2522                 self.assertTrue(abs(values1[i+3*j]-res[i])<1e-12);
2523                 pass
2524             pass
2525         #On gauss
2526         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,NO_TIME);
2527         f.setMesh(m);
2528         _a=0.446948490915965;
2529         _b=0.091576213509771;
2530         _p1=0.11169079483905;
2531         _p2=0.0549758718227661;
2532         refCoo1=[ 0.,0., 1.,0., 0.,1. ]
2533         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 ];
2534         wg1=[ 4*_p2, 4*_p2, 4*_p2, 4*_p1, 4*_p1, 4*_p1 ]
2535         _refCoo1=refCoo1[0:6];
2536         _gsCoo1=gsCoo1[0:12];
2537         _wg1=wg1[0:6];
2538         f.setGaussLocalizationOnType(NORM_TRI3,_refCoo1,_gsCoo1,_wg1);
2539         refCoo2=[ 0.,0., 1.,0., 1.,1., 0.,1. ]
2540         _refCoo2=refCoo2[0:8];
2541         _gsCoo1=_gsCoo1[0:4]
2542         _wg1=_wg1[0:2]
2543         f.setGaussLocalizationOnType(NORM_QUAD4,_refCoo2,_gsCoo1,_wg1);
2544         arr=DataArrayDouble.New();
2545         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.]
2546         arr.setValues(values2,18,2);
2547         f.setArray(arr);
2548         f.checkCoherency();
2549         fCpy=f.clone(True);
2550         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2551         f.renumberCells(renumber1,False);
2552         self.assertTrue(not f.isEqual(fCpy,1e-12,1e-12));
2553         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.]
2554         ptr=f.getArray().getValues();
2555         for i in xrange(36):
2556             self.assertTrue(abs(expected2[i]-ptr[i])<1e-12);
2557             pass
2558         renumber2=[2,1,4,0,3]
2559         f.renumberCells(renumber2,False);
2560         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2561         #GaussNE
2562         f=MEDCouplingFieldDouble.New(ON_GAUSS_NE,NO_TIME);
2563         f.setMesh(m);
2564         arr=DataArrayDouble.New();
2565         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.]
2566         arr.setValues(values3,18,2);
2567         f.setArray(arr);
2568         f.checkCoherency();
2569         fCpy=f.clone(True);
2570         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2571         f.renumberCells(renumber1,False);
2572         self.assertTrue(not f.isEqual(fCpy,1e-12,1e-12));
2573         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.]
2574         ptr=f.getArray().getValues();
2575         for i in xrange(36):
2576             self.assertTrue(abs(expected3[i]-ptr[i])<1e-12);
2577             pass
2578         f.renumberCells(renumber2,False);#perform reverse operation of renumbering to check that the resulting field is equal.
2579         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2580         #
2581         pass
2582
2583     def testRenumberNodesForFields(self):
2584         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2585         f=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
2586         f.setMesh(m);
2587         self.assertEqual(9,f.getNumberOfMeshPlacesExpected());
2588         arr=DataArrayDouble.New();
2589         nbOfNodes=m.getNumberOfNodes();
2590         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.]
2591         arr.setValues(values1,nbOfNodes,3);
2592         f.setArray(arr);
2593         f.checkCoherency();
2594         renumber1=[0,4,1,3,5,2,6,7,8]
2595         loc=[0.5432,-0.2432, 0.5478,0.1528]
2596         expected1=[9.0272, 109.0272, 10009.0272, 11.4124,111.4124,10011.4124]
2597         for j in xrange(2):
2598             res=f.getValueOn(loc[2*j:2*j+2]);
2599             for i in xrange(3):
2600                 self.assertTrue(abs(expected1[i+3*j]-res[i])<1e-12);
2601                 pass
2602             pass
2603         fCpy=f.clone(True);
2604         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2605         f.renumberNodes(renumber1);
2606         self.assertTrue(not f.isEqual(fCpy,1e-12,1e-12));
2607         for j in xrange(2):
2608             res=f.getValueOn(loc[2*j:2*j+2]);
2609             for i in xrange(3):
2610                 self.assertTrue(abs(expected1[i+3*j]-res[i])<1e-12);
2611                 pass
2612             pass
2613         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.]
2614         for i in xrange(27):
2615             self.assertTrue(abs(expected2[i]-f.getArray().getValues()[i])<1e-12);
2616             pass
2617         renumber2=[0,2,5,3,1,4,6,7,8]
2618         f.renumberNodes(renumber2);
2619         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2620         pass
2621
2622     def testConvertQuadraticCellsToLinear(self):
2623         mesh=MEDCouplingDataForTest.build2DTargetMesh_3();
2624         mesh.checkCoherency();
2625         types=mesh.getAllTypes();
2626         types.sort()
2627         self.assertEqual(5,len(types));
2628         expected1=[NORM_POLYGON, NORM_TRI3, NORM_QUAD4, NORM_TRI6, NORM_QUAD8]
2629         expected1.sort()
2630         self.assertEqual(expected1,types);
2631         self.assertTrue(mesh.isPresenceOfQuadratic());
2632         self.assertEqual(62,mesh.getMeshLength());
2633         f1=mesh.getMeasureField(False);
2634         #
2635         mesh.convertQuadraticCellsToLinear();
2636         self.assertTrue(not mesh.isPresenceOfQuadratic());
2637         #
2638         mesh.checkCoherency();
2639         f2=mesh.getMeasureField(False);
2640         self.assertTrue(f1.getArray().isEqual(f2.getArray(),1e-12));
2641         self.assertEqual(48,mesh.getMeshLength());
2642         types2=mesh.getAllTypes();
2643         types2.sort()
2644         self.assertEqual(3,len(types2));
2645         expected2=[NORM_POLYGON, NORM_TRI3, NORM_QUAD4]
2646         expected2.sort()
2647         self.assertEqual(expected2,types2);
2648         pass
2649
2650     def testCheckGeoEquivalWith(self):
2651         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2652         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2653         #First test mesh1
2654         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh1,0,1e-12);#deepEqual
2655         self.assertTrue(cellCor==None);
2656         self.assertTrue(nodeCor==None);
2657         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh1,1,1e-12);#fastEqual
2658         self.assertTrue(cellCor==None);
2659         self.assertTrue(nodeCor==None);
2660         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh1,10,1e-12);#deepEqual with geo permutations
2661         self.assertTrue(cellCor==None);
2662         self.assertTrue(nodeCor==None);
2663         #Second test mesh1 and mesh2 are 2 different meshes instance
2664         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,0,1e-12);#deepEqual
2665         self.assertTrue(cellCor==None);
2666         self.assertTrue(nodeCor==None);
2667         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,1,1e-12);#fastEqual
2668         self.assertTrue(cellCor==None);
2669         self.assertTrue(nodeCor==None);
2670         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);#deepEqual with geo permutations
2671         self.assertTrue(cellCor==None);
2672         self.assertTrue(nodeCor==None);
2673         #Third test : cell permutation by keeping the first the middle and the last as it is.
2674         renum=[0,2,1,3,4,5,6,8,7,9]
2675         mesh2.renumberCells(renum,False);
2676         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12);#deepEqual fails
2677         self.assertTrue(cellCor==None);
2678         self.assertTrue(nodeCor==None);
2679         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,1,1e-12);#fastEqual do not see anything
2680         self.assertTrue(cellCor==None);
2681         self.assertTrue(nodeCor==None);
2682         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);#deepEqual with geo permutations
2683         self.assertTrue(cellCor);
2684         self.assertEqual(10,cellCor.getNumberOfTuples());
2685         self.assertEqual(1,cellCor.getNumberOfComponents());
2686         self.assertEqual(renum,list(cellCor.getValues()))
2687         self.assertTrue(nodeCor==None);
2688         cellCor=0;
2689         self.assertTrue(nodeCor==None);
2690         a,b=mesh1.checkDeepEquivalWith(mesh2,0,1e-12);
2691         self.assertEqual(renum,list(a.getValues()))
2692         self.assertTrue(b==None);
2693         mesh2.setCoords(mesh1.getCoords())
2694         a=mesh1.checkDeepEquivalOnSameNodesWith(mesh2,0,1e-12);
2695         self.assertEqual(renum,list(a.getValues()))
2696         #4th test : cell and node permutation by keeping the first the middle and the last as it is.
2697         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2698         renum2=[0,2,1,3,4,5,6,8,7,9,10]
2699         mesh2.renumberCells(renum,False);
2700         mesh2.renumberNodes(renum2,11);
2701         cellCor=None
2702         nodeCor=None
2703         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12);#deepEqual fails
2704         self.assertTrue(cellCor==None);
2705         self.assertTrue(nodeCor==None);
2706         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,1,1e-12);#fastEqual do not see anything
2707         self.assertTrue(cellCor==None);
2708         self.assertTrue(nodeCor==None);
2709         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);#deepEqual with geo permutations
2710         self.assertTrue(cellCor);
2711         self.assertEqual(10,cellCor.getNumberOfTuples());
2712         self.assertEqual(1,cellCor.getNumberOfComponents());
2713         self.assertEqual(renum,list(cellCor.getValues()))
2714         self.assertTrue(nodeCor);
2715         self.assertEqual(11,nodeCor.getNumberOfTuples());
2716         self.assertEqual(1,nodeCor.getNumberOfComponents());
2717         self.assertEqual(renum2,list(nodeCor.getValues()))
2718         cellCor=0;
2719         nodeCor=0;
2720         #5th test : modification of the last cell to check fastCheck detection.
2721         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2722         renum3=[0,2,1,3,4,5,6,8,9,7]
2723         mesh2.renumberCells(renum3,False);
2724         mesh2.renumberNodes(renum2,11);
2725         cellCor=None
2726         nodeCor=None
2727         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12)
2728         self.assertTrue(cellCor==None);
2729         self.assertTrue(nodeCor==None);
2730         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,1,1e-12)
2731         self.assertTrue(cellCor==None);
2732         self.assertTrue(nodeCor==None);
2733         cellCor,nodeCor=mesh2.checkGeoEquivalWith(mesh1,10,1e-12);#deepEqual with geo permutations
2734         self.assertTrue(cellCor!=None);
2735         self.assertEqual(10,cellCor.getNumberOfTuples());
2736         self.assertEqual(1,cellCor.getNumberOfComponents());
2737         self.assertEqual(renum3,list(cellCor.getValues()))
2738         self.assertTrue(nodeCor!=None);
2739         self.assertEqual(11,nodeCor.getNumberOfTuples());
2740         self.assertEqual(1,nodeCor.getNumberOfComponents());
2741         self.assertEqual(renum2,list(nodeCor.getValues()));
2742         pass
2743
2744     def testCheckGeoEquivalWith2(self):
2745         mesh1=MEDCouplingDataForTest.build2DTargetMesh_4();
2746         mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
2747         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);
2748         self.assertEqual(None,cellCor);
2749         self.assertNotEqual(None,nodeCor);
2750         expected1=[0, 1, 3, 4, 5, 6, 7, 8, 9]
2751         for i in xrange(9):
2752             self.assertEqual(expected1[i],nodeCor.getIJ(i,0));
2753             pass
2754         pass
2755
2756     def testCopyTinyStringsFromOnFields(self):
2757         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2758         nbOfCells=m.getNumberOfCells();
2759         f=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
2760         f.setMesh(m);
2761         self.assertEqual(5,f.getNumberOfMeshPlacesExpected());
2762         f.setName("a");
2763         f.setDescription("b");
2764         a1=DataArrayDouble.New();
2765         a1.alloc(nbOfCells,2);
2766         a1.fillWithZero();
2767         a1.setInfoOnComponent(0,"c");
2768         a1.setInfoOnComponent(1,"d");
2769         a2=a1.deepCpy();
2770         a2.setInfoOnComponent(0,"e");
2771         a2.setInfoOnComponent(1,"f");
2772         f.setArray(a1);
2773         f.setEndArray(a2);
2774         f.setEndTime(3.,3,4);
2775         m.setName("g");
2776         m.getCoords().setInfoOnComponent(0,"h");
2777         m.getCoords().setInfoOnComponent(1,"i");
2778         m.getCoords().setInfoOnComponent(2,"j");
2779         #
2780         f.checkCoherency();
2781         f2=f.clone(True);
2782         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2783         f2.setName("smth");
2784         self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2785         f2.copyTinyStringsFrom(f);
2786         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2787         f2.setDescription("GGG");
2788         self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2789         f2.copyTinyStringsFrom(f);
2790         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2791         f2.getArray().setInfoOnComponent(0,"mmmm");
2792         self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2793         f2.copyTinyStringsFrom(f);
2794         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2795         f2.getEndArray().setInfoOnComponent(1,"mmmm");
2796         self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2797         f2.copyTinyStringsFrom(f);
2798         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2799         m2=m.clone(True);
2800         self.assertTrue(m2.isEqual(m,1e-12));
2801         m2.setName("123");
2802         self.assertTrue(not m2.isEqual(m,1e-12));
2803         m2.copyTinyStringsFrom(m);
2804         self.assertTrue(m2.isEqual(m,1e-12));
2805         m2.getCoords().setInfoOnComponent(1,"eee");
2806         self.assertTrue(not m2.isEqual(m,1e-12));
2807         m2.copyTinyStringsFrom(m);
2808         self.assertTrue(m2.isEqual(m,1e-12));
2809         pass
2810
2811     def testTryToShareSameCoordsPermute(self):
2812         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2813         m2=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2814         #self.assertTrue(m.getCoords()!=m2.getCoords());
2815         m.tryToShareSameCoordsPermute(m2,1e-12);
2816         #self.assertTrue(m.getCoords()==m2.getCoords());
2817         self.assertTrue(m2.isEqual(m,1e-12));
2818         renum1=[1,2,0,5,8,7,4,3,6]
2819         r1=DataArrayInt.New()
2820         r1.setValues(renum1,len(renum1),1)
2821         m.renumberNodes(r1,9);
2822         #self.assertTrue(m.getCoords()!=m2.getCoords());
2823         self.assertTrue(not m2.isEqual(m,1e-12));
2824         m.tryToShareSameCoordsPermute(m2,1e-12);
2825         #self.assertTrue(m.getCoords()==m2.getCoords());
2826         self.assertTrue(m2.isEqual(m,1e-12));
2827         pass
2828
2829     def testTryToShareSameCoordsPermute2(self):
2830         m1=MEDCouplingDataForTest.build2DTargetMesh_4();
2831         targetCoords=[-0.3,-0.3, 0.2,-0.3, -0.3,0.2, 0.2,0.2 ]
2832         targetConn=[0,2,3,1]
2833         m2=MEDCouplingUMesh.New();
2834         m2.setMeshDimension(2);
2835         m2.allocateCells(1);
2836         m2.insertNextCell(NORM_QUAD4,targetConn[0:4])
2837         m2.finishInsertingCells();
2838         myCoords=DataArrayDouble.New();
2839         myCoords.setValues(targetCoords,4,2);
2840         m2.setCoords(myCoords);
2841         m2.checkCoherency();
2842         m1.checkCoherency();
2843         #
2844         expected1=[0.25,0.125,0.125,0.25,0.25]
2845         f1=m1.getMeasureField(False);
2846         f2=m2.getMeasureField(False);
2847         self.assertEqual(5,f1.getArray().getNumberOfTuples());
2848         self.assertEqual(1,f2.getArray().getNumberOfTuples());
2849         for i in xrange(5):
2850             self.assertAlmostEqual(expected1[i],f1.getIJ(i,0),12);
2851             pass
2852         self.assertAlmostEqual(expected1[0],f2.getIJ(0,0),12);
2853         self.assertRaises(InterpKernelException,m1.tryToShareSameCoordsPermute,m2,1e-12);# <- here in this order the sharing is impossible.
2854         # Let's go for deeper test of tryToShareSameCoordsPermute
2855         m2.tryToShareSameCoordsPermute(m1,1e-12);
2856         f1=m1.getMeasureField(False);
2857         f2=m2.getMeasureField(False);
2858         self.assertEqual(5,f1.getArray().getNumberOfTuples());
2859         self.assertEqual(1,f2.getArray().getNumberOfTuples());
2860         for i in xrange(5):
2861             self.assertAlmostEqual(expected1[i],f1.getIJ(i,0),12);
2862             pass
2863         self.assertAlmostEqual(expected1[0],f2.getIJ(0,0),12);
2864         pass
2865
2866     def testChangeUnderlyingMesh1(self):
2867         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2868         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2869         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2870         f1.setMesh(mesh1);
2871         array=DataArrayDouble.New();
2872         arr=[7., 107., 8., 108., 9., 109., 10., 110., 11., 111., 12., 112., 13., 113., 14., 114., 15., 115., 16., 116.]
2873         array.setValues(arr,mesh1.getNumberOfCells(),2);
2874         f1.setArray(array);
2875         #
2876         renum=[0,2,1,3,4,5,6,8,7,9]
2877         mesh2.renumberCells(renum,False);
2878         #self.assertTrue(f1.getMesh()==mesh1);
2879         f1.changeUnderlyingMesh(mesh1,10,1e-12);# nothing done only to check that nothing done.
2880         #self.assertTrue(f1.getMesh()==mesh1);
2881         f1.changeUnderlyingMesh(mesh2,10,1e-12);
2882         #self.assertTrue(f1.getMesh()==mesh2);
2883         expected1=[7.,107.,9.,109.,8.,108.,10.,110.,11.,111.,12.,112.,13.,113.,15.,115.,14.,114.,16.,116.]
2884         for i in xrange(20):
2885             self.assertAlmostEqual(expected1[i],f1.getArray().getIJ(0,i),12);
2886             pass
2887         #
2888         f1=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
2889         f1.setMesh(mesh1);
2890         array=DataArrayDouble.New();
2891         arr2=[7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.,17.,117.]
2892         array.setValues(arr2,mesh1.getNumberOfNodes(),2);
2893         f1.setArray(array);
2894         #
2895         renum2=[0,2,10,3,4,5,6,8,7,9,1]
2896         mesh2.renumberNodes(renum2,11);
2897         #self.assertTrue(f1.getMesh()==mesh1);
2898         f1.changeUnderlyingMesh(mesh2,10,1e-12);
2899         #self.assertTrue(f1.getMesh()==mesh2);
2900         expected2=[7.,107.,17.,117.,8.,108.,10.,110.,11.,111.,12.,112.,13.,113.,15.,115.,14.,114.,16.,116.,9.,109.]
2901         for i in xrange(22):
2902             self.assertAlmostEqual(expected2[i],f1.getArray().getIJ(0,i),12);
2903             pass
2904         pass
2905
2906     def testGetMaxValue1(self):
2907         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2908         nbOfCells=m.getNumberOfCells();
2909         f=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
2910         f.setMesh(m);
2911         a1=DataArrayDouble.New();
2912         val1=[3.,4.,5.,6.,7.]
2913         a1.setValues(val1,nbOfCells,1);
2914         a2=DataArrayDouble.New();
2915         val2=[0.,1.,2.,8.,7.]
2916         a2.setValues(val2,nbOfCells,1);
2917         f.setArray(a1);
2918         f.setEndArray(a2);
2919         f.setEndTime(3.,3,4);
2920         f.checkCoherency();
2921         #
2922         self.assertAlmostEqual(8.,f.getMaxValue(),14);
2923         self.assertAlmostEqual(0.,f.getMinValue(),14);
2924         self.assertAlmostEqual(5.,f.getAverageValue(),14);
2925         self.assertAlmostEqual(5.125,f.getWeightedAverageValue(0,True),14);
2926         a1.setIJ(0,2,9.5);
2927         self.assertAlmostEqual(9.5,f.getMaxValue(),14);
2928         self.assertAlmostEqual(0.,f.getMinValue(),14);
2929         a2.setIJ(0,0,9.);
2930         self.assertAlmostEqual(9.5,f.getMaxValue(),14);
2931         self.assertAlmostEqual(1.,f.getMinValue(),14);
2932         pass
2933
2934     def testSubstractInPlaceDM1(self):
2935         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2936         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2937         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2938         f1.setMesh(mesh1);
2939         array=DataArrayDouble.New();
2940         arr=[7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.]
2941         array.setValues(arr,mesh1.getNumberOfCells(),2);
2942         f1.setArray(array);
2943         #
2944         self.assertEqual(10,f1.getNumberOfTuples());
2945         self.assertEqual(2,f1.getNumberOfComponents());
2946         self.assertEqual(20,f1.getNumberOfValues());
2947         #
2948         renum=[0,2,3,1,4,5,6,8,7,9]
2949         mesh2.renumberCells(renum,False);
2950         #
2951         f2=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2952         f2.setMesh(mesh2);
2953         array=DataArrayDouble.New();
2954         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]
2955         array.setValues(arr2,mesh2.getNumberOfCells(),2);
2956         f2.setArray(array);
2957         #
2958         f1.substractInPlaceDM(f2,10,1e-12);
2959         f1.applyFunc(1,"abs(x+y+0.2)");
2960         self.assertAlmostEqual(0.,f1.getMaxValue(),13);
2961         pass
2962
2963     def testDotCrossProduct1(self):
2964         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2965         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
2966         f1.setTime(2.3,5,6);
2967         f1.setMesh(mesh1);
2968         array=DataArrayDouble.New();
2969         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.]
2970         array.setValues(arr1,mesh1.getNumberOfCells(),3);
2971         f1.setArray(array);
2972         f2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
2973         f2.setTime(7.8,4,5);
2974         f2.setMesh(mesh1);
2975         array=DataArrayDouble.New();
2976         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.]
2977         array.setValues(arr2,mesh1.getNumberOfCells(),3);
2978         f2.setArray(array);
2979         #
2980         f3=f1.dot(f2);
2981         expected1=[842.,1820.,2816.,3830.,4862.,5912.,6980.,8066.,9170.,10292.]
2982         for i in xrange(10):
2983             self.assertAlmostEqual(expected1[i],f3.getIJ(i,0),9);
2984             pass
2985         #
2986         f4=f1.crossProduct(f2);
2987         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.]
2988         for i in xrange(30):
2989             self.assertAlmostEqual(expected2[i],f4.getIJ(0,i),9);
2990             pass
2991         pass
2992
2993     def testMinMaxFields1(self):
2994         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2995         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
2996         f1.setTime(2.3,5,6);
2997         f1.setMesh(mesh1);
2998         array=DataArrayDouble.New();
2999         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.]
3000         array.setValues(arr1,mesh1.getNumberOfCells(),3);
3001         f1.setArray(array);
3002         f2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3003         f2.setTime(7.8,4,5);
3004         f2.setMesh(mesh1);
3005         array=DataArrayDouble.New();
3006         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.]
3007         array.setValues(arr2,mesh1.getNumberOfCells(),3);
3008         f2.setArray(array);
3009         #
3010         f3=f1.max(f2);
3011         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.]
3012         for i in xrange(30):
3013             self.assertAlmostEqual(expected1[i],f3.getIJ(0,i),9);
3014             pass
3015         #
3016         f4=f1.min(f2);
3017         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.]
3018         for i in xrange(30):
3019             self.assertAlmostEqual(expected2[i],f4.getIJ(0,i),9);
3020             pass
3021         #
3022         pass
3023
3024     def testApplyLin1(self):
3025         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
3026         f1=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
3027         f1.setMesh(mesh1);
3028         array=DataArrayDouble.New();
3029         arr=[7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.]
3030         array.setValues(arr,mesh1.getNumberOfCells(),2);
3031         f1.setArray(array);
3032         #
3033         f1.applyLin(2.,3.,0);
3034         expected1=[17.,107.,19.,108.,21.,109.,23.,110.,25.,111.,27.,112.,29.,113.,31.,114.,33.,115.,35.,116.]
3035         for i in xrange(20):
3036             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),9);
3037             pass
3038         #
3039         arr2=[2.,102.,3.,103.,4.,104.,5.,105.,6.,106.,7.,107.,8.,108.,9.,109.,10.,110.,11.,111.]
3040         array=DataArrayDouble.New();
3041         array.setValues(arr2,mesh1.getNumberOfCells(),2);
3042         f1.setEndArray(array);
3043         #
3044         f1.applyLin(4.,5.,1);
3045         #
3046         expected2=[17.,433.,19.,437.,21.,441.,23.,445.,25.,449.,27.,453.,29.,457.,31.,461.,33.,465.,35.,469.]
3047         for i in xrange(20):
3048             self.assertAlmostEqual(expected2[i],f1.getIJ(0,i),9);
3049             pass
3050         expected3=[2.,413.,3.,417.,4.,421.,5.,425.,6.,429.,7.,433.,8.,437.,9.,441.,10.,445.,11.,449.]
3051         for i in xrange(20):
3052             self.assertAlmostEqual(expected3[i],f1.getEndArray().getIJ(0,i),9);
3053             pass
3054         #
3055         pass
3056
3057     def testGetIdsInRange1(self):
3058         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
3059         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3060         f1.setTime(2.3,5,6);
3061         f1.setMesh(mesh1);
3062         array=DataArrayDouble.New();
3063         arr1=[2.,8.,6.,5.,11.,7.,9.,3.,10.,4.]
3064         array.setValues(arr1,mesh1.getNumberOfCells(),1);
3065         f1.setArray(array);
3066         #
3067         f1.checkCoherency();
3068         da=f1.getIdsInRange(2.9,7.1);
3069         self.failUnlessEqual(5,da.getNbOfElems());
3070         expected1=[2,3,5,7,9]
3071         self.failUnlessEqual(expected1,list(da.getValues()));
3072         da=f1.getIdsInRange(8.,12.);
3073         self.failUnlessEqual(4,da.getNbOfElems());
3074         expected2=[1,4,6,8]
3075         self.failUnlessEqual(expected2,list(da.getValues()));
3076         #
3077         pass
3078
3079     def testBuildSubPart1(self):
3080         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3081         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3082         f1.setTime(2.3,5,6);
3083         f1.setMesh(mesh1);
3084         array=DataArrayDouble.New();
3085         arr1=[3.,103.,4.,104.,5.,105.,6.,106.,7.,107.]
3086         array.setValues(arr1,mesh1.getNumberOfCells(),2);
3087         f1.setArray(array);
3088         #
3089         part1=[2,1,4]
3090         f2=f1[part1];
3091         f2.zipCoords()
3092         self.failUnlessEqual(3,f2.getNumberOfTuples());
3093         self.failUnlessEqual(2,f2.getNumberOfComponents());
3094         expected1=[5.,105.,4.,104.,7.,107.]
3095         for i in xrange(6):
3096             self.assertAlmostEqual(f2.getIJ(0,i),expected1[i],12);
3097             pass
3098         self.failUnlessEqual(3,f2.getMesh().getNumberOfCells());
3099         self.failUnlessEqual(6,f2.getMesh().getNumberOfNodes());
3100         self.failUnlessEqual(2,f2.getMesh().getSpaceDimension());
3101         self.failUnlessEqual(2,f2.getMesh().getMeshDimension());
3102         m2C=f2.getMesh();
3103         self.failUnlessEqual(13,m2C.getMeshLength());
3104         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]
3105         for i in xrange(12):
3106             self.assertAlmostEqual(expected2[i],m2C.getCoords().getIJ(0,i),12);
3107             pass
3108         expected3=[3,2,3,1,3,0,2,1,4,4,5,3,2]
3109         self.failUnlessEqual(expected3,list(m2C.getNodalConnectivity().getValues()));
3110         expected4=[0,4,8,13]
3111         self.failUnlessEqual(expected4,list(m2C.getNodalConnectivityIndex().getValues()));
3112         # Test with field on nodes.
3113         f1=MEDCouplingFieldDouble.New(ON_NODES,ONE_TIME);
3114         f1.setTime(2.3,5,6);
3115         f1.setMesh(mesh1);
3116         array=DataArrayDouble.New();
3117         arr2=[3.,103.,4.,104.,5.,105.,6.,106.,7.,107.,8.,108.,9.,109.,10.,110.,11.,111.]
3118         array.setValues(arr2,mesh1.getNumberOfNodes(),2);
3119         f1.setArray(array);
3120         part2=[1,2]
3121         f2=f1.buildSubPart(part2);
3122         self.failUnlessEqual(4,f2.getNumberOfTuples());
3123         self.failUnlessEqual(2,f2.getNumberOfComponents());
3124         expected5=[4.,104.,5.,105.,7.,107.,8.,108.]
3125         for i in xrange(8):
3126             self.assertAlmostEqual(f2.getIJ(0,i),expected5[i],12);
3127             pass
3128         self.failUnlessEqual(2,f2.getMesh().getNumberOfCells());
3129         self.failUnlessEqual(4,f2.getMesh().getNumberOfNodes());
3130         self.failUnlessEqual(2,f2.getMesh().getSpaceDimension());
3131         self.failUnlessEqual(2,f2.getMesh().getMeshDimension());
3132         m2C=f2.getMesh();
3133         self.failUnlessEqual(8,m2C.getMeshLength());
3134         for i in xrange(8):#8 is not an error
3135             self.assertAlmostEqual(expected2[i],m2C.getCoords().getIJ(0,i),12);
3136             pass
3137         self.failUnlessEqual(expected3[:4],list(m2C.getNodalConnectivity().getValues())[4:]);
3138         self.failUnlessEqual(expected3[4:8],list(m2C.getNodalConnectivity().getValues())[:4]);
3139         self.failUnlessEqual(expected4[:3],list(m2C.getNodalConnectivityIndex().getValues()));
3140         #idem previous because nodes of cell#4 are not fully present in part3
3141         part3=[1,2]
3142         arrr=DataArrayInt.New();
3143         arrr.setValues(part3,2,1);
3144         f2=f1.buildSubPart(arrr);
3145         self.failUnlessEqual(4,f2.getNumberOfTuples());
3146         self.failUnlessEqual(2,f2.getNumberOfComponents());
3147         for i in xrange(8):
3148             self.assertAlmostEqual(f2.getIJ(0,i),expected5[i],12);
3149             pass
3150         self.failUnlessEqual(2,f2.getMesh().getNumberOfCells());
3151         self.failUnlessEqual(4,f2.getMesh().getNumberOfNodes());
3152         self.failUnlessEqual(2,f2.getMesh().getSpaceDimension());
3153         self.failUnlessEqual(2,f2.getMesh().getMeshDimension());
3154         m2C=f2.getMesh();
3155         self.failUnlessEqual(8,m2C.getMeshLength());
3156         for i in xrange(8):#8 is not an error
3157             self.assertAlmostEqual(expected2[i],m2C.getCoords().getIJ(0,i),12);
3158             pass
3159         self.failUnlessEqual(expected3[:4],list(m2C.getNodalConnectivity().getValues())[4:8]);
3160         self.failUnlessEqual(expected3[4:8],list(m2C.getNodalConnectivity().getValues())[:4]);
3161         self.failUnlessEqual(expected4[:3],list(m2C.getNodalConnectivityIndex().getValues()));
3162         #
3163         part4=[1,2,4]
3164         f2=f1.buildSubPart(part4);
3165         self.failUnlessEqual(6,f2.getNumberOfTuples());
3166         self.failUnlessEqual(2,f2.getNumberOfComponents());
3167         expected6=[4.,104.,5.,105.,7.,107.,8.,108.,10.,110.,11.,111.]
3168         for i in xrange(12):
3169             self.assertAlmostEqual(f2.getIJ(0,i),expected6[i],12);
3170             pass
3171         self.failUnlessEqual(3,f2.getMesh().getNumberOfCells());
3172         self.failUnlessEqual(6,f2.getMesh().getNumberOfNodes());
3173         self.failUnlessEqual(2,f2.getMesh().getSpaceDimension());
3174         self.failUnlessEqual(2,f2.getMesh().getMeshDimension());
3175         m2C=f2.getMesh();
3176         self.failUnlessEqual(13,m2C.getMeshLength());
3177         for i in xrange(12):
3178             self.assertAlmostEqual(expected2[i],m2C.getCoords().getIJ(0,i),12);
3179             pass
3180         self.failUnlessEqual(expected3[0:4],list(m2C.getNodalConnectivity().getValues())[4:8]);
3181         self.failUnlessEqual(expected3[4:8],list(m2C.getNodalConnectivity().getValues())[0:4]);
3182         self.failUnlessEqual(expected3[8:13],list(m2C.getNodalConnectivity().getValues())[8:13]);
3183         self.failUnlessEqual(expected4,list(m2C.getNodalConnectivityIndex().getValues()));
3184         pass
3185
3186     def testDoublyContractedProduct1(self):
3187         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3188         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3189         f1.setMesh(mesh1);
3190         array=DataArrayDouble.New();
3191         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]
3192         array.setValues(arr1,mesh1.getNumberOfCells(),6);
3193         f1.setArray(array);
3194         f1.checkCoherency();
3195         #
3196         f2=f1.doublyContractedProduct();
3197         f2.checkCoherency();
3198         self.assertEqual(1,f2.getNumberOfComponents());
3199         self.assertEqual(5,f2.getNumberOfTuples());
3200         for i in xrange(5):
3201             self.assertAlmostEqual(3906.56,f2.getIJ(i,0),9);
3202             pass
3203         #
3204         pass
3205
3206     def testDeterminant1(self):
3207         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3208         f1=MEDCouplingFieldDouble.New(ON_CELLS,CONST_ON_TIME_INTERVAL);
3209         f1.setTime(2.3,5,6);
3210         f1.setEndTime(3.8,7,3);
3211         f1.setMesh(mesh1);
3212         array=DataArrayDouble.New();
3213         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]
3214         array.setValues(arr1,mesh1.getNumberOfCells(),4);
3215         f1.setArray(array);
3216         #4 components
3217         f1.checkCoherency();
3218         f2=f1.determinant();
3219         f2.checkCoherency();
3220         self.assertEqual(CONST_ON_TIME_INTERVAL,f2.getTimeDiscretization());
3221         self.assertEqual(1,f2.getNumberOfComponents());
3222         self.assertEqual(5,f2.getNumberOfValues());
3223         for i in xrange(5):
3224             self.assertAlmostEqual(-2.42,f2.getIJ(i,0),13);
3225             pass
3226         #6 components multi arrays with end array not defined
3227         f1=MEDCouplingFieldDouble.New(ON_NODES,LINEAR_TIME);
3228         f1.setTime(2.3,5,6);
3229         f1.setEndTime(3.8,7,3);
3230         f1.setMesh(mesh1);
3231         array=DataArrayDouble.New();
3232         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,
3233               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]
3234         array.setValues(arr2,mesh1.getNumberOfNodes(),6);
3235         f1.setArray(array);
3236         self.assertRaises(InterpKernelException,f1.checkCoherency);#no end array specified !
3237         #
3238         f2=f1.determinant();
3239         self.assertEqual(LINEAR_TIME,f2.getTimeDiscretization());
3240         self.assertEqual(1,f2.getArray().getNumberOfComponents());
3241         self.assertEqual(9,f2.getNumberOfTuples());
3242         for i in xrange(9):
3243             self.assertAlmostEqual(137.335,f2.getIJ(i,0),10);
3244             pass
3245         #6 components multi arrays with end array defined
3246         array=DataArrayDouble.New();
3247         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,
3248               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]
3249         array.setValues(arr3,mesh1.getNumberOfNodes(),6);
3250         f1.setEndArray(array);
3251         f1.checkCoherency();
3252         f2=f1.determinant();
3253         f2.checkCoherency();
3254         self.assertEqual(LINEAR_TIME,f2.getTimeDiscretization());
3255         self.assertEqual(1,f2.getNumberOfComponents());
3256         self.assertEqual(9,f2.getNumberOfTuples());
3257         time2,it,order=f2.getTime()
3258         self.assertAlmostEqual(2.3,time2,12);
3259         self.assertEqual(5,it);
3260         self.assertEqual(6,order);
3261         time2,it,order=f2.getEndTime()
3262         self.assertAlmostEqual(3.8,time2,12);
3263         self.assertEqual(7,it);
3264         self.assertEqual(3,order);
3265         for i in xrange(9):
3266             self.assertAlmostEqual(137.335,f2.getIJ(i,0),10);
3267             self.assertAlmostEqual(1289.685,f2.getEndArray().getIJ(i,0),9);
3268             pass
3269         #9 components
3270         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3271         f1.setTime(7.8,10,2);
3272         f1.setMesh(mesh1);
3273         array=DataArrayDouble.New();
3274         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]
3275         array.setValues(arr4,mesh1.getNumberOfCells(),9);
3276         f1.setArray(array);
3277         #
3278         f1.checkCoherency();
3279         f2=f1.determinant();
3280         f2.checkCoherency();
3281         self.assertEqual(ONE_TIME,f2.getTimeDiscretization());
3282         self.assertEqual(1,f2.getNumberOfComponents());
3283         self.assertEqual(5,f2.getNumberOfTuples());
3284         time2,it,order=f2.getTime()
3285         self.assertAlmostEqual(7.8,time2,12);
3286         self.assertEqual(10,it);
3287         self.assertEqual(2,order);
3288         for i in xrange(5):
3289             self.assertAlmostEqual(3.267,f2.getIJ(i,0),13);
3290             pass
3291         pass
3292
3293     def testEigenValues1(self):
3294         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3295         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3296         f1.setMesh(mesh1);
3297         array=DataArrayDouble.New();
3298         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]
3299         array.setValues(arr1,mesh1.getNumberOfCells(),6);
3300         f1.setArray(array);
3301         f1.checkCoherency();
3302         #
3303         f2=f1.eigenValues();
3304         f2.checkCoherency();
3305         self.assertEqual(3,f2.getNumberOfComponents());
3306         self.assertEqual(5,f2.getNumberOfTuples());
3307         expected1=[13.638813677891717,-4.502313844635971,-2.2364998332557486]
3308         for i in xrange(5):
3309             self.assertAlmostEqual(expected1[0],f2.getIJ(i,0),13);
3310             self.assertAlmostEqual(expected1[1],f2.getIJ(i,1),13);
3311             self.assertAlmostEqual(expected1[2],f2.getIJ(i,2),13);
3312             pass
3313         pass
3314
3315     def testEigenVectors1(self):
3316         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3317         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3318         f1.setMesh(mesh1);
3319         array=DataArrayDouble.New();
3320         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]
3321         array.setValues(arr1,mesh1.getNumberOfCells(),6);
3322         f1.setArray(array);
3323         f1.checkCoherency();
3324         #
3325         f2=f1.eigenVectors();
3326         f2.checkCoherency();
3327         self.assertEqual(9,f2.getNumberOfComponents());
3328         self.assertEqual(5,f2.getNumberOfTuples());
3329         expected1=[0.5424262364180696, 0.5351201064614425, 0.6476266283176001,#eigenvect 0
3330                    0.7381111277307373, 0.06458838384003074, -0.6715804522117897,#eigenvect 1
3331                    -0.4012053603397987, 0.8423032781211455, -0.3599436712889738#eigenvect 2
3332                    ]
3333         for i in xrange(5):
3334             self.assertAlmostEqual(expected1[0],f2.getIJ(i,0),13);
3335             self.assertAlmostEqual(expected1[1],f2.getIJ(i,1),13);
3336             self.assertAlmostEqual(expected1[2],f2.getIJ(i,2),13);
3337             self.assertAlmostEqual(expected1[3],f2.getIJ(i,3),13);
3338             self.assertAlmostEqual(expected1[4],f2.getIJ(i,4),13);
3339             self.assertAlmostEqual(expected1[5],f2.getIJ(i,5),13);
3340             self.assertAlmostEqual(expected1[6],f2.getIJ(i,6),13);
3341             self.assertAlmostEqual(expected1[7],f2.getIJ(i,7),13);
3342             self.assertAlmostEqual(expected1[8],f2.getIJ(i,8),13);
3343             pass
3344         #
3345         pass
3346
3347     def testInverse1(self):
3348         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3349         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3350         f1.setMesh(mesh1);
3351         array=DataArrayDouble.New();
3352         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]
3353         array.setValues(arr1,mesh1.getNumberOfCells(),9);
3354         f1.setArray(array);
3355         f1.checkCoherency();
3356         #
3357         f2=f1.inverse();
3358         f2.checkCoherency();
3359         self.assertEqual(9,f2.getNumberOfComponents());
3360         self.assertEqual(5,f2.getNumberOfTuples());
3361         expected1=[-2.6538108356290113, 2.855831037649208, -1.1111111111111067, 3.461891643709813, -4.775022956841121, 2.2222222222222143, -1.1111111111111054, 2.222222222222214, -1.1111111111111072]
3362         for i in xrange(5):
3363             self.assertAlmostEqual(expected1[0],f2.getIJ(i,0),13);
3364             self.assertAlmostEqual(expected1[1],f2.getIJ(i,1),13);
3365             self.assertAlmostEqual(expected1[2],f2.getIJ(i,2),13);
3366             self.assertAlmostEqual(expected1[3],f2.getIJ(i,3),13);
3367             self.assertAlmostEqual(expected1[4],f2.getIJ(i,4),13);
3368             self.assertAlmostEqual(expected1[5],f2.getIJ(i,5),13);
3369             self.assertAlmostEqual(expected1[6],f2.getIJ(i,6),13);
3370             self.assertAlmostEqual(expected1[7],f2.getIJ(i,7),13);
3371             self.assertAlmostEqual(expected1[8],f2.getIJ(i,8),13);
3372             pass
3373         #
3374         array=DataArrayDouble.New();
3375         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]
3376         array.setValues(arr3,mesh1.getNumberOfCells(),6);
3377         f1.setArray(array);
3378         f1.checkCoherency();
3379         #
3380         f2=f1.inverse();
3381         f2.checkCoherency();
3382         self.assertEqual(6,f2.getNumberOfComponents());
3383         self.assertEqual(5,f2.getNumberOfTuples());
3384         expected3=[-0.3617705098531818, -0.8678630828458127, -0.026843764174972983, 0.5539957431465833, 0.13133439560823013, -0.05301294502145887]
3385         for i in xrange(5):
3386             self.assertAlmostEqual(expected3[0],f2.getIJ(i,0),13);
3387             self.assertAlmostEqual(expected3[1],f2.getIJ(i,1),13);
3388             self.assertAlmostEqual(expected3[2],f2.getIJ(i,2),13);
3389             self.assertAlmostEqual(expected3[3],f2.getIJ(i,3),13);
3390             self.assertAlmostEqual(expected3[4],f2.getIJ(i,4),13);
3391             self.assertAlmostEqual(expected3[5],f2.getIJ(i,5),13);
3392             pass
3393         #
3394         array=DataArrayDouble.New();
3395         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]
3396         array.setValues(arr2,mesh1.getNumberOfCells(),4);
3397         f1.setArray(array);
3398         f1.checkCoherency();
3399         #
3400         f2=f1.inverse();
3401         f2.checkCoherency();
3402         self.assertEqual(4,f2.getNumberOfComponents());
3403         self.assertEqual(5,f2.getNumberOfTuples());
3404         expected2=[-1.8595041322314059, 0.9504132231404963, 1.404958677685951, -0.49586776859504156]
3405         for i in xrange(5):
3406             self.assertAlmostEqual(expected2[0],f2.getIJ(i,0),13);
3407             self.assertAlmostEqual(expected2[1],f2.getIJ(i,1),13);
3408             self.assertAlmostEqual(expected2[2],f2.getIJ(i,2),13);
3409             self.assertAlmostEqual(expected2[3],f2.getIJ(i,3),13);
3410             pass
3411         #
3412         pass
3413
3414     def testTrace1(self):
3415         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3416         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3417         f1.setMesh(mesh1);
3418         array=DataArrayDouble.New();
3419         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]
3420         array.setValues(arr1,mesh1.getNumberOfCells(),9);
3421         f1.setArray(array);
3422         f1.checkCoherency();
3423         #
3424         f2=f1.trace();
3425         f2.checkCoherency();
3426         self.assertEqual(1,f2.getNumberOfComponents());
3427         self.assertEqual(5,f2.getNumberOfTuples());
3428         for i in xrange(5):
3429             self.assertAlmostEqual(15.9,f2.getIJ(i,0),13);
3430             pass
3431         #
3432         array=DataArrayDouble.New();
3433         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]
3434         array.setValues(arr3,mesh1.getNumberOfCells(),6);
3435         f1.setArray(array);
3436         f1.checkCoherency();
3437         #
3438         f2=f1.trace();
3439         f2.checkCoherency();
3440         self.assertEqual(1,f2.getNumberOfComponents());
3441         self.assertEqual(5,f2.getNumberOfTuples());
3442         for i in xrange(5):
3443             self.assertAlmostEqual(25.8,f2.getIJ(i,0),13);
3444             pass
3445         #
3446         array=DataArrayDouble.New();
3447         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]
3448         array.setValues(arr2,mesh1.getNumberOfCells(),4);
3449         f1.setArray(array);
3450         f1.checkCoherency();
3451         #
3452         f2=f1.trace();
3453         f2.checkCoherency();
3454         self.assertEqual(1,f2.getNumberOfComponents());
3455         self.assertEqual(5,f2.getNumberOfTuples());
3456         for i in xrange(5):
3457             self.assertAlmostEqual(5.7,f2.getIJ(i,0),13);
3458             pass
3459         #
3460         pass
3461
3462     def testDeviator1(self):
3463         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3464         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3465         f1.setMesh(mesh1);
3466         array=DataArrayDouble.New();
3467         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]
3468         array.setValues(arr1,mesh1.getNumberOfCells(),6);
3469         f1.setArray(array);
3470         f1.checkCoherency();
3471         #
3472         f2=f1.deviator();
3473         f2.checkCoherency();
3474         self.assertEqual(6,f2.getNumberOfComponents());
3475         self.assertEqual(5,f2.getNumberOfTuples());
3476         expected1=[-1.1,0.,1.1,4.5,5.6,6.7]
3477         for i in xrange(5):
3478             self.assertAlmostEqual(expected1[0],f2.getIJ(i,0),13);
3479             self.assertAlmostEqual(expected1[1],f2.getIJ(i,1),13);
3480             self.assertAlmostEqual(expected1[2],f2.getIJ(i,2),13);
3481             self.assertAlmostEqual(expected1[3],f2.getIJ(i,3),13);
3482             self.assertAlmostEqual(expected1[4],f2.getIJ(i,4),13);
3483             self.assertAlmostEqual(expected1[5],f2.getIJ(i,5),13);
3484             pass
3485         #
3486         pass
3487
3488     def testMagnitude1(self):
3489         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3490         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3491         f1.setMesh(mesh1);
3492         array=DataArrayDouble.New();
3493         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]
3494         array.setValues(arr1,mesh1.getNumberOfCells(),5);
3495         f1.setArray(array);
3496         f1.checkCoherency();
3497         #
3498         f2=f1.magnitude();
3499         f2.checkCoherency();
3500         self.assertEqual(1,f2.getNumberOfComponents());
3501         self.assertEqual(5,f2.getNumberOfTuples());
3502         for i in xrange(5):
3503             self.assertAlmostEqual(8.3606219864313918,f2.getIJ(i,0),13);
3504             pass
3505         #
3506         pass
3507
3508     def testMaxPerTuple1(self):
3509         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3510         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3511         f1.setMesh(mesh1);
3512         array=DataArrayDouble.New();
3513         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]
3514         array.setValues(arr1,mesh1.getNumberOfCells(),5);
3515         f1.setArray(array);
3516         f1.checkCoherency();
3517         #
3518         f2=f1.maxPerTuple();
3519         f2.checkCoherency();
3520         self.assertEqual(1,f2.getNumberOfComponents());
3521         self.assertEqual(5,f2.getNumberOfTuples());
3522         for i in xrange(5):
3523             self.assertAlmostEqual(5.6,f2.getIJ(i,0),13);
3524             pass
3525         #
3526         d2,d2I=array.maxPerTupleWithCompoId()
3527         self.assertEqual(1,d2.getNumberOfComponents());
3528         self.assertEqual(5,d2.getNumberOfTuples());
3529         for i in xrange(5):
3530             self.assertAlmostEqual(5.6,d2.getIJ(i,0),13);
3531             pass
3532         self.assertTrue(d2I.isEqual(DataArrayInt([4,3,2,0,1])))
3533         pass
3534
3535     def testChangeNbOfComponents(self):
3536         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3537         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3538         f1.setMesh(mesh1);
3539         array=DataArrayDouble.New();
3540         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]
3541         array.setValues(arr1,mesh1.getNumberOfCells(),5);
3542         f1.setArray(array);
3543         f1.checkCoherency();
3544         #
3545         f1.changeNbOfComponents(3,7.77);
3546         f1.checkCoherency();
3547         self.assertEqual(3,f1.getNumberOfComponents());
3548         self.assertEqual(5,f1.getNumberOfTuples());
3549         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]
3550         for i in xrange(15):
3551             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),13);
3552             pass
3553         f1.changeNbOfComponents(4,7.77);
3554         f1.checkCoherency();
3555         self.assertEqual(4,f1.getNumberOfComponents());
3556         self.assertEqual(5,f1.getNumberOfTuples());
3557         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]
3558         for i in xrange(20):
3559             self.assertAlmostEqual(expected2[i],f1.getIJ(0,i),13);
3560             pass
3561         #
3562         pass
3563
3564     def testSortPerTuple1(self):
3565         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3566         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3567         f1.setMesh(mesh1);
3568         array=DataArrayDouble.New();
3569         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]
3570         array.setValues(arr1,mesh1.getNumberOfCells(),5);
3571         f1.setArray(array);
3572         f1.checkCoherency();
3573         #
3574         f1.sortPerTuple(True);
3575         f1.checkCoherency();
3576         self.assertEqual(5,f1.getNumberOfComponents());
3577         self.assertEqual(5,f1.getNumberOfTuples());
3578         for i in xrange(5):
3579             self.assertAlmostEqual(arr1[0],f1.getIJ(i,0),13);
3580             self.assertAlmostEqual(arr1[1],f1.getIJ(i,1),13);
3581             self.assertAlmostEqual(arr1[2],f1.getIJ(i,2),13);
3582             self.assertAlmostEqual(arr1[3],f1.getIJ(i,3),13);
3583             self.assertAlmostEqual(arr1[4],f1.getIJ(i,4),13);
3584             pass
3585         #
3586         f1.sortPerTuple(False);
3587         f1.checkCoherency();
3588         self.assertEqual(5,f1.getNumberOfComponents());
3589         self.assertEqual(5,f1.getNumberOfTuples());
3590         for i in xrange(5):
3591             self.assertAlmostEqual(arr1[4],f1.getIJ(i,0),13);
3592             self.assertAlmostEqual(arr1[3],f1.getIJ(i,1),13);
3593             self.assertAlmostEqual(arr1[2],f1.getIJ(i,2),13);
3594             self.assertAlmostEqual(arr1[1],f1.getIJ(i,3),13);
3595             self.assertAlmostEqual(arr1[0],f1.getIJ(i,4),13);
3596             pass
3597         #
3598         pass
3599
3600     def testIsEqualWithoutConsideringStr1(self):
3601         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3602         mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
3603         #
3604         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3605         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3606         mesh2.setName("rr");
3607         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
3608         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3609         da1,da2=mesh1.checkGeoEquivalWith(mesh2,2,1e-12);
3610         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12);
3611         mesh2.setName("");
3612         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3613         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3614         mesh2.getCoords().setInfoOnComponent(0,"tty");
3615         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
3616         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3617         mesh2.getCoords().setInfoOnComponent(0,"");
3618         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3619         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3620         mesh2.getCoords().setInfoOnComponent(1,"tty");
3621         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
3622         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3623         mesh2.getCoords().setInfoOnComponent(1,"");
3624         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3625         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3626         tmp=mesh2.getCoords().getIJ(0,3);
3627         mesh2.getCoords().setIJ(0,3,9999.);
3628         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
3629         self.assertTrue(not mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3630         mesh2.getCoords().setIJ(0,3,tmp);
3631         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3632         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3633         tmp2=mesh2.getNodalConnectivity().getIJ(0,4);
3634         mesh2.getNodalConnectivity().setIJ(0,4,0);
3635         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
3636         self.assertTrue(not mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3637         mesh2.getNodalConnectivity().setIJ(0,4,tmp2);
3638         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3639         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3640         #
3641         f1=mesh1.getMeasureField(True);
3642         f2=mesh2.getMeasureField(True);
3643         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
3644         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3645         f2.setName("ftest");
3646         self.assertTrue(not f1.isEqual(f2,1e-12,1e-12));
3647         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3648         f1.setName("ftest");
3649         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
3650         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3651         #
3652         f2.getArray().setInfoOnComponent(0,"eee");
3653         self.assertTrue(not f1.isEqual(f2,1e-12,1e-12));
3654         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3655         f2.getArray().setInfoOnComponent(0,"");
3656         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
3657         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3658         #
3659         f2.getArray().setIJ(1,0,0.123);
3660         self.assertTrue(not f1.isEqual(f2,1e-12,1e-12));
3661         self.assertTrue(not f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3662         f2.getArray().setIJ(1,0,0.125);
3663         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
3664         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3665         #
3666         pass
3667
3668     def testGetNodeIdsOfCell1(self):
3669         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3670         li=mesh1.getNodeIdsOfCell(1)
3671         expected1=[1, 4, 2]
3672         self.assertEqual(expected1,list(li))
3673         li=mesh1.getCoordinatesOfNode(4)
3674         self.assertEqual(2,len(li))
3675         self.assertAlmostEqual(0.2,li[0],13);
3676         self.assertAlmostEqual(0.2,li[1],13);
3677         li=mesh1.getCoords().getValuesAsTuple()
3678         self.assertEqual(9,len(li))
3679         li2=mesh1.getNodalConnectivityIndex().getValuesAsTuple()
3680         self.assertEqual(6,len(li2))
3681         pass
3682
3683     def testGetEdgeRatioField1(self):
3684         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
3685         m1.setTime(3.4,5,6); m1.setTimeUnit("us");
3686         f1=m1.getEdgeRatioField();
3687         self.assertAlmostEqual(3.4,f1.getTime()[0],12) ; self.assertEqual(5,f1.getTime()[1]) ; self.assertEqual(6,f1.getTime()[2])
3688         self.assertEqual("us",f1.getTimeUnit())
3689         self.assertEqual(m1.getNumberOfCells(),f1.getNumberOfTuples());
3690         self.assertEqual(5,f1.getNumberOfTuples());
3691         self.assertEqual(1,f1.getNumberOfComponents());
3692         expected1=[1.,1.4142135623730951, 1.4142135623730951,1.,1.]
3693         for i in xrange(5):
3694             self.assertAlmostEqual(expected1[i],f1.getIJ(i,0),14);
3695             pass
3696         #
3697         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
3698         f1=m1.getEdgeRatioField();
3699         self.assertEqual(m1.getNumberOfCells(),f1.getNumberOfTuples());
3700         self.assertEqual(5,f1.getNumberOfTuples());
3701         self.assertEqual(1,f1.getNumberOfComponents());
3702         expected2=[1.4142135623730951, 1.7320508075688772, 1.7320508075688772, 1.4142135623730951, 1.4142135623730951]
3703         for i in xrange(5):
3704             self.assertAlmostEqual(expected2[i],f1.getIJ(i,0),14);
3705             pass
3706         pass
3707
3708     def testFillFromAnalytic3(self):
3709         m=MEDCouplingDataForTest.build2DTargetMesh_1()
3710         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME)
3711         self.assertRaises(InterpKernelException,f1.fillFromAnalytic,1,"y+x");
3712         f1.setMesh(m)
3713         f1.setName("myField");
3714         f1.fillFromAnalytic(1,"y+x");
3715         f1.checkCoherency();
3716         self.assertEqual(f1.getName(),"myField");
3717         self.assertEqual(f1.getTypeOfField(),ON_CELLS);
3718         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
3719         self.assertEqual(1,f1.getNumberOfComponents());
3720         self.assertEqual(5,f1.getNumberOfTuples());
3721         values1=[-0.1,0.23333333333333336,0.56666666666666665,0.4,0.9]
3722         tmp=f1.getArray().getValues();
3723         self.assertEqual(len(values1),len(tmp))
3724         for i in xrange(len(values1)):
3725             self.assertTrue(abs(values1[i]-tmp[i])<1.e-12);
3726             pass
3727         #
3728         f1=MEDCouplingFieldDouble.New(ON_NODES,CONST_ON_TIME_INTERVAL)
3729         f1.setMesh(m)
3730         f1.fillFromAnalytic(1,"y+2*x");
3731         f1.setEndTime(1.2,3,4);
3732         f1.checkCoherency();
3733         self.assertEqual(f1.getTypeOfField(),ON_NODES);
3734         self.assertEqual(f1.getTimeDiscretization(),CONST_ON_TIME_INTERVAL);
3735         self.assertEqual(1,f1.getNumberOfComponents());
3736         self.assertEqual(9,f1.getNumberOfTuples());
3737         values2=[-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1]
3738         tmp=f1.getArray().getValues();
3739         self.assertEqual(len(values2),len(tmp))
3740         for i in xrange(len(values2)):
3741             self.assertTrue(abs(values2[i]-tmp[i])<1.e-12);
3742             pass
3743         f1=MEDCouplingFieldDouble.New(ON_NODES,LINEAR_TIME);
3744         f1.setMesh(m)
3745         f1.fillFromAnalytic(1,"2.*x+y");
3746         f1.setEndTime(1.2,3,4);
3747         f1.checkCoherency();
3748         self.assertEqual(f1.getTypeOfField(),ON_NODES);
3749         self.assertEqual(f1.getTimeDiscretization(),LINEAR_TIME);
3750         self.assertEqual(1,f1.getNumberOfComponents());
3751         self.assertEqual(9,f1.getNumberOfTuples());
3752         tmp=f1.getArray().getValues();
3753         values2Bis=[-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1]
3754         self.assertEqual(len(values2Bis),len(tmp))
3755         for i in xrange(len(values2Bis)):
3756             self.assertTrue(abs(values2Bis[i]-tmp[i])<1.e-12);
3757             pass
3758         tmp=f1.getEndArray().getValues();
3759         self.assertEqual(len(values2Bis),len(tmp))
3760         for i in xrange(len(values2Bis)):
3761             self.assertTrue(abs(values2Bis[i]-tmp[i])<1.e-12);
3762             pass
3763         #
3764         f1=MEDCouplingFieldDouble.New(ON_NODES,ONE_TIME);
3765         f1.setMesh(m)
3766         f1.fillFromAnalytic(2,"(x+y)*IVec+2*(x+y)*JVec");
3767         f1.checkCoherency();
3768         self.assertEqual(f1.getTypeOfField(),ON_NODES);
3769         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
3770         self.assertEqual(2,f1.getNumberOfComponents());
3771         self.assertEqual(9,f1.getNumberOfTuples());
3772         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]
3773         tmp=f1.getArray().getValues();
3774         self.assertEqual(len(values3),len(tmp))
3775         for i in xrange(len(values3)):
3776             self.assertTrue(abs(values3[i]-tmp[i])<1.e-12);
3777             pass
3778         values4=f1.accumulate();
3779         self.assertTrue(abs(3.6-values4[0])<1.e-12);
3780         self.assertTrue(abs(7.2-values4[1])<1.e-12);
3781         values4=f1.integral(True);
3782         self.assertTrue(abs(0.5-values4[0])<1.e-12);
3783         self.assertTrue(abs(1.-values4[1])<1.e-12);
3784         #
3785         f1=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
3786         f1.setMesh(m);
3787         self.assertRaises(InterpKernelException,f1.fillFromAnalytic,1,"1./(x-0.2)");
3788         pass
3789
3790     def testFieldDoubleOpEqual1(self):
3791         m=MEDCouplingDataForTest.build2DTargetMesh_1();
3792         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3793         self.assertRaises(InterpKernelException,f1.assign,0.07);
3794         f1.setMesh(m);
3795         f1.assign(0.07);
3796         f1.checkCoherency();
3797         self.assertEqual(1,f1.getNumberOfComponents());
3798         self.assertEqual(5,f1.getNumberOfTuples());
3799         for i in xrange(5):
3800             self.assertAlmostEqual(0.07,f1.getIJ(i,0),16);
3801             pass
3802         f1.assign(0.09);
3803         f1.checkCoherency();
3804         self.assertEqual(1,f1.getNumberOfComponents());
3805         self.assertEqual(5,f1.getNumberOfTuples());
3806         for i in xrange(5):
3807             self.assertAlmostEqual(0.09,f1.getIJ(i,0),16);
3808             pass
3809         #
3810         f1=MEDCouplingFieldDouble.New(ON_NODES,LINEAR_TIME);
3811         f1.setEndTime(4.5,2,3);
3812         f1.setMesh(m);
3813         f1.assign(0.08);
3814         f1.checkCoherency();
3815         self.assertEqual(1,f1.getNumberOfComponents());
3816         self.assertEqual(9,f1.getNumberOfTuples());
3817         for i in xrange(9):
3818             self.assertAlmostEqual(0.08,f1.getIJ(i,0),16);
3819             pass
3820         self.assertEqual(1,f1.getEndArray().getNumberOfComponents());
3821         self.assertEqual(9,f1.getEndArray().getNumberOfTuples());
3822         for i in xrange(9):
3823             self.assertAlmostEqual(0.08,f1.getEndArray().getIJ(i,0),16);
3824             pass
3825         pass
3826
3827     def testAreaBary3D2(self):
3828         coordsForHexa8=[-75.45749305371, 180.95495078401, 39.515472018008,
3829                         -9.755591679144, 23.394927935279, 5.108794294848,
3830                         14.337630157832, 61.705351002702, 160.42422501908,
3831                         -27.273893776752, 167.567731083961, 192.830034145464,
3832                         99.857193154796,264.499264735586,-8.287335493412,
3833                         144.939882761126,156.38626563134,-31.896173894226,
3834                         161.34096835726,182.4654895809,73.832387065572,
3835                         132.680430393685,255.37973247196,96.15235602819];
3836         volHexa8=3258520.29637466;
3837         baryHexa8=[43.925705821778, 155.31893955289, 65.874418109644]
3838
3839         coordsForPenta6=[-68.199829618726,178.938498373416,62.608505919588,
3840                          8.461744647847,76.653979804423,165.00018874933,
3841                          -27.273893776752,167.567731083961,192.830034145464,
3842                          106.586501038965,262.629609408327,13.124533008813,
3843                          155.465082847275,197.414118382622,78.408350795821,
3844                          132.680430393685,255.37973247196,96.15235602819];
3845         volPenta6=944849.868507338;
3846         baryPenta6=[39.631002313543,182.692711783428,106.98540473964]
3847
3848         coordsForPyra5=[132.680430393685,255.37973247196,96.15235602819,
3849                         -27.273893776752,167.567731083961,192.830034145464,
3850                         8.461744647847,76.653979804423,165.00018874933,
3851                         155.465082847275,197.414118382622,78.408350795821,
3852                         -68.199829618726,178.938498373416,62.608505919588];
3853         volPyra5=756943.92980254;
3854         baryPyra5=[29.204294116618,172.540129749156,118.01035951483]
3855         mesh=MEDCouplingUMesh.New("Bary3D2",3);
3856         coo=DataArrayDouble.New();
3857         tmp=coordsForHexa8+coordsForPenta6+coordsForPyra5
3858         coo.setValues(tmp,19,3);
3859         mesh.setCoords(coo);
3860         #
3861         tmpConn=[0,1,2,3,4,5,6,7]
3862         mesh.allocateCells(3);
3863         self.assertRaises(InterpKernelException,mesh.insertNextCell,NORM_HEXA8,9,tmpConn[0:8])
3864         mesh.insertNextCell(NORM_HEXA8,tmpConn[0:8])
3865         mesh.insertNextCell(NORM_PENTA6,6,[i+8 for i in tmpConn])
3866         mesh.insertNextCell(NORM_PYRA5,5,[i+14 for i in tmpConn])
3867         mesh.finishInsertingCells();
3868         mesh.checkCoherency();
3869         mesh.mergeNodes(1e-7)
3870         self.assertEqual(12,mesh.getNumberOfNodes());
3871         vols=mesh.getMeasureField(True);
3872         self.assertEqual(3,vols.getNumberOfTuples());
3873         self.assertEqual(1,vols.getNumberOfComponents());
3874         self.assertAlmostEqual(volHexa8,vols.getIJ(0,0),6);
3875         self.assertAlmostEqual(volPenta6,vols.getIJ(1,0),7);
3876         self.assertAlmostEqual(volPyra5,vols.getIJ(2,0),7);
3877         bary=mesh.getBarycenterAndOwner();
3878         self.assertEqual(3,bary.getNumberOfTuples());
3879         self.assertEqual(3,bary.getNumberOfComponents());
3880         self.assertAlmostEqual(baryHexa8[0],bary.getIJ(0,0),11);
3881         self.assertAlmostEqual(baryHexa8[1],bary.getIJ(0,1),11);
3882         self.assertAlmostEqual(baryHexa8[2],bary.getIJ(0,2),11);
3883         self.assertAlmostEqual(baryPenta6[0],bary.getIJ(1,0),11);
3884         self.assertAlmostEqual(baryPenta6[1],bary.getIJ(1,1),11);
3885         self.assertAlmostEqual(baryPenta6[2],bary.getIJ(1,2),11);
3886         self.assertAlmostEqual(baryPyra5[0],bary.getIJ(2,0),11);
3887         self.assertAlmostEqual(baryPyra5[1],bary.getIJ(2,1),11);
3888         self.assertAlmostEqual(baryPyra5[2],bary.getIJ(2,2),11);
3889         pass
3890
3891     def testGetMeasureFieldCMesh1(self):
3892         m=MEDCouplingCMesh.New();
3893         da=DataArrayDouble.New();
3894         discX=[2.3,3.4,5.8,10.2]
3895         discY=[12.3,23.4,45.8]
3896         discZ=[-0.7,1.2,1.25,2.13,2.67]
3897         da.setValues(discX,4,1);
3898         m.setCoordsAt(0,da);
3899         m.checkCoherency();
3900         self.assertEqual(4,m.getNumberOfNodes());
3901         self.assertEqual(3,m.getNumberOfCells());
3902         self.assertEqual(1,m.getSpaceDimension());
3903         f=m.getMeasureField(True);
3904         self.assertEqual(3,f.getNumberOfTuples());
3905         self.assertEqual(1,f.getNumberOfComponents());
3906         expected1=[1.1,2.4,4.4]
3907         for i in xrange(3):
3908             self.assertAlmostEqual(expected1[i],f.getIJ(i,0),12);
3909             pass
3910         coords=m.getCoordinatesAndOwner();
3911         self.assertEqual(4,coords.getNumberOfTuples());
3912         self.assertEqual(1,coords.getNumberOfComponents());
3913         for i in xrange(4):
3914             self.assertAlmostEqual(discX[i],coords.getIJ(i,0),12);
3915             pass
3916         coords=m.getBarycenterAndOwner();
3917         self.assertEqual(3,coords.getNumberOfTuples());
3918         self.assertEqual(1,coords.getNumberOfComponents());
3919         expected1_3=[2.85,4.6,8.]
3920         for i in xrange(3):
3921             self.assertAlmostEqual(expected1_3[i],coords.getIJ(i,0),12);
3922             pass
3923         #
3924         da=DataArrayDouble.New();
3925         da.setValues(discY,3,1);
3926         m.setCoordsAt(1,da);
3927         m.checkCoherency();
3928         self.assertEqual(12,m.getNumberOfNodes());
3929         self.assertEqual(6,m.getNumberOfCells());
3930         self.assertEqual(2,m.getSpaceDimension());
3931         f=m.getMeasureField(True);
3932         self.assertEqual(6,f.getNumberOfTuples());
3933         self.assertEqual(1,f.getNumberOfComponents());
3934         expected2=[12.21,26.64,48.84,24.64,53.76,98.56]
3935         for i in xrange(6):
3936             self.assertAlmostEqual(expected2[i],f.getIJ(i,0),12);
3937             pass
3938         coords=m.getCoordinatesAndOwner();
3939         self.assertEqual(12,coords.getNumberOfTuples());
3940         self.assertEqual(2,coords.getNumberOfComponents());
3941         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]
3942         for i in xrange(24):
3943             self.assertAlmostEqual(expected2_2[i],coords.getIJ(0,i),12);
3944             pass
3945         coords=m.getBarycenterAndOwner();
3946         self.assertEqual(6,coords.getNumberOfTuples());
3947         self.assertEqual(2,coords.getNumberOfComponents());
3948         expected2_3=[2.85,17.85,4.6,17.85,8.,17.85, 2.85,34.6,4.6,34.6,8.,34.6]
3949         for i in xrange(12):
3950             self.assertAlmostEqual(expected2_3[i],coords.getIJ(0,i),12);
3951             pass
3952         #
3953         da=DataArrayDouble.New();
3954         da.setValues(discZ,5,1);
3955         m.setCoordsAt(2,da);
3956         m.checkCoherency();
3957         self.assertEqual(60,m.getNumberOfNodes());
3958         self.assertEqual(24,m.getNumberOfCells());
3959         self.assertEqual(3,m.getSpaceDimension());
3960         f=m.getMeasureField(True);
3961         self.assertEqual(24,f.getNumberOfTuples());
3962         self.assertEqual(1,f.getNumberOfComponents());
3963         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]
3964         for i in xrange(24):
3965             self.assertAlmostEqual(expected3[i],f.getIJ(i,0),12);
3966             pass
3967         coords=m.getCoordinatesAndOwner();
3968         self.assertEqual(60,coords.getNumberOfTuples());
3969         self.assertEqual(3,coords.getNumberOfComponents());
3970         expected3_2=[
3971             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,
3972             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,
3973             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,
3974             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,
3975             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];
3976         for i in xrange(180):
3977             self.assertAlmostEqual(expected3_2[i],coords.getIJ(0,i),12);
3978             pass
3979         coords=m.getBarycenterAndOwner();
3980         self.assertEqual(24,coords.getNumberOfTuples());
3981         self.assertEqual(3,coords.getNumberOfComponents());
3982         expected3_3=[
3983             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,
3984             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,
3985             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,
3986             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];
3987         for i in xrange(72):
3988             self.assertAlmostEqual(expected3_3[i],coords.getIJ(0,i),12);
3989             pass
3990         pass
3991
3992     def testFieldDoubleZipCoords1(self):
3993         m=MEDCouplingDataForTest.build2DTargetMeshMergeNode_1();
3994         f=m.fillFromAnalytic(ON_NODES,2,"x*2.");
3995         f.getArray().setInfoOnComponent(0,"titi");
3996         f.getArray().setInfoOnComponent(1,"tutu");
3997         f.checkCoherency();
3998         self.assertEqual(18,f.getNumberOfTuples());
3999         self.assertEqual(2,f.getNumberOfComponents());
4000         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]
4001         for i in xrange(36):
4002             self.assertAlmostEqual(expected1[i],f.getIJ(0,i),12);
4003             pass
4004         self.assertTrue(f.zipCoords());
4005         f.checkCoherency();
4006         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]
4007         for i in xrange(30):
4008             self.assertAlmostEqual(expected2[i],f.getIJ(0,i),12);
4009             pass
4010         self.assertTrue(not f.zipCoords());
4011         f.checkCoherency();
4012         for i in xrange(30):
4013             self.assertAlmostEqual(expected2[i],f.getIJ(0,i),12);
4014             pass
4015         self.assertTrue(f.getArray().getInfoOnComponent(0)=="titi");
4016         self.assertTrue(f.getArray().getInfoOnComponent(1)=="tutu");
4017         pass
4018
4019     def testFieldDoubleZipConnectivity1(self):
4020         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
4021         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
4022         cells1=[2,3,4]
4023         m3_1=m2.buildPartOfMySelf(cells1,True);
4024         m3=m3_1;
4025         m4=MEDCouplingDataForTest.build2DSourceMesh_1();
4026         m5=MEDCouplingUMesh.MergeUMeshes(m1,m3);
4027         m6=MEDCouplingUMesh.MergeUMeshes(m5,m4);
4028         #
4029         self.assertEqual(10,m6.getNumberOfCells());
4030         self.assertEqual(22,m6.getNumberOfNodes());
4031         arr,areNodesMerged,newNbOfNodes=m6.mergeNodes(1e-13);
4032         self.assertEqual(9,m6.getNumberOfNodes());
4033         f=m6.fillFromAnalytic(ON_CELLS,2,"x");
4034         f2=m6.fillFromAnalytic(ON_NODES,2,"x");
4035         self.assertEqual(10,f.getNumberOfTuples());
4036         self.assertEqual(2,f.getNumberOfComponents());
4037         expected1=[-0.05, -0.05, 0.3666666666666667, 0.3666666666666667, 0.53333333333333321, 0.53333333333333321,
4038                    -0.05, -0.05, 0.45, 0.45, 0.53333333333333321, 0.53333333333333321, -0.05, -0.05, 0.45, 0.45,
4039                    0.36666666666666659, 0.36666666666666659, 0.033333333333333326, 0.033333333333333326];
4040         for i in xrange(20):
4041             self.assertAlmostEqual(expected1[i],f.getIJ(0,i),12);
4042             pass
4043         f.getArray().setInfoOnComponent(0,"titi");
4044         f.getArray().setInfoOnComponent(1,"tutu");
4045         f.checkCoherency();
4046         self.assertTrue(f.zipConnectivity(0));
4047         expected2=[-0.05, -0.05, 0.3666666666666667, 0.3666666666666667, 0.53333333333333321, 0.53333333333333321,
4048                    -0.05, -0.05, 0.45, 0.45, 0.36666666666666659, 0.36666666666666659, 0.033333333333333326, 0.033333333333333326];
4049         self.assertEqual(7,f.getNumberOfTuples());
4050         self.assertEqual(2,f.getNumberOfComponents());
4051         for i in xrange(14):
4052             self.assertAlmostEqual(expected2[i],f.getIJ(0,i),12);
4053             pass
4054         self.assertTrue(f.getArray().getInfoOnComponent(0)=="titi");
4055         self.assertTrue(f.getArray().getInfoOnComponent(1)=="tutu");
4056         self.assertTrue(not f.zipConnectivity(0));
4057         #
4058         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,
4059                    -0.3, -0.3, 0.2, 0.2, 0.7, 0.7];
4060         self.assertEqual(9,f2.getNumberOfTuples());
4061         self.assertEqual(2,f2.getNumberOfComponents());
4062         for i in xrange(18):
4063             self.assertAlmostEqual(expected3[i],f2.getIJ(0,i),12);
4064             pass
4065         self.assertTrue(f2.zipConnectivity(0));
4066         self.assertEqual(9,f2.getNumberOfTuples());
4067         self.assertEqual(2,f2.getNumberOfComponents());
4068         for i in xrange(18):
4069             self.assertAlmostEqual(expected3[i],f2.getIJ(0,i),12);
4070             pass
4071         pass
4072
4073     def testDaDoubleRenumber1(self):
4074         a=DataArrayDouble.New();
4075         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]
4076         a.setValues(arr1,7,2);
4077         a.setInfoOnComponent(0,"toto");
4078         a.setInfoOnComponent(1,"tata");
4079         #
4080         arr2=[3,1,0,6,5,4,2]
4081         b=a.renumber(arr2);
4082         self.assertEqual(7,b.getNumberOfTuples());
4083         self.assertEqual(2,b.getNumberOfComponents());
4084         self.assertTrue(b.getInfoOnComponent(0)=="toto");
4085         self.assertTrue(b.getInfoOnComponent(1)=="tata");
4086         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]
4087         for i in xrange(14):
4088             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
4089             pass
4090         #
4091         c=DataArrayInt.New();
4092         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4093         c.setValues(arr3,7,2);
4094         c.setInfoOnComponent(0,"toto");
4095         c.setInfoOnComponent(1,"tata");
4096         d=c.renumber(arr2);
4097         self.assertEqual(7,d.getNumberOfTuples());
4098         self.assertEqual(2,d.getNumberOfComponents());
4099         self.assertTrue(d.getInfoOnComponent(0)=="toto");
4100         self.assertTrue(d.getInfoOnComponent(1)=="tata");
4101         expected2=[3, 13, 2, 12, 7, 17, 1, 11, 6, 16, 5, 15, 4, 14]
4102         for i in xrange(14):
4103             self.assertEqual(expected2[i],d.getIJ(0,i));
4104             pass
4105         pass
4106
4107     def testDaDoubleRenumberAndReduce1(self):
4108         a=DataArrayDouble.New();
4109         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]
4110         a.setValues(arr1,7,2);
4111         a.setInfoOnComponent(0,"toto");
4112         a.setInfoOnComponent(1,"tata");
4113         #
4114         arr2=[2,-1,1,-1,0,4,3]
4115         b=a.renumberAndReduce(arr2,5);
4116         self.assertEqual(5,b.getNumberOfTuples());
4117         self.assertEqual(2,b.getNumberOfComponents());
4118         self.assertTrue(b.getInfoOnComponent(0)=="toto");
4119         self.assertTrue(b.getInfoOnComponent(1)=="tata");
4120         expected1=[5.1,15.1,3.1,13.1,1.1,11.1,7.1,17.1,6.1,16.1]
4121         for i in xrange(10):
4122             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
4123             pass
4124         #
4125         c=DataArrayInt.New();
4126         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4127         c.setValues(arr3,7,2);
4128         c.setInfoOnComponent(0,"toto");
4129         c.setInfoOnComponent(1,"tata");
4130         d=c.renumberAndReduce(arr2,5);
4131         self.assertEqual(5,d.getNumberOfTuples());
4132         self.assertEqual(2,d.getNumberOfComponents());
4133         self.assertTrue(d.getInfoOnComponent(0)=="toto");
4134         self.assertTrue(d.getInfoOnComponent(1)=="tata");
4135         expected2=[5,15,3,13,1,11,7,17,6,16]
4136         for i in xrange(10):
4137             self.assertEqual(expected2[i],d.getIJ(0,i));
4138             pass
4139         pass
4140
4141     def testDaDoubleRenumberInPlace1(self):
4142         a=DataArrayDouble.New();
4143         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]
4144         a.setValues(arr1,7,2);
4145         #
4146         arr2=[3,1,0,6,5,4,2]
4147         a.renumberInPlace(arr2);
4148         self.assertEqual(7,a.getNumberOfTuples());
4149         self.assertEqual(2,a.getNumberOfComponents());
4150         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]
4151         for i in xrange(14):
4152             self.assertAlmostEqual(expected1[i],a.getIJ(0,i),14);
4153             pass
4154         #
4155         c=DataArrayInt.New();
4156         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4157         c.setValues(arr3,7,2);
4158         c.renumberInPlace(arr2);
4159         self.assertEqual(7,c.getNumberOfTuples());
4160         self.assertEqual(2,c.getNumberOfComponents());
4161         expected2=[3, 13, 2, 12, 7, 17, 1, 11, 6, 16, 5, 15, 4, 14]
4162         for i in xrange(14):
4163             self.assertEqual(expected2[i],c.getIJ(0,i));
4164             pass
4165         pass
4166
4167     def testDaDoubleRenumberR1(self):
4168         a=DataArrayDouble.New();
4169         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]
4170         a.setValues(arr1,7,2);
4171         a.setInfoOnComponent(0,"toto");
4172         a.setInfoOnComponent(1,"tata");
4173         #
4174         arr2=[3,1,0,6,5,4,2]
4175         b=a.renumberR(arr2);
4176         self.assertEqual(7,b.getNumberOfTuples());
4177         self.assertEqual(2,b.getNumberOfComponents());
4178         self.assertTrue(b.getInfoOnComponent(0)=="toto");
4179         self.assertTrue(b.getInfoOnComponent(1)=="tata");
4180         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]
4181         for i in xrange(14):
4182             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
4183             pass
4184         #
4185         c=DataArrayInt.New();
4186         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4187         c.setValues(arr3,7,2);
4188         c.setInfoOnComponent(0,"toto");
4189         c.setInfoOnComponent(1,"tata");
4190         d=c.renumberR(arr2);
4191         self.assertEqual(7,d.getNumberOfTuples());
4192         self.assertEqual(2,d.getNumberOfComponents());
4193         self.assertTrue(d.getInfoOnComponent(0)=="toto");
4194         self.assertTrue(d.getInfoOnComponent(1)=="tata");
4195         expected2=[4, 14, 2, 12, 1, 11, 7, 17, 6, 16, 5, 15, 3, 13]
4196         for i in xrange(14):
4197             self.assertEqual(expected2[i],d.getIJ(0,i));
4198             pass
4199         pass
4200
4201     def testDaDoubleRenumberInPlaceR1(self):
4202         a=DataArrayDouble.New();
4203         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]
4204         a.setValues(arr1,7,2);
4205         #
4206         arr2=[3,1,0,6,5,4,2]
4207         a.renumberInPlaceR(arr2);
4208         self.assertEqual(7,a.getNumberOfTuples());
4209         self.assertEqual(2,a.getNumberOfComponents());
4210         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]
4211         for i in xrange(14):
4212             self.assertAlmostEqual(expected1[i],a.getIJ(0,i),14);
4213             pass
4214         #
4215         c=DataArrayInt.New();
4216         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4217         c.setValues(arr3,7,2);
4218         c.renumberInPlaceR(arr2);
4219         self.assertEqual(7,c.getNumberOfTuples());
4220         self.assertEqual(2,c.getNumberOfComponents());
4221         expected2=[4, 14, 2, 12, 1, 11, 7, 17, 6, 16, 5, 15, 3, 13]
4222         for i in xrange(14):
4223             self.assertEqual(expected2[i],c.getIJ(0,i));
4224             pass
4225         pass
4226
4227     def testDaDoubleSelectByTupleId1(self):
4228         a=DataArrayDouble.New();
4229         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]
4230         a.setValues(arr1,7,2);
4231         a.setInfoOnComponent(0,"toto");
4232         a.setInfoOnComponent(1,"tata");
4233         #
4234         arr2=[4,2,0,6,5]
4235         b=a.selectByTupleId(arr2);
4236         self.assertEqual(5,b.getNumberOfTuples());
4237         self.assertEqual(2,b.getNumberOfComponents());
4238         self.assertTrue(b.getInfoOnComponent(0)=="toto");
4239         self.assertTrue(b.getInfoOnComponent(1)=="tata");
4240         expected1=[5.1,15.1,3.1,13.1,1.1,11.1,7.1,17.1,6.1,16.1]
4241         for i in xrange(10):
4242             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
4243             pass
4244         #
4245         c=DataArrayInt.New();
4246         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4247         c.setValues(arr3,7,2);
4248         c.setInfoOnComponent(0,"toto");
4249         c.setInfoOnComponent(1,"tata");
4250         d=c.selectByTupleId(arr2);
4251         self.assertEqual(5,d.getNumberOfTuples());
4252         self.assertEqual(2,d.getNumberOfComponents());
4253         self.assertTrue(d.getInfoOnComponent(0)=="toto");
4254         self.assertTrue(d.getInfoOnComponent(1)=="tata");
4255         expected2=[5,15,3,13,1,11,7,17,6,16]
4256         for i in xrange(10):
4257             self.assertEqual(expected2[i],d.getIJ(0,i));
4258             pass
4259         pass
4260
4261     def testDaDoubleGetMinMaxValues1(self):
4262         a=DataArrayDouble.New();
4263         arr1=[2.34,4.56,-6.77,4.55,4.56,2.24,2.34,1.02,4.56]
4264         a.setValues(arr1,9,1);
4265         m,where=a.getMaxValue();
4266         self.assertEqual(1,where);
4267         self.assertAlmostEqual(4.56,m,12);
4268         m,ws=a.getMaxValue2();
4269         self.assertAlmostEqual(4.56,m,12);
4270         self.assertEqual(3,ws.getNumberOfTuples());
4271         self.assertEqual(1,ws.getNumberOfComponents());
4272         expected1=[1,4,8]
4273         for i in xrange(3):
4274             self.assertEqual(expected1[i],ws.getIJ(i,0));
4275             pass
4276         a=DataArrayDouble.New();
4277         arr2=[-2.34,-4.56,6.77,-4.55,-4.56,-2.24,-2.34,-1.02,-4.56]
4278         a.setValues(arr2,9,1);
4279         m,where=a.getMinValue();
4280         self.assertEqual(1,where);
4281         self.assertAlmostEqual(-4.56,m,12);
4282         m,ws=a.getMinValue2();
4283         self.assertAlmostEqual(-4.56,m,12);
4284         self.assertEqual(3,ws.getNumberOfTuples());
4285         self.assertEqual(1,ws.getNumberOfComponents());
4286         for i in xrange(3):
4287             self.assertEqual(expected1[i],ws.getIJ(i,0));
4288             pass
4289         pass
4290
4291     def testFieldDoubleGetMinMaxValues2(self):
4292         m2,m1=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
4293         self.assertEqual(18,m2.getNumberOfCells());
4294         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]
4295         f=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
4296         a=DataArrayDouble.New();
4297         a.setValues(arr1,18,1);
4298         f.setArray(a);
4299         f.setMesh(m2);
4300         #
4301         f.checkCoherency();
4302         m=f.getMaxValue();
4303         self.assertAlmostEqual(8.71,m,12);
4304         m,ws=f.getMaxValue2();
4305         self.assertAlmostEqual(8.71,m,12);
4306         self.assertEqual(4,ws.getNumberOfTuples());
4307         self.assertEqual(1,ws.getNumberOfComponents());
4308         expected1=[0,3,7,17]
4309         for i in xrange(4):
4310             self.assertEqual(expected1[i],ws.getIJ(i,0));
4311             pass
4312         #
4313         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]
4314         a.setValues(arr2,18,1);
4315         f.checkCoherency();
4316         m=f.getMinValue();
4317         self.assertAlmostEqual(-8.71,m,12);
4318         m,ws=f.getMinValue2();
4319         self.assertAlmostEqual(-8.71,m,12);
4320         self.assertEqual(4,ws.getNumberOfTuples());
4321         self.assertEqual(1,ws.getNumberOfComponents());
4322         for i in xrange(4):
4323             self.assertEqual(expected1[i],ws.getIJ(i,0));
4324             pass
4325         pass
4326
4327     def testBuildUnstructuredCMesh1(self):
4328         m=MEDCouplingCMesh.New();
4329         da=DataArrayDouble.New();
4330         discX=[2.3,3.4,5.8,10.2]
4331         discY=[12.3,23.4,45.8]
4332         discZ=[-0.7,1.2,1.25,2.13,2.67]
4333         da.setValues(discX,4,1);
4334         m.setCoordsAt(0,da);
4335         m.checkCoherency();
4336         self.assertEqual(0,m.getCellContainingPoint([2.4],1e-12));
4337         self.assertEqual(1,m.getCellContainingPoint([3.7],1e-12));
4338         self.assertEqual(2,m.getCellContainingPoint([5.9],1e-12));
4339         self.assertEqual(-1,m.getCellContainingPoint([10.3],1e-12));
4340         self.assertEqual(-1,m.getCellContainingPoint([1.3],1e-12));
4341         #
4342         m2=m.buildUnstructured();
4343         m2.checkCoherency();
4344         f1=m.getMeasureField(False);
4345         f2=m2.getMeasureField(False);
4346         self.assertTrue(isinstance(f1.getMesh(),MEDCouplingCMesh))
4347         self.assertEqual(f1.getNumberOfTuples(),3);
4348         self.assertEqual(f2.getNumberOfTuples(),3);
4349         self.assertEqual(1,m2.getMeshDimension());
4350         self.assertEqual(1,m2.getSpaceDimension());
4351         for i in xrange(3):
4352             self.assertAlmostEqual(f1.getIJ(i,0),f2.getIJ(i,0),10);
4353             pass
4354         da=DataArrayDouble.New();
4355         da.setValues(discY,3,1);
4356         m.setCoordsAt(1,da);
4357         #
4358         m2=m.buildUnstructured();
4359         m2.checkCoherency();
4360         f1=m.getMeasureField(False);
4361         f2=m2.getMeasureField(False);
4362         self.assertEqual(f1.getNumberOfTuples(),6);
4363         self.assertEqual(f2.getNumberOfTuples(),6);
4364         self.assertEqual(2,m2.getMeshDimension());
4365         self.assertEqual(2,m2.getSpaceDimension());
4366         for i in xrange(6):
4367             self.assertAlmostEqual(f1.getIJ(i,0),f2.getIJ(i,0),10);
4368             pass
4369         #
4370         da=DataArrayDouble.New();
4371         da.setValues(discZ,5,1);
4372         m.setCoordsAt(2,da);
4373         m2=m.buildUnstructured();
4374         m2.checkCoherency();
4375         f1=m.getMeasureField(False);
4376         f2=m2.getMeasureField(False);
4377         self.assertEqual(f1.getNumberOfTuples(),24);
4378         self.assertEqual(f2.getNumberOfTuples(),24);
4379         self.assertEqual(3,m2.getMeshDimension());
4380         self.assertEqual(3,m2.getSpaceDimension());
4381         for i in xrange(24):
4382             self.assertAlmostEqual(f1.getIJ(i,0),f2.getIJ(i,0),10);
4383             pass
4384         #
4385         pos1=[5.,30.,2.]
4386         self.assertEqual(16,m.getCellContainingPoint(pos1,1e-12));
4387         #
4388         elems=m2.getCellsInBoundingBox([3.5,6.,12.2,25.,0.,1.5],1e-7)
4389         self.assertEqual([1, 2, 4, 5, 7, 8, 10, 11, 13, 14, 16, 17],elems.getValues())
4390         #
4391         pt=[2.4,12.7,-3.4]
4392         m.scale(pt,3.7);
4393         m3=m.buildUnstructured();
4394         m2.scale(pt,3.7);
4395         self.assertTrue(m3.isEqual(m2,1e-12));
4396         pass
4397
4398     def testDataArrayIntInvertO2NNO21(self):
4399         arr1=[2,0,4,1,5,3]
4400         da=DataArrayInt.New();
4401         da.setValues(arr1,6,1);
4402         da2=da.invertArrayO2N2N2O(6);
4403         self.assertEqual(6,da2.getNumberOfTuples());
4404         self.assertEqual(1,da2.getNumberOfComponents());
4405         expected1=[1,3,0,5,2,4]
4406         for i in xrange(6):
4407             self.assertEqual(expected1[i],da2.getIJ(i,0));
4408             pass
4409         da3=da2.invertArrayN2O2O2N(6);
4410         for i in xrange(6):
4411             self.assertEqual(arr1[i],da3.getIJ(i,0));
4412             pass
4413         #
4414         arr2=[3,-1,5,4,-1,0,-1,1,2,-1]
4415         da=DataArrayInt.New();
4416         da.setValues(arr2,10,1);
4417         da2=da.invertArrayO2N2N2O(6);
4418         self.assertEqual(6,da2.getNumberOfTuples());
4419         self.assertEqual(1,da2.getNumberOfComponents());
4420         expected2=[5,7,8,0,3,2]
4421         for i in xrange(6):
4422             self.assertEqual(expected2[i],da2.getIJ(i,0));
4423             pass
4424         da3=da2.invertArrayN2O2O2N(10);
4425         for i in xrange(10):
4426             self.assertEqual(arr2[i],da3.getIJ(i,0));
4427             pass
4428         pass
4429
4430     def testKeepSetSelectedComponent1(self):
4431         arr1=[1.,2.,3.,4., 11.,12.,13.,14., 21.,22.,23.,24., 31.,32.,33.,34., 41.,42.,43.,44.]
4432         a1=DataArrayDouble.New();
4433         a1.setValues(arr1,5,4);
4434         expp=[21.,22.,23.,24.]
4435         self.assertEqual(4,len(a1.getTuple(2)));
4436         for i in xrange(4):
4437             self.assertAlmostEqual(expp[i],a1.getTuple(2)[i],12)
4438             pass
4439         a1.setInfoOnComponent(0,"aaaa");
4440         a1.setInfoOnComponent(1,"bbbb");
4441         a1.setInfoOnComponent(2,"cccc");
4442         a1.setInfoOnComponent(3,"dddd");
4443         arr2V=[1,2,1,2,0,0]
4444         a2=a1.keepSelectedComponents(arr2V);
4445         self.assertEqual(6,a2.getNumberOfComponents());
4446         self.assertEqual(5,a2.getNumberOfTuples());
4447         self.assertTrue(a2.getInfoOnComponent(0)=="bbbb");
4448         self.assertTrue(a2.getInfoOnComponent(1)=="cccc");
4449         self.assertTrue(a2.getInfoOnComponent(2)=="bbbb");
4450         self.assertTrue(a2.getInfoOnComponent(3)=="cccc");
4451         self.assertTrue(a2.getInfoOnComponent(4)=="aaaa");
4452         self.assertTrue(a2.getInfoOnComponent(5)=="aaaa");
4453         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.]
4454         for i in xrange(30):
4455             self.assertAlmostEqual(expected1[i],a2.getIJ(0,i),14);
4456             pass
4457         a3=a1.convertToIntArr();
4458         self.assertEqual([21,22,23,24],a3.getTuple(2))
4459         a4=a3.keepSelectedComponents(arr2V);
4460         self.assertEqual(6,a4.getNumberOfComponents());
4461         self.assertEqual(5,a4.getNumberOfTuples());
4462         self.assertTrue(a4.getInfoOnComponent(0)=="bbbb");
4463         self.assertTrue(a4.getInfoOnComponent(1)=="cccc");
4464         self.assertTrue(a4.getInfoOnComponent(2)=="bbbb");
4465         self.assertTrue(a4.getInfoOnComponent(3)=="cccc");
4466         self.assertTrue(a4.getInfoOnComponent(4)=="aaaa");
4467         self.assertTrue(a4.getInfoOnComponent(5)=="aaaa");
4468         for i in xrange(30):
4469             self.assertEqual(int(expected1[i]),a4.getIJ(0,i));
4470             pass
4471         # setSelectedComponents
4472         arr3V=[3,2]
4473         a5=a1.keepSelectedComponents(arr3V);
4474         a5.setInfoOnComponent(0,"eeee");
4475         a5.setInfoOnComponent(1,"ffff");
4476         arr4V=[1,2]
4477         a2.setSelectedComponents(a5,arr4V);
4478         self.assertEqual(6,a2.getNumberOfComponents());
4479         self.assertEqual(5,a2.getNumberOfTuples());
4480         self.assertTrue(a2.getInfoOnComponent(0)=="bbbb");
4481         self.assertTrue(a2.getInfoOnComponent(1)=="eeee");
4482         self.assertTrue(a2.getInfoOnComponent(2)=="ffff");
4483         self.assertTrue(a2.getInfoOnComponent(3)=="cccc");
4484         self.assertTrue(a2.getInfoOnComponent(4)=="aaaa");
4485         self.assertTrue(a2.getInfoOnComponent(5)=="aaaa");
4486         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.]
4487         for i in xrange(30):
4488             self.assertAlmostEqual(expected2[i],a2.getIJ(0,i),14);
4489             pass
4490         a6=a5.convertToIntArr();
4491         a6.setInfoOnComponent(0,"eeee");
4492         a6.setInfoOnComponent(1,"ffff");
4493         a4.setSelectedComponents(a6,arr4V);
4494         self.assertEqual(6,a4.getNumberOfComponents());
4495         self.assertEqual(5,a4.getNumberOfTuples());
4496         self.assertTrue(a4.getInfoOnComponent(0)=="bbbb");
4497         self.assertTrue(a4.getInfoOnComponent(1)=="eeee");
4498         self.assertTrue(a4.getInfoOnComponent(2)=="ffff");
4499         self.assertTrue(a4.getInfoOnComponent(3)=="cccc");
4500         self.assertTrue(a4.getInfoOnComponent(4)=="aaaa");
4501         self.assertTrue(a4.getInfoOnComponent(5)=="aaaa");
4502         for i in xrange(30):
4503             self.assertEqual(int(expected2[i]),a4.getIJ(0,i));
4504             pass
4505         # test of throw
4506         arr5V=[2,3,6]
4507         arr6V=[2,7,5]
4508         arr7V=[2,1,4,6]
4509         self.assertRaises(InterpKernelException,a2.keepSelectedComponents,arr5V);
4510         self.assertRaises(InterpKernelException,a2.keepSelectedComponents,arr6V);
4511         self.assertRaises(InterpKernelException,a2.setSelectedComponents,a1,arr7V);
4512         arr7V=arr7V[0:3]
4513         self.assertRaises(InterpKernelException,a2.setSelectedComponents,a1,arr7V);
4514         #
4515         pass
4516
4517     def testKeepSetSelectedComponent2(self):
4518         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
4519         arr1=[1.,2.,3.,4., 11.,12.,13.,14., 21.,22.,23.,24., 31.,32.,33.,34., 41.,42.,43.,44.]
4520         a1=DataArrayDouble.New();
4521         a1.setValues(arr1,5,4);
4522         a1.setInfoOnComponent(0,"aaaa");
4523         a1.setInfoOnComponent(1,"bbbb");
4524         a1.setInfoOnComponent(2,"cccc");
4525         a1.setInfoOnComponent(3,"dddd");
4526         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
4527         f1.setTime(2.3,4,5);
4528         f1.setMesh(m1);
4529         f1.setName("f1");
4530         f1.setArray(a1);
4531         f1.checkCoherency();
4532         #
4533         arr2V=[1,2,1,2,0,0]
4534         f2=f1.keepSelectedComponents(arr2V);
4535         self.assertTrue(f2.getTimeDiscretization()==ONE_TIME);
4536         t,dt,it=f2.getTime()
4537         self.assertAlmostEqual(2.3,t,13);
4538         self.assertEqual(4,dt);
4539         self.assertEqual(5,it);
4540         f2.checkCoherency();
4541         self.assertEqual(6,f2.getNumberOfComponents());
4542         self.assertEqual(5,f2.getNumberOfTuples());
4543         self.assertTrue(f2.getArray().getInfoOnComponent(0)=="bbbb");
4544         self.assertTrue(f2.getArray().getInfoOnComponent(1)=="cccc");
4545         self.assertTrue(f2.getArray().getInfoOnComponent(2)=="bbbb");
4546         self.assertTrue(f2.getArray().getInfoOnComponent(3)=="cccc");
4547         self.assertTrue(f2.getArray().getInfoOnComponent(4)=="aaaa");
4548         self.assertTrue(f2.getArray().getInfoOnComponent(5)=="aaaa");
4549         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.]
4550         for i in xrange(30):
4551             self.assertAlmostEqual(expected1[i],f2.getIJ(0,i),14);
4552             pass
4553         #setSelectedComponents
4554         arr3V=[3,2]
4555         f5=f1.keepSelectedComponents(arr3V);
4556         f5.setTime(6.7,8,9);
4557         f5.getArray().setInfoOnComponent(0,"eeee");
4558         f5.getArray().setInfoOnComponent(1,"ffff");
4559         f5.checkCoherency();
4560         arr4V=[1,2]
4561         f2.setSelectedComponents(f5,arr4V);
4562         self.assertEqual(6,f2.getNumberOfComponents());
4563         self.assertEqual(5,f2.getNumberOfTuples());
4564         f2.checkCoherency();
4565         t,dt,it=f2.getTime()
4566         self.assertAlmostEqual(2.3,t,13);
4567         self.assertEqual(4,dt);
4568         self.assertEqual(5,it);
4569         self.assertTrue(f2.getArray().getInfoOnComponent(0)=="bbbb");
4570         self.assertTrue(f2.getArray().getInfoOnComponent(1)=="eeee");
4571         self.assertTrue(f2.getArray().getInfoOnComponent(2)=="ffff");
4572         self.assertTrue(f2.getArray().getInfoOnComponent(3)=="cccc");
4573         self.assertTrue(f2.getArray().getInfoOnComponent(4)=="aaaa");
4574         self.assertTrue(f2.getArray().getInfoOnComponent(5)=="aaaa");
4575         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.]
4576         for i in xrange(30):
4577             self.assertAlmostEqual(expected2[i],f2.getIJ(0,i),14);
4578             pass
4579         #
4580         pass
4581
4582     def testElementaryDAThrowAndSpecialCases(self):
4583         da=DataArrayInt.New();
4584         self.assertRaises(InterpKernelException, da.checkAllocated);
4585         self.assertRaises(InterpKernelException, da.fillWithValue, 1);
4586         self.assertRaises(InterpKernelException, da.iota, 1);
4587         da.alloc(7,1);
4588         da.fillWithValue(11); #11,11,11,11...
4589         da.iota(10); #10,11,12,13...
4590
4591         db=DataArrayInt.New();
4592         db.alloc(7,2);
4593
4594         dbl2=DataArrayDouble.New();
4595         dbl2.alloc(7,2);
4596         self.assertRaises(InterpKernelException, dbl2.isUniform, 10., 1e-15);
4597         self.assertRaises(InterpKernelException, dbl2.sort);
4598         self.assertRaises(InterpKernelException, dbl2.iota, 10.);
4599
4600         dbl=DataArrayDouble.New();
4601         #DataArrayDouble not allocated yet
4602         self.assertRaises(InterpKernelException, dbl.iota, 10.);
4603         self.assertRaises(InterpKernelException, dbl.isUniform, 10., 1e-15);
4604         self.assertRaises(InterpKernelException, dbl.sort);
4605         self.assertRaises(InterpKernelException, dbl.fromNoInterlace);
4606         self.assertRaises(InterpKernelException, dbl.toNoInterlace);
4607
4608         dbl.alloc(7,1);
4609         dbl.iota(10.);
4610         self.assertTrue(not dbl.isUniform(10.,1e-15));
4611         dbl.sort();
4612         self.assertTrue(dbl.isMonotonic(True, .99));
4613         self.assertTrue(dbl.isMonotonic(True, -.99));
4614         self.assertTrue(not dbl.isMonotonic(True, 1.1));
4615         self.assertTrue(not dbl.isMonotonic(True, -1.1));
4616         dbl.reverse();
4617         self.assertTrue(dbl.isMonotonic(False, .99));
4618         self.assertTrue(not dbl.isMonotonic(False, 1.1));
4619         self.assertTrue(not dbl.isMonotonic(False, -1.1));
4620
4621         dc=DataArrayInt.New();
4622         dc.alloc(14,1);
4623
4624         dd=DataArrayDouble.New();
4625         self.assertRaises(InterpKernelException, dd.checkAllocated);
4626         self.assertRaises(InterpKernelException, dd.fillWithValue, 1.);
4627         self.assertRaises(InterpKernelException, dd.iota, 1.);
4628         self.assertTrue(not ((dd.repr().find("No data"))==-1));
4629
4630         dd.alloc(0,1); #Allocated but nbOfElements==0!
4631         self.assertTrue(not ((dd.repr().find("Number of tuples : 0"))==-1));
4632         self.assertTrue(not ((dd.repr().find("Empty Data"))==-1));
4633         dd.fillWithValue(11); #?!...ok
4634         dd.iota(10); #?!...ok
4635         self.assertTrue(dd.isMonotonic(True, 1.));  #nothing is monotonic
4636         self.assertTrue(dd.isMonotonic(False, 1.));
4637
4638         self.assertRaises(InterpKernelException, db.copyStringInfoFrom, da);
4639         self.assertRaises(InterpKernelException, db.copyStringInfoFrom, da);
4640         cIds=[2,2]
4641         self.assertRaises(InterpKernelException, da.copyPartOfStringInfoFrom, db, cIds);
4642         cIds[0]=1;
4643         cIds[0]=-1;
4644         self.assertRaises(InterpKernelException, da.copyPartOfStringInfoFrom, db, cIds);
4645
4646         info=["infoOfOneComponent"]*2;
4647         self.assertRaises(InterpKernelException, da.setInfoOnComponents, info);
4648         self.assertRaises(InterpKernelException, da.setInfoOnComponent, 1, info[0]);
4649         db.setInfoOnComponents(info);
4650
4651         self.assertRaises(InterpKernelException, da.getInfoOnComponent, -1);
4652         self.assertRaises(InterpKernelException, da.getInfoOnComponent, 2);
4653         self.assertTrue(db.getInfoOnComponent(1)==db.getInfoOnComponent(0));
4654         self.assertRaises(InterpKernelException, db.getVarOnComponent, -1);
4655         self.assertRaises(InterpKernelException, db.getVarOnComponent, 2);
4656         self.assertRaises(InterpKernelException, db.getUnitOnComponent, -1);
4657         self.assertRaises(InterpKernelException, db.getUnitOnComponent, 2);
4658
4659         self.assertTrue(da.GetVarNameFromInfo("varname unit ")=="varname unit ");
4660         self.assertTrue(da.GetVarNameFromInfo("varname]unit[")=="varname]unit[");
4661         self.assertTrue(da.GetVarNameFromInfo("[unit]")=="");
4662         self.assertTrue(da.GetVarNameFromInfo("varname [unit]")=="varname");
4663
4664         self.assertTrue(da.GetUnitFromInfo("varname unit ")=="");
4665         self.assertTrue(da.GetUnitFromInfo("varname]unit[")=="");
4666         self.assertTrue(da.GetUnitFromInfo("[unit]")=="unit");
4667         self.assertTrue(da.GetUnitFromInfo("varname [unit]")=="unit");
4668
4669         self.assertRaises(InterpKernelException, da.checkNbOfTuplesAndComp, db, "theMessageInThrow");
4670         self.assertRaises(InterpKernelException, da.checkNbOfTuplesAndComp, dc, "theMessageInThrow");
4671         self.assertRaises(InterpKernelException, db.checkNbOfTuplesAndComp, dc, "theMessageInThrow");
4672
4673         self.assertRaises(InterpKernelException, da.checkNbOfTuplesAndComp, 7, 2, "theMessageInThrow");
4674         da.checkNbOfTuplesAndComp(7,1,"theMessageInThrow");
4675
4676         self.assertRaises(InterpKernelException, db.checkNbOfElems, 7*2+1, "theMessageInThrow");
4677         db.checkNbOfElems(7*2,"theMessageInThrow");
4678
4679         self.assertRaises(InterpKernelException, db.GetNumberOfItemGivenBES, 10, 9, 1, "theMessageInThrow");
4680         self.assertRaises(InterpKernelException, db.GetNumberOfItemGivenBES, 0, 1, -1, "theMessageInThrow");
4681         self.assertEqual(10,db.GetNumberOfItemGivenBES(0,10,1,"theMessageInThrow"));
4682         self.assertEqual(5,db.GetNumberOfItemGivenBES(0,10,2,"theMessageInThrow"));
4683         self.assertEqual(6,db.GetNumberOfItemGivenBES(0,11,2,"theMessageInThrow"));
4684
4685         self.assertTrue(not ((da.repr().find("Number of components : 1"))==-1));
4686         self.assertTrue(not ((dd.repr().find("Number of components : 1"))==-1));
4687         self.assertTrue(not ((dbl.repr().find("Number of components : 1"))==-1));
4688
4689         self.assertTrue(not ((da.reprZip().find("Number of components : 1"))==-1));
4690         self.assertTrue(not ((dd.reprZip().find("Number of components : 1"))==-1));
4691         self.assertTrue(not ((dbl.reprZip().find("Number of components : 1"))==-1));
4692
4693         self.assertRaises(InterpKernelException, dbl.selectByTupleId2, 0, 1, -1);
4694         self.assertRaises(InterpKernelException, dbl.substr, -1, 1);
4695         self.assertRaises(InterpKernelException, dbl.substr, 8, 1);
4696         self.assertRaises(InterpKernelException, dbl.substr, 0, 8);
4697         self.assertRaises(InterpKernelException, dbl.meldWith, dd);
4698
4699         self.assertRaises(InterpKernelException, dbl.setPartOfValuesAdv, dbl2, da); #dbl dbl2 not have the same number of components
4700         self.assertRaises(InterpKernelException, dbl.setPartOfValuesAdv, dd, da);  #da tuple selector DataArrayInt instance not have exactly 2 components
4701
4702         dbl3=DataArrayDouble.New();
4703         dbl3.alloc(6,2);
4704         dbl3.fillWithValue(11.);
4705         #bad number of components
4706         self.assertRaises(InterpKernelException, dbl3.getMaxValue);
4707         self.assertRaises(InterpKernelException, dd.getMaxValue);
4708         self.assertRaises(InterpKernelException, dbl3.getMinValue);
4709         self.assertRaises(InterpKernelException, dd.getMinValue);
4710         self.assertRaises(InterpKernelException, dbl3.getAverageValue);
4711         self.assertRaises(InterpKernelException, dd.getAverageValue);
4712         self.assertRaises(InterpKernelException, dd.accumulate, 100);
4713         self.assertRaises(InterpKernelException, dbl.fromPolarToCart);
4714         self.assertRaises(InterpKernelException, dbl3.fromCylToCart);
4715         self.assertRaises(InterpKernelException, dbl3.fromSpherToCart);
4716         self.assertRaises(InterpKernelException, dbl3.doublyContractedProduct);
4717         self.assertRaises(InterpKernelException, dbl3.determinant);
4718         self.assertRaises(InterpKernelException, dbl3.eigenValues);
4719         self.assertRaises(InterpKernelException, dbl3.eigenVectors);
4720         self.assertRaises(InterpKernelException, dbl3.inverse);
4721         self.assertRaises(InterpKernelException, dbl3.trace);
4722         self.assertRaises(InterpKernelException, dbl3.deviator);
4723
4724         dbl3.setIJ(5,1,12.);
4725         self.assertTrue(dbl3.getMaxValueInArray()==12.);
4726         self.assertTrue(dbl3.getMinValueInArray()==11.);
4727
4728         db.fillWithValue(100); #bad Ids
4729         self.assertRaises(InterpKernelException, dbl3.setPartOfValuesAdv, dbl2, db);
4730         db.fillWithValue(-1); #bad Ids
4731         self.assertRaises(InterpKernelException, dbl3.setPartOfValuesAdv, dbl2, db);
4732         db.fillWithValue(6); #bad Ids for dbl3
4733         self.assertRaises(InterpKernelException, dbl3.setPartOfValuesAdv, dbl2, db);
4734
4735         dbl3.checkNoNullValues();
4736         dbl3.setIJ(5,0,0.);
4737         self.assertRaises(InterpKernelException, dbl3.checkNoNullValues);
4738         self.assertRaises(InterpKernelException, dbl3.applyInv, 1.);  #div by zero
4739         self.assertRaises(InterpKernelException, dbl2.getIdsInRange, 1., 2.);
4740         a=[]
4741         self.assertRaises(InterpKernelException, DataArrayDouble_Aggregate, a);
4742         self.assertRaises(InterpKernelException, DataArrayDouble_Meld, a);
4743
4744         a=[dbl2,dbl]; #Nb of components mismatch
4745         self.assertRaises(InterpKernelException, DataArrayDouble_Aggregate, a);
4746
4747         self.assertRaises(InterpKernelException, DataArrayDouble_Dot, dbl2, dbl);
4748
4749         self.assertRaises(InterpKernelException, DataArrayDouble_CrossProduct, dbl2, dbl); #Nb of components mismatch
4750         self.assertRaises(InterpKernelException, DataArrayDouble_CrossProduct, dbl2, dbl2); #Nb of components must be equal to 3
4751         dbl4=DataArrayDouble.New();
4752         dbl4.alloc(6,3);
4753         dbl5=DataArrayDouble.New();
4754         dbl5.alloc(7,3);
4755         self.assertRaises(InterpKernelException, DataArrayDouble_CrossProduct, dbl4, dbl5); #Nb of tuples mismatch
4756
4757         a[0]=dbl4; #Nb of tuple mismatch
4758         a[1]=dbl5; #Nb of tuple mismatch
4759         self.assertRaises(InterpKernelException, DataArrayDouble_Meld, a);
4760         self.assertRaises(InterpKernelException, DataArrayDouble_Dot, dbl4, dbl5);
4761         pass
4762
4763     def testDAIGetIdsEqual1(self):
4764         tab1=[5,-2,-4,-2,3,2,-2];
4765         da=DataArrayInt.New();
4766         da.setValues(tab1,7,1);
4767         da2=da.getIdsEqual(-2);
4768         self.assertEqual(3,da2.getNumberOfTuples());
4769         self.assertEqual(1,da2.getNumberOfComponents());
4770         expected1=[1,3,6];
4771         self.assertEqual(expected1,da2.getValues());
4772         pass
4773
4774     def testDAIGetIdsEqualList1(self):
4775         tab1=[5,-2,-4,-2,3,2,-2];
4776         da=DataArrayInt.New();
4777         da.setValues(tab1,7,1);
4778         da2=da.getIdsEqualList([3,-2,0]);
4779         self.assertEqual(4,da2.getNumberOfTuples());
4780         self.assertEqual(1,da2.getNumberOfComponents());
4781         expected1=[1,3,4,6];
4782         self.assertEqual(expected1,da2.getValues());
4783         pass
4784
4785     def testDAFromNoInterlace1(self):
4786         tab1=[1,11,21,31,41,2,12,22,32,42,3,13,23,33,43]
4787         da=DataArrayInt.New();
4788         da.setValues(tab1,5,3);
4789         da2=da.fromNoInterlace();
4790         expected1=[1,2,3,11,12,13,21,22,23,31,32,33,41,42,43]
4791         self.assertEqual(5,da2.getNumberOfTuples());
4792         self.assertEqual(3,da2.getNumberOfComponents());# it's not a bug. Avoid to have 1 million components !
4793         self.assertEqual(expected1,da2.getValues());
4794         da3=da.convertToDblArr();
4795         da4=da3.fromNoInterlace();
4796         self.assertEqual(5,da4.getNumberOfTuples());
4797         self.assertEqual(3,da4.getNumberOfComponents());# it's not a bug. Avoid to have 1 million components !
4798         for i in xrange(15):
4799             self.assertAlmostEqual(expected1[i],da4.getIJ(0,i),14);
4800             pass
4801         pass
4802
4803     def testDAToNoInterlace1(self):
4804         tab1=[1,2,3,11,12,13,21,22,23,31,32,33,41,42,43]
4805         da=DataArrayInt.New();
4806         da.setValues(tab1,5,3);
4807         da2=da.toNoInterlace();
4808         expected1=[1,11,21,31,41,2,12,22,32,42,3,13,23,33,43]
4809         self.assertEqual(5,da2.getNumberOfTuples());
4810         self.assertEqual(3,da2.getNumberOfComponents());# it's not a bug. Avoid to have 1 million components !
4811         self.assertEqual(expected1,da2.getValues());
4812         da3=da.convertToDblArr();
4813         da4=da3.toNoInterlace();
4814         self.assertEqual(5,da4.getNumberOfTuples());
4815         self.assertEqual(3,da4.getNumberOfComponents());# it's not a bug. Avoid to have 1 million components !
4816         for i in xrange(15):
4817             self.assertAlmostEqual(expected1[i],da4.getIJ(0,i),14);
4818             pass
4819         pass
4820
4821     def testDAIsUniform1(self):
4822         tab1=[1,1,1,1,1]
4823         da=DataArrayInt.New();
4824         da.setValues(tab1,5,1);
4825         self.assertTrue(da.isUniform(1));
4826         da.setIJ(2,0,2);
4827         self.assertTrue(not da.isUniform(1));
4828         da.setIJ(2,0,1);
4829         self.assertTrue(da.isUniform(1));
4830         da2=da.convertToDblArr();
4831         self.assertTrue(da2.isUniform(1.,1.e-12));
4832         da2.setIJ(1,0,1.+1.e-13);
4833         self.assertTrue(da2.isUniform(1.,1.e-12));
4834         da2.setIJ(1,0,1.+1.e-11);
4835         self.assertTrue(not da2.isUniform(1.,1.e-12));
4836         pass
4837
4838     def testDADFromPolarToCart1(self):
4839         tab1=[2.,0.2,2.5,0.7]
4840         da=DataArrayDouble.New();
4841         da.setValues(tab1,2,2);
4842         da2=da.fromPolarToCart();
4843         expected1=[1.9601331556824833,0.39733866159012243, 1.9121054682112213,1.6105442180942275]
4844         for i in xrange(4):
4845             self.assertAlmostEqual(expected1[i],da2.getIJ(0,i),13);
4846             pass
4847         pass
4848
4849     def testDADFromCylToCart1(self):
4850         tab1=[2.,0.2,4.,2.5,0.7,9.]
4851         da=DataArrayDouble.New();
4852         da.setValues(tab1,2,3);
4853         da2=da.fromCylToCart();
4854         expected1=[1.9601331556824833,0.39733866159012243,4., 1.9121054682112213,1.6105442180942275,9.]
4855         for i in xrange(6):
4856             self.assertAlmostEqual(expected1[i],da2.getIJ(0,i),13);
4857             pass
4858         pass
4859
4860     def testDADFromSpherToCart1(self):
4861         tab1=[2.,0.2,0.3,2.5,0.7,0.8]
4862         da=DataArrayDouble.New();
4863         da.setValues(tab1,2,3);
4864         da2=da.fromSpherToCart();
4865         expected1=[0.37959212195737485,0.11742160338765303,1.9601331556824833, 1.1220769624465328,1.1553337045129035,1.9121054682112213]
4866         for i in xrange(6):
4867             self.assertAlmostEqual(expected1[i],da2.getIJ(0,i),13);
4868             pass
4869         pass
4870
4871     def testUnPolyze1(self):
4872         elts=[0,1,2,3,4,5,6,7]
4873         eltsV=elts;
4874         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
4875         mesh.convertToPolyTypes(eltsV);
4876         mesh.unPolyze();
4877         mesh2=MEDCouplingDataForTest.build3DTargetMesh_1();
4878         mesh.checkCoherency();
4879         self.assertTrue(mesh.isEqual(mesh2,1e-12));
4880         mesh.convertToPolyTypes(eltsV);
4881         self.assertTrue(not mesh.isEqual(mesh2,1e-12));
4882         mesh.getNodalConnectivity().setIJ(0,6,10);
4883         mesh.getNodalConnectivity().setIJ(0,7,9);
4884         mesh.getNodalConnectivity().setIJ(0,8,12);
4885         mesh.getNodalConnectivity().setIJ(0,9,13);
4886         mesh.unPolyze();
4887         self.assertTrue(mesh.isEqual(mesh2,1e-12));
4888         mesh.convertToPolyTypes(eltsV);
4889         mesh.getNodalConnectivity().setIJ(0,6,12);
4890         mesh.getNodalConnectivity().setIJ(0,7,13);
4891         mesh.getNodalConnectivity().setIJ(0,8,10);
4892         mesh.getNodalConnectivity().setIJ(0,9,9);
4893         mesh.unPolyze();
4894         self.assertTrue(mesh.isEqual(mesh2,1e-12));
4895         mesh.convertToPolyTypes(eltsV);
4896         mesh.getNodalConnectivity().setIJ(0,6,12);
4897         mesh.getNodalConnectivity().setIJ(0,7,10);
4898         mesh.getNodalConnectivity().setIJ(0,8,13);
4899         mesh.getNodalConnectivity().setIJ(0,9,9);
4900         mesh.unPolyze();
4901         self.assertTrue(not mesh.isEqual(mesh2,1e-12));
4902         # Test for 2D mesh
4903         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
4904         mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
4905         eltsV=eltsV[:5];
4906         mesh.convertToPolyTypes(eltsV);
4907         self.assertTrue(not mesh.isEqual(mesh2,1e-12));
4908         mesh.unPolyze();
4909         self.assertTrue(mesh.isEqual(mesh2,1e-12));
4910         pass
4911
4912     def testConvertDegeneratedCells1(self):
4913         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
4914         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]
4915         mesh.allocateCells(4);
4916         mesh.insertNextCell(NORM_HEXA8,8,conn[0:8])
4917         mesh.insertNextCell(NORM_HEXA8,8,conn[8:16])
4918         mesh.insertNextCell(NORM_HEXA8,8,conn[16:24])
4919         mesh.insertNextCell(NORM_HEXA8,8,conn[24:32])
4920         mesh.finishInsertingCells();
4921         mesh.checkCoherency();
4922         self.assertEqual(4,mesh.getNumberOfCells());
4923         self.assertEqual(NORM_HEXA8,mesh.getTypeOfCell(0));
4924         self.assertEqual(NORM_HEXA8,mesh.getTypeOfCell(1));
4925         self.assertEqual(NORM_HEXA8,mesh.getTypeOfCell(2));
4926         self.assertEqual(NORM_HEXA8,mesh.getTypeOfCell(3));
4927         f1=mesh.getMeasureField(True);
4928         mesh.convertDegeneratedCells();
4929         mesh.checkCoherency();
4930         f2=mesh.getMeasureField(True);
4931         self.assertEqual(4,mesh.getNumberOfCells());
4932         self.assertEqual(NORM_PENTA6,mesh.getTypeOfCell(0));
4933         self.assertEqual(NORM_PYRA5,mesh.getTypeOfCell(1));
4934         self.assertEqual(NORM_TETRA4,mesh.getTypeOfCell(2));
4935         self.assertEqual(NORM_PYRA5,mesh.getTypeOfCell(3));
4936         for i in xrange(4):
4937             self.assertAlmostEqual(f1.getArray().getIJ(0,i),f2.getArray().getIJ(0,i),5);
4938             pass
4939         pass
4940
4941     def testGetNodeIdsNearPoints1(self):
4942         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
4943         coords=mesh.getCoords();
4944         tmp=DataArrayDouble.New();
4945         vals=[0.2,0.2,0.1,0.2,0.2,0.2]
4946         tmp.setValues(vals,3,2);
4947         tmp2=DataArrayDouble.Aggregate(coords,tmp);
4948         mesh.setCoords(tmp2);
4949         pts=[0.2,0.2,0.1,0.3,-0.3,0.7]
4950         c=mesh.getNodeIdsNearPoint(pts[:2],1e-7);
4951         self.assertEqual([4,9,11],c.getValues());
4952         c,cI=mesh.getNodeIdsNearPoints(pts,3,1e-7);
4953         self.assertEqual([0,3,3,4],cI.getValues());
4954         self.assertEqual([4,9,11,6],c.getValues());
4955         c,cI=mesh.getNodeIdsNearPoints(pts,1e-7);
4956         self.assertEqual([0,3,3,4],cI.getValues());
4957         self.assertEqual([4,9,11,6],c.getValues());
4958         c,cI=mesh.getNodeIdsNearPoints(DataArrayDouble.New(pts,3,2),1e-7);
4959         self.assertEqual([0,3,3,4],cI.getValues());
4960         self.assertEqual([4,9,11,6],c.getValues());
4961         self.assertRaises(InterpKernelException,mesh.getNodeIdsNearPoints,DataArrayDouble.New(pts,2,3),1e-7);
4962         pass
4963
4964     def testFieldCopyTinyAttrFrom1(self):
4965         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
4966         f1.setName("f1");
4967         f1.setTimeTolerance(1.e-5);
4968         f1.setDescription("f1Desc");
4969         f1.setTime(1.23,4,5);
4970         f2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
4971         f2.setName("f2");
4972         f2.setDescription("f2Desc");
4973         f2.setTime(6.78,9,10);
4974         f2.setTimeTolerance(4.556e-12);
4975         #
4976         f1.copyTinyAttrFrom(f2);
4977         self.assertAlmostEqual(4.556e-12,f1.getTimeTolerance(),24);
4978         t,dt,it=f1.getTime()
4979         self.assertAlmostEqual(6.78,t,12);
4980         self.assertEqual(9,dt);
4981         self.assertEqual(10,it);
4982         self.assertTrue(f1.getName()=="f1");#name unchanged
4983         self.assertTrue(f1.getDescription()=="f1Desc");#description unchanged
4984         #
4985         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
4986         f1.setName("f1");
4987         f1.setTimeTolerance(1.e-5);
4988         f1.setDescription("f1Desc");
4989         f2=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
4990         f2.setName("f2");
4991         f2.setDescription("f2Desc");
4992         f2.setTimeTolerance(4.556e-12);
4993         #
4994         f1.copyTinyAttrFrom(f2);
4995         self.assertAlmostEqual(4.556e-12,f1.getTimeTolerance(),24);
4996         self.assertTrue(f1.getName()=="f1");#name unchanged
4997         self.assertTrue(f1.getDescription()=="f1Desc");#description unchanged
4998         #
4999         f1=MEDCouplingFieldDouble.New(ON_CELLS,CONST_ON_TIME_INTERVAL);
5000         f1.setName("f1");
5001         f1.setTimeTolerance(1.e-5);
5002         f1.setDescription("f1Desc");
5003         f1.setTime(1.23,4,5);
5004         f1.setEndTime(5.43,2,1);
5005         f2=MEDCouplingFieldDouble.New(ON_CELLS,CONST_ON_TIME_INTERVAL);
5006         f2.setName("f2");
5007         f2.setDescription("f2Desc");
5008         f2.setTimeTolerance(4.556e-12);
5009         f2.setTime(6.78,9,10);
5010         f2.setEndTime(10.98,7,6);
5011         #
5012         f1.copyTinyAttrFrom(f2);
5013         self.assertAlmostEqual(4.556e-12,f1.getTimeTolerance(),24);
5014         self.assertTrue(f1.getName()=="f1");#name unchanged
5015         self.assertTrue(f1.getDescription()=="f1Desc");#description unchanged
5016         t,dt,it=f1.getTime()
5017         self.assertAlmostEqual(6.78,t,12);
5018         self.assertEqual(9,dt);
5019         self.assertEqual(10,it);
5020         t,dt,it=f1.getEndTime()
5021         self.assertAlmostEqual(10.98,t,12);
5022         self.assertEqual(7,dt);
5023         self.assertEqual(6,it);
5024         #
5025         f1=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
5026         f1.setName("f1");
5027         f1.setTimeTolerance(1.e-5);
5028         f1.setDescription("f1Desc");
5029         f1.setTime(1.23,4,5);
5030         f1.setEndTime(5.43,2,1);
5031         f2=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
5032         f2.setName("f2");
5033         f2.setDescription("f2Desc");
5034         f2.setTimeTolerance(4.556e-12);
5035         f2.setTime(6.78,9,10);
5036         f2.setEndTime(10.98,7,6);
5037         #
5038         f1.copyTinyAttrFrom(f2);
5039         self.assertAlmostEqual(4.556e-12,f1.getTimeTolerance(),24);
5040         self.assertTrue(f1.getName()=="f1");#name unchanged
5041         self.assertTrue(f1.getDescription()=="f1Desc");#description unchanged
5042         t,dt,it=f1.getTime()
5043         self.assertAlmostEqual(6.78,t,12);
5044         self.assertEqual(9,dt);
5045         self.assertEqual(10,it);
5046         t,dt,it=f1.getEndTime()
5047         self.assertAlmostEqual(10.98,t,12);
5048         self.assertEqual(7,dt);
5049         self.assertEqual(6,it);
5050         pass
5051
5052     def testExtrudedMesh5(self):
5053         coo1=[0.,1.,2.,3.5]
5054         a=DataArrayDouble.New();
5055         a.setValues(coo1,4,1);
5056         b=MEDCouplingCMesh.New();
5057         b.setCoordsAt(0,a);
5058         c=b.buildUnstructured();
5059         self.assertEqual(1,c.getSpaceDimension());
5060         c.changeSpaceDimension(2);
5061         #
5062         d=DataArrayDouble.New();
5063         d.alloc(13,1);
5064         d.iota();
5065         e=MEDCouplingCMesh.New();
5066         e.setCoordsAt(0,d);
5067         f=e.buildUnstructured();
5068         g=f.getCoords().applyFunc(2,"3.5*IVec+x/6*3.14159265359*JVec");
5069         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 !
5070         h=g.fromPolarToCart();
5071         f.setCoords(h);
5072         i=c.buildExtrudedMesh(f,1);
5073         self.assertEqual(52,i.getNumberOfNodes());
5074         tmp,tmp2,tmp3=i.mergeNodes(1e-9);
5075         self.assertTrue(tmp2);
5076         self.assertEqual(37,tmp3);
5077         i.convertDegeneratedCells();
5078         i.checkCoherency();
5079         self.assertEqual(36,i.getNumberOfCells());
5080         self.assertEqual(37,i.getNumberOfNodes());
5081         self.assertEqual(12,i.getNumberOfCellsWithType(NORM_TRI3));
5082         self.assertEqual(24,i.getNumberOfCellsWithType(NORM_QUAD4));
5083         expected1=[0.25,0.75,2.0625]
5084         j=i.getMeasureField(True);
5085         for ii in xrange(12):
5086             for k in xrange(3):
5087                 self.assertAlmostEqual(expected1[k],j.getIJ(0,ii*3+k),10);
5088                 pass
5089             pass
5090         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]
5091         m=i.getBarycenterAndOwner();
5092         for i in xrange(72):
5093             self.assertAlmostEqual(expected2[i],m.getIJ(0,i),10);
5094             pass
5095         #
5096         pass
5097
5098     def testExtrudedMesh6(self):
5099         coo1=[0.,1.,2.,3.5]
5100         a=DataArrayDouble.New();
5101         a.setValues(coo1,4,1);
5102         b=MEDCouplingCMesh.New();
5103         b.setCoordsAt(0,a);
5104         c=b.buildUnstructured();
5105         self.assertEqual(1,c.getSpaceDimension());
5106         c.changeSpaceDimension(2);
5107         #
5108         d=DataArrayDouble.New();
5109         d.alloc(5);
5110         d.iota();
5111         e=MEDCouplingCMesh.New();
5112         e.setCoordsAt(0,d);
5113         f=e.buildUnstructured();
5114         d2=f.getCoords().applyFunc("x*x/2");
5115         f.setCoords(d2);
5116         f.changeSpaceDimension(2);
5117         #
5118         center=[0.,0.]
5119         f.rotate(center,None,pi/3);
5120         g=c.buildExtrudedMesh(f,0);
5121         g.checkCoherency();
5122         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 ]
5123         f1=g.getMeasureField(True);
5124         for i in xrange(12):
5125             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),12);
5126             pass
5127         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]
5128         f2=g.getBarycenterAndOwner();
5129         for i in xrange(24):
5130             self.assertAlmostEqual(expected2[i],f2.getIJ(0,i),12);
5131             pass
5132         pass
5133
5134     def testExtrudedMesh7(self):
5135         coo1=[0.,1.,2.,3.5]
5136         a=DataArrayDouble.New();
5137         a.setValues(coo1,4,1);
5138         b=MEDCouplingCMesh.New();
5139         b.setCoordsAt(0,a);
5140         c=b.buildUnstructured();
5141         self.assertEqual(1,c.getSpaceDimension());
5142         c.changeSpaceDimension(2);
5143         #
5144         d=DataArrayDouble.New();
5145         d.alloc(13,1);
5146         d.iota();
5147         e=MEDCouplingCMesh.New();
5148         e.setCoordsAt(0,d);
5149         f=e.buildUnstructured();
5150         g=f.getCoords().applyFunc(2,"3.5*IVec+x/6*3.14159265359*JVec");
5151         h=g.fromPolarToCart();
5152         f.setCoords(h);
5153         i=c.buildExtrudedMesh(f,1);
5154         self.assertEqual(52,i.getNumberOfNodes());
5155         tmp,tmp2,tmp3=i.mergeNodes(1e-9);
5156         self.assertTrue(tmp2);
5157         self.assertEqual(37,tmp3);
5158         i.convertDegeneratedCells();
5159         vec1=[10.,0]
5160         i.translate(vec1);
5161         g2=h.applyFunc(3,"13.5/3.5*x*IVec+0*JVec+13.5/3.5*y*KVec");
5162         f.setCoords(g2);
5163         i.changeSpaceDimension(3);
5164         i3=i.buildExtrudedMesh(f,1);
5165         f2=i3.getMeasureField(True);
5166         tmp,tmp2,tmp3=i.mergeNodes(1e-9);
5167         self.assertTrue(tmp2);
5168         self.assertEqual(444,tmp3);
5169         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]
5170         for ii in xrange(12):
5171             for jj in xrange(36):
5172                 self.assertAlmostEqual(expected1[jj],f2.getIJ(0,ii*36+jj),9);
5173                 pass
5174         #
5175         pass
5176
5177     def testSimplexize1(self):
5178         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5179         m.convertToPolyTypes([3]);
5180         da=m.simplexize(0);
5181         self.assertEqual(7,da.getNumberOfTuples());
5182         self.assertEqual(1,da.getNumberOfComponents());
5183         expected2=[0,0,1,2,3,4,4]
5184         for i in xrange(7):
5185             self.assertEqual(expected2[i],da.getIJ(i,0));
5186             pass
5187         m.checkCoherency();
5188         self.assertEqual(7,m.getNumberOfCells());
5189         self.assertEqual(NORM_TRI3,m.getTypeOfCell(0));
5190         self.assertEqual(NORM_TRI3,m.getTypeOfCell(1));
5191         self.assertEqual(NORM_TRI3,m.getTypeOfCell(2));
5192         self.assertEqual(NORM_TRI3,m.getTypeOfCell(3));
5193         self.assertEqual(NORM_POLYGON,m.getTypeOfCell(4));
5194         self.assertEqual(NORM_TRI3,m.getTypeOfCell(5));
5195         self.assertEqual(NORM_TRI3,m.getTypeOfCell(6));
5196         expected1=[0.125,0.125,0.125,0.125,0.25,0.125,0.125]
5197         f=m.getMeasureField(False);
5198         for i in xrange(7):
5199             self.assertAlmostEqual(expected1[i]*sqrt(2.),f.getIJ(i,0),10);
5200             pass
5201         types=m.getAllTypes();
5202         self.assertEqual([NORM_TRI3,NORM_POLYGON],types);
5203         #
5204         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5205         m.convertToPolyTypes([3]);
5206         da=m.simplexize(1);
5207         self.assertEqual(7,da.getNumberOfTuples());
5208         self.assertEqual(1,da.getNumberOfComponents());
5209         for i in xrange(7):
5210             self.assertEqual(expected2[i],da.getIJ(i,0));
5211             pass
5212         m.checkCoherency();
5213         types=m.getAllTypes();
5214         self.assertEqual([NORM_TRI3,NORM_POLYGON],types);
5215         self.assertEqual(7,m.getNumberOfCells());
5216         self.assertEqual(NORM_TRI3,m.getTypeOfCell(0));
5217         self.assertEqual(NORM_TRI3,m.getTypeOfCell(1));
5218         self.assertEqual(NORM_TRI3,m.getTypeOfCell(2));
5219         self.assertEqual(NORM_TRI3,m.getTypeOfCell(3));
5220         self.assertEqual(NORM_POLYGON,m.getTypeOfCell(4));
5221         self.assertEqual(NORM_TRI3,m.getTypeOfCell(5));
5222         self.assertEqual(NORM_TRI3,m.getTypeOfCell(6));
5223         f=m.getMeasureField(False);
5224         for i in xrange(7):
5225             self.assertAlmostEqual(expected1[i]*sqrt(2.),f.getIJ(i,0),10);
5226             pass
5227         pass
5228
5229     def testSimplexize2(self):
5230         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5231         m.convertToPolyTypes([3]);
5232         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
5233         f1.setMesh(m);
5234         arr=DataArrayDouble.New();
5235         arr1=[10.,110.,20.,120.,30.,130.,40.,140.,50.,150.]
5236         arr.setValues(arr1,5,2);
5237         f1.setArray(arr);
5238         #
5239         f1.checkCoherency();
5240         self.assertTrue(f1.simplexize(0));
5241         f1.checkCoherency();
5242         expected1=[10.,110.,10.,110.,20.,120.,30.,130.,40.,140.,50.,150.,50.,150.]
5243         for i in xrange(14):
5244             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),10);
5245             pass
5246         self.assertTrue(not f1.simplexize(0));
5247         for i in xrange(14):
5248             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),10);
5249             pass
5250         #
5251         pass
5252
5253     def testDAMeld1(self):
5254         da1=DataArrayDouble.New();
5255         da1.alloc(7,2);
5256         da2=DataArrayDouble.New();
5257         da2.alloc(7,1);
5258         #
5259         da1.fillWithValue(7.);
5260         da2.iota(0.);
5261         da3=da2.applyFunc(3,"10*x*IVec+100*x*JVec+1000*x*KVec");
5262         #
5263         da1.setInfoOnComponent(0,"c0da1");
5264         da1.setInfoOnComponent(1,"c1da1");
5265         da3.setInfoOnComponent(0,"c0da3");
5266         da3.setInfoOnComponent(1,"c1da3");
5267         da3.setInfoOnComponent(2,"c2da3");
5268         #
5269         da1C=da1.deepCpy();
5270         da1.meldWith(da3);
5271         self.assertEqual(5,da1.getNumberOfComponents());
5272         self.assertEqual(7,da1.getNumberOfTuples());
5273         self.assertTrue(da1.getInfoOnComponent(0)=="c0da1");
5274         self.assertTrue(da1.getInfoOnComponent(1)=="c1da1");
5275         self.assertTrue(da1.getInfoOnComponent(2)=="c0da3");
5276         self.assertTrue(da1.getInfoOnComponent(3)=="c1da3");
5277         self.assertTrue(da1.getInfoOnComponent(4)=="c2da3");
5278         #
5279         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.]
5280         for i in xrange(35):
5281             self.assertAlmostEqual(expected1[i],da1.getIJ(0,i),10);
5282             pass
5283         #
5284         dai1=da1C.convertToIntArr();
5285         dai3=da3.convertToIntArr();
5286         dai1.meldWith(dai3);
5287         self.assertEqual(5,dai1.getNumberOfComponents());
5288         self.assertEqual(7,dai1.getNumberOfTuples());
5289         self.assertTrue(dai1.getInfoOnComponent(0)=="c0da1");
5290         self.assertTrue(dai1.getInfoOnComponent(1)=="c1da1");
5291         self.assertTrue(dai1.getInfoOnComponent(2)=="c0da3");
5292         self.assertTrue(dai1.getInfoOnComponent(3)=="c1da3");
5293         self.assertTrue(dai1.getInfoOnComponent(4)=="c2da3");
5294         for i in xrange(35):
5295             self.assertEqual(int(expected1[i]),dai1.getIJ(0,i));
5296             pass
5297         # test of static method DataArrayDouble::meld
5298         da4=DataArrayDouble.Meld(da1C,da3);
5299         tmp=DataArrayDouble.Meld([da1C,da3]);
5300         self.assertTrue(da4.isEqual(tmp,1e-10))
5301         self.assertEqual(5,da4.getNumberOfComponents());
5302         self.assertEqual(7,da4.getNumberOfTuples());
5303         self.assertTrue(da4.getInfoOnComponent(0)=="c0da1");
5304         self.assertTrue(da4.getInfoOnComponent(1)=="c1da1");
5305         self.assertTrue(da4.getInfoOnComponent(2)=="c0da3");
5306         self.assertTrue(da4.getInfoOnComponent(3)=="c1da3");
5307         self.assertTrue(da4.getInfoOnComponent(4)=="c2da3");
5308         for i in xrange(35):
5309             self.assertAlmostEqual(expected1[i],da4.getIJ(0,i),10);
5310             pass
5311         # test of static method DataArrayInt::meld
5312         dai1=da1C.convertToIntArr();
5313         dai4=DataArrayInt.Meld(dai1,dai3);
5314         tmp=DataArrayInt.Meld([dai1,dai3]);
5315         self.assertTrue(dai4.isEqual(tmp))
5316         self.assertEqual(5,dai4.getNumberOfComponents());
5317         self.assertEqual(7,dai4.getNumberOfTuples());
5318         self.assertTrue(dai4.getInfoOnComponent(0)=="c0da1");
5319         self.assertTrue(dai4.getInfoOnComponent(1)=="c1da1");
5320         self.assertTrue(dai4.getInfoOnComponent(2)=="c0da3");
5321         self.assertTrue(dai4.getInfoOnComponent(3)=="c1da3");
5322         self.assertTrue(dai4.getInfoOnComponent(4)=="c2da3");
5323         for i in xrange(35):
5324             self.assertEqual(int(expected1[i]),dai4.getIJ(0,i));
5325             pass
5326         pass
5327
5328     def testFieldMeld1(self):
5329         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5330         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
5331         f1.setMesh(m);
5332         da1=DataArrayDouble.New();
5333         arr1=[12.,23.,34.,45.,56.]
5334         da1.setValues(arr1,5,1);
5335         da1.setInfoOnComponent(0,"aaa");
5336         f1.setArray(da1);
5337         f1.setTime(3.4,2,1);
5338         f1.checkCoherency();
5339         #
5340         f2=f1.deepCpy();
5341         f2.setMesh(f1.getMesh());
5342         f2.checkCoherency();
5343         f2.changeNbOfComponents(2,5.);
5344         f2.assign(5.);
5345         f2.getArray().setInfoOnComponent(0,"bbb");
5346         f2.getArray().setInfoOnComponent(1,"ccc");
5347         f2.checkCoherency();
5348         #
5349         f3=MEDCouplingFieldDouble.MeldFields(f2,f1);
5350         f3.checkCoherency();
5351         self.assertEqual(5,f3.getNumberOfTuples());
5352         self.assertEqual(3,f3.getNumberOfComponents());
5353         self.assertTrue(f3.getArray().getInfoOnComponent(0)=="bbb");
5354         self.assertTrue(f3.getArray().getInfoOnComponent(1)=="ccc");
5355         self.assertTrue(f3.getArray().getInfoOnComponent(2)=="aaa");
5356         expected1=[5.,5.,12.,5.,5.,23.,5.,5.,34.,5.,5.,45.,5.,5.,56.]
5357         for i in xrange(15):
5358             self.assertAlmostEqual(expected1[i],f3.getIJ(0,i),12);
5359             pass
5360         time,dt,it=f3.getTime();
5361         self.assertAlmostEqual(3.4,time,14);
5362         self.assertEqual(2,dt);
5363         self.assertEqual(1,it);
5364         #
5365         f4=f2.buildNewTimeReprFromThis(NO_TIME,False);
5366         f5=f1.buildNewTimeReprFromThis(NO_TIME,False);
5367         f6=MEDCouplingFieldDouble.MeldFields(f4,f5);
5368         f6.checkCoherency();
5369         self.assertEqual(5,f6.getNumberOfTuples());
5370         self.assertEqual(3,f6.getNumberOfComponents());
5371         self.assertTrue(f6.getArray().getInfoOnComponent(0)=="bbb");
5372         self.assertTrue(f6.getArray().getInfoOnComponent(1)=="ccc");
5373         self.assertTrue(f6.getArray().getInfoOnComponent(2)=="aaa");
5374         for i in xrange(15):
5375             self.assertAlmostEqual(expected1[i],f6.getIJ(0,i),12);
5376             pass
5377         #
5378         pass
5379
5380     def testMergeNodes2(self):
5381         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5382         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
5383         vec=[0.002,0.]
5384         m2.translate(vec);
5385         #
5386         m3=MEDCouplingUMesh.MergeUMeshes([m1,m2]);
5387         da,b,newNbOfNodes=m3.mergeNodes2(0.01);
5388         self.assertEqual(9,m3.getNumberOfNodes());
5389         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]
5390         for i in xrange(18):
5391             self.assertAlmostEqual(expected1[i],m3.getCoords().getIJ(0,i),13);
5392             pass
5393         #
5394         pass
5395
5396     def testMergeField2(self):
5397         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5398         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
5399         f1.setMesh(m);
5400         arr=DataArrayDouble.New();
5401         arr.alloc(5,2);
5402         arr.fillWithValue(2.);
5403         f1.setArray(arr);
5404         f2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
5405         f2.setMesh(m);
5406         arr=DataArrayDouble.New();
5407         arr.alloc(5,2);
5408         arr.fillWithValue(5.);
5409         f2.setArray(arr);
5410         f3=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
5411         f3.setMesh(m);
5412         arr=DataArrayDouble.New();
5413         arr.alloc(5,2);
5414         arr.fillWithValue(7.);
5415         f3.setArray(arr);
5416         #
5417         f4=MEDCouplingFieldDouble.MergeFields([f1,f2,f3]);
5418         self.assertEqual(15,f4.getMesh().getNumberOfCells());
5419         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.]
5420         for i in xrange(30):
5421             self.assertAlmostEqual(expected1[i],f4.getIJ(0,i),13);
5422             pass
5423         #
5424         pass
5425
5426     def testDAIBuildComplement1(self):
5427         a=DataArrayInt.New();
5428         tab=[3,1,7,8]
5429         a.setValues(tab,4,1);
5430         b=a.buildComplement(12);
5431         self.assertEqual(8,b.getNumberOfTuples());
5432         self.assertEqual(1,b.getNumberOfComponents());
5433         expected1=[0,2,4,5,6,9,10,11]
5434         for i in xrange(8):
5435             self.assertEqual(expected1[i],b.getIJ(0,i));
5436             pass
5437         pass
5438
5439     def testDAIBuildUnion1(self):
5440         a=DataArrayInt.New();
5441         tab1=[3,1,7,8]
5442         a.setValues(tab1,4,1);
5443         c=DataArrayInt.New();
5444         tab2=[5,3,0,18,8]
5445         c.setValues(tab2,5,1);
5446         b=a.buildUnion(c);
5447         self.assertEqual(7,b.getNumberOfTuples());
5448         self.assertEqual(1,b.getNumberOfComponents());
5449         expected1=[0,1,3,5,7,8,18]
5450         for i in xrange(7):
5451             self.assertEqual(expected1[i],b.getIJ(0,i));
5452             pass
5453         b=DataArrayInt.BuildUnion([a,c]);
5454         self.assertEqual(7,b.getNumberOfTuples());
5455         self.assertEqual(1,b.getNumberOfComponents());
5456         expected1=[0,1,3,5,7,8,18]
5457         for i in xrange(7):
5458             self.assertEqual(expected1[i],b.getIJ(0,i));
5459             pass
5460         pass
5461
5462     def testDAIBuildIntersection1(self):
5463         a=DataArrayInt.New();
5464         tab1=[3,1,7,8]
5465         a.setValues(tab1,4,1);
5466         c=DataArrayInt.New();
5467         tab2=[5,3,0,18,8]
5468         c.setValues(tab2,5,1);
5469         b=a.buildIntersection(c);
5470         self.assertEqual(2,b.getNumberOfTuples());
5471         self.assertEqual(1,b.getNumberOfComponents());
5472         expected1=[3,8]
5473         for i in xrange(2):
5474             self.assertEqual(expected1[i],b.getIJ(0,i));
5475             pass
5476         b=DataArrayInt.BuildIntersection([a,c]);
5477         self.assertEqual(2,b.getNumberOfTuples());
5478         self.assertEqual(1,b.getNumberOfComponents());
5479         expected1=[3,8]
5480         for i in xrange(2):
5481             self.assertEqual(expected1[i],b.getIJ(0,i));
5482             pass
5483         pass
5484
5485     def testDAIDeltaShiftIndex1(self):
5486         a=DataArrayInt.New();
5487         tab=[1,3,6,7,7,9,15]
5488         a.setValues(tab,7,1);
5489         b=a.deltaShiftIndex();
5490         self.assertEqual(6,b.getNumberOfTuples());
5491         self.assertEqual(1,b.getNumberOfComponents());
5492         expected1=[2,3,1,0,2,6]
5493         for i in xrange(6):
5494             self.assertEqual(expected1[i],b.getIJ(0,i));
5495             pass
5496         pass
5497
5498     def testDaDoubleSelectByTupleIdSafe1(self):
5499         a=DataArrayDouble.New();
5500         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]
5501         a.setValues(arr1,7,2);
5502         a.setInfoOnComponent(0,"toto");
5503         a.setInfoOnComponent(1,"tata");
5504         #
5505         arr2=[4,2,0,6,5]
5506         b=a.selectByTupleIdSafe(arr2);
5507         self.assertEqual(5,b.getNumberOfTuples());
5508         self.assertEqual(2,b.getNumberOfComponents());
5509         self.assertTrue(b.getInfoOnComponent(0)=="toto");
5510         self.assertTrue(b.getInfoOnComponent(1)=="tata");
5511         expected1=[5.1,15.1,3.1,13.1,1.1,11.1,7.1,17.1,6.1,16.1]
5512         for i in xrange(10):
5513             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
5514             pass
5515         arr4=[4,-1,0,6,5]
5516         self.assertRaises(InterpKernelException,a.selectByTupleIdSafe,arr4);
5517         arr5=[4,2,0,6,7]
5518         self.assertRaises(InterpKernelException,a.selectByTupleIdSafe,arr5);
5519         #
5520         c=DataArrayInt.New();
5521         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
5522         c.setValues(arr3,7,2);
5523         c.setInfoOnComponent(0,"toto");
5524         c.setInfoOnComponent(1,"tata");
5525         d=c.selectByTupleIdSafe(arr2);
5526         self.assertEqual(5,d.getNumberOfTuples());
5527         self.assertEqual(2,d.getNumberOfComponents());
5528         self.assertTrue(d.getInfoOnComponent(0)=="toto");
5529         self.assertTrue(d.getInfoOnComponent(1)=="tata");
5530         expected2=[5,15,3,13,1,11,7,17,6,16]
5531         for i in xrange(10):
5532             self.assertEqual(expected2[i],d.getIJ(0,i));
5533             pass
5534         self.assertRaises(InterpKernelException,c.selectByTupleIdSafe,arr4);
5535         self.assertRaises(InterpKernelException,c.selectByTupleIdSafe,arr5);
5536         pass
5537
5538     def testAreCellsIncludedIn1(self):
5539         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5540         pt=[1,3]
5541         m2=m.buildPartOfMySelf(pt,True);
5542         ret,tmp=m.areCellsIncludedIn(m2,0)
5543         self.assertTrue(ret);
5544         self.assertEqual(2,tmp.getNumberOfTuples());
5545         self.assertEqual(1,tmp.getNumberOfComponents());
5546         self.assertEqual(pt[0],tmp.getIJ(0,0));
5547         self.assertEqual(pt[1],tmp.getIJ(0,1));
5548         ret,tmp=m2.areCellsIncludedIn(m,0)
5549         self.assertTrue(not ret);
5550         m3=MEDCouplingUMesh.MergeUMeshesOnSameCoords(m,m2)
5551         c,cI=m3.findCommonCells(2,m.getNumberOfCells())
5552         self.assertTrue(c.isEqual(DataArrayInt([1,5,3,6])))
5553         self.assertTrue(cI.isEqual(DataArrayInt([0,2,4])))
5554         pass
5555
5556     def testSwigErrorProtection1(self):
5557         m=MEDCouplingDataForTest.build3DTargetMesh_1();
5558         m.rotate([0.,0.,0.],[0.3,0.6,1.2],0.37)
5559         m.rotate([0.,0.,0.],[0.3,6,1.2],0.37)
5560         self.assertRaises(InterpKernelException,m.rotate,[0.,0.,0.],(0.3,6,"1.2"),0.37)
5561         self.assertRaises(InterpKernelException,m.rotate,[0.,"0.",0.],[0.3,0.6,1.2],0.37)
5562         self.assertRaises(InterpKernelException,m.rotate,[0.,0.,0.],[0.3,'0.6',1.2],0.37)
5563         m2=m.buildPartOfMySelf([2,5],True)
5564         m3=m.buildPartOfMySelf((2,5),True)
5565         self.assertTrue(m2.isEqual(m3,1e-12))
5566         self.assertRaises(InterpKernelException,m.buildPartOfMySelf,[2,5.],True)
5567         da1=m.getCoords().keepSelectedComponents([1])
5568         da2=m.getCoords().keepSelectedComponents((1,))
5569         self.assertTrue(da1.isEqual(da2,1e-12))
5570         self.assertRaises(InterpKernelException,m.getCoords().keepSelectedComponents,["1"])
5571         pass
5572
5573     def testDAIBuildSubstraction1(self):
5574         a=DataArrayInt.New()
5575         aa=[2,3,6,8,9]
5576         a.setValues(aa,5,1)
5577         b=DataArrayInt.New()
5578         bb=[1,3,5,9,11]
5579         b.setValues(bb,5,1)
5580         self.assertEqual([2,6,8],a.buildSubstraction(b).getValues())
5581         pass
5582
5583     def testBuildOrthogonalField2(self):
5584         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5585         d1=DataArrayInt.New();
5586         d2=DataArrayInt.New();
5587         d3=DataArrayInt.New();
5588         d4=DataArrayInt.New();
5589         m1=m.buildDescendingConnectivity(d1,d2,d3,d4);
5590         #
5591         f1=m1.buildOrthogonalField();
5592         da1=f1.getArray();
5593         self.assertEqual(2,da1.getNumberOfComponents());
5594         self.assertEqual(13,da1.getNumberOfTuples());
5595         #
5596         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.];
5597         for i in xrange(26):
5598             self.assertAlmostEqual(expected1[i],da1.getIJ(0,i),14);
5599             pass
5600         pass
5601
5602     def testSwigErrorProtection2(self):
5603         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5604         coo=m.getCoords()
5605         c=m.getNodalConnectivity()
5606         ci=m.getNodalConnectivityIndex()
5607         del m
5608         self.assertEqual(2,coo.getNumberOfComponents());
5609         self.assertEqual(6,ci.getNumberOfTuples());
5610         self.assertEqual(23,c.getNumberOfTuples());
5611         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5612         f=m.getMeasureField(True)
5613         c=f.getArray()
5614         del f
5615         self.assertEqual(1,c.getNumberOfComponents());
5616         m=MEDCouplingCMesh.New()
5617         x=DataArrayDouble.New()
5618         x.setValues([1.,2.,4.],3,1)
5619         m.setCoordsAt(0,x)
5620         del x
5621         xx=m.getCoordsAt(0)
5622         del m
5623         self.assertEqual(3,xx.getNumberOfTuples());
5624         #
5625         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5626         f=m.getMeasureField(True)
5627         m2=f.getMesh()
5628         del m
5629         del f
5630         self.assertEqual(5,m2.getNumberOfCells());
5631         pass
5632
5633     def testUMInsertNextCell1(self):
5634         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 ]
5635         targetConn=[0,3,4,1, 1,4,2, 4,5,2, 6,7,4,3, 7,8,5,4]
5636         targetMesh=MEDCouplingUMesh.New();
5637         targetMesh.allocateCells(5);
5638         self.assertRaises(InterpKernelException,targetMesh.insertNextCell,NORM_QUAD4,4,targetConn[0:4])
5639         targetMesh.setMeshDimension(2);
5640         targetMesh.insertNextCell(NORM_QUAD4,4,targetConn[0:4])
5641         self.assertRaises(InterpKernelException,targetMesh.insertNextCell,NORM_TETRA4,4,targetConn[0:4])
5642         self.assertRaises(InterpKernelException,targetMesh.insertNextCell,NORM_SEG2,2,targetConn[0:2])
5643         self.assertRaises(InterpKernelException,targetMesh.insertNextCell,NORM_POINT1,1,targetConn[0:1])
5644         targetMesh.insertNextCell(NORM_TRI3,3,targetConn[4:7])
5645         targetMesh.insertNextCell(NORM_TRI3,3,targetConn[7:10])
5646         targetMesh.insertNextCell(NORM_QUAD4,4,targetConn[10:14])
5647         targetMesh.insertNextCell(NORM_QUAD4,4,targetConn[14:18])
5648         targetMesh.finishInsertingCells();
5649         myCoords=DataArrayDouble.New();
5650         myCoords.setValues(targetCoords,9,2);
5651         targetMesh.setCoords(myCoords);
5652         targetMesh.checkCoherency();
5653         pass
5654
5655     def testFieldOperatorDivDiffComp1(self):
5656         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5657         m1,d0,d1,d2,d3=m.buildDescendingConnectivity();
5658         #
5659         f1=m1.buildOrthogonalField();
5660         arr1=[2.,3.,4.,5.,6.,7.,8.,9.,10.,11.,12.,13.,14.]
5661         arr=DataArrayDouble.New();
5662         arr.setValues(arr1,13,1);
5663         f2=MEDCouplingFieldDouble.New(ON_CELLS);
5664         f2.setArray(arr);
5665         f2.setMesh(m1);
5666         f2.checkCoherency();
5667         #
5668         f3=f1/f2;
5669         self.assertRaises(InterpKernelException,f2.__div__,f1)
5670         f3.checkCoherency();
5671         f1/=f2;
5672         #self.assertRaises(InterpKernelException,f2.__idiv__,f1) # mem leaks
5673         self.assertTrue(f1.isEqual(f3,1e-10,1e-10));
5674         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]
5675         for i in xrange(26):
5676             self.assertAlmostEqual(expected1[i],f3.getIJ(0,i),10);
5677             pass
5678         pass
5679
5680     def testDARearrange1(self):
5681         da1=DataArrayInt.New();
5682         da1.alloc(12,1);
5683         da1.iota(0);
5684         #
5685         self.assertEqual(12,da1.getNbOfElems());
5686         self.assertEqual(1,da1.getNumberOfComponents());
5687         self.assertEqual(12,da1.getNumberOfTuples());
5688         da1.rearrange(4);
5689         self.assertEqual(12,da1.getNbOfElems());
5690         self.assertEqual(4,da1.getNumberOfComponents());
5691         self.assertEqual(3,da1.getNumberOfTuples());
5692         for i in xrange(12):
5693             self.assertEqual(i,da1.getIJ(0,i));
5694         #
5695         da1.rearrange(6);
5696         self.assertEqual(12,da1.getNbOfElems());
5697         self.assertEqual(6,da1.getNumberOfComponents());
5698         self.assertEqual(2,da1.getNumberOfTuples());
5699         for i in xrange(12):
5700             self.assertEqual(i,da1.getIJ(0,i));
5701         #
5702         self.assertRaises(InterpKernelException,da1.rearrange,7);
5703         #
5704         da1.rearrange(12);
5705         self.assertEqual(12,da1.getNbOfElems());
5706         self.assertEqual(12,da1.getNumberOfComponents());
5707         self.assertEqual(1,da1.getNumberOfTuples());
5708         for i in xrange(12):
5709             self.assertEqual(i,da1.getIJ(0,i));
5710         #
5711         da1.rearrange(3);
5712         self.assertEqual(12,da1.getNbOfElems());
5713         self.assertEqual(3,da1.getNumberOfComponents());
5714         self.assertEqual(4,da1.getNumberOfTuples());
5715         for i in xrange(12):
5716             self.assertEqual(i,da1.getIJ(0,i));
5717         #double
5718         da2=da1.convertToDblArr();
5719         st=da2.getHiddenCppPointer()
5720         #
5721         self.assertEqual(12,da2.getNbOfElems());
5722         self.assertEqual(3,da2.getNumberOfComponents());
5723         self.assertEqual(4,da2.getNumberOfTuples());
5724         da2.rearrange(4);
5725         self.assertEqual(12,da2.getNbOfElems());
5726         self.assertEqual(4,da2.getNumberOfComponents());
5727         self.assertEqual(3,da2.getNumberOfTuples());
5728         for i in xrange(12):
5729             self.assertAlmostEqual(float(i),da2.getIJ(0,i),14);
5730         #
5731         da2.rearrange(6);
5732         self.assertEqual(12,da2.getNbOfElems());
5733         self.assertEqual(6,da2.getNumberOfComponents());
5734         self.assertEqual(2,da2.getNumberOfTuples());
5735         for i in xrange(12):
5736             self.assertAlmostEqual(float(i),da2.getIJ(0,i),14);
5737         #
5738         self.assertRaises(InterpKernelException,da2.rearrange,7);
5739         #
5740         da2.rearrange(1);
5741         self.assertEqual(st,da2.getHiddenCppPointer())
5742         self.assertEqual(12,da2.getNbOfElems());
5743         self.assertEqual(1,da2.getNumberOfComponents());
5744         self.assertEqual(12,da2.getNumberOfTuples());
5745         for i in xrange(12):
5746             self.assertAlmostEqual(float(i),da2.getIJ(0,i),14);
5747         #
5748         da2.rearrange(3);
5749         self.assertEqual(12,da2.getNbOfElems());
5750         self.assertEqual(3,da2.getNumberOfComponents());
5751         self.assertEqual(4,da2.getNumberOfTuples());
5752         for i in xrange(12):
5753             self.assertAlmostEqual(float(i),da2.getIJ(0,i),14);
5754         pass
5755
5756     def testDARearrange2(self):
5757         da1=DataArrayInt.New();
5758         arr=[1,2,3,2,2,3,5,1,5,5,2,2]
5759         da1.setValues(arr,4,3);
5760         s=da1.getDifferentValues();
5761         expected1=DataArrayInt([1,2,3,5])
5762         self.assertTrue(expected1.isEqual(s));
5763         pass
5764
5765     def testSwigErrorProtection3(self):
5766         da=DataArrayInt.New()
5767         da.setValues([1,2,3,4,0,0,0,0,0,0,0,0],4,3)
5768         self.assertEqual([1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0],da.getValues())
5769         self.assertEqual(3,da.getNumberOfComponents());
5770         self.assertEqual(4,da.getNumberOfTuples());
5771         da=DataArrayInt.New()
5772         da.setValues(((1,2,3),(4,4,3),(0,0,0),(0,0,0)),4,3)
5773         self.assertEqual([1, 2, 3, 4, 4, 3, 0, 0, 0, 0, 0, 0],da.getValues())
5774         self.assertEqual(3,da.getNumberOfComponents());
5775         self.assertEqual(4,da.getNumberOfTuples());
5776         da.setValues((10*[1]+290*[2])[:12],4,3)
5777         self.assertEqual(10*[1]+[2,2],da.getValues())
5778         self.assertEqual(3,da.getNumberOfComponents());
5779         self.assertEqual(4,da.getNumberOfTuples());
5780         #
5781         da=DataArrayDouble.New()
5782         da.setValues([1,2,3.,4,0,0,0,0,0,0,0,0],4,3)
5783         self.assertEqual([1., 2., 3., 4., 0., 0., 0., 0., 0., 0., 0., 0.],da.getValues())
5784         self.assertEqual(3,da.getNumberOfComponents());
5785         self.assertEqual(4,da.getNumberOfTuples());
5786         da=DataArrayDouble.New()
5787         da.setValues(((1,2,3),(4.,4,3),(0,0,0),(0,0,0)),4,3)
5788         self.assertEqual([1., 2., 3., 4., 4., 3., 0., 0., 0., 0., 0., 0.],da.getValues())
5789         self.assertEqual(3,da.getNumberOfComponents());
5790         self.assertEqual(4,da.getNumberOfTuples());
5791         da.setValues((10*[1]+290*[2])[:12],4,3)
5792         self.assertEqual(10*[1.]+[2.,2.],da.getValues())
5793         self.assertEqual(3,da.getNumberOfComponents());
5794         self.assertEqual(4,da.getNumberOfTuples());
5795         pass
5796
5797     def testDAIBuildPermutationArr1(self):
5798         a=DataArrayInt.New()
5799         a.setValues([4,5,6,7,8],5,1)
5800         b=DataArrayInt.New()
5801         b.setValues([5,4,8,6,7],5,1)
5802         c=a.buildPermutationArr(b)
5803         self.assertEqual([1,0,4,2,3],c.getValues())
5804         self.assertTrue(a.isEqualWithoutConsideringStrAndOrder(b))
5805         b.setIJ(0,0,9)
5806         self.assertTrue(not a.isEqualWithoutConsideringStrAndOrder(b))
5807         self.assertRaises(InterpKernelException,a.buildPermutationArr,b)
5808         a.setIJ(3,0,4)
5809         b.setIJ(0,0,5)
5810         b.setIJ(4,0,4)#a==[4,5,6,4,8] and b==[5,4,8,6,4]
5811         self.assertTrue(a.isEqualWithoutConsideringStrAndOrder(b))
5812         c=a.buildPermutationArr(b)
5813         self.assertEqual([1,3,4,2,3],c.getValues())
5814         d=b.convertToDblArr()
5815         expect3=[4,4,5,6,8]
5816         b.sort()
5817         self.assertEqual(expect3,b.getValues())
5818         d.sort()
5819         self.assertEqual(5,d.getNumberOfTuples());
5820         self.assertEqual(1,d.getNumberOfComponents());
5821         for i in xrange(5):
5822             self.assertAlmostEqual(float(expect3[i]),d.getIJ(i,0),14);
5823             pass
5824         pass
5825
5826     def testAreCellsIncludedIn2(self):
5827         myName="Vitoo";
5828         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5829         m2=m.buildPartOfMySelf([],True);
5830         self.assertEqual(0,m2.getNumberOfCells());
5831         self.assertEqual(3,m2.getSpaceDimension());
5832         self.assertEqual(2,m2.getMeshDimension());
5833         m2.setName(myName);
5834         test,tmp=m.areCellsIncludedIn(m2,0)
5835         self.assertTrue(test);
5836         self.assertEqual(myName,tmp.getName());
5837         self.assertEqual(0,tmp.getNumberOfTuples())
5838         self.assertEqual(1,tmp.getNumberOfComponents())
5839         pass
5840
5841     def testUMeshGetPartBarycenterAndOwner1(self):
5842         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5843         part1=[1,0,4];
5844         part=DataArrayInt.New();
5845         part.setValues(part1,3,1);
5846         b=m1.getPartBarycenterAndOwner(part);
5847         self.assertEqual(2,b.getNumberOfComponents());
5848         self.assertEqual(3,b.getNumberOfTuples());
5849         expected1=[0.36666666666666665,-0.13333333333333333,-0.05,-0.05,0.45,0.45];
5850         for i in xrange(6):
5851             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
5852             pass
5853         pass
5854
5855     def testUMeshGetPartMeasureField1(self):
5856         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5857         part1=[1,0,4];
5858         part=DataArrayInt.New();
5859         part.setValues(part1,3,1);
5860         b=m1.getPartMeasureField(True,part);
5861         self.assertEqual(1,b.getNumberOfComponents());
5862         self.assertEqual(3,b.getNumberOfTuples());
5863         expected1=[0.125,0.25,0.25];
5864         for i in xrange(3):
5865             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
5866             pass
5867         pass
5868
5869     def testUMeshBuildPartOrthogonalField1(self):
5870         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5871         m1.changeSpaceDimension(3);
5872         part1=[1,0,4];
5873         part=DataArrayInt.New();
5874         part.setValues(part1,3,1);
5875         b=m1.buildPartOrthogonalField(part);
5876         self.assertEqual(3,b.getArray().getNumberOfComponents());
5877         self.assertEqual(3,b.getArray().getNumberOfTuples());
5878         expected1=[0.,0.,-1.,0.,0.,-1.,0.,0.,-1.];
5879         for i in xrange(9):
5880             self.assertAlmostEqual(expected1[i],b.getArray().getIJ(0,i),14);
5881             pass
5882         pass
5883
5884     def testUMeshGetTypesOfPart1(self):
5885         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5886         part1=[0,3,4];
5887         p1=DataArrayInt.New()
5888         p1.setValues(part1,3,1)
5889         s=m1.getTypesOfPart(p1);
5890         self.assertEqual([NORM_QUAD4],s);
5891         part2=[2,2,2,1];
5892         p2=DataArrayInt.New()
5893         p2.setValues(part2,4,1)
5894         s=m1.getTypesOfPart(p2);
5895         self.assertEqual([NORM_TRI3],s);
5896         part3=[3,2,1];
5897         p3=DataArrayInt.New()
5898         p3.setValues(part3,3,1)
5899         s=m1.getTypesOfPart(p3);
5900         self.assertEqual(s,[NORM_TRI3,NORM_QUAD4]);
5901         pass
5902
5903     def testUMeshKeepCellIdsByType1(self):
5904         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5905         part1=[0,3,4]
5906         p1=DataArrayInt.New()
5907         p1.setValues(part1,3,1)
5908         p1.setName("p1")
5909         a=m1.keepCellIdsByType(NORM_TRI3,p1);
5910         self.assertEqual("p1",a.getName())
5911         self.assertEqual(1,a.getNumberOfComponents());
5912         self.assertEqual(0,a.getNumberOfTuples());
5913         #
5914         part2=[3,2,0,2,4]
5915         p2=DataArrayInt.New()
5916         p2.setValues(part2,5,1)
5917         p2.setName("p2")
5918         a=m1.keepCellIdsByType(NORM_TRI3,p2);
5919         self.assertEqual("p2",a.getName())
5920         self.assertEqual(1,a.getNumberOfComponents());
5921         self.assertEqual(2,a.getNumberOfTuples());
5922         self.assertEqual(2,a.getIJ(0,0));
5923         self.assertEqual(2,a.getIJ(1,0));
5924         #
5925         a=m1.keepCellIdsByType(NORM_QUAD4,p2);
5926         self.assertEqual("p2",a.getName())
5927         self.assertEqual(1,a.getNumberOfComponents());
5928         self.assertEqual(3,a.getNumberOfTuples());
5929         self.assertEqual(3,a.getIJ(0,0));
5930         self.assertEqual(0,a.getIJ(1,0));
5931         self.assertEqual(4,a.getIJ(2,0));
5932         pass
5933
5934     def testSwigErrorDaIntSelectByTupleId1(self):
5935         a=DataArrayInt.New();
5936         arr1=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
5937         a.setValues(arr1,7,2);
5938         a.setInfoOnComponent(0,"toto");
5939         a.setInfoOnComponent(1,"tata");
5940         #
5941         arr2=[4,2,0,6,5]
5942         b=a.selectByTupleId(arr2);
5943         self.assertEqual(5,b.getNumberOfTuples());
5944         self.assertEqual(2,b.getNumberOfComponents());
5945         self.assertTrue(b.getInfoOnComponent(0)=="toto");
5946         self.assertTrue(b.getInfoOnComponent(1)=="tata");
5947         expected1=[5,15,3,13,1,11,7,17,6,16]
5948         self.assertEqual(expected1,b.getValues())
5949         #
5950         a2=DataArrayInt.New()
5951         a2.setValues(arr2,5,1)
5952         b=a.selectByTupleId(a2);
5953         self.assertEqual(5,b.getNumberOfTuples());
5954         self.assertEqual(2,b.getNumberOfComponents());
5955         self.assertTrue(b.getInfoOnComponent(0)=="toto");
5956         self.assertTrue(b.getInfoOnComponent(1)=="tata");
5957         expected1=[5,15,3,13,1,11,7,17,6,16]
5958         self.assertEqual(expected1,b.getValues())
5959         pass
5960
5961     def testSwigErrorRenum(self):
5962         da=DataArrayDouble.New()
5963         da.setValues([7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.],10,2)
5964         d=DataArrayInt.New()
5965         d.setValues([0,2,3,1,4,5,6,8,7,9],10,1)
5966         da.renumberInPlace(d)
5967         da.renumber(d)
5968         pass
5969
5970     def testSwigGetItem1(self):
5971         da=DataArrayInt.New()
5972         da.alloc(16,3)
5973         da.rearrange(1)
5974         da.iota(7)
5975         da.rearrange(3)
5976         da.setInfoOnComponent(0,"X [m]")
5977         da.setInfoOnComponent(1,"Y [m]")
5978         da.setInfoOnComponent(2,"Z [km]")
5979         da2=da[5:-1]
5980         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())
5981         da2=da[4]
5982         self.assertEqual([19, 20, 21],da2.getValues())
5983         try:
5984             da2=da[4:17]
5985         except InterpKernelException as e:
5986             self.assertTrue(True)
5987         else:
5988             self.assertTrue(False)
5989             pass
5990         da2=da[5:-2,2]
5991         self.assertEqual([24, 27, 30, 33, 36, 39, 42, 45, 48],da2.getValues())
5992         da2=da[5:8,:]
5993         self.assertEqual([22, 23, 24, 25, 26, 27, 28, 29, 30],da2.getValues())
5994         da2=da[:]
5995         self.assertTrue(da2.isEqual(da))
5996         da2=da[:,:]
5997         self.assertTrue(da2.isEqual(da))
5998         try:
5999             da2=da[:,:,:]
6000         except InterpKernelException as e:
6001             self.assertTrue(True)
6002         else:
6003             self.assertTrue(False)
6004             pass
6005         try:
6006             da2=da[5:8,-2]
6007         except InterpKernelException as e:
6008             self.assertTrue(True)
6009         else:
6010             self.assertTrue(False)
6011             pass
6012         da2=da[5:8,:-2]
6013         self.assertEqual([22, 25, 28],da2.getValues())
6014         try:
6015             da2=da[5:-18,2]
6016         except InterpKernelException as e:
6017             self.assertTrue(True)
6018         else:
6019             self.assertTrue(False)
6020             pass
6021         da2=da[5:5,2]
6022         self.assertEqual([],da2.getValues())
6023         pass
6024
6025     def testSwigGetItem2(self):
6026         da=DataArrayDouble.New()
6027         da.alloc(16,3)
6028         da.rearrange(1)
6029         da.iota(7)
6030         da.rearrange(3)
6031         da.setInfoOnComponent(0,"X [m]")
6032         da.setInfoOnComponent(1,"Y [m]")
6033         da.setInfoOnComponent(2,"Z [km]")
6034         da2=da[5:-1]
6035         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())
6036         da2=da[4]
6037         self.assertEqual([19., 20., 21],da2.getValues())
6038         try:
6039             da2=da[4:17]
6040         except InterpKernelException as e:
6041             self.assertTrue(True)
6042         else:
6043             self.assertTrue(False)
6044             pass
6045         da2=da[5:-2,2]
6046         self.assertEqual([24., 27., 30., 33., 36., 39., 42., 45., 48.],da2.getValues())
6047         da2=da[5:8,:]
6048         self.assertEqual([22., 23., 24., 25., 26., 27., 28., 29., 30.],da2.getValues())
6049         da2=da[:]
6050         self.assertTrue(da2.isEqual(da,1e-12))
6051         da2=da[:,:]
6052         self.assertTrue(da2.isEqual(da,1e-12))
6053         try:
6054             da2=da[:,:,:]
6055         except InterpKernelException as e:
6056             self.assertTrue(True)
6057         else:
6058             self.assertTrue(False)
6059             pass
6060         try:
6061             da2=da[5:8,-2]
6062         except InterpKernelException as e:
6063             self.assertTrue(True)
6064         else:
6065             self.assertTrue(False)
6066             pass
6067         da2=da[5:8,:-2]
6068         self.assertEqual([22., 25., 28.],da2.getValues())
6069         try:
6070             da2=da[5:-18,2]
6071         except InterpKernelException as e:
6072             self.assertTrue(True)
6073         else:
6074             self.assertTrue(False)
6075             pass
6076         da2=da[5:5,2]
6077         self.assertEqual([],da2.getValues())
6078         pass
6079
6080     def testSwigSetItem1(self):
6081         da=DataArrayInt.New()
6082         da.alloc(20,1)
6083         da.iota(7)
6084         da.rearrange(5)
6085         da.setInfoOnComponent(0,"X [m]") ; da.setInfoOnComponent(1,"Y [km]") ; da.setInfoOnComponent(2,"Y [m]")
6086         da.setInfoOnComponent(3,"Z [W]") ; da.setInfoOnComponent(4,"ZZ [km]") ;
6087         da[:,2]=3
6088         self.assertEqual([7, 8, 3, 10, 11, 12, 13, 3, 15, 16, 17, 18, 3, 20, 21, 22, 23, 3, 25, 26],da.getValues())
6089         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6090         da[2]=3
6091         self.assertEqual([7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 3, 3, 3, 3, 3, 22, 23, 24, 25, 26],da.getValues())
6092         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6093         da[[0,3]]=-1
6094         self.assertEqual([-1, -1, -1, -1, -1, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, -1, -1, -1, -1, -1],da.getValues())
6095         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6096         da[:,[1,3,4]]=-3
6097         self.assertEqual([7, -3, 9, -3, -3, 12, -3, 14, -3, -3, 17, -3, 19, -3, -3, 22, -3, 24, -3, -3],da.getValues())
6098         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6099         da2=DataArrayInt.New() ; da2.setValues([0,2,3],3,1)
6100         da[da2]=-7
6101         self.assertEqual([-7, -7, -7, -7, -7, 12, 13, 14, 15, 16, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7],da.getValues())
6102         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6103         da[da2,-2:]=-7
6104         self.assertEqual([7, 8, 9, -7, -7, 12, 13, 14, 15, 16, 17, 18, 19, -7, -7, 22, 23, 24, -7, -7],da.getValues())
6105         # Let's test with DAI right hand side
6106         da1=DataArrayInt.New()
6107         da1.setValues([25,26,27,125,126,127],2,3)
6108         #
6109         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6110         da[-2:,1:4]=da1
6111         self.assertEqual([7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 25, 26, 27, 21, 22, 125, 126, 127, 26],da.getValues())
6112         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6113         da[1:,3]=[225,226,227]
6114         self.assertEqual([7, 8, 9, 10, 11, 12, 13, 14, 225, 16, 17, 18, 19, 226, 21, 22, 23, 24, 227, 26],da.getValues())
6115         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6116         da[1,2:]=[225,226,227]
6117         self.assertEqual([7, 8, 9, 10, 11, 12, 13, 225, 226, 227, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26],da.getValues())
6118         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6119         da[da2,-2:]=[88,99,1010,1111,1212,1313]
6120         self.assertEqual([7, 8, 9, 88, 99, 12, 13, 14, 15, 16, 17, 18, 19, 1010, 1111, 22, 23, 24, 1212, 1313],da.getValues())
6121         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6122         da3=DataArrayInt.New(); da3.setValues([88,99,1010,1111,1212,1313],3,2)
6123         da[da2,-2:]=da3
6124         self.assertEqual([7, 8, 9, 88, 99, 12, 13, 14, 15, 16, 17, 18, 19, 1010, 1111, 22, 23, 24, 1212, 1313],da.getValues())
6125         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6126         da[da2,[0,2]]=da3
6127         self.assertEqual([88, 8, 99, 10, 11, 12, 13, 14, 15, 16, 1010, 18, 1111, 20, 21, 1212, 23, 1313, 25, 26],da.getValues())
6128         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6129         da[da2,0:3:2]=da3
6130         self.assertEqual([88, 8, 99, 10, 11, 12, 13, 14, 15, 16, 1010, 18, 1111, 20, 21, 1212, 23, 1313, 25, 26],da.getValues())
6131         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6132         da[da2,0:3:2]=-8
6133         self.assertEqual([-8, 8, -8, 10, 11, 12, 13, 14, 15, 16, -8, 18, -8, 20, 21, -8, 23, -8, 25, 26],da.getValues())
6134         pass
6135
6136     def testSwigSetItem2(self):
6137         da=DataArrayDouble.New()
6138         da.alloc(20,1)
6139         da.iota(7)
6140         da.rearrange(5)
6141         da.setInfoOnComponent(0,"X [m]") ; da.setInfoOnComponent(1,"Y [km]") ; da.setInfoOnComponent(2,"Y [m]")
6142         da.setInfoOnComponent(3,"Z [W]") ; da.setInfoOnComponent(4,"ZZ [km]") ;
6143         da[:,2]=3.
6144         self.assertEqual([7., 8., 3., 10., 11., 12., 13., 3., 15., 16., 17., 18., 3., 20., 21., 22., 23., 3., 25., 26.],da.getValues())
6145         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6146         da[2]=3.
6147         self.assertEqual([7., 8., 9., 10., 11., 12., 13., 14., 15., 16., 3., 3., 3., 3., 3., 22., 23., 24., 25., 26.],da.getValues())
6148         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6149         da[[0,3]]=-1.
6150         self.assertEqual([-1., -1., -1., -1., -1., 12., 13., 14., 15., 16., 17., 18., 19., 20., 21., -1., -1., -1., -1., -1.],da.getValues())
6151         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6152         da[:,[1,3,4]]=-3.
6153         self.assertEqual([7., -3., 9., -3., -3., 12., -3., 14., -3., -3., 17., -3., 19., -3., -3., 22., -3., 24., -3., -3.],da.getValues())
6154         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6155         da2=DataArrayInt.New() ; da2.setValues([0,2,3],3,1)
6156         da[da2]=-7.
6157         self.assertEqual([-7., -7., -7., -7., -7., 12., 13., 14., 15., 16., -7., -7., -7., -7., -7., -7., -7., -7., -7., -7.],da.getValues())
6158         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6159         da[da2,-2:]=-7
6160         self.assertEqual([7., 8., 9., -7., -7., 12., 13., 14., 15., 16., 17., 18., 19., -7., -7., 22., 23., 24., -7., -7.],da.getValues())
6161         # Let's test with DAI right hand side
6162         da1=DataArrayDouble.New()
6163         da1.setValues([25,26,27,125,126,127],2,3)
6164         #
6165         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6166         da[-2:,1:4]=da1
6167         self.assertEqual([7., 8., 9., 10., 11., 12., 13., 14., 15., 16., 17., 25., 26., 27., 21., 22., 125., 126., 127., 26.],da.getValues())
6168         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6169         da[1:,3]=[225.,226.,227.]
6170         self.assertEqual([7., 8., 9., 10., 11., 12., 13., 14., 225., 16., 17., 18., 19., 226., 21., 22., 23., 24., 227., 26.],da.getValues())
6171         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6172         da[1,2:]=[225,226,227]
6173         self.assertEqual([7., 8., 9., 10., 11., 12., 13., 225., 226., 227., 17., 18., 19., 20., 21., 22., 23., 24., 25., 26.],da.getValues())
6174         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6175         da[da2,-2:]=[88,99,1010,1111,1212,1313]
6176         self.assertEqual([7., 8., 9., 88., 99., 12., 13., 14., 15., 16., 17., 18., 19., 1010., 1111., 22., 23., 24., 1212., 1313.],da.getValues())
6177         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6178         da3=DataArrayDouble.New(); da3.setValues([88,99,1010,1111,1212,1313],3,2)
6179         da[da2,-2:]=da3
6180         self.assertEqual([7., 8., 9., 88., 99., 12., 13., 14., 15., 16., 17., 18., 19., 1010., 1111., 22., 23., 24., 1212., 1313.],da.getValues())
6181         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6182         da[da2,[0,2]]=da3
6183         self.assertEqual([88., 8., 99., 10., 11., 12., 13., 14., 15., 16., 1010., 18., 1111., 20., 21., 1212., 23., 1313., 25., 26.],da.getValues())
6184         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6185         da[da2,0:3:2]=da3
6186         self.assertEqual([88., 8., 99., 10., 11., 12., 13., 14., 15., 16., 1010., 18., 1111., 20., 21., 1212., 23., 1313., 25., 26.],da.getValues())
6187         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6188         da[da2,0:3:2]=-8.
6189         self.assertEqual([-8., 8., -8., 10., 11., 12., 13., 14., 15., 16., -8., 18., -8., 20., 21., -8., 23., -8., 25., 26.],da.getValues())
6190         pass
6191
6192     def testSwigDADOp(self):
6193         da=DataArrayDouble.New()
6194         da.alloc(12,1)
6195         da.iota(7.)
6196         da1=DataArrayDouble.New()
6197         da1.alloc(12,1)
6198         da1.iota(8.)
6199         da2=da+da1
6200         self.assertEqual([15., 17., 19., 21., 23., 25., 27., 29., 31., 33., 35., 37.],da2.getValues())
6201         da2=da+3
6202         da3=3+da
6203         self.assertTrue(da2.isEqual(da3,1e-12))
6204         da2=da-1.
6205         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())
6206         da2=1-da
6207         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())
6208         da2=da*3
6209         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())
6210         da2=3.*da
6211         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())
6212         da2=da*da1
6213         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())
6214         da2=da/4.
6215         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())
6216         da3=4./da
6217         da4=da3*da2
6218         self.assertTrue(da4.isUniform(1.,1e-12))
6219         st1=da.getHiddenCppPointer()
6220         da+=1
6221         st2=da.getHiddenCppPointer()
6222         self.assertEqual(st1,st2)
6223         self.assertTrue(da.isEqual(da1,1e-12))
6224         da-=8
6225         st2=da.getHiddenCppPointer()
6226         self.assertEqual(st1,st2)
6227         self.assertEqual(range(12),da.getValues())
6228         da+=da1
6229         st2=da.getHiddenCppPointer()
6230         self.assertEqual(st1,st2)
6231         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())
6232         da*=0.5
6233         st2=da.getHiddenCppPointer()
6234         self.assertEqual(st1,st2)
6235         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())
6236         da*=da1
6237         st2=da.getHiddenCppPointer()
6238         self.assertEqual(st1,st2)
6239         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())
6240         da/=da1
6241         self.assertEqual(st1,st2)
6242         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())
6243         da/=2
6244         st2=da.getHiddenCppPointer()
6245         self.assertEqual(st1,st2)
6246         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())
6247         da.rearrange(3)
6248         da5=DataArrayDouble.New()
6249         da5.setValues([5.,4.,3.,2.],4,1)
6250         da*=da5 # it works with unmathing number of compo
6251         st2=da.getHiddenCppPointer()
6252         self.assertEqual(st1,st2)
6253         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())
6254         #
6255         da.alloc(30,1)
6256         da.iota(7.)
6257         da.rearrange(3)
6258         ids=DataArrayInt.New()
6259         ids.setValues([3,4,7],3,1)
6260         da[ids,:]=[5.,8.,9.]
6261         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())
6262         #
6263         da.rearrange(1) ; da.iota(7) ; da.rearrange(3)
6264         da[ids,[1,2]]=[5,8]
6265         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())
6266         pass
6267
6268     def testSwigDAIOp(self):
6269         da=DataArrayInt.New()
6270         da.alloc(12,1)
6271         da.iota(7)
6272         da1=DataArrayInt.New()
6273         da1.alloc(12,1)
6274         da1.iota(8)
6275         da2=da+da1
6276         self.assertEqual([15,17,19,21,23,25,27,29,31,33,35,37],da2.getValues())
6277         da2=da+3
6278         da3=3+da
6279         self.assertTrue(da2.isEqual(da3))
6280         da2=da-1
6281         self.assertEqual([6,7,8,9,10,11,12,13,14,15,16,17],da2.getValues())
6282         da2=1-da
6283         self.assertEqual([-6,-7,-8,-9,-10,-11,-12,-13,-14,-15,-16,-17],da2.getValues())
6284         da2=da*3
6285         self.assertEqual([21,24,27,30,33,36,39,42,45,48,51,54.0],da2.getValues())
6286         da2=3*da
6287         self.assertEqual([21,24,27,30,33,36,39,42,45,48,51,54.0],da2.getValues())
6288         da2=da*da1
6289         self.assertEqual([56,72,90,110,132,156,182,210,240,272,306,342.0],da2.getValues())
6290         da2=da/4
6291         self.assertEqual([1,2,2,2,2,3,3,3,3,4,4,4],da2.getValues())
6292         da3=4/da
6293         da4=da3*da2
6294         self.assertTrue(da4.isUniform(0))
6295         st1=da.getHiddenCppPointer()
6296         da+=1
6297         st2=da.getHiddenCppPointer()
6298         self.assertEqual(st1,st2)
6299         self.assertTrue(da.isEqual(da1))
6300         da-=8
6301         st2=da.getHiddenCppPointer()
6302         self.assertEqual(st1,st2)
6303         self.assertEqual(range(12),da.getValues())
6304         da+=da1
6305         st2=da.getHiddenCppPointer()
6306         self.assertEqual(st1,st2)
6307         self.assertEqual([8,10,12,14,16,18,20,22,24,26,28,30],da.getValues())
6308         da/=2
6309         st2=da.getHiddenCppPointer()
6310         self.assertEqual(st1,st2)
6311         self.assertEqual([4,5,6,7,8,9,10,11,12,13,14,15],da.getValues())
6312         da*=da1
6313         st2=da.getHiddenCppPointer()
6314         self.assertEqual(st1,st2)
6315         self.assertEqual([32,45,60,77,96,117,140,165,192,221,252,285],da.getValues())
6316         da/=da1
6317         self.assertEqual(st1,st2)
6318         self.assertEqual([4,5,6,7,8,9,10,11,12,13,14,15],da.getValues())
6319         da/=2
6320         st2=da.getHiddenCppPointer()
6321         self.assertEqual(st1,st2)
6322         self.assertEqual([2,2, 3,3, 4,4, 5,5, 6,6, 7,7],da.getValues())
6323         da.rearrange(3)
6324         da5=DataArrayInt.New()
6325         da5.setValues([5,4,3,2],4,1)
6326         da*=da5 # it works with unmathing number of compo
6327         st2=da.getHiddenCppPointer()
6328         self.assertEqual(st1,st2)
6329         self.assertEqual([10,10, 15,12,16,16,15,15, 18,12,14,14],da.getValues())
6330         da%=6
6331         st2=da.getHiddenCppPointer()
6332         self.assertEqual(st1,st2)
6333         self.assertEqual([4,4,3,0,4,4,3,3,0,0,2,2],da.getValues())
6334         #
6335         da.alloc(30,1)
6336         da.iota(7)
6337         da.rearrange(3)
6338         ids=DataArrayInt.New()
6339         ids.setValues([3,4,7],3,1)
6340         da[ids,:]=[5,8,9]
6341         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())
6342         #
6343         da.rearrange(1) ; da.iota(7) ; da.rearrange(3)
6344         da[ids,[1,2]]=[5,8]
6345         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())
6346         pass
6347
6348     def testSwigDAIOp2(self):
6349         da=DataArrayInt.New()
6350         st=da.getHiddenCppPointer()
6351         da.alloc(10,3)
6352         da.rearrange(1)
6353         da.iota(0)
6354         da.rearrange(3)
6355         da[:,1]+=4
6356         da[-2:,2]+=10
6357         da[-2:,2]+=10
6358         da[:,2]+=da[:,0]
6359         da[da[0],:]=7
6360         self.assertEqual(st,da.getHiddenCppPointer())
6361         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])
6362         pass
6363
6364     def testSwigDAIOp3(self):
6365         da=DataArrayInt.New()
6366         self.assertRaises(InterpKernelException,da.__len__)
6367         self.assertRaises(InterpKernelException,da.__int__)
6368         for elt in da:
6369             self.assertTrue(False)
6370             pass
6371         da.alloc(12,3)
6372         da.rearrange(1) ; da.fillWithZero()
6373         l1=list(da)
6374         self.assertEqual(36,len(da));
6375         da.rearrange(3)
6376         tmp=da[0]
6377         self.assertRaises(InterpKernelException,tmp.__int__)
6378         self.assertEqual(12,len(da));
6379         l=list(da)
6380         for elt in enumerate(l):
6381             elt[1][2]=elt[0]
6382             pass
6383         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]
6384         self.assertEqual(ref,da.getValues());
6385         da.rearrange(1)
6386         l=[int(elt) for elt in l1]
6387         self.assertEqual(ref,da.getValues());
6388         self.assertEqual(11,int(da[-1:]))
6389         pass
6390
6391     def testSwigDADOp3(self):
6392         da=DataArrayDouble.New()
6393         self.assertRaises(InterpKernelException,da.__len__)
6394         self.assertRaises(InterpKernelException,da.__float__)
6395         for elt in da:
6396             self.assertTrue(False)
6397             pass
6398         da.alloc(12,3)
6399         da.rearrange(1) ; da.fillWithZero()
6400         l1=list(da)
6401         self.assertEqual(36,len(da));
6402         da.rearrange(3)
6403         tmp=da[0]
6404         self.assertRaises(InterpKernelException,tmp.__float__)
6405         self.assertEqual(12,len(da));
6406         l=list(da)
6407         for elt in enumerate(l):
6408             elt[1][2]=elt[0]
6409             pass
6410         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.]
6411         self.assertEqual(ref,da.getValues());
6412         da.rearrange(1)
6413         l=[float(elt) for elt in l1]
6414         self.assertEqual(ref,da.getValues());
6415         self.assertEqual(11.,float(da[-1:]))
6416         pass
6417
6418     def testSwigDataArrayIntIterator1(self):
6419         da=DataArrayInt.New()
6420         da.alloc(12,1)
6421         da.iota(2)
6422         da.rearrange(3)
6423         # __getitem__ testing
6424         li=[]
6425         for it in da:
6426             li+=it[1:]
6427             pass
6428         self.assertEqual([3, 4, 6, 7, 9, 10, 12, 13],li)
6429         li=[]
6430         for it in da:
6431             li+=[it[-1]]
6432             pass
6433         self.assertEqual([4, 7, 10, 13],li)
6434         li=[]
6435         for it in da:
6436             li+=it[[2,1,0]]
6437             pass
6438         self.assertEqual([4, 3, 2, 7, 6, 5, 10, 9, 8, 13, 12, 11],li)
6439         # __setitem__ testing
6440         da3=da.deepCpy()
6441         da2=DataArrayInt.New()
6442         da2.alloc(12,1)
6443         da2.iota(2002)
6444         da2.rearrange(3)
6445         it2=da2.__iter__()
6446         i=0
6447         for it in da:
6448             pt=it2.next()
6449             it[:]=pt
6450             pass
6451         self.assertTrue(da.isEqual(da2))
6452         da=da3
6453         da3=da.deepCpy()
6454         #
6455         for it in da:
6456             it[:]=5
6457             pass
6458         da.rearrange(1)
6459         self.assertTrue(da.isUniform(5))
6460         da=da3
6461         da3=da.deepCpy()
6462         #
6463         for it in da:
6464             it[:]=[8,9,12]
6465             pass
6466         self.assertEqual([8, 9, 12, 8, 9, 12, 8, 9, 12, 8, 9, 12],da.getValues())
6467         da=da3
6468         da3=da.deepCpy()
6469         #
6470         for it in da:
6471             it[2]=[7]
6472             pass
6473         self.assertEqual([2, 3, 7, 5, 6, 7, 8, 9, 7, 11, 12, 7],da.getValues())
6474         pass
6475
6476     def testSwigDataArrayDoubleIterator1(self):
6477         da=DataArrayDouble.New()
6478         da.alloc(12,1)
6479         da.iota(2)
6480         da.rearrange(3)
6481         # __getitem__ testing
6482         li=[]
6483         for it in da:
6484             li+=it[1:]
6485             pass
6486         self.assertEqual([3, 4, 6, 7, 9, 10, 12, 13],li)
6487         li=[]
6488         for it in da:
6489             li+=[it[-1]]
6490             pass
6491         self.assertEqual([4, 7, 10, 13],li)
6492         li=[]
6493         for it in da:
6494             li+=it[[2,1,0]]
6495             pass
6496         self.assertEqual([4, 3, 2, 7, 6, 5, 10, 9, 8, 13, 12, 11],li)
6497         # __setitem__ testing
6498         da3=da.deepCpy()
6499         da2=DataArrayDouble.New()
6500         da2.alloc(12,1)
6501         da2.iota(2002)
6502         da2.rearrange(3)
6503         it2=da2.__iter__()
6504         i=0
6505         for it in da:
6506             pt=it2.next()
6507             it[:]=pt
6508             pass
6509         self.assertTrue(da.isEqual(da2,1e-12))
6510         da=da3
6511         da3=da.deepCpy()
6512         #
6513         for it in da:
6514             it[:]=5
6515             pass
6516         da.rearrange(1)
6517         self.assertTrue(da.isUniform(5,1e-12))
6518         da=da3
6519         da3=da.deepCpy()
6520         #
6521         for it in da:
6522             it[:]=[8,9,12]
6523             pass
6524         self.assertEqual([8, 9, 12, 8, 9, 12, 8, 9, 12, 8, 9, 12],da.getValues())
6525         da=da3
6526         da3=da.deepCpy()
6527         #
6528         for it in da:
6529             it[2]=[7]
6530             pass
6531         self.assertEqual([2, 3, 7, 5, 6, 7, 8, 9, 7, 11, 12, 7],da.getValues())
6532         pass
6533
6534     def testSwigUMeshIterator1(self):
6535         m=MEDCouplingDataForTest.build2DTargetMesh_1()
6536         li1=[]
6537         li2=[]
6538         for cell in m:
6539             li1+=cell.getAllConn()[1:]
6540             li2+=[cell.getType()]
6541             pass
6542         self.assertEqual(li1,[0, 3, 4, 1, 1, 4, 2, 4, 5, 2, 6, 7, 4, 3, 7, 8, 5, 4])
6543         self.assertEqual(li2,[4, 3, 3, 4, 4])
6544         pass
6545
6546     def testSwigUMeshIterator2(self):
6547         m=MEDCouplingDataForTest.build2DTargetMesh_1()
6548         self.assertRaises(InterpKernelException,m.cellsByType);
6549         m.rearrange2ConsecutiveCellTypes()
6550         li1=[]
6551         li2=[]
6552         li3=[]
6553         for cellsByType in m.cellsByType():
6554             li1.append(cellsByType.getType())
6555             li2.append(cellsByType.getNumberOfElems())
6556             temp=[]
6557             for cell in cellsByType:
6558                 t=[None,None]
6559                 t[0]=cell.getType()
6560                 t[1]=cell.getAllConn()[1:]
6561                 temp.append(t)
6562                 pass
6563             li3.append(temp)
6564             pass
6565         self.assertEqual(li1,[4, 3])
6566         self.assertEqual(li2,[3, 2])
6567         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)]]])
6568         pass
6569
6570     def testDAIAggregateMulti1(self):
6571         a=DataArrayInt.New()
6572         a.setValues(range(4),2,2)
6573         a.setName("aa")
6574         b=DataArrayInt.New()
6575         b.setValues(range(6),3,2)
6576         c=DataArrayInt.Aggregate([a,b])
6577         self.assertEqual(range(4)+range(6),c.getValues())
6578         self.assertEqual("aa",c.getName())
6579         self.assertEqual(5,c.getNumberOfTuples())
6580         self.assertEqual(2,c.getNumberOfComponents())
6581         pass
6582
6583     def testMergeUMeshes2(self):
6584         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6585         m2=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6586         m3=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6587         #
6588         vec1=[0,2,3]
6589         m2_2=m2.buildPartOfMySelf(vec1,False);
6590         vec2=[1,1]
6591         m3_2=m3.buildPartOfMySelf(vec2,False);
6592         #
6593         ms=[m1,m2_2,m3_2];
6594         #
6595         self.assertRaises(InterpKernelException,MEDCouplingUMesh.MergeUMeshes,ms+[None]);
6596         self.assertRaises(InterpKernelException,MEDCouplingUMesh.MergeUMeshes,ms+[3.4])
6597         m4=MEDCouplingUMesh.MergeUMeshes(ms);
6598         m4.checkCoherency();
6599         self.assertEqual(10,m4.getNumberOfCells());
6600         self.assertEqual(20,m4.getNumberOfNodes());
6601         self.assertEqual(45,m4.getMeshLength());
6602         m4bis=MEDCouplingMesh.MergeMeshes(ms);
6603         self.assertTrue(m4.isEqual(m4bis,1e-12))
6604         del m4bis
6605         #
6606         vec3=[0,1,2,3,4]
6607         m4_1=m4.buildPartOfMySelf(vec3,False);
6608         m4_1.setName(m1.getName());
6609         self.assertTrue(m4_1.isEqual(m1,1e-12));
6610         #
6611         vec4=[5,6,7]
6612         m4_2=m4.buildPartOfMySelf(vec4,False);
6613         cellCor,nodeCor=m4_2.checkGeoEquivalWith(m2_2,10,1e-12);
6614         #
6615         vec5=[8,9]
6616         m4_3=m4.buildPartOfMySelf(vec5,False);
6617         self.assertEqual(2,m4_3.getNumberOfCells());
6618         self.assertEqual(3,m4_3.getNumberOfNodes());
6619         m3_2.zipCoords();
6620         m4_3.setName(m3_2.getName());
6621         self.assertTrue(m4_3.isEqual(m3_2,1e-12));
6622         #
6623         pass
6624
6625     def testBuild0DMeshFromCoords1(self):
6626         sourceCoords=[-0.3,-0.3,0., 0.7,-0.3,0., -0.3,0.7,0., 0.7,0.7,0.]
6627         coo=DataArrayDouble.New();
6628         coo.setValues(sourceCoords,4,3);
6629         coo.setName("My0D");
6630         m=MEDCouplingUMesh.Build0DMeshFromCoords(coo);
6631         m.checkCoherency();
6632         self.assertEqual(4,m.getNumberOfNodes());
6633         self.assertEqual(4,m.getNumberOfCells());
6634         self.assertEqual(3,m.getSpaceDimension());
6635         self.assertEqual(0,m.getMeshDimension());
6636         types1=m.getAllTypes();
6637         self.assertEqual([NORM_POINT1],types1);
6638         for i in xrange(4):
6639             conn=m.getNodeIdsOfCell(i);
6640             self.assertEqual([i],conn);
6641             self.assertTrue(NORM_POINT1==m.getTypeOfCell(i));
6642             pass
6643         self.assertEqual(m.getName(),"My0D");
6644         pass
6645
6646     def testDescriptionInMeshTimeUnit1(self):
6647         text1="totoTTEDD";
6648         m=MEDCouplingDataForTest.build2DTargetMesh_1();
6649         m.setDescription(text1);
6650         self.assertEqual(m.getDescription(),text1);
6651         m2=m.deepCpy();
6652         self.assertTrue(m.isEqual(m2,1e-12));
6653         self.assertEqual(m2.getDescription(),text1);
6654         m2.setDescription("ggg");
6655         self.assertTrue(not m.isEqual(m2,1e-12));
6656         #
6657         f=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
6658         f.setTimeUnit(text1);
6659         self.assertEqual(f.getTimeUnit(),text1);
6660         f2=f.deepCpy();
6661         self.assertEqual(f2.getTimeUnit(),text1);
6662         #
6663         pass
6664
6665     def testMultiFields1(self):
6666         mfs=MEDCouplingDataForTest.buildMultiFields_1();
6667         ms=mfs.getMeshes();
6668         dms,refs=mfs.getDifferentMeshes()
6669         das=mfs.getArrays();
6670         das2,refs2=mfs.getDifferentArrays()
6671         self.assertEqual(5,len(mfs.getFields()))
6672         self.assertEqual(1,len(mfs.getFields()[0].getArrays()));
6673         self.assertEqual(2,len(mfs.getFields()[1].getArrays()));
6674         self.assertEqual(1,len(mfs.getFields()[2].getArrays()));
6675         self.assertEqual(1,len(mfs.getFields()[3].getArrays()));
6676         self.assertEqual(1,len(mfs.getFields()[4].getArrays()));
6677         self.assertEqual(5,len(ms));
6678         self.assertEqual(2,len(dms));
6679         self.assertEqual(6,len(das));
6680         self.assertEqual(5,len(das2));
6681         mfs2=mfs.deepCpy();
6682         self.assertTrue(mfs.isEqual(mfs2,1e-12,1e-12))
6683         pass
6684
6685     def testFieldOverTime1(self):
6686         fs=MEDCouplingDataForTest.buildMultiFields_2();
6687         self.assertRaises(InterpKernelException,MEDCouplingFieldOverTime.New,fs);
6688         f4bis=fs[4].buildNewTimeReprFromThis(ONE_TIME,False);
6689         fs[4]=f4bis;
6690         self.assertRaises(InterpKernelException,MEDCouplingFieldOverTime.New,fs);
6691         f4bis.setTime(2.7,20,21);
6692         fot=MEDCouplingFieldOverTime.New(fs);
6693         dt=fot.getDefinitionTimeZone();
6694         hs=dt.getHotSpotsTime();
6695         self.assertEqual(6,len(hs));
6696         expected1=[0.2,0.7,1.2,1.35,1.7,2.7]
6697         for i in xrange(6):
6698             self.assertAlmostEqual(expected1[i],hs[i],12);
6699             pass
6700         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(0.2);
6701         self.assertEqual(0,meshId);
6702         self.assertEqual(0,arrId);
6703         self.assertEqual(0,arrIdInField);
6704         self.assertEqual(0,fieldId);
6705         #
6706         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(0.7);
6707         self.assertEqual(0,meshId);
6708         self.assertEqual(1,arrId);
6709         self.assertEqual(0,arrIdInField);
6710         self.assertEqual(1,fieldId);
6711         #
6712         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeLeft(1.2);#**** WARNING left here
6713         self.assertEqual(0,meshId);
6714         self.assertEqual(2,arrId);
6715         self.assertEqual(1,arrIdInField);
6716         self.assertEqual(1,fieldId);
6717         #
6718         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(1.2);#**** WARNING right again here
6719         self.assertEqual(1,meshId);
6720         self.assertEqual(3,arrId);
6721         self.assertEqual(0,arrIdInField);
6722         self.assertEqual(2,fieldId);
6723         #
6724         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(1.35);
6725         self.assertEqual(1,meshId);
6726         self.assertEqual(3,arrId);
6727         self.assertEqual(0,arrIdInField);
6728         self.assertEqual(2,fieldId);
6729         #
6730         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(1.7);
6731         self.assertEqual(0,meshId);
6732         self.assertEqual(3,arrId);
6733         self.assertEqual(0,arrIdInField);
6734         self.assertEqual(3,fieldId);
6735         #
6736         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(2.7);
6737         self.assertEqual(1,meshId);
6738         self.assertEqual(4,arrId);
6739         self.assertEqual(0,arrIdInField);
6740         self.assertEqual(4,fieldId);
6741         #
6742         dt2=MEDCouplingDefinitionTime();
6743         self.assertTrue(not dt2.isEqual(dt));
6744         dt2.assign(dt);
6745         dt2.assign(dt);#to check memory management
6746         self.assertTrue(dt2.isEqual(dt));
6747         #
6748         dt3=MEDCouplingDefinitionTime();
6749         #
6750         pass
6751
6752     def testDAICheckAndPreparePermutation1(self):
6753         vals1=[9,10,0,6,4,11,3,7];
6754         expect1=[5,6,0,3,2,7,1,4];
6755         vals2=[9,10,0,6,10,11,3,7];
6756         da=DataArrayInt.New();
6757         da.setValues(vals1,8,1);
6758         da2=da.checkAndPreparePermutation();
6759         self.assertEqual(8,da2.getNumberOfTuples());
6760         self.assertEqual(1,da2.getNumberOfComponents());
6761         for i in xrange(8):
6762             self.assertEqual(expect1[i],da2.getIJ(i,0));
6763             pass
6764         #
6765         da=DataArrayInt.New();
6766         da.alloc(8,1);
6767         da.iota(0);
6768         da2=da.checkAndPreparePermutation();
6769         self.assertEqual(8,da2.getNumberOfTuples());
6770         self.assertEqual(1,da2.getNumberOfComponents());
6771         self.assertTrue(da2.isIdentity());
6772         #
6773         da=DataArrayInt.New();
6774         da.alloc(8,1);
6775         da.setValues(vals2,8,1);
6776         self.assertRaises(InterpKernelException,da.checkAndPreparePermutation);
6777         pass
6778
6779     def testDAIChangeSurjectiveFormat1(self):
6780         vals1=[0,3,2,3,2,2,1,2]
6781         expected1=[0,1,2,6,8]
6782         expected2=[0,  6,  2,4,5,7,  1,3]
6783         da=DataArrayInt.New();
6784         da.setValues(vals1,8,1);
6785         #
6786         da2,da2I=da.changeSurjectiveFormat(4);
6787         self.assertEqual(5,da2I.getNumberOfTuples());
6788         self.assertEqual(8,da2.getNumberOfTuples());
6789         self.assertEqual(expected1,da2I.getValues());
6790         self.assertEqual(expected2,da2.getValues());
6791         #
6792         self.assertRaises(InterpKernelException,da.changeSurjectiveFormat,3);
6793         #
6794         pass
6795
6796     def testUMeshGetCellIdsLyingOnNodes1(self):
6797         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6798         nodeIds1=[1,2,3,4,6]
6799         nodeIds2=[6,7]
6800         da=m.getCellIdsLyingOnNodes(nodeIds1,True);
6801         self.assertEqual(1,da.getNumberOfTuples());
6802         self.assertEqual(1,da.getNumberOfComponents());
6803         self.assertEqual(1,da.getIJ(0,0));
6804         da2=DataArrayInt.New()
6805         da2.setValues(nodeIds2,2,1)
6806         da=m.getCellIdsLyingOnNodes(da2,False);
6807         self.assertEqual(2,da.getNumberOfTuples());
6808         self.assertEqual(1,da.getNumberOfComponents());
6809         self.assertEqual(3,da.getIJ(0,0));
6810         self.assertEqual(4,da.getIJ(1,0));
6811         pass
6812
6813     def testUMeshFindCellIdsOnBoundary1(self):
6814         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6815         da5=m.findCellIdsOnBoundary();
6816         self.assertEqual(5,da5.getNumberOfTuples());
6817         self.assertTrue(da5.isIdentity());
6818         pass
6819
6820     def testMeshSetTime1(self):
6821         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6822         m2=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6823         #
6824         self.assertTrue(m1.isEqual(m2,1e-12));
6825         m1.setTime(3.14,6,7);
6826         tmp3,tmp1,tmp2=m1.getTime();
6827         self.assertEqual(6,tmp1);
6828         self.assertEqual(7,tmp2);
6829         self.assertAlmostEqual(3.14,tmp3,12);
6830         self.assertTrue(not m1.isEqual(m2,1e-12));
6831         m2.setTime(3.14,6,7);
6832         self.assertTrue(m1.isEqual(m2,1e-12));
6833         m1.setTimeUnit("ms");
6834         self.assertTrue(m1.getTimeUnit()=="ms");
6835         m1.setTimeUnit("us");
6836         self.assertTrue(m1.getTimeUnit()=="us");
6837         self.assertTrue(not m1.isEqual(m2,1e-12));
6838         m2.setTimeUnit("us");
6839         self.assertTrue(m1.isEqual(m2,1e-12));
6840         m2.setTime(3.14,6,8);
6841         self.assertTrue(not m1.isEqual(m2,1e-12));
6842         m2.setTime(3.14,7,7);
6843         self.assertTrue(not m1.isEqual(m2,1e-12));
6844         m2.setTime(3.15,6,7);
6845         self.assertTrue(not m1.isEqual(m2,1e-12));
6846         #
6847         m1.setTime(10.34,55,12);
6848         m3=m1.deepCpy();
6849         self.assertTrue(m1.isEqual(m3,1e-12));
6850         tmp3,tmp1,tmp2=m3.getTime();
6851         self.assertEqual(55,tmp1);
6852         self.assertEqual(12,tmp2);
6853         self.assertAlmostEqual(10.34,tmp3,12);
6854         #
6855         # testing CMesh
6856         coo1=[0.,1.,2.,3.5]
6857         a=DataArrayDouble.New();
6858         a.setValues(coo1,4,1);
6859         b=MEDCouplingCMesh.New();
6860         b.setCoordsAt(0,a);
6861         #
6862         b.setTime(5.67,8,100);
6863         tmp3,tmp1,tmp2=b.getTime();
6864         self.assertEqual(8,tmp1);
6865         self.assertEqual(100,tmp2);
6866         self.assertAlmostEqual(5.67,tmp3,12);
6867         c=b.deepCpy();
6868         self.assertTrue(c.isEqual(b,1e-12));
6869         tmp3,tmp1,tmp2=c.getTime();
6870         self.assertEqual(8,tmp1);
6871         self.assertEqual(100,tmp2);
6872         self.assertAlmostEqual(5.67,tmp3,12);
6873         pass
6874
6875     def testApplyFuncTwo1(self):
6876         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6877         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
6878         f1.setMesh(m1);
6879         #
6880         vals=[1.,11.,21.,2.,12.,22.,3.,13.,23.,4.,14.,24.,5.,15.,25.]
6881         da=DataArrayDouble.New();
6882         da.setValues(vals,5,3);
6883         f1.setArray(da);
6884         #
6885         self.assertRaises(InterpKernelException,da.applyFunc2,1,"y+z");
6886         da.setInfoOnComponent(0,"x [m]");
6887         da.setInfoOnComponent(1,"y [mm]");
6888         da.setInfoOnComponent(2,"z [km]");
6889
6890         self.assertRaises(InterpKernelException, da.applyFunc2, 1, "x+y+zz+zzz");
6891         self.assertRaises(InterpKernelException, da.applyFunc2, 1, "toto(x+y)");
6892         self.assertRaises(InterpKernelException, da.applyFunc2, 1, "x/0");
6893
6894         da2=da.applyFunc2(1,"y+z");
6895         self.assertEqual(1,da2.getNumberOfComponents());
6896         self.assertEqual(5,da2.getNumberOfTuples());
6897         expected1=[32.,34.,36.,38.,40.]
6898         for i in xrange(5):
6899             self.assertAlmostEqual(expected1[i],da2.getIJ(0,i),12);
6900             pass
6901         da2=da.applyFunc(1,"y+z");
6902         expected2=[12.,14.,16.,18.,20.]
6903         for i in xrange(5):
6904             self.assertAlmostEqual(expected2[i],da2.getIJ(0,i),12);
6905             pass
6906         #
6907         self.assertEqual(3,f1.getNumberOfComponents());
6908         self.assertEqual(5,f1.getNumberOfTuples());
6909         f1.applyFunc2(1,"y+z");
6910         self.assertEqual(1,f1.getNumberOfComponents());
6911         self.assertEqual(5,f1.getNumberOfTuples());
6912         for i in xrange(5):
6913             self.assertAlmostEqual(expected1[i],f1.getArray().getIJ(0,i),12);
6914             pass
6915         #
6916         pass
6917
6918     def testApplyFuncThree1(self):
6919         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6920         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
6921         f1.setMesh(m1);
6922         #
6923         vals=[1.,11.,21.,2.,12.,22.,3.,13.,23.,4.,14.,24.,5.,15.,25.]
6924         da=DataArrayDouble.New();
6925         da.setValues(vals,5,3);
6926         f1.setArray(da);
6927         #
6928         vs=3*[None];
6929         vs[0]="x"; vs[1]="Y"; vs[2]="z";
6930         self.assertRaises(InterpKernelException, da.applyFunc3, 1, vs, "y+z");
6931         self.assertRaises(InterpKernelException, da.applyFunc3, 1, vs, "x+Y+z+zz+zzz");
6932         self.assertRaises(InterpKernelException, da.applyFunc3, 1, vs, "x/0");
6933         vs[1]="y";
6934         da2=da.applyFunc3(1,vs,"y+z");
6935         expected1=[32.,34.,36.,38.,40.]
6936         for i in xrange(5):
6937             self.assertAlmostEqual(expected1[i],da2.getIJ(0,i),12);
6938             pass
6939         self.assertRaises(InterpKernelException, da.applyFunc3, 1, ["x","y","z","a"],"x+a")
6940         f1.setArray(da);
6941         self.assertEqual(3,f1.getNumberOfComponents());
6942         self.assertEqual(5,f1.getNumberOfTuples());
6943         f1.applyFunc3(1,vs,"y+z");
6944         self.assertEqual(1,f1.getNumberOfComponents());
6945         self.assertEqual(5,f1.getNumberOfTuples());
6946         for i in xrange(5):
6947             self.assertAlmostEqual(expected1[i],f1.getArray().getIJ(0,i),12);
6948             pass
6949         pass
6950
6951     def testFillFromAnalyticTwo1(self):
6952         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6953         m1.setTime(3.4,5,6); m1.setTimeUnit("us");
6954         self.assertRaises(InterpKernelException,m1.fillFromAnalytic2,ON_NODES,1,"y+z");
6955         m1.getCoords().setInfoOnComponent(0,"x [m]");
6956         m1.getCoords().setInfoOnComponent(1,"y");
6957         m1.getCoords().setInfoOnComponent(2,"z");
6958         f1=m1.fillFromAnalytic2(ON_NODES,1,"y+z");
6959         self.assertAlmostEqual(3.4,f1.getTime()[0],12) ; self.assertEqual(5,f1.getTime()[1]) ; self.assertEqual(6,f1.getTime()[2])
6960         self.assertEqual("us",f1.getTimeUnit())
6961         self.assertEqual(1,f1.getNumberOfComponents());
6962         self.assertEqual(9,f1.getNumberOfTuples());
6963         expected1=[0.2, 0.7, 1.2, 0.7, 1.2, 1.7, 1.2, 1.7, 2.2]
6964         for i in xrange(9):
6965             self.assertAlmostEqual(expected1[i],f1.getArray().getIJ(0,i),12);
6966             pass
6967         pass
6968
6969     def testFillFromAnalyticThree1(self):
6970         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6971         m1.setTime(3.4,5,6); m1.setTimeUnit("us");
6972         vs=3*[None];
6973         vs[0]="x"; vs[1]="Y"; vs[2]="z";
6974         self.assertRaises(InterpKernelException,m1.fillFromAnalytic3,ON_NODES,1,vs,"y+z");
6975         vs[1]="y";
6976         f1=m1.fillFromAnalytic3(ON_NODES,1,vs,"y+z");
6977         self.assertAlmostEqual(3.4,f1.getTime()[0],12) ; self.assertEqual(5,f1.getTime()[1]) ; self.assertEqual(6,f1.getTime()[2])
6978         self.assertEqual("us",f1.getTimeUnit())
6979         self.assertEqual(1,f1.getNumberOfComponents());
6980         self.assertEqual(9,f1.getNumberOfTuples());
6981         expected1=[0.2, 0.7, 1.2, 0.7, 1.2, 1.7, 1.2, 1.7, 2.2]
6982         for i in xrange(9):
6983             self.assertAlmostEqual(expected1[i],f1.getArray().getIJ(0,i),12);
6984             pass
6985         pass
6986
6987     def testDAUnitVar1(self):
6988         da=DataArrayDouble.New();
6989         da.alloc(1,3);
6990         da.setInfoOnComponent(0,"XPS [m]");
6991         st1=da.getVarOnComponent(0);
6992         self.assertTrue(st1=="XPS");
6993         st2=da.getUnitOnComponent(0);
6994         self.assertTrue(st2=="m");
6995         #
6996         da.setInfoOnComponent(0,"XPS         [m]");
6997         st1=da.getVarOnComponent(0);
6998         self.assertTrue(st1=="XPS");
6999         st2=da.getUnitOnComponent(0);
7000         self.assertTrue(st2=="m");
7001         #
7002         da.setInfoOnComponent(0,"XPP         [m]");
7003         st1=da.getVarOnComponent(0);
7004         self.assertTrue(st1=="XPP");
7005         st2=da.getUnitOnComponent(0);
7006         self.assertTrue(st2=="m");
7007         #
7008         da.setInfoOnComponent(0,"XPP kdep  kefer   [ m  ]");
7009         st1=da.getVarOnComponent(0);
7010         self.assertTrue(st1=="XPP kdep  kefer");
7011         st2=da.getUnitOnComponent(0);
7012         self.assertTrue(st2==" m  ");
7013         #
7014         da.setInfoOnComponent(0,"     XPP k[  dep  k]efer   [ m^ 2/s^3*kJ  ]");
7015         st1=da.getVarOnComponent(0);
7016         self.assertTrue(st1=="     XPP k[  dep  k]efer");
7017         st2=da.getUnitOnComponent(0);
7018         self.assertTrue(st2==" m^ 2/s^3*kJ  ");
7019         #
7020         da.setInfoOnComponent(0,"     XPP kefer   ");
7021         st1=da.getVarOnComponent(0);
7022         self.assertTrue(st1=="     XPP kefer   ");
7023         st2=da.getUnitOnComponent(0);
7024         self.assertTrue(st2=="");
7025         #
7026         da.setInfoOnComponent(0,"temperature( bof)");
7027         st1=da.getVarOnComponent(0);
7028         self.assertTrue(st1=="temperature( bof)");
7029         st2=da.getUnitOnComponent(0);
7030         self.assertTrue(st2=="");
7031         #
7032         da.setInfoOnComponent(0,"kkk [m]");
7033         da.setInfoOnComponent(1,"ppp   [m^2/kJ]");
7034         da.setInfoOnComponent(2,"abcde   [MW/s]");
7035         #
7036         vs=da.getVarsOnComponent();
7037         self.assertEqual(3,len(vs));
7038         self.assertTrue(vs[0]=="kkk");
7039         self.assertTrue(vs[1]=="ppp");
7040         self.assertTrue(vs[2]=="abcde");
7041         vs=da.getUnitsOnComponent();
7042         self.assertEqual(3,len(vs));
7043         self.assertTrue(vs[0]=="m");
7044         self.assertTrue(vs[1]=="m^2/kJ");
7045         self.assertTrue(vs[2]=="MW/s");
7046         pass
7047
7048     def testGaussCoordinates1(self):
7049         #Testing 1D cell types
7050         m1=MEDCouplingDataForTest.build1DMultiTypes_1();
7051         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,ONE_TIME);
7052         f.setMesh(m1);
7053         wg1=[0.3];
7054         gsCoo1=[0.2];
7055         refCoo1=[-1.0,1.0];
7056         f.setGaussLocalizationOnType(NORM_SEG2,refCoo1,gsCoo1,wg1);
7057         wg2=wg1;
7058         gsCoo2=[0.2];
7059         refCoo2=[-1.0,1.0,0.0];
7060         f.setGaussLocalizationOnType(NORM_SEG3,refCoo2,gsCoo2,wg2);
7061         #
7062         resToTest=f.getLocalizationOfDiscr();
7063         self.assertEqual(3,resToTest.getNumberOfComponents());
7064         self.assertEqual(2,resToTest.getNumberOfTuples());
7065         expected1=[0.6,0.6,0.6, 0.6,0.6,0.6]
7066         for i in xrange(6):
7067             self.assertAlmostEqual(expected1[i],resToTest.getIJ(0,i),14);
7068             pass
7069         #
7070         #Testing 2D cell types
7071         m2=MEDCouplingDataForTest.build2DMultiTypes_1();
7072         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,ONE_TIME);
7073         f.setMesh(m2);
7074         wg3=[0.3,0.3];
7075         tria3CooGauss=[ 0.1, 0.8, 0.2, 0.7 ]
7076         gsCoo3=tria3CooGauss
7077         tria3CooRef=[ 0.0, 0.0, 1.0 , 0.0, 0.0, 1.0 ]
7078         refCoo3=tria3CooRef;
7079         f.setGaussLocalizationOnType(NORM_TRI3,refCoo3,gsCoo3,wg3);
7080         wg4=[0.3,0.3,0.3];
7081         tria6CooGauss=[ 0.3, 0.2, 0.2, 0.1, 0.2, 0.4 ]
7082         gsCoo4=tria6CooGauss;
7083         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]
7084         refCoo4=tria6CooRef;
7085         f.setGaussLocalizationOnType(NORM_TRI6,refCoo4,gsCoo4,wg4);
7086         wg5=[0.3,0.3,0.3,0.3];
7087         quad4CooGauss=[ 0.3, 0.2, 0.2, 0.1, 0.2, 0.4, 0.15, 0.27 ]
7088         gsCoo5=quad4CooGauss;
7089         quad4CooRef=[-1.0, 1.0, -1.0, -1.0, 1.0, -1.0, 1.0, 1.0]
7090         refCoo5=quad4CooRef;
7091         f.setGaussLocalizationOnType(NORM_QUAD4,refCoo5,gsCoo5,wg5);
7092         wg6=[0.3,0.3,0.3,0.3];
7093         quad8CooGauss=[ 0.34, 0.16, 0.21, 0.3, 0.23, 0.4, 0.14, 0.37 ]
7094         gsCoo6=quad8CooGauss;
7095         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]
7096         refCoo6=quad8CooRef;
7097         f.setGaussLocalizationOnType(NORM_QUAD8,refCoo6,gsCoo6,wg6);
7098         #
7099         resToTest=f.getLocalizationOfDiscr();
7100         self.assertEqual(3,resToTest.getNumberOfComponents());
7101         self.assertEqual(13,resToTest.getNumberOfTuples());#2+3+4+4 gauss points for resp TRI3,TRI6,QUAD4,QUAD8
7102         expected2=[5.1,1.55,0.0, 4.7,1.65,0.0,
7103                    2.32,1.52,0.0, 1.6,1.32,0.0, 3.52,1.26,0.0,#TRI6
7104                    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
7105                    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
7106         for i in xrange(39):
7107             self.assertAlmostEqual(expected2[i],resToTest.getIJ(0,i),14);
7108             pass
7109         #
7110         #Testing 3D cell types
7111         m3=MEDCouplingDataForTest.build3DMultiTypes_1();
7112         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,ONE_TIME);
7113         f.setMesh(m3);
7114         #
7115         wg7=[0.3];
7116         tetra4CooGauss=[0.34, 0.16, 0.21]
7117         gsCoo7=tetra4CooGauss;
7118         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]
7119         refCoo7=tetra4CooRef;
7120         f.setGaussLocalizationOnType(NORM_TETRA4,refCoo7,gsCoo7,wg7);
7121         wg8=[0.3];
7122         tetra10CooGauss=[0.2, 0.3, 0.1]
7123         gsCoo8=tetra10CooGauss;
7124         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]
7125         refCoo8=tetra10CooRef;
7126         f.setGaussLocalizationOnType(NORM_TETRA10,refCoo8,gsCoo8,wg8);
7127         wg9=[0.3];
7128         pyra5CooGauss=[0.2, 0.3, 0.1]
7129         gsCoo9=pyra5CooGauss;
7130         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]
7131         refCoo9=pyra5CooRef;
7132         f.setGaussLocalizationOnType(NORM_PYRA5,refCoo9,gsCoo9,wg9);
7133         wg10=[0.3];
7134         pyra13CooGauss=[0.1, 0.2, 0.7]
7135         gsCoo10=pyra13CooGauss;
7136         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]
7137         refCoo10=pyra13CooRef;
7138         f.setGaussLocalizationOnType(NORM_PYRA13,refCoo10,gsCoo10,wg10);
7139         wg11=[0.3];
7140         penta6CooGauss=[0.2, 0.3, 0.1]
7141         gsCoo11=penta6CooGauss;
7142         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]
7143         refCoo11=penta6CooRef;
7144         f.setGaussLocalizationOnType(NORM_PENTA6,refCoo11,gsCoo11,wg11);
7145         wg12=[0.3];
7146         penta15CooGauss=[0.2, 0.3,0.15]
7147         gsCoo12=penta15CooGauss;
7148         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]
7149         refCoo12=penta15CooRef;
7150         f.setGaussLocalizationOnType(NORM_PENTA15,refCoo12,gsCoo12,wg12);
7151         wg13=[0.3];
7152         hexa8CooGauss=[0.2,0.3,0.15]
7153         gsCoo13=hexa8CooGauss;
7154         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]
7155         refCoo13=hexa8CooRef;
7156         f.setGaussLocalizationOnType(NORM_HEXA8,refCoo13,gsCoo13,wg13);
7157         wg14=[0.3];
7158         hexa20CooGauss=[0.11,0.3,0.55]
7159         gsCoo14=hexa20CooGauss;
7160         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]
7161         refCoo14=hexa20CooRef;
7162         f.setGaussLocalizationOnType(NORM_HEXA20,refCoo14,gsCoo14,wg14);
7163         #
7164         resToTest=f.getLocalizationOfDiscr();
7165         self.assertEqual(3,resToTest.getNumberOfComponents());
7166         self.assertEqual(8,resToTest.getNumberOfTuples());#2+3+4+4 gauss points for resp TRI3,TRI6,QUAD4,QUAD8
7167         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]
7168         for i in xrange(24):
7169             self.assertAlmostEqual(expected3[i],resToTest.getIJ(0,i),14);
7170             pass
7171         #
7172         pass
7173
7174     def testP2Localization1(self):
7175         m=MEDCouplingUMesh.New("testP2",2);
7176         coords=[0.,2.,3.5,0.,4.5,1.5,1.2,0.32,3.4,1.,2.1,2.4]
7177         conn=[0,1,2,3,4,5]
7178         coo=DataArrayDouble.New();
7179         coo.setValues(coords,6,2);
7180         m.setCoords(coo);
7181         m.allocateCells(1);
7182         m.insertNextCell(NORM_TRI6,6,conn[0:6])
7183         m.finishInsertingCells();
7184         #
7185         f=MEDCouplingFieldDouble.New(ON_NODES,ONE_TIME);
7186         f.setMesh(m);
7187         da=DataArrayDouble.New();
7188         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]
7189         da.setValues(vals1,6,3);
7190         f.setArray(da);
7191         #
7192         loc=[2.27,1.3]
7193         locs=f.getValueOnMulti(loc);
7194         expected1=[6.0921164547752236, 7.1921164547752232, 8.2921164547752255]
7195         for i in xrange(3):
7196             self.assertAlmostEqual(expected1[i],locs.getIJ(0,i),12);
7197             pass
7198         pass
7199
7200     def testP2Localization2(self):
7201         m=MEDCouplingUMesh.New("testP2_2",3);
7202         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]
7203         conn=[0,1,2,3,4,5,6,7,8,9]
7204         coo=DataArrayDouble.New();
7205         coo.setValues(coords,10,3);
7206         m.setCoords(coo);
7207         m.allocateCells(1);
7208         m.insertNextCell(NORM_TETRA10,10,conn[0:10])
7209         m.finishInsertingCells();
7210         #
7211         f=MEDCouplingFieldDouble.New(ON_NODES,ONE_TIME);
7212         f.setMesh(m);
7213         da=DataArrayDouble.New();
7214         vals1=[1.1,2.1,3.1,4.1,5.2,6.2,7.2,8.2,9.2,10.2]
7215         da.setValues(vals1,10,1);
7216         f.setArray(da);
7217         #
7218         loc=[0.64637931739890486, -0.16185896817550552, 0.22678966365273748]
7219         locs=f.getValueOnMulti(loc);
7220         expected1=[10.0844021968047]
7221         for i in xrange(1):
7222             self.assertAlmostEqual(expected1[i],locs.getIJ(0,i),12);
7223             pass
7224         pass
7225
7226     def testGetValueOn2(self):
7227         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7228         f=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
7229         f.setMesh(m);
7230         arr=DataArrayDouble.New();
7231         nbOfCells=m.getNumberOfCells();
7232         f.setArray(arr);
7233         values1=[7.,107.,10007.,8.,108.,10008.,9.,109.,10009.,10.,110.,10010.,11.,111.,10011.]
7234         arr.setValues(values1,nbOfCells,3);
7235         loc=[-0.05,-0.05, 0.55,-0.25, 0.55,0.15, -0.05,0.45, 0.45,0.45]
7236         f.checkCoherency();
7237         locs=f.getValueOnMulti(loc);
7238         self.assertEqual(5,locs.getNumberOfTuples());
7239         self.assertEqual(3,locs.getNumberOfComponents());
7240         for j in xrange(15):
7241             self.assertAlmostEqual(values1[j],locs.getIJ(0,j),12);
7242             pass
7243         # Testing ON_NODES
7244         f=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
7245         f.setMesh(m);
7246         arr=DataArrayDouble.New();
7247         nbOfNodes=m.getNumberOfNodes();
7248         f.setArray(arr);
7249         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.]
7250         arr.setValues(values2,nbOfNodes,3);
7251         loc2=[0.5432,-0.2432, 0.5478,0.1528, 0.5432,-0.2432, 0.5432,-0.2432]
7252         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]
7253         f.checkCoherency();
7254         loc3=DataArrayDouble.New()
7255         loc3.setValues(loc2,4,2);
7256         locs=f.getValueOnMulti(loc3);
7257         self.assertEqual(4,locs.getNumberOfTuples());
7258         self.assertEqual(3,locs.getNumberOfComponents());
7259         for i in xrange(12):
7260             self.assertAlmostEqual(expected2[i],locs.getIJ(0,i),12);
7261             pass
7262         #
7263         pass
7264
7265     def testDAIGetIdsNotEqual1(self):
7266         d=DataArrayInt.New();
7267         vals1=[2,3,5,6,8,5,5,6,1,-5]
7268         d.setValues(vals1,10,1);
7269         d2=d.getIdsNotEqual(5);
7270         self.assertEqual(7,d2.getNumberOfTuples());
7271         self.assertEqual(1,d2.getNumberOfComponents());
7272         expected1=[0,1,3,4,7,8,9]
7273         for i in xrange(7):
7274             self.assertEqual(expected1[i],d2.getIJ(0,i));
7275             pass
7276         d.rearrange(2);
7277         self.assertRaises(InterpKernelException,d.getIdsNotEqual,5);
7278         vals2=[-4,5,6]
7279         vals3=vals2;
7280         d.rearrange(1);
7281         d3=d.getIdsNotEqualList(vals3);
7282         self.assertEqual(5,d3.getNumberOfTuples());
7283         self.assertEqual(1,d3.getNumberOfComponents());
7284         expected2=[0,1,4,8,9]
7285         for i in xrange(5):
7286             self.assertEqual(expected2[i],d3.getIJ(0,i));
7287             pass
7288         pass
7289
7290     def testDAIComputeOffsets1(self):
7291         d=DataArrayInt.New();
7292         vals1=[3,5,1,2,0,8]
7293         expected1=[0,3,8,9,11,11]
7294         d.setValues(vals1,6,1);
7295         d.computeOffsets();
7296         self.assertEqual(6,d.getNumberOfTuples());
7297         self.assertEqual(1,d.getNumberOfComponents());
7298         for i in xrange(6):
7299             self.assertEqual(expected1[i],d.getIJ(0,i));
7300             pass
7301         pass
7302
7303     def testUMeshHexagonPrism1(self):
7304         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,
7305                 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];
7306         conn=[1,2,3,4,5,0,7,8,9,10,11,6]
7307         mesh=MEDCouplingUMesh.New("MyFirstHexagonalPrism",3);
7308         coo=DataArrayDouble.New();
7309         coo.setValues(coords,12,3);
7310         mesh.setCoords(coo);
7311         mesh.allocateCells(1);
7312         mesh.insertNextCell(NORM_HEXGP12,12,conn[0:12])
7313         mesh.finishInsertingCells();
7314         #
7315         mesh.checkCoherency();
7316         vols=mesh.getMeasureField(False);
7317         self.assertEqual(1,vols.getNumberOfTuples());
7318         self.assertEqual(1,vols.getNumberOfComponents());
7319         self.assertAlmostEqual(-5.196152422706632,vols.getIJ(0,0),12);
7320         bary=mesh.getBarycenterAndOwner();
7321         self.assertEqual(1,bary.getNumberOfTuples());
7322         self.assertEqual(3,bary.getNumberOfComponents());
7323         expected1=[0.,0.,1.]
7324         for i in xrange(3):
7325             self.assertAlmostEqual(expected1[i],bary.getIJ(0,i),12);
7326             pass
7327         d1=DataArrayInt.New();
7328         d2=DataArrayInt.New();
7329         d3=DataArrayInt.New();
7330         d4=DataArrayInt.New();
7331         m2=mesh.buildDescendingConnectivity(d1,d2,d3,d4);
7332         self.assertEqual(8,m2.getNumberOfCells());
7333         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]];
7334         expected2=[NORM_POLYGON, NORM_POLYGON, NORM_QUAD4, NORM_QUAD4, NORM_QUAD4, NORM_QUAD4, NORM_QUAD4, NORM_QUAD4];
7335         expected3=[6,6,4,4,4,4,4,4]
7336         for i in xrange(8):
7337             self.assertTrue(m2.getTypeOfCell(i)==expected2[i]);
7338             v=m2.getNodeIdsOfCell(i);
7339             self.assertTrue(len(v)==expected3[i]);
7340             self.assertEqual(expected4[i],v);
7341         #
7342         mesh.convertAllToPoly();
7343         self.assertTrue(NORM_POLYHED==mesh.getTypeOfCell(0));
7344         mesh.unPolyze();
7345         self.assertTrue(NORM_HEXGP12==mesh.getTypeOfCell(0));
7346         self.assertEqual(13,mesh.getMeshLength());
7347         #
7348         pass
7349
7350     def testDADCheckIsMonotonic(self):
7351         da=DataArrayDouble.New();
7352         da.setValues([-1.,1.01,2.03,6.],2,2);
7353         self.assertRaises(InterpKernelException,da.isMonotonic,True,1e-12);
7354         da.rearrange(1);
7355         self.assertTrue(da.isMonotonic(True,1e-12));
7356         da.checkMonotonic(True,1e-12);
7357         da.setIJ(2,0,6.1);
7358         self.assertTrue(not da.isMonotonic(True,1e-12));
7359         self.assertRaises(InterpKernelException,da.checkMonotonic,True,1e-12);
7360         da.setIJ(2,0,5.99);
7361         self.assertTrue(da.isMonotonic(True,1e-12));
7362         self.assertTrue(not da.isMonotonic(True,1e-1));
7363         pass
7364
7365     def testCheckCoherencyDeeper1(self):
7366         m=MEDCouplingDataForTest.build3DSourceMesh_1();
7367         m.checkCoherency();
7368         m.checkCoherency1();
7369         m.getNodalConnectivity().setIJ(8,0,-1);
7370         m.checkCoherency();
7371         self.assertRaises(InterpKernelException,m.checkCoherency1);
7372         m.getNodalConnectivity().setIJ(8,0,-6);
7373         m.checkCoherency();
7374         self.assertRaises(InterpKernelException,m.checkCoherency1);
7375         m.getNodalConnectivity().setIJ(8,0,9);#9>=NbOfNodes
7376         m.checkCoherency();
7377         self.assertRaises(InterpKernelException,m.checkCoherency1);
7378         m.getNodalConnectivity().setIJ(8,0,8);#OK
7379         m.checkCoherency();
7380         m.checkCoherency1();
7381         elts=[1,5]
7382         m.convertToPolyTypes(elts);
7383         m.checkCoherency();
7384         m.checkCoherency1();
7385         m.getNodalConnectivity().setIJ(2,0,9);#9>=NbOfNodes
7386         m.checkCoherency();
7387         self.assertRaises(InterpKernelException,m.checkCoherency1);
7388         m.getNodalConnectivity().setIJ(2,0,-3);
7389         m.checkCoherency();
7390         self.assertRaises(InterpKernelException,m.checkCoherency1);
7391         m.getNodalConnectivity().setIJ(2,0,-1);
7392         m.checkCoherency();
7393         self.assertRaises(InterpKernelException,m.checkCoherency1);#Throw because cell#0 is not a polyhedron
7394         m.getNodalConnectivity().setIJ(2,0,4);
7395         m.checkCoherency();
7396         m.checkCoherency1();
7397         m.getNodalConnectivity().setIJ(7,0,-1);
7398         m.checkCoherency();
7399         m.checkCoherency1();#OK because we are in polyhedron connec
7400         m.getNodalConnectivity().setIJ(36,0,14);
7401         m.checkCoherency();
7402         self.assertRaises(InterpKernelException,m.checkCoherency1);#Throw beacause now cell 5 is a TETRA4 (14) so mimatch of number index and static type.
7403         pass
7404
7405     def testUnPolyze2(self):
7406         m=MEDCouplingUMesh.New("jjj",3);
7407         coo=DataArrayDouble.New();
7408         coo.alloc(4,3);
7409         coo.rearrange(1);
7410         coo.iota(0);
7411         coo.rearrange(3);
7412         m.setCoords(coo);
7413         m.allocateCells(2);
7414         m.insertNextCell(NORM_TETRA4,4,[0,1,2,3]);
7415         m.insertNextCell(NORM_TETRA4,4,[0,1,2,3]);
7416         m.finishInsertingCells();
7417         m2=MEDCouplingUMesh.MergeUMeshesOnSameCoords(4*[m]);
7418         m2.convertToPolyTypes([2]);
7419         m2.unPolyze();
7420         self.assertEqual(NORM_TETRA4,m2.getTypeOfCell(2));
7421         self.assertEqual(40,m2.getMeshLength());
7422         temp2=m2.getNodeIdsOfCell(2);
7423         self.assertEqual(temp2,[0,1,2,3]);
7424         m2.checkCoherency1();
7425         m3=m2.deepCpy();
7426         m2.unPolyze();
7427         self.assertTrue(m3.isEqual(m2,1e-12));
7428         pass
7429
7430     def testDACpyFrom1(self):
7431         d=DataArrayDouble.New();
7432         d.alloc(12,1);
7433         d.iota(14.);
7434         d.rearrange(3);
7435         d.setName("Toto");
7436         d.setInfoOnComponent(0,"X [m]");
7437         d.setInfoOnComponent(1,"Y [m]");
7438         d.setInfoOnComponent(2,"Z [m]");
7439         #
7440         d1=DataArrayDouble.New();
7441         self.assertTrue(not d.isEqual(d1,1e-12));
7442         d1.cpyFrom(d);
7443         self.assertTrue(d.isEqual(d1,1e-12));
7444         d1.cpyFrom(d);
7445         self.assertTrue(d.isEqual(d1,1e-12));
7446         d1.rearrange(2);
7447         self.assertTrue(not d.isEqual(d1,1e-12));
7448         d1.cpyFrom(d);
7449         self.assertTrue(d.isEqual(d1,1e-12));
7450         #
7451         d2=d.convertToIntArr();
7452         d4=DataArrayInt.New();
7453         self.assertTrue(not d2.isEqual(d4));
7454         d4.cpyFrom(d2);
7455         self.assertTrue(d2.isEqual(d4));
7456         d4.cpyFrom(d2);
7457         self.assertTrue(d2.isEqual(d4));
7458         d4.rearrange(2);
7459         self.assertTrue(not d2.isEqual(d4));
7460         d4.cpyFrom(d2);
7461         self.assertTrue(d2.isEqual(d4));
7462         pass
7463
7464     def testDAITransformWithIndArr1(self):
7465         tab1=[17,18,22,19]
7466         tab2=[0,1,1,3,3,0,1,3,2,2,3,0]
7467         expected=[17,18,18,19,19,17,18,19,22,22,19,17]
7468         d=DataArrayInt.New();
7469         d.setValues(tab1,4,1);
7470         d1=DataArrayInt.New();
7471         d1.setValues(tab2,12,1);
7472         d2=d1[:]
7473         #
7474         d1.transformWithIndArr(d);
7475         self.assertEqual(12,d1.getNumberOfTuples());
7476         self.assertEqual(1,d1.getNumberOfComponents());
7477         for i in xrange(12):
7478             self.assertEqual(expected[i],d1.getIJ(i,0));
7479             pass
7480         #
7481         d1=d2
7482         d1.transformWithIndArr(tab1)
7483         self.assertEqual(12,d1.getNumberOfTuples());
7484         self.assertEqual(1,d1.getNumberOfComponents());
7485         for i in xrange(12):
7486             self.assertEqual(expected[i],d1.getIJ(i,0));
7487             pass
7488         pass
7489
7490     def testDAIBuildPermArrPerLevel1(self):
7491         arr=[2,0,1,1,0,1,2,0,1,1,0,0]
7492         expected1=[10,0,5,6,1,7,11,2,8,9,3,4]
7493         da=DataArrayInt.New();
7494         da.setValues(arr,12,1);
7495         da2=da.buildPermArrPerLevel();
7496         self.assertEqual(12,da2.getNumberOfTuples());
7497         self.assertEqual(1,da2.getNumberOfComponents());
7498         for i in xrange(12):
7499             self.assertEqual(expected1[i],da2.getIJ(i,0));
7500             pass
7501         pass
7502
7503     def testDAIOperations1(self):
7504         arr1=[-1,-2,4,7,3,2,6,6,4,3,0,1]
7505         da=DataArrayInt.New();
7506         da.setValues(arr1,4,3);
7507         da1=DataArrayInt.New();
7508         da1.alloc(12,1);
7509         da1.iota(2);
7510         self.assertRaises(InterpKernelException,DataArrayInt.Add,da,da1);#not same number of tuples/Components
7511         da1.rearrange(3);
7512         da2=DataArrayInt.Add(da,da1);
7513         self.assertEqual(4,da2.getNumberOfTuples());
7514         self.assertEqual(3,da2.getNumberOfComponents());
7515         expected1=[1,1,8,12,9,9,14,15,14,14,12,14]
7516         for i in xrange(12):
7517             self.assertEqual(expected1[i],da2.getIJ(0,i));
7518             pass
7519         da1.substractEqual(da);
7520         expected2=[3,5,0,-2,3,5,2,3,6,8,12,12]
7521         for i in xrange(12):
7522             self.assertEqual(expected2[i],da1.getIJ(0,i));
7523             pass
7524         da1.rearrange(1); da1.iota(2); da1.rearrange(3);
7525         da1.addEqual(da);
7526         for i in xrange(12):
7527             self.assertEqual(expected1[i],da1.getIJ(0,i));
7528             pass
7529         da1.rearrange(1); da1.iota(2); da1.rearrange(3);
7530         da2=DataArrayInt.Multiply(da,da1);
7531         self.assertEqual(4,da2.getNumberOfTuples());
7532         self.assertEqual(3,da2.getNumberOfComponents());
7533         expected3=[-2,-6,16,35,18,14,48,54,40,33,0,13]
7534         for i in xrange(12):
7535             self.assertEqual(expected3[i],da2.getIJ(0,i));
7536             pass
7537         da.divideEqual(da1);
7538         self.assertEqual(4,da.getNumberOfTuples());
7539         self.assertEqual(3,da.getNumberOfComponents());
7540         expected4=[0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0]
7541         for i in xrange(12):
7542             self.assertEqual(expected4[i],da.getIJ(0,i));
7543             pass
7544         da.setValues(arr1,4,3);
7545         da1.multiplyEqual(da);
7546         self.assertEqual(4,da1.getNumberOfTuples());
7547         self.assertEqual(3,da1.getNumberOfComponents());
7548         for i in xrange(12):
7549             self.assertEqual(expected3[i],da1.getIJ(0,i));
7550             pass
7551         da1.rearrange(1); da1.iota(2); da1.rearrange(3);
7552         da2=DataArrayInt.Divide(da,da1);
7553         self.assertEqual(4,da2.getNumberOfTuples());
7554         self.assertEqual(3,da2.getNumberOfComponents());
7555         for i in xrange(12):
7556             self.assertEqual(expected4[i],da2.getIJ(0,i));
7557             pass
7558         da1.applyInv(321);
7559         self.assertEqual(4,da1.getNumberOfTuples());
7560         self.assertEqual(3,da1.getNumberOfComponents());
7561         expected5=[160,107,80,64,53,45,40,35,32,29,26,24]
7562         for i in xrange(12):
7563             self.assertEqual(expected5[i],da1.getIJ(0,i));
7564             pass
7565         da1.applyDivideBy(2);
7566         self.assertEqual(4,da1.getNumberOfTuples());
7567         self.assertEqual(3,da1.getNumberOfComponents());
7568         expected6=[80,53,40,32,26,22,20,17,16,14,13,12]
7569         for i in xrange(12):
7570             self.assertEqual(expected6[i],da1.getIJ(0,i));
7571             pass
7572         expected7=[3,4,5,4,5,1,6,3,2,0,6,5]
7573         da1.applyModulus(7);
7574         for i in xrange(12):
7575             self.assertEqual(expected7[i],da1.getIJ(0,i));
7576             pass
7577         da1.applyLin(1,1);
7578         expected8=[3,3,3,3,3,1,3,3,0,0,3,3]
7579         da1.applyRModulus(3);
7580         for i in xrange(12):
7581             self.assertEqual(expected8[i],da1.getIJ(0,i));
7582             pass
7583         pass
7584
7585     def testEmulateMEDMEMBDC1(self):
7586         m,m1=MEDCouplingDataForTest.buildPointe_1();
7587         m2,da1,da2,da3,da4,da5,da0=m.emulateMEDMEMBDC(m1)
7588         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]
7589         expected1=[1,32,29,23,41,36]
7590         self.assertEqual(47,da0.getNumberOfTuples());
7591         self.assertEqual(1,da0.getNumberOfComponents());
7592         for i in xrange(47):
7593             self.assertEqual(expected0[i],da0.getIJ(0,i));
7594             pass
7595         self.assertEqual(6,da5.getNumberOfTuples());
7596         self.assertEqual(1,da5.getNumberOfComponents());
7597         for i in xrange(6):
7598             self.assertEqual(expected1[i],da5.getIJ(0,i));
7599             pass
7600         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]
7601         self.assertEqual(70,da1.getNumberOfTuples());
7602         self.assertEqual(1,da1.getNumberOfComponents());
7603         for i in xrange(70):
7604             self.assertEqual(expected2[i],da1.getIJ(0,i));
7605             pass
7606         expected3=[0,4,8,12,16,20,24,28,32,36,40,44,48,53,58,64,70]
7607         self.assertEqual(17,da2.getNumberOfTuples());
7608         self.assertEqual(1,da2.getNumberOfComponents());
7609         for i in xrange(17):
7610             self.assertEqual(expected3[i],da2.getIJ(0,i));
7611             pass
7612         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]
7613         #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];
7614         self.assertEqual(48,da4.getNumberOfTuples());
7615         self.assertEqual(1,da4.getNumberOfComponents());
7616         for i in xrange(48):
7617             self.assertEqual(expected4[i],da4.getIJ(0,i));
7618             pass
7619         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]
7620         self.assertEqual(70,da3.getNumberOfTuples());
7621         self.assertEqual(1,da3.getNumberOfComponents());
7622         for i in xrange(70):
7623             self.assertEqual(expected5[i],da3.getIJ(0,i));
7624             pass
7625         pass
7626
7627     def testGetLevArrPerCellTypes1(self):
7628         m,m1=MEDCouplingDataForTest.buildPointe_1();
7629         m1,d0,d1,d2,d3=m.buildDescendingConnectivity();
7630         order=[NORM_TRI3,NORM_QUAD4];
7631         da0,da1=m1.getLevArrPerCellTypes(order);
7632         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]
7633         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]
7634         self.assertEqual(47,da0.getNumberOfTuples());
7635         self.assertEqual(1,da0.getNumberOfComponents());
7636         for i in xrange(47):
7637             self.assertEqual(expected0[i],da0.getIJ(0,i));
7638             pass
7639         self.assertEqual(2,da1.getNumberOfTuples());
7640         self.assertEqual(1,da1.getNumberOfComponents());
7641         self.assertEqual(36,da1.getIJ(0,0));#36 TRI3
7642         self.assertEqual(11,da1.getIJ(1,0));#11 QUAD4
7643         #
7644         da2=da0.buildPermArrPerLevel();
7645         #
7646         self.assertEqual(47,da2.getNumberOfTuples());
7647         self.assertEqual(1,da2.getNumberOfComponents());
7648         for i in xrange(47):
7649             self.assertEqual(expected1[i],da2.getIJ(0,i));
7650             pass
7651         pass
7652
7653     def testSortCellsInMEDFileFrmt1(self):
7654         m,m1=MEDCouplingDataForTest.buildPointe_1();
7655         m2=m.deepCpy()
7656         da=DataArrayInt.New()
7657         da.setValues([0,1,2,14,3,12,4,5,15,6,7,8,9,10,11,13],16,1)
7658         daa=da.invertArrayN2O2O2N(16)
7659         m.renumberCells(daa,False)
7660         da2=m.sortCellsInMEDFileFrmt()
7661         self.assertEqual(da2.getValues(),[0,1,2,14,3,12,4,5,15,6,7,8,9,10,11,13])
7662         self.assertTrue(m.isEqual(m2,1e-12))
7663         self.assertTrue(da.isEqual(da2))
7664         pass
7665
7666     def testBuildPartAndReduceNodes1(self):
7667         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7668         arr=[1,0]
7669         m2,da=m.buildPartAndReduceNodes(arr);
7670         self.assertEqual(5,m2.getNumberOfNodes());
7671         self.assertEqual(2,m2.getNumberOfCells());
7672         f=m2.getMeasureField(True);
7673         self.assertAlmostEqual(0.125,f.getArray().getIJ(0,0),12);
7674         self.assertAlmostEqual(0.25,f.getArray().getIJ(1,0),12);
7675         #
7676         arr2=DataArrayInt.New()
7677         arr2.setValues(arr,2,1)
7678         m2,da=m.buildPartAndReduceNodes(arr2);
7679         self.assertEqual(5,m2.getNumberOfNodes());
7680         self.assertEqual(2,m2.getNumberOfCells());
7681         f=m2.getMeasureField(True);
7682         self.assertAlmostEqual(0.125,f.getArray().getIJ(0,0),12);
7683         self.assertAlmostEqual(0.25,f.getArray().getIJ(1,0),12);
7684         pass
7685
7686     def testDAITransformWithIndArrR1(self):
7687         tab1=[2,4,5,3,6,7]
7688         tab2=[-1,-1,0,1,2,3,4,5,-1,-1,-1,-1]
7689         expected=[0,3,1,2,4,5]
7690         d=DataArrayInt.New();
7691         d.setValues(tab1,6,1);
7692         d1=DataArrayInt.New();
7693         d1.setValues(tab2,12,1);
7694         d2=d1[:]
7695         #
7696         d3=d.transformWithIndArrR(d1);
7697         self.assertEqual(6,d3.getNumberOfTuples());
7698         self.assertEqual(1,d3.getNumberOfComponents());
7699         for i in xrange(6):
7700             self.assertEqual(expected[i],d3.getIJ(i,0));
7701             pass
7702         #
7703         d1=d2
7704         d3=d.transformWithIndArrR(tab2)
7705         self.assertEqual(6,d3.getNumberOfTuples());
7706         self.assertEqual(1,d3.getNumberOfComponents());
7707         for i in xrange(6):
7708             self.assertEqual(expected[i],d3.getIJ(i,0));
7709             pass
7710         pass
7711
7712     def testDAISplitByValueRange1(self):
7713         val1=[6,5,0,3,2,7,8,1,4]
7714         val2=[0,4,9]
7715         d=DataArrayInt.New();
7716         d.setValues(val1,9,1);
7717         e,f,g=d.splitByValueRange(val2);
7718         self.assertEqual(9,e.getNumberOfTuples());
7719         self.assertEqual(1,e.getNumberOfComponents());
7720         self.assertEqual(9,f.getNumberOfTuples());
7721         self.assertEqual(1,f.getNumberOfComponents());
7722         self.assertEqual(2,g.getNumberOfTuples());
7723         self.assertEqual(1,g.getNumberOfComponents());
7724         #
7725         expected1=[1,1,0,0,0,1,1,0,1]
7726         expected2=[2,1,0,3,2,3,4,1,0]
7727         for i in xrange(9):
7728             self.assertEqual(expected1[i],e.getIJ(i,0));
7729             self.assertEqual(expected2[i],f.getIJ(i,0));
7730             pass
7731         self.assertEqual(0,g.getIJ(0,0));
7732         self.assertEqual(1,g.getIJ(1,0));
7733         #
7734         d.setIJ(6,0,9);
7735         self.assertRaises(InterpKernelException,d.splitByValueRange,val2);
7736         pass
7737
7738     def testUMeshSplitProfilePerType1(self):
7739         val0=[2,0,1,3,4]
7740         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7741         m.renumberCells(val0,False);
7742         #
7743         val1=[0,2,3]
7744         d=DataArrayInt.New();
7745         d.setValues(val1,3,1);
7746         d.setName("sup")
7747         code,idsInPflPerType,pfls=m.splitProfilePerType(d);
7748         self.assertEqual(2,len(code));
7749         self.assertEqual(2,len(idsInPflPerType));
7750         expected1=[[3,1,0], [4,2,1]]
7751         self.assertEqual(expected1,code)
7752         self.assertEqual(2,len(idsInPflPerType));
7753         self.assertEqual(1,idsInPflPerType[0].getNumberOfTuples());
7754         self.assertEqual(0,idsInPflPerType[0].getIJ(0,0));
7755         self.assertEqual(2,idsInPflPerType[1].getNumberOfTuples());
7756         self.assertEqual(1,idsInPflPerType[1].getIJ(0,0));
7757         self.assertEqual(2,idsInPflPerType[1].getIJ(1,0));
7758         #
7759         self.assertEqual(2,len(pfls));
7760         self.assertEqual("sup",pfls[0].getName())
7761         self.assertEqual(1,pfls[0].getNumberOfTuples());
7762         self.assertEqual(0,pfls[0].getIJ(0,0));
7763         self.assertEqual("sup",pfls[1].getName())
7764         self.assertEqual(2,pfls[1].getNumberOfTuples());
7765         self.assertEqual(0,pfls[1].getIJ(0,0));
7766         self.assertEqual(1,pfls[1].getIJ(1,0));
7767         #
7768         val2=[0,2,3,4]
7769         d=DataArrayInt.New();
7770         d.setValues(val2,4,1);
7771         code,idsInPflPerType,pfls=m.splitProfilePerType(d);
7772         self.assertEqual(2,len(code));
7773         self.assertEqual(2,len(idsInPflPerType));
7774         expected2=[[3,1,0], [4,3,-1]]
7775         self.assertEqual(expected2,code);
7776         self.assertEqual(2,len(idsInPflPerType));
7777         self.assertEqual(1,idsInPflPerType[0].getNumberOfTuples());
7778         self.assertEqual(0,idsInPflPerType[0].getIJ(0,0));
7779         self.assertEqual(3,idsInPflPerType[1].getNumberOfTuples());
7780         self.assertEqual(1,idsInPflPerType[1].getIJ(0,0));
7781         self.assertEqual(2,idsInPflPerType[1].getIJ(1,0));
7782         self.assertEqual(3,idsInPflPerType[1].getIJ(2,0));
7783         #
7784         self.assertEqual(1,len(pfls));
7785         self.assertEqual(1,pfls[0].getNumberOfTuples());
7786         self.assertEqual(0,pfls[0].getIJ(0,0));
7787         #
7788         val3=[1,0,2]
7789         d=DataArrayInt.New();
7790         d.setValues(val3,3,1);
7791         code,idsInPflPerType,pfls=m.splitProfilePerType(d);
7792         self.assertEqual(2,len(code));
7793         self.assertEqual(2,len(idsInPflPerType));
7794         expected3=[[3,2,0], [4,1,1]]
7795         self.assertEqual(expected3,code);
7796         self.assertEqual(2,len(idsInPflPerType));
7797         self.assertEqual(2,idsInPflPerType[0].getNumberOfTuples());
7798         self.assertEqual(0,idsInPflPerType[0].getIJ(0,0));
7799         self.assertEqual(1,idsInPflPerType[0].getIJ(1,0));
7800         self.assertEqual(1,idsInPflPerType[1].getNumberOfTuples());
7801         self.assertEqual(2,idsInPflPerType[1].getIJ(0,0));
7802         #
7803         self.assertEqual(2,len(pfls));
7804         self.assertEqual(2,pfls[0].getNumberOfTuples());
7805         self.assertEqual(1,pfls[0].getIJ(0,0));
7806         self.assertEqual(0,pfls[0].getIJ(1,0));
7807         self.assertEqual(0,pfls[1].getIJ(0,0));
7808         #
7809         val4=[3,4]
7810         d=DataArrayInt.New();
7811         d.setValues(val4,2,1);
7812         code,idsInPflPerType,pfls=m.splitProfilePerType(d);
7813         self.assertEqual(1,len(code));
7814         self.assertEqual(1,len(idsInPflPerType));
7815         expected4=[[4,2,0]]
7816         self.assertEqual(expected4,code);
7817         self.assertEqual(1,len(idsInPflPerType));
7818         self.assertEqual(2,idsInPflPerType[0].getNumberOfTuples());
7819         self.assertEqual(0,idsInPflPerType[0].getIJ(0,0));
7820         self.assertEqual(1,idsInPflPerType[0].getIJ(1,0));
7821         #
7822         self.assertEqual(1,len(pfls));
7823         self.assertEqual(2,pfls[0].getNumberOfTuples());
7824         self.assertEqual(1,pfls[0].getIJ(0,0));
7825         self.assertEqual(2,pfls[0].getIJ(1,0));
7826         pass
7827
7828     def testDAIBuildExplicitArrByRanges1(self):
7829         d=DataArrayInt.New();
7830         vals1=[0,2,3]
7831         d.setValues(vals1,3,1);
7832         e=DataArrayInt.New();
7833         vals2=[0,3,6,10,14,20]
7834         e.setValues(vals2,6,1);
7835         #
7836         f=d.buildExplicitArrByRanges(e);
7837         self.assertEqual(11,f.getNumberOfTuples());
7838         self.assertEqual(1,f.getNumberOfComponents());
7839         expected1=[0,1,2,6,7,8,9,10,11,12,13]
7840         for i in xrange(11):
7841             self.assertEqual(expected1[i],f.getIJ(i,0));
7842             pass
7843         pass
7844
7845     def testDAIComputeOffsets2(self):
7846         d=DataArrayInt.New();
7847         vals1=[3,5,1,2,0,8]
7848         expected1=[0,3,8,9,11,11,19]
7849         d.setValues(vals1,6,1);
7850         d.computeOffsets2();
7851         self.assertEqual(7,d.getNumberOfTuples());
7852         self.assertEqual(1,d.getNumberOfComponents());
7853         for i in xrange(7):
7854             self.assertEqual(expected1[i],d.getIJ(0,i));
7855             pass
7856         pass
7857
7858     def testMergeField3(self):
7859         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7860         m.getCoords().setInfoOnComponent(0,"x [m]");
7861         m.getCoords().setInfoOnComponent(1,"z [km]");
7862         m.setName("m");
7863         m.setDescription("desc");
7864         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
7865         f1.setName("f1");
7866         f1.setMesh(m);
7867         arr=DataArrayDouble.New();
7868         arr.alloc(5,2);
7869         arr.setInfoOnComponent(0,"X [m]");
7870         arr.setInfoOnComponent(1,"YY [mm]");
7871         arr.fillWithValue(2.);
7872         f1.setArray(arr);
7873         #
7874         f2=MEDCouplingFieldDouble.MergeFields([f1]);
7875         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
7876         #
7877         pass
7878
7879     def testGetDistributionOfTypes1(self):
7880         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7881         tab1=[2,0,1,3,4]
7882         self.assertRaises(InterpKernelException,m.getDistributionOfTypes);
7883         m.renumberCells(tab1,False);
7884         code=m.getDistributionOfTypes();
7885         self.assertEqual(2,len(code));
7886         self.assertEqual(3,code[0][0]);
7887         self.assertEqual(2,code[0][1]);
7888         self.assertEqual(0,code[0][2]);
7889         self.assertEqual(4,code[1][0]);
7890         self.assertEqual(3,code[1][1]);
7891         self.assertEqual(0,code[1][2]);
7892         pass
7893
7894     def testNorm2_1(self):
7895         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7896         f=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
7897         f.setMesh(m);
7898         #
7899         d=DataArrayDouble.New();
7900         tab=[1.2,1.3,2.2,2.3,3.2,3.3,4.2,4.3,5.2,5.3]
7901         d.setValues(tab,5,2);
7902         f.setArray(d);
7903         f.checkCoherency();
7904         #
7905         self.assertAlmostEqual(11.209371079592289,f.norm2(),14);
7906         #
7907         pass
7908
7909     def testNormMax1(self):
7910         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7911         f=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
7912         f.setMesh(m);
7913         #
7914         d=DataArrayDouble.New();
7915         tab=[2.3,-1.2,6.3,-7.8,2.9,7.7,2.1,0.,3.6,-7.6]
7916         d.setValues(tab,5,2);
7917         f.setArray(d);
7918         f.checkCoherency();
7919         #
7920         self.assertAlmostEqual(7.8,f.normMax(),14);
7921         #
7922         pass
7923
7924     def testFindAndCorrectBadOriented3DExtrudedCells1(self):
7925         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];
7926         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]
7927         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]
7928         invalidCells=[2,3,6,7]
7929         m=MEDCouplingUMesh.New("Example",3);
7930         coo=DataArrayDouble.New();
7931         coo.setValues(coords,38,3);
7932         m.setCoords(coo);
7933         m.allocateCells(8);
7934         m.insertNextCell(NORM_PENTA6,6,conn[0:6])
7935         m.insertNextCell(NORM_PENTA6,6,conn[6:12])
7936         m.insertNextCell(NORM_PENTA6,6,conn[12:18])
7937         m.insertNextCell(NORM_PENTA6,6,conn[18:24])
7938         m.insertNextCell(NORM_HEXA8,8,conn[24:32])
7939         m.insertNextCell(NORM_HEXA8,8,conn[32:40])
7940         m.insertNextCell(NORM_HEXA8,8,conn[40:48])
7941         m.insertNextCell(NORM_HEXA8,8,conn[48:56])
7942         m.finishInsertingCells();
7943         #
7944         v=m.findAndCorrectBadOriented3DExtrudedCells();
7945         self.assertEqual(4,len(v));
7946         self.assertEqual(v.getValues(),invalidCells);
7947         self.assertEqual(connExp,m.getNodalConnectivity().getValues());
7948         self.assertTrue(m.findAndCorrectBadOriented3DExtrudedCells().empty())
7949         #
7950         pass
7951
7952     def testConvertExtrudedPolyhedra1(self):
7953         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]
7954         m=MEDCouplingUMesh.New("Example",3);
7955         coo=DataArrayDouble.New();
7956         coo.alloc(73,3);
7957         coo.rearrange(1); coo.iota(0); coo.rearrange(3);
7958         m.setCoords(coo);
7959         m.allocateCells(9);
7960         m.insertNextCell(NORM_TETRA4,4,conn[0:4])
7961         m.insertNextCell(NORM_HEXA8,8,conn[4:12])
7962         m.insertNextCell(NORM_TETRA4,4,conn[12:16])
7963         m.insertNextCell(NORM_POLYHED,6,conn[16:22])
7964         m.insertNextCell(NORM_PENTA6,6,conn[22:28])
7965         m.insertNextCell(NORM_POLYHED,10,conn[28:38])
7966         m.insertNextCell(NORM_HEXA8,8,conn[38:46])
7967         m.insertNextCell(NORM_HEXGP12,12,conn[46:58])
7968         m.insertNextCell(NORM_POLYHED,14,conn[58:72])
7969         m.finishInsertingCells();
7970         #
7971         m.convertExtrudedPolyhedra();
7972         da=m.getNodalConnectivity();
7973         dai=m.getNodalConnectivityIndex();
7974         self.assertEqual(10,dai.getNbOfElems());
7975         self.assertEqual(159,da.getNbOfElems());
7976         #
7977         expected1=[14,1,2,3,4,18,5,6,7,8,9,10,11,12,14,13,14,15,16,31,17,18,19,-1,20,22,21,-1,17,20,21,18,-1,18,21,22,19,-1,19,22,20,17,16,23,24,25,26,27,28,31,29,30,31,32,33,-1,34,38,37,36,35,-1,29,34,35,30,-1,30,35,36,31,-1,31,36,37,32,-1,32,37,38,33,-1,33,38,34,29,18,39,40,41,42,43,44,45,46,22,47,48,49,50,51,52,53,54,55,56,57,58,31,59,60,61,62,63,64,65,-1,66,72,71,70,69,68,67,-1,59,66,67,60,-1,60,67,68,61,-1,61,68,69,62,-1,62,69,70,63,-1,63,70,71,64,-1,64,71,72,65,-1,65,72,66,59];
7978         expected2=[0,5,14,19,42,49,86,95,108,159]
7979         self.assertEqual(expected1,da.getValues());
7980         self.assertEqual(expected2,dai.getValues());
7981         m.checkCoherency2()
7982         pass
7983
7984     def testNonRegressionCopyTinyStrings(self):
7985         m=MEDCouplingDataForTest.build2DTargetMesh_1()
7986         f1=m.getMeasureField(True)
7987         f1.getArray().setInfoOnComponent(0,"P [N/m^2]")
7988         bary=m.getBarycenterAndOwner()
7989         f2=f1.buildNewTimeReprFromThis(NO_TIME,False)
7990         f2.setArray(bary)
7991         self.assertRaises(InterpKernelException,f1.copyTinyAttrFrom,f2)
7992         pass
7993
7994     def testDaDSetPartOfValuesAdv1(self):
7995         tab1=[3.,4.,5., 13.,14.,15., 23.,24.,25., 33.,34.,35., 43.,44.,45., 53.,54.,55.]
7996         tab2=[6.,7.,8., 16.,17.,18., 26.,27.,28.]
7997         tab3=[4,1, 2,2, 3,0]
7998         a=DataArrayDouble.New();
7999         a.setValues(tab1,6,3);
8000         b=DataArrayDouble.New();
8001         b.setValues(tab2,3,3);
8002         c=DataArrayInt.New();
8003         c.setValues(tab3,3,2);
8004         #
8005         a.setPartOfValuesAdv(b,c);
8006         expected1=[3.,4.,5., 13.,14.,15., 26.,27.,28., 6.,7.,8., 16.,17.,18., 53.,54.,55.]
8007         self.assertEqual(expected1,a.getValues());
8008         pass
8009
8010     def testUMeshBuildSetInstanceFromThis1(self):
8011         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
8012         m2=m.buildSetInstanceFromThis(3);
8013         self.assertTrue(m.isEqual(m2,1e-12));
8014         #
8015         m=MEDCouplingUMesh.New("toto",2);
8016         m2=m.buildSetInstanceFromThis(3);
8017         self.assertEqual(0,m2.getNumberOfNodes());
8018         self.assertEqual(0,m2.getNumberOfCells());
8019         pass
8020
8021     def testUMeshMergeMeshesCVW1(self):
8022         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
8023         m2=MEDCouplingUMesh.New("toto",2);
8024         m3=MEDCouplingUMesh.MergeUMeshes([m,m2]);
8025         m3.setName(m.getName());
8026         self.assertTrue(m.isEqual(m3,1e-12));
8027         pass
8028
8029     def testChangeUnderlyingMeshWithCMesh1(self):
8030         mesh=MEDCouplingCMesh.New();
8031         coordsX=DataArrayDouble.New();
8032         arrX=[ -1., 1., 2., 4. ]
8033         coordsX.setValues(arrX,4,1);
8034         coordsY=DataArrayDouble.New();
8035         arrY=[ -2., 2., 4., 8. ]
8036         coordsY.setValues(arrY,4,1);
8037         coordsZ=DataArrayDouble.New();
8038         arrZ=[ -3., 3., 6., 12. ]
8039         coordsZ.setValues(arrZ,4,1);
8040         mesh.setCoords(coordsX,coordsY,coordsZ);
8041         f=mesh.getMeasureField(True)
8042         mesh2=mesh.deepCpy()
8043         for myId in [0,1,2,10,11,12,20,21,22]:
8044             f=mesh.getMeasureField(True)
8045             f.changeUnderlyingMesh(mesh2,myId,1e-12);
8046             pass
8047         mesh2.setName("uuuu")
8048         for myId in [1,2,10,11,12,20,21,22]:
8049             f=mesh.getMeasureField(True)
8050             f.changeUnderlyingMesh(mesh2,myId,1e-12);
8051             pass
8052         pass
8053
8054     def testDADFindCommonTuples1(self):
8055         da=DataArrayDouble.New();
8056         # nbOftuples=1
8057         array1=[2.3,1.2,1.3,2.3,2.301,0.8]
8058         da.setValues(array1,6,1)
8059         c,cI=da.findCommonTuples(1e-2);
8060         expected1=[0,3,4]
8061         expected2=[0,3]
8062         self.assertEqual(3,c.getNbOfElems());
8063         self.assertEqual(2,cI.getNbOfElems());
8064         self.assertEqual(expected1,c.getValues())
8065         self.assertEqual(expected2,cI.getValues())
8066         c,cI=da.findCommonTuples(2e-1)
8067         expected3=[0,3,4,1,2]
8068         expected4=[0,3,5]
8069         self.assertEqual(5,c.getNbOfElems());
8070         self.assertEqual(3,cI.getNbOfElems());
8071         self.assertEqual(expected3,c.getValues())
8072         self.assertEqual(expected4,cI.getValues())
8073         # nbOftuples=2
8074         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]
8075         da.setValues(array2,6,2)
8076         c,cI=da.findCommonTuples(1e-2);
8077         self.assertEqual(3,c.getNbOfElems());
8078         self.assertEqual(2,cI.getNbOfElems());
8079         self.assertEqual(expected1,c.getValues())
8080         self.assertEqual(expected2,cI.getValues())
8081         c,cI=da.findCommonTuples(2e-1)
8082         self.assertEqual(5,c.getNbOfElems());
8083         self.assertEqual(3,cI.getNbOfElems());
8084         self.assertEqual(expected3,c.getValues())
8085         self.assertEqual(expected4,cI.getValues())
8086         # nbOftuples=3
8087         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]
8088         da.setValues(array3,6,3)
8089         c,cI=da.findCommonTuples(1e-2);
8090         self.assertEqual(3,c.getNbOfElems());
8091         self.assertEqual(2,cI.getNbOfElems());
8092         self.assertEqual(expected1,c.getValues())
8093         self.assertEqual(expected2,cI.getValues())
8094         c,cI=da.findCommonTuples(2e-1)
8095         self.assertEqual(5,c.getNbOfElems());
8096         self.assertEqual(3,cI.getNbOfElems());
8097         self.assertEqual(expected3,c.getValues())
8098         self.assertEqual(expected4,cI.getValues())
8099         # nbOftuples=1, no common groups
8100         array11=[2.3,1.2,1.3,2.4,2.5,0.8]
8101         da.setValues(array11,6,1)
8102         c,cI=da.findCommonTuples(1e-2);
8103         self.assertEqual(0,c.getNbOfElems());
8104         self.assertEqual(1,cI.getNbOfElems());
8105         self.assertEqual([0],cI.getValues())
8106
8107         array12=[0.]*(6*4)
8108         da.setValues(array12,6,4) #bad NumberOfComponents
8109         self.assertRaises(InterpKernelException, da.findCommonTuples, 1e-2);
8110         pass
8111
8112     def testDABack1(self):
8113         da=DataArrayDouble.New();
8114         array1=[2.3,1.2,1.3,2.3,2.301,0.8]
8115         da.setValues(array1,6,1);
8116         self.assertAlmostEqual(0.8,da.back(),14);
8117         da.rearrange(2);
8118         self.assertRaises(InterpKernelException,da.back);
8119         da.alloc(0,1);
8120         self.assertRaises(InterpKernelException,da.back);
8121         #
8122         da=DataArrayInt.New();
8123         array2=[4,7,8,2]
8124         da.setValues(array2,4,1);
8125         self.assertEqual(2,da.back());
8126         da.rearrange(2);
8127         self.assertRaises(InterpKernelException,da.back);
8128         da.alloc(0,1);
8129         self.assertRaises(InterpKernelException,da.back);
8130         pass
8131
8132     def testDADGetDifferentValues1(self):
8133         da=DataArrayDouble.New();
8134         array1=[2.3,1.2,1.3,2.3,2.301,0.8]
8135         da.setValues(array1,6,1)
8136         #
8137         expected1=[2.301,1.2,1.3,0.8]
8138         dv=da.getDifferentValues(1e-2);
8139         self.assertEqual(4,dv.getNbOfElems());
8140         for i in xrange(4):
8141             self.assertAlmostEqual(expected1[i],dv.getIJ(i,0),14);
8142             pass
8143         #
8144         dv=da.getDifferentValues(2e-1);
8145         expected2=[2.301,1.3,0.8]
8146         self.assertEqual(3,dv.getNbOfElems());
8147         for i in xrange(3):
8148             self.assertAlmostEqual(expected2[i],dv.getIJ(i,0),14);
8149             pass
8150         pass
8151
8152     def testDAIBuildOld2NewArrayFromSurjectiveFormat2(self):
8153         arr=[0,3, 5,7,9]
8154         arrI=[0,2,5]
8155         a=DataArrayInt.New();
8156         a.setValues(arr,5,1);
8157         b=DataArrayInt.New();
8158         b.setValues(arrI,3,1);
8159         ret,newNbTuple=DataArrayInt.BuildOld2NewArrayFromSurjectiveFormat2(10,a,b);
8160         expected=[0,1,2,0,3,4,5,4,6,4]
8161         self.assertEqual(10,ret.getNbOfElems());
8162         self.assertEqual(7,newNbTuple);
8163         self.assertEqual(1,ret.getNumberOfComponents());
8164         self.assertEqual(expected,ret.getValues());
8165         self.assertRaises(InterpKernelException,DataArrayInt.BuildOld2NewArrayFromSurjectiveFormat2,9,a,b);
8166         pass
8167
8168     def testDADIReverse1(self):
8169         arr=[0,3,5,7,9,2]
8170         a=DataArrayInt.New();
8171         a.setValues(arr,6,1);
8172         self.assertEqual(2,a.back());
8173         a.reverse();
8174         for i in xrange(6):
8175             self.assertEqual(arr[5-i],a.getIJ(i,0));
8176             pass
8177         a.setValues(arr[:-1],5,1);
8178         a.reverse();
8179         for i in xrange(5):
8180             self.assertEqual(arr[4-i],a.getIJ(i,0));
8181             pass
8182         #
8183         arr2=[0.,3.,5.,7.,9.,2.]
8184         b=DataArrayDouble.New();
8185         b.setValues(arr2,6,1);
8186         b.reverse();
8187         for i in xrange(6):
8188             self.assertAlmostEqual(arr2[5-i],b.getIJ(i,0),14);
8189             pass
8190         b.setValues(arr2[:5],5,1);
8191         self.assertAlmostEqual(9.,b.back(),14)
8192         b.reverse();
8193         for i in xrange(5):
8194             self.assertAlmostEqual(arr2[4-i],b.getIJ(i,0),14);
8195             pass
8196         pass
8197
8198     def testGetNodeIdsInUse1(self):
8199         m0=MEDCouplingDataForTest.build2DTargetMesh_1();
8200         CellIds=[1,2]
8201         m1=m0.buildPartOfMySelf(CellIds,True);
8202         arr,newNbOfNodes=m1.getNodeIdsInUse();
8203         expected=[-1,0,1,-1,2,3,-1,-1,-1]
8204         self.assertEqual(4,newNbOfNodes);
8205         self.assertEqual(9,arr.getNbOfElems());
8206         self.assertEqual(expected,arr.getValues());
8207         arr2=arr.invertArrayO2N2N2O(newNbOfNodes);
8208         self.assertEqual(4,arr2.getNbOfElems());
8209         expected2=[1,2,4,5]
8210         self.assertEqual(expected2,arr2.getValues());
8211         pass
8212
8213     def testBuildDescendingConnec2(self):
8214         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
8215         #
8216         mesh2,desc,descIndx,revDesc,revDescIndx=mesh.buildDescendingConnectivity2();
8217         mesh2.checkCoherency();
8218         self.assertEqual(1,mesh2.getMeshDimension());
8219         self.assertEqual(13,mesh2.getNumberOfCells());
8220         self.assertEqual(14,revDescIndx.getNbOfElems()); self.assertEqual(14,revDescIndx.getNumberOfTuples());
8221         self.assertEqual(6,descIndx.getNbOfElems()); self.assertEqual(6,descIndx.getNumberOfTuples());
8222         self.assertEqual(18,desc.getNbOfElems()); self.assertEqual(18,desc.getNumberOfTuples());
8223         self.assertEqual(18,revDesc.getNbOfElems()); self.assertEqual(18,revDesc.getNumberOfTuples());
8224         expected1=[1,2,3,4,-3,5,6, 7,8,-5,9,10,-2,11, 12,13,-7,-10]
8225         self.assertEqual(expected1,desc.getValues());
8226         expected2=[0,4,7,10,14,18]
8227         self.assertEqual(expected2,descIndx.getValues());
8228         expected3=[0,1,3,5,6,8,9,11,12,13,15,16,17,18]
8229         self.assertEqual(expected3,revDescIndx.getValues());
8230         expected4=[0, 0,3, 0,1, 0, 1,2, 1, 2,4, 2, 3, 3,4, 3, 4, 4]
8231         self.assertEqual(expected4,revDesc.getValues());
8232         conn=mesh2.getNodalConnectivity();
8233         connIndex=mesh2.getNodalConnectivityIndex();
8234         expected5=[0,3,6,9,12,15,18,21,24,27,30,33,36,39]
8235         self.assertEqual(expected5,connIndex.getValues());
8236         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]
8237         self.assertEqual(expected6,conn.getValues());
8238         pass
8239
8240     def testIntersect2DMeshesTmp1(self):
8241         m1c=MEDCouplingCMesh.New();
8242         coordsX=DataArrayDouble.New();
8243         arrX=[ -1., 1., 2., 4. ]
8244         coordsX.setValues(arrX,4,1);
8245         m1c.setCoordsAt(0,coordsX);
8246         coordsY=DataArrayDouble.New();
8247         arrY=[ -2., 2., 4., 8. ]
8248         coordsY.setValues(arrY,4,1);
8249         m1c.setCoordsAt(1,coordsY);
8250         m1=m1c.buildUnstructured()
8251         m1bis=m1.buildPartOfMySelf([3,4,5],False)
8252         m2=m1.deepCpy()
8253         m2=m2.buildPartOfMySelf([0,1,2],False)
8254         m2.translate([0.5,0.5])
8255         #
8256         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m1bis,m2,1e-10)
8257         expected1=[0,0,1,1,1,2,2,2]
8258         expected2=[0,-1,0,1,-1,1,2,-1]
8259         self.assertEqual(8,d1.getNumberOfTuples());
8260         self.assertEqual(8,d2.getNumberOfTuples());
8261         self.assertEqual(8,m3.getNumberOfCells());
8262         self.assertEqual(22,m3.getNumberOfNodes());
8263         self.assertEqual(2,m3.getSpaceDimension());
8264         self.assertEqual(expected1,d1.getValues());
8265         self.assertEqual(expected2,d2.getValues());
8266         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]
8267         expected4=[0,5,12,17,22,28,33,38,44]
8268         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]
8269         self.assertEqual(44,m3.getNodalConnectivity().getNumberOfTuples());
8270         self.assertEqual(9,m3.getNodalConnectivityIndex().getNumberOfTuples());
8271         self.assertEqual(expected3,m3.getNodalConnectivity().getValues());
8272         self.assertEqual(expected4,m3.getNodalConnectivityIndex().getValues());
8273         for i in xrange(44):
8274             self.assertAlmostEqual(expected5[i],m3.getCoords().getIJ(0,i),12);
8275             pass
8276         pass
8277
8278     def testFindNodesOnLine1(self):
8279         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
8280         pt=[-0.3,-0.3]
8281         pt2=[0.,0.,0.]
8282         pt3=[-0.3,0.,0.]
8283         vec=[0.,1.]
8284         vec2=[1.,0.,0.]
8285         vec3=[0.,1.,1.]
8286         expected1=[0,3,6]
8287         res=mesh.findNodesOnLine(pt,vec,1e-12);
8288         self.assertEqual(3,len(res));
8289         self.assertEqual(expected1,res.getValues());
8290         #
8291         mesh.changeSpaceDimension(3);
8292         mesh.rotate(pt2,vec2,pi/4.);
8293         res=mesh.findNodesOnLine(pt3,vec3,1e-12);
8294         self.assertEqual(3,len(res));
8295         self.assertEqual(expected1,res.getValues());
8296         pass
8297
8298     def testIntersect2DMeshesTmp2(self):
8299         m1c=MEDCouplingCMesh.New();
8300         coordsX1=DataArrayDouble.New();
8301         arrX1=[ 0., 1., 1.5, 2. ]
8302         coordsX1.setValues(arrX1,4,1);
8303         m1c.setCoordsAt(0,coordsX1);
8304         coordsY1=DataArrayDouble.New();
8305         arrY1=[ 0., 1.5, 3.]
8306         coordsY1.setValues(arrY1,3,1);
8307         m1c.setCoordsAt(1,coordsY1);
8308         m1=m1c.buildUnstructured();
8309         m2c=MEDCouplingCMesh.New();
8310         coordsX2=DataArrayDouble.New();
8311         arrX2=[ 0., 1., 2. ]
8312         coordsX2.setValues(arrX2,3,1);
8313         m2c.setCoordsAt(0,coordsX2);
8314         coordsY2=DataArrayDouble.New();
8315         arrY2=[ 0., 1., 3.]
8316         coordsY2.setValues(arrY2,3,1);
8317         m2c.setCoordsAt(1,coordsY2);
8318         m2=m2c.buildUnstructured();
8319         #
8320         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m1,m2,1e-10)
8321         #
8322         expected1=[0,0,1,1,2,2,3,4,5]
8323         expected2=[0,2,1,3,1,3,2,3,3]
8324         self.assertEqual(9,d1.getNumberOfTuples());
8325         self.assertEqual(9,d2.getNumberOfTuples());
8326         self.assertEqual(9,m3.getNumberOfCells());
8327         self.assertEqual(22,m3.getNumberOfNodes());
8328         self.assertEqual(2,m3.getSpaceDimension());
8329         self.assertEqual(expected1,d1.getValues());
8330         self.assertEqual(expected2,d2.getValues());
8331         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]
8332         expected4=[0,5,10,15,20,25,30,35,40,45]
8333         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]
8334         self.assertEqual(45,m3.getNodalConnectivity().getNumberOfTuples());
8335         self.assertEqual(10,m3.getNodalConnectivityIndex().getNumberOfTuples());
8336         self.assertEqual(expected3,m3.getNodalConnectivity().getValues());
8337         self.assertEqual(expected4,m3.getNodalConnectivityIndex().getValues());
8338         for i in xrange(44):
8339             self.assertAlmostEqual(expected5[i],m3.getCoords().getIJ(0,i),12);
8340             pass
8341         pass
8342
8343     def testBuildPartOfMySelfSafe1(self):
8344         mesh=MEDCouplingDataForTest.build2DTargetMesh_1()
8345         self.assertRaises(InterpKernelException,mesh.buildPartOfMySelf,[0,-1,4,2],True)
8346         self.assertRaises(InterpKernelException,mesh.buildPartOfMySelf,[0,4,5,4],True)
8347         pass
8348
8349     def testIntersect2DMeshesTmp3(self):
8350         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];
8351         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];
8352         m1=MEDCouplingUMesh.New();
8353         m1.setMeshDimension(2);
8354         m1.allocateCells(8);
8355         m1.insertNextCell(NORM_TRI6,6,m1Conn[0:6]);
8356         m1.insertNextCell(NORM_QUAD8,8,m1Conn[6:14]);
8357         m1.insertNextCell(NORM_TRI6,6,m1Conn[14:20]);
8358         m1.insertNextCell(NORM_QUAD8,8,m1Conn[20:28]);
8359         m1.insertNextCell(NORM_TRI6,6,m1Conn[28:34]);
8360         m1.insertNextCell(NORM_QUAD8,8,m1Conn[34:42]);
8361         m1.insertNextCell(NORM_TRI6,6,m1Conn[42:48]);
8362         m1.insertNextCell(NORM_QUAD8,8,m1Conn[48:56]);
8363         m1.finishInsertingCells();
8364         myCoords1=DataArrayDouble.New();
8365         myCoords1.setValues(m1Coords,25,2);
8366         m1.setCoords(myCoords1);
8367         #
8368         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.]
8369         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]
8370         m2=MEDCouplingUMesh.New();
8371         m2.setMeshDimension(2);
8372         m2.allocateCells(8);
8373         for i in xrange(8):
8374             m2.insertNextCell(NORM_QUAD4,4,m2Conn[4*i:4*(i+1)])
8375             pass
8376         m2.finishInsertingCells();
8377         myCoords2=DataArrayDouble.New();
8378         myCoords2.setValues(m2Coords,15,2);
8379         m2.setCoords(myCoords2);
8380         #
8381         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m1,m2,1e-10)
8382         m3.unPolyze()
8383         #
8384         expected1=[0,1,1,1,2,3,3,3,4,5,5,5,6,7,7,7]
8385         expected2=[0,0,1,-1,2,2,3,-1,4,4,5,-1,6,6,7,-1]
8386         self.assertEqual(16,d1.getNumberOfTuples());
8387         self.assertEqual(16,d2.getNumberOfTuples());
8388         self.assertEqual(16,m3.getNumberOfCells());
8389         self.assertEqual(104,m3.getNumberOfNodes());
8390         self.assertEqual(2,m3.getSpaceDimension());
8391         self.assertEqual(expected1,d1.getValues());
8392         self.assertEqual(expected2,d2.getValues());
8393         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]
8394         expected4=[0,7,16,25,34,41,50,59,68,75,84,93,102,109,118,127,136]
8395         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]
8396         self.assertEqual(136,m3.getNodalConnectivity().getNumberOfTuples());
8397         self.assertEqual(17,m3.getNodalConnectivityIndex().getNumberOfTuples());
8398         self.assertEqual(expected3,m3.getNodalConnectivity().getValues());
8399         self.assertEqual(expected4,m3.getNodalConnectivityIndex().getValues());
8400         for i in xrange(208):
8401             self.assertAlmostEqual(expected5[i],m3.getCoords().getIJ(0,i),12);
8402             pass
8403         pass
8404
8405     def testUMeshTessellate2D1(self):
8406         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];
8407         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];
8408         m1=MEDCouplingUMesh.New();
8409         m1.setMeshDimension(2);
8410         m1.allocateCells(8);
8411         m1.insertNextCell(NORM_TRI6,6,m1Conn[0:6]);
8412         m1.insertNextCell(NORM_QUAD8,8,m1Conn[6:14]);
8413         m1.insertNextCell(NORM_TRI6,6,m1Conn[14:20]);
8414         m1.insertNextCell(NORM_QUAD8,8,m1Conn[20:28]);
8415         m1.insertNextCell(NORM_TRI6,6,m1Conn[28:34]);
8416         m1.insertNextCell(NORM_QUAD8,8,m1Conn[34:42]);
8417         m1.insertNextCell(NORM_TRI6,6,m1Conn[42:48]);
8418         m1.insertNextCell(NORM_QUAD8,8,m1Conn[48:56]);
8419         m1.finishInsertingCells();
8420         myCoords1=DataArrayDouble.New();
8421         myCoords1.setValues(m1Coords,25,2);
8422         m1.setCoords(myCoords1);
8423         #
8424         m11=m1.deepCpy();
8425         m11.tessellate2D(1.);
8426         self.assertTrue(m11.getCoords().isEqual(m11.getCoords(),1e-12));
8427         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]
8428         expected2=[0,5,12,17,24,29,36,41,48]
8429         self.assertEqual(48,m11.getNodalConnectivity().getNumberOfTuples());
8430         self.assertEqual(9,m11.getNodalConnectivityIndex().getNumberOfTuples());
8431         self.assertEqual(expected1,m11.getNodalConnectivity().getValues());
8432         self.assertEqual(expected2,m11.getNodalConnectivityIndex().getValues());
8433         #
8434         m12=m1.deepCpy();
8435         m12.tessellate2D(0.5);
8436         self.assertEqual(41,m12.getNumberOfNodes());
8437         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]
8438         expected4=[0,6,15,21,30,36,45,51,60]
8439         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]
8440         for i in xrange(82):
8441             self.assertAlmostEqual(expected5[i],m12.getCoords().getIJ(0,i),12);
8442             pass
8443         self.assertEqual(60,m12.getNodalConnectivity().getNumberOfTuples());
8444         self.assertEqual(9,m12.getNodalConnectivityIndex().getNumberOfTuples());
8445         self.assertEqual(expected3,m12.getNodalConnectivity().getValues());
8446         self.assertEqual(expected4,m12.getNodalConnectivityIndex().getValues());
8447         pass
8448
8449     def testIntersect2DMeshesTmp4(self):
8450         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];
8451         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];
8452         m1=MEDCouplingUMesh.New();
8453         m1.setMeshDimension(2);
8454         m1.allocateCells(8);
8455         m1.insertNextCell(NORM_TRI6,6,m1Conn[0:6]);
8456         m1.insertNextCell(NORM_QUAD8,8,m1Conn[6:14]);
8457         m1.insertNextCell(NORM_TRI6,6,m1Conn[14:20]);
8458         m1.insertNextCell(NORM_QUAD8,8,m1Conn[20:28]);
8459         m1.insertNextCell(NORM_TRI6,6,m1Conn[28:34]);
8460         m1.insertNextCell(NORM_QUAD8,8,m1Conn[34:42]);
8461         m1.insertNextCell(NORM_TRI6,6,m1Conn[42:48]);
8462         m1.insertNextCell(NORM_QUAD8,8,m1Conn[48:56]);
8463         m1.finishInsertingCells();
8464         myCoords1=DataArrayDouble.New();
8465         myCoords1.setValues(m1Coords,25,2);
8466         m1.setCoords(myCoords1);
8467         #
8468         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.]
8469         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]
8470         m2=MEDCouplingUMesh.New();
8471         m2.setMeshDimension(2);
8472         m2.allocateCells(8);
8473         for i in xrange(8):
8474             m2.insertNextCell(NORM_QUAD4,4,m2Conn[4*i:4*(i+1)])
8475             pass
8476         m2.finishInsertingCells();
8477         myCoords2=DataArrayDouble.New();
8478         myCoords2.setValues(m2Coords,15,2);
8479         m2.setCoords(myCoords2);
8480         #
8481         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m2,m1,1e-10)
8482         m3.unPolyze()
8483         #
8484         expected1=[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
8485         expected2=[0,1,1,-1,2,3,3,-1,4,5,5,-1,6,7,7,-1]
8486         self.assertEqual(16,d1.getNumberOfTuples());
8487         self.assertEqual(16,d2.getNumberOfTuples());
8488         self.assertEqual(16,m3.getNumberOfCells());
8489         self.assertEqual(104,m3.getNumberOfNodes());
8490         self.assertEqual(2,m3.getSpaceDimension());
8491         self.assertEqual(expected1,d1.getValues());
8492         self.assertEqual(expected2,d2.getValues());
8493         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]
8494         expected4=[0,7,16,25,34,41,50,59,68,75,84,93,102,109,118,127,136]
8495         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]
8496         self.assertEqual(136,m3.getNodalConnectivity().getNumberOfTuples());
8497         self.assertEqual(17,m3.getNodalConnectivityIndex().getNumberOfTuples());
8498         self.assertEqual(expected3,m3.getNodalConnectivity().getValues());
8499         self.assertEqual(expected4,m3.getNodalConnectivityIndex().getValues());
8500         for i in xrange(208):
8501             self.assertAlmostEqual(expected5[i],m3.getCoords().getIJ(0,i),12);
8502             pass
8503         pass
8504
8505     def testGetCellIdsCrossingPlane1(self):
8506         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
8507         vec=[-0.07,1.,0.07]
8508         origin=[1.524,1.4552,1.74768]
8509         ids1=mesh3D.getCellIdsCrossingPlane(origin,vec,1e-10)
8510         self.assertEqual([1,3,4,7,9,10,13,15,16],ids1.getValues())
8511         vec2=[0.,0.,1.]
8512         ids2=mesh3D.getCellIdsCrossingPlane(origin,vec2,1e-10)
8513         self.assertEqual([6,7,8,9,10,11],ids2.getValues())
8514         pass
8515
8516     def testBuildSlice3D1(self):
8517         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
8518         vec1=[-0.07,1.,0.07]
8519         origin1=[1.524,1.4552,1.74768]
8520         slice1,ids=mesh3D.buildSlice3D(origin1,vec1,1e-10);
8521         expected1=[1,3,4,7,9,10,13,15,16]
8522         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]
8523         expected3=[0,6,11,17,22,27,32,37,42,47]
8524         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.]
8525         self.assertEqual(2,slice1.getMeshDimension());
8526         self.assertEqual(3,slice1.getSpaceDimension());
8527         self.assertEqual(57,slice1.getNumberOfNodes());
8528         self.assertEqual(9,slice1.getNumberOfCells());
8529         self.assertEqual(9,ids.getNumberOfTuples());
8530         self.assertEqual(47,slice1.getNodalConnectivity().getNumberOfTuples());
8531         self.assertEqual(10,slice1.getNodalConnectivityIndex().getNumberOfTuples());
8532         self.assertEqual(expected1,ids.getValues());
8533         self.assertEqual(expected2,slice1.getNodalConnectivity().getValues());
8534         self.assertEqual(expected3,slice1.getNodalConnectivityIndex().getValues());
8535         for i in xrange(171):
8536             self.assertAlmostEqual(expected4[i],slice1.getCoords().getIJ(0,i),12);
8537             pass
8538         # 2nd slice based on already existing nodes of mesh3D.
8539         vec2=[0.,3.,1.]
8540         origin2=[2.5,1.,3.]
8541         slice1,ids=mesh3D.buildSlice3D(origin2,vec2,1e-10);
8542         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]
8543         expected6=[0,5,10,15,21,26,32,38,43,49]
8544         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]
8545         self.assertEqual(2,slice1.getMeshDimension());
8546         self.assertEqual(3,slice1.getSpaceDimension());
8547         self.assertEqual(60,slice1.getNumberOfNodes());
8548         self.assertEqual(9,slice1.getNumberOfCells());
8549         self.assertEqual(9,ids.getNumberOfTuples());
8550         self.assertEqual(49,slice1.getNodalConnectivity().getNumberOfTuples());
8551         self.assertEqual(10,slice1.getNodalConnectivityIndex().getNumberOfTuples());
8552         self.assertEqual(expected1,ids.getValues());
8553         self.assertEqual(expected5,slice1.getNodalConnectivity().getValues());
8554         self.assertEqual(expected6,slice1.getNodalConnectivityIndex().getValues());
8555         for i in xrange(180):
8556             self.assertAlmostEqual(expected7[i],slice1.getCoords().getIJ(0,i),12);
8557             pass
8558         # 3rd slice based on shared face of mesh3D.
8559         vec3=[0.,0.,1.]
8560         origin3=[2.5,1.,2.]
8561         slice1,ids=mesh3D.buildSlice3D(origin3,vec3,1e-10);
8562         expected8=[6,7,8,9,10,11,12,13,14,15,16,17]
8563         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]
8564         expected10=[0,5,12,17,22,29,34,39,46,51,56,63,68]
8565         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.]
8566         self.assertEqual(2,slice1.getMeshDimension());
8567         self.assertEqual(3,slice1.getSpaceDimension());
8568         self.assertEqual(45,slice1.getNumberOfNodes());
8569         self.assertEqual(12,slice1.getNumberOfCells());
8570         self.assertEqual(12,ids.getNumberOfTuples());
8571         self.assertEqual(68,slice1.getNodalConnectivity().getNumberOfTuples());
8572         self.assertEqual(13,slice1.getNodalConnectivityIndex().getNumberOfTuples());
8573         self.assertEqual(expected8,ids.getValues());
8574         self.assertEqual(expected9,slice1.getNodalConnectivity().getValues());
8575         self.assertEqual(expected10,slice1.getNodalConnectivityIndex().getValues());
8576         for i in xrange(135):
8577             self.assertAlmostEqual(expected11[i],slice1.getCoords().getIJ(0,i),12);
8578             pass
8579         pass
8580
8581     def testBuildSlice3DSurf1(self):
8582         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
8583         mesh2D=mesh3D.buildDescendingConnectivity()[0];
8584         vec1=[-0.07,1.,0.07]
8585         origin1=[1.524,1.4552,1.74768]
8586         slice1,ids=mesh2D.buildSlice3DSurf(origin1,vec1,1e-10);
8587         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]
8588         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]
8589         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];
8590         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.]
8591         self.assertEqual(1,slice1.getMeshDimension());
8592         self.assertEqual(3,slice1.getSpaceDimension());
8593         self.assertEqual(57,slice1.getNumberOfNodes());
8594         self.assertEqual(25,slice1.getNumberOfCells());
8595         self.assertEqual(25,ids.getNumberOfTuples());
8596         self.assertEqual(75,slice1.getNodalConnectivity().getNumberOfTuples());
8597         self.assertEqual(26,slice1.getNodalConnectivityIndex().getNumberOfTuples());
8598         self.assertEqual(expected1,ids.getValues());
8599         self.assertEqual(expected2,slice1.getNodalConnectivity().getValues());
8600         self.assertEqual(expected3,slice1.getNodalConnectivityIndex().getValues());
8601         for i in xrange(171):
8602             self.assertAlmostEqual(expected4[i],slice1.getCoords().getIJ(0,i),12);
8603             pass
8604         #
8605         vec2=[0.,0.,1.]
8606         origin2=[2.5,1.,2.]
8607         slice1,ids=mesh2D.buildSlice3DSurf(origin2,vec2,1e-10);
8608         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]
8609         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]
8610         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];
8611         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.]
8612         self.assertEqual(1,slice1.getMeshDimension());
8613         self.assertEqual(3,slice1.getSpaceDimension());
8614         self.assertEqual(45,slice1.getNumberOfNodes());
8615         self.assertEqual(68,slice1.getNumberOfCells());
8616         self.assertEqual(68,ids.getNumberOfTuples());
8617         self.assertEqual(204,slice1.getNodalConnectivity().getNumberOfTuples());
8618         self.assertEqual(69,slice1.getNodalConnectivityIndex().getNumberOfTuples());
8619         self.assertEqual(expected5,ids.getValues());
8620         self.assertEqual(expected6,slice1.getNodalConnectivity().getValues());
8621         self.assertEqual(expected7,slice1.getNodalConnectivityIndex().getValues());
8622         for i in xrange(135):
8623             self.assertAlmostEqual(expected8[i],slice1.getCoords().getIJ(0,i),12);
8624             pass
8625         pass
8626
8627     def testDataArrayDoubleAdvSetting1(self):
8628         data1=[1.,11.,2.,12.,3.,13.,4.,14.,5.,15.,6.,16.,7.,17.]
8629         data2=[8.,38.,9.,39.,0.,30.,11.,41.,12.,42.]
8630         compsCpp=["comp1","comp2"]
8631         da=DataArrayDouble.New();
8632         da.setInfoAndChangeNbOfCompo(compsCpp);
8633         da.setName("da");
8634         da.alloc(7,2);
8635         compsCpp=compsCpp[:-1]
8636         self.assertRaises(InterpKernelException,da.setInfoAndChangeNbOfCompo,compsCpp);
8637         da.setValues(data1,7,2)
8638         #
8639         p=[(0,3),(3,5),(5,7)]
8640         tmp=da.selectByTupleRanges(p);
8641         self.assertTrue(tmp.isEqual(da,1e-14));
8642         p=[(0,2),(3,4),(5,7)]
8643         tmp=da.selectByTupleRanges(p);
8644         expected1=[1.,11.,2.,12.,4.,14.,6.,16.,7.,17.]
8645         self.assertEqual(5,tmp.getNumberOfTuples());
8646         self.assertEqual(2,tmp.getNumberOfComponents());
8647         for i in xrange(10):
8648             self.assertAlmostEqual(expected1[i],tmp.getIJ(0,i),14);
8649             pass
8650         p=[(0,2),(0,2),(5,6)]
8651         tmp=da.selectByTupleRanges(p);
8652         expected2=[1.,11.,2.,12.,1.,11.,2.,12.,6.,16.]
8653         self.assertEqual(5,tmp.getNumberOfTuples());
8654         self.assertEqual(2,tmp.getNumberOfComponents());
8655         for i in xrange(10):
8656             self.assertAlmostEqual(expected2[i],tmp.getIJ(0,i),14);
8657             pass
8658         p=[(0,2),(-1,2),(5,6)]
8659         self.assertRaises(InterpKernelException,da.selectByTupleRanges,p);
8660         p=[(0,2),(0,2),(5,8)]
8661         self.assertRaises(InterpKernelException,da.selectByTupleRanges,p);
8662         #
8663         da2=DataArrayDouble.New();
8664         da2.setValues(data2,5,2);
8665         #
8666         dac=da.deepCpy();
8667         dac.setContigPartOfSelectedValues2(1,da2,2,4,1);
8668         expected3=[1.,11.,0.,30.,11.,41.,4.,14.,5.,15.,6.,16.,7.,17.]
8669         for i in xrange(14):
8670             self.assertAlmostEqual(expected3[i],dac.getIJ(0,i),14);
8671             pass
8672         #
8673         dac=da.deepCpy();
8674         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,3,da2,0,5,1);
8675         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,0,da2,4,6,1);
8676         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,3,da2,5,0,1);
8677         dac.setContigPartOfSelectedValues2(3,da2,1,5,1);
8678         expected4=[1.,11.,2.,12.,3.,13.,9.,39.,0.,30.,11.,41.,12.,42.]
8679         for i in xrange(14):
8680             self.assertAlmostEqual(expected4[i],dac.getIJ(0,i),14);
8681             pass
8682         #
8683         ids=DataArrayInt.New();
8684         ids.alloc(3,1);
8685         dac=da.deepCpy();
8686         ids.setIJ(0,0,2); ids.setIJ(1,0,0); ids.setIJ(2,0,4);
8687         dac.setContigPartOfSelectedValues(2,da2,ids);
8688         expected5=[1.,11.,2.,12.,0.,30.,8.,38.,12.,42.,6.,16.,7.,17.]
8689         for i in xrange(14):
8690             self.assertAlmostEqual(expected5[i],dac.getIJ(0,i),14);
8691             pass
8692         #
8693         dac=da.deepCpy();
8694         ids.setIJ(0,0,2); ids.setIJ(1,0,5); ids.setIJ(2,0,4);
8695         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,1,da2,ids);
8696         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,-1);
8697         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,1,da2,ids);
8698         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,1);
8699         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,5,da2,ids);
8700         #
8701         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,1);
8702         dac=da.deepCpy();
8703         dac.setContigPartOfSelectedValues(4,da2,ids);
8704         expected6=[1.,11.,2.,12.,3.,13.,4.,14.,0.,30.,0.,30.,9.,39.]
8705         for i in xrange(14):
8706             self.assertAlmostEqual(expected6[i],dac.getIJ(0,i),14);
8707             pass
8708         pass
8709
8710     def testDataArrayIntAdvSetting1(self):
8711         data1=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
8712         data2=[8,38,9,39,0,30,11,41,12,42]
8713         compsCpp=["comp1","comp2"]
8714         da=DataArrayInt.New();
8715         da.setInfoAndChangeNbOfCompo(compsCpp);
8716         da.setName("da");
8717         da.alloc(7,2);
8718         compsCpp=compsCpp[:-1]
8719         self.assertRaises(InterpKernelException,da.setInfoAndChangeNbOfCompo,compsCpp);
8720         da.setValues(data1,7,2)
8721         #
8722         p=[(0,3),(3,5),(5,7)]
8723         tmp=da.selectByTupleRanges(p);
8724         self.assertTrue(tmp.isEqual(da));
8725         p=[(0,2),(3,4),(5,7)]
8726         tmp=da.selectByTupleRanges(p);
8727         expected1=[1,11,2,12,4,14,6,16,7,17]
8728         self.assertEqual(5,tmp.getNumberOfTuples());
8729         self.assertEqual(2,tmp.getNumberOfComponents());
8730         for i in xrange(10):
8731             self.assertEqual(expected1[i],tmp.getIJ(0,i));
8732             pass
8733         p=[(0,2),(0,2),(5,6)]
8734         tmp=da.selectByTupleRanges(p);
8735         expected2=[1,11,2,12,1,11,2,12,6,16]
8736         self.assertEqual(5,tmp.getNumberOfTuples());
8737         self.assertEqual(2,tmp.getNumberOfComponents());
8738         for i in xrange(10):
8739             self.assertEqual(expected2[i],tmp.getIJ(0,i));
8740             pass
8741         p=[(0,2),(-1,2),(5,6)]
8742         self.assertRaises(InterpKernelException,da.selectByTupleRanges,p);
8743         p=[(0,2),(0,2),(5,8)]
8744         self.assertRaises(InterpKernelException,da.selectByTupleRanges,p);
8745         #
8746         da2=DataArrayInt.New();
8747         da2.setValues(data2,5,2);
8748         #
8749         dac=da.deepCpy();
8750         dac.setContigPartOfSelectedValues2(1,da2,2,4,1);
8751         expected3=[1,11,0,30,11,41,4,14,5,15,6,16,7,17]
8752         for i in xrange(14):
8753             self.assertEqual(expected3[i],dac.getIJ(0,i));
8754             pass
8755         #
8756         dac=da.deepCpy();
8757         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,3,da2,0,5,1);
8758         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,0,da2,4,6,1);
8759         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,3,da2,5,0,1);
8760         dac.setContigPartOfSelectedValues2(3,da2,1,5,1);
8761         expected4=[1,11,2,12,3,13,9,39,0,30,11,41,12,42]
8762         for i in xrange(14):
8763             self.assertEqual(expected4[i],dac.getIJ(0,i));
8764             pass
8765         #
8766         ids=DataArrayInt.New();
8767         ids.alloc(3,1);
8768         dac=da.deepCpy();
8769         ids.setIJ(0,0,2); ids.setIJ(1,0,0); ids.setIJ(2,0,4);
8770         dac.setContigPartOfSelectedValues(2,da2,ids);
8771         expected5=[1,11,2,12,0,30,8,38,12,42,6,16,7,17]
8772         for i in xrange(14):
8773             self.assertEqual(expected5[i],dac.getIJ(0,i));
8774             pass
8775         #
8776         dac=da.deepCpy();
8777         ids.setIJ(0,0,2); ids.setIJ(1,0,5); ids.setIJ(2,0,4);
8778         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,1,da2,ids);
8779         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,-1);
8780         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,1,da2,ids);
8781         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,1);
8782         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,5,da2,ids);
8783         #
8784         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,1);
8785         dac=da.deepCpy();
8786         dac.setContigPartOfSelectedValues(4,da2,ids);
8787         expected6=[1,11,2,12,3,13,4,14,0,30,0,30,9,39]
8788         for i in xrange(14):
8789             self.assertEqual(expected6[i],dac.getIJ(0,i));
8790             pass
8791         pass
8792
8793     def testBuildDescendingConnec2Of3DMesh1(self):
8794         mesh=MEDCouplingDataForTest.build3DSourceMesh_1();
8795         #
8796         mesh2,desc,descIndx,revDesc,revDescIndx=mesh.buildDescendingConnectivity2();
8797         mesh2.checkCoherency();
8798         self.assertEqual(2,mesh2.getMeshDimension());
8799         self.assertEqual(30,mesh2.getNumberOfCells());
8800         self.assertEqual(31,revDescIndx.getNbOfElems()); self.assertEqual(31,revDescIndx.getNumberOfTuples());
8801         self.assertEqual(13,descIndx.getNbOfElems()); self.assertEqual(13,descIndx.getNumberOfTuples());
8802         self.assertEqual(48,desc.getNbOfElems()); self.assertEqual(48,desc.getNumberOfTuples());
8803         self.assertEqual(48,revDesc.getNbOfElems()); self.assertEqual(48,revDesc.getNumberOfTuples());
8804         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]
8805         self.assertEqual(expected1,desc.getValues());
8806         expected2=[0,4,8,12,16,20,24,28,32,36,40,44,48]
8807         self.assertEqual(expected2,descIndx.getValues());
8808         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]
8809         self.assertEqual(expected3,revDescIndx.getValues());
8810         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]
8811         self.assertEqual(expected4,revDesc.getValues());
8812         conn=mesh2.getNodalConnectivity();
8813         connIndex=mesh2.getNodalConnectivityIndex();
8814         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]
8815         self.assertEqual(expected5,connIndex.getValues());
8816         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]
8817         self.assertEqual(expected6,conn.getValues());
8818         pass
8819
8820     def testAre2DCellsNotCorrectlyOriented1(self):
8821         m1Coords=[1.,1.,-1.,-1.,-1.,-1.,1.,-1.]
8822         m1Conn=[0,3,1,2]
8823         m1=MEDCouplingUMesh.New();
8824         m1.setMeshDimension(2);
8825         m1.allocateCells(1);
8826         m1.insertNextCell(NORM_QUAD4,4,m1Conn[0:4])
8827         m1.finishInsertingCells();
8828         myCoords1=DataArrayDouble.New();
8829         myCoords1.setValues(m1Coords,4,2);
8830         m1.setCoords(myCoords1);
8831         #
8832         vec1=[0.,0.,1.]
8833         for i in xrange(18):
8834             vec2=[3.*cos(pi/9.*i),3.*sin(pi/9.*i)];
8835             m1Cpy=m1.deepCpy();
8836             m1Cpy.translate(vec2);
8837             self.assertRaises(InterpKernelException,m1Cpy.are2DCellsNotCorrectlyOriented,vec1,False);
8838             m1Cpy.changeSpaceDimension(3);
8839             res=m1Cpy.are2DCellsNotCorrectlyOriented(vec1,False)
8840             self.assertEqual([0],res.getValues());
8841             pass
8842         pass
8843
8844     def testDataArrayAbs1(self):
8845         d1=DataArrayDouble.New();
8846         val1=[2.,-3.,-5.,6.,-7.,-8.,9.,10.,-11.,-12.,-13.,-15.]
8847         expected1=[2.,3.,5.,6.,7.,8.,9.,10.,11.,12.,13.,15.]
8848         d1.setValues(val1,6,2);
8849         d2=d1.convertToIntArr();
8850         #
8851         d1.abs();
8852         for i in xrange(12):
8853             self.assertAlmostEqual(expected1[i],d1.getIJ(0,i),14);
8854             pass
8855         #
8856         expected2=[2,3,5,6,7,8,9,10,11,12,13,15]
8857         d2.abs();
8858         for i in xrange(12):
8859             self.assertEqual(expected2[i],d2.getIJ(0,i));
8860             pass
8861         #
8862         pass
8863
8864     # test on 1D
8865     def testGetValueOn3(self):
8866         v=[0.,1.,1.5,2.]
8867         v2=[0.7,1.25,0.,2.,1.5]
8868         disp=[5.,50.,500.,6.,60.,600.,7.,70.,700.,8.,80.,800.]
8869         m=MEDCouplingUMesh.New("myMesh",1)
8870         nbNodes=len(v)
8871         nbCells=nbNodes-1
8872         m.allocateCells(nbCells)
8873         coords=DataArrayDouble.New() ; coords.setValues(v,nbNodes,1)
8874         m.setCoords(coords)
8875         m.insertNextCell(NORM_SEG2,2,[0,1])
8876         m.insertNextCell(NORM_SEG2,2,[2,1])
8877         m.insertNextCell(NORM_SEG2,2,[2,3])
8878         m.finishInsertingCells()
8879         f=MEDCouplingFieldDouble.New(ON_NODES)
8880         f.setMesh(m)
8881         array=DataArrayDouble.New(); array.setValues(disp,m.getNumberOfNodes(),3)
8882         f.setArray(array)
8883         arr1=f.getValueOnMulti(v2)
8884         self.assertEqual(5,arr1.getNumberOfTuples());
8885         self.assertEqual(3,arr1.getNumberOfComponents());
8886         expected1=[5.7,57.,570.,6.5,65.,650.,5.,50.,500.,8.,80.,800.,7.,70.,700.]
8887         for i in xrange(15):
8888             self.assertAlmostEqual(expected1[i],arr1.getIJ(0,i),14);
8889             pass
8890         pass
8891
8892     def testGetNodeIdsOfCell2(self):
8893         m1c=MEDCouplingCMesh.New();
8894         coordsX=DataArrayDouble.New();
8895         arrX=[ -1., 1., 2., 4., 4.5 ]
8896         coordsX.setValues(arrX,5,1);
8897         coordsY=DataArrayDouble.New();
8898         arrY=[ -2., 2., 4., 8.]
8899         coordsY.setValues(arrY,4,1);
8900         coordsZ=DataArrayDouble.New();
8901         arrZ=[ -2., 2., 4.]
8902         coordsZ.setValues(arrZ,3,1);
8903         # test in 1D
8904         m1c.setCoordsAt(0,coordsX);
8905         expected1=[[0,1],[1,2],[2,3],[3,4]]
8906         self.assertEqual(4,m1c.getNumberOfCells())
8907         for i in xrange(m1c.getNumberOfCells()):
8908             self.assertEqual(expected1[i],m1c.getNodeIdsOfCell(i))
8909             pass
8910         # test in 2D
8911         m1c.setCoordsAt(1,coordsY);
8912         self.assertEqual(12,m1c.getNumberOfCells())
8913         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]]
8914         for i in xrange(m1c.getNumberOfCells()):
8915             self.assertEqual(expected2[i],m1c.getNodeIdsOfCell(i))
8916             pass
8917         # test in 3D
8918         m1c.setCoordsAt(2,coordsZ);
8919         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]]
8920         self.assertEqual(24,m1c.getNumberOfCells())
8921         for i in xrange(m1c.getNumberOfCells()):
8922             self.assertEqual(expected3[i],m1c.getNodeIdsOfCell(i))
8923             pass
8924         pass
8925
8926     def testSwigDADOp4(self):
8927         da=DataArrayDouble.New(range(6,30),12,2)
8928         self.assertEqual(12,da.getNumberOfTuples());
8929         self.assertEqual(2,da.getNumberOfComponents());
8930         for i in xrange(24):
8931             self.assertAlmostEqual(da.getIJ(0,i),float(i+6),13)
8932             pass
8933         # operator transpose
8934         da.transpose()
8935         self.assertEqual(2,da.getNumberOfTuples());
8936         self.assertEqual(12,da.getNumberOfComponents());
8937         for i in xrange(24):
8938             self.assertAlmostEqual(da.getIJ(0,i),float(i+6),13)
8939             pass
8940         da.transpose()
8941         # operator __neg__
8942         da2=DataArrayDouble.New(12,1)
8943         da2.iota(0.)
8944         dabis=-da
8945         for i in xrange(24):
8946             self.assertAlmostEqual(dabis.getIJ(0,i),-float(i+6),13)
8947             pass
8948         # operator+=
8949         da+=da2
8950         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.]
8951         for i in xrange(24):
8952             self.assertAlmostEqual(da.getIJ(0,i),expected1[i],13)
8953             pass
8954         da=-dabis
8955         da+=[100.,101.]
8956         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.]
8957         self.assertEqual(12,da.getNumberOfTuples());
8958         self.assertEqual(2,da.getNumberOfComponents());
8959         for i in xrange(24):
8960             self.assertAlmostEqual(da.getIJ(0,i),expected2[i],13)
8961             pass
8962         for pos,elt in enumerate(dabis):
8963             da[pos]+=elt
8964             pass
8965         self.assertEqual(12,da.getNumberOfTuples());
8966         self.assertEqual(2,da.getNumberOfComponents());
8967         for elt in da:
8968             li=elt[:]
8969             self.assertAlmostEqual(li[0],100.,13) ; self.assertAlmostEqual(li[1],101.,13)
8970             pass
8971         # operator-=
8972         da=DataArrayDouble.New(range(6,30),12,2)
8973         da2=DataArrayDouble.New(range(12),12,1)
8974         dabis=-da
8975         da-=da2
8976         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.]
8977         for i in xrange(24):
8978             self.assertAlmostEqual(da.getIJ(0,i),expected1[i],13)
8979             pass
8980         da=-dabis
8981         da-=[100.,101.]
8982         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.]
8983         self.assertEqual(12,da.getNumberOfTuples());
8984         self.assertEqual(2,da.getNumberOfComponents());
8985         for i in xrange(24):
8986             self.assertAlmostEqual(da.getIJ(0,i),expected2[i],13)
8987             pass
8988         for pos,elt in enumerate(dabis):
8989             da[pos]-=elt
8990             pass
8991         self.assertEqual(12,da.getNumberOfTuples());
8992         self.assertEqual(2,da.getNumberOfComponents());
8993         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.]
8994         for i in xrange(24):
8995             self.assertAlmostEqual(da.getIJ(0,i),expected3[i],13)
8996             pass
8997         # operator*=
8998         da=DataArrayDouble.New(range(6,30),12,2)
8999         da2=DataArrayDouble.New(range(12),12,1)
9000         dabis=-da
9001         da*=da2
9002         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.]
9003         for i in xrange(24):
9004             self.assertAlmostEqual(da.getIJ(0,i),expected1[i],13)
9005             pass
9006         da=-dabis
9007         da*=[100.,101.]
9008         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.]
9009         self.assertEqual(12,da.getNumberOfTuples());
9010         self.assertEqual(2,da.getNumberOfComponents());
9011         for i in xrange(24):
9012             self.assertAlmostEqual(da.getIJ(0,i),expected2[i],13)
9013             pass
9014         for pos,elt in enumerate(dabis):
9015             da[pos]*=elt
9016             pass
9017         self.assertEqual(12,da.getNumberOfTuples());
9018         self.assertEqual(2,da.getNumberOfComponents());
9019         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]
9020         for i in xrange(24):
9021             self.assertAlmostEqual(da.getIJ(0,i),expected3[i],13)
9022             pass
9023         # operator/=
9024         da=DataArrayDouble.New(range(6,30),12,2)
9025         da2=DataArrayDouble.New(range(1,13),12,1)
9026         dabis=-da
9027         da/=da2
9028         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]
9029         for i in xrange(24):
9030             self.assertAlmostEqual(da.getIJ(0,i),expected1[i],13)
9031             pass
9032         da=-dabis
9033         da/=[100.,101.]
9034         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]
9035         self.assertEqual(12,da.getNumberOfTuples());
9036         self.assertEqual(2,da.getNumberOfComponents());
9037         for i in xrange(24):
9038             self.assertAlmostEqual(da.getIJ(0,i),expected2[i],13)
9039             pass
9040         for pos,elt in enumerate(dabis):
9041             da[pos]/=elt
9042             pass
9043         self.assertEqual(12,da.getNumberOfTuples());
9044         self.assertEqual(2,da.getNumberOfComponents());
9045         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]
9046         for i in xrange(24):
9047             self.assertAlmostEqual(da.getIJ(0,i),expected3[i],13)
9048             pass
9049         pass
9050
9051     def testSwigDAIOp4(self):
9052         da=DataArrayInt.New(range(6,30),12,2)
9053         self.assertEqual(12,da.getNumberOfTuples());
9054         self.assertEqual(2,da.getNumberOfComponents());
9055         for i in xrange(24):
9056             self.assertEqual(da.getIJ(0,i),i+6)
9057             pass
9058         # operator transpose
9059         da.transpose()
9060         self.assertEqual(2,da.getNumberOfTuples());
9061         self.assertEqual(12,da.getNumberOfComponents());
9062         for i in xrange(24):
9063             self.assertEqual(da.getIJ(0,i),i+6)
9064             pass
9065         da.transpose()
9066         # operator __neg__
9067         da2=DataArrayInt.New(12,1)
9068         da2.iota(0)
9069         dabis=-da
9070         for i in xrange(24):
9071             self.assertEqual(dabis.getIJ(0,i),-(i+6))
9072             pass
9073         # operator+=
9074         da+=da2
9075         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]
9076         for i in xrange(24):
9077             self.assertEqual(da.getIJ(0,i),expected1[i])
9078             pass
9079         da=-dabis
9080         da+=[100,101]
9081         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]
9082         self.assertEqual(12,da.getNumberOfTuples());
9083         self.assertEqual(2,da.getNumberOfComponents());
9084         for i in xrange(24):
9085             self.assertEqual(da.getIJ(0,i),expected2[i])
9086             pass
9087         for pos,elt in enumerate(dabis):
9088             da[pos]+=elt
9089             pass
9090         self.assertEqual(12,da.getNumberOfTuples());
9091         self.assertEqual(2,da.getNumberOfComponents());
9092         for elt in da:
9093             li=elt[:]
9094             self.assertEqual(li[0],100) ; self.assertEqual(li[1],101)
9095             pass
9096         # operator-=
9097         da=DataArrayInt.New(range(6,30),12,2)
9098         da2=DataArrayInt.New(range(12),12,1)
9099         dabis=-da
9100         da-=da2
9101         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]
9102         for i in xrange(24):
9103             self.assertEqual(da.getIJ(0,i),expected1[i])
9104             pass
9105         da=-dabis
9106         da-=[100,101]
9107         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]
9108         self.assertEqual(12,da.getNumberOfTuples());
9109         self.assertEqual(2,da.getNumberOfComponents());
9110         for i in xrange(24):
9111             self.assertEqual(da.getIJ(0,i),expected2[i])
9112             pass
9113         for pos,elt in enumerate(dabis):
9114             da[pos]-=elt
9115             pass
9116         self.assertEqual(12,da.getNumberOfTuples());
9117         self.assertEqual(2,da.getNumberOfComponents());
9118         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]
9119         for i in xrange(24):
9120             self.assertEqual(da.getIJ(0,i),expected3[i])
9121             pass
9122         # operator*=
9123         da=DataArrayInt.New(range(6,30),12,2)
9124         da2=DataArrayInt.New(range(12),12,1)
9125         dabis=-da
9126         da*=da2
9127         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]
9128         for i in xrange(24):
9129             self.assertEqual(da.getIJ(0,i),expected1[i])
9130             pass
9131         da=-dabis
9132         da*=[100,101]
9133         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]
9134         self.assertEqual(12,da.getNumberOfTuples());
9135         self.assertEqual(2,da.getNumberOfComponents());
9136         for i in xrange(24):
9137             self.assertEqual(da.getIJ(0,i),expected2[i])
9138             pass
9139         for pos,elt in enumerate(dabis):
9140             da[pos]*=elt
9141             pass
9142         self.assertEqual(12,da.getNumberOfTuples());
9143         self.assertEqual(2,da.getNumberOfComponents());
9144         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]
9145         for i in xrange(24):
9146             self.assertEqual(da.getIJ(0,i),expected3[i])
9147             pass
9148         # operator/=
9149         da=DataArrayInt.New(range(6,30),12,2)
9150         da2=DataArrayInt.New(range(1,13),12,1)
9151         dabis=-da
9152         da/=da2
9153         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]
9154         for i in xrange(24):
9155             self.assertEqual(da.getIJ(0,i),expected1[i])
9156             pass
9157         da=-dabis
9158         da/=DataArrayInt.New([2,3],1,2)
9159         self.assertEqual(12,da.getNumberOfTuples());
9160         self.assertEqual(2,da.getNumberOfComponents());
9161         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]
9162         for i in xrange(24):
9163             self.assertEqual(da.getIJ(0,i),expected2[i])
9164             pass
9165         pass
9166
9167     def testSwigDADOp5(self):
9168         da=DataArrayDouble.New([5,6,7,8,9,6,7,-2,3,9,8,10])
9169         da.rearrange(3)
9170         da2=DataArrayDouble.New([5.,8.,10.,12])
9171         self.assertEqual(4,da2.getNumberOfTuples());
9172         self.assertEqual(1,da2.getNumberOfComponents());
9173         da3=da+da2
9174         self.assertEqual(4,da3.getNumberOfTuples());
9175         self.assertEqual(3,da3.getNumberOfComponents());
9176         expected1=[10.,11.,12.,16.,17.,14.,17.,8.,13.,21.,20.,22.]
9177         for i in xrange(12):
9178             self.assertAlmostEqual(da3.getIJ(0,i),expected1[i],13)
9179             pass
9180         da3=da2+da
9181         self.assertEqual(4,da3.getNumberOfTuples());
9182         self.assertEqual(3,da3.getNumberOfComponents());
9183         for i in xrange(12):
9184             self.assertAlmostEqual(da3.getIJ(0,i),expected1[i],13)
9185             pass
9186         # Test new API of classmethod DataArrayDouble.New
9187         vals=[5,6,7,8,9,6,7,-2,3,9,8,10]
9188         da=DataArrayDouble.New(vals)
9189         self.assertEqual(12,da.getNumberOfTuples());
9190         self.assertEqual(1,da.getNumberOfComponents());
9191         for i in xrange(12):
9192             self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
9193             pass
9194         da=DataArrayDouble.New(vals,12)
9195         self.assertEqual(12,da.getNumberOfTuples());
9196         self.assertEqual(1,da.getNumberOfComponents());
9197         for i in xrange(12):
9198             self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
9199             pass
9200         da=DataArrayDouble.New(vals,1,12)
9201         self.assertEqual(1,da.getNumberOfTuples());
9202         self.assertEqual(12,da.getNumberOfComponents());
9203         for i in xrange(12):
9204             self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
9205             pass
9206         da=DataArrayDouble.New(vals,6,2)
9207         self.assertEqual(6,da.getNumberOfTuples());
9208         self.assertEqual(2,da.getNumberOfComponents());
9209         for i in xrange(12):
9210             self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
9211             pass
9212         da=DataArrayDouble.New(vals,4,3)
9213         self.assertEqual(4,da.getNumberOfTuples());
9214         self.assertEqual(3,da.getNumberOfComponents());
9215         for i in xrange(12):
9216             self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
9217             pass
9218         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,11);
9219         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,13);
9220         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,5,2);
9221         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,7,2);
9222         pass
9223
9224     def testSwigDADOp6(self):
9225         da=DataArrayInt.New([5,6,7,8,9,6,7,-2,3,9,8,10])
9226         da.rearrange(3)
9227         da2=DataArrayInt.New([5,8,10,12])
9228         self.assertEqual(4,da2.getNumberOfTuples());
9229         self.assertEqual(1,da2.getNumberOfComponents());
9230         da3=da+da2
9231         self.assertEqual(4,da3.getNumberOfTuples());
9232         self.assertEqual(3,da3.getNumberOfComponents());
9233         expected1=[10,11,12,16,17,14,17,8,13,21,20,22]
9234         for i in xrange(12):
9235             self.assertEqual(da3.getIJ(0,i),expected1[i])
9236             pass
9237         da3=da2+da
9238         self.assertEqual(4,da3.getNumberOfTuples());
9239         self.assertEqual(3,da3.getNumberOfComponents());
9240         for i in xrange(12):
9241             self.assertEqual(da3.getIJ(0,i),expected1[i])
9242             pass
9243         da3=da+DataArrayInt.New(da2.getValues())
9244         # Test new API of classmethod DataArrayInt.New
9245         vals=[5,6,7,8,9,6,7,-2,3,9,8,10]
9246         da=DataArrayDouble.New(vals)
9247         self.assertEqual(12,da.getNumberOfTuples());
9248         self.assertEqual(1,da.getNumberOfComponents());
9249         for i in xrange(12):
9250             self.assertEqual(da.getIJ(0,i),vals[i])
9251             pass
9252         da=DataArrayDouble.New(vals,12)
9253         self.assertEqual(12,da.getNumberOfTuples());
9254         self.assertEqual(1,da.getNumberOfComponents());
9255         for i in xrange(12):
9256             self.assertEqual(da.getIJ(0,i),vals[i])
9257             pass
9258         da=DataArrayDouble.New(vals,1,12)
9259         self.assertEqual(1,da.getNumberOfTuples());
9260         self.assertEqual(12,da.getNumberOfComponents());
9261         for i in xrange(12):
9262             self.assertEqual(da.getIJ(0,i),vals[i])
9263             pass
9264         da=DataArrayDouble.New(vals,6,2)
9265         self.assertEqual(6,da.getNumberOfTuples());
9266         self.assertEqual(2,da.getNumberOfComponents());
9267         for i in xrange(12):
9268             self.assertEqual(da.getIJ(0,i),vals[i])
9269             pass
9270         da=DataArrayDouble.New(vals,4,3)
9271         self.assertEqual(4,da.getNumberOfTuples());
9272         self.assertEqual(3,da.getNumberOfComponents());
9273         for i in xrange(12):
9274             self.assertEqual(da.getIJ(0,i),vals[i])
9275             pass
9276         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,11);
9277         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,13);
9278         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,5,2);
9279         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,7,2);
9280         pass
9281
9282     def testSwigDADOp9(self):
9283         l1=[(1.,2.,3),(4.,5.,6.),(7.,8.,9.),[10.,11.,12.]]
9284         da1=DataArrayDouble(l1,4,3)
9285         self.assertEqual(4,da1.getNumberOfTuples());
9286         self.assertEqual(3,da1.getNumberOfComponents());
9287         da2=DataArrayDouble(12) ; da2.iota(1.) ; da2.rearrange(3)
9288         self.assertTrue(da2.isEqual(da1,1e-12))
9289         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,3,4);
9290         da3=DataArrayDouble(l1,4)
9291         self.assertTrue(da3.isEqual(da1,1e-12))
9292         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,3);
9293         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,5);
9294         l1=[(1.,2.,3),(4.,(5.),((6.))),(7.,8.,9.),[10.,11.,12.]]
9295         da1=DataArrayDouble(l1,4,3)
9296         self.assertEqual(4,da1.getNumberOfTuples());
9297         self.assertEqual(3,da1.getNumberOfComponents());
9298         da2=DataArrayDouble(12) ; da2.iota(1.) ; da2.rearrange(3)
9299         self.assertTrue(da2.isEqual(da1,1e-12))
9300         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,3,4);
9301         da3=DataArrayDouble(l1,4)
9302         self.assertTrue(da3.isEqual(da1,1e-12))
9303         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,3);
9304         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,5);
9305         #
9306         l1=[(1,2,3),(4,5,6),(7,8,9),[10,11,12]]
9307         da1=DataArrayInt(l1,4,3)
9308         self.assertEqual(4,da1.getNumberOfTuples());
9309         self.assertEqual(3,da1.getNumberOfComponents());
9310         da2=DataArrayInt(12) ; da2.iota(1) ; da2.rearrange(3)
9311         self.assertTrue(da2.isEqual(da1))
9312         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,3,4);
9313         da3=DataArrayInt(l1,4)
9314         self.assertTrue(da3.isEqual(da1))
9315         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,3);
9316         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,5);
9317         l1=[(1,[2],3),(4,[(5)],6),((([7])),8,9),[10,11,12]]
9318         da1=DataArrayInt(l1,4,3)
9319         self.assertEqual(4,da1.getNumberOfTuples());
9320         self.assertEqual(3,da1.getNumberOfComponents());
9321         da2=DataArrayInt(12) ; da2.iota(1) ; da2.rearrange(3)
9322         self.assertTrue(da2.isEqual(da1))
9323         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,3,4);
9324         da3=DataArrayInt(l1,4)
9325         self.assertTrue(da3.isEqual(da1))
9326         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,3);
9327         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,5);
9328         pass
9329
9330     def testRenumberNodesInConn1(self):
9331         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. ]
9332         mesh2DConn=[1,4,2, 4,5,2, 0,3,4,1, 6,7,4,3, 7,8,5,4]
9333         mesh2D=MEDCouplingUMesh.New("mesh",2);
9334         mesh2D.allocateCells(5);
9335         mesh2D.insertNextCell(NORM_TRI3,3,mesh2DConn[0:3])
9336         mesh2D.insertNextCell(NORM_TRI3,3,mesh2DConn[3:6])
9337         mesh2D.insertNextCell(NORM_QUAD4,4,mesh2DConn[6:10])
9338         mesh2D.insertNextCell(NORM_QUAD4,4,mesh2DConn[10:14])
9339         mesh2D.insertNextCell(NORM_QUAD4,4,mesh2DConn[14:18])
9340         mesh2D.finishInsertingCells();
9341         myCoords=DataArrayDouble.New(mesh2DCoords,9,3);
9342         mesh2D.setCoords(myCoords);
9343         mesh2D.checkCoherency();
9344         #
9345         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. ]
9346         mesh3DConn=[0,1,2,3,4,5,6,7]
9347         mesh3D=MEDCouplingUMesh.New("mesh",3);
9348         mesh3D.allocateCells(1);
9349         mesh3D.insertNextCell(NORM_HEXA8,8,mesh3DConn[:])
9350         mesh3D.finishInsertingCells();
9351         myCoords3D=DataArrayDouble.New(mesh3DCoords,8,3);
9352         mesh3D.setCoords(myCoords3D);
9353         mesh3D.checkCoherency();
9354         #
9355         mesh3D_2=mesh3D.deepCpy();
9356         mesh2D_2=mesh2D.deepCpy();
9357         mesh3D_4=mesh3D.deepCpy();
9358         mesh2D_4=mesh2D.deepCpy();
9359         oldNbOf3DNodes=mesh3D.getNumberOfNodes();
9360         renumNodes=DataArrayInt.New();
9361         renumNodes.alloc(mesh2D.getNumberOfNodes(),1);
9362         renumNodes.iota(oldNbOf3DNodes);
9363         coo=DataArrayDouble.Aggregate(mesh3D.getCoords(),mesh2D.getCoords());
9364         mesh3D.setCoords(coo);
9365         mesh2D.setCoords(coo);
9366         mesh2DCpy=mesh2D.deepCpy()
9367         mesh2D_3=mesh2D.deepCpy();
9368         mesh2D_3.shiftNodeNumbersInConn(oldNbOf3DNodes);
9369         mesh2D.renumberNodesInConn(renumNodes);
9370         mesh2DCpy.renumberNodesInConn(renumNodes.getValues());
9371         self.assertTrue(mesh2D.isEqual(mesh2DCpy,1e-12))
9372         self.assertTrue(mesh2D.isEqual(mesh2D_3,1e-12))
9373         #
9374         da1,da2=mesh3D.checkGeoEquivalWith(mesh3D_2,10,1e-12);
9375         self.assertTrue(da1==None);
9376         self.assertEqual(8,da2.getNumberOfTuples());
9377         self.assertEqual(1,da2.getNumberOfComponents());
9378         expected1=[8,11,12,9,4,5,6,7]
9379         for i in xrange(8):
9380             self.assertEqual(expected1[i],da2.getIJ(i,0));
9381             pass
9382         #
9383         da1,da2=mesh2D.checkGeoEquivalWith(mesh2D_2,10,1e-12);
9384         self.assertTrue(da1==None);
9385         self.assertEqual(9,da2.getNumberOfTuples());
9386         self.assertEqual(1,da2.getNumberOfComponents());
9387         for i in xrange(9):
9388             self.assertEqual(8+i,da2.getIJ(i,0));
9389             pass
9390         #
9391         mesh2D_5=mesh2D_4.deepCpy();
9392         mesh2D_5.translate([1.,0.,0.]);
9393         meshes=[mesh3D_4,mesh2D_4,mesh2D_5];
9394         MEDCouplingUMesh.PutUMeshesOnSameAggregatedCoords(meshes);
9395         self.assertTrue(mesh3D_4.getCoords().getHiddenCppPointer()==mesh2D_4.getCoords().getHiddenCppPointer());
9396         self.assertTrue(mesh2D_4.getCoords().getHiddenCppPointer()==mesh2D_5.getCoords().getHiddenCppPointer());
9397         mesh3D_4.checkCoherency(); mesh2D_4.checkCoherency(); mesh2D_5.checkCoherency();
9398         self.assertEqual(26,mesh3D_4.getNumberOfNodes());
9399         self.assertEqual(3,mesh3D_4.getSpaceDimension());
9400         self.assertEqual(9,mesh3D_4.getNodalConnectivity().getNumberOfTuples());
9401         self.assertEqual(23,mesh2D_4.getNodalConnectivity().getNumberOfTuples());
9402         self.assertEqual(23,mesh2D_5.getNodalConnectivity().getNumberOfTuples());
9403         expected2=[18,0,1,2,3,4,5,6,7]
9404         expected3=[3,9,12,10, 3,12,13,10, 4,8,11,12,9, 4,14,15,12,11, 4,15,16,13,12]
9405         expected4=[3,18,21,19, 3,21,22,19, 4,17,20,21,18, 4,23,24,21,20, 4,24,25,22,21]
9406         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]
9407         self.assertEqual(expected2,mesh3D_4.getNodalConnectivity().getValues());
9408         self.assertEqual(expected3,mesh2D_4.getNodalConnectivity().getValues());
9409         self.assertEqual(expected4,mesh2D_5.getNodalConnectivity().getValues());
9410         for i in xrange(78):
9411             self.assertAlmostEqual(expected5[i],mesh3D_4.getCoords().getIJ(0,i),12);
9412             pass
9413         #
9414         MEDCouplingUMesh.MergeNodesOnUMeshesSharingSameCoords(meshes,1e-12);
9415         mesh3D_4.checkCoherency(); mesh2D_4.checkCoherency(); mesh2D_5.checkCoherency();
9416         self.assertTrue(mesh3D_4.getCoords().getHiddenCppPointer()==mesh2D_4.getCoords().getHiddenCppPointer());
9417         self.assertTrue(mesh2D_4.getCoords().getHiddenCppPointer()==mesh2D_5.getCoords().getHiddenCppPointer());
9418         self.assertEqual(19,mesh3D_4.getNumberOfNodes());
9419         self.assertEqual(3,mesh3D_4.getSpaceDimension());
9420         self.assertEqual(9,mesh3D_4.getNodalConnectivity().getNumberOfTuples());
9421         self.assertEqual(23,mesh2D_4.getNodalConnectivity().getNumberOfTuples());
9422         self.assertEqual(23,mesh2D_5.getNodalConnectivity().getNumberOfTuples());
9423         expected6=[18,0,1,2,3,4,5,6,7]
9424         expected7=[3,3,2,8, 3,2,9,8, 4,0,1,2,3, 4,10,11,2,1, 4,11,12,9,2]
9425         expected8=[3,13,15,14, 3,15,16,14, 4,8,9,15,13, 4,12,17,15,9, 4,17,18,16,15]
9426         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.,
9427                     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.,
9428                     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.]
9429         self.assertEqual(expected6,mesh3D_4.getNodalConnectivity().getValues());
9430         self.assertEqual(expected7,mesh2D_4.getNodalConnectivity().getValues());
9431         self.assertEqual(expected8,mesh2D_5.getNodalConnectivity().getValues());
9432         for i in xrange(57):
9433             self.assertAlmostEqual(expected9[i],mesh3D_4.getCoords().getIJ(0,i),12);
9434             pass
9435         #
9436         pass
9437
9438     def testComputeNeighborsOfCells1(self):
9439         m=MEDCouplingDataForTest.build2DTargetMesh_1();
9440         d1,d2=m.computeNeighborsOfCells();
9441         self.assertEqual(6,d2.getNumberOfTuples());
9442         self.assertEqual(10,d1.getNumberOfTuples());
9443         expected1=[0,2,4,6,8,10]
9444         expected2=[3,1,0,2,4,1,4,0,2,3]
9445         self.assertEqual(expected1,d2.getValues());
9446         self.assertEqual(expected2,d1.getValues());
9447         pass
9448
9449     def testCheckButterflyCellsBug1(self):
9450         mesh2DCoords=[323.85,120.983748908684,317.5,131.982271536747,336.55,120.983748908686,330.2,131.982271536751,323.85,142.98079416481]
9451         mesh2DConn=[4,1,0,2,3]
9452         mesh2D=MEDCouplingUMesh.New("mesh",2);
9453         mesh2D.allocateCells(1);
9454         mesh2D.insertNextCell(NORM_POLYGON,5,mesh2DConn[0:5])
9455         mesh2D.finishInsertingCells();
9456         myCoords=DataArrayDouble.New(mesh2DCoords,5,2);
9457         mesh2D.setCoords(myCoords);
9458         mesh2D.checkCoherency();
9459         #
9460         v=mesh2D.checkButterflyCells();
9461         self.assertTrue(v.empty());
9462         pass
9463
9464     def testDataArrayIntRange1(self):
9465         d=DataArrayInt.Range(2,17,7);
9466         expected1=[2,9,16]
9467         self.assertEqual(3,d.getNumberOfTuples());
9468         self.assertEqual(1,d.getNumberOfComponents());
9469         self.assertEqual(expected1,d.getValues());
9470         #
9471         d=DataArrayInt.Range(2,23,7);
9472         self.assertEqual(3,d.getNumberOfTuples());
9473         self.assertEqual(1,d.getNumberOfComponents());
9474         self.assertEqual(expected1,d.getValues());
9475         #
9476         d=DataArrayInt.Range(2,24,7);
9477         expected2=[2,9,16,23]
9478         self.assertEqual(4,d.getNumberOfTuples());
9479         self.assertEqual(1,d.getNumberOfComponents());
9480         self.assertEqual(expected2,d.getValues());
9481         #
9482         d=DataArrayInt.Range(24,2,-7);
9483         expected3=[24,17,10,3]
9484         self.assertEqual(4,d.getNumberOfTuples());
9485         self.assertEqual(1,d.getNumberOfComponents());
9486         self.assertEqual(expected3,d.getValues());
9487         #
9488         d=DataArrayInt.Range(23,2,-7);
9489         expected4=[23,16,9]
9490         self.assertEqual(3,d.getNumberOfTuples());
9491         self.assertEqual(1,d.getNumberOfComponents());
9492         self.assertEqual(expected4,d.getValues());
9493         #
9494         d=DataArrayInt.Range(23,22,-7);
9495         self.assertEqual(1,d.getNumberOfTuples());
9496         self.assertEqual(1,d.getNumberOfComponents());
9497         self.assertEqual(23,d.getIJ(0,0));
9498         #
9499         d=DataArrayInt.Range(22,23,7);
9500         self.assertEqual(1,d.getNumberOfTuples());
9501         self.assertEqual(1,d.getNumberOfComponents());
9502         self.assertEqual(22,d.getIJ(0,0));
9503         #
9504         d=DataArrayInt.Range(22,22,7);
9505         self.assertEqual(0,d.getNumberOfTuples());
9506         self.assertEqual(1,d.getNumberOfComponents());
9507         #
9508         d=DataArrayInt.Range(22,22,-7);
9509         self.assertEqual(0,d.getNumberOfTuples());
9510         self.assertEqual(1,d.getNumberOfComponents());
9511         #
9512         self.assertRaises(InterpKernelException,DataArrayInt.Range,22,23,-7);
9513         self.assertRaises(InterpKernelException,DataArrayInt.Range,23,22,7);
9514         self.assertRaises(InterpKernelException,DataArrayInt.Range,23,22,0);
9515         self.assertRaises(InterpKernelException,DataArrayInt.Range,22,23,0);
9516         pass
9517
9518     def testSwigUMeshGetItem1(self):
9519         m=MEDCouplingDataForTest.build2DTargetMesh_1();
9520         subMesh=m.buildPartOfMySelf([1,3],True);
9521         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
9522         m1=m[[1,3]]
9523         self.assertTrue(isinstance(m1,MEDCouplingUMesh))
9524         m2=m[(1,3)]
9525         self.assertTrue(isinstance(m2,MEDCouplingUMesh))
9526         m3=m[1::2]
9527         self.assertTrue(isinstance(m3,MEDCouplingUMesh))
9528         m4=m[DataArrayInt.New([1,3])]
9529         m5_1=m[1]
9530         self.assertTrue(isinstance(m5_1,MEDCouplingUMesh))
9531         m5_2=m[3]
9532         self.assertTrue(isinstance(m5_2,MEDCouplingUMesh))
9533         m5=MEDCouplingUMesh.MergeUMeshesOnSameCoords([m5_1,m5_2]);
9534         m5.setName(subMesh.getName())
9535         self.assertTrue(isinstance(m4,MEDCouplingUMesh))
9536         self.assertTrue(subMesh.isEqual(m1,1e-12))
9537         self.assertTrue(subMesh.isEqual(m2,1e-12))
9538         self.assertTrue(subMesh.isEqual(m3,1e-12))
9539         self.assertTrue(subMesh.isEqual(m4,1e-12))
9540         self.assertTrue(subMesh.isEqual(m5,1e-12))
9541         self.assertRaises(InterpKernelException,m.buildPartOfMySelf,[1,5],True);
9542         pass
9543
9544     def testSwigGetItem3(self):
9545         da=DataArrayInt.New([4,5,6])
9546         self.assertEqual(5,da[1])
9547         self.assertRaises(InterpKernelException,da.__getitem__,-1)
9548         self.assertRaises(InterpKernelException,da.__getitem__,3)
9549         da=DataArrayInt.New([4,5,6,7,8,9],2,3)
9550         self.assertEqual(9,da[1,2])
9551         da=DataArrayDouble.New([4.1,5.2,6.3])
9552         self.assertAlmostEqual(5.2,da[1],12)
9553         self.assertRaises(InterpKernelException,da.__getitem__,-1)
9554         self.assertRaises(InterpKernelException,da.__getitem__,3)
9555         da=DataArrayDouble.New([4.12,5.12,6.12,7.12,8.12,9.12],2,3)
9556         self.assertAlmostEqual(9.12,da[1,2],12)
9557         pass
9558
9559     def testSwigDADISub1(self):
9560         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
9561         bary=mesh3D.getBarycenterAndOwner()
9562         bary=bary[:,:2]
9563         pts=bary.getDifferentValues(1e-12)
9564         expected=[[0,6,12],[1,7,13],[2,8,14],[3,9,15],[4,10,16],[5,11,17]]
9565         for pos,pt in enumerate(pts):
9566             bary2=bary[:,:2]
9567             bary2[:]-=pt
9568             norm=bary2.magnitude()
9569             self.assertEqual(expected[pos],norm.getIdsInRange(-1.,1e-5).getValues())
9570             pass
9571         expected2=[[3.,54.],[-141.,180.],[21.,54.],[39.,72.],[-15.,90.],[21.,90.]]
9572         for pos,pt in enumerate(pts):
9573             bary2=bary[:,:2]
9574             bary2[:]+=pt
9575             self.assertAlmostEqual(expected2[pos][0],bary2.accumulate()[0],12);
9576             self.assertAlmostEqual(expected2[pos][1],bary2.accumulate()[1],12);
9577             pass
9578         expected3=[[-3.,22.5],[45.,337.5],[-9., 22.5],[-15.,67.5],[3.,112.5],[-9.,112.5]]
9579         for pos,pt in enumerate(pts):
9580             bary2=bary[:,:2]
9581             bary2[:]*=pt
9582             self.assertAlmostEqual(expected3[pos][0],bary2.accumulate()[0],12);
9583             self.assertAlmostEqual(expected3[pos][1],bary2.accumulate()[1],12);
9584             pass
9585         expected4=[[-12.,90.],[0.8,6.],[-4,90.],[-2.4,30.],[12.,18],[-4,18.]]
9586         for pos,pt in enumerate(pts):
9587             bary2=bary[:,:2]
9588             bary2[:]/=pt
9589             self.assertAlmostEqual(expected4[pos][0],bary2.accumulate()[0],12);
9590             self.assertAlmostEqual(expected4[pos][1],bary2.accumulate()[1],12);
9591             pass
9592         #
9593         d=DataArrayInt.New([1,2,0,1,0,2],3,2)
9594         e=DataArrayInt.New([1,11,101,2,12,102,3,13,103,4,14,104],4,3)
9595         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]]
9596         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]]
9597         for pos,tup in enumerate(d):
9598             f=e[:]
9599             self.assertTrue(isinstance(f,DataArrayInt))
9600             f[tup]=77
9601             self.assertEqual(expected5[pos],f.getValues())
9602             self.assertEqual(6*[77],f[tup].getValues())
9603             f=e[:]
9604             f[:,tup]=77
9605             self.assertEqual(expected6[pos],f.getValues())
9606             self.assertEqual(8*[77],f[:,tup].getValues())
9607             pass
9608         #
9609         e=e.convertToDblArr()
9610         for pos,tup in enumerate(d):
9611             f=e[:]
9612             self.assertTrue(isinstance(f,DataArrayDouble))
9613             f[tup]=77.
9614             self.assertEqual(expected5[pos],f.convertToIntArr().getValues())
9615             self.assertEqual(6*[77],f[tup].convertToIntArr().getValues())
9616             f=e[:]
9617             f[:,tup]=77.
9618             self.assertEqual(expected6[pos],f.convertToIntArr().getValues())
9619             self.assertEqual(8*[77],f[:,tup].convertToIntArr().getValues())
9620             pass
9621         pass
9622
9623     def testDataArrayDoubleGetMinMaxPerComponent1(self):
9624         values1=[1.,2.,3.,-0.9,2.1,3.,1.3,1.7,3.,1.,1.8,3.]
9625         d1=DataArrayDouble.New();
9626         self.assertRaises(InterpKernelException,d1.getMinMaxPerComponent)
9627         d1=DataArrayDouble.New(values1,4,3);
9628         res=d1.getMinMaxPerComponent();
9629         self.assertTrue(isinstance(res,list))
9630         self.assertEqual(3,len(res))
9631         for i in xrange(3):
9632             self.assertTrue(isinstance(res[i],tuple))
9633             self.assertEqual(2,len(res[i]))
9634             pass
9635         expected1=[-0.9,1.3,1.7,2.1,3.,3.]
9636         for i in xrange(6):
9637             self.assertAlmostEqual(expected1[i],res[i/2][i%2],14)
9638             pass
9639         #
9640         d1.rearrange(2);
9641         res=d1.getMinMaxPerComponent();
9642         self.assertTrue(isinstance(res,list))
9643         self.assertEqual(2,len(res))
9644         for i in xrange(2):
9645             self.assertTrue(isinstance(res[i],tuple))
9646             self.assertEqual(2,len(res[i]))
9647             pass
9648         expected2=[1.,3.,-0.9,3.]
9649         for i in xrange(4):
9650             self.assertAlmostEqual(expected2[i],res[i/2][i%2],14)
9651             pass
9652         #
9653         d1.rearrange(1);
9654         res=d1.getMinMaxPerComponent();
9655         self.assertTrue(isinstance(res,list))
9656         self.assertEqual(1,len(res))
9657         for i in xrange(1):
9658             self.assertTrue(isinstance(res[i],tuple))
9659             self.assertEqual(2,len(res[i]))
9660             pass
9661         expected3=[-0.9,3.]
9662         for i in xrange(2):
9663             self.assertAlmostEqual(expected3[i],res[i/2][i%2],14)
9664             pass
9665         pass
9666
9667     def testDataArrayIntGetHashCode1(self):
9668         d1=DataArrayInt.New(range(3545))
9669         d2=DataArrayInt.New(range(3545))
9670         self.assertEqual(d2.getHashCode(),d1.getHashCode())
9671         self.assertEqual(232341068,d1.getHashCode())
9672         d1[886]=6
9673         self.assertEqual(232340188,d1.getHashCode())
9674         pass
9675
9676     def testZipConnectivityPol1(self):
9677         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
9678         cells1=[2,3,4]
9679         m2_1=m1.buildPartOfMySelf(cells1,True);
9680         m2=m2_1
9681         self.assertTrue(isinstance(m2,MEDCouplingUMesh))
9682         # no permutation policy 0
9683         isOk,arr=m1.areCellsIncludedIn(m2,0)
9684         self.assertTrue(isOk);
9685         self.assertEqual(3,arr.getNumberOfTuples());
9686         self.assertEqual(1,arr.getNumberOfComponents());
9687         self.assertEqual(cells1,arr.getValues())
9688         # no permutation policy 1
9689         isOk,arr=m1.areCellsIncludedIn(m2,1)
9690         self.assertTrue(isOk);
9691         self.assertEqual(3,arr.getNumberOfTuples());
9692         self.assertEqual(1,arr.getNumberOfComponents());
9693         self.assertEqual(cells1,arr.getValues())
9694         # no permutation policy 2
9695         isOk,arr=m1.areCellsIncludedIn(m2,2)
9696         self.assertTrue(isOk);
9697         self.assertEqual(3,arr.getNumberOfTuples());
9698         self.assertEqual(1,arr.getNumberOfComponents());
9699         self.assertEqual(cells1,arr.getValues())
9700         # some modification into m2
9701         modif1=[2,4,5]
9702         m2.getNodalConnectivity()[1:4]=modif1
9703         #policy 0 fails because cell0 in m2 has same orientation be not same connectivity
9704         expected1=[5,3,4]
9705         isOk,arr=m1.areCellsIncludedIn(m2,0)
9706         self.assertTrue(not isOk);
9707         self.assertEqual(3,arr.getNumberOfTuples());
9708         self.assertEqual(1,arr.getNumberOfComponents());
9709         self.assertEqual(expected1,arr.getValues())
9710         #policy 1 succeeds because cell0 in m2 has not exactly the same conn
9711         isOk,arr=m1.areCellsIncludedIn(m2,1)
9712         self.assertTrue(isOk);
9713         self.assertEqual(3,arr.getNumberOfTuples());
9714         self.assertEqual(1,arr.getNumberOfComponents());
9715         self.assertEqual(cells1,arr.getValues())
9716         #policy 2 succeeds because cell0 in m2 has same nodes in connectivity
9717         isOk,arr=m1.areCellsIncludedIn(m2,2)
9718         self.assertTrue(isOk);
9719         self.assertEqual(3,arr.getNumberOfTuples());
9720         self.assertEqual(1,arr.getNumberOfComponents());
9721         self.assertEqual(cells1,arr.getValues())
9722         #some new modification into m2
9723         modif2=[2,5,4]
9724         m2.getNodalConnectivity()[1:4]=modif2
9725         #policy 0 fails because cell0 in m2 has not exactly the same conn
9726         isOk,arr=m1.areCellsIncludedIn(m2,0)
9727         self.assertTrue(not isOk);
9728         self.assertEqual(3,arr.getNumberOfTuples());
9729         self.assertEqual(1,arr.getNumberOfComponents());
9730         self.assertEqual(expected1,arr.getValues())
9731         #policy 1 fails too because cell0 in m2 has not same orientation
9732         isOk,arr=m1.areCellsIncludedIn(m2,1)
9733         self.assertTrue(not isOk);
9734         self.assertEqual(3,arr.getNumberOfTuples());
9735         self.assertEqual(1,arr.getNumberOfComponents());
9736         self.assertEqual(expected1,arr.getValues())
9737         #policy 2 succeeds because cell0 in m2 has same nodes in connectivity
9738         isOk,arr=m1.areCellsIncludedIn(m2,2)
9739         self.assertTrue(isOk);
9740         self.assertEqual(3,arr.getNumberOfTuples());
9741         self.assertEqual(1,arr.getNumberOfComponents());
9742         self.assertEqual(cells1,arr.getValues())
9743         # Now 1D
9744         cells2=[3,2]
9745         m1=MEDCouplingDataForTest.build1DSourceMesh_2();
9746         m2_1=m1.buildPartOfMySelf(cells2,True);
9747         m2=m2_1
9748         self.assertTrue(isinstance(m2,MEDCouplingUMesh))
9749         # no permutation policy 0
9750         isOk,arr=m1.areCellsIncludedIn(m2,0)
9751         self.assertTrue(isOk);
9752         self.assertEqual(2,arr.getNumberOfTuples());
9753         self.assertEqual(1,arr.getNumberOfComponents());
9754         self.assertEqual(cells2,arr.getValues())
9755         # no permutation policy 1
9756         isOk,arr=m1.areCellsIncludedIn(m2,1)
9757         self.assertTrue(isOk);
9758         self.assertEqual(2,arr.getNumberOfTuples());
9759         self.assertEqual(1,arr.getNumberOfComponents());
9760         self.assertEqual(cells2,arr.getValues())
9761         # no permutation policy 2
9762         isOk,arr=m1.areCellsIncludedIn(m2,2)
9763         self.assertTrue(isOk);
9764         self.assertEqual(2,arr.getNumberOfTuples());
9765         self.assertEqual(1,arr.getNumberOfComponents());
9766         self.assertEqual(cells2,arr.getValues())
9767         # some modification into m2
9768         modif3=[4,3]
9769         m2.getNodalConnectivity()[1:3]=modif3
9770         #policy 0 fails because cell0 in m2 has not exactly the same conn
9771         expected2=[4,2]
9772         isOk,arr=m1.areCellsIncludedIn(m2,0)
9773         self.assertTrue(not isOk);
9774         self.assertEqual(2,arr.getNumberOfTuples());
9775         self.assertEqual(1,arr.getNumberOfComponents());
9776         self.assertEqual(expected2,arr.getValues())
9777         #policy 1 fails too because cell0 in m2 has not same orientation
9778         isOk,arr=m1.areCellsIncludedIn(m2,1)
9779         self.assertTrue(not isOk);
9780         self.assertEqual(2,arr.getNumberOfTuples());
9781         self.assertEqual(1,arr.getNumberOfComponents());
9782         self.assertEqual(expected2,arr.getValues())
9783         #policy 2 succeeds because cell0 in m2 has same nodes in connectivity
9784         isOk,arr=m1.areCellsIncludedIn(m2,2)
9785         self.assertTrue(isOk);
9786         self.assertEqual(2,arr.getNumberOfTuples());
9787         self.assertEqual(1,arr.getNumberOfComponents());
9788         self.assertEqual(cells2,arr.getValues())
9789         pass
9790
9791     def toSeeIfDaIIopsAreOK(self,d):
9792         d+=5
9793         d*=6
9794         d/=3
9795         d-=2
9796         d%=7
9797         pass
9798
9799     def testSwigDAIOp5(self):
9800         d=DataArrayInt.New([4,5,6,10,3,-1],2,3)
9801         self.toSeeIfDaIIopsAreOK(d)
9802         dExp=DataArrayInt.New([2,4,6,0,0,6],2,3)
9803         self.assertTrue(d.isEqual(dExp));
9804         pass
9805
9806     def toSeeIfDaDIopsAreOK(self,d):
9807         d+=5
9808         d*=6
9809         d/=3
9810         d-=2
9811         pass
9812
9813     def testSwigDADOp7(self):
9814         d=DataArrayDouble.New([4.,5.,6.,10.,3.,-1.],2,3)
9815         self.toSeeIfDaDIopsAreOK(d)
9816         dExp=DataArrayDouble.New([16.,18.,20.,28.,14.,6.],2,3)
9817         self.assertTrue(d.isEqual(dExp,1e-14));
9818         pass
9819
9820     def testConvexEnvelop2D1(self):
9821         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]
9822         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]
9823         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]
9824         #
9825         m=MEDCouplingUMesh.New("convexhull",2);
9826         m.allocateCells(331);
9827         for i in xrange(331):
9828             m.insertNextCell(NORM_POLYGON,conn[connI[i]:connI[i+1]]);
9829             pass
9830         m.finishInsertingCells();
9831         coordsDa=DataArrayDouble.New(coords,331,2);
9832         m.setCoords(coordsDa);
9833         m.checkCoherency();
9834         #
9835         da=m.convexEnvelop2D();
9836         m.checkCoherency()
9837         self.assertEqual(coordsDa.getHiddenCppPointer(),m.getCoords().getHiddenCppPointer())
9838         daC=da.buildComplement(m.getNumberOfCells());
9839         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]);
9840         self.assertTrue(expected2.isEqual(daC));
9841         #
9842         vals=m.getMeasureField(ON_CELLS).getArray()
9843         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]
9844         vals-=DataArrayDouble.New(ref)
9845         vals.abs()
9846         theTest=vals.getIdsInRange(-1.,1e-7)
9847         self.assertTrue(theTest.isIdentity())
9848         self.assertEqual(331,len(theTest))
9849         pass
9850
9851     def testSwigDAIOp8(self):
9852         da=DataArrayInt.New([7,5,6,7,8,9,9,10,12,13,47,15])
9853         self.assertTrue(7 in da)
9854         self.assertTrue(47 in da)
9855         self.assertTrue(15 in da)
9856         self.assertEqual(0,da.index(7))
9857         self.assertEqual(10,da.index(47))
9858         self.assertTrue(14 not in da)
9859         self.assertEqual(5,da.search([9,9]))
9860         self.assertEqual(-1,da.search([5,8]))
9861         da.rearrange(2)
9862         self.assertTrue([47,16] not in da)
9863         self.assertTrue([5,6] not in da)
9864         self.assertTrue([6,7] in da)
9865         self.assertEqual(4,da.index([12,13]))
9866         pass
9867
9868     def testDataArraySort1(self):
9869         arr=DataArrayInt.New();
9870         self.assertRaises(InterpKernelException,arr.sort,True)
9871         self.assertRaises(InterpKernelException,arr.sort,False)
9872         values=[2,1,6,5,4,7]
9873         arr.alloc(3,2);
9874         self.assertRaises(InterpKernelException,arr.sort,True)
9875         self.assertRaises(InterpKernelException,arr.sort,False)
9876         arr.rearrange(1);
9877         arr.setValues(values,6,1)
9878         arr1=arr.deepCpy();
9879         arr2=arr.deepCpy();
9880         arr1.sort(True);
9881         expected1=[1,2,4,5,6,7]
9882         self.assertEqual(6,arr1.getNumberOfTuples());
9883         self.assertEqual(1,arr1.getNumberOfComponents());
9884         self.assertEqual(expected1,arr1.getValues());
9885         arr2.sort(False);
9886         expected2=[7,6,5,4,2,1]
9887         self.assertEqual(6,arr2.getNumberOfTuples());
9888         self.assertEqual(1,arr2.getNumberOfComponents());
9889         self.assertTrue(expected2,arr2.getValues());
9890         #
9891         ard=DataArrayDouble.New();
9892         self.assertRaises(InterpKernelException,ard.sort,True)
9893         self.assertRaises(InterpKernelException,ard.sort,False)
9894         valuesD=[2.,1.,6.,5.,4.,7.]
9895         ard.alloc(3,2);
9896         self.assertRaises(InterpKernelException,ard.sort,True)
9897         self.assertRaises(InterpKernelException,ard.sort,False)
9898         ard.rearrange(1);
9899         ard.setValues(valuesD,6,1)
9900         ard1=ard.deepCpy();
9901         ard2=ard.deepCpy();
9902         ard1.sort(True);
9903         expected3=[1.,2.,4.,5.,6.,7.]
9904         self.assertEqual(6,ard1.getNumberOfTuples());
9905         self.assertEqual(1,ard1.getNumberOfComponents());
9906         for i in xrange(6):
9907             self.assertAlmostEqual(expected3[i],ard1.getIJ(i,0),12)
9908             pass
9909         ard2.sort(False);
9910         expected4=[7.,6.,5.,4.,2.,1.]
9911         self.assertEqual(6,ard2.getNumberOfTuples());
9912         self.assertEqual(1,ard2.getNumberOfComponents());
9913         for i in xrange(6):
9914             self.assertAlmostEqual(expected4[i],ard2.getIJ(i,0),12)
9915             pass
9916         pass
9917
9918     def testPartitionBySpreadZone1(self):
9919         m=MEDCouplingDataForTest.build2DTargetMesh_1();
9920         m4=MEDCouplingUMesh.MergeUMeshes([m,m[-3:],m[0:2]]);
9921         m4.renumberCells([5,2,9,6,4,7,0,1,3,8]);
9922         #
9923         v2=m4.partitionBySpreadZone();
9924         self.assertTrue(3,len(v2));
9925         self.assertTrue(v2[0].isEqual(DataArrayInt.New([0,1,7])))
9926         self.assertTrue(v2[1].isEqual(DataArrayInt.New([2,4,5,6,9])))
9927         self.assertTrue(v2[2].isEqual(DataArrayInt.New([3,8])))
9928         #
9929         m5=m4.buildSpreadZonesWithPoly();
9930         self.assertEqual(3,m5.getNumberOfCells());
9931         self.assertTrue(m5.getCoords().getHiddenCppPointer()==m4.getCoords().getHiddenCppPointer());
9932         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())
9933         self.assertEqual([0,8,17,23],m5.getNodalConnectivityIndex().getValues())
9934         #
9935         pass
9936
9937     def testGiveCellsWithType1(self):
9938         expected0=[1,2]
9939         expected1=[0,3,4]
9940         m=MEDCouplingDataForTest.build2DTargetMesh_1();
9941         da=m.giveCellsWithType(NORM_TRI3);
9942         self.assertEqual(2,da.getNumberOfTuples());
9943         self.assertEqual(1,da.getNumberOfComponents());
9944         self.assertEqual(expected0,da.getValues())
9945         #
9946         da=m.giveCellsWithType(NORM_QUAD4);
9947         self.assertEqual(3,da.getNumberOfTuples());
9948         self.assertEqual(1,da.getNumberOfComponents());
9949         self.assertEqual(expected1,da.getValues())
9950         #
9951         da=m.giveCellsWithType(NORM_TRI6);
9952         self.assertEqual(0,da.getNumberOfTuples());
9953         self.assertEqual(1,da.getNumberOfComponents());
9954         #
9955         self.assertRaises(InterpKernelException,m.giveCellsWithType,NORM_SEG2)
9956         self.assertRaises(InterpKernelException,m.giveCellsWithType,NORM_HEXA8)
9957         pass
9958
9959     def testSwigDAOp1(self):
9960         d=DataArrayDouble.New(5,2)
9961         d.rearrange(1) ; d.iota(2.) ; d.rearrange(2)
9962         d.setInfoOnComponents(["X [m]","Y [m]"])
9963         d.setName("AName")
9964         #
9965         d1=d+[8,9]
9966         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))
9967         d1bis=DataArrayDouble.New([8,9],1,2)+d
9968         self.assertTrue(d1bis.isEqual(d1,1e-12))
9969         d1ter=[8,9]+d
9970         self.assertTrue(d1ter.isEqual(d1,1e-12))
9971         #
9972         d2=d1-[8,9]
9973         self.assertTrue(d2.isEqual(d,1e-12))
9974         self.assertRaises(InterpKernelException,d1.__rsub__,[8,9])#[8,9]-d1
9975         #
9976         d3=d*[8,9]
9977         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))
9978         d3bis=DataArrayDouble.New([8,9],1,2)*d
9979         self.assertTrue(d3bis.isEqual(d3,1e-12))
9980         d3ter=[8,9]*d
9981         self.assertTrue(d3ter.isEqual(d3,1e-12))
9982         #
9983         d4=d3/[8,9]
9984         self.assertTrue(d4.isEqual(d,1e-12))
9985         #
9986         d=DataArrayInt.New(5,2)
9987         d.rearrange(1) ; d.iota(2) ; d.rearrange(2)
9988         d.setInfoOnComponents(["X [m]","Y [m]"])
9989         d.setName("AName")
9990         #
9991         d1=d+[8,9]
9992         self.assertEqual(d1.getValues(),[10,12,12,14,14,16,16,18,18,20])
9993         d1bis=DataArrayInt.New([8,9],1,2)+d
9994         self.assertTrue(d1bis.isEqual(d1))
9995         d1ter=[8,9]+d
9996         self.assertTrue(d1ter.isEqual(d1))
9997         #
9998         d2=d1-[8,9]
9999         self.assertTrue(d2.isEqual(d))
10000         self.assertRaises(InterpKernelException,d1.__rsub__,[8,9])
10001         #
10002         d3=d*[8,9]
10003         self.assertEqual(d3.getValues(),[16,27,32,45,48,63,64,81,80,99])
10004         d3bis=DataArrayInt.New([8,9],1,2)*d
10005         self.assertTrue(d3bis.isEqual(d3))
10006         d3ter=[8,9]*d
10007         self.assertTrue(d3ter.isEqual(d3))
10008         #
10009         d4=d3/[8,9]
10010         self.assertTrue(d4.isEqual(d))
10011         #
10012         d5=d%[4,5]
10013         self.assertEqual(d5.getValues(),[2,3,0,0,2,2,0,4,2,1])
10014         pass
10015
10016     def testSwigSelectTupleId2DAIBug1(self):
10017         da=DataArrayInt.New([0,1,2,3,12,13,4,5,6,7,14,15,8,9,10,11,16,17])
10018         self.assertEqual([2,6,10],da[2::6].getValues())
10019         self.assertEqual([0,4,8],da[::6].getValues())
10020         self.assertEqual([5,9],da[7::6].getValues())
10021         self.assertEqual([5],da[7:-5:6].getValues())
10022         pass
10023
10024     def testSwigCpp5Safe1(self):
10025         m=MEDCouplingUMesh.New("toto",2)
10026         coords=DataArrayDouble.New([0.,0.,1.,0.,1.,1.,0.,1.],4,2)
10027         m.setCoords(coords)
10028         vecs=DataArrayDouble.New([2.,3.,4.,5.,6.,7.],3,2)
10029         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]]
10030         for pos,vec in enumerate(vecs):
10031             m2=m.deepCpy()
10032             m2.translate(vec)
10033             self.assertTrue(m2.getCoords().isEqual(DataArrayDouble.New(expected1[pos],4,2),1e-12))
10034             pass
10035         for pos,vec in enumerate(vecs):
10036             m2=m.deepCpy()
10037             m2.translate(vec.buildDADouble())
10038             self.assertTrue(m2.getCoords().isEqual(DataArrayDouble.New(expected1[pos],4,2),1e-12))
10039             pass
10040         pass
10041
10042     def testSwigBugNonRegressionZipDA(self):
10043         angles=map(lambda x:pi/3*x,xrange(6))
10044         radius=3
10045         #
10046         dad=DataArrayDouble.New(6, 2)
10047         dad[:,0]=radius
10048         dad[:,1]=angles
10049         #
10050         dad2=dad.fromPolarToCart()
10051         dads=[dad2.deepCpy() for elt in 7*[None]]
10052         #
10053         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.)]]
10054         for d,t in zip(dads,translationToPerform):
10055             d+=t
10056             pass
10057         for elt in dads:
10058             self.assertTrue(not dad2.isEqual(elt,1e-12))
10059             pass
10060         for d,t in zip(dads,translationToPerform):
10061             d-=t
10062             pass
10063         for elt in dads:
10064             self.assertTrue(dad2.isEqual(elt,1e-12))
10065             pass
10066         pass
10067
10068     def testBuildSlice3D2(self):
10069         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
10070         vec1=[-0.07,1.,0.07]
10071         origin1=[1.524,1.4552,1.74768]
10072         slice1,ids=mesh3D.buildSlice3D(origin1,vec1,1e-10);
10073         f=MEDCouplingFieldDouble(ON_CELLS,ONE_TIME)
10074         f.setTime(4.5,6,7) ; f.setMesh(mesh3D)
10075         arr=DataArrayDouble(mesh3D.getNumberOfCells(),2)
10076         arr.rearrange(1) ; arr.iota(2.) ; arr.rearrange(2)
10077         f.setArray(arr)
10078         f.checkCoherency()
10079         expected1=DataArrayInt([1,3,4,7,9,10,13,15,16])
10080         self.assertTrue(expected1.isEqual(ids))
10081         arr2=arr[expected1]
10082         #
10083         f2=f.extractSlice3D(origin1,vec1,1e-10)
10084         self.assertTrue(f2.getArray().isEqual(arr2,1e-12));
10085         self.assertTrue(slice1.isEqual(f2.getMesh(),1e-12))
10086         self.assertEqual(6,f2.getTime()[1]) ; self.assertEqual(7,f2.getTime()[2])
10087         self.assertAlmostEqual(4.5,f2.getTime()[0],12);
10088         pass
10089
10090     def testComputeTupleIdsToSelectFromCellIds1(self):
10091         m=MEDCouplingDataForTest.build2DTargetMesh_3()
10092         f=MEDCouplingFieldDouble.New(ON_GAUSS_NE,NO_TIME);
10093         f.setMesh(m);
10094         arr=DataArrayDouble(52,2) ; arr.rearrange(1) ; arr.iota(7.) ; arr.rearrange(2)
10095         f.setArray(arr)
10096         #
10097         f2=f.buildSubPart([1,5,9])
10098         f2.checkCoherency()
10099         cI=m.computeNbOfNodesPerCell()
10100         cI.computeOffsets2()
10101         sel=DataArrayInt([1,5,9])
10102         res=sel.buildExplicitArrByRanges(cI)
10103         arr2=arr[res]
10104         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))
10105         self.assertTrue(arr2.isEqual(f2.getArray(),1e-12))
10106         pass
10107
10108     def testComputeSkin1(self):
10109         arrX=DataArrayDouble([2.,3.4,5.6,7.7,8.0]) ; arrY=DataArrayDouble([2.,3.4,5.6,7.7,9.0,14.2])
10110         cmesh=MEDCouplingCMesh() ; cmesh.setCoordsAt(0,arrX) ; cmesh.setCoordsAt(1,arrY)
10111         umesh=cmesh.buildUnstructured()
10112         #
10113         skin=umesh.computeSkin()
10114         self.assertEqual(18,skin.getNumberOfCells())
10115         self.assertEqual(1,skin.getMeshDimension())
10116         self.assertTrue(skin.getCoords().getHiddenCppPointer()==umesh.getCoords().getHiddenCppPointer())
10117         self.assertEqual([0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48,51,54],skin.getNodalConnectivityIndex().getValues())
10118         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())
10119         ids=skin.computeFetchedNodeIds()
10120         self.assertEqual([0,1,2,3,4,5,9,10,14,15,19,20,24,25,26,27,28,29],ids.getValues())
10121         part=umesh.buildFacePartOfMySelfNode(ids,True)
10122         part.setName(skin.getName());
10123         self.assertTrue(part.isEqual(skin,1e-12))
10124         part2=part[1::2]
10125         part[::2]=part2
10126         self.assertTrue(not part.isEqual(skin,1e-12))
10127         trad=part.zipConnectivityTraducer(0)
10128         self.assertEqual(9,part.getNumberOfCells())
10129         self.assertEqual([0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8],trad.getValues())
10130         pass
10131
10132     def testUMeshSetPartOfMySelf2(self):
10133         # resize with explicit ids list
10134         m=MEDCouplingDataForTest.build2DTargetMesh_1()
10135         self.assertEqual([3,4],m.getAllTypes())
10136         part=m[[0,3,4]]
10137         part.simplexize(0)
10138         part2=part[[1,2,5]]
10139         m[[0,3,4]]=part2
10140         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())
10141         self.assertEqual([0,4,8,12,16,20],m.getNodalConnectivityIndex().getValues())
10142         self.assertEqual([3],m.getAllTypes())
10143         # no resize with explicit ids list
10144         m=MEDCouplingDataForTest.build2DTargetMesh_1()
10145         part=m[[0,3]]
10146         part.convertAllToPoly()
10147         m[[3,4]]=part
10148         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())
10149         self.assertEqual([0,5,9,13,18,23],m.getNodalConnectivityIndex().getValues())
10150         self.assertEqual([3,4,5],m.getAllTypes())
10151         # resize with range ids
10152         m=MEDCouplingDataForTest.build2DTargetMesh_1()
10153         part=m[3:]
10154         m[1:3]=part
10155         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())
10156         self.assertEqual([0,5,10,15,20,25],m.getNodalConnectivityIndex().getValues())
10157         self.assertEqual([4],m.getAllTypes())
10158         # no resize with range ids
10159         m=MEDCouplingDataForTest.build2DTargetMesh_1()
10160         part=m[0::3]
10161         part.convertAllToPoly()
10162         m[3:]=part
10163         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())
10164         self.assertEqual([0,5,9,13,18,23],m.getNodalConnectivityIndex().getValues())
10165         self.assertEqual([3,4,5],m.getAllTypes())
10166         # no resize with range ids negative direction
10167         m=MEDCouplingDataForTest.build2DTargetMesh_1()
10168         part=m[3::-3]
10169         part.convertAllToPoly()
10170         m[:-3:-1]=part
10171         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())
10172         self.assertEqual([0,5,9,13,18,23],m.getNodalConnectivityIndex().getValues())
10173         self.assertEqual([3,4,5],m.getAllTypes())
10174         pass
10175
10176     def testUnPolyze3(self):
10177         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]
10178         conn=[1,2,5,4,-1,4,3,0,1,-1,2,0,3,5,-1,0,2,1,-1,4,5,3]
10179         m=MEDCouplingUMesh.New("a mesh",3);
10180         m.allocateCells(1);
10181         m.insertNextCell(NORM_POLYHED,22,conn[0:22])
10182         m.finishInsertingCells();
10183         coords=DataArrayDouble(coord,6,3);
10184         m.setCoords(coords);
10185         m.checkCoherency();
10186         #
10187         vol=m.getMeasureField(ON_CELLS);
10188         self.assertEqual(1,vol.getArray().getNumberOfTuples());
10189         self.assertAlmostEqual(0.5,vol.getArray().getIJ(0,0),12)
10190         #
10191         m.unPolyze();
10192         #
10193         self.assertEqual([NORM_PENTA6],m.getAllTypes())
10194         self.assertTrue(DataArrayInt([0,7]).isEqual(m.getNodalConnectivityIndex()))
10195         self.assertTrue(DataArrayInt([16,0,2,1,3,5,4]).isEqual(m.getNodalConnectivity()))
10196         #
10197         vol=m.getMeasureField(ON_CELLS);
10198         self.assertEqual(1,vol.getArray().getNumberOfTuples());
10199         self.assertAlmostEqual(0.5,vol.getArray().getIJ(0,0),12)
10200         pass
10201
10202     def testKrSpatialDiscretization1(self):
10203         srcPointCoordsX=[0.8401877171547095, 0.7830992237586059, 0.9116473579367843, 0.335222755714889, 0.2777747108031878, 0.4773970518621602, 0.3647844727918433, 0.9522297251747128, 0.6357117279599009, 0.1416025553558034]
10204         srcFieldValsOnPoints=[2.129892434968836, 2.295320474540621, 1.931948594981134, 2.728013590937196, 2.715603240418478, 2.661778472822935, 2.695696990104364, 1.893710234970982, 2.529628016549284, 2.728432341300668]
10205         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]
10206         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]
10207         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])
10208         #
10209         nbOfInputPoints=10;
10210         f=MEDCouplingFieldDouble.New(ON_NODES_KR,ONE_TIME);
10211         srcArrX=DataArrayDouble.New(srcPointCoordsX,nbOfInputPoints,1);
10212         cmesh=MEDCouplingCMesh.New("aMesh");
10213         cmesh.setCoordsAt(0,srcArrX);
10214         umesh=cmesh.buildUnstructured();
10215         f.setMesh(umesh);
10216         srcVals=DataArrayDouble.New(srcFieldValsOnPoints,nbOfInputPoints,1);
10217         f.setArray(srcVals);
10218         f.checkCoherency();
10219         #
10220         res0=f.getValueOn(targetPointCoordsX[:1]);
10221         self.assertAlmostEqual(targetFieldValsExpected[0],res0[0],10)
10222         #
10223         valuesToTest=f.getValueOnMulti(targetPointCoordsX);
10224         self.assertEqual(40,valuesToTest.getNumberOfTuples());
10225         self.assertEqual(1,valuesToTest.getNumberOfComponents());
10226         for i in xrange(40):
10227             self.assertAlmostEqual(targetFieldValsExpected[i],valuesToTest.getIJ(i,0),10)
10228             pass
10229         fd=f.getDiscretization()
10230         del f
10231         self.assertTrue(isinstance(fd,MEDCouplingFieldDiscretizationKriging))
10232         coeffs,isDrift=fd.computeVectorOfCoefficients(umesh,srcVals)
10233         self.assertEqual(2,isDrift)
10234         self.assertTrue(coeffsExpected.isEqual(coeffs,1e-8))
10235         #
10236         pass
10237
10238     def testDuplicateEachTupleNTimes1(self):
10239         d=DataArrayDouble.New([9.,8.,7.,6.],4,1) ; d.setInfoOnComponents(["mass [kg]"]) ; d.setName("aname")
10240         d2=d.duplicateEachTupleNTimes(3)
10241         self.assertTrue(d2.isEqualWithoutConsideringStr(DataArrayDouble.New([9.,9.,9.,8.,8.,8.,7.,7.,7.,6.,6.,6.],4*3,1),1e-14))
10242         self.assertEqual("aname",d2.getName())
10243         self.assertEqual(["mass [kg]"],d2.getInfoOnComponents())
10244         #
10245         d=DataArrayInt.New([9,8,7,6],4,1) ; d.setInfoOnComponents(["mass [kg]"]) ; d.setName("aname")
10246         d2=d.duplicateEachTupleNTimes(3)
10247         self.assertTrue(d2.isEqualWithoutConsideringStr(DataArrayInt.New([9,9,9,8,8,8,7,7,7,6,6,6],4*3,1)))
10248         self.assertEqual("aname",d2.getName())
10249         self.assertEqual(["mass [kg]"],d2.getInfoOnComponents())
10250         pass
10251
10252     def testSwigComputeTupleIdsNearTuples1(self):
10253         da=DataArrayDouble([5.,6.,-5.,-6.,5.,-6.,-5.,6.,5.,6.],5,2)
10254         arr,arrI=da.computeTupleIdsNearTuples(DataArrayDouble([5.,-6.,5.,6.,-5.,-6.],3,2),1e-10)
10255         self.assertEqual([2,0,4,1],arr.getValues())
10256         self.assertEqual([0,1,3,4],arrI.getValues())
10257         arr,arrI=da.computeTupleIdsNearTuples([5.,-6.,5.,6.,-5.,-6.],1e-10)
10258         self.assertEqual([2,0,4,1],arr.getValues())
10259         self.assertEqual([0,1,3,4],arrI.getValues())
10260         expected0=[[2],[0,4],[1]]
10261         expected1=[[0,1],[0,2],[0,1]]
10262         for pos,it in enumerate(DataArrayDouble([5.,-6.,5.,6.,-5.,-6.],3,2)):
10263             arr,arrI=da.computeTupleIdsNearTuples(it,1e-10)
10264             self.assertEqual(expected0[pos],arr.getValues())
10265             self.assertEqual(expected1[pos],arrI.getValues())
10266             pass
10267         pass
10268
10269     def testSwigDataTupleIOp1(self):
10270         d=DataArrayDouble(10,1)
10271         d.iota(7.)
10272         for elt in d:
10273             elt+=2.
10274             pass
10275         toTest=DataArrayDouble([9.0,10.0,11.0,12.0,13.0,14.0,15.0,16.0,17.0,18.0])
10276         self.assertTrue(toTest.isEqual(d,1e-12))
10277         for elt in d:
10278             elt-=2.
10279             pass
10280         toTest=DataArrayDouble([7.0,8.0,9.0,10.0,11.0,12.0,13.0,14.0,15.0,16.0])
10281         self.assertTrue(toTest.isEqual(d,1e-12))
10282         for elt in d:
10283             elt*=2.
10284             pass
10285         toTest=DataArrayDouble([14.0,16.0,18.0,20.0,22.0,24.0,26.0,28.0,30.0,32.0])
10286         self.assertTrue(toTest.isEqual(d,1e-12))
10287         for elt in d:
10288             elt/=2.
10289             pass
10290         toTest=DataArrayDouble([7.0,8.0,9.0,10.0,11.0,12.0,13.0,14.0,15.0,16.0])
10291         self.assertTrue(toTest.isEqual(d,1e-12))
10292         #
10293         d=DataArrayInt(10,1)
10294         d.iota(7)
10295         for elt in d:
10296             elt+=2
10297             pass
10298         self.assertEqual(d.getValues(),[9,10,11,12,13,14,15,16,17,18])
10299         for elt in d:
10300             elt-=2
10301             pass
10302         self.assertEqual(d.getValues(),[7,8,9,10,11,12,13,14,15,16])
10303         for elt in d:
10304             elt*=2
10305             pass
10306         self.assertEqual(d.getValues(),[14,16,18,20,22,24,26,28,30,32])
10307         for elt in d:
10308             elt/=2
10309             pass
10310         self.assertEqual(d.getValues(),[7,8,9,10,11,12,13,14,15,16])
10311         for elt in d:
10312             elt%=3
10313             pass
10314         self.assertEqual(d.getValues(),[1,2,0,1,2,0,1,2,0,1])
10315         pass
10316
10317     def testIntersect2DMeshesTmp5(self):
10318         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)
10319         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)
10320         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)
10321         #
10322         m1=MEDCouplingUMesh.New("Fix",2);
10323         m1.setCoords(coords);
10324         m1.setConnectivity(conn,connI,True);
10325         #
10326         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)
10327         # connectivity
10328         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);
10329         conn.setName("");
10330         connI=DataArrayInt([0,9,18,27,36,45,54,63,72],9)
10331         m2=MEDCouplingUMesh.New("Mobile",2);
10332         m2.setCoords(coords);
10333         m2.setConnectivity(conn,connI,True);
10334         #
10335         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m1,m2,1e-10);
10336         self.assertEqual(105,m3.getNumberOfCells());
10337         self.assertEqual(105,d1.getNumberOfTuples());
10338         self.assertEqual(105,d2.getNumberOfTuples());
10339         self.assertEqual(704,m3.getNumberOfNodes());
10340         #
10341         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]
10342         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]
10343         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]
10344         f3=m3.getMeasureField(ON_CELLS).getArray().getValues();
10345         for i in xrange(105):
10346             self.assertAlmostEqual(areaExpected[i],f3[i],10)
10347             pass
10348         self.assertEqual(expected1,d1.getValues())
10349         self.assertEqual(expected2,d2.getValues())
10350         pass
10351
10352     def testDAIBuildUnique1(self):
10353         d=DataArrayInt([1,2,2,3,3,3,3,4,5,5,7,7,7,19])
10354         e=d.buildUnique()
10355         self.assertTrue(e.isEqual(DataArrayInt([1,2,3,4,5,7,19])))
10356         pass
10357
10358     def testDAIPartitionByDifferentValues1(self):
10359         d=DataArrayInt([1,0,1,2,0,2,2,-3,2])
10360         expected=[[-3,[7]],[0,[1,4]],[1,[0,2]],[2,[3,5,6,8]]]
10361         for i,elt in enumerate(zip(*d.partitionByDifferentValues())):
10362             self.assertEqual(expected[i][0],elt[1])
10363             self.assertEqual(expected[i][1],elt[0].getValues())
10364             pass
10365         pass
10366
10367     def testFieldGaussMultiDiscPerType1(self):
10368         coords=DataArrayDouble([0.,0.,0.,1.,1.,1.,1.,0.,0.,0.5,0.5,1.,1.,0.5,0.5,0.],8,2)
10369         mQ8=MEDCouplingUMesh("",2) ; mQ8.setCoords(coords)
10370         mQ8.allocateCells(1)
10371         mQ8.insertNextCell(NORM_QUAD8,range(8))
10372         mQ8.finishInsertingCells()
10373         mQ4=MEDCouplingUMesh("",2) ; mQ4.setCoords(coords)
10374         mQ4.allocateCells(1)
10375         mQ4.insertNextCell(NORM_QUAD4,range(4))
10376         mQ4.finishInsertingCells()
10377         mT3=MEDCouplingUMesh("",2) ; mT3.setCoords(coords)
10378         mT3.allocateCells(1)
10379         mT3.insertNextCell(NORM_TRI3,range(3))
10380         mT3.finishInsertingCells()
10381
10382         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.]]
10383         ms=2*[mQ4]+7*[mQ8]+11*[mT3]
10384         ms[:]=(elt.deepCpy() for elt in ms)
10385         for m,t in zip(ms,tr):
10386             d=m.getCoords() ; d+= t
10387             pass
10388         m=MEDCouplingUMesh.MergeUMeshes(ms)
10389         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,NO_TIME)
10390         f.setMesh(m)
10391         # throw because cell 0,1 are QUAD4 and cell 3 is QUAD8
10392         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])
10393         f.setGaussLocalizationOnCells([0,1],[0.,0.,1.,0.,1.,1.,0.,1.],[0.3,0.3,0.7,0.7],[0.8,0.2])
10394         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])
10395         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])
10396         f.setGaussLocalizationOnCells([9,10,11,12,13],[0.,0.,1.,0.,1.,1.],[0.4,0.4],[1.])
10397         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])
10398         self.assertEqual(46,f.getNumberOfTuplesExpected())
10399         vals=DataArrayDouble.New(46*3,1) ; vals.iota(7.7) ; vals.rearrange(3)
10400         f.setArray(vals)
10401         f.checkCoherency()
10402         #f.getLocalizationOfDiscr()
10403         self.assertRaises(InterpKernelException,f.getGaussLocalizationIdOfOneType,NORM_QUAD8) #throw because several loc
10404         self.assertEqual([1,2],f.getGaussLocalizationIdsOfOneType(NORM_QUAD8))
10405         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())
10406         fc=f[[1,2,3,8]]
10407         fc.checkCoherency()
10408         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))
10409         fc.renumberCells([3,2,0,1])
10410         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))
10411         fc.getArray()
10412         pass
10413
10414     def testSwigRotate(self):
10415         d=DataArrayDouble([1.,2.,3.,4.,6.,5.],2,3)
10416         MEDCouplingPointSet.Rotate3DAlg([0.,0.,0.],[0.,1.,0.],1.5707963267948966,d)
10417         self.assertTrue(d.isEqual(DataArrayDouble([3.,2.,-1.,5.,6.,-4.],2,3),1e-12))
10418         d=DataArrayDouble([1.,2.,3.,4.,6.,5.],3,2)
10419         MEDCouplingPointSet.Rotate2DAlg([0.,0.],1.5707963267948966,d)
10420         self.assertTrue(d.isEqual(DataArrayDouble([-2.,1.,-4.,3.,-5.,6.],3,2),1e-12))
10421         pass
10422
10423     def testSwigCMeshProtection(self):
10424         cm=MEDCouplingCMesh()
10425         self.assertRaises(InterpKernelException,cm.setCoordsAt,0,DataArrayDouble([4.,4.5,6.,7.],2,2))
10426         self.assertRaises(InterpKernelException,cm.setCoords,DataArrayDouble([4.,4.5,6.,7.],2,2))
10427         pass
10428
10429     def testSwigCellsInBoundingBox1(self):
10430         m3D=MEDCouplingDataForTest.build3DExtrudedUMesh_1()[0]
10431         self.assertTrue(m3D.getCellsInBoundingBox([(0,3),(0,3),(0,1)],-1e-12).isEqual(DataArrayInt([0,1,2,3,4,5])))
10432         self.assertRaises(InterpKernelException,m3D.getCellsInBoundingBox,[(0,3,0),(3,0,1)],-1e-12)
10433         pass
10434
10435     def testDAICheckMonotonic1(self):
10436         data1=[-1,0,2,2,4,5]
10437         data2=[6,2,0,-8,-9,-56]
10438         data3=[-1,0,3,2,4,6]
10439         data4=[7,5,2,3,0,-6]
10440         d=DataArrayInt.New(data1);
10441         self.assertTrue(d.isMonotonic(True));
10442         self.assertTrue(not d.isMonotonic(False));
10443         d.checkMonotonic(True);
10444         self.assertRaises(InterpKernelException,d.checkMonotonic,False)
10445         d=DataArrayInt.New(data2);
10446         self.assertTrue(d.isMonotonic(False));
10447         self.assertTrue(not d.isMonotonic(True));
10448         d.checkMonotonic(False);
10449         self.assertRaises(InterpKernelException,d.checkMonotonic,True)
10450         d=DataArrayInt.New(data3);
10451         self.assertTrue(not d.isMonotonic(False));
10452         self.assertTrue(not d.isMonotonic(True));
10453         self.assertRaises(InterpKernelException,d.checkMonotonic,True)
10454         self.assertRaises(InterpKernelException,d.checkMonotonic,False)
10455         d=DataArrayInt.New(data4);
10456         self.assertTrue(not d.isMonotonic(False));
10457         self.assertTrue(not d.isMonotonic(True));
10458         self.assertRaises(InterpKernelException,d.checkMonotonic,True)
10459         self.assertRaises(InterpKernelException,d.checkMonotonic,False)
10460         d=DataArrayInt.New(0,1)
10461         self.assertTrue(d.isMonotonic(True));
10462         self.assertTrue(d.isMonotonic(False));
10463         d.checkMonotonic(True);
10464         d.checkMonotonic(False);
10465         d=DataArrayInt.New(data4,3,2);#throw because nbComp!=1
10466         self.assertRaises(InterpKernelException,d.isMonotonic,True)
10467         self.assertRaises(InterpKernelException,d.isMonotonic,False)
10468         self.assertRaises(InterpKernelException,d.checkMonotonic,True)
10469         self.assertRaises(InterpKernelException,d.checkMonotonic,False)
10470         pass
10471
10472     def testSwigDASetItemOnEmpty1(self):
10473         d=DataArrayInt(0,1)
10474         isThrow=False
10475         try:
10476             d[0:1000:2]=4
10477         except InterpKernelException as e:
10478             isThrow=True
10479             pass
10480         self.assertTrue(isThrow)
10481         d[:]=4
10482         d[::2]=5
10483         #
10484         d=DataArrayDouble(0,1)
10485         isThrow=False
10486         try:
10487             d[0:1000:2]=4
10488         except InterpKernelException as e:
10489             isThrow=True
10490             pass
10491         self.assertTrue(isThrow)
10492         d[:]=4
10493         d[::2]=5
10494         d=DataArrayInt([],0,1)
10495         d2=DataArrayInt(0)
10496         self.assertTrue(d2.isEqual(d))
10497         d=DataArrayDouble([],0,1)
10498         d2=DataArrayDouble(0)
10499         self.assertTrue(d2.isEqual(d,1e-12))
10500         pass
10501
10502     def testSwigDAITransformWithIndArr1(self):
10503         arr=DataArrayInt([0,4,5,1])
10504         d=DataArrayInt([7,8,9,10])
10505         self.assertRaises(InterpKernelException,arr.transformWithIndArr,d)
10506         pass
10507
10508     def testIntersect2DMeshesTmp6(self):
10509         # coordinates
10510         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);
10511         # connectivity
10512         conn=DataArrayInt.New([8,0,3,5,1,4,6,7,2])
10513         connI=DataArrayInt.New([0,9]);
10514         m1=MEDCouplingUMesh.New("Fixe",2);
10515         m1.setCoords(coords);
10516         m1.setConnectivity(conn,connI,True);
10517         #
10518         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);
10519         # connectivity
10520         conn=DataArrayInt.New([8,0,1,2,3,4,5,6,7,8,3,2,8,9,6,10,11,12]);
10521         connI=DataArrayInt.New([0,9,18]);
10522         #
10523         m2=MEDCouplingUMesh.New("Mobile",2);
10524         m2.setCoords(coords);
10525         m2.setConnectivity(conn,connI,True);
10526         #
10527         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m1,m2,1e-10);
10528         self.assertTrue(d1.isEqual(DataArrayInt([0,0,0,0])));
10529         self.assertTrue(d2.isEqual(DataArrayInt([0,1,-1,-1])));
10530         self.assertEqual(4,m3.getNumberOfCells());
10531         self.assertEqual(4,d1.getNumberOfTuples());
10532         self.assertEqual(4,d2.getNumberOfTuples());
10533         self.assertEqual(43,m3.getNumberOfNodes());
10534         dI,areMerged,newNbOfNodes=m3.mergeNodes(1e-12)
10535         self.assertEqual(35,m3.getNumberOfNodes());
10536         m3.zipCoords();
10537         self.assertEqual(23,m3.getNumberOfNodes());
10538         #
10539         f=m3.getMeasureField(True);
10540         valuesExpected=DataArrayDouble([1.6603638692585716,5.747555728471923,129.68907101754394,7.4162714498559694])
10541         self.assertTrue(f.getArray().isEqual(valuesExpected,1e-12))
10542         pass
10543
10544     def testDAPushBack(self):
10545         d=DataArrayDouble(0,1)
10546         for i in xrange(8):
10547             d.pushBackSilent(i)
10548             pass
10549         self.assertEqual(d.getNumberOfTuples(),8)
10550         self.assertEqual(d.getNbOfElemAllocated(),8)
10551         d.pushBackSilent(4.44)
10552         self.assertEqual(d.getNumberOfTuples(),9)
10553         self.assertEqual(d.getNbOfElemAllocated(),16)
10554         self.assertTrue(d.isEqual(DataArrayDouble([0.,1.,2.,3.,4.,5.,6.,7.,4.44]),1e-12))
10555         e=d.deepCpy()
10556         self.assertEqual(e.getNumberOfTuples(),9)
10557         self.assertEqual(e.getNbOfElemAllocated(),9)
10558         self.assertTrue(e.isEqual(DataArrayDouble([0.,1.,2.,3.,4.,5.,6.,7.,4.44]),1e-12))
10559         self.assertAlmostEqual(d.popBackSilent(),4.44,12)
10560         self.assertEqual(d.getNumberOfTuples(),8)
10561         self.assertEqual(d.getNbOfElemAllocated(),16)
10562         self.assertTrue(d.isEqual(DataArrayDouble([0.,1.,2.,3.,4.,5.,6.,7.]),1e-12))
10563         f=DataArrayDouble()
10564         f.reserve(1000)
10565         f.pushBackSilent(4.)
10566         self.assertTrue(f.isEqual(DataArrayDouble([4.]),1e-12))
10567         self.assertEqual(f.getNumberOfTuples(),1)
10568         self.assertEqual(f.getNbOfElemAllocated(),1000)
10569         ff=f[:]
10570         self.assertTrue(ff.isEqual(DataArrayDouble([4.]),1e-12))
10571         self.assertEqual(ff.getNumberOfTuples(),1)
10572         self.assertEqual(ff.getNbOfElemAllocated(),1)
10573         d=DataArrayDouble()
10574         d.pushBackSilent(4.44)
10575         d.pushBackSilent(5.55)
10576         d.pushBackSilent(6.66)
10577         self.assertTrue(d.isEqual(DataArrayDouble([4.44,5.55,6.66]),1e-12))
10578         #
10579         d=DataArrayInt(0,1)
10580         for i in xrange(8):
10581             d.pushBackSilent(i)
10582             pass
10583         self.assertEqual(d.getNumberOfTuples(),8)
10584         self.assertEqual(d.getNbOfElemAllocated(),8)
10585         d.pushBackSilent(444)
10586         self.assertEqual(d.getNumberOfTuples(),9)
10587         self.assertEqual(d.getNbOfElemAllocated(),16)
10588         self.assertTrue(d.isEqual(DataArrayInt([0,1,2,3,4,5,6,7,444])))
10589         e=d.deepCpy()
10590         self.assertEqual(e.getNumberOfTuples(),9)
10591         self.assertEqual(e.getNbOfElemAllocated(),9)
10592         self.assertTrue(e.isEqual(DataArrayInt([0,1,2,3,4,5,6,7,444])))
10593         self.assertEqual(d.popBackSilent(),444)
10594         self.assertEqual(d.getNumberOfTuples(),8)
10595         self.assertEqual(d.getNbOfElemAllocated(),16)
10596         self.assertTrue(d.isEqual(DataArrayInt([0,1,2,3,4,5,6,7])))
10597         f=DataArrayInt()
10598         f.reserve(1000)
10599         f.pushBackSilent(4)
10600         self.assertTrue(f.isEqual(DataArrayInt([4])))
10601         self.assertEqual(f.getNumberOfTuples(),1)
10602         self.assertEqual(f.getNbOfElemAllocated(),1000)
10603         ff=f[:]
10604         self.assertTrue(ff.isEqual(DataArrayInt([4])))
10605         self.assertEqual(ff.getNumberOfTuples(),1)
10606         self.assertEqual(ff.getNbOfElemAllocated(),1)
10607         d=DataArrayInt()
10608         d.pushBackSilent(444)
10609         d.pushBackSilent(555)
10610         d.pushBackSilent(666)
10611         self.assertTrue(d.isEqual(DataArrayInt([444,555,666])))
10612         #
10613         d=DataArrayInt()
10614         d.alloc(10,1)
10615         d.setInfoOnComponent(0,"ABC")
10616         d.setName("dEf")
10617         d.iota(7)
10618         e=DataArrayInt([7,8,9,10,11,12,13,14,15,16]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
10619         self.assertEqual(10,d.getNbOfElemAllocated())
10620         d.pushBackSilent(55)
10621         e=DataArrayInt([7,8,9,10,11,12,13,14,15,16,55]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
10622         self.assertEqual(20,d.getNbOfElemAllocated())
10623         d.reserve(4)
10624         e=DataArrayInt([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
10625         self.assertEqual(4,d.getNbOfElemAllocated())
10626         d.pushBackSilent(5)
10627         e=DataArrayInt([7,8,9,10,5]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
10628         self.assertEqual(8,d.getNbOfElemAllocated())
10629         self.assertEqual(5,d.popBackSilent())
10630         e=DataArrayInt([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
10631         self.assertEqual(8,d.getNbOfElemAllocated())
10632         self.assertRaises(OverflowError,d.reserve,-1)
10633         e=DataArrayInt([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
10634         self.assertEqual(8,d.getNbOfElemAllocated())
10635         d.reserve(0)
10636         e=DataArrayInt([]) ; e.setInfoOnComponent(0,"ABC") ; e.setName("dEf") ; self.assertTrue(d.isEqual(e))
10637         self.assertEqual(0,d.getNbOfElemAllocated())
10638         #
10639         d=DataArrayDouble()
10640         d.alloc(10,1)
10641         d.setInfoOnComponent(0,"ABC")
10642         d.setName("dEf")
10643         d.iota(7)
10644         e=DataArrayDouble([7,8,9,10,11,12,13,14,15,16]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
10645         self.assertEqual(10,d.getNbOfElemAllocated())
10646         d.pushBackSilent(55)
10647         e=DataArrayDouble([7,8,9,10,11,12,13,14,15,16,55]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
10648         self.assertEqual(20,d.getNbOfElemAllocated())
10649         d.reserve(4)
10650         e=DataArrayDouble([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
10651         self.assertEqual(4,d.getNbOfElemAllocated())
10652         d.pushBackSilent(5)
10653         e=DataArrayDouble([7,8,9,10,5]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
10654         self.assertEqual(8,d.getNbOfElemAllocated())
10655         self.assertEqual(5.,d.popBackSilent())
10656         e=DataArrayDouble([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
10657         self.assertEqual(8,d.getNbOfElemAllocated())
10658         self.assertRaises(OverflowError,d.reserve,-1)
10659         e=DataArrayDouble([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
10660         self.assertEqual(8,d.getNbOfElemAllocated())
10661         d.reserve(0)
10662         e=DataArrayDouble([]) ; e.setInfoOnComponent(0,"ABC") ; e.setName("dEf") ; self.assertTrue(d.isEqual(e,1e-14))
10663         self.assertEqual(0,d.getNbOfElemAllocated())
10664         pass
10665
10666     def testDAIBuildSubstractionOptimized1(self):
10667         da1=DataArrayInt.New([1,3,5,6,7,9,13])
10668         da2=DataArrayInt.New([3,5,9])
10669         da3=DataArrayInt.New([1,3,5])
10670         da4=DataArrayInt.New([1,3,5,6,7,9,13])
10671         #
10672         a=da1.buildSubstractionOptimized(da2);
10673         self.assertTrue(a.isEqual(DataArrayInt([1,6,7,13])));
10674         #
10675         a=da1.buildSubstractionOptimized(da3);
10676         self.assertTrue(a.isEqual(DataArrayInt([6,7,9,13])));
10677         #
10678         a=da1.buildSubstractionOptimized(da4);
10679         self.assertTrue(a.isEqual(DataArrayInt([])));
10680         pass
10681
10682     def testDAIIsStrictlyMonotonic1(self):
10683         da1=DataArrayInt.New([1,3,5,6,7,9,13])
10684         self.assertTrue(da1.isStrictlyMonotonic(True));
10685         da1.checkStrictlyMonotonic(True);
10686         self.assertTrue(da1.isMonotonic(True));
10687         da1.checkMonotonic(True);
10688         self.assertTrue(not da1.isStrictlyMonotonic(False));
10689         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,False)
10690         self.assertTrue(not da1.isMonotonic(False));
10691         self.assertRaises(InterpKernelException,da1.checkMonotonic,False)
10692         #
10693         da1=DataArrayInt.New([1,3,5,6,6,9,13])
10694         self.assertTrue(not da1.isStrictlyMonotonic(True));
10695         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,True)
10696         self.assertTrue(da1.isMonotonic(True));
10697         da1.checkMonotonic(True);
10698         self.assertTrue(not da1.isStrictlyMonotonic(False));
10699         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,False)
10700         self.assertTrue(not da1.isMonotonic(False));
10701         self.assertRaises(InterpKernelException,da1.checkMonotonic,False)
10702         #
10703         da1=DataArrayInt.New([1,3,5,6,5,9,13])
10704         self.assertTrue(not da1.isStrictlyMonotonic(True));
10705         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,True)
10706         self.assertTrue(not da1.isMonotonic(True));
10707         self.assertRaises(InterpKernelException,da1.checkMonotonic,True)
10708         self.assertTrue(not da1.isStrictlyMonotonic(False));
10709         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,False)
10710         self.assertTrue(not da1.isMonotonic(False));
10711         self.assertRaises(InterpKernelException,da1.checkMonotonic,False)
10712         #
10713         da1=DataArrayInt.New([13,9,7,6,5,3,1])
10714         self.assertTrue(not da1.isStrictlyMonotonic(True));
10715         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,True)
10716         self.assertTrue(not da1.isMonotonic(True));
10717         self.assertRaises(InterpKernelException,da1.checkMonotonic,True)
10718         self.assertTrue(da1.isStrictlyMonotonic(False));
10719         da1.checkStrictlyMonotonic(False);
10720         self.assertTrue(da1.isMonotonic(False));
10721         da1.checkMonotonic(False);
10722         #
10723         da1=DataArrayInt.New([13,9,6,6,5,3,1])
10724         self.assertTrue(not da1.isStrictlyMonotonic(True));
10725         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,True)
10726         self.assertTrue(not da1.isMonotonic(True));
10727         self.assertRaises(InterpKernelException,da1.checkMonotonic,True)
10728         self.assertTrue(not da1.isStrictlyMonotonic(False));
10729         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,False)
10730         self.assertTrue(da1.isMonotonic(False));
10731         da1.checkMonotonic(False);
10732         #
10733         da1=DataArrayInt.New([13,9,5,6,5,3,1])
10734         self.assertTrue(not da1.isStrictlyMonotonic(True));
10735         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,True)
10736         self.assertTrue(not da1.isMonotonic(True));
10737         self.assertRaises(InterpKernelException,da1.checkMonotonic,True)
10738         self.assertTrue(not da1.isStrictlyMonotonic(False));
10739         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,False)
10740         self.assertTrue(not da1.isMonotonic(False));
10741         self.assertRaises(InterpKernelException,da1.checkMonotonic,False)
10742         #
10743         da1=DataArrayInt.New([])
10744         self.assertTrue(da1.isStrictlyMonotonic(True));
10745         da1.checkStrictlyMonotonic(True);
10746         self.assertTrue(da1.isMonotonic(True));
10747         da1.checkMonotonic(True);
10748         self.assertTrue(da1.isStrictlyMonotonic(False));
10749         da1.checkStrictlyMonotonic(False);
10750         self.assertTrue(da1.isMonotonic(False));
10751         da1.checkMonotonic(False);
10752         #
10753         da1=DataArrayInt.New([13])
10754         self.assertTrue(da1.isStrictlyMonotonic(True));
10755         da1.checkStrictlyMonotonic(True);
10756         self.assertTrue(da1.isMonotonic(True));
10757         da1.checkMonotonic(True);
10758         self.assertTrue(da1.isStrictlyMonotonic(False));
10759         da1.checkStrictlyMonotonic(False);
10760         self.assertTrue(da1.isMonotonic(False));
10761         da1.checkMonotonic(False);
10762         pass
10763
10764     def testFindAndCorrectBadOriented3DCells1(self):
10765         nbOfDisc=20
10766         vects=([0,0,-1],[0.3,0.7,0.2],[-0.3,0.7,0.2],[-0.3,-0.7,0.2])
10767         #
10768         m0=MEDCouplingUMesh("m",3) ; m0.allocateCells(0); m0.insertNextCell(NORM_TETRA4,[0,1,2,3]); #Well oriented
10769         m1=MEDCouplingUMesh("m",3) ; m1.allocateCells(0); m1.insertNextCell(NORM_PYRA5,[0,1,2,3,4]); #Well oriented
10770         m2=MEDCouplingUMesh("m",3) ; m2.allocateCells(0); m2.insertNextCell(NORM_PENTA6,[0,1,2,3,4,5]); #Well oriented
10771         m3=MEDCouplingUMesh("m",3) ; m3.allocateCells(0); m3.insertNextCell(NORM_HEXA8,[0,1,2,3,4,5,6,7]); #Well oriented
10772         m4=MEDCouplingUMesh("m",3) ; m4.allocateCells(0)
10773         self.assertRaises(InterpKernelException,m4.insertNextCell,NORM_HEXGP12,[0,1,2,3,4,5,6,7,8,9,10,11,12]);
10774         m4.insertNextCell(NORM_HEXGP12,[0,1,2,3,4,5,6,7,8,9,10,11]); #Well oriented
10775         c0=DataArrayDouble([0.,0.,0.,0.,1.,0.,1.,0.,0.,0.,0.,1.],4,3) ; m0.setCoords(c0)
10776         c1=DataArrayDouble([0.,0.,0.,0.,1.,0.,1.,1.,0.,1.,0.,0.,0.,0.,1.],5,3) ; m1.setCoords(c1)
10777         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)
10778         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)
10779         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)
10780         m=MEDCouplingMesh.MergeMeshes([m0,m1,m2,m3,m4])
10781         expected1=DataArrayDouble([0.16666666666666666,0.3333333333333333,0.5,1.,1.])
10782         for v in vects:
10783             for i in xrange(nbOfDisc):
10784                 mm=m.deepCpy()
10785                 mm.rotate([0.,0.,0.],[0.3,0.7,0.2],float(i)/float(nbOfDisc)*2*pi)
10786                 mm2=mm.deepCpy()
10787                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
10788                 self.assertTrue(mm.findAndCorrectBadOriented3DCells().empty())
10789                 self.assertTrue(mm.isEqual(mm2,1e-14))
10790                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
10791                 mm.convertAllToPoly()
10792                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
10793                 pass
10794             pass
10795         #
10796         mOK=m.deepCpy()
10797         m0=MEDCouplingUMesh("m",3) ; m0.allocateCells(0); m0.insertNextCell(NORM_TETRA4,[0,2,1,3]); #Not well oriented
10798         m1=MEDCouplingUMesh("m",3) ; m1.allocateCells(0); m1.insertNextCell(NORM_PYRA5,[0,1,2,3,4]); #Well oriented
10799         m2=MEDCouplingUMesh("m",3) ; m2.allocateCells(0); m2.insertNextCell(NORM_PENTA6,[0,1,2,3,4,5]); #Well oriented
10800         m3=MEDCouplingUMesh("m",3) ; m3.allocateCells(0); m3.insertNextCell(NORM_HEXA8,[0,3,2,1,4,7,6,5]); #Not well oriented
10801         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
10802         m0.setCoords(c0) ; m1.setCoords(c1) ; m2.setCoords(c2) ; m3.setCoords(c3) ; m4.setCoords(c4)
10803         m=MEDCouplingMesh.MergeMeshes([m0,m1,m2,m3,m4])
10804         expected2=DataArrayDouble([-0.16666666666666666,0.3333333333333333,0.5,-1.,-1.])
10805         for v in vects:
10806             for i in xrange(nbOfDisc):
10807                 mm=m.deepCpy()
10808                 mm.rotate([0.,0.,0.],[0.3,0.7,0.2],float(i)/float(nbOfDisc)*2*pi)
10809                 mm2=mm.deepCpy() ; mm3=mm.deepCpy() ; mm3.convertAllToPoly()
10810                 self.assertTrue(mm3.getMeasureField(False).getArray().isEqual(expected2,1e-14))
10811                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected2,1e-14))
10812                 self.assertTrue(mm.findAndCorrectBadOriented3DCells().isEqual(DataArrayInt([0,3,4])))
10813                 mOK.setCoords(mm.getCoords())
10814                 self.assertTrue(mm.isEqual(mOK,1e-14))
10815                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
10816                 mmm=mm.deepCpy()
10817                 self.assertTrue(mmm.findAndCorrectBadOriented3DCells().empty())
10818                 mm.convertAllToPoly()
10819                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
10820                 pass
10821             pass
10822         #
10823         m0=MEDCouplingUMesh("m",3) ; m0.allocateCells(0); m0.insertNextCell(NORM_TETRA4,[0,1,2,3]); #Well oriented
10824         m1=MEDCouplingUMesh("m",3) ; m1.allocateCells(0); m1.insertNextCell(NORM_PYRA5,[0,3,2,1,4]); #Not well oriented
10825         m2=MEDCouplingUMesh("m",3) ; m2.allocateCells(0); m2.insertNextCell(NORM_PENTA6,[0,2,1,3,5,4]); #Not well oriented
10826         m3=MEDCouplingUMesh("m",3) ; m3.allocateCells(0); m3.insertNextCell(NORM_HEXA8,[0,1,2,3,4,5,6,7]); #Well oriented
10827         m4=MEDCouplingUMesh("m",3) ; m4.allocateCells(0); m4.insertNextCell(NORM_HEXGP12,range(12)); #Well oriented
10828         m0.setCoords(c0) ; m1.setCoords(c1) ; m2.setCoords(c2) ; m3.setCoords(c3) ; m4.setCoords(c4)
10829         m=MEDCouplingMesh.MergeMeshes([m0,m1,m2,m3,m4])
10830         expected3=DataArrayDouble([0.16666666666666666,-0.3333333333333333,-0.5,1.,1.])
10831         for v in vects:
10832             for i in xrange(nbOfDisc):
10833                 mm=m.deepCpy()
10834                 mm.rotate([0.,0.,0.],[0.3,0.7,0.2],float(i)/float(nbOfDisc)*2*pi)
10835                 mm2=mm.deepCpy() ; mm3=mm.deepCpy() ; mm3.convertAllToPoly()
10836                 self.assertTrue(mm3.getMeasureField(False).getArray().isEqual(expected3,1e-14))
10837                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected3,1e-14))
10838                 self.assertTrue(mm.findAndCorrectBadOriented3DCells().isEqual(DataArrayInt([1,2])))
10839                 mOK.setCoords(mm.getCoords())
10840                 self.assertTrue(mm.isEqual(mOK,1e-14))
10841                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
10842                 mmm=mm.deepCpy()
10843                 self.assertTrue(mmm.findAndCorrectBadOriented3DCells().empty())
10844                 mm.convertAllToPoly()
10845                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
10846                 pass
10847             pass
10848         pass
10849
10850     def testSwig2CellOrientation1(self):
10851         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)
10852         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]]
10853         for i in xrange(256):
10854             mesh=MEDCouplingUMesh("FluidMesh_1",3);
10855             mesh.allocateCells(0)
10856             conn2=[elt[:] for elt in conn]
10857             code=bin(i)[2:] ; code='0'*(8-len(code))+code
10858             for face,rev in zip(conn2,code):
10859                 if bool(int(rev)):
10860                     face.reverse()
10861                     pass
10862                 pass
10863             conn3=[elt+[-1] for elt in conn2]
10864             conn3=sum(conn3,[])[:-1]
10865             mesh.insertNextCell(NORM_POLYHED,conn3)
10866             mesh.setCoords(coords)
10867             mesh.orientCorrectlyPolyhedrons()
10868             self.assertTrue(mesh.getBarycenterAndOwner().isEqual(DataArrayDouble([-0.10803,0.,0.3385],1,3),1e-12))
10869             pass
10870         pass
10871
10872     def testSwig2CheckConsecutiveCellTypesForMEDFileFrmt1(self):
10873         m1=MEDCouplingUMesh("",2) ; m1.allocateCells(0)
10874         m1.insertNextCell(NORM_QUAD4,[0,1,2,3])
10875         m1.insertNextCell(NORM_TRI3,[0,1,2])
10876         d=DataArrayDouble(4,3) ; d[:]=0.
10877         m1.setCoords(d)
10878         self.assertTrue(m1.checkConsecutiveCellTypes())
10879         self.assertTrue(not m1.checkConsecutiveCellTypesForMEDFileFrmt())
10880         m1.renumberCells([1,0])
10881         self.assertTrue(m1.checkConsecutiveCellTypes())
10882         self.assertTrue(m1.checkConsecutiveCellTypesForMEDFileFrmt())
10883         pass
10884
10885     def testSwig2DAAccumulate1(self):
10886         d=DataArrayInt(10) ; d.iota(0)
10887         self.assertEqual([45],d.accumulate())
10888         self.assertEqual(45,d.accumulate(0))
10889         d=DataArrayInt(30) ; d.iota(0) ; d.rearrange(3)
10890         self.assertEqual([135,145,155],d.accumulate())
10891         self.assertEqual(135,d.accumulate(0))
10892         self.assertEqual(145,d.accumulate(1))
10893         self.assertEqual(155,d.accumulate(2))
10894         d=DataArrayDouble(10) ; d.iota(0.)
10895         self.assertEqual([45.],d.accumulate())
10896         self.assertEqual(45.,d.accumulate(0))
10897         d=DataArrayDouble(30) ; d.iota(0) ; d.rearrange(3)
10898         self.assertEqual([135.,145.,155.],d.accumulate())
10899         self.assertEqual(135.,d.accumulate(0))
10900         self.assertEqual(145.,d.accumulate(1))
10901         self.assertEqual(155.,d.accumulate(2))
10902         pass
10903
10904     def testSwig2UMeshDistanceToMesh1(self):
10905         m=MEDCouplingUMesh("toto",2)
10906         coords=DataArrayDouble([2.3,3.4,5.6,6.5,-4.3,3.2,-9.8,7.6,-5.4],3,3)
10907         m.setCoords(coords)
10908         m.allocateCells(0)
10909         m.insertNextCell(NORM_TRI3,[0,1,2])
10910         a,b=m.distanceToPoint([-0.335,2.27,1.21])
10911         self.assertEqual(0,b)
10912         self.assertAlmostEqual(0.022360988100374124,a,14);
10913         a,b=m.distanceToPoint(DataArrayDouble([-0.335,2.27,1.21],1,3))
10914         self.assertEqual(0,b)
10915         self.assertAlmostEqual(0.022360988100374124,a,14);
10916         a,b=coords.distanceToTuple([-0.335,2.27,1.21])
10917         self.assertAlmostEqual(5.243302871282566,a,14)
10918         self.assertEqual(0,b)
10919         #
10920         m=MEDCouplingUMesh("toto",2)
10921         coords=DataArrayDouble([0.,0.,0., 8.,0.,0., 8.,8.,0., 0.,8.,0.],4,3)
10922         m.setCoords(coords)
10923         m.allocateCells(0)
10924         m.insertNextCell(NORM_QUAD4,[0,1,2,3])
10925         m.checkCoherency2()
10926         self.assertEqual([4,0,1,2,3],m.getNodalConnectivity().getValues())
10927         a,b=m.distanceToPoint([5.,2.,0.1])
10928         self.assertAlmostEqual(0.1,a,14) ; self.assertEqual(0,b)
10929         a,b=m.distanceToPoint([5.,-2.,4.])
10930         self.assertAlmostEqual(sqrt(2*2+4*4),a,14) ; self.assertEqual(0,b)
10931         m.allocateCells(0)
10932         m.insertNextCell(NORM_POLYGON,[0,1,2,3])
10933         m.checkCoherency2()
10934         self.assertEqual([5,0,1,2,3],m.getNodalConnectivity().getValues())
10935         a,b=m.distanceToPoint([11.,3.,4.])
10936         self.assertAlmostEqual(sqrt(3*3+4*4),a,14) ; self.assertEqual(0,b)
10937         a,b=m.distanceToPoint([4.,12.,5.])
10938         self.assertAlmostEqual(sqrt(4*4+5*5),a,14) ; self.assertEqual(0,b)
10939         d=DataArrayDouble([-1.2,3.,2.],1,3)
10940         for elt in d:
10941             a,b=m.distanceToPoint(d)
10942             self.assertAlmostEqual(sqrt(1.2*1.2+2*2),a,14) ; self.assertEqual(0,b)
10943             pass
10944         #
10945         m=MEDCouplingUMesh("toto",1)
10946         coords=DataArrayDouble([0.,0.,4.,0.,0.,4.],3,2) ; m.setCoords(coords)
10947         m.allocateCells(0) ; m.insertNextCell(NORM_SEG2,[0,1]) ; m.insertNextCell(NORM_SEG2,[1,2])
10948         a,b=m.distanceToPoint([-0.1,4.1])
10949         self.assertAlmostEqual(0.14142135623730925,a,14)  # b==1 self.assertEqual(2,c)
10950         a,b=m.distanceToPoint([0.,3.9])
10951         self.assertAlmostEqual(0.07071067811865482,a,14) ; self.assertEqual(1,b) # self.assertEqual(2,c)
10952         pass
10953
10954     def testSwig2NonRegressionPartitionBySpreadZone1(self):
10955         m=MEDCouplingCMesh()
10956         arr=DataArrayDouble(6) ; arr.iota(0.)
10957         m.setCoords(arr,arr,arr)
10958         m=m.buildUnstructured()
10959         mPart=m[50,80,85,87,92,122]
10960         zones=mPart.partitionBySpreadZone()
10961         self.assertEqual(4,len(zones))
10962         self.assertTrue(zones[0].isEqual(DataArrayInt([0])))
10963         self.assertTrue(zones[1].isEqual(DataArrayInt([1,2])))
10964         self.assertTrue(zones[2].isEqual(DataArrayInt([3,4])))
10965         self.assertTrue(zones[3].isEqual(DataArrayInt([5])))
10966         #
10967         n,ni=m.computeNeighborsOfCells()
10968         a,b=MEDCouplingUMesh.ComputeSpreadZoneGraduallyFromSeed(0,n,ni)
10969         self.assertEqual(13,b) ; self.assertEqual(125,len(a)) ; self.assertTrue(a.isIdentity())
10970         a,b=MEDCouplingUMesh.ComputeSpreadZoneGraduallyFromSeed([1],n,ni)
10971         self.assertEqual(12,b) ; self.assertEqual(125,len(a)) ; self.assertTrue(a.isIdentity())
10972         a,b=MEDCouplingUMesh.ComputeSpreadZoneGraduallyFromSeed((2,),n,ni)
10973         self.assertEqual(11,b) ; self.assertEqual(125,len(a)) ; self.assertTrue(a.isIdentity())
10974         a,b=MEDCouplingUMesh.ComputeSpreadZoneGraduallyFromSeed(DataArrayInt([3]),n,ni)
10975         self.assertEqual(12,b) ; self.assertEqual(125,len(a)) ; self.assertTrue(a.isIdentity())
10976         pass
10977
10978     def testSwigUMeshInsertNextCell1(self):
10979         m=MEDCouplingUMesh("toto",2)
10980         #
10981         coords=DataArrayDouble([0.,0.,1.,1.,1.,0.]) ; m.setCoords(coords)
10982         da=DataArrayInt([0,1,2])
10983         m.allocateCells(0)
10984         for i in xrange(5):
10985             m.insertNextCell(NORM_TRI3,da)
10986             pass
10987         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])))
10988         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4,8,12,16,20])))
10989         #
10990         da=DataArrayInt([0,1,2,3])
10991         m.allocateCells(0)
10992         for i in xrange(5):
10993             m.insertNextCell(NORM_TRI3,3,da)
10994             pass
10995         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])))
10996         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4,8,12,16,20])))
10997         #
10998         da=DataArrayInt([0,1])
10999         m.allocateCells(0)
11000         self.assertRaises(InterpKernelException,m.insertNextCell,NORM_TRI3,3,da)
11001         #
11002         da=DataArrayInt([0,1,2,0,1,3,0,1,4,0,1,5,0,1,6],5,3)
11003         m.allocateCells(0)
11004         for t in da:
11005             m.insertNextCell(NORM_TRI3,t)
11006             pass
11007         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])))
11008         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4,8,12,16,20])))
11009         self.assertRaises(InterpKernelException,m.insertNextCell,NORM_TRI3,None)
11010         pass
11011
11012     def testSwigCurveLinearMesh1(self):
11013         m=MEDCouplingCurveLinearMesh("toto")
11014         m.setNodeGridStructure([2,3])
11015         coords=DataArrayDouble([0.,0., 2.,0., 0.,1., 1.9,1.1, 0.3,1.9, 2.2,2.1],6,2)
11016         m.setCoords(coords)
11017         m.checkCoherency()
11018         m0=m.deepCpy()
11019         self.assertTrue(m0.isEqual(m,1e-12))
11020         m.getCoords().setInfoOnComponents(["X [m]","Y [m]"])
11021         self.assertTrue(not m0.isEqual(m,1e-12))
11022         m0=m.deepCpy()
11023         self.assertTrue(m0.isEqual(m,1e-12))
11024         self.assertEqual(m.getNodeGridStructure(),(2,3))
11025         pass
11026
11027     def testSimplexize3(self):
11028         m=MEDCouplingUMesh("toto",3)
11029         m.allocateCells(0)
11030         m.insertNextCell(NORM_TETRA4,[0,1,2,3])
11031         m.insertNextCell(NORM_HEXA8,[4,5,6,7,8,9,10,11])
11032         m.insertNextCell(NORM_HEXA8,[12,13,14,15,16,17,18,19])
11033         m.insertNextCell(NORM_TETRA4,[20,21,22,23])
11034         c1=DataArrayDouble([0.,0.,0.,0.,1.,0.,1.,0.,0.,0.,0.,1.],4,3)
11035         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.]
11036         c3=c2+[2.,0.,0.]
11037         c4=c1+[6.,0.,0.]
11038         c=DataArrayDouble.Aggregate([c1,c2,c3,c4])
11039         m.setCoords(c)
11040         m.checkCoherency2()
11041         #
11042         m1=m.deepCpy()
11043         d1=m1.simplexize(PLANAR_FACE_5)
11044         m1.checkCoherency2()
11045         vol1=m1.getMeasureField(ON_CELLS).getArray()
11046         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))
11047         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])
11048         self.assertEqual(m1.getNodalConnectivityIndex().getValues(),[0,5,10,15,20,25,30,35,40,45,50,55,60])
11049         self.assertTrue(d1.isEqual(DataArrayInt([0,1,1,1,1,1,2,2,2,2,2,3])))
11050         #
11051         m2=m.deepCpy()
11052         d2=m2.simplexize(PLANAR_FACE_6)
11053         m2.checkCoherency2()
11054         vol2=m2.getMeasureField(ON_CELLS).getArray()
11055         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))
11056         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])
11057         self.assertEqual(m2.getNodalConnectivityIndex().getValues(),[0,5,10,15,20,25,30,35,40,45,50,55,60,65,70])
11058         self.assertTrue(d2.isEqual(DataArrayInt([0,1,1,1,1,1,1,2,2,2,2,2,2,3])))
11059         pass
11060
11061     def testSwig2CurveLinearMesh2(self):
11062         c=MEDCouplingCMesh()
11063         #2D
11064         arr1=DataArrayDouble([0,1,3,7])
11065         arr2=DataArrayDouble([0,1,1.5])
11066         c.setCoords(arr1,arr2)
11067         u=c.buildUnstructured()
11068         coo=u.getCoords()
11069         cl=MEDCouplingCurveLinearMesh()
11070         cl.setCoords(coo)
11071         cl.setNodeGridStructure([4,3])
11072         cl.checkCoherency2()
11073         li1=[1.,2.,4.,0.5,1.,2.]
11074         self.assertTrue(cl.getMeasureField(False).getArray().isEqual(DataArrayDouble(li1),1e-14))
11075         self.assertTrue(u.getMeasureField(False).getArray().isEqual(DataArrayDouble(li1),1e-14))
11076         li1_1=[0.5,0.5,2.,0.5,5.,0.5,0.5,1.25,2.,1.25,5.,1.25]
11077         self.assertTrue(cl.getBarycenterAndOwner().isEqual(DataArrayDouble(li1_1,6,2),1e-14))
11078         self.assertTrue(u.getBarycenterAndOwner().isEqual(DataArrayDouble(li1_1,6,2),1e-14))
11079         #3D
11080         c.setCoords(arr1,arr2,arr2)
11081         u=c.buildUnstructured()
11082         coo=u.getCoords()
11083         cl=MEDCouplingCurveLinearMesh()
11084         cl.setCoords(coo)
11085         cl.setNodeGridStructure([4,3,3])
11086         cl.checkCoherency2()
11087         li2=[1.,2.,4.,0.5, 1.,2.,0.5,1.,2.,0.25,0.5,1.]
11088         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]
11089         self.assertTrue(cl.getMeasureField(False).getArray().isEqual(DataArrayDouble(li2),1e-14))
11090         self.assertTrue(u.getMeasureField(False).getArray().isEqual(DataArrayDouble(li2),1e-14))
11091         self.assertTrue(cl.getBarycenterAndOwner().isEqual(DataArrayDouble(li2_1,12,3),1e-14))
11092         self.assertTrue(u.getBarycenterAndOwner().isEqual(DataArrayDouble(li2_1,12,3),1e-14))
11093         #1D spaceDim 1
11094         coo=DataArrayDouble(5) ; coo.iota(0.)
11095         coo=coo*coo
11096         cl.setCoords(coo)
11097         cl.setNodeGridStructure([5])
11098         cl.checkCoherency2()
11099         li3=[1.,3.,5.,7.]
11100         li3_1=[0.5,2.5,6.5,12.5]
11101         self.assertTrue(cl.getMeasureField(False).getArray().isEqual(DataArrayDouble(li3),1e-14))
11102         self.assertTrue(cl.buildUnstructured().getMeasureField(False).getArray().isEqual(DataArrayDouble(li3),1e-14))
11103         self.assertTrue(cl.getBarycenterAndOwner().isEqual(DataArrayDouble(li3_1),1e-14))
11104         self.assertTrue(cl.buildUnstructured().getBarycenterAndOwner().isEqual(DataArrayDouble(li3_1),1e-14))
11105         #1D spaceDim 2
11106         coo=DataArrayDouble.Meld(coo,coo)
11107         cl.setCoords(coo)
11108         cl.checkCoherency2()
11109         li4=[sqrt(2.)*elt for elt in [1.,3.,5.,7.]]
11110         li4_1=[0.5,0.5,2.5,2.5,6.5,6.5,12.5,12.5]
11111         self.assertTrue(cl.getMeasureField(False).getArray().isEqual(DataArrayDouble(li4),1e-14))
11112         self.assertTrue(cl.buildUnstructured().getMeasureField(False).getArray().isEqual(DataArrayDouble(li4),1e-14))
11113         self.assertTrue(cl.getBarycenterAndOwner().isEqual(DataArrayDouble(li4_1,4,2),1e-14))
11114         self.assertTrue(cl.buildUnstructured().getBarycenterAndOwner().isEqual(DataArrayDouble(li4_1,4,2),1e-14))
11115         pass
11116
11117     def testSwig2CurveLinearMeshNonRegression1(self):
11118         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)
11119         m=MEDCouplingCurveLinearMesh("toto")
11120         m.setCoords(coords)
11121         m.setNodeGridStructure([3,3,3])
11122         #
11123         vol=m.getMeasureField(False).getArray()
11124         self.assertTrue(vol.isEqual(DataArrayDouble([0.11450000709295281, 0.10583334351579375,0.11149999939029423,0.08866666863113633, 0.1404166805123294,0.1250000135352219,0.1270833433481557,0.13258334288001067]),1e-12))
11125         self.assertTrue(vol.isEqual(m.buildUnstructured().getMeasureField(False).getArray(),1e-12))
11126         #
11127         self.assertTrue(m.getBarycenterAndOwner().isEqual(m.buildUnstructured().getBarycenterAndOwner(),1e-12))
11128         pass
11129
11130     def testSwig2NonRegressionDASetSelectedComponents1(self):
11131         da=DataArrayDouble.New([1.,2.,3.,4.,5.,6.],3,2)
11132         dv=DataArrayDouble.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(DataArrayDouble([2.,1.,0.,0.,4.,3.,0.,0.,6.,5.,0.,0.,0.,0.,0.,0.],4,4),1e-14))
11139         #
11140         da=DataArrayInt.New([1,2,3,4,5,6],3,2)
11141         dv=DataArrayInt.New();
11142         dv.alloc(4,4)
11143         dv.fillWithZero()
11144         # da has less tuples than dv
11145         dv.setSelectedComponents(da,[1,0])
11146         #
11147         self.assertTrue(dv.isEqual(DataArrayInt([2,1,0,0,4,3,0,0,6,5,0,0,0,0,0,0],4,4)))
11148         pass
11149
11150     def testSwigSetItem3(self):
11151         # 1-2
11152         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11153         d[3]=[1,2]
11154         self.assertTrue(d.isEqual(DataArrayDouble([0,0,0,0,0,0,1,2,0,0,0,0],6,2),1e-14))
11155         # 2-2 false
11156         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11157         d[[5,3,2]]=[1,2]
11158         self.assertTrue(d.isEqual(DataArrayDouble([0,0,0,0,1,2,1,2,0,0,1,2],6,2),1e-14))
11159         # 3-2 false
11160         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11161         d[:]=[1,2]
11162         self.assertTrue(d.isEqual(DataArrayDouble([1,2,1,2,1,2,1,2,1,2,1,2],6,2),1e-14))
11163         # 4-2 false
11164         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11165         d[DataArrayInt([0,3,4])]=[1,2]
11166         self.assertTrue(d.isEqual(DataArrayDouble([1,2,0,0,0,0,1,2,1,2,0,0],6,2),1e-14))
11167         # 5-2
11168         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11169         d[5,1]=[7]
11170         self.assertTrue(d.isEqual(DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,7],6,2),1e-14))
11171         # 6-2 false
11172         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11173         d[[3,5],1]=[7]
11174         self.assertTrue(d.isEqual(DataArrayDouble([0,0,0,0,0,0,0,7,0,0,0,7],6,2),1e-14))
11175         # 7-2 false
11176         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11177         d[:-1:2,1]=[7]
11178         self.assertTrue(d.isEqual(DataArrayDouble([0,7,0,0,0,7,0,0,0,7,0,0],6,2),1e-14))
11179         # 8-2 false
11180         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11181         d[DataArrayInt([0,3,4]),1]=[7]
11182         self.assertTrue(d.isEqual(DataArrayDouble([0,7,0,0,0,0,0,7,0,7,0,0],6,2),1e-14))
11183         # 9-2
11184         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11185         d[3,[1,0]]=[7,8]
11186         self.assertTrue(d.isEqual(DataArrayDouble([0,0,0,0,0,0,8,7,0,0,0,0],6,2),1e-14))
11187         # 10-2 false
11188         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11189         d[[1,3,4],[1,0]]=[7,8]
11190         self.assertTrue(d.isEqual(DataArrayDouble([0,0,8,7,0,0,8,7,8,7,0,0],6,2),1e-14))
11191         # 11-2 false
11192         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11193         d[1::2,[1,0]]=[7,8]
11194         self.assertTrue(d.isEqual(DataArrayDouble([0,0,8,7,0,0,8,7,0,0,8,7],6,2),1e-14))
11195         # 12-2 false
11196         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11197         d[DataArrayInt([1,4]),[1,0]]=[7,8]
11198         self.assertTrue(d.isEqual(DataArrayDouble([0,0,8,7,0,0,0,0,8,7,0,0],6,2),1e-14))
11199         # 13-2
11200         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11201         d[1,:-1]=[9]
11202         self.assertTrue(d.isEqual(DataArrayDouble([0,0,9,0,0,0,0,0,0,0,0,0],6,2),1e-14))
11203         # 14-2 false
11204         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11205         d[[1,4,5],:]=[7,8]
11206         self.assertTrue(d.isEqual(DataArrayDouble([0,0,7,8,0,0,0,0,7,8,7,8],6,2),1e-14))
11207         # 15-2 false
11208         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11209         d[1::2,:]=[3,9]
11210         self.assertTrue(d.isEqual(DataArrayDouble([0,0,3,9,0,0,3,9,0,0,3,9],6,2),1e-14))
11211         # 1-2
11212         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11213         d[3]=[1,2]
11214         self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,0,0,1,2,0,0,0,0],6,2)))
11215         # 2-2 false
11216         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11217         d[[5,3,2]]=[1,2]
11218         self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,1,2,1,2,0,0,1,2],6,2)))
11219         # 3-2 false
11220         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11221         d[:]=[1,2]
11222         self.assertTrue(d.isEqual(DataArrayInt([1,2,1,2,1,2,1,2,1,2,1,2],6,2)))
11223         # 4-2 false
11224         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11225         d[DataArrayInt([0,3,4])]=[1,2]
11226         self.assertTrue(d.isEqual(DataArrayInt([1,2,0,0,0,0,1,2,1,2,0,0],6,2)))
11227         # 5-2
11228         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11229         d[5,1]=[7]
11230         self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,7],6,2)))
11231         # 6-2 false
11232         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11233         d[[3,5],1]=[7]
11234         self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,0,0,0,7,0,0,0,7],6,2)))
11235         # 7-2 false
11236         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11237         d[:-1:2,1]=[7]
11238         self.assertTrue(d.isEqual(DataArrayInt([0,7,0,0,0,7,0,0,0,7,0,0],6,2)))
11239         # 8-2 false
11240         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11241         d[DataArrayInt([0,3,4]),1]=[7]
11242         self.assertTrue(d.isEqual(DataArrayInt([0,7,0,0,0,0,0,7,0,7,0,0],6,2)))
11243         # 9-2
11244         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11245         d[3,[1,0]]=[7,8]
11246         self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,0,0,8,7,0,0,0,0],6,2)))
11247         # 10-2 false
11248         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11249         d[[1,3,4],[1,0]]=[7,8]
11250         self.assertTrue(d.isEqual(DataArrayInt([0,0,8,7,0,0,8,7,8,7,0,0],6,2)))
11251         # 11-2 false
11252         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11253         d[1::2,[1,0]]=[7,8]
11254         self.assertTrue(d.isEqual(DataArrayInt([0,0,8,7,0,0,8,7,0,0,8,7],6,2)))
11255         # 12-2 false
11256         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11257         d[DataArrayInt([1,4]),[1,0]]=[7,8]
11258         self.assertTrue(d.isEqual(DataArrayInt([0,0,8,7,0,0,0,0,8,7,0,0],6,2)))
11259         # 13-2
11260         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11261         d[1,:-1]=[9]
11262         self.assertTrue(d.isEqual(DataArrayInt([0,0,9,0,0,0,0,0,0,0,0,0],6,2)))
11263         # 14-2 false
11264         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11265         d[[1,4,5],:]=[7,8]
11266         self.assertTrue(d.isEqual(DataArrayInt([0,0,7,8,0,0,0,0,7,8,7,8],6,2)))
11267         # 15-2 false
11268         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11269         d[1::2,:]=[3,9]
11270         self.assertTrue(d.isEqual(DataArrayInt([0,0,3,9,0,0,3,9,0,0,3,9],6,2)))
11271         pass
11272
11273     def testSwig2ConvertLinearCellsToQuadratic1(self):
11274         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)
11275         # 2D
11276         m2D=MEDCouplingDataForTest.build2DTargetMesh_1()
11277         m2D.convertLinearCellsToQuadratic(0)
11278         m2D.checkCoherency1()
11279         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])
11280         self.assertEqual(m2D.getNodalConnectivityIndex().getValues(),[0,9,16,23,32,41])
11281         self.assertTrue(m2D.getCoords().isEqual(coordsExp,1e-14))
11282         # 1D
11283         m1D=MEDCouplingDataForTest.build2DTargetMesh_1().buildDescendingConnectivity()[0]
11284         m1D.convertLinearCellsToQuadratic(0)
11285         m1D.checkCoherency1()
11286         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])
11287         self.assertEqual(m1D.getNodalConnectivityIndex().getValues(),[0,4,8,12,16,20,24,28,32,36,40,44,48,52])
11288         self.assertTrue(m1D.getCoords().isEqual(coordsExp,1e-14))
11289         # 3D
11290         m2D=MEDCouplingDataForTest.build2DTargetMesh_1()
11291         m2D.changeSpaceDimension(3)
11292         arr=DataArrayDouble(4);  arr.iota(0) ; z=MEDCouplingCMesh() ; z.setCoords(arr)
11293         m1D=z.buildUnstructured() ; m1D.setCoords(arr.changeNbOfComponents(3,0.))
11294         m1D.getCoords()[:]=m1D.getCoords()[:,[1,2,0]]
11295         cooTmp=m2D.getCoords()[:]
11296         m3D=m2D.buildExtrudedMesh(m1D,0)
11297         m3D.convertLinearCellsToQuadratic(0)
11298         m3D.checkCoherency1()
11299         # check of new m3D content
11300         coordsExp2=[coordsExp.changeNbOfComponents(3,i) for i in xrange(4)]
11301         coordsExp3=[DataArrayDouble.Meld(cooTmp[:,[0,1]],cooTmp[:,2]+(0.5+float(i))) for i in xrange(3)]
11302         coordsExp4=DataArrayDouble.Aggregate([coordsExp2[0],coordsExp3[0],coordsExp2[1],coordsExp3[1],coordsExp2[2],coordsExp3[2],coordsExp2[3]])
11303         c=DataArrayDouble.Aggregate(m3D.getCoords(),coordsExp4)
11304         self.assertEqual(len(coordsExp4),115)
11305         self.assertEqual(len(m3D.getCoords()),115)
11306         a,b=c.findCommonTuples(1e-14)
11307         self.assertEqual(len(b),len(coordsExp4)+1)
11308         e,f=DataArrayInt.BuildOld2NewArrayFromSurjectiveFormat2(2*115,a,b)
11309         self.assertEqual(f,115)
11310         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])))
11311         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()))
11312         self.assertTrue(DataArrayInt([0,21,37,53,74,95,116,132,148,169,190,211,227,243,264,285]).isEqual(m3D.getNodalConnectivityIndex()))
11313         # testing explode3DMeshTo1D
11314         m3DSlice0=m3D[:5]
11315         m3DSlice0.zipCoords()
11316         a,b,c,d,e=m3DSlice0.explode3DMeshTo1D()
11317         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])))
11318         self.assertTrue(c.isEqual(DataArrayInt([0,12,21,30,42,54])))
11319         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])))
11320         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])))
11321         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])))
11322         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])))
11323         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))
11324         pass
11325
11326     def testSwig2DataArrayPushBackValsSilent1(self):
11327         d=DataArrayDouble()
11328         d.pushBackValsSilent([4,5,6])
11329         self.assertTrue(d.isEqual(DataArrayDouble([4.,5.,6.]),1e-14))
11330         e=DataArrayDouble([1,2,3],1,3)
11331         for t in e: d.pushBackValsSilent(t)
11332         self.assertTrue(d.isEqual(DataArrayDouble([4.,5.,6.,1.,2.,3.]),1e-14))
11333         d.pushBackValsSilent(DataArrayDouble([9,10.]))
11334         self.assertTrue(d.isEqual(DataArrayDouble([4.,5.,6.,1.,2.,3.,9.,10.]),1e-14))
11335         d.pushBackValsSilent(DataArrayDouble(0,1))
11336         self.assertTrue(d.isEqual(DataArrayDouble([4.,5.,6.,1.,2.,3.,9.,10.]),1e-14))
11337         e=DataArrayDouble([1,2,3],3,1)
11338         for t in e: d.pushBackValsSilent(t)
11339         self.assertTrue(d.isEqual(DataArrayDouble([4.,5.,6.,1.,2.,3.,9.,10.,1.,2.,3.]),1e-14))
11340         d.pushBackValsSilent(77)
11341         self.assertTrue(d.isEqual(DataArrayDouble([4.,5.,6.,1.,2.,3.,9.,10.,1.,2.,3.,77.]),1e-14))
11342         #
11343         d=DataArrayInt()
11344         d.pushBackValsSilent([4,5,6])
11345         self.assertTrue(d.isEqual(DataArrayInt([4,5,6])))
11346         e=DataArrayInt([1,2,3],1,3)
11347         for t in e: d.pushBackValsSilent(t)
11348         self.assertTrue(d.isEqual(DataArrayInt([4,5,6,1,2,3])))
11349         d.pushBackValsSilent(DataArrayInt([9,10]))
11350         self.assertTrue(d.isEqual(DataArrayInt([4,5,6,1,2,3,9,10])))
11351         d.pushBackValsSilent(DataArrayInt(0,1))
11352         self.assertTrue(d.isEqual(DataArrayInt([4,5,6,1,2,3,9,10])))
11353         e=DataArrayInt([1,2,3],3,1)
11354         for t in e: d.pushBackValsSilent(t)
11355         self.assertTrue(d.isEqual(DataArrayInt([4,5,6,1,2,3,9,10,1,2,3])))
11356         d.pushBackValsSilent(77)
11357         self.assertTrue(d.isEqual(DataArrayInt([4,5,6,1,2,3,9,10,1,2,3,77])))
11358         pass
11359
11360     def testSwig2ConvertLinearCellsToQuadratic2(self):
11361         m2D=MEDCouplingDataForTest.build2DTargetMesh_1()
11362         ret=m2D.convertLinearCellsToQuadratic(1)
11363         self.assertTrue(ret.isIdentity())
11364         self.assertEqual(5,len(ret))
11365         m2D.checkCoherency1()
11366         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)
11367         self.assertTrue(m2D.getCoords().isEqual(coordsExp,1e-14))
11368         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])))
11369         self.assertTrue(m2D.getNodalConnectivityIndex().isEqual(DataArrayInt([0,10,18,26,36,46])))
11370         #
11371         m2D=MEDCouplingDataForTest.build2DTargetMesh_1()[(0,3)] ; m2D.zipCoords()
11372         m2D.changeSpaceDimension(3)
11373         arr=DataArrayDouble(3);  arr.iota(0) ; z=MEDCouplingCMesh() ; z.setCoords(arr)
11374         m1D=z.buildUnstructured() ; m1D.setCoords(arr.changeNbOfComponents(3,0.))
11375         m1D.getCoords()[:]=m1D.getCoords()[:,[1,2,0]]
11376         cooTmp=m2D.getCoords()[:]
11377         m3D=m2D.buildExtrudedMesh(m1D,0)
11378         ret=m3D.convertLinearCellsToQuadratic(1)
11379         self.assertTrue(ret.isIdentity())
11380         self.assertEqual(4,len(ret))
11381         m3D.checkCoherency1()
11382         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)
11383         self.assertTrue(m3D.getCoords().isEqual(coordsExp2,1e-14))
11384         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])))
11385         self.assertTrue(m3D.getNodalConnectivityIndex().isEqual(DataArrayInt([0,28,56,84,112])))
11386         pass
11387
11388     def testSwig2GaussNEIntegral1(self):
11389         m2D=MEDCouplingDataForTest.build2DTargetMesh_1()
11390         m0=m2D[0] ; m0.zipCoords()
11391         m1=m2D[[1,2]] ; m1.zipCoords()
11392         m2=m2D[[3,4]] ; m2.zipCoords()
11393         m0.convertLinearCellsToQuadratic(1)
11394         m1.convertLinearCellsToQuadratic(0)
11395         m2.convertLinearCellsToQuadratic(1)
11396         m=MEDCouplingUMesh.MergeUMeshes([m0,m1,m2])
11397         m.mergeNodes(1e-12)
11398         f=MEDCouplingFieldDouble(ON_GAUSS_NE)
11399         f.setMesh(m)
11400         arr=DataArrayDouble([1.1,2.2,3.3,4.4,5.5,6.6,7.7,8.8,9.9,
11401                              11.1,12.2,13.3,14.4,15.5,16.6,
11402                              21.1,22.2,23.3,24.4,25.5,26.6,
11403                              31.1,32.2,33.3,34.4,35.5,36.6,37.7,38.8,39.9,
11404                              41.1,42.2,43.3,44.4,45.5,46.6,47.7,48.8,49.9])
11405         arr2=DataArrayDouble(len(arr),2)
11406         arr2[:,0]=arr ; arr2[:,1]=arr+100
11407         f.setArray(arr2)
11408         f.checkCoherency()
11409         res=f.integral(False)
11410         # a=25./81 ; b=40./81 ; c=64./81
11411         # p1=0.11169079483905 ; p2=0.0549758718227661
11412         # 1st compo
11413         # 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
11414         # c1=(p2*(11.1+12.2+13.3)+p1*(14.4+15.5+16.6))*0.125/0.4999999999854482 ; c1=1.8014347172346943
11415         # c2=(p2*(21.1+22.2+23.3)+p1*(24.4+25.5+26.6))*0.125/0.4999999999854482 ; c2=3.0514347172346943
11416         # 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
11417         # 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
11418         # c0+c1+c2+c3+c4=27.104258323358287
11419         integExp0=27.104258323358287
11420         self.assertAlmostEqual(res[0],integExp0,13)
11421         # 2nd compo
11422         # 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
11423         # c1=(p2*(111.1+112.2+113.3)+p1*(114.4+115.5+116.6))*0.125/0.4999999999854482 ; c1=14.301434717234699
11424         # c2=(p2*(121.1+122.2+123.3)+p1*(124.4+125.5+126.6))*0.125/0.4999999999854482 ; c2=15.5514347172347
11425         # 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
11426         # 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
11427         # c0+c1+c2+c3+c4=127.10425832335835
11428         integExp1=127.10425832335835
11429         self.assertAlmostEqual(res[1],integExp1,12)
11430         meas=f.getDiscretization().getMeasureField(f.getMesh(),False)
11431         intPerTuple=meas*f
11432         res2=intPerTuple.accumulate()
11433         self.assertAlmostEqual(res2[0],integExp0,13)
11434         self.assertAlmostEqual(res2[1],integExp1,12)
11435         #
11436         meas2=f.buildMeasureField(False)
11437         intPerTuple=meas2*f
11438         res3=intPerTuple.accumulate()
11439         self.assertAlmostEqual(res3[0],integExp0,13)
11440         self.assertAlmostEqual(res3[1],integExp1,12)
11441         #
11442         res4=f.getWeightedAverageValue(False) # res4==res2 because sum of area of mesh is equal to 1
11443         self.assertAlmostEqual(res4[0],integExp0,13)
11444         self.assertAlmostEqual(res4[1],integExp1,12)
11445         #
11446         m.scale([0,0],2.)
11447         #
11448         res5=f.getWeightedAverageValue() # res4==res4 because weighted average is not sensitive to the scaling
11449         self.assertAlmostEqual(res5[0],integExp0,13)
11450         self.assertAlmostEqual(res5[1],integExp1,12)
11451         meas3=f.buildMeasureField(False)
11452         delta=4*meas2.getArray()-meas3.getArray()
11453         delta.abs()
11454         self.assertTrue(delta.isUniform(0.,1e-16))
11455         res6=f.integral(False)
11456         self.assertAlmostEqual(res6[0],4.*integExp0,12)
11457         self.assertAlmostEqual(res6[1],4.*integExp1,11)
11458         pass
11459
11460     def testSwig2SlowDADFindClosestTupleId(self):
11461         nbPts=[10,]
11462         for nbPt in nbPts:
11463             d=DataArrayDouble(nbPt) ; d.iota() ; d*=1./(nbPt-1)
11464             c=MEDCouplingCMesh() ; c.setCoords(d,d) ; m=c.buildUnstructured() ; pts=m.getCoords() ; del m
11465             #
11466             d0=DataArrayDouble((nbPt-1)*(nbPt-1)) ; d0.iota() ; d0*=(3./((nbPt-1)*(nbPt-1))) ; d0=d0.applyFunc("exp(x)-1")
11467             d1=DataArrayDouble((nbPt-1)*(nbPt-1)) ; d1.iota()
11468             d2=DataArrayDouble.Meld(d0,d1) ; d2=d2.fromPolarToCart() ; d2+=[0.32,0.73]
11469             ids=pts.findClosestTupleId(d2)
11470             #print "Start of costly computation"
11471             idsExpected=DataArrayInt(len(d2))
11472             tmp=1e300
11473             for i,elt in enumerate(d2):
11474                 l,m=(pts-elt).magnitude().getMinValue()
11475                 idsExpected.setIJSilent(i,0,m)
11476                 if l<tmp:
11477                     tmp=l ; tmp1=m ; tmp2=i
11478                     pass
11479                 pass
11480             #print "End of costly computation"
11481             self.assertTrue(idsExpected.isEqual(ids))
11482             a,b,c=pts.minimalDistanceTo(d2)
11483             self.assertEqual(tmp,a)
11484             self.assertEqual(tmp1,b)
11485             self.assertEqual(tmp2,c)
11486             #
11487             l=[d2[:,i] for i in [0,1]]
11488             for elt in l: elt.reverse()
11489             d2i=DataArrayDouble.Meld(l)
11490             ids1=pts.findClosestTupleId(d2i)
11491             idsExpectedI=idsExpected.deepCpy() ; idsExpectedI.reverse()
11492             self.assertTrue(idsExpectedI.isEqual(ids1))
11493             #
11494             l=[pts[:,i] for i in [0,1]]
11495             for elt in l: elt.reverse()
11496             ptsi=DataArrayDouble.Meld(l)
11497             ids2=ptsi.findClosestTupleId(d2)
11498             idsExpected2=nbPt*nbPt-1-ids
11499             self.assertTrue(idsExpected2.isEqual(ids2))
11500             #
11501             ids3=ptsi.findClosestTupleId(d2i)
11502             idsExpected3=idsExpected2.deepCpy() ; idsExpected3.reverse()
11503             self.assertTrue(idsExpected3.isEqual(ids3))
11504             pass
11505
11506     def testSwig2DataArrayAsciiChar1(self):
11507         alpha=DataArrayInt(26) ; alpha.iota(ord("A"))
11508         d=DataArrayAsciiChar(alpha.getValues(),2,13)
11509         d.setInfoOnComponents(["c%i"%(v) for v in xrange(13)])
11510         self.assertEqual('ABCDEFGHIJKLM',d.getTuple(0))
11511         self.assertEqual('NOPQRSTUVWXYZ',d.getTuple(1))
11512         self.assertEqual(2,d.getNumberOfTuples())
11513         self.assertEqual(26,d.getNbOfElems())
11514         self.assertEqual(13,d.getNumberOfComponents())
11515         dd=d.deepCpy()
11516         self.assertTrue(d.isEqual(dd))
11517         dd.setIJ(0,3,'d')
11518         self.assertTrue(not d.isEqual(dd))
11519         d.setIJ(0,3,ord('d'))
11520         self.assertTrue(d.isEqual(dd))
11521         d.rearrange(1)
11522         d.reserve(20)
11523         self.assertEqual(20,d.getNumberOfTuples())
11524         self.assertEqual(20,d.getNbOfElems())
11525         self.assertEqual(1,d.getNumberOfComponents())
11526         #
11527         d0=DataArrayAsciiChar([ord('a')],1,1)
11528         self.assertEqual('a',d0.asciiCharValue())
11529         self.assertTrue(not d0.empty())
11530         d0=DataArrayAsciiChar(0,3)
11531         self.assertTrue(d0.empty())
11532         d.pushBackSilent("U") ; d.pushBackSilent("V") ; d.pushBackSilent("W")
11533         self.assertEqual("W",d.popBackSilent())
11534         d.rearrange(2)
11535         self.assertEqual(['AB','Cd','EF','GH','IJ','KL','MN','OP','QR','ST','UV'],d.toStrList())
11536         d.fillWithZero()
11537         self.assertEqual(11*[''],d.toStrList())
11538         d.fillWithValue('T')
11539         self.assertEqual(11*["TT"],d.toStrList())
11540         d.rearrange(1)
11541         self.assertTrue(d.isUniform("T"))
11542         d.rearrange(2)
11543         #
11544         dd.rearrange(2)
11545         dd2=dd.deepCpy()
11546         dd.renumberInPlace([3,1,2,4,0,11,10,9,8,7,5,12,6])
11547         self.assertEqual(dd.toStrList(),['IJ','Cd','EF','AB','GH','UV','YZ','ST','QR','OP','MN','KL','WX'])
11548         dd.renumberInPlaceR([3,1,2,4,0,11,10,9,8,7,5,12,6])
11549         self.assertEqual(['AB','Cd','EF','GH','IJ','KL','MN','OP','QR','ST','UV','WX','YZ'],dd.toStrList())
11550         e=dd.renumber([3,1,2,4,0,11,10,9,8,7,5,12,6])
11551         self.assertEqual(e.toStrList(),['IJ','Cd','EF','AB','GH','UV','YZ','ST','QR','OP','MN','KL','WX'])
11552         e=dd.renumberR([3,1,2,4,0,11,10,9,8,7,5,12,6])
11553         self.assertEqual(e.toStrList(),['GH','Cd','EF','IJ','AB','WX','UV','ST','QR','OP','KL','YZ','MN'])
11554         e=dd.renumberAndReduce([1,1,1,1,1,1,1,2,0,0,0,0,0],3)
11555         self.assertEqual(['YZ','MN','OP'],e.toStrList())
11556         self.assertEqual(['GH','IJ'],dd.selectByTupleIdSafe([3,4]).toStrList())
11557         self.assertEqual(['AB','GH','MN','ST','YZ'],dd.selectByTupleId2(0,13,3).toStrList())
11558         dd3=dd.changeNbOfComponents(3,"G")
11559         self.assertEqual(['ABG','CdG','EFG','GHG','IJG','KLG','MNG','OPG','QRG','STG','UVG','WXG','YZG'],dd3.toStrList())
11560         dd3.rearrange(1) ; self.assertEqual("G",dd3.back()) ; dd3.rearrange(3)
11561         self.assertTrue(dd3.changeNbOfComponents(2,"\0").isEqual(dd))
11562         self.assertEqual(len(dd),13)
11563         d=DataArrayAsciiChar(13,2) ; d.fillWithValue('Y')
11564         dd3.meldWith(d)
11565         self.assertEqual(['ABGYY','CdGYY','EFGYY','GHGYY','IJGYY','KLGYY','MNGYY','OPGYY','QRGYY','STGYY','UVGYY','WXGYY','YZGYY'],dd3.toStrList())
11566         self.assertEqual("d",dd3.getIJ(0,6))
11567         self.assertRaises(InterpKernelException,dd3.getIJSafe,0,6)
11568         self.assertEqual("d",dd3.getIJSafe(1,1))
11569         dd3.rearrange(1)
11570         e=dd3.getIdsEqual("Y")
11571         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])))
11572         e=dd3.getIdsNotEqual("Y")
11573         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])))
11574         self.assertEqual(("d",6),dd3.getMaxValue())
11575         self.assertEqual(("A",0),dd3.getMinValue())
11576         self.assertEqual(26,dd3.search("LGYYM"))
11577         self.assertEqual(-1,dd3.search("LGYYN"))
11578         dd3.rearrange(5)
11579         self.assertEqual(7,dd3.locateTuple("OPGYY"))
11580         self.assertTrue("OPGYY" in dd3)
11581         self.assertEqual(7,dd3.index("OPGYY"))
11582         self.assertEqual(-1,dd3.locateTuple("OPGYP"))
11583         dd3.rearrange(1)
11584         self.assertEqual(2,dd3.locateValue("OPGYY"))
11585         self.assertTrue(dd3.presenceOfValue("OPGYY"))
11586         self.assertTrue("O" in dd3)
11587         self.assertTrue(not dd3.presenceOfValue("z"))
11588         self.assertTrue("z" not in dd3)
11589         dd3.rearrange(5)
11590         l=list(dd3)
11591         self.assertEqual([e.buildDAAsciiChar().toStrList()[0] for e in list(dd3)],dd3.toStrList())
11592         dd3.reAlloc(5)
11593         dd4=DataArrayChar.Aggregate(dd3,dd3)
11594         self.assertEqual(['ABGYY','CdGYY','EFGYY','GHGYY','IJGYY','ABGYY','CdGYY','EFGYY','GHGYY','IJGYY'],dd4.toStrList())
11595         dd5=DataArrayChar.Aggregate([dd4,dd3,dd4])
11596         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())
11597         # getitem,__iter__,__setitem__
11598         a=list(dd3)
11599         self.assertEqual("ABGYY",str(a[0]))
11600         dd4=dd3[::2]
11601         self.assertEqual(['ABGYY','EFGYY','IJGYY'],dd4.toStrList())
11602         dd4=dd3[(3,2,1)]
11603         self.assertEqual(['GHGYY','EFGYY','CdGYY'],dd4.toStrList())
11604         dd4=dd3[:]
11605         dd4[::2]=["12","345","67890"]
11606         self.assertEqual(['12   ','CdGYY','345  ','GHGYY','67890'],dd4.toStrList())
11607         dd4=dd3[:]
11608         dd4[[1,2]]=" "
11609         self.assertEqual(['ABGYY','     ','     ','GHGYY','IJGYY'],dd4.toStrList())
11610         dd4=dd3[:]
11611         dd4[4]='12345'
11612         self.assertEqual(['ABGYY','CdGYY','EFGYY','GHGYY','12345'],dd4.toStrList())
11613         dd4[0]=dd4[1]
11614         self.assertEqual(['CdGYY','CdGYY','EFGYY','GHGYY','12345'],dd4.toStrList())
11615         dd4=DataArrayAsciiChar(["abc","de","fghi"])
11616         self.assertEqual(['abc ','de  ','fghi'],dd4.toStrList())
11617         dd4=DataArrayAsciiChar(["abc","de","fghi"],"t")
11618         self.assertEqual(['abct','dett','fghi'],dd4.toStrList())
11619         pass
11620
11621     def testSwig2GaussNELocalizationOfDiscValues(self):
11622         m=MEDCouplingDataForTest.build2DTargetMesh_3()[[0,1,3,4,5,6,8,9]] # suppression of polygons
11623         f=MEDCouplingFieldDouble(ON_GAUSS_NE)
11624         f.setMesh(m)
11625         loc=f.getLocalizationOfDiscr()
11626         self.assertEqual(42,len(loc))
11627         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))
11628         m.changeSpaceDimension(3)
11629         m.getCoords()[:,2]=7.
11630         loc=f.getLocalizationOfDiscr()
11631         self.assertEqual(42,len(loc))
11632         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))
11633         pass
11634
11635     def testSwig2GaussMeasureAndIntegral(self):
11636         ft=MEDCouplingDataForTest.buildFieldOnGauss_1()
11637         mea=ft.buildMeasureField(False)
11638         mea.checkCoherency()
11639         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))
11640         f=MEDCouplingFieldDouble(ft)
11641         arr=DataArrayDouble(126,2)
11642         arr[:,0]=range(126)
11643         arr[:,1]=range(126)
11644         arr[:,1]+=1000
11645         f.setArray(arr)
11646         f.checkCoherency()
11647         self.assertTrue(DataArrayDouble(f.integral(False)).isEqual(DataArrayDouble([-211.66121638700983,-4863.9563007698835]),1e-12))
11648         self.assertTrue(DataArrayDouble(f.getWeightedAverageValue()).isEqual(DataArrayDouble([45.496085813113595,1045.496085813114]),1e-12))
11649         self.assertTrue(DataArrayDouble(f.normL1()).isEqual(DataArrayDouble([45.49608581311362,1045.496085813114]),1e-12))
11650         self.assertTrue(DataArrayDouble(f.normL2()).isEqual(DataArrayDouble([58.16846378340898,1046.1241521947334]),1e-12))
11651         pass
11652
11653     def testSwig2FieldDiscretizationComputeMeshRestrictionFromTupleIds1(self):
11654         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1()
11655         f=MEDCouplingFieldDouble(ON_GAUSS_NE)
11656         f.setMesh(m)
11657         a,b=f.getDiscretization().computeMeshRestrictionFromTupleIds(f.getMesh(),[3,4,5,6,8,9,10,14,15,16,17])
11658         self.assertTrue(a.isEqual(DataArrayInt([1,4])))
11659         self.assertTrue(b.isEqual(DataArrayInt([4,5,6,14,15,16,17])))
11660         a,b=f.getDiscretization().computeMeshRestrictionFromTupleIds(f.getMesh(),DataArrayInt([0,1,2,3,5,7,8,9,10,11,12,18]))
11661         self.assertTrue(a.isEqual(DataArrayInt([0,2])))
11662         self.assertTrue(b.isEqual(DataArrayInt([0,1,2,3,7,8,9])))
11663         #
11664         f=MEDCouplingFieldDouble(ON_CELLS)
11665         f.setMesh(m)
11666         a,b=f.getDiscretization().computeMeshRestrictionFromTupleIds(f.getMesh(),[3,4])
11667         self.assertTrue(a.isEqual(DataArrayInt([3,4])))
11668         self.assertTrue(b.isEqual(DataArrayInt([3,4])))
11669         #
11670         f=MEDCouplingFieldDouble(ON_NODES)
11671         f.setMesh(m)
11672         a,b=f.getDiscretization().computeMeshRestrictionFromTupleIds(f.getMesh(),[1,2,3,4])
11673         self.assertTrue(a.isEqual(DataArrayInt([1])))
11674         self.assertTrue(b.isEqual(DataArrayInt([1,2,4])))
11675         #
11676         f=MEDCouplingDataForTest.buildFieldOnGauss_1()
11677         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])
11678         self.assertTrue(a.isEqual(DataArrayInt([0,11,12,18,35])))
11679         self.assertTrue(b.isEqual(DataArrayInt([0,11,12,13,14,15,36,37,38,117,118,119,120,121,122,123,124,125])))
11680         #
11681         d=DataArrayInt([0,3,7,9,15,18])
11682         e=DataArrayInt([0,1,2,3,7,8,15,16,17])
11683         a,b=d.searchRangesInListOfIds(e)
11684         self.assertTrue(a.isEqual(DataArrayInt([0,2,4])))
11685         self.assertTrue(b.isEqual(DataArrayInt([0,1,2,7,8,15,16,17])))
11686         pass
11687
11688     def testSwig2BigMem(self):
11689         if MEDCouplingSizeOfVoidStar()==64:
11690             d=DataArrayAsciiChar(223456789,16)
11691             self.assertTrue(d.getNumberOfTuples(),223456789)
11692             self.assertTrue(d.getNumberOfComponents(),16)
11693             d.setIJ(223456788,5,"r")
11694             self.assertTrue(d.getIJ(223456788,5),'r')
11695             d[223456787]="1234567890123456"
11696             self.assertTrue(d[223456787],'1234567890123456')
11697             self.assertRaises(InterpKernelException,d.rearrange,1)# fails because it would lead to nb of tuples > 2147483647
11698             pass
11699         pass
11700
11701     def testSwig2DAReverseMultiCompo1(self):
11702         d=DataArrayDouble(6,2)
11703         d[:,0]=range(6)
11704         d[:,1]=range(10,16)
11705         d.reverse()
11706         self.assertTrue(d.isEqual(DataArrayDouble([5.,15.,4.,14.,3.,13.,2.,12.,1.,11.,0.,10.],6,2),1e-14))
11707         d=DataArrayDouble(7,2)
11708         d[:,0]=range(7)
11709         d[:,1]=range(10,17)
11710         d.reverse()
11711         self.assertTrue(d.isEqual(DataArrayDouble([6.,16.,5.,15.,4.,14.,3.,13.,2.,12.,1.,11.,0.,10.],7,2),1e-14))
11712         #
11713         d=DataArrayInt(6,2)
11714         d[:,0]=range(6)
11715         d[:,1]=range(10,16)
11716         d.reverse()
11717         self.assertTrue(d.isEqual(DataArrayInt([5,15,4,14,3,13,2,12,1,11,0,10],6,2)))
11718         d=DataArrayInt(7,2)
11719         d[:,0]=range(7)
11720         d[:,1]=range(10,17)
11721         d.reverse()
11722         self.assertTrue(d.isEqual(DataArrayInt([6,16,5,15,4,14,3,13,2,12,1,11,0,10],7,2)))
11723         pass
11724
11725     def testSwigDAPow1(self):
11726         d=DataArrayInt(10)
11727         d.iota(0)
11728         d1=d.deepCpy()
11729         d.setIJ(2,0,-2)
11730         self.assertTrue((d**2).isEqual(DataArrayInt([0,1,4,9,16,25,36,49,64,81])))
11731         self.assertTrue((d**3).isEqual(DataArrayInt([0,1,-8,27,64,125,216,343,512,729])))
11732         for elt in [d]:
11733             elt**=2
11734             pass
11735         self.assertTrue(d.isEqual(DataArrayInt([0,1,4,9,16,25,36,49,64,81])))
11736         self.assertTrue((d1[:4]**d1[:4]).isEqual(DataArrayInt([1,1,4,27])))
11737         self.assertTrue((3**d1[:4]).isEqual(DataArrayInt([1,3,9,27])))
11738         d2=d1[:4]
11739         d2**=d2
11740         self.assertTrue(d2.isEqual(DataArrayInt([1,1,4,27])))
11741         self.assertRaises(InterpKernelException,d2.__pow__,-1)#non supporting negative pow in DataArrayInt.__pow__
11742         self.assertRaises(InterpKernelException,d2.__ipow__,-1)#non supporting negative pow in DataArrayInt.__pow__
11743         #
11744         d=DataArrayDouble(10)
11745         d.iota(0)
11746         d1=d.deepCpy()
11747         d.setIJ(2,0,-2.)
11748         self.assertTrue((d**2).isEqual(DataArrayDouble([0,1,4,9,16,25,36,49,64,81]),1e-12))
11749         self.assertTrue((d**3).isEqual(DataArrayDouble([0,1,-8,27,64,125,216,343,512,729]),1e-12))
11750         self.assertRaises(InterpKernelException,d.__pow__,3.1)#3.1 is double not integer -> not supporting negative values in d
11751         for elt in [d]:
11752             elt**=2
11753             pass
11754         self.assertTrue(d.isEqual(DataArrayDouble([0,1,4,9,16,25,36,49,64,81]),1e-12))
11755         self.assertTrue((d1[:4]**d1[:4]).isEqual(DataArrayDouble([1,1,4,27]),1e-12))
11756         self.assertTrue((3**d1[:4]).isEqual(DataArrayDouble([1,3,9,27]),1e-12))
11757         d2=d1[:4]
11758         d2**=d2
11759         self.assertTrue(d2.isEqual(DataArrayDouble([1,1,4,27]),1e-12))
11760         d2**=-0.5
11761         self.assertTrue(d2.isEqual(DataArrayDouble([1,1,1./2,1./sqrt(27.)]),1e-14))
11762         d3=-1./d1[1:5]
11763         self.assertTrue((3**d3).isEqual(DataArrayDouble([0.3333333333333333,0.5773502691896257,0.6933612743506348,0.7598356856515925]),1e-14))
11764         d4=d3.deepCpy() ; d4.abs()
11765         self.assertTrue((d4**d3).isEqual(DataArrayDouble([1.,sqrt(2.),1.4422495703074083,sqrt(2.)]),1e-14))
11766         d4**=d3
11767         self.assertTrue(d4.isEqual(DataArrayDouble([1.,sqrt(2.),1.4422495703074083,sqrt(2.)]),1e-14))
11768         pass
11769
11770     def testSwig2Baryenter3DForCellsWithVolumeZero1(self):
11771         coo=DataArrayDouble([0.,0.,0.,1.,0.,0.,0.,1.,0.],3,3)
11772         m2=MEDCouplingUMesh("mesh",2)
11773         m2.allocateCells(0)
11774         m2.insertNextCell(NORM_POLYGON,[0,1,2])
11775         m2.setCoords(coo)
11776         m2.checkCoherency1()
11777         #
11778         coo2=DataArrayDouble([0.,0.,0.,0.,0.,0.,0.,0.,2.],3,3)
11779         m1=MEDCouplingUMesh("mesh",1)
11780         m1.allocateCells(0)
11781         m1.insertNextCell(NORM_SEG2,[0,1])
11782         m1.insertNextCell(NORM_SEG2,[1,2])
11783         m1.setCoords(coo2)
11784         m1.checkCoherency1()
11785         #
11786         m3=m2.buildExtrudedMesh(m1,0)
11787         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
11788         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))
11789         m4,a,b,c,d=m3.buildDescendingConnectivity()
11790         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))
11791         pass
11792
11793     def testSwigRepr1(self):
11794         d=DataArrayDouble()
11795         self.assertTrue(len(d.__repr__())<100)
11796         d.alloc(1000,0) ; self.assertTrue(len(d.__repr__())<100)
11797         for i in xrange(100):
11798             d.alloc(i,1) ; d.iota(1.1234567890123456) ; d*=1e123
11799             self.assertTrue(len(d.__repr__())<500)
11800             pass
11801         for i in xrange(50):
11802             d.alloc(i,2) ; d.rearrange(1) ; d.iota(1.1234567890123456) ; d.rearrange(2) ; d*=1e123
11803             self.assertTrue(len(d.__repr__())<500)
11804             pass
11805         d.alloc(4000,1) ; d.iota() ; self.assertTrue(len(d.__repr__())<500)
11806         for i in xrange(2,4):
11807             d.alloc(362880,1) ; d.iota() ; d.rearrange(i) ; self.assertTrue(len(d.__repr__())<500)
11808             pass
11809         d.alloc(0,9)
11810         self.assertTrue(len(d.__repr__())<100)
11811         #
11812         d=DataArrayInt()
11813         self.assertTrue(len(d.__repr__())<100)
11814         d.alloc(1000,0) ; self.assertTrue(len(d.__repr__())<100)
11815         for i in xrange(100):
11816             d.alloc(i,1) ; d.iota(123456789)
11817             self.assertTrue(len(d.__repr__())<500)
11818             pass
11819         for i in xrange(50):
11820             d.alloc(i,2) ; d.rearrange(1) ; d.iota(123456789) ; d.rearrange(2)
11821             self.assertTrue(len(d.__repr__())<500)
11822             pass
11823         d.alloc(4000,1) ; d.iota() ; self.assertTrue(len(d.__repr__())<500)
11824         for i in xrange(2,10):
11825             d.alloc(362880,1) ; d.iota() ; d.rearrange(i) ; self.assertTrue(len(d.__repr__())<500)
11826             pass
11827         d.alloc(0,9)
11828         self.assertTrue(len(d.__repr__())<100)
11829         #
11830         d=DataArrayAsciiChar()
11831         d.alloc(1000,0) ; self.assertTrue(len(d.__repr__())<100)
11832         d.alloc(2,16) ; d[:]='1234567890ABCDEF'
11833         self.assertTrue(len(d.__repr__())<500)
11834         d.alloc(2000,16) ; d[:]='1234567890ABCDEF'
11835         self.assertTrue(len(d.__repr__())<500)
11836         d.alloc(0,16) ; d[:]='1234567890ABCDEF'
11837         self.assertTrue(len(d.__repr__())<100)
11838         #
11839         d=DataArrayByte()
11840         self.assertTrue(len(d.__repr__())<100)
11841         d.alloc(1000,0) ; self.assertTrue(len(d.__repr__())<100)
11842         d.alloc(0,16) ; self.assertTrue(len(d.__repr__())<100)
11843         d.alloc(5,1) ; d.fillWithValue(127)
11844         self.assertTrue(len(d.__repr__())<200)
11845         d.alloc(1000,1) ; d.fillWithValue(127)
11846         self.assertTrue(len(d.__repr__())<500)
11847         d.alloc(1000,3) ; d.fillWithValue(127)
11848         self.assertTrue(len(d.__repr__())<500)
11849         pass
11850
11851     def testSwig2MeshComputeIsoBarycenterOfNodesPerCell1(self):
11852         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)
11853         m=MEDCouplingUMesh.New("toto",3)
11854         m.allocateCells(0)
11855         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])
11856         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])
11857         m.setCoords(coo)
11858         m.checkCoherency1()
11859         #
11860         dReference=DataArrayDouble([(34.900130952189848,0.,200),(17.450065476094931,30.2244,200.)])
11861         self.assertTrue(m.computeIsoBarycenterOfNodesPerCell().isEqual(dReference,1e-12))
11862         m.getNodalConnectivity().setIJ(87,0,24)
11863         self.assertRaises(InterpKernelException,m.computeIsoBarycenterOfNodesPerCell)
11864         m.getNodalConnectivity().setIJ(87,0,-2)
11865         self.assertRaises(InterpKernelException,m.computeIsoBarycenterOfNodesPerCell)
11866         m.getNodalConnectivity().setIJ(87,0,21)# put again 21 as at the beginning
11867         #
11868         self.assertTrue(m.unPolyze())
11869         self.assertEqual([NORM_HEXGP12],m.getAllTypes())
11870         self.assertTrue(m.computeIsoBarycenterOfNodesPerCell().isEqual(dReference,1e-12))
11871         m.getNodalConnectivity().setIJ(25,0,24)
11872         self.assertRaises(InterpKernelException,m.computeIsoBarycenterOfNodesPerCell)
11873         m.getNodalConnectivity().setIJ(25,0,-1)
11874         self.assertRaises(InterpKernelException,m.computeIsoBarycenterOfNodesPerCell)
11875         pass
11876
11877     def testSwig2NonRegressionBugDescHexa20(self):
11878         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)
11879         m=MEDCouplingUMesh('mesh',3)
11880         m.allocateCells(0)
11881         m.insertNextCell(NORM_HEXA20,[0,3,5,1,12,18,16,14,7,4,6,2,19,17,15,13,8,11,10,9])
11882         m.setCoords(coo)
11883         m.checkCoherency1()
11884         #
11885         a,b,c,d,e=m.buildDescendingConnectivity()
11886         m2=MEDCouplingUMesh('mesh',2)
11887         m2.allocateCells(0)
11888         m2.setCoords(coo)
11889         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]]
11890         for i in xrange(6):
11891             m2.insertNextCell(NORM_QUAD8,conn2[i])
11892             pass
11893         self.assertTrue(m2.isEqual(a,1e-12))
11894         self.assertTrue(b.isEqual(DataArrayInt([0,1,2,3,4,5])))
11895         self.assertTrue(c.isEqual(DataArrayInt([0,6])))
11896         self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,0,0])))
11897         self.assertTrue(e.isEqual(DataArrayInt([0,1,2,3,4,5,6])))
11898         #
11899         m.convertQuadraticCellsToLinear() ; m.zipCoords()
11900         m.convertLinearCellsToQuadratic(1)
11901         #
11902         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)
11903         m3=MEDCouplingUMesh("mesh",3)
11904         m3.allocateCells(1)
11905         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])
11906         m3.setCoords(coo2)
11907         self.assertTrue(m3.isEqual(m,1e-12))
11908         #
11909         a,b,c,d,e=m.buildDescendingConnectivity()
11910         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]]
11911         m4=MEDCouplingUMesh("mesh",2)
11912         m4.allocateCells(0)
11913         for i in xrange(6):
11914             m4.insertNextCell(NORM_QUAD9,conn4[i])
11915             pass
11916         m4.setCoords(coo2)
11917         self.assertTrue(m4.isEqual(a,1e-12))
11918         self.assertTrue(b.isEqual(DataArrayInt([0,1,2,3,4,5])))
11919         self.assertTrue(c.isEqual(DataArrayInt([0,6])))
11920         self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,0,0])))
11921         self.assertTrue(e.isEqual(DataArrayInt([0,1,2,3,4,5,6])))
11922         pass
11923
11924     def testSwigAdvGauss(self):
11925         f=MEDCouplingFieldTemplate(ON_GAUSS_PT)
11926         f.setDiscretization(None)
11927         f.__repr__() ; f.__str__()
11928         #
11929         f=MEDCouplingFieldTemplate(ON_GAUSS_PT)
11930         d=f.getDiscretization()
11931         i=DataArrayInt() ; i.alloc(10,1) ; i.iota(1)
11932         d.setArrayOfDiscIds(i)
11933         f.__repr__() ; f.__str__()
11934         i2=d.getArrayOfDiscIds()
11935         self.assertEqual(i.__repr__(),i2.__repr__())
11936         #
11937         f=MEDCouplingFieldDouble(ON_GAUSS_PT)
11938         f.setDiscretization(None)
11939         f.__repr__() ; f.__str__()
11940         #
11941         f=MEDCouplingFieldDouble(ON_GAUSS_PT)
11942         d=f.getDiscretization()
11943         i=DataArrayInt() ; i.alloc(10,1) ; i.iota(1)
11944         d.setArrayOfDiscIds(i)
11945         f.__repr__() ; f.__str__()
11946         #
11947         gl=MEDCouplingGaussLocalization(NORM_SEG2,[0,1],[0.5],[1.])
11948         gl.setWeights([3.])
11949         gl.__repr__() ; gl.__str__()
11950         gl=MEDCouplingGaussLocalization(NORM_ERROR)
11951         gl.setWeights([3.])
11952         gl.__repr__() ; gl.__str__()
11953         pass
11954
11955     def testSwig2NonRegressionBugSubstractInPlaceDM(self):
11956         m0=MEDCouplingCMesh()
11957         arr=DataArrayDouble(5,1) ; arr.iota(0.)
11958         m0.setCoords(arr,arr)
11959         m0=m0.buildUnstructured()
11960         m00=m0[::2] ; m00.simplexize(0) ; m01=m0[1::2]
11961         m0=MEDCouplingUMesh.MergeUMeshes([m00,m01])
11962         m0.getCoords()[:]*=1/4.
11963         m0.setName("mesh")
11964         #
11965         NodeField=MEDCouplingFieldDouble(ON_NODES,ONE_TIME) ; NodeField.setTime(5.6,5,6) ; NodeField.setMesh(m0)
11966         NodeField.setName("NodeField")
11967         NodeField.fillFromAnalytic(1,"exp(-((x-1)*(x-1)+(y-1)*(y-1)))") ; NodeField.getArray().setInfoOnComponent(0,"powernode [W]")
11968         proc0=m0.getCellsInBoundingBox([(0.,0.4),(0.,0.4)],1e-10)
11969         proc1=proc0.buildComplement(m0.getNumberOfCells())
11970         #
11971         NodeField0=NodeField[proc0] ; NodeField0.getMesh().setName(m0.getName())
11972         NodeField1=NodeField[proc1] ; NodeField1.getMesh().setName(m0.getName())
11973         #
11974         NodeField_read=MEDCouplingFieldDouble.MergeFields([NodeField0,NodeField1])
11975         NodeField_read.mergeNodes(1e-10)
11976         NodeFieldCpy=NodeField.deepCpy()
11977         NodeFieldCpy.mergeNodes(1e-10)
11978         NodeField.checkCoherency()
11979         self.assertTrue(not NodeField.getArray().isUniform(0.,1e-12))
11980         NodeField.substractInPlaceDM(NodeField_read,10,1e-12)
11981         self.assertTrue(NodeField.getArray().isUniform(0.,1e-12))
11982         pass
11983
11984     def testSwigFieldOperationOpen1(self):
11985         ## MEDCouplingFieldDouble.__add__
11986         m=MEDCouplingDataForTest.build2DTargetMesh_1()
11987         f=MEDCouplingFieldDouble(ON_CELLS)
11988         f.setMesh(m)
11989         arr=DataArrayDouble(5,2)
11990         arr[:,0]=range(5) ; arr[:,1]=2*arr[:,0]
11991         f2=f.clone(True)
11992         self.assertRaises(InterpKernelException,f.__add__,2)
11993         self.assertRaises(InterpKernelException,f.__add__,range(5))
11994         self.assertRaises(InterpKernelException,f.__add__,arr)
11995         self.assertRaises(InterpKernelException,f.__add__,f2)
11996         f.setArray(DataArrayDouble())
11997         self.assertRaises(InterpKernelException,f.__add__,2)
11998         self.assertRaises(InterpKernelException,f.__add__,range(5))
11999         self.assertRaises(InterpKernelException,f.__add__,arr)
12000         self.assertRaises(InterpKernelException,f.__add__,f2)
12001         self.assertRaises(InterpKernelException,f.__getitem__,(slice(None),0))
12002         f.getArray().alloc(5,2)
12003         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
12004         ff=f+2
12005         ff.checkCoherency()
12006         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(2,9),(3,10),(4,11),(5,12),(6,13)]),1e-12))
12007         ff=f+arr
12008         ff.checkCoherency()
12009         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,7),(2,10),(4,13),(6,16),(8,19)]),1e-12))
12010         self.assertRaises(InterpKernelException,f.__add__,f2)
12011         f2.setArray(arr)
12012         ff=f+f2
12013         ff.checkCoherency()
12014         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,7),(2,10),(4,13),(6,16),(8,19)]),1e-12))
12015         ff=f+[5,8]
12016         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(5,15),(6,16),(7,17),(8,18),(9,19)]),1e-12))
12017         ### MEDCouplingFieldDouble.__sub__
12018         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12019         f=MEDCouplingFieldDouble(ON_CELLS)
12020         f.setMesh(m)
12021         arr=DataArrayDouble(5,2)
12022         arr[:,0]=range(5) ; arr[:,1]=2*arr[:,0]
12023         f2=f.clone(True)
12024         self.assertRaises(InterpKernelException,f.__sub__,2)
12025         self.assertRaises(InterpKernelException,f.__sub__,range(5))
12026         self.assertRaises(InterpKernelException,f.__sub__,arr)
12027         self.assertRaises(InterpKernelException,f.__sub__,f2)
12028         f.setArray(DataArrayDouble())
12029         self.assertRaises(InterpKernelException,f.__sub__,2)
12030         self.assertRaises(InterpKernelException,f.__sub__,range(5))
12031         self.assertRaises(InterpKernelException,f.__sub__,arr)
12032         self.assertRaises(InterpKernelException,f.__sub__,f2)
12033         self.assertRaises(InterpKernelException,f.__getitem__,(slice(None),0))
12034         f.getArray().alloc(5,2)
12035         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
12036         ff=f-2
12037         ff.checkCoherency()
12038         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(-2,5),(-1,6),(0,7),(1,8),(2,9)]),1e-12))
12039         ff=f-arr
12040         ff.checkCoherency()
12041         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,7),(0,6),(0,5),(0,4),(0,3)]),1e-12))
12042         self.assertRaises(InterpKernelException,f.__sub__,f2)
12043         f2.setArray(arr)
12044         ff=f-f2
12045         ff.checkCoherency()
12046         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,7),(0,6),(0,5),(0,4),(0,3)]),1e-12))
12047         ff=f-[5,8]
12048         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(-5,-1),(-4,0),(-3,1),(-2,2),(-1,3)]),1e-12))
12049         ### MEDCouplingFieldDouble.__mul__
12050         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12051         f=MEDCouplingFieldDouble(ON_CELLS)
12052         f.setMesh(m)
12053         arr=DataArrayDouble(5,2)
12054         arr[:,0]=range(5) ; arr[:,1]=2*arr[:,0]
12055         f2=f.clone(True)
12056         self.assertRaises(InterpKernelException,f.__mul__,2)
12057         self.assertRaises(InterpKernelException,f.__mul__,range(5))
12058         self.assertRaises(InterpKernelException,f.__mul__,arr)
12059         self.assertRaises(InterpKernelException,f.__mul__,f2)
12060         f.setArray(DataArrayDouble())
12061         self.assertRaises(InterpKernelException,f.__mul__,2)
12062         self.assertRaises(InterpKernelException,f.__mul__,range(5))
12063         self.assertRaises(InterpKernelException,f.__mul__,arr)
12064         self.assertRaises(InterpKernelException,f.__mul__,f2)
12065         self.assertRaises(InterpKernelException,f.__getitem__,(slice(None),0))
12066         f.getArray().alloc(5,2)
12067         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
12068         ff=f*2
12069         ff.checkCoherency()
12070         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,14),(2,16),(4,18),(6,20),(8,22)]),1e-12))
12071         ff=f*arr
12072         ff.checkCoherency()
12073         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,0),(1,16),(4,36),(9,60),(16,88)]),1e-12))
12074         self.assertRaises(InterpKernelException,f.__mul__,f2)
12075         f2.setArray(arr)
12076         ff=f*f2
12077         ff.checkCoherency()
12078         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,0),(1,16),(4,36),(9,60),(16,88)]),1e-12))
12079         ff=f*[5,8]
12080         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,56),(5,64),(10,72),(15,80),(20,88)]),1e-12))
12081         ### MEDCouplingFieldDouble.__div__
12082         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12083         f=MEDCouplingFieldDouble(ON_CELLS)
12084         f.setMesh(m)
12085         arr=DataArrayDouble(5,2)
12086         arr[:,0]=range(1,6) ; arr[:,1]=2*arr[:,0]
12087         f2=f.clone(True)
12088         self.assertRaises(InterpKernelException,f.__div__,2)
12089         self.assertRaises(InterpKernelException,f.__div__,range(5))
12090         self.assertRaises(InterpKernelException,f.__div__,arr)
12091         self.assertRaises(InterpKernelException,f.__div__,f2)
12092         f.setArray(DataArrayDouble())
12093         self.assertRaises(InterpKernelException,f.__div__,2)
12094         self.assertRaises(InterpKernelException,f.__div__,range(5))
12095         self.assertRaises(InterpKernelException,f.__div__,arr)
12096         self.assertRaises(InterpKernelException,f.__div__,f2)
12097         self.assertRaises(InterpKernelException,f.__getitem__,(slice(None),0))
12098         f.getArray().alloc(5,2)
12099         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
12100         self.assertRaises(InterpKernelException,f.__div__,0)
12101         ff=f/2
12102         ff.checkCoherency()
12103         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,3.5),(0.5,4),(1,4.5),(1.5,5),(2,5.5)]),1e-12))
12104         ff=f/arr
12105         ff.checkCoherency()
12106         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,3.5),(0.5,2),(0.6666666666666666,1.5),(0.75,1.25),(0.8,1.1)]),1e-12))
12107         self.assertRaises(InterpKernelException,f.__div__,f2)
12108         f2.setArray(arr)
12109         ff=f/f2
12110         ff.checkCoherency()
12111         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,3.5),(0.5,2),(0.6666666666666666,1.5),(0.75,1.25),(0.8,1.1)]),1e-12))
12112         ff=f/[5,8]
12113         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,0.875),(0.2,1),(0.4,1.125),(0.6,1.25),(0.8,1.375)]),1e-12))
12114         ### MEDCouplingFieldDouble.__pow__
12115         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12116         f=MEDCouplingFieldDouble(ON_CELLS)
12117         f.setMesh(m)
12118         arr=DataArrayDouble(5)
12119         arr[:]=[1,1,3,2,0]
12120         f2=f.clone(True)
12121         self.assertRaises(InterpKernelException,f.__div__,2)
12122         self.assertRaises(InterpKernelException,f.__div__,range(5))
12123         self.assertRaises(InterpKernelException,f.__div__,arr)
12124         self.assertRaises(InterpKernelException,f.__div__,f2)
12125         f.setArray(DataArrayDouble())
12126         self.assertRaises(InterpKernelException,f.__div__,2)
12127         self.assertRaises(InterpKernelException,f.__div__,range(5))
12128         self.assertRaises(InterpKernelException,f.__div__,arr)
12129         self.assertRaises(InterpKernelException,f.__div__,f2)
12130         self.assertRaises(InterpKernelException,f.__getitem__,(slice(None),0))
12131         f.getArray().alloc(5,1)
12132         f.getArray()[:]=range(2,7)
12133         ff=f**2
12134         ff.checkCoherency()
12135         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([4,9,16,25,36]),1e-12))
12136         ff=f**arr
12137         ff.checkCoherency()
12138         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([2,3,64,25,1]),1e-12))
12139         f2.setArray(arr)
12140         ff=f**f2
12141         ff.checkCoherency()
12142         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([2,3,64,25,1]),1e-12))
12143         ## MEDCouplingFieldDouble.__iadd__
12144         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12145         f=MEDCouplingFieldDouble(ON_CELLS)
12146         f.setMesh(m)
12147         arr=DataArrayDouble(5,2)
12148         arr[:,0]=range(5) ; arr[:,1]=2*arr[:,0]
12149         f2=f.clone(True)
12150         self.assertRaises(InterpKernelException,f.__iadd__,2)
12151         self.assertRaises(InterpKernelException,f.__iadd__,range(5))
12152         self.assertRaises(InterpKernelException,f.__iadd__,arr)
12153         self.assertRaises(InterpKernelException,f.__iadd__,f2)
12154         f.setArray(DataArrayDouble())
12155         self.assertRaises(InterpKernelException,f.__iadd__,2)
12156         self.assertRaises(InterpKernelException,f.__iadd__,range(5))
12157         self.assertRaises(InterpKernelException,f.__iadd__,arr)
12158         self.assertRaises(InterpKernelException,f.__iadd__,f2)
12159         f.getArray().alloc(5,2)
12160         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
12161         f.checkCoherency()
12162         f+=2
12163         f.checkCoherency()
12164         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(2,9),(3,10),(4,11),(5,12),(6,13)]),1e-12))
12165         f+=arr
12166         f.checkCoherency()
12167         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(2,9),(4,12),(6,15),(8,18),(10,21)]),1e-12))
12168         f2.setArray(arr)
12169         f+=f2
12170         f.checkCoherency()
12171         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(2,9),(5,14),(8,19),(11,24),(14,29)]),1e-12))
12172         f+=[0.1,0.2]
12173         f.checkCoherency()
12174         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(2.1,9.2),(5.1,14.2),(8.1,19.2),(11.1,24.2),(14.1,29.2)]),1e-12))
12175         ## MEDCouplingFieldDouble.__isub__
12176         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12177         f=MEDCouplingFieldDouble(ON_CELLS)
12178         f.setMesh(m)
12179         arr=DataArrayDouble(5,2)
12180         arr[:,0]=range(5) ; arr[:,1]=2*arr[:,0]
12181         f2=f.clone(True)
12182         self.assertRaises(InterpKernelException,f.__isub__,2)
12183         self.assertRaises(InterpKernelException,f.__isub__,range(5))
12184         self.assertRaises(InterpKernelException,f.__isub__,arr)
12185         self.assertRaises(InterpKernelException,f.__isub__,f2)
12186         f.setArray(DataArrayDouble())
12187         self.assertRaises(InterpKernelException,f.__isub__,2)
12188         self.assertRaises(InterpKernelException,f.__isub__,range(5))
12189         self.assertRaises(InterpKernelException,f.__isub__,arr)
12190         self.assertRaises(InterpKernelException,f.__isub__,f2)
12191         f.getArray().alloc(5,2)
12192         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
12193         f.checkCoherency()
12194         f-=2
12195         f.checkCoherency()
12196         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(-2,5),(-1,6),(0,7),(1,8),(2,9)]),1e-12))
12197         f-=arr
12198         f.checkCoherency()
12199         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(-2,5),(-2,4),(-2,3),(-2,2),(-2,1)]),1e-12))
12200         f2.setArray(arr)
12201         f-=f2
12202         f.checkCoherency()
12203         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(-2,5),(-3,2),(-4,-1),(-5,-4),(-6,-7)]),1e-12))
12204         f-=[0.1,0.2]
12205         f.checkCoherency()
12206         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(-2.1,4.8),(-3.1,1.8),(-4.1,-1.2),(-5.1,-4.2),(-6.1,-7.2)]),1e-12))
12207         ## MEDCouplingFieldDouble.__imul__
12208         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12209         f=MEDCouplingFieldDouble(ON_CELLS)
12210         f.setMesh(m)
12211         arr=DataArrayDouble(5,2)
12212         arr[:,0]=range(5) ; arr[:,1]=2*arr[:,0]
12213         f2=f.clone(True)
12214         self.assertRaises(InterpKernelException,f.__imul__,2)
12215         self.assertRaises(InterpKernelException,f.__imul__,range(5))
12216         self.assertRaises(InterpKernelException,f.__imul__,arr)
12217         self.assertRaises(InterpKernelException,f.__imul__,f2)
12218         f.setArray(DataArrayDouble())
12219         self.assertRaises(InterpKernelException,f.__imul__,2)
12220         self.assertRaises(InterpKernelException,f.__imul__,range(5))
12221         self.assertRaises(InterpKernelException,f.__imul__,arr)
12222         self.assertRaises(InterpKernelException,f.__imul__,f2)
12223         f.getArray().alloc(5,2)
12224         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
12225         f.checkCoherency()
12226         f*=2
12227         f.checkCoherency()
12228         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(0,14),(2,16),(4,18),(6,20),(8,22)]),1e-12))
12229         f*=arr
12230         f.checkCoherency()
12231         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(0,0),(2,32),(8,72),(18,120),(32,176)]),1e-12))
12232         f2.setArray(arr)
12233         f*=f2
12234         f.checkCoherency()
12235         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(0,0),(2,64),(16,288),(54,720),(128,1408)]),1e-12))
12236         f*=[0.1,0.2]
12237         f.checkCoherency()
12238         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(0,0),(0.2,12.8),(1.6,57.6),(5.4,144),(12.8,281.6)]),1e-12))
12239         ## MEDCouplingFieldDouble.__idiv__
12240         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12241         f=MEDCouplingFieldDouble(ON_CELLS)
12242         f.setMesh(m)
12243         arr=DataArrayDouble(5,2)
12244         arr[:,0]=range(1,6) ; arr[:,1]=2*arr[:,0]
12245         f2=f.clone(True)
12246         self.assertRaises(InterpKernelException,f.__idiv__,2)
12247         self.assertRaises(InterpKernelException,f.__idiv__,range(5))
12248         self.assertRaises(InterpKernelException,f.__idiv__,arr)
12249         self.assertRaises(InterpKernelException,f.__idiv__,f2)
12250         f.setArray(DataArrayDouble())
12251         self.assertRaises(InterpKernelException,f.__idiv__,2)
12252         self.assertRaises(InterpKernelException,f.__idiv__,range(5))
12253         self.assertRaises(InterpKernelException,f.__idiv__,arr)
12254         self.assertRaises(InterpKernelException,f.__idiv__,f2)
12255         f.getArray().alloc(5,2)
12256         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
12257         f.checkCoherency()
12258         f/=2
12259         f.checkCoherency()
12260         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(0,3.5),(0.5,4),(1,4.5),(1.5,5),(2,5.5)]),1e-12))
12261         f/=arr
12262         f.checkCoherency()
12263         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(0,1.75),(0.25,1),(0.3333333333333333,0.75),(0.375,0.625),(0.4,0.55)]),1e-12))
12264         f2.setArray(arr)
12265         f/=f2
12266         f.checkCoherency()
12267         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(0,0.875),(0.125,0.25),(0.1111111111111111,0.125),(0.09375,0.078125),(0.08,0.055)]),1e-12))
12268         f/=[0.1,0.2]
12269         f.checkCoherency()
12270         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(0,4.375),(1.25,1.25),(1.1111111111111111,0.625),(0.9375,0.390625),(0.8,0.275)]),1e-12))
12271         ## MEDCouplingFieldDouble.__ipow__
12272         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12273         f=MEDCouplingFieldDouble(ON_CELLS)
12274         f.setMesh(m)
12275         arr=DataArrayDouble(5,2)
12276         arr[:,0]=range(1,6) ; arr[:,1]=2*arr[:,0]
12277         f2=f.clone(True)
12278         self.assertRaises(InterpKernelException,f.__ipow__,2)
12279         self.assertRaises(InterpKernelException,f.__ipow__,range(5))
12280         self.assertRaises(InterpKernelException,f.__ipow__,arr)
12281         self.assertRaises(InterpKernelException,f.__ipow__,f2)
12282         f.setArray(DataArrayDouble())
12283         self.assertRaises(InterpKernelException,f.__ipow__,2)
12284         self.assertRaises(InterpKernelException,f.__ipow__,range(5))
12285         self.assertRaises(InterpKernelException,f.__ipow__,arr)
12286         self.assertRaises(InterpKernelException,f.__ipow__,f2)
12287         f.getArray().alloc(5,2)
12288         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
12289         f.checkCoherency()
12290         f**=2
12291         f.checkCoherency()
12292         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(0,49),(1,64),(4,81),(9,100),(16,121)]),1e-12))
12293          ## MEDCouplingFieldDouble.__radd__
12294         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12295         f=MEDCouplingFieldDouble(ON_CELLS)
12296         f.setMesh(m)
12297         arr=DataArrayDouble(5,2)
12298         arr[:,0]=range(5) ; arr[:,1]=2*arr[:,0]
12299         f2=f.clone(True)
12300         self.assertRaises(InterpKernelException,f.__radd__,2)
12301         self.assertRaises(InterpKernelException,f.__radd__,range(5))
12302         self.assertRaises(InterpKernelException,f.__radd__,arr)
12303         self.assertRaises(InterpKernelException,f.__radd__,f2)
12304         f.setArray(DataArrayDouble())
12305         self.assertRaises(InterpKernelException,f.__radd__,2)
12306         self.assertRaises(InterpKernelException,f.__radd__,range(5))
12307         self.assertRaises(InterpKernelException,f.__radd__,arr)
12308         self.assertRaises(InterpKernelException,f.__radd__,f2)
12309         self.assertRaises(InterpKernelException,f.__getitem__,(slice(None),0))
12310         f.getArray().alloc(5,2)
12311         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
12312         ff=2+f
12313         ff.checkCoherency()
12314         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(2,9),(3,10),(4,11),(5,12),(6,13)]),1e-12))
12315         ff=arr+f
12316         ff.checkCoherency()
12317         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,7),(2,10),(4,13),(6,16),(8,19)]),1e-12))
12318         self.assertRaises(InterpKernelException,f.__radd__,f2)
12319         ff=[5,8]+f
12320         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(5,15),(6,16),(7,17),(8,18),(9,19)]),1e-12))
12321         ### MEDCouplingFieldDouble.__rsub__
12322         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12323         f=MEDCouplingFieldDouble(ON_CELLS)
12324         f.setMesh(m)
12325         arr=DataArrayDouble(5,2)
12326         arr[:,0]=range(5) ; arr[:,1]=2*arr[:,0]
12327         f2=f.clone(True)
12328         self.assertRaises(InterpKernelException,f.__rsub__,2)
12329         self.assertRaises(InterpKernelException,f.__rsub__,range(5))
12330         self.assertRaises(InterpKernelException,f.__rsub__,arr)
12331         self.assertRaises(InterpKernelException,f.__rsub__,f2)
12332         f.setArray(DataArrayDouble())
12333         self.assertRaises(InterpKernelException,f.__rsub__,2)
12334         self.assertRaises(InterpKernelException,f.__rsub__,range(5))
12335         self.assertRaises(InterpKernelException,f.__rsub__,arr)
12336         self.assertRaises(InterpKernelException,f.__rsub__,f2)
12337         self.assertRaises(InterpKernelException,f.__getitem__,(slice(None),0))
12338         f.getArray().alloc(5,2)
12339         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
12340         ff=2-f
12341         ff.checkCoherency()
12342         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(2,-5),(1,-6),(0,-7),(-1,-8),(-2,-9)]),1e-12))
12343         ff=arr-f
12344         ff.checkCoherency()
12345         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,-7),(0,-6),(0,-5),(0,-4),(0,-3)]),1e-12))
12346         self.assertRaises(InterpKernelException,f.__rsub__,f2)
12347         ### MEDCouplingFieldDouble.__rmul__
12348         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12349         f=MEDCouplingFieldDouble(ON_CELLS)
12350         f.setMesh(m)
12351         arr=DataArrayDouble(5,2)
12352         arr[:,0]=range(5) ; arr[:,1]=2*arr[:,0]
12353         f2=f.clone(True)
12354         self.assertRaises(InterpKernelException,f.__rmul__,2)
12355         self.assertRaises(InterpKernelException,f.__rmul__,range(5))
12356         self.assertRaises(InterpKernelException,f.__rmul__,arr)
12357         self.assertRaises(InterpKernelException,f.__rmul__,f2)
12358         f.setArray(DataArrayDouble())
12359         self.assertRaises(InterpKernelException,f.__rmul__,2)
12360         self.assertRaises(InterpKernelException,f.__rmul__,range(5))
12361         self.assertRaises(InterpKernelException,f.__rmul__,arr)
12362         self.assertRaises(InterpKernelException,f.__rmul__,f2)
12363         self.assertRaises(InterpKernelException,f.__getitem__,(slice(None),0))
12364         f.getArray().alloc(5,2)
12365         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
12366         ff=2*f
12367         ff.checkCoherency()
12368         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,14),(2,16),(4,18),(6,20),(8,22)]),1e-12))
12369         ff=arr*f
12370         ff.checkCoherency()
12371         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,0),(1,16),(4,36),(9,60),(16,88)]),1e-12))
12372         self.assertRaises(InterpKernelException,f.__rmul__,f2)
12373         ff=f*[5,8]
12374         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,56),(5,64),(10,72),(15,80),(20,88)]),1e-12))
12375         ### MEDCouplingFieldDouble.__rdiv__
12376         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12377         f=MEDCouplingFieldDouble(ON_CELLS)
12378         f.setMesh(m)
12379         arr=DataArrayDouble(5,2)
12380         arr[:,0]=range(1,6) ; arr[:,1]=2*arr[:,0]
12381         f2=f.clone(True)
12382         self.assertRaises(InterpKernelException,f.__rdiv__,2)
12383         self.assertRaises(InterpKernelException,f.__rdiv__,range(5))
12384         self.assertRaises(InterpKernelException,f.__rdiv__,arr)
12385         self.assertRaises(InterpKernelException,f.__rdiv__,f2)
12386         f.setArray(DataArrayDouble())
12387         self.assertRaises(InterpKernelException,f.__rdiv__,2)
12388         self.assertRaises(InterpKernelException,f.__rdiv__,range(5))
12389         self.assertRaises(InterpKernelException,f.__rdiv__,arr)
12390         self.assertRaises(InterpKernelException,f.__rdiv__,f2)
12391         self.assertRaises(InterpKernelException,f.__getitem__,(slice(None),0))
12392         f.getArray().alloc(5,2)
12393         f.getArray()[:,0]=range(1,6) ; f.getArray()[:,1]=f.getArray()[:,0]+7
12394         ff=2/f
12395         ff.checkCoherency()
12396         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(2,0.25),(1,0.22222222222222221),(0.66666666666666663,0.20000000000000001),(0.5,0.18181818181818182),(0.40000000000000002,0.16666666666666666)]),1e-12))
12397         ff=arr/f
12398         ff.checkCoherency()
12399         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(1,0.25),(1,0.44444444444444442),(1,0.59999999999999998),(1,0.72727272727272729),(1,0.83333333333333337)]),1e-12))
12400         self.assertRaises(InterpKernelException,f.__rdiv__,f2)
12401         pass
12402
12403     def testSwig2FieldDoubleBuildSubPartRange1(self):
12404         #ON_CELLS
12405         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12406         f=MEDCouplingFieldDouble(ON_CELLS)
12407         f.setMesh(m)
12408         arr=DataArrayDouble(5,2) ; arr[:,0]=range(7,12) ; arr[:,1]=100+arr[:,0]
12409         f.setArray(arr)
12410         f.checkCoherency()
12411         ff=f[1:-1:2]
12412         ff.checkCoherency()
12413         self.assertTrue((m.buildPartOfMySelf([1,3],True)).isEqual(ff.getMesh(),1e-12))
12414         self.assertTrue(9,ff.getMesh().getNumberOfNodes())
12415         self.assertTrue(2,ff.getMesh().getNumberOfCells())
12416         self.assertTrue(ff.getArray().isEqual(arr[[1,3]],1e-12))
12417         #
12418         a,b=f.buildSubMeshDataRange(2,5,1)
12419         self.assertTrue(m.buildPartOfMySelf([2,3,4],True).isEqual(a,1e-12))
12420         self.assertEqual(b,slice(2,5,1))
12421         ff=f[2:]
12422         ff.checkCoherency()
12423         self.assertTrue((m.buildPartOfMySelf([2,3,4],True)).isEqual(ff.getMesh(),1e-12))
12424         self.assertTrue(9,ff.getMesh().getNumberOfNodes())
12425         self.assertTrue(3,ff.getMesh().getNumberOfCells())
12426         self.assertTrue(ff.getArray().isEqual(arr[[2,3,4]],1e-12))
12427         #
12428         ff=f[-2:0:-1]
12429         ff.checkCoherency()
12430         self.assertTrue((m.buildPartOfMySelf([3,2,1],True)).isEqual(ff.getMesh(),1e-12))
12431         self.assertTrue(9,ff.getMesh().getNumberOfNodes())
12432         self.assertTrue(3,ff.getMesh().getNumberOfCells())
12433         self.assertTrue(ff.getArray().isEqual(arr[[3,2,1]],1e-12))
12434         self.assertTrue(f[-2:0:-1,1].getArray().isEqual(arr[[3,2,1],1],1e-12))
12435         #ON_NODES
12436         f=MEDCouplingFieldDouble(ON_NODES)
12437         f.setMesh(m)
12438         arr=DataArrayDouble(9,2) ; arr[:,0]=range(7,16) ; arr[:,1]=100+arr[:,0]
12439         f.setArray(arr)
12440         f.checkCoherency()
12441         ff=f[1:-1:2]
12442         ff.checkCoherency()
12443         self.assertTrue((m.buildPartOfMySelf([1,3],False)).isEqual(ff.getMesh(),1e-12))
12444         self.assertTrue(6,ff.getMesh().getNumberOfNodes())
12445         self.assertTrue(2,ff.getMesh().getNumberOfCells())
12446         self.assertTrue(ff.getArray().isEqual(arr[[1,2,3,4,6,7]],1e-12))
12447         #
12448         m2=m.buildPartRange(2,5,1)
12449         self.assertTrue(m.buildPartOfMySelf([2,3,4],True).isEqual(m2,1e-12))
12450         m2,b=m.buildPartRangeAndReduceNodes(2,5,1)
12451         self.assertTrue(m.buildPartOfMySelf([2,3,4],False).isEqual(m2,1e-12))
12452         self.assertTrue(b.isEqual(DataArrayInt([-1,-1,0,1,2,3,4,5,6])))
12453         a,b=f.buildSubMeshDataRange(2,5,1)
12454         self.assertTrue(m.buildPartOfMySelf([2,3,4],False).isEqual(a,1e-12))
12455         self.assertTrue(b.isEqual(DataArrayInt([2,3,4,5,6,7,8])))
12456         ff=f[2:]
12457         ff.checkCoherency()
12458         self.assertTrue((m.buildPartOfMySelf([2,3,4],False)).isEqual(ff.getMesh(),1e-12))
12459         self.assertTrue(7,ff.getMesh().getNumberOfNodes())
12460         self.assertTrue(3,ff.getMesh().getNumberOfCells())
12461         self.assertTrue(ff.getArray().isEqual(arr[[2,3,4,5,6,7,8]],1e-12))
12462         #
12463         ff=f[-2:0:-1]
12464         ff.checkCoherency()
12465         self.assertTrue((m.buildPartOfMySelf([3,2,1],False)).isEqual(ff.getMesh(),1e-12))
12466         self.assertTrue(7,ff.getMesh().getNumberOfNodes())
12467         self.assertTrue(3,ff.getMesh().getNumberOfCells())
12468         self.assertTrue(ff.getArray().isEqual(arr[[1,2,3,4,5,6,7]],1e-12))
12469         self.assertTrue(f[-2:0:-1,1].getArray().isEqual(arr[[1,2,3,4,5,6,7],1],1e-12))
12470         #ON_GAUSS_NE
12471         f=MEDCouplingFieldDouble(ON_GAUSS_NE)
12472         f.setMesh(m)
12473         arr=DataArrayDouble(18,2) ; arr[:,0]=range(7,25) ; arr[:,1]=100+arr[:,0]
12474         f.setArray(arr)
12475         f.checkCoherency()
12476         ff=f[1:-1:2]
12477         ff.checkCoherency()
12478         self.assertTrue((m.buildPartOfMySelf([1,3],True)).isEqual(ff.getMesh(),1e-12))
12479         self.assertTrue(9,ff.getMesh().getNumberOfNodes())
12480         self.assertTrue(2,ff.getMesh().getNumberOfCells())
12481         self.assertTrue(ff.getArray().isEqual(arr[[4,5,6,10,11,12,13]],1e-12))
12482         #
12483         a,b=f.buildSubMeshDataRange(2,5,1)
12484         self.assertTrue(m.buildPartOfMySelf([2,3,4],True).isEqual(a,1e-12))
12485         self.assertEqual(b,slice(7,18,1))
12486         ff=f[2:]
12487         ff.checkCoherency()
12488         self.assertTrue((m.buildPartOfMySelf([2,3,4],True)).isEqual(ff.getMesh(),1e-12))
12489         self.assertTrue(9,ff.getMesh().getNumberOfNodes())
12490         self.assertTrue(3,ff.getMesh().getNumberOfCells())
12491         self.assertTrue(ff.getArray().isEqual(arr[[7,8,9,10,11,12,13,14,15,16,17]],1e-12))
12492         #
12493         ff=f[-2:0:-1]
12494         ff.checkCoherency()
12495         self.assertTrue((m.buildPartOfMySelf([3,2,1],True)).isEqual(ff.getMesh(),1e-12))
12496         self.assertTrue(9,ff.getMesh().getNumberOfNodes())
12497         self.assertTrue(3,ff.getMesh().getNumberOfCells())
12498         self.assertTrue(ff.getArray().isEqual(arr[[10,11,12,13,7,8,9,4,5,6]],1e-12))
12499         self.assertTrue(f[-2:0:-1,1].getArray().isEqual(arr[[10,11,12,13,7,8,9,4,5,6],1],1e-12))
12500         #ON_GAUSS_PT
12501         f=MEDCouplingFieldDouble(ON_GAUSS_PT)
12502         f.setMesh(m)
12503         f.setGaussLocalizationOnCells([0,4],[0,0,1,0,1,1,1,0],[1.1,1.1,2.2,2.2],[0.2,0.8]);
12504         f.setGaussLocalizationOnCells([3],[0,0,1,0,1,1,1,0],[1.1,1.1,2.2,2.2,3.,3.],[0.2,0.4,0.4]);
12505         f.setGaussLocalizationOnCells([1],[0,0,1,0,1,0],[1.1,1.1,2.2,2.2,3.,3.,4.,4.],[0.1,0.1,0.4,0.4]);
12506         f.setGaussLocalizationOnCells([2],[0,0,1,0,1,0],[1.1,1.1,2.2,2.2,3.,3.,4.,4.,5.,5.],[0.1,0.1,0.4,0.3,0.1]);
12507         arr=DataArrayDouble(16,2) ; arr[:,0]=range(7,23) ; arr[:,1]=100+arr[:,0]
12508         f.setArray(arr)
12509         f.checkCoherency()
12510         ff=f[1:-1:2]
12511         ff.checkCoherency()
12512         self.assertTrue((m.buildPartOfMySelf([1,3],True)).isEqual(ff.getMesh(),1e-12))
12513         self.assertTrue(9,ff.getMesh().getNumberOfNodes())
12514         self.assertTrue(2,ff.getMesh().getNumberOfCells())
12515         self.assertTrue(ff.getArray().isEqual(arr[[2,3,4,5,11,12,13]],1e-12))
12516         #
12517         a,b=f.buildSubMeshDataRange(2,5,1)
12518         self.assertTrue(m.buildPartOfMySelf([2,3,4],True).isEqual(a,1e-12))
12519         self.assertEqual(b,slice(6,16,1))
12520         ff=f[2:]
12521         ff.checkCoherency()
12522         self.assertTrue((m.buildPartOfMySelf([2,3,4],True)).isEqual(ff.getMesh(),1e-12))
12523         self.assertTrue(9,ff.getMesh().getNumberOfNodes())
12524         self.assertTrue(3,ff.getMesh().getNumberOfCells())
12525         self.assertTrue(ff.getArray().isEqual(arr[[6,7,8,9,10,11,12,13,14,15]],1e-12))
12526         #
12527         ff=f[-2:0:-1]
12528         ff.checkCoherency()
12529         self.assertTrue((m.buildPartOfMySelf([3,2,1],True)).isEqual(ff.getMesh(),1e-12))
12530         self.assertTrue(9,ff.getMesh().getNumberOfNodes())
12531         self.assertTrue(3,ff.getMesh().getNumberOfCells())
12532         self.assertTrue(ff.getArray().isEqual(arr[[11,12,13,6,7,8,9,10,2,3,4,5]],1e-12))
12533         self.assertTrue(f[-2:0:-1,0].getArray().isEqual(arr[[11,12,13,6,7,8,9,10,2,3,4,5],0],1e-12))
12534         pass
12535
12536     def testSwig2FieldDoubleApplyFuncBug1(self):
12537         f=MEDCouplingFieldDouble(ON_CELLS)
12538         f.setMesh(MEDCouplingDataForTest.build2DTargetMesh_1())
12539         f.applyFunc(3,700.)
12540         f.checkCoherency()
12541         self.assertEqual(3,f.getArray().getNumberOfComponents())
12542         f.getArray().rearrange(1)
12543         self.assertTrue(f.getArray().isUniform(700.,1e-10))
12544         f.getArray().rearrange(3)
12545         f.checkCoherency()
12546         f.applyFunc(4,800.)
12547         f.checkCoherency()
12548         self.assertEqual(4,f.getArray().getNumberOfComponents())
12549         f.getArray().rearrange(1)
12550         self.assertTrue(f.getArray().isUniform(800.,1e-10))
12551         f.getArray().rearrange(4)
12552         f.checkCoherency()
12553         pass
12554
12555     def testSwig2ComputeTupleIdsNearTupleBug1(self):
12556         coords=[1.1,0.0, 1.1,0.0 ];
12557         coordsArr=DataArrayDouble(coords,2,2);
12558         mesh=MEDCouplingUMesh();
12559         mesh.setCoords(coordsArr);
12560         points=[1.1, 0.002]
12561         c,cI=mesh.getNodeIdsNearPoints(points,0.00185);
12562         self.assertTrue(c.isEqual(DataArrayInt([])))
12563         self.assertTrue(cI.isEqual(DataArrayInt([0,0])))
12564         c,cI=mesh.getNodeIdsNearPoints(points,0.00200000000000001);
12565         self.assertTrue(c.isEqual(DataArrayInt([0,1])))
12566         self.assertTrue(cI.isEqual(DataArrayInt([0,2])))
12567         pass
12568
12569     def testSwig2NonRegressionBugChangeUnderlyingWithZeroCells(self):
12570         coords1=[0.,1.,2.,3.]
12571         coords2=[2.,1.,0.,3.] #0 <==> #2
12572         # mesh 1
12573         mesh1=MEDCouplingUMesh.New();
12574         coordsArr=DataArrayDouble.New(coords1,4,1);
12575         mesh1.setCoords(coordsArr);
12576         mesh1.setMeshDimension(0);
12577         mesh1.allocateCells(0);
12578         mesh1.finishInsertingCells();
12579         # mesh 2
12580         mesh2=mesh1.deepCpy();
12581         coordsArr=DataArrayDouble.New(coords2,4,1);
12582         mesh2.setCoords(coordsArr);
12583         field = mesh1.fillFromAnalytic(ON_NODES,1,"x")
12584         field.checkCoherency()
12585         levOfCheck = 10
12586         field.changeUnderlyingMesh( mesh2, levOfCheck, 1e-13, 0 )
12587         self.assertTrue( field.getArray().getValues() == coords2 )
12588         pass
12589
12590     def testSwig2UMeshDistanceToMesh2(self):
12591         sz=5
12592         m=MEDCouplingCMesh()
12593         arr=DataArrayDouble(sz+1) ; arr.iota() ; arr/=sz
12594         m.setCoords(arr,arr,arr)
12595         m=m.buildUnstructured()
12596         m1=m.computeSkin()
12597         m1.zipCoords()
12598         c=m1.getCoords()[:]
12599         d=2*(c-[0.5,0.5,0.5])+[0.5,0.5,0.5]
12600         time_deb = datetime.now()
12601         #print "go.."
12602         a,b=m1.distanceToPoints(d)
12603         #print 'time spent in distanceToPoints %s ' %str(datetime.now() - time_deb)
12604         time_deb = datetime.now()
12605         a1=DataArrayDouble(len(d))
12606         b1=DataArrayInt(len(d))
12607         m1s=[m1[i] for i in xrange(m1.getNumberOfCells())]
12608         for j,pt in enumerate(d):
12609             eter=1e308
12610             fter=-1
12611             for i,miter in enumerate(m1s):
12612                 e,f=miter.distanceToPoint(pt)
12613                 self.assertEqual(0,f)
12614                 if e<eter:
12615                     eter=e ; fter=i
12616                     pass
12617                 pass
12618             a1[j]=eter
12619             b1[j]=fter
12620             pass
12621         #print 'time spent in naive distanceToPoints  %s ' %str(datetime.now() - time_deb)
12622         self.assertTrue(a.isEqual(a1,1e-12))
12623         self.assertTrue(b.isEqual(b1))
12624         self.assertTrue(a.isEqual(DataArrayDouble([0.8660254037844386,0.714142842854285,0.7071067811865476,0.7071067811865476,0.714142842854285,0.8660254037844386,0.714142842854285,0.5196152422706632,0.5099019513592785,0.5099019513592785,0.5196152422706632,0.714142842854285,0.7071067811865475,0.5099019513592785,0.5,0.5,0.5099019513592785,0.7071067811865476,0.7071067811865475,0.5099019513592785,0.5,0.5,0.5099019513592785,0.7071067811865476,0.714142842854285,0.5196152422706632,0.5099019513592785,0.5099019513592785,0.5196152422706632,0.714142842854285,0.8660254037844386,0.714142842854285,0.7071067811865476,0.7071067811865476,0.714142842854285,0.8660254037844386,0.714142842854285,0.5196152422706632,0.5099019513592785,0.5099019513592785,0.5196152422706631,0.714142842854285,0.5196152422706631,0.5196152422706632,0.5099019513592784,0.5099019513592785,0.5099019513592784,0.5099019513592785,0.5196152422706631,0.5196152422706632,0.714142842854285,0.5196152422706632,0.5099019513592785,0.5099019513592785,0.5196152422706632,0.714142842854285,0.7071067811865475,0.5099019513592785,0.5,0.5,0.5099019513592784,0.7071067811865475,0.5099019513592784,0.5099019513592785,0.5,0.5,0.5,0.5,0.5099019513592785,0.5099019513592785,0.7071067811865476,0.5099019513592785,0.5,0.5,0.5099019513592785,0.7071067811865476,0.7071067811865475,0.5099019513592785,0.5,0.5,0.5099019513592784,0.7071067811865475,0.5099019513592784,0.5099019513592785,0.5,0.5,0.5,0.5,0.5099019513592785,0.5099019513592785,0.7071067811865476,0.5099019513592785,0.5,0.5,0.5099019513592785,0.7071067811865476,0.714142842854285,0.5196152422706632,0.5099019513592785,0.5099019513592785,0.5196152422706631,0.714142842854285,0.5196152422706631,0.5196152422706632,0.5099019513592784,0.5099019513592785,0.5099019513592784,0.5099019513592785,0.5196152422706631,0.5196152422706632,0.714142842854285,0.5196152422706632,0.5099019513592785,0.5099019513592785,0.5196152422706632,0.714142842854285,0.8660254037844386,0.714142842854285,0.7071067811865476,0.7071067811865476,0.714142842854285,0.8660254037844386,0.714142842854285,0.5196152422706632,0.5099019513592785,0.5099019513592785,0.5196152422706632,0.714142842854285,0.7071067811865475,0.5099019513592785,0.5,0.5,0.5099019513592785,0.7071067811865476,0.7071067811865475,0.5099019513592785,0.5,0.5,0.5099019513592785,0.7071067811865476,0.714142842854285,0.5196152422706632,0.5099019513592785,0.5099019513592785,0.5196152422706632,0.714142842854285,0.8660254037844386,0.714142842854285,0.7071067811865476,0.7071067811865476,0.714142842854285,0.8660254037844386]),1e-12))
12625         self.assertTrue(b.isEqual(DataArrayInt([0,0,3,7,9,9,0,0,3,7,9,9,12,12,14,16,17,17,26,26,28,30,31,31,33,33,36,40,42,42,33,33,36,40,42,42,0,0,3,7,11,9,0,9,12,17,26,31,33,42,33,33,36,40,42,42,45,45,47,49,51,51,45,50,52,53,56,57,58,63,58,58,60,62,63,63,85,85,87,89,91,91,85,90,92,93,96,97,98,103,98,98,100,102,103,103,105,105,108,112,116,114,105,114,117,122,131,136,138,147,138,138,141,145,147,147,105,105,108,112,114,114,105,105,108,112,114,114,117,117,119,121,122,122,131,131,133,135,136,136,138,138,141,145,147,147,138,138,141,145,147,147])))
12626         pass
12627
12628     def testSwig2NonRegressionBugDistance1(self):
12629         pt=DataArrayDouble([(8.8452994616207476,3.1547005383792515,3.1547005383792515)])
12630         coo=DataArrayDouble([(8,0,0),(8,0,8),(8,8,8),(8,8,0),(16,0,0),(16,0,8),(16,8,8),(16,8,0),(8,0,4),(8,4,8),(8,8,4),(8,4,0),(16,0,4),(16,4,8),(16,8,4),(16,4,0),(12,0,0),(12,0,8),(12,8,8),(12,8,0),(8,4,4),(16,4,4),(12,0,4),(12,4,8),(12,8,4),(12,4,0)])
12631         conn=DataArrayInt([4,15,21,12,4,16,25,15,12,22,16,4,0,8,20,11,16,0,11,25,22,8,0,16,15,7,14,21,15,25,19,7,7,19,24,14,11,20,10,3,25,11,3,19,19,3,10,24,12,21,13,5,13,23,17,5,5,17,22,12,8,1,9,20,23,9,1,17,17,1,8,22,21,14,6,13,14,24,18,6 ,6,18,23,13,20,9,2,10,24,10,2,18,18,2,9,23])
12632         m=MEDCouplingUMesh("mesh",2)
12633         m.setCoords(coo)
12634         m.allocateCells()
12635         for i in xrange(24):
12636             m.insertNextCell(NORM_QUAD4,conn[4*i:4*i+4])
12637             pass
12638         m.checkCoherency2()
12639         m0=m[3] ; m0.zipCoords()
12640         expectedDist=0.8452994616207476
12641         a,b=m0.distanceToPoint(pt)
12642         self.assertAlmostEqual(expectedDist,a,14)
12643         self.assertEqual(0,b)
12644         #
12645         a,b=m.distanceToPoint(pt)
12646         self.assertAlmostEqual(expectedDist,a,14)
12647         self.assertEqual(3,b)
12648         #
12649         fd=MEDCouplingFieldDiscretization.New(ON_CELLS)
12650         self.assertEqual(24,fd.getNumberOfTuples(m))
12651         fd=MEDCouplingFieldDiscretization.New(ON_NODES)
12652         self.assertEqual(26,fd.getNumberOfTuples(m))
12653         pass
12654
12655     def testSwig2AreaBarySeg3Quad8Tri6QPolyg(self):
12656         #QUAD8 representing a circle of center zeBary and radius zeRadius
12657         zeBary=[5,6]
12658         zeRadius=3
12659         d=DataArrayDouble(8,2)
12660         d[:,0]=zeRadius
12661         d[:,1]=[87,-100,-170,110,5,-130,175,95] # angle in degree
12662         d[:,1]*=pi/180. # angle in radian
12663         d=d.fromPolarToCart()
12664         d+=zeBary
12665         m=MEDCouplingUMesh("quad8",2) ; m.allocateCells() ; m.insertNextCell(NORM_QUAD8,range(8)) ; m.setCoords(d)
12666         self.assertTrue(m.getBarycenterAndOwner().isEqual(DataArrayDouble(zeBary,1,2),1e-13))
12667         self.assertAlmostEqual(float(m.getMeasureField(False).getArray()),pi*zeRadius*zeRadius,12)
12668         tri32D=m.buildDescendingConnectivity()[0][0] ; tri32D.zipCoords()
12669         # spaceDim=3 QUAD8 becomes QUAD4 ... for the moment
12670         m.setCoords(m.getCoords().changeNbOfComponents(3,0.))
12671         m2=m.deepCpy()
12672         m2.convertQuadraticCellsToLinear()
12673         self.assertAlmostEqual(float(m.getMeasureField(False).getArray()),float(m2.getMeasureField(False).getArray()),12)
12674         self.assertTrue(m.getBarycenterAndOwner().isEqual(m2.getBarycenterAndOwner(),1e-13))
12675         #TRI6 representing a circle of center zeBary and radius zeRadius
12676         zeBary=[5,6]
12677         zeRadius=3
12678         d=DataArrayDouble(6,2)
12679         d[:,0]=zeRadius
12680         d[:,1]=[87,-100,110,5,175,95] # angle in degree
12681         d[:,1]*=pi/180. # angle in radian
12682         d=d.fromPolarToCart()
12683         d+=zeBary
12684         m=MEDCouplingUMesh("tri6",2) ; m.allocateCells() ; m.insertNextCell(NORM_TRI6,range(6)) ; m.setCoords(d)
12685         self.assertTrue(m.getBarycenterAndOwner().isEqual(DataArrayDouble(zeBary,1,2),1e-13))
12686         self.assertAlmostEqual(float(m.getMeasureField(False).getArray()),pi*zeRadius*zeRadius,12)
12687         # spaceDim=3 TRI6 becomes TRI3 ... for the moment
12688         m.setCoords(m.getCoords().changeNbOfComponents(3,0.))
12689         m2=m.deepCpy()
12690         m2.convertQuadraticCellsToLinear()
12691         self.assertAlmostEqual(float(m.getMeasureField(False).getArray()),float(m2.getMeasureField(False).getArray()),12)
12692         self.assertTrue(m.getBarycenterAndOwner().isEqual(m2.getBarycenterAndOwner(),1e-13))
12693         # QPOLYG representing a circle of center zeBary and radius zeRadius
12694         zeBary=[5,6]
12695         zeRadius=3
12696         d=DataArrayDouble(10,2)
12697         d[:,0]=zeRadius
12698         d[:,1]=[87,-80,-100,-170,110,5,-90,-130,175,95] # angle in degree
12699         d[:,1]*=pi/180. # angle in radian
12700         d=d.fromPolarToCart()
12701         d+=zeBary
12702         m=MEDCouplingUMesh("qpolyg",2) ; m.allocateCells() ; m.insertNextCell(NORM_QPOLYG,range(10)) ; m.setCoords(d)
12703         self.assertTrue(m.getBarycenterAndOwner().isEqual(DataArrayDouble(zeBary,1,2),1e-13))
12704         self.assertAlmostEqual(float(m.getMeasureField(False).getArray()),pi*zeRadius*zeRadius,12)
12705         # spaceDim=3 QPOLYG becomes POLYG ... for the moment
12706         m.setCoords(m.getCoords().changeNbOfComponents(3,0.))
12707         m2=m.deepCpy()
12708         m2.convertQuadraticCellsToLinear() ; m2.checkCoherency2()
12709         self.assertTrue(m2.getAllGeoTypes()==[NORM_POLYGON] and m2.getNodalConnectivity().getValues()==[5,0,1,2,3,4])
12710         self.assertAlmostEqual(float(m.getMeasureField(False).getArray()),float(m2.getMeasureField(False).getArray()),12)
12711         self.assertTrue(m.getBarycenterAndOwner().isEqual(m2.getBarycenterAndOwner(),1e-13))
12712         # TRI3
12713         self.assertAlmostEqual(float(tri32D.getMeasureField(False).getArray()),(87+100)*pi/180*zeRadius,13)
12714         exp=DataArrayDouble(1,2) ; exp[:,0]=3 ; exp[:,1]=(87-100)/2. ; exp[:,1]*=pi/180. ;  exp=exp.fromPolarToCart() ; exp+=DataArrayDouble([5,6],1,2)
12715         self.assertTrue(tri32D.getBarycenterAndOwner().isEqual(exp,1e-12))
12716         # spaceDim=3 TRI3 becomes TRI2 ... for the moment
12717         tri32D.changeSpaceDimension(3)
12718         tri2=tri32D.deepCpy() ; tri2.convertQuadraticCellsToLinear()
12719         self.assertAlmostEqual(float(tri32D.getMeasureField(False).getArray()),float(tri2.getMeasureField(False).getArray()),13)
12720         self.assertTrue(tri32D.getBarycenterAndOwner().isEqual(tri2.getBarycenterAndOwner(),1e-12))
12721         tri32D.changeSpaceDimension(1)
12722         self.assertAlmostEqual(float(tri32D.getMeasureField(False).getArray()),-0.67795240172962323,12)
12723         pass
12724
12725     # this bug 5/6/2013 is swig specific
12726     def testSwigNonRegressionBugRotate3D1(self):
12727         m=MEDCouplingUMesh.New()
12728         dataArray=DataArrayDouble.New(100,3)
12729         dataArray[:]=0.
12730         dataArray[0]=[0.,1,3]
12731         m.setCoords(dataArray[0])
12732         m1=m.deepCpy()
12733         m.rotate([0.,0.,3.],[1.,0.,0.],0.5*pi)
12734         self.assertTrue(m.getCoords().isEqual(DataArrayDouble([0.,0.,4.],1,3),1e-15))
12735         #
12736         d1=DataArrayDouble([0.,0.,3.],1,3) ; d2=DataArrayDouble([1.,0.,0.],1,3)
12737         pts=[[0.,0.,3.],[(0.,0.,3.)],DataArrayDouble([0.,0.,3.],1,3),list(d1)[0]]
12738         vec=[[1.,0.,0.],[(1.,0.,0.)],DataArrayDouble([1.,0.,0.],1,3),list(d2)[0]]
12739         for p in pts:
12740             for v in vec:
12741                 m2=m1.deepCpy()
12742                 m2.rotate(p,v,0.5*pi)
12743                 self.assertTrue(m2.getCoords().isEqual(DataArrayDouble([0.,0.,4.],1,3),1e-15))
12744                 pass
12745         pass
12746
12747     def testSwig2DataArrayCount1(self):
12748         d=DataArrayInt([])
12749         self.assertEqual(0,d.getNumberOfTuples())
12750         self.assertEqual(1,d.getNumberOfComponents())
12751         self.assertEqual(0,d.count(0))
12752         self.assertEqual(0,d.count(1))
12753         self.assertEqual(0,d.count(-1))
12754         d=DataArrayInt([2,1,-2,-3,2,0,0,7,2,-2,3,0])
12755         self.assertEqual(12,d.getNumberOfTuples())
12756         self.assertEqual(1,d.getNumberOfComponents())
12757         self.assertEqual(3,d.count(0))
12758         self.assertEqual(1,d.count(1))
12759         self.assertEqual(0,d.count(-1))
12760         self.assertEqual(2,d.count(-2))
12761         self.assertEqual(3,d.count(2))
12762         e=d.getDifferentValues()
12763         f=DataArrayInt()
12764         for it in e:
12765             f.pushBackSilent(d.count(int(it)))
12766             pass
12767         self.assertEqual(12,f.accumulate()[0])
12768         #
12769         eps=1e-12
12770         d=DataArrayDouble([])
12771         self.assertEqual(0,d.getNumberOfTuples())
12772         self.assertEqual(1,d.getNumberOfComponents())
12773         self.assertEqual(0,d.count(0,eps))
12774         self.assertEqual(0,d.count(1,eps))
12775         self.assertEqual(0,d.count(-1,eps))
12776         d=DataArrayDouble([2,1,-2,-3,2,0,eps/10,7,2+eps/10,-2,3,0])
12777         self.assertEqual(12,d.getNumberOfTuples())
12778         self.assertEqual(1,d.getNumberOfComponents())
12779         self.assertEqual(3,d.count(0,eps))
12780         self.assertEqual(1,d.count(1,eps))
12781         self.assertEqual(0,d.count(-1,eps))
12782         self.assertEqual(2,d.count(-2,eps))
12783         self.assertEqual(3,d.count(2,eps))
12784         self.assertEqual(3,d.count(2,eps))
12785         self.assertEqual(2,d.count(2,eps/100))
12786         e=d.getDifferentValues(eps)
12787         f=DataArrayInt()
12788         for it in e:
12789             f.pushBackSilent(d.count(float(it),eps))
12790             pass
12791         self.assertEqual(12,f.accumulate()[0])
12792         pass
12793
12794     def testSwig2DataArrayGetSlice1(self):
12795         s=slice(2,18,1)
12796         self.assertEqual(DataArray.GetNumberOfItemGivenBESRelative(s),16)
12797         self.assertEqual(DataArray.GetNumberOfItemGivenBES(s),16)
12798         self.assertEqual(DataArray.GetSlice(s,0,4),slice(2,6,1))
12799         self.assertEqual(DataArray.GetSlice(s,1,4),slice(6,10,1))
12800         self.assertEqual(DataArray.GetSlice(s,2,4),slice(10,14,1))
12801         self.assertEqual(DataArray.GetSlice(s,3,4),slice(14,18,1))
12802         #
12803         s=slice(2,18,2)
12804         self.assertEqual(DataArray.GetNumberOfItemGivenBESRelative(s),8)
12805         self.assertEqual(DataArray.GetNumberOfItemGivenBES(s),8)
12806         self.assertEqual(DataArray.GetSlice(s,0,4),slice(2,6,2))
12807         self.assertEqual(DataArray.GetSlice(s,1,4),slice(6,10,2))
12808         self.assertEqual(DataArray.GetSlice(s,2,4),slice(10,14,2))
12809         self.assertEqual(DataArray.GetSlice(s,3,4),slice(14,18,2))
12810         #
12811         s=slice(1,18,1)
12812         self.assertEqual(DataArray.GetSlice(s,0,4),slice(1,5,1))
12813         self.assertEqual(DataArray.GetSlice(s,1,4),slice(5,9,1))
12814         self.assertEqual(DataArray.GetSlice(s,2,4),slice(9,13,1))
12815         self.assertEqual(DataArray.GetSlice(s,3,4),slice(13,18,1))# 18 not 17
12816         #
12817         s=slice(1,18,2)
12818         self.assertEqual(DataArray.GetNumberOfItemGivenBESRelative(s),9)
12819         self.assertEqual(DataArray.GetNumberOfItemGivenBES(s),9)
12820         self.assertEqual(DataArray.GetSlice(s,0,4),slice(1,5,2))
12821         self.assertEqual(DataArray.GetSlice(s,1,4),slice(5,9,2))
12822         self.assertEqual(DataArray.GetSlice(s,2,4),slice(9,13,2))
12823         self.assertEqual(DataArray.GetSlice(s,3,4),slice(13,18,2))# 18 not 17
12824         #
12825         s=slice(18,2,-1)
12826         self.assertEqual(DataArray.GetSlice(s,0,4),slice(18,14,-1))
12827         self.assertEqual(DataArray.GetSlice(s,1,4),slice(14,10,-1))
12828         self.assertEqual(DataArray.GetSlice(s,2,4),slice(10,6,-1))
12829         self.assertEqual(DataArray.GetSlice(s,3,4),slice(6,2,-1))
12830         #
12831         s=slice(18,2,-2)
12832         self.assertEqual(DataArray.GetSlice(s,0,4),slice(18,14,-2))
12833         self.assertEqual(DataArray.GetSlice(s,1,4),slice(14,10,-2))
12834         self.assertEqual(DataArray.GetSlice(s,2,4),slice(10,6,-2))
12835         self.assertEqual(DataArray.GetSlice(s,3,4),slice(6,2,-2))
12836         #
12837         s=slice(18,1,-1)
12838         self.assertEqual(DataArray.GetSlice(s,0,4),slice(18,14,-1))
12839         self.assertEqual(DataArray.GetSlice(s,1,4),slice(14,10,-1))
12840         self.assertEqual(DataArray.GetSlice(s,2,4),slice(10,6,-1))
12841         self.assertEqual(DataArray.GetSlice(s,3,4),slice(6,1,-1))# 1 not 2
12842         #
12843         s=slice(18,1,-2)
12844         self.assertEqual(DataArray.GetNumberOfItemGivenBESRelative(s),9)
12845         self.assertRaises(InterpKernelException,DataArray.GetNumberOfItemGivenBES,s)
12846         self.assertEqual(sum([DataArray.GetNumberOfItemGivenBESRelative(DataArray.GetSlice(s,i,4)) for i in xrange(4)]),DataArray.GetNumberOfItemGivenBESRelative(s))
12847         self.assertEqual(DataArray.GetSlice(s,0,4),slice(18,14,-2))
12848         self.assertEqual(DataArray.GetSlice(s,1,4),slice(14,10,-2))
12849         self.assertEqual(DataArray.GetSlice(s,2,4),slice(10,6,-2))
12850         self.assertEqual(DataArray.GetSlice(s,3,4),slice(6,1,-2))# 1 not 2
12851         self.assertRaises(InterpKernelException,DataArray.GetSlice,slice(0,None,2),0,4)
12852         #
12853         d=DataArrayInt.Range(0,18,1)
12854         s=slice(2,None,1)
12855         self.assertEqual(d.getNumberOfItemGivenBES(s),16)
12856         self.assertEqual(d.getNumberOfItemGivenBESRelative(s),16)
12857         self.assertEqual(d.getSlice(s,0,4),slice(2,6,1))
12858         self.assertEqual(d.getSlice(s,1,4),slice(6,10,1))
12859         self.assertEqual(d.getSlice(s,2,4),slice(10,14,1))
12860         self.assertEqual(d.getSlice(s,3,4),slice(14,18,1))
12861         #
12862         d=DataArrayInt.Range(0,18,1)
12863         s=slice(2,-2,1)
12864         self.assertEqual(d.getSlice(s,0,4),slice(2,5,1))
12865         self.assertEqual(d.getSlice(s,1,4),slice(5,8,1))
12866         self.assertEqual(d.getSlice(s,2,4),slice(8,11,1))
12867         self.assertEqual(d.getSlice(s,3,4),slice(11,16,1))
12868         #
12869         d=DataArrayInt.Range(0,18,1)
12870         s=slice(None,None,1)
12871         self.assertEqual(d.getSlice(s,0,4),slice(0,4,1))
12872         self.assertEqual(d.getSlice(s,1,4),slice(4,8,1))
12873         self.assertEqual(d.getSlice(s,2,4),slice(8,12,1))
12874         self.assertEqual(d.getSlice(s,3,4),slice(12,18,1))
12875         #
12876         d=DataArrayInt.Range(0,18,1)
12877         s=slice(None,2,-2)
12878         self.assertRaises(InterpKernelException,d.getNumberOfItemGivenBES,s)
12879         self.assertEqual(d.getNumberOfItemGivenBESRelative(s),8)
12880         self.assertEqual(d.getSlice(s,0,4),slice(17,13,-2))
12881         self.assertEqual(d.getSlice(s,1,4),slice(13,9,-2))
12882         self.assertEqual(d.getSlice(s,2,4),slice(9,5,-2))
12883         self.assertEqual(d.getSlice(s,3,4),slice(5,2,-2))
12884         pass
12885
12886     def testSwig2AccumulatePerChunk1(self):
12887         arr=DataArrayDouble(11) ; arr.iota()
12888         m=MEDCouplingCMesh() ; m.setCoords(arr,arr)
12889         m=m.buildUnstructured()
12890         m0=m[::2] ; ids0=m0.simplexize(0) ; m1=m[1::2]
12891         m=MEDCouplingUMesh.MergeUMeshesOnSameCoords(m0,m1) ; m.setName("mesh")
12892         m.checkConsecutiveCellTypesForMEDFileFrmt()
12893         #
12894         formula="7-sqrt((x-5.)*(x-5.)+(y-5.)*(y-5.))"
12895         f=MEDCouplingFieldDouble(ON_CELLS,ONE_TIME) ; f.setMesh(m)
12896         f.fillFromAnalytic(1,formula)
12897         f.setName("Field1") ; f.setTime(1.1,1,-1)
12898         f.checkCoherency()
12899         #
12900         arr=f.getArray()
12901         arr2=DataArrayDouble(len(arr),2) ; arr2[:,0]=arr
12902         arr2=DataArrayDouble(len(arr),2) ; arr2[:,0]=arr ; arr2[:,1]=2*arr
12903         f.setArray(arr2)
12904         f.checkCoherency()
12905         # here the compact code to obviously put field on cell to nodes
12906         rn,rni=f.getMesh().getReverseNodalConnectivity()
12907         arr2=f.getArray()[rn]
12908         arr4=arr2.accumulatePerChunck(rni)
12909         nbOfCellsSharingNodes=rni.deltaShiftIndex()
12910         arr4/=nbOfCellsSharingNodes.convertToDblArr()
12911         #
12912         maxNbCSN=nbOfCellsSharingNodes.getMaxValue()[0]
12913         arr3=DataArrayDouble(f.getMesh().getNumberOfNodes(),f.getArray().getNumberOfComponents()) ; arr3[:]=0.
12914         for i in xrange(1,maxNbCSN+1):
12915             ids=nbOfCellsSharingNodes.getIdsEqual(i)
12916             if len(ids)==0:
12917                 continue
12918             for j in range(i):
12919                 rni2=rni[ids] ; rni2+=j
12920                 arr3[ids]+=arr2[rni2]
12921                 pass
12922             arr3[ids]/=i
12923             pass
12924         fNode=MEDCouplingFieldDouble(ON_NODES,ONE_TIME) ; fNode.setMesh(m)
12925         fNode.setName("Field1Node") ; fNode.setTime(1.1,1,-1)
12926         fNode.setArray(arr3) ; fNode.checkCoherency()
12927         self.assertTrue(arr3.isEqual(arr4,1e-12))
12928         #
12929         d=DataArrayInt.Range(0,20,1)
12930         self.assertTrue(d.accumulatePerChunck([2,4,12]).isEqual(DataArrayInt([5,60])))
12931         #
12932         a=DataArrayDouble(12) ; a.iota() ; a.rearrange(3)
12933         b=DataArrayDouble(12) ; b.iota(20) ; b.rearrange(3)
12934         ids=DataArrayInt([])
12935         self.assertEqual(len(a[ids]),0)
12936         self.assertEqual(len(b[ids]),0)
12937         a2=a.deepCpy() ;  a2[ids]+=b[ids] ; self.assertTrue(a2.isEqual(a,1e-15))
12938         a2=a.deepCpy() ;  a2[ids]*=b[ids] ; self.assertTrue(a2.isEqual(a,1e-15))
12939         a2=a.deepCpy() ;  a2[ids]/=b[ids] ; self.assertTrue(a2.isEqual(a,1e-15))
12940         a2=a.deepCpy() ;  a2[ids]-=b[ids] ; self.assertTrue(a2.isEqual(a,1e-15))
12941         pass
12942
12943     def testSwig2CheckAndPreparePermutation1(self):
12944         a=DataArrayInt([10003,9999999,5,67])
12945         self.assertTrue(a.checkAndPreparePermutation().isEqual(DataArrayInt([2,3,0,1])))
12946         a=DataArrayInt([10003,-9999999,5,67])
12947         self.assertTrue(a.checkAndPreparePermutation().isEqual(DataArrayInt([3,0,1,2])))
12948         a=DataArrayInt([])
12949         self.assertTrue(a.checkAndPreparePermutation().isEqual(DataArrayInt([])))
12950         a=DataArrayInt([])
12951         a.iota();
12952         self.assertTrue(a.isEqual(DataArrayInt([])))
12953         pass
12954
12955     def testSwig21SGTUMesh1(self):
12956         m=MEDCoupling1GTUMesh.New("m",NORM_PENTA6)
12957         m.__repr__() ; m.__str__()
12958         self.assertTrue(isinstance(m,MEDCoupling1SGTUMesh))
12959         m.setCoords(DataArrayDouble(20,3))
12960         m.allocateCells()
12961         m.__repr__() ; m.__str__()
12962         m.insertNextCell([0,1,2,5,7,2])
12963         self.assertEqual(1,m.getNumberOfCells())
12964         self.assertTrue(DataArrayInt([6]).isEqual(m.computeNbOfNodesPerCell()))
12965         self.assertTrue(DataArrayInt([5]).isEqual(m.computeNbOfFacesPerCell()))
12966         m.__repr__() ; m.__str__()
12967         m.checkCoherency()
12968         m.checkCoherency2()
12969         #
12970         cm=MEDCouplingCMesh() ; cm.setName("m")
12971         arr0=DataArrayDouble(6) ; arr0.iota()
12972         arr1=DataArrayDouble([0,1])
12973         cm.setCoords(arr0,arr1,arr1) ; um=cm.buildUnstructured()
12974         #
12975         m=MEDCoupling1SGTUMesh("m",NORM_QUAD4)
12976         m.allocateCells(5)
12977         self.assertIn(m.getHeapMemorySize(),xrange(80,90))
12978         self.assertEqual(m.getNodalConnectivity().getNbOfElemAllocated(),20)
12979         m.setCoords(um.getCoords())
12980         m.insertNextCell([1,0,6,7])
12981         self.assertEqual(1,m.getNumberOfCells())
12982         m.insertNextCell([2,1,7,8])
12983         m.insertNextCell([3,2,8,9])
12984         m.insertNextCell([4,3,9,10])
12985         m.insertNextCell([5,4,10,11])
12986         self.assertEqual(5,m.getNumberOfCells())
12987         self.assertRaises(InterpKernelException,m.insertNextCell,[0,6,7])
12988         self.assertRaises(InterpKernelException,m.insertNextCell,[0,6,7,1,2])
12989         self.assertEqual(m.getNodalConnectivity().getNbOfElemAllocated(),20)
12990         f=m.getMeasureField(ON_CELLS)
12991         self.assertEqual(f.getMesh().getHiddenCppPointer(),m.getHiddenCppPointer())
12992         self.assertTrue(f.getArray().isUniform(1,1e-14))
12993         self.assertEqual(m.getType(),10)
12994         self.assertEqual(m.getCellModelEnum(),NORM_QUAD4)
12995         mo=MEDCoupling1SGTUMesh("m",NORM_QUAD4) ; mo.setCoords(m.getCoords())
12996         mo.setNodalConnectivity(DataArrayInt([1,0,6,7,2,1,7,8,3,2,8,9,4,3,9,10,5,4,10,11]))
12997         self.assertTrue(m.isEqual(mo,1e-12))
12998         #
12999         mo2=MEDCoupling1SGTUMesh.Merge1SGTUMeshesOnSameCoords([m[[0,1]],m[[2]],m[[3,4]]])
13000         mo2.setName(m.getName())
13001         self.assertTrue(m.isEqual(mo2,1e-12))
13002         #
13003         mp0=m[[0]] ; mp0.zipCoords() ; mp1=m[2] ; mp1.zipCoords() ; mp2=m[4] ; mp2.zipCoords()
13004         mo3=MEDCoupling1SGTUMesh.Merge1SGTUMeshes([mp0,mp1,mp2])
13005         self.assertTrue(isinstance(mo3,MEDCoupling1SGTUMesh))
13006         mo3.setName(m.getName())
13007         m_ref=m[(0,2,4)] ; m_ref.zipCoords()
13008         m_ref.tryToShareSameCoordsPermute(mo3,1e-12)
13009         self.assertTrue(m_ref.isEqual(mo3,1e-12))
13010         #
13011         m1=um.buildDescendingConnectivity()[0]
13012         ids=m1.getCellIdsFullyIncludedInNodeIds(DataArrayInt.Range(0,12,1))
13013         m1=m1[ids]
13014         m1c=m1.convertIntoSingleGeoTypeMesh()
13015         self.assertTrue(isinstance(m1c,MEDCoupling1SGTUMesh))
13016         self.assertEqual(m1c.getCoords().getHiddenCppPointer(),m.getCoords().getHiddenCppPointer())
13017         m1c.checkCoherency2()
13018         self.assertTrue(m1c.getNodalConnectivity().isEqual(DataArrayInt([1,0,6,7,2,1,7,8,3,2,8,9,4,3,9,10,5,4,10,11])))
13019         self.assertEqual(20,m1c.getNodalConnectivityLength())
13020         self.assertTrue(m.isEqual(m1c,1e-12))
13021         m.getNodalConnectivity().setIJ(1,0,1)
13022         self.assertTrue(not m.isEqual(m1c,1e-12))
13023         m.getNodalConnectivity().setIJ(1,0,0)
13024         self.assertTrue(m.isEqual(m1c,1e-12))
13025         m1c.setCoords(m.getCoords().deepCpy())
13026         self.assertTrue(m.isEqual(m1c,1e-12))
13027         m1c.getCoords().setIJ(0,1,0.1)
13028         self.assertTrue(not m.isEqual(m1c,1e-12))
13029         m1c.getCoords().setIJ(0,1,0)
13030         self.assertTrue(m.isEqual(m1c,1e-12))
13031         m1c.getCoords().setInfoOnComponent(1,"X")
13032         self.assertTrue(not m.isEqual(m1c,1e-12) and m.isEqualWithoutConsideringStr(m1c,1e-12))
13033         m.getCoords().setInfoOnComponent(1,"X")
13034         self.assertTrue(m.isEqual(m1c,1e-12) and m.isEqualWithoutConsideringStr(m1c,1e-12))
13035         m.setName("m2")
13036         self.assertTrue(not m.isEqual(m1c,1e-12) and m.isEqualWithoutConsideringStr(m1c,1e-12))
13037         #
13038         m.checkCoherency() ; m.checkCoherency1() ; m.checkCoherency2()
13039         self.assertEqual(m.getMeshDimension(),2)
13040         self.assertTrue(m.giveCellsWithType(NORM_QUAD4).isEqual(DataArrayInt([0,1,2,3,4])))
13041         self.assertTrue(m.giveCellsWithType(NORM_TRI3).isEqual(DataArrayInt([])))
13042         self.assertEqual(m.getNumberOfCellsWithType(NORM_QUAD4),5)
13043         self.assertEqual(m.getNumberOfCellsWithType(NORM_TRI3),0)
13044         self.assertEqual(m.getTypeOfCell(3),NORM_QUAD4)
13045         self.assertRaises(InterpKernelException,m.getTypeOfCell,5)
13046         self.assertEqual(m.getAllGeoTypes(),[NORM_QUAD4])
13047         self.assertEqual(m.getDistributionOfTypes(),[[NORM_QUAD4,5,0]])
13048         ##
13049         pfl1=DataArrayInt([1,3,4])
13050         a,b,c=m.splitProfilePerType(pfl1)
13051         d,e,f=m.buildUnstructured().splitProfilePerType(pfl1)
13052         self.assertTrue(a==[[4,3,0]] and len(b)==1 and b[0].isEqual(DataArrayInt([0,1,2])) and len(c)==1 and c[0].getHiddenCppPointer()==pfl1.getHiddenCppPointer())
13053         self.assertTrue(a==d and len(b)==1 and b[0].isEqual(e[0]) and len(c)==1 and c[0].isEqual(f[0]))
13054         #
13055         pfl2=DataArrayInt([0,1,2,3])
13056         a,b,c=m.splitProfilePerType(pfl2)
13057         d,e,f=m.buildUnstructured().splitProfilePerType(pfl2)
13058         self.assertTrue(a==[[4,4,0]] and len(b)==1 and b[0].isEqual(DataArrayInt([0,1,2,3])) and len(c)==1 and c[0].getHiddenCppPointer()==pfl2.getHiddenCppPointer())
13059         self.assertTrue(a==d and len(b)==1 and b[0].isEqual(e[0]) and len(c)==1 and c[0].isEqual(f[0]))
13060         #
13061         pfl3=DataArrayInt([0,1,2,3,4])
13062         a,b,c=m.splitProfilePerType(pfl3)
13063         d,e,f=m.buildUnstructured().splitProfilePerType(pfl3)
13064         self.assertTrue(a==[[4,5,-1]] and len(b)==1 and b[0].isEqual(DataArrayInt([0,1,2,3,4])) and c==[])
13065         self.assertTrue(a==d and len(b)==1 and b[0].isEqual(e[0]) and c==[])
13066         #
13067         invalidPfl=DataArrayInt([1,2,3,4,5])
13068         self.assertRaises(InterpKernelException,m.splitProfilePerType,invalidPfl)
13069         self.assertRaises(InterpKernelException,m.buildUnstructured().splitProfilePerType,invalidPfl)
13070         ##
13071         pfl1=DataArrayInt([1,2,3])
13072         a=m.checkTypeConsistencyAndContig([NORM_QUAD4,3,0],[pfl1])
13073         b=m.buildUnstructured().checkTypeConsistencyAndContig([NORM_QUAD4,3,0],[pfl1])
13074         self.assertTrue(a.isEqual(b) and pfl1.getHiddenCppPointer(),a.getHiddenCppPointer())
13075         #
13076         pfl2=DataArrayInt([0,1,2,3])
13077         a=m.checkTypeConsistencyAndContig([NORM_QUAD4,4,0],[pfl2])
13078         b=m.buildUnstructured().checkTypeConsistencyAndContig([NORM_QUAD4,4,0],[pfl2])
13079         self.assertTrue(a.isEqual(b) and pfl2.getHiddenCppPointer()==a.getHiddenCppPointer())
13080         #
13081         pfl3=DataArrayInt([0,1,2,3,4])
13082         a=m.checkTypeConsistencyAndContig([NORM_QUAD4,4,0],[pfl3])
13083         b=m.buildUnstructured().checkTypeConsistencyAndContig([NORM_QUAD4,5,0],[pfl3])
13084         self.assertTrue(a.isEqual(b) and pfl3.getHiddenCppPointer()==a.getHiddenCppPointer())
13085         #
13086         invalidPfl=DataArrayInt([1,2,3,4,5])
13087         self.assertRaises(InterpKernelException,m.checkTypeConsistencyAndContig,[NORM_QUAD4,5,0],[invalidPfl])
13088         self.assertRaises(InterpKernelException,m.buildUnstructured().checkTypeConsistencyAndContig,[NORM_QUAD4,5,0],[invalidPfl])
13089         ##
13090         self.assertTrue(DataArrayInt([4,4,4,4,4]).isEqual(m.computeNbOfNodesPerCell()))
13091         ##
13092         self.assertEqual(m.getNodeIdsOfCell(1),[2,1,7,8])
13093         ##
13094         self.assertTrue(m.computeIsoBarycenterOfNodesPerCell().isEqual(DataArrayDouble([(0.5,0.5,0),(1.5,0.5,0),(2.5,0.5,0),(3.5,0.5,0),(4.5,0.5,0)]),1e-13))
13095         ##
13096         ref=m.getCoords().getHiddenCppPointer()
13097         mcpy=m.deepCpy() ; mcpy.insertNextCell([1,0,6,7])
13098         c=m.getNodalConnectivity().deepCpy()
13099         o2n=DataArrayInt([2,0,1,4,3])
13100         m.renumberCells(o2n,False)
13101         c.rearrange(4) ; c.renumberInPlace(o2n) ; c.rearrange(1)
13102         self.assertTrue(c.isEqual(m.getNodalConnectivity()))
13103         self.assertEqual(ref,m.getCoords().getHiddenCppPointer())
13104         m2=mcpy.mergeMyselfWith(m)
13105         self.assertTrue(isinstance(m2,MEDCoupling1SGTUMesh))
13106         self.assertEqual(11,m2.getNumberOfCells())
13107         self.assertEqual(48,m2.getNumberOfNodes())
13108         self.assertTrue(m2.getCoords().isEqual(DataArrayDouble.Aggregate([m.getCoords(),m.getCoords()]),1e-12))
13109         self.assertTrue(m2.getNodalConnectivity().isEqual(DataArrayInt([1,0,6,7,2,1,7,8,3,2,8,9,4,3,9,10,5,4,10,11,1,0,6,7,26,25,31,32,27,26,32,33,25,24,30,31,29,28,34,35,28,27,33,34])))
13110         ##
13111         mu=m.buildUnstructured()
13112         mu.checkCoherency2()
13113         self.assertEqual(mu.getCoords().getHiddenCppPointer(),m.getCoords().getHiddenCppPointer())
13114         self.assertEqual(2,mu.getMeshDimension())
13115         self.assertEqual([NORM_QUAD4],mu.getAllGeoTypes())
13116         self.assertTrue(mu.getNodalConnectivity().isEqual(DataArrayInt([4,2,1,7,8,4,3,2,8,9,4,1,0,6,7,4,5,4,10,11,4,4,3,9,10])))
13117         self.assertTrue(mu.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5,10,15,20,25])))
13118         ##
13119         for typ in [0,1]:
13120             mcpy2=m.deepCpy() ; umcpy2=mcpy2.buildUnstructured()
13121             ids=mcpy2.simplexize(typ) ; ids2=umcpy2.simplexize(typ)
13122             self.assertTrue(ids.isEqual(ids2))
13123             mcpy3=umcpy2.convertIntoSingleGeoTypeMesh()
13124             self.assertTrue(mcpy2.isEqual(mcpy3,1e-14))
13125             pass
13126         um1=um.convertIntoSingleGeoTypeMesh()
13127         self.assertEqual(8,um1.getNumberOfNodesPerCell())
13128         for typ in [PLANAR_FACE_5,PLANAR_FACE_6]:
13129             mcpy2=um1.deepCpy() ; umcpy2=mcpy2.buildUnstructured()
13130             ids=mcpy2.simplexize(typ) ; ids2=umcpy2.simplexize(typ)
13131             self.assertTrue(ids.isEqual(ids2))
13132             mcpy3=umcpy2.convertIntoSingleGeoTypeMesh()
13133             self.assertTrue(mcpy2.isEqual(mcpy3,1e-14))
13134             pass
13135         ##
13136         self.assertRaises(InterpKernelException,mcpy.mergeMyselfWithOnSameCoords,m)
13137         mcpy.tryToShareSameCoords(m,1e-14)
13138         m3=mcpy.mergeMyselfWithOnSameCoords(m)
13139         self.assertTrue(isinstance(m3,MEDCoupling1SGTUMesh))
13140         self.assertEqual(11,m3.getNumberOfCells())
13141         self.assertEqual(24,m3.getNumberOfNodes())
13142         self.assertEqual(m3.getCoords().getHiddenCppPointer(),mcpy.getCoords().getHiddenCppPointer())
13143         self.assertTrue(m3.getNodalConnectivity().isEqual(DataArrayInt([1,0,6,7,2,1,7,8,3,2,8,9,4,3,9,10,5,4,10,11,1,0,6,7,2,1,7,8,3,2,8,9,1,0,6,7,5,4,10,11,4,3,9,10])))
13144         ##
13145         ref=mcpy.getCoords().deepCpy()
13146         c3=mcpy.getNodalConnectivity()[:]
13147         mcpy.getNodalConnectivity().setIJ(int(c3.getIdsEqual(11)),0,24)
13148         c2=DataArrayDouble.Aggregate([mcpy.getCoords(),mcpy.getCoords()[11:]])
13149         mcpy.setCoords(c2)
13150         mcpy.checkCoherency2()
13151         a,b=mcpy.getNodeIdsInUse()
13152         self.assertEqual(12,b)
13153         self.assertTrue(a.isEqual(DataArrayInt([0,1,2,3,4,5,6,7,8,9,10,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,11,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1])))
13154         ids=mcpy.zipCoordsTraducer()
13155         self.assertTrue(ids.isEqual(DataArrayInt([0,1,2,3,4,5,6,7,8,9,10,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,11,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1])))
13156         self.assertTrue(mcpy.getCoords().isEqual(ref[:12],1e-12))
13157         self.assertTrue(mcpy.getNodalConnectivity().isEqual(c3))
13158         mcpy.checkCoherency2()
13159         ##
13160         m4=mcpy[DataArrayInt([0,3,4])]
13161         m5=mcpy.buildPartOfMySelfKeepCoords(DataArrayInt([0,3,4]))
13162         self.assertTrue(isinstance(m4,MEDCoupling1SGTUMesh))
13163         self.assertTrue(m4.isEqual(m5,-1e-14))# < 0 not a bug it proves that coordinates pointer are equal
13164         self.assertTrue(m4.getNodalConnectivity().isEqual(DataArrayInt([1,0,6,7,4,3,9,10,5,4,10,11])))
13165         m6=mcpy[::2]
13166         self.assertTrue(isinstance(m6,MEDCoupling1SGTUMesh))
13167         self.assertTrue(m6.getNodalConnectivity().isEqual(DataArrayInt([1,0,6,7,3,2,8,9,5,4,10,11])))
13168         ##
13169         mcpy.setCoords(DataArrayDouble.Aggregate([mcpy.getCoords(),mcpy.getCoords()]))
13170         mcpy.checkCoherency2()
13171         ##
13172         mcppy=mcpy.deepCpyConnectivityOnly()
13173         self.assertTrue(mcppy.isEqual(mcpy,1e-12))
13174         self.assertTrue(mcppy.getCoords().getHiddenCppPointer()==mcpy.getCoords().getHiddenCppPointer())
13175         self.assertTrue(mcppy.getNodalConnectivity().isEqual(mcpy.getNodalConnectivity()))
13176         self.assertTrue(mcppy.getNodalConnectivity().getHiddenCppPointer()!=mcpy.getNodalConnectivity().getHiddenCppPointer())
13177         ##
13178         a,b=mcpy.getReverseNodalConnectivity()
13179         self.assertTrue(a.isEqual(DataArrayInt([0,5,0,1,5,1,2,2,3,3,4,4,0,5,0,1,5,1,2,2,3,3,4,4])))
13180         self.assertTrue(b.isEqual(DataArrayInt([0,2,5,7,9,11,12,14,17,19,21,23,24,24,24,24,24,24,24,24,24,24,24,24,24])))
13181         self.assertTrue(mcpy.fillCellIdsToKeepFromNodeIds([0,1,6,7],False).isEqual(DataArrayInt([0,1,5])))
13182         self.assertTrue(mcpy.fillCellIdsToKeepFromNodeIds([0,1,6,7],True).isEqual(DataArrayInt([0,5])))
13183         self.assertTrue(mcpy.getCellsInBoundingBox([(0,1),(0,1),(0,1)],1e-12).isEqual(DataArrayInt([0,1,5])))
13184         f=mcpy.buildOrthogonalField()
13185         self.assertEqual(f.getMesh().getHiddenCppPointer(),mcpy.getHiddenCppPointer())
13186         self.assertTrue(f.getArray().isEqual(DataArrayDouble(6*[(0,0,-1)]),1e-12))
13187         mcpy.changeSpaceDimension(2)
13188         self.assertEqual(1,mcpy.getCellContainingPoint([1.5,0.5],1e-12))
13189         ##
13190         self.assertTrue(mcpy.fillCellIdsToKeepFromNodeIds(DataArrayInt([6,7]),False).isEqual(DataArrayInt([0,1,5])))
13191         ##
13192         mcpy2=mcpy.deepCpy()
13193         self.assertEqual([None,None],mcpy.checkGeoEquivalWith(mcpy2,1,1e-12))#fast equal
13194         mcpy.checkFastEquivalWith(mcpy2,1e-12)
13195         mcpy2.renumberCells([0,2,4,3,1,5])
13196         mcpy.checkFastEquivalWith(mcpy2,1e-12)
13197         self.assertEqual([None,None],mcpy.checkGeoEquivalWith(mcpy2,1,1e-12))#fast equal
13198         mcpy2.renumberCells([0,2,4,3,1,5])
13199         mcpy2.renumberCells([1,3,5,0,2,4])
13200         self.assertRaises(InterpKernelException,mcpy.checkFastEquivalWith,mcpy2,1e-12)
13201         self.assertRaises(InterpKernelException,mcpy.checkGeoEquivalWith,mcpy2,1,1e-12)#fast equal
13202         pass
13203
13204     def testSwig21DGTUMesh1(self):
13205         a0=DataArrayInt([0,2,3,5,6,8])
13206         a1=DataArrayInt([0,4,7,11,14,18,21,25])
13207         a2=DataArrayInt([0,1,4,5])
13208         self.assertTrue(DataArrayInt.AggregateIndexes([a0,a1,a2]).isEqual(DataArrayInt([0,2,3,5,6,8,12,15,19,22,26,29,33,34,37,38])))
13209         self.assertEqual(a1[3:].front(),11)
13210         self.assertEqual(a1[4:].convertToDblArr().front(),14.)
13211         a1c=DataArrayInt([5,7,1,2, 8,11,0, 5,6,3,12, 1,5,2, 13,12,11,7, 6,1,0, 20,21,19,17])
13212         d,e=MEDCouplingUMesh.ExtractFromIndexedArrays2(1,5,2,a1c,a1)
13213         self.assertTrue(d.isEqual(DataArrayInt([8,11,0,1,5,2])))
13214         self.assertTrue(e.isEqual(DataArrayInt([0,3,6])))
13215         #
13216         m=MEDCouplingDataForTest.build2DTargetMesh_1()[0,3,4]
13217         ref=DataArrayInt([0,3,4,1,6,7,4,3,7,8,5,4])
13218         self.assertTrue(m.convertNodalConnectivityToStaticGeoTypeMesh().isEqual(ref))
13219         d,e=m.convertNodalConnectivityToDynamicGeoTypeMesh()
13220         self.assertTrue(d.isEqual(ref))
13221         self.assertTrue(e.isEqual(DataArrayInt.Range(0,13,4)))
13222         self.assertTrue(m.fillCellIdsToKeepFromNodeIds(DataArrayInt([6,7]),False).isEqual(DataArrayInt([1,2])))
13223         #
13224         m=MEDCoupling1GTUMesh.New("m",NORM_POLYHED)
13225         self.assertTrue(isinstance(m,MEDCoupling1DGTUMesh))
13226         m.__repr__() ; m.__str__()
13227         m.setCoords(DataArrayDouble(20,3))
13228         m.allocateCells()
13229         m.__repr__() ; m.__str__()
13230         m.insertNextCell([0,1,2,5,7,2,-1,1,3])
13231         self.assertEqual(1,m.getNumberOfCells())
13232         self.assertTrue(DataArrayInt([8]).isEqual(m.computeNbOfNodesPerCell()))
13233         self.assertTrue(DataArrayInt([2]).isEqual(m.computeNbOfFacesPerCell()))
13234         m.__repr__() ; m.__str__()
13235         m.checkCoherency()
13236         m.checkCoherency2()
13237         #
13238         cm=MEDCouplingCMesh() ; cm.setName("m")
13239         arr0=DataArrayDouble(6) ; arr0.iota()
13240         arr1=DataArrayDouble([0,1])
13241         cm.setCoords(arr0,arr1,arr1) ; um=cm.buildUnstructured() ; um.convertAllToPoly()
13242         um2=um.deepCpyConnectivityOnly()
13243         self.assertTrue(um2.isEqual(um,1e-12))
13244         self.assertEqual(um2.getCoords().getHiddenCppPointer(),um.getCoords().getHiddenCppPointer())
13245         self.assertTrue(um2.getNodalConnectivity().isEqual(um.getNodalConnectivity()))
13246         self.assertTrue(um2.getNodalConnectivity().getHiddenCppPointer()!=um.getNodalConnectivity().getHiddenCppPointer())
13247         self.assertTrue(um2.getNodalConnectivityIndex().isEqual(um.getNodalConnectivityIndex()))
13248         self.assertTrue(um2.getNodalConnectivityIndex().getHiddenCppPointer()!=um.getNodalConnectivityIndex().getHiddenCppPointer())
13249         #
13250         self.assertRaises(InterpKernelException,MEDCoupling1SGTUMesh.New,"m",NORM_POLYHED)
13251         m=MEDCoupling1DGTUMesh("m",NORM_POLYHED)
13252         m.allocateCells(5)
13253         self.assertEqual(15,m.getNodalConnectivity().getNbOfElemAllocated())
13254         self.assertEqual(6,m.getNodalConnectivityIndex().getNbOfElemAllocated())
13255         m.setCoords(um.getCoords())
13256         m.insertNextCell([1,0,6,7,-1,7,6,1])
13257         self.assertEqual(1,m.getNumberOfCells())
13258         m.insertNextCell([2,1,7,8,-1,2,1,-1,8,-1,7])
13259         m.insertNextCell([3,2,8,9])
13260         m.insertNextCell([4,3,9,10,-1,5,3,9])
13261         m.insertNextCell([5,4,10,11,-1,11,10,-1,5])
13262         m.checkCoherency()
13263         m.checkCoherency2()
13264         self.assertEqual(5,m.getNumberOfCells())
13265         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,8,19,23,31,40])))
13266         self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([1,0,6,7,-1,7,6,1,2,1,7,8,-1,2,1,-1,8,-1,7,3,2,8,9,4,3,9,10,-1,5,3,9,5,4,10,11,-1,11,10,-1,5])))
13267         #
13268         m4=m.deepCpy()
13269         self.assertTrue(m.isEqual(m4,1e-12))
13270         m4.getNodalConnectivity().setIJ(2,0,5)
13271         self.assertTrue(not m.isEqual(m4,1e-12))
13272         m4.getNodalConnectivity().setIJ(2,0,6)
13273         self.assertTrue(m.isEqual(m4,1e-12))
13274         m4.getNodalConnectivityIndex().setIJ(2,0,21)
13275         self.assertTrue(not m.isEqual(m4,1e-12))
13276         m4.getNodalConnectivityIndex().setIJ(2,0,19)
13277         self.assertTrue(m.isEqual(m4,1e-12))
13278         m4.getCoords().setIJ(10,1,1.1)
13279         self.assertTrue(not m.isEqual(m4,1e-12))
13280         m4.getCoords().setIJ(10,1,1.)
13281         self.assertTrue(m.isEqual(m4,1e-12))
13282         m4.getNodalConnectivity().pushBackSilent(7)
13283         self.assertTrue(not m.isEqual(m4,1e-12))
13284         self.assertEqual(7,m4.getNodalConnectivity().popBackSilent())
13285         self.assertTrue(m.isEqual(m4,1e-12))
13286         m4.setName("m4")
13287         self.assertTrue(not m.isEqual(m4,1e-12))
13288         m4.setName("m")
13289         self.assertTrue(m.isEqual(m4,1e-12))
13290         #
13291         self.assertEqual(6,m.getNodalConnectivityIndex().getNbOfElemAllocated())
13292         self.assertEqual(60,m.getNodalConnectivity().getNbOfElemAllocated())
13293         self.assertTrue(m.computeNbOfNodesPerCell().isEqual(DataArrayInt([7,8,4,7,7])))
13294         self.assertTrue(m.computeNbOfFacesPerCell().isEqual(DataArrayInt([2,4,1,2,3])))
13295         self.assertEqual(m.getNodeIdsOfCell(1),[2,1,7,8,-1,2,1,-1,8,-1,7])
13296         f=m.computeIsoBarycenterOfNodesPerCell()
13297         self.assertTrue(DataArrayDouble([(0.5714285714285714,0.5714285714285714,0),(1.5,0.5,0),(2.5,0.5,0),(3.5714285714285712,0.42857142857142855,0),(4.5714285714285712,0.5714285714285714,0)]).isEqual(f,1e-14))
13298         mu0=m.buildUnstructured()
13299         o2n=[1,2,0,4,3]
13300         m2=m.deepCpy()
13301         m3=m.deepCpyConnectivityOnly()
13302         self.assertTrue(m3.isEqual(m,1e-12))
13303         self.assertEqual(m3.getCoords().getHiddenCppPointer(),m.getCoords().getHiddenCppPointer())
13304         self.assertTrue(m3.getNodalConnectivity().getHiddenCppPointer()!=m.getNodalConnectivity().getHiddenCppPointer())
13305         self.assertTrue(m3.getNodalConnectivity().isEqual(m.getNodalConnectivity()))
13306         self.assertTrue(m3.getNodalConnectivityIndex().getHiddenCppPointer()!=m.getNodalConnectivityIndex().getHiddenCppPointer())
13307         self.assertTrue(m3.getNodalConnectivityIndex().isEqual(m.getNodalConnectivityIndex()))
13308         m.renumberCells(o2n)
13309         mu0.renumberCells(o2n)
13310         self.assertTrue(mu0.isEqual(m.buildUnstructured(),1e-12))
13311         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4,12,23,32,40])))
13312         self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([3,2,8,9,1,0,6,7,-1,7,6,1,2,1,7,8,-1,2,1,-1,8,-1,7,5,4,10,11,-1,11,10,-1,5,4,3,9,10,-1,5,3,9])))
13313         #
13314         mcpy0=m.buildUnstructured()
13315         self.assertTrue(isinstance(mcpy0,MEDCouplingUMesh))
13316         self.assertTrue(mcpy0.getNodalConnectivity().isEqual(DataArrayInt([31,3,2,8,9,31,1,0,6,7,-1,7,6,1,31,2,1,7,8,-1,2,1,-1,8,-1,7,31,5,4,10,11,-1,11,10,-1,5,31,4,3,9,10,-1,5,3,9])))
13317         self.assertTrue(mcpy0.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5,14,26,36,45])))
13318         self.assertEqual(mcpy0.getAllTypes(),[NORM_POLYHED])
13319         mcpy0.checkCoherency()
13320         mcpy0.checkCoherency2()
13321         mcpy1=mcpy0.convertIntoSingleGeoTypeMesh()
13322         self.assertTrue(mcpy1.isEqual(m,1e-12))
13323         #
13324         m_mrg=MEDCoupling1DGTUMesh.Merge1DGTUMeshes([m2,m,m2])
13325         self.assertTrue(m_mrg.getNodalConnectivityIndex().isEqual(DataArrayInt([0,8,19,23,31,40,44,52,63,72,80,88,99,103,111,120])))
13326         self.assertTrue(m_mrg.getNodalConnectivity().isEqual(DataArrayInt([1,0,6,7,-1,7,6,1,2,1,7,8,-1,2,1,-1,8,-1,7,3,2,8,9,4,3,9,10,-1,5,3,9,5,4,10,11,-1,11,10,-1,5,27,26,32,33,25,24,30,31,-1,31,30,25,26,25,31,32,-1,26,25,-1,32,-1,31,29,28,34,35,-1,35,34,-1,29,28,27,33,34,-1,29,27,33,49,48,54,55,-1,55,54,49,50,49,55,56,-1,50,49,-1,56,-1,55,51,50,56,57,52,51,57,58,-1,53,51,57,53,52,58,59,-1,59,58,-1,53])))
13327         m_mrg2=MEDCoupling1DGTUMesh.Merge1DGTUMeshesOnSameCoords([m3,m,m3])
13328         self.assertTrue(m_mrg2.getNodalConnectivityIndex().isEqual(DataArrayInt([0,8,19,23,31,40,44,52,63,72,80,88,99,103,111,120])))
13329         self.assertTrue(m_mrg2.getNodalConnectivity().isEqual(DataArrayInt([1,0,6,7,-1,7,6,1,2,1,7,8,-1,2,1,-1,8,-1,7,3,2,8,9,4,3,9,10,-1,5,3,9,5,4,10,11,-1,11,10,-1,5,3,2,8,9,1,0,6,7,-1,7,6,1,2,1,7,8,-1,2,1,-1,8,-1,7,5,4,10,11,-1,11,10,-1,5,4,3,9,10,-1,5,3,9,1,0,6,7,-1,7,6,1,2,1,7,8,-1,2,1,-1,8,-1,7,3,2,8,9,4,3,9,10,-1,5,3,9,5,4,10,11,-1,11,10,-1,5])))
13330         a,b=m_mrg2.getReverseNodalConnectivity()
13331         self.assertTrue(b.isEqual(DataArrayInt([0,3,15,24,33,39,48,54,66,75,84,93,99,99,99,99,99,99,99,99,99,99,99,99,99])))
13332         self.assertTrue(a.isEqual(DataArrayInt([0,6,10,0,0,1,1,6,6,7,7,10,10,11,11,1,1,2,5,7,7,11,11,12,2,3,3,5,9,9,12,13,13,3,4,8,9,13,14,3,4,4,8,8,9,13,14,14,0,0,6,6,10,10,0,0,1,1,6,6,7,7,10,10,11,11,1,1,2,5,7,7,11,11,12,2,3,3,5,9,9,12,13,13,3,4,4,8,8,9,13,14,14,4,4,8,8,14,14])))
13333         self.assertTrue(m_mrg2.fillCellIdsToKeepFromNodeIds([7],False).isEqual(DataArrayInt([0,1,6,7,10,11])))
13334         self.assertTrue(m_mrg2.fillCellIdsToKeepFromNodeIds([0,1,6,7],True).isEqual(DataArrayInt([0,6,10])))
13335         #
13336         self.assertTrue(m_mrg2.isPacked())
13337         self.assertEqual(120,m_mrg2.getNodalConnectivityIndex().popBackSilent())
13338         self.assertEqual(m_mrg2.getNumberOfCells(),14)
13339         m_mrg2.checkCoherency2()
13340         self.assertTrue(not m_mrg2.isPacked())
13341         m_mrg4,b=m_mrg2.copyWithNodalConnectivityPacked()
13342         self.assertTrue(not b)
13343         m_mrg4.checkCoherency2()
13344         self.assertEqual(m_mrg4.getNumberOfCells(),14)
13345         self.assertTrue(m_mrg4.getNodalConnectivityIndex().isEqual(m_mrg2.getNodalConnectivityIndex()))
13346         self.assertEqual(len(m_mrg4.getNodalConnectivity()),111)
13347         self.assertEqual(len(m_mrg2.getNodalConnectivity()),120)
13348         self.assertTrue(m_mrg4.getNodalConnectivity().isEqual(m_mrg2.getNodalConnectivity()[:111]))
13349         #
13350         m0=m_mrg2[:5]
13351         m1=m_mrg2[[5,6,7,8,9]]
13352         m2=m_mrg2[10:]
13353         self.assertTrue(m1.isEqualWithoutConsideringStr(m,1e-12))
13354         a,b=m.checkGeoEquivalWith(m0,12,1e-12)
13355         self.assertTrue(a.isEqual(DataArrayInt(o2n)))
13356         self.assertTrue(b is None)
13357         pass
13358
13359     def testSwig2DADAreIncludedInMe1(self):
13360         a=DataArrayDouble(30) ; a.iota() ; a.rearrange(3)
13361         p=DataArrayInt([5,2,1,9])
13362         b,c=a.areIncludedInMe(a[p],1e-12)
13363         self.assertTrue(b)
13364         self.assertTrue(c.isEqual(p))
13365         d=a[p]
13366         d.setIJ(3,1,28.1)
13367         b,c=a.areIncludedInMe(d,1e-12)
13368         self.assertTrue(not b)
13369         self.assertTrue(c.isEqual(DataArrayInt([5,2,1,10])))
13370         pass
13371
13372     def testSwig2DADesallocate1(self):
13373         d=DataArrayDouble([(1,2),(6,7),(6,8)]) ; d.setInfoOnComponents(["aa","bbb"])
13374         self.assertTrue(d.isAllocated())
13375         d.checkAllocated()
13376         self.assertEqual(d.getInfoOnComponents(),["aa","bbb"])
13377         ref=d.getHeapMemorySize()
13378         d.desallocate()
13379         self.assertEqual(ref-d.getHeapMemorySize(),6*8)
13380         self.assertTrue(not d.isAllocated())
13381         self.assertEqual(d.getInfoOnComponents(),["aa","bbb"])
13382         self.assertRaises(InterpKernelException,d.checkAllocated)
13383         #
13384         d=DataArrayInt([(1,2),(6,7),(6,8)]) ; d.setInfoOnComponents(["aa","bbb"])
13385         self.assertTrue(d.isAllocated())
13386         d.checkAllocated()
13387         self.assertEqual(d.getInfoOnComponents(),["aa","bbb"])
13388         ref=d.getHeapMemorySize()
13389         d.desallocate()
13390         self.assertEqual(ref-d.getHeapMemorySize(),6*4)
13391         self.assertTrue(not d.isAllocated())
13392         self.assertEqual(d.getInfoOnComponents(),["aa","bbb"])
13393         self.assertRaises(InterpKernelException,d.checkAllocated)
13394         pass
13395
13396     def setUp(self):
13397         pass
13398     pass
13399
13400 unittest.main()