src/MEDCoupling_Swig/MEDCouplingBasicsTest.py

   1 #  -*- coding: iso-8859-1 -*-
   2 # Copyright (C) 2007-2014  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, or (at your option) any later version.
   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, to 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.getAllGeoTypes()==[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.getAllGeoTypes()));
 389         self.assertEqual(NORM_TRI3,mesh.getAllGeoTypes()[0]);
 390         self.assertEqual(NORM_QUAD4,mesh.getAllGeoTypes()[1]);
 391         self.assertEqual(1,len(subMesh.getAllGeoTypes()));
 392         self.assertEqual(NORM_QUAD4,subMesh.getAllGeoTypes()[0]);
 393         self.assertEqual(name,"Toto");
 394         self.assertEqual(2,subMesh.getNumberOfCells());
 395         subConn=[4,0,3,4,1,4,7,8,5,4];
 396         subConnIndex=[0,5,10];
 397         self.assertEqual(10,subMesh.getNodalConnectivity().getNbOfElems());
 398         self.assertEqual(3,subMesh.getNodalConnectivityIndex().getNbOfElems());
 399         self.assertEqual(subConn[0:10],list(subMesh.getNodalConnectivity().getValues()));
 400         self.assertEqual(subConnIndex[0:3],list(subMesh.getNodalConnectivityIndex().getValues()));
 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.getAllGeoTypes()));
 406         self.assertEqual(NORM_TRI3,subMesh.getAllGeoTypes()[0]);
 407         self.assertEqual(NORM_QUAD4,subMesh.getAllGeoTypes()[1]);
 408         self.assertEqual(name,"Toto");
 409         self.assertEqual(3,subMesh.getNumberOfCells());
 410         subConn2=[4,0,3,4,1,3,4,5,2,4,6,7,4,3]
 411         subConnIndex2=[0,5,9,14]
 412         self.assertEqual(14,subMesh.getNodalConnectivity().getNbOfElems());
 413         self.assertEqual(4,subMesh.getNodalConnectivityIndex().getNbOfElems());
 414         self.assertEqual(subConn2[0:14],list(subMesh.getNodalConnectivity().getValues()));
 415         self.assertEqual(subConnIndex2[0:4],list(subMesh.getNodalConnectivityIndex().getValues()));
 416         dd=DataArrayInt.New()
 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.getAllGeoTypes()));
 430         self.assertEqual(NORM_QUAD4,subMesh.getAllGeoTypes()[0]);
 431         self.assertEqual(1,subMesh.getNumberOfCells());
 432         self.assertEqual(5,subMesh.getNodalConnectivity().getNbOfElems());
 433         self.assertEqual(2,subMesh.getNodalConnectivityIndex().getNbOfElems());
 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.getAllGeoTypes()));
 446         self.assertEqual(NORM_TRI3,subMesh.getAllGeoTypes()[0]);
 447         self.assertEqual(NORM_QUAD4,subMesh.getAllGeoTypes()[1]);
 448         self.assertEqual(3,subMesh.getNumberOfCells());
 449         self.assertEqual(14,subMesh.getNodalConnectivity().getNbOfElems());
 450         self.assertEqual(4,subMesh.getNodalConnectivityIndex().getNbOfElems());
 451         subConn2=[3,4,5,2,4,6,7,4,3,4,7,8,5,4]
 452         subConnIndex2=[0,4,9,14]
 453         self.assertEqual(subConn2[0:14],list(subMesh.getNodalConnectivity().getValues()));
 454         self.assertEqual(subConnIndex2[0:4],list(subMesh.getNodalConnectivityIndex().getValues()));
 455         #testing the case where length of tab2 is greater than max number of node per cell.
 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.getAllGeoTypes()));
 460         self.assertEqual(NORM_TRI3,subMesh.getAllGeoTypes()[0]);
 461         self.assertEqual(NORM_QUAD4,subMesh.getAllGeoTypes()[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.getAllGeoTypes()));
 468         self.assertEqual(2,mesh.getSpaceDimension());
 469         self.assertEqual(9,mesh.getNumberOfNodes());
 470         self.assertEqual(5,mesh.getNumberOfCells());
 471         oldConn=mesh.getNodalConnectivity().getValues()[0:mesh.getNodalConnectivity().getNbOfElems()];
 472         oldConnIndex=mesh.getNodalConnectivityIndex().getValues()[0:mesh.getNumberOfCells()+1]
 473         oldCoords=mesh.getCoords();
 474         mesh.zipCoords();
 475         self.assertEqual(2,len(mesh.getAllGeoTypes()));
 476         self.assertEqual(2,mesh.getSpaceDimension());
 477         self.assertEqual(9,mesh.getNumberOfNodes());
 478         self.assertEqual(5,mesh.getNumberOfCells());
 479         self.assertEqual(mesh.getCoords().getValues()[0:2*9],oldCoords.getValues());
 480         self.assertEqual(list(oldConn),list(mesh.getNodalConnectivity().getValues()));
 481         self.assertEqual(list(oldConnIndex),list(mesh.getNodalConnectivityIndex().getValues()));
 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.getAllGeoTypes()[0]);
 490         self.assertEqual(2,subMesh.getNumberOfCells());
 491         subConn=[4,0,2,3,1,4,5,6,4,3]
 492         subConnIndex=[0,5,10]
 493         self.assertEqual(7,subMesh.getNumberOfNodes());
 494         self.assertEqual(10,subMesh.getNodalConnectivity().getNbOfElems());
 495         self.assertEqual(3,subMesh.getNodalConnectivityIndex().getNbOfElems());
 496         self.assertEqual(subConn,list(subMesh.getNodalConnectivity().getValues()));
 497         self.assertEqual(subConnIndex,list(subMesh.getNodalConnectivityIndex().getValues()));
 498         #
 499         subMesh=mesh.buildPartOfMySelf(tab1,False);
 500         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
 501         self.assertEqual(NORM_QUAD4,subMesh.getAllGeoTypes()[0]);
 502         self.assertEqual(2,subMesh.getNumberOfCells());
 503         self.assertEqual(7,subMesh.getNumberOfNodes());
 504         self.assertEqual(10,subMesh.getNodalConnectivity().getNbOfElems());
 505         self.assertEqual(3,subMesh.getNodalConnectivityIndex().getNbOfElems());
 506         self.assertEqual(subConn,list(subMesh.getNodalConnectivity().getValues()));
 507         self.assertEqual(subConnIndex,list(subMesh.getNodalConnectivityIndex().getValues()));
 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(-1, dis[0][2]);
1836
1837         idsPerType=[]
1838         self.assertTrue(not mesh1.checkTypeConsistencyAndContig(dis, idsPerType));
1839         dis[0][0]=NORM_QUAD4;
1840         self.assertRaises(InterpKernelException, mesh1.checkTypeConsistencyAndContig, dis, idsPerType);
1841         dis[0][0]=NORM_HEXA8;
1842         dis[0][2]=0;
1843         ids=DataArrayInt.New();
1844         ids.alloc(10, 1);
1845         ids.fillWithValue(23);
1846         idsPerType=[ids];
1847         check=mesh1.checkTypeConsistencyAndContig(dis, idsPerType);
1848         self.assertTrue(check);
1849         self.assertTrue(check.isEqual(ids));
1850
1851         code, idsInPflPerType, pfls=mesh1.splitProfilePerType(ids);
1852         self.assertEqual(1, len(code));
1853         self.assertEqual(NORM_HEXA8, code[0][0]);
1854         self.assertEqual(10, code[0][1]);
1855         self.assertEqual(0, code[0][2]);
1856         self.assertEqual(1, len(idsInPflPerType));
1857         self.assertEqual(1, len(pfls));
1858         self.assertTrue(idsInPflPerType[0].isEqual(DataArrayInt([0,1,2,3,4,5,6,7,8,9])));
1859         self.assertTrue(pfls[0].isEqual(ids));
1860
1861         cells1=[0, 1, 25, 26]
1862         partMesh1=mesh1.buildPart(cells1)
1863         self.assertTrue(isinstance(partMesh1,MEDCouplingMesh))
1864         self.assertEqual(4, partMesh1.getNumberOfCellsWithType(NORM_HEXA8));
1865         self.assertEqual(64, mesh1.getNumberOfNodes());
1866         self.assertEqual(64, partMesh1.getNumberOfNodes());
1867
1868         cells2=[25, 26]
1869         partMesh2, arr1=mesh1.buildPartAndReduceNodes(cells2)
1870         self.assertTrue(isinstance(partMesh2,MEDCouplingCMesh))
1871         self.assertEqual(2,partMesh2.getNumberOfCellsWithType(NORM_HEXA8));
1872         self.assertEqual(12,partMesh2.getNumberOfNodes());
1873
1874         cells3=[2, 3]
1875         partMesh3, arr2=partMesh1.buildPartAndReduceNodes(cells3)
1876         self.assertTrue(isinstance(partMesh3,MEDCouplingUMesh))
1877         self.assertEqual(2, partMesh3.getNumberOfCellsWithType(NORM_HEXA8));
1878         self.assertEqual(12, partMesh3.getNumberOfNodes());
1879
1880         self.assertRaises(InterpKernelException, mesh1.simplexize, 0);
1881         self.assertRaises(InterpKernelException, mesh1.getMeasureFieldOnNode, True);
1882
1883         #double bbox1[6];
1884         #double bbox2[6];
1885         bbox1=mesh1.getBoundingBox(); #[(-1.0, 4.0), (-2.0, 8.0), (-3.0, 12.0)]
1886         bbox2=partMesh1.getBoundingBox();
1887         self.assertTrue(bbox1==bbox2);
1888         bbox1=partMesh3.getBoundingBox();
1889         bbox2=partMesh2.getBoundingBox();
1890         self.assertTrue(bbox1==bbox2);
1891
1892         self.assertRaises(InterpKernelException, mesh1.buildOrthogonalField);
1893         mesh2d=MEDCouplingCMesh.New();
1894         mesh2d.setCoords(coordsX1, coordsY1);
1895         f1=mesh2d.buildOrthogonalField();
1896
1897         pass
1898
1899     def testScale(self):
1900         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1901         pos=[0.2,0.2]
1902         mesh.scale(pos,0.5);
1903         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,
1904                    -0.05,0.45, 0.2,0.45, 0.45,0.45]
1905         val=mesh.getCoords().getValues();
1906         self.assertEqual(18,len(val))
1907         for i in xrange(18):
1908             self.assertTrue(abs(expected1[i]-val[i])<1e-12);
1909             pass
1910         pass
1911
1912     def testTryToShareSameCoords(self):
1913         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
1914         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
1915         self.assertTrue(m1.getCoords().getHiddenCppPointer()!=m2.getCoords().getHiddenCppPointer());
1916         m1.tryToShareSameCoords(m2,1e-12);
1917         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1918         m1.tryToShareSameCoords(m2,1e-12);
1919         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1920         m2.tryToShareSameCoords(m1,1e-12);
1921         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1922         #
1923         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
1924         m2=MEDCouplingDataForTest.build2DTargetMesh_2();
1925         self.assertTrue(m1.getCoords().getHiddenCppPointer()!=m2.getCoords().getHiddenCppPointer());
1926         m1.tryToShareSameCoords(m2,1e-12);
1927         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1928         m1.tryToShareSameCoords(m2,1e-12);
1929         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1930         m2.tryToShareSameCoords(m1,1e-12);
1931         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1932         #
1933         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
1934         m2=MEDCouplingDataForTest.build2DSourceMesh_1();
1935         self.assertTrue(m1.getCoords().getHiddenCppPointer()!=m2.getCoords().getHiddenCppPointer());
1936         self.assertRaises(InterpKernelException,m1.tryToShareSameCoords,m2,1e-12)
1937         pass
1938
1939     def testFindNodeOnPlane(self):
1940         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
1941         pt=[300.,300.,0.]
1942         v=[0.,0.,2.]
1943         n=mesh.findNodesOnPlane(pt,v,1e-12);
1944         self.assertEqual(9,len(n));
1945         m3dSurf=mesh.buildFacePartOfMySelfNode(n,True);
1946         self.assertTrue(isinstance(m3dSurf,MEDCouplingUMesh))
1947         me=MEDCouplingExtrudedMesh.New(mesh,m3dSurf,0);
1948         da=me.getMesh3DIds();
1949         self.assertEqual(8,me.getNumberOfCells());
1950         expected=[0,1,2,3,4,5,6,7]
1951         val=da.getValues();
1952         self.assertEqual(expected,list(val));
1953         #
1954         m3dSurf=mesh.buildFacePartOfMySelfNode(n,True);
1955         self.assertTrue(isinstance(m3dSurf,MEDCouplingUMesh))
1956         me=MEDCouplingExtrudedMesh.New(mesh,m3dSurf,0);
1957         da=me.getMesh3DIds();
1958         self.assertEqual(8,me.getNumberOfCells());
1959         expected=[0,1,2,3,4,5,6,7]
1960         val=da.getValues();
1961         self.assertEqual(expected,list(val));
1962         pass
1963
1964     def testRenumberCells(self):
1965         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1966         m2=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1967         self.assertTrue(m.isEqual(m2,0));
1968         arr=[12,3,25,2,26]
1969         m.renumberCells(arr,True);
1970         self.assertTrue(not m.isEqual(m2,0));
1971         self.assertEqual(NORM_QUAD4,m.getTypeOfCell(0));
1972         self.assertEqual(NORM_TRI3,m.getTypeOfCell(1));
1973         self.assertEqual(NORM_QUAD4,m.getTypeOfCell(2));
1974         self.assertEqual(NORM_TRI3,m.getTypeOfCell(3));
1975         self.assertEqual(NORM_QUAD4,m.getTypeOfCell(4));
1976         arr2=[5,-1,-5,4,8]
1977         m.renumberCells(arr2,True);
1978         self.assertTrue(m.isEqual(m2,0));
1979         pass
1980
1981     def testChangeSpaceDimension(self):
1982         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1983         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
1984         #
1985         self.assertEqual(3,m1.getSpaceDimension());
1986         m1.changeSpaceDimension(2);
1987         self.assertEqual(2,m1.getSpaceDimension());
1988         m1.setName(m2.getName());
1989         self.assertTrue(m1.isEqual(m2,1e-12));
1990         m1.changeSpaceDimension(3);
1991         self.assertEqual(3,m1.getSpaceDimension());
1992         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.]
1993         val=m1.getCoords().getValues();
1994         for i in xrange(27):
1995             self.assertTrue(abs(expected[i]-val[i])<1e-14);
1996             pass
1997         pass
1998
1999     def testGaussPointField1(self):
2000         _a=0.446948490915965;
2001         _b=0.091576213509771;
2002         _p1=0.11169079483905;
2003         _p2=0.0549758718227661;
2004         refCoo1=[ 0.,0., 1.,0., 0.,1. ]
2005         gsCoo1=[ 2*_b-1, 1-4*_b, 2*_b-1, 2.07*_b-1, 1-4*_b,
2006                  2*_b-1, 1-4*_a, 2*_a-1, 2*_a-1, 1-4*_a, 2*_a-1, 2*_a-1 ]
2007         wg1=[ 4*_p2, 4*_p2, 4*_p2, 4*_p1, 4*_p1, 4*_p1 ]
2008         _refCoo1=refCoo1
2009         _gsCoo1=gsCoo1
2010         _wg1=wg1
2011         #
2012         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2013         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,NO_TIME);
2014         f.setMesh(m);
2015         self.assertEqual(5,f.getNumberOfMeshPlacesExpected());
2016         self.assertEqual(0,f.getNbOfGaussLocalization());
2017         f.setGaussLocalizationOnType(NORM_TRI3,_refCoo1,_gsCoo1,_wg1);
2018         f.setGaussLocalizationOnType(NORM_TRI3,_refCoo1,_gsCoo1,_wg1); # not a bug only to check that it works well
2019         self.assertRaises(InterpKernelException,f.setGaussLocalizationOnType,NORM_QUAD4,_refCoo1,_gsCoo1,_wg1)
2020         self.assertEqual(1,f.getNbOfGaussLocalization());
2021         refCoo2=[ 0.,0., 1.,0., 1.,1., 0.,1. ]
2022         _refCoo2=refCoo2
2023         _gsCoo1=_gsCoo1[0:4]
2024         _wg1=_wg1[0:2]
2025         f.setGaussLocalizationOnType(NORM_QUAD4,_refCoo2,_gsCoo1,_wg1);
2026         self.assertEqual(2,f.getNbOfGaussLocalization());
2027         array=DataArrayDouble.New();
2028         ptr=18*2*[None]
2029         for i in xrange(18*2):
2030             ptr[i]=float(i+1)
2031         array.setValues(ptr,18,2);
2032         ptr=array.getPointer();
2033         f.setArray(array);
2034         f.setName("MyFirstFieldOnGaussPoint");
2035         f.checkCoherency();
2036         self.assertAlmostEqual(27.,f.getIJK(2,5,0),14);
2037         self.assertAlmostEqual(16.,f.getIJK(1,5,1),14);
2038         #
2039         f.clearGaussLocalizations();
2040         self.assertEqual(0,f.getNbOfGaussLocalization());
2041         self.assertRaises(InterpKernelException,f.checkCoherency);
2042         ids1=[0,1,3,4]
2043         self.assertRaises(InterpKernelException,f.setGaussLocalizationOnCells,ids1,_refCoo2,_gsCoo1,_wg1);
2044         self.assertEqual(0,f.getNbOfGaussLocalization());
2045         ids2=[0,4]
2046         f.setGaussLocalizationOnCells(ids2,_refCoo2,_gsCoo1,_wg1);
2047         self.assertEqual(1,f.getNbOfGaussLocalization());
2048         self.assertEqual(0,f.getGaussLocalizationIdOfOneCell(0));
2049         self.assertRaises(InterpKernelException,f.getGaussLocalizationIdOfOneCell,1);
2050         ids3=[1,2]
2051         f.setGaussLocalizationOnCells(ids3,_refCoo1,_gsCoo1,_wg1);
2052         self.assertEqual(2,f.getNbOfGaussLocalization());
2053         self.assertEqual(0,f.getGaussLocalizationIdOfOneCell(0));
2054         self.assertEqual(1,f.getGaussLocalizationIdOfOneCell(1));
2055         self.assertEqual(1,f.getGaussLocalizationIdOfOneCell(2));
2056         self.assertRaises(InterpKernelException,f.checkCoherency);#<- cell 3 has no localization
2057         ids4=[3]
2058         _gsCoo2=_gsCoo1;
2059         _wg2=_wg1;
2060         _gsCoo2[0]=0.8888777776666;
2061         _wg2[0]=0.1234567892377;
2062         f.setGaussLocalizationOnCells(ids4,_refCoo2,_gsCoo2,_wg2);
2063         self.assertEqual(3,f.getNbOfGaussLocalization());
2064         tmpIds=f.getCellIdsHavingGaussLocalization(0);
2065         self.assertEqual(ids2,list(tmpIds.getValues()));
2066         self.assertRaises(InterpKernelException,f.checkCoherency);#<- it's always not ok because undelying array not with the good size.
2067         array2=f.getArray().substr(0,10);
2068         f.setArray(array2);
2069         f.checkCoherency();#<- here it is OK
2070         f2=f.clone(True);
2071         self.assertTrue(f.isEqual(f2,1e-14,1e-14));
2072         gl1=f2.getGaussLocalization(0);
2073         tmp=gl1.getGaussCoord(1,1);
2074         self.assertAlmostEqual(2.07*_b-1,tmp,14);
2075         gl1.setGaussCoord(1,1,0.07);
2076         self.assertTrue(not f.isEqual(f2,1e-14,1e-14));
2077         gl1.setGaussCoord(1,1,tmp);
2078         self.assertTrue(f.isEqual(f2,1e-14,1e-14));
2079         f2.checkCoherency();
2080         pass
2081
2082     def testGaussPointNEField1(self):
2083         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2084         f=MEDCouplingFieldDouble.New(ON_GAUSS_NE,NO_TIME);
2085         f.setMesh(m);
2086         self.assertEqual(5,f.getNumberOfMeshPlacesExpected());
2087         f.setName("MyFirstFieldOnNE");
2088         f.setDescription("MyDescriptionNE");
2089         array=DataArrayDouble.New();
2090         tmp=18*2*[None]
2091         for i in xrange(18*2):
2092             tmp[i]=float(i+7)
2093             pass
2094         array.setValues(tmp,18,2);
2095         ptr=array.getPointer();
2096         f.setArray(array);
2097         #
2098         f.checkCoherency();
2099         f2=f.clone(True);
2100         self.assertTrue(f.isEqual(f2,1e-14,1e-14));
2101         self.assertAlmostEqual(21.,f.getIJK(2,0,0),14);
2102         self.assertAlmostEqual(18.,f.getIJK(1,1,1),14);
2103         pass
2104
2105     def testCellOrientation1(self):
2106         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2107         vec=[0.,0.,-1.]
2108         self.assertRaises(InterpKernelException,m.are2DCellsNotCorrectlyOriented,vec,False);
2109         m.changeSpaceDimension(3);
2110         res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2111         self.assertTrue(len(res1)==0);
2112         vec[2]=1.;
2113         res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2114         self.assertEqual(5,len(res1));
2115         #
2116         vec[2]=-1.;
2117         # connectivity inversion
2118         conn=m.getNodalConnectivity().getValues();
2119         tmp=conn[11];
2120         conn[11]=conn[12];
2121         conn[12]=tmp;
2122         m.getNodalConnectivity().setValues(conn,len(conn),1)
2123         res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2124         self.assertEqual(1,len(res1));
2125         self.assertEqual(2,res1.getValues()[0]);
2126         m.orientCorrectly2DCells(vec,False);
2127         res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2128         self.assertTrue(len(res1)==0);
2129         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
2130         m2.changeSpaceDimension(3);
2131         self.assertTrue(m.isEqual(m2,1e-12));
2132         pass
2133
2134     def testCellOrientation2(self):
2135         m2,m1=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
2136         res1=m2.arePolyhedronsNotCorrectlyOriented();
2137         self.assertEqual(6,len(res1));
2138         m2.orientCorrectlyPolyhedrons();
2139         res1=m2.arePolyhedronsNotCorrectlyOriented();
2140         self.assertTrue(len(res1)==0);
2141         m2.checkCoherency();
2142         self.assertEqual(18,m2.getNumberOfCells());
2143         cellIds2=[0,6,12]
2144         m2.convertToPolyTypes(cellIds2);
2145         m2.orientCorrectlyPolyhedrons();
2146         res1=m2.arePolyhedronsNotCorrectlyOriented();
2147         self.assertTrue(len(res1)==0);
2148         f2=m2.getMeasureField(False);
2149         f2Ptr=f2.getArray().getValues();
2150         #Test to check global reverse in MEDCouplingUMesh::tryToCorrectPolyhedronOrientation
2151         m3=MEDCouplingDataForTest.build2DTargetMesh_1();
2152         vec=[0.,0.,1.]
2153         m3.changeSpaceDimension(3);
2154         ids2=[0,1,2,3,4]
2155         m3.convertToPolyTypes(ids2);
2156         m3.orientCorrectly2DCells(vec,False);
2157         m4=MEDCouplingDataForTest.buildCU1DMesh_U();
2158         m4.changeSpaceDimension(3);
2159         center=[0.,0.,0.]
2160         vector=[0.,1.,0.]
2161         m4.rotate(center,vector,-pi/2.);
2162         m5=m3.buildExtrudedMesh(m4,0);
2163         res1=m5.arePolyhedronsNotCorrectlyOriented();
2164         self.assertEqual(15,len(res1));
2165         m5.orientCorrectlyPolyhedrons();
2166         res1=m5.arePolyhedronsNotCorrectlyOriented();
2167         self.assertTrue(len(res1)==0);
2168         f3=m5.getMeasureField(False);
2169         self.assertEqual(15,f3.getArray().getNumberOfTuples());
2170         self.assertEqual(1,f3.getNumberOfComponents());
2171         f3Ptr=f3.getArray().getValues();
2172         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];
2173         for i in xrange(15):
2174             self.assertTrue(abs(expected1[i]-f3Ptr[i])<1e-12);
2175             pass
2176         f4=m5.getBarycenterAndOwner();
2177         self.assertEqual(15,f4.getNumberOfTuples());
2178         self.assertEqual(3,f4.getNumberOfComponents());
2179         f4Ptr=f4.getValues();
2180         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];
2181         for i in xrange(45):
2182             self.assertTrue(abs(expected2[i]-f4Ptr[i])<1e-12);
2183             pass
2184         pass
2185
2186     def testCellOrientation3(self):
2187         from cmath import rect
2188
2189         c = [rect(1.0, i*pi/4.0) for i in range(8)]
2190         coords = [c[-1].real,c[-1].imag,  c[3].real,c[3].imag,
2191                    c[5].real,c[5].imag,  c[1].real,c[1].imag]
2192         connec = [0,1,2,3]
2193         baseMesh = MEDCouplingUMesh.New("circle", 2)
2194         baseMesh.allocateCells(1)
2195         meshCoords = DataArrayDouble.New(coords, 4, 2)
2196         baseMesh.setCoords(meshCoords)
2197         baseMesh.insertNextCell(NORM_QPOLYG, connec)  # a circle
2198         baseMesh.finishInsertingCells()
2199         baseMesh.changeSpaceDimension(3)
2200         Oz = [0.0, 0.0, -1.0]
2201         cell_lst = baseMesh.are2DCellsNotCorrectlyOriented(Oz, False)
2202         self.assertEqual(cell_lst.getNumberOfTuples(), 0)
2203         Oz[2] = 1.0
2204         cell_lst = baseMesh.are2DCellsNotCorrectlyOriented(Oz, False)
2205         self.assertEqual(cell_lst.getNumberOfTuples(), 1)
2206
2207     def testPolyhedronBarycenter(self):
2208         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];
2209         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];
2210         meshN=MEDCouplingUMesh.New();
2211         meshN.setName("ForBary");
2212         meshN.setMeshDimension(3);
2213         meshN.allocateCells(4);
2214         meshN.insertNextCell(NORM_POLYHED,29,connN[0:29])
2215         meshN.finishInsertingCells();
2216         myCoords=DataArrayDouble.New();
2217         myCoords.setValues(coords,9,3);
2218         meshN.setCoords(myCoords);
2219         meshN.checkCoherency();
2220         #
2221         res1=meshN.arePolyhedronsNotCorrectlyOriented();
2222         meshN.orientCorrectlyPolyhedrons();
2223         self.assertTrue(len(res1)==0);
2224         da=meshN.getBarycenterAndOwner();
2225         self.assertEqual(1,da.getNumberOfTuples());
2226         self.assertEqual(3,da.getNumberOfComponents());
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         center=[0.,0.,0.]
2234         vec=[0.,2.78,0.]
2235         da=meshN.getBarycenterAndOwner();
2236         daPtr=da.getValues();
2237         ref=meshN.getCoords().getValues()[24:];
2238         for i in xrange(3):
2239             self.assertTrue(abs(ref[i]-daPtr[i])<1e-12);
2240             pass
2241         #
2242         meshN.rotate(center,vec,pi/7.);
2243         meshN.translate(vec);
2244         da=meshN.getBarycenterAndOwner();
2245         daPtr=da.getValues();
2246         ref=meshN.getCoords().getValues()[24:];
2247         for i in xrange(3):
2248             self.assertTrue(abs(ref[i]-daPtr[i])<1e-12);
2249             pass
2250         #
2251         center2=[1.12,3.45,6.78]
2252         vec2=[4.5,9.3,2.8]
2253         meshN.rotate(center2,vec2,e);
2254         meshN.translate(vec2);
2255         da=meshN.getBarycenterAndOwner();
2256         daPtr=da.getValues();
2257         ref=meshN.getCoords().getValues()[24:];
2258         for i in xrange(3):
2259             self.assertTrue(abs(ref[i]-daPtr[i])<1e-10);
2260             pass
2261         pass
2262
2263     def testNormL12Integ1D(self):
2264         m1=MEDCouplingDataForTest.build1DTargetMesh_3();
2265         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2266         f1.setMesh(m1);
2267         array=DataArrayDouble.New();
2268         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]
2269         array.setValues(arr,m1.getNumberOfCells(),3);
2270         f1.setArray(array);
2271         #
2272         f3=m1.getBarycenterAndOwner();
2273         self.assertEqual(4,f3.getNumberOfTuples());
2274         self.assertEqual(1,f3.getNumberOfComponents());
2275         expected9=[0.75,5.105,0.8,5.155]
2276         ptr=f3.getValues();
2277         for i in xrange(4):
2278             self.assertTrue(abs(expected9[i]-ptr[i])<1e-12);
2279             pass
2280         #
2281         f2=m1.getMeasureField(False);
2282         self.assertEqual(4,f2.getArray().getNumberOfTuples());
2283         self.assertEqual(1,f2.getNumberOfComponents());
2284         expected1=[0.5,0.21,-0.6,-0.31]
2285         ptr=f2.getArray().getValues();
2286         for i in xrange(4):
2287             self.assertTrue(abs(expected1[i]-ptr[i])<1e-12);
2288             pass
2289         expected2=[0.5,0.21,0.6,0.31]
2290         f2=m1.getMeasureField(True);
2291         ptr=f2.getArray().getValues();
2292         for i in xrange(4):
2293             self.assertTrue(abs(expected2[i]-ptr[i])<1e-12);
2294             pass
2295         #integral
2296         self.assertTrue(4,f1.getNumberOfTuples())
2297         res=f1.integral(False);
2298         self.assertTrue(3,len(res))
2299         expected3=[0.9866,-0.3615,0.4217]
2300         for i in xrange(3):
2301             self.assertTrue(abs(expected3[i]-res[i])<1e-12);
2302             pass
2303         self.assertTrue(abs(expected3[0]-f1.integral(0,False))<1e-12);
2304         self.assertTrue(abs(expected3[1]-f1.integral(1,False))<1e-12);
2305         self.assertTrue(abs(expected3[2]-f1.integral(2,False))<1e-12);
2306         res=f1.integral(True);
2307         expected4=[-3.4152,8.7639,-14.6879]
2308         for i in xrange(3):
2309             self.assertTrue(abs(expected4[i]-res[i])<1e-12);
2310             pass
2311         #normL1
2312         res=f1.normL1();
2313         self.assertTrue(3,len(res))
2314         expected5=[6.979506172839505, 16.89018518518518, 27.02969135802469]
2315         for i in xrange(3):
2316             self.assertTrue(abs(expected5[i]-res[i])<1e-12);
2317             pass
2318         self.assertTrue(abs(expected5[0]-f1.normL1(0))<1e-12);
2319         self.assertTrue(abs(expected5[1]-f1.normL1(1))<1e-12);
2320         self.assertTrue(abs(expected5[2]-f1.normL1(2))<1e-12);
2321         #normL2
2322         res=f1.normL2();
2323         self.assertTrue(3,len(res))
2324         expected7=[7.090910979452395, 16.9275542960123, 27.053271464160858]
2325         for i in xrange(3):
2326             self.assertTrue(abs(expected7[i]-res[i])<1e-9);
2327             pass
2328         self.assertTrue(abs(expected7[0]-f1.normL2(0))<1e-9);
2329         self.assertTrue(abs(expected7[1]-f1.normL2(1))<1e-9);
2330         self.assertTrue(abs(expected7[2]-f1.normL2(2))<1e-9);
2331         #buildMeasureField
2332         f4=f1.buildMeasureField(False);
2333         self.assertTrue(abs(-0.2-f4.accumulate(0))<1e-12);
2334         f4=f1.buildMeasureField(True);
2335         self.assertTrue(abs(1.62-f4.accumulate(0))<1e-12);
2336         # Testing with 2D Curve
2337         m1=MEDCouplingDataForTest.build2DCurveTargetMesh_3();
2338         f2=m1.getMeasureField(False);
2339         self.assertEqual(4,f2.getArray().getNumberOfTuples());
2340         self.assertEqual(1,f2.getNumberOfComponents());
2341         ptr=f2.getArray().getValues();
2342         for i in xrange(4):
2343             self.assertTrue(abs(sqrt(2.)*expected2[i]-ptr[i])<1e-12);
2344             pass
2345         f2=m1.getMeasureField(True);
2346         self.assertEqual(4,f2.getArray().getNumberOfTuples());
2347         self.assertEqual(1,f2.getNumberOfComponents());
2348         ptr=f2.getArray().getValues();
2349         for i in xrange(4):
2350             self.assertTrue(abs(expected2[i]*sqrt(2.)-ptr[i])<1e-12);
2351             pass
2352         #bary
2353         f3=m1.getBarycenterAndOwner();
2354         self.assertEqual(4,f3.getNumberOfTuples());
2355         self.assertEqual(2,f3.getNumberOfComponents());
2356         expected10=[0.75,0.75,5.105,5.105,0.8,0.8,5.155,5.155]
2357         ptr=f3.getValues();
2358         for i in xrange(8):
2359             self.assertTrue(abs(expected10[i]-ptr[i])<1e-12);
2360             pass
2361         #
2362         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2363         f1.setMesh(m1);
2364         array=DataArrayDouble.New();
2365         array.setValues(arr,m1.getNumberOfCells(),3);
2366         f1.setArray(array);
2367         res=f1.integral(False);
2368         for i in xrange(3):
2369             self.assertTrue(abs(sqrt(2.)*expected4[i]-res[i])<1e-12);
2370             pass
2371         res=f1.integral(True);
2372         for i in xrange(3):
2373             self.assertTrue(abs(sqrt(2.)*expected4[i]-res[i])<1e-12);
2374             pass
2375         res=f1.normL1();
2376         for i in xrange(3):
2377             self.assertTrue(abs(expected5[i]-res[i])<1e-12);
2378             pass
2379         res=f1.normL2();
2380         for i in xrange(3):
2381             self.assertTrue(abs(expected7[i]-res[i])<1e-12);
2382             pass
2383         pass
2384
2385     def testAreaBary2D(self):
2386         m1=MEDCouplingDataForTest.build2DTargetMesh_3();
2387         f1=m1.getMeasureField(False);
2388         self.assertEqual(10,f1.getArray().getNumberOfTuples());
2389         self.assertEqual(1,f1.getNumberOfComponents());
2390         expected1=[-0.5,-1,-1.5,-0.5,-1,  0.5,1,1.5,0.5,1]
2391         ptr=f1.getArray().getValues();
2392         for i in xrange(10):
2393             self.assertTrue(abs(expected1[i]-ptr[i])<1e-12);
2394             pass
2395         f1=m1.getMeasureField(True);
2396         ptr=f1.getArray().getValues();
2397         for i in xrange(10):
2398             self.assertTrue(abs(abs(expected1[i])-ptr[i])<1e-12);
2399             pass
2400         f2=m1.getBarycenterAndOwner();
2401         self.assertEqual(10,f2.getNumberOfTuples());
2402         self.assertEqual(2,f2.getNumberOfComponents());
2403         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]
2404         ptr=f2.getValues();
2405         for i in xrange(20):
2406             self.assertTrue(abs(expected2[i]-ptr[i])<1e-12);
2407             pass
2408         m1.changeSpaceDimension(3);
2409         f1=m1.getMeasureField(False);
2410         self.assertEqual(10,f1.getArray().getNumberOfTuples());
2411         self.assertEqual(1,f1.getNumberOfComponents());
2412         ptr=f1.getArray().getValues();
2413         for i in xrange(10):
2414             self.assertTrue(abs(abs(expected1[i])-ptr[i])<1e-12);
2415             pass
2416         f2=m1.getBarycenterAndOwner();
2417         self.assertEqual(10,f2.getNumberOfTuples());
2418         self.assertEqual(3,f2.getNumberOfComponents());
2419         ptr=f2.getValues();
2420         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.]
2421         for i in xrange(30):
2422             self.assertTrue(abs(expected3[i]-ptr[i])<1e-12);
2423             pass
2424         pass
2425
2426     def testAreaBary3D(self):
2427         coords=[ 0.241310763507 , 0.0504777305619 , 0.0682283524903 , 0.252501053866 , -0.0625176732937 , 0.137272639894 ,
2428                  0.152262663601 , 0.241816569527 , 0.133812556197 , 0.18047750211 , -0.0789949051358 , 0.339098173401 ,
2429                  0.151741971857 , 0.238885278571 , 0.137715037333 , 0.242532155481 , -0.0928169086456 , 0.0678043417367 ,
2430                  0.240941965335 , -0.015461491464 , 0.0617186345825 , 0.24127650112 , 0.0499427876717 , 0.0679634099148 ,
2431                  -0.145828917428 , 0.206291632565 , 0.0310071927543 , 0.0125651775307 , 0.266262085828 , 0.105228430543 ,
2432                  -0.0994066533286 , 0.233224271238 , 0.0572213839567 , -0.0951345338317 , 0.234819509426 , 0.0592126284538 ,
2433                  0.136580574205 , -0.205486212579 , 0.0572866072014 , 0.0637270784978 , -0.168886355238 , 0.446614057077 ,
2434                  0.041337157151 , -0.213402568198 , 0.372407095999 , 0.0411601970268 , -0.202387875756 , 0.411334979491 ,
2435                  -0.108355701857 , 0.193636239335 , 0.204886756738 , 0.00639779029829 , 0.155296981517 , 0.252585892979 ,
2436                  0.0262473111702 , -0.112919732543 , 0.424286639249 ,-0.224103052733 , -0.139430015438 , -0.0122352295701 ,
2437                 -0.0312760589481 , -0.274272003594 , 0.0323959636568 , -0.166663422532 , -0.217754445175 , 0.00392109070364 ,
2438                  -0.30586619777 , -0.0475168041091 , -0.0144585228182 , -0.280881480586 , 0.135571293538 , 0.00623923647986 ,
2439                  -0.25548538234 , 0.156819217766 , 0.0645277879769 , -0.131567009284 , 0.184133752309 , 0.206021802753 ,
2440                  -0.196204010965 , 0.151602971681 , 0.212974777736 , -0.183713879463 , 0.0802946639531 , 0.260115662599 ,
2441                  -0.244241178767 , -0.0738873389604 , 0.144590565817 , -0.155804057829 , -0.164892720025 , 0.210613950558 ,
2442                  -0.170950800428 , -0.215099334026 , 0.00610122860092 , -0.30552634869 , -0.0490020791904 , -0.0132786533145 ,
2443                  0.271831011884 , 0.15105657296 , 0.0230534827908 , 0.281919192283 , 0.0898544306288 , -0.0625201489143 ,
2444                  0.260240727276 , -0.0120688706637 , -0.0532316588626 , 0.244947737722 , 0.0197984684293 , 0.0309341209233 ,
2445                  0.23439631578 , 0.229825279875 , 0.0508520585381 , 0.160921316875 , 0.265078502128 , 0.121716560626 ,
2446                  -0.315088694175 , 0.0747700471918 , -0.245836615071 , -0.327728781776 , 0.0857114674649 , -0.239431905957 ,
2447                  -0.308385460634 , 0.145142997084 , -0.149886828433 , 0.0488236045164 , 0.309462801914 , 0.0849169148265 ,
2448                 -0.0244964803395 , 0.33145611751 , -0.0476415818061 , 0.0060567994229 , 0.32418412014 , 0.0367779543812 ,
2449                  -0.0950221448063 , 0.236675326003 , 0.0572594453983 , 0.248723023186 , 0.0886648784791 , -0.176629430538 ,
2450                  0.116796984 , 0.256596599567 , -0.292863523603 , 0.118024552914 , 0.229154257843 , -0.34233232501 ,
2451                  0.217507892549 , -0.0417822335742 , -0.176771782888 , -0.224429321304 , 0.0125595300114 , -0.362064725588 ,
2452                  0.0937301100955 , -0.0500824832657 , -0.299713548444 , -0.244162220397 , 0.0383853931293 , -0.389856984411 ,
2453                  -0.0281989366102 , 0.097392811563 , -0.458244577284 , -0.385010847162 , 0.10122766194 , -0.140052859922 ,
2454                  -0.377936358012 , 0.110875172128 , -0.176207095463 , 0.244483045556 , -0.0991073977045 , 0.0575134372934 ,
2455                 0.262605120167 , -0.100243191645 , -0.0495620806935 , 0.240306880972 , -0.136153701579 , -0.114745281696 ,
2456                  0.215763176129 , -0.0836766059189 , -0.183249640616 , 0.237870396603 , -0.132449578286 , -0.121598854639 ,
2457                  -0.0637683083097 , -0.27921020214 , -0.149112321992 , -0.0856211014977 , -0.2973233473 , -0.0446878139589 ,
2458                  0.104675342288 , -0.0625908305324 , -0.290346256534 , 0.0248264249186 , -0.247797708548 , -0.165830884019 ,
2459                  0.0719302438309 , -0.178468260473 , -0.211432157345 , 0.142871843159 , -0.208769948542 , 0.0454101128246 ,
2460                  0.167803379307 , -0.207851396623 , -0.088802726124 , 0.12868717152 , -0.230920439715 , 0.00760508389036 ,
2461                  -0.0372812069535 , -0.286740286332 , 0.00963701291166 ]
2462
2463         connN = [ #polyhedron 0
2464             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
2465             , 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
2466             , 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
2467             , 22 , 19 , 21 , 30 , 31 , -1 , 22 , 31 , 28 , 27 , 26 , 24 , 23 , -1 , 31 , 30 , 29 , 28,
2468             # polyhedron 1
2469             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
2470             , 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
2471             , 33 , 34 , 48 , 45 , -1 , 35 , 34 , 48 , 50 , 49 , 38 , -1 , 41 , 43 , 42 , 46 , 36 , 37 , -1 , 38 , 39 , 51 , 49 , -1
2472             , 39 , 40 , 42 , 46 , 47 , 52 , 51 , -1 , 45 , 47 , 52 , 50 , 48 , -1 , 52 , 51 , 49 , 50,
2473             # polyhedron 2
2474             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
2475             , 23 , 53 , 54 , 40 , 8 , -1 , 53 , 22 , 23 , -1 , 39 , 54 , 40,
2476             # polyhedron 3
2477             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
2478             , 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
2479             , 55 , 5 , 12 , 65 , -1 , 66 , 67 , 65 , 55 , 56 , 57 , -1 , 63 , 66 , 57 , 59 , 64 , -1 , 64 , 62 , 58 , 59 , -1
2480             , 60 , 63 , 66 , 67 , 68 , 61 , -1 , 61 , 68 , 20 , 21 , -1 , 67 , 68 , 20 , 12 , 65]
2481
2482         barys = [ -0.0165220465527 , -0.0190922868195 , 0.158882733414 ,
2483                   0.0287618656076 , 0.135874379934 , -0.14601588119 ,
2484                   -0.147128055553 , 0.0465995097041 , -0.049391174453 ,
2485                   -0.00142506732317 , -0.0996953090351 , -0.115159183132 ]
2486         meshN=MEDCouplingUMesh.New();
2487         meshN.setName("ForBary");
2488         meshN.setMeshDimension(3);
2489         meshN.allocateCells(4);
2490         meshN.insertNextCell(NORM_POLYHED,113,connN);
2491         meshN.insertNextCell(NORM_POLYHED,99,connN[113:]);
2492         meshN.insertNextCell(NORM_POLYHED,43,connN[212:]);
2493         meshN.insertNextCell(NORM_POLYHED,92,connN[255:]);
2494         meshN.finishInsertingCells();
2495         myCoords=DataArrayDouble.New();
2496         myCoords.setValues(coords,69,3);
2497         meshN.setCoords(myCoords);
2498         meshN.checkCoherency();
2499         res1=meshN.arePolyhedronsNotCorrectlyOriented();
2500         meshN.orientCorrectlyPolyhedrons();
2501         res1=meshN.arePolyhedronsNotCorrectlyOriented();
2502         self.assertTrue(len(res1)==0);
2503         #
2504         da=meshN.getBarycenterAndOwner();
2505         self.assertEqual(4,da.getNumberOfTuples());
2506         self.assertEqual(3,da.getNumberOfComponents());
2507         daPtr=da.getValues();
2508         for i in xrange(12):
2509             self.assertTrue(abs(barys[i]-daPtr[i])<1e-12);
2510             pass
2511         pass
2512
2513     def testRenumberCellsForFields(self):
2514         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2515         f=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2516         f.setMesh(m);
2517         arr=DataArrayDouble.New();
2518         nbOfCells=m.getNumberOfCells();
2519         values1=[7.,107.,10007.,8.,108.,10008.,9.,109.,10009.,10.,110.,10010.,11.,111.,10011.]
2520         arr.setValues(values1,nbOfCells,3);
2521         f.setArray(arr);
2522         renumber1=[3,1,0,4,2]
2523         loc=[-0.05,-0.05, 0.55,-0.25, 0.55,0.15, -0.05,0.45, 0.45,0.45]
2524         for j in xrange(5):
2525             res=f.getValueOn(loc[2*j:2*j+2]);
2526             for i in xrange(3):
2527                 self.assertTrue(abs(values1[i+3*j]-res[i])<1e-12);
2528                 pass
2529             pass
2530         f.renumberCells(renumber1,False);
2531         ptr=f.getArray().getValues();
2532         expected1=[9.,109.,10009.,8.,108.,10008.,11.,111.,10011.,7.,107.,10007.,10.,110.,10010.]
2533         for i in xrange(15):
2534             self.assertTrue(abs(expected1[i]-ptr[i])<1e-12);
2535             pass
2536         #check that fields remains the same geometrically
2537         for j in xrange(5):
2538             res=f.getValueOn(loc[2*j:2*(j+1)]);
2539             for i in xrange(3):
2540                 self.assertTrue(abs(values1[i+3*j]-res[i])<1e-12);
2541                 pass
2542             pass
2543         #On gauss
2544         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,NO_TIME);
2545         f.setMesh(m);
2546         _a=0.446948490915965;
2547         _b=0.091576213509771;
2548         _p1=0.11169079483905;
2549         _p2=0.0549758718227661;
2550         refCoo1=[ 0.,0., 1.,0., 0.,1. ]
2551         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 ];
2552         wg1=[ 4*_p2, 4*_p2, 4*_p2, 4*_p1, 4*_p1, 4*_p1 ]
2553         _refCoo1=refCoo1[0:6];
2554         _gsCoo1=gsCoo1[0:12];
2555         _wg1=wg1[0:6];
2556         f.setGaussLocalizationOnType(NORM_TRI3,_refCoo1,_gsCoo1,_wg1);
2557         refCoo2=[ 0.,0., 1.,0., 1.,1., 0.,1. ]
2558         _refCoo2=refCoo2[0:8];
2559         _gsCoo1=_gsCoo1[0:4]
2560         _wg1=_wg1[0:2]
2561         f.setGaussLocalizationOnType(NORM_QUAD4,_refCoo2,_gsCoo1,_wg1);
2562         arr=DataArrayDouble.New();
2563         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.]
2564         arr.setValues(values2,18,2);
2565         f.setArray(arr);
2566         f.checkCoherency();
2567         fCpy=f.clone(True);
2568         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2569         f.renumberCells(renumber1,False);
2570         self.assertTrue(not f.isEqual(fCpy,1e-12,1e-12));
2571         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.]
2572         ptr=f.getArray().getValues();
2573         for i in xrange(36):
2574             self.assertTrue(abs(expected2[i]-ptr[i])<1e-12);
2575             pass
2576         renumber2=[2,1,4,0,3]
2577         f.renumberCells(renumber2,False);
2578         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2579         #GaussNE
2580         f=MEDCouplingFieldDouble.New(ON_GAUSS_NE,NO_TIME);
2581         f.setMesh(m);
2582         arr=DataArrayDouble.New();
2583         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.]
2584         arr.setValues(values3,18,2);
2585         f.setArray(arr);
2586         f.checkCoherency();
2587         fCpy=f.clone(True);
2588         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2589         f.renumberCells(renumber1,False);
2590         self.assertTrue(not f.isEqual(fCpy,1e-12,1e-12));
2591         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.]
2592         ptr=f.getArray().getValues();
2593         for i in xrange(36):
2594             self.assertTrue(abs(expected3[i]-ptr[i])<1e-12);
2595             pass
2596         f.renumberCells(renumber2,False);#perform reverse operation of renumbering to check that the resulting field is equal.
2597         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2598         #
2599         pass
2600
2601     def testRenumberNodesForFields(self):
2602         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2603         f=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
2604         f.setMesh(m);
2605         self.assertEqual(9,f.getNumberOfMeshPlacesExpected());
2606         arr=DataArrayDouble.New();
2607         nbOfNodes=m.getNumberOfNodes();
2608         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.]
2609         arr.setValues(values1,nbOfNodes,3);
2610         f.setArray(arr);
2611         f.checkCoherency();
2612         renumber1=[0,4,1,3,5,2,6,7,8]
2613         loc=[0.5432,-0.2432, 0.5478,0.1528]
2614         expected1=[9.0272, 109.0272, 10009.0272, 11.4124,111.4124,10011.4124]
2615         for j in xrange(2):
2616             res=f.getValueOn(loc[2*j:2*j+2]);
2617             for i in xrange(3):
2618                 self.assertTrue(abs(expected1[i+3*j]-res[i])<1e-12);
2619                 pass
2620             pass
2621         fCpy=f.clone(True);
2622         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2623         f.renumberNodes(renumber1);
2624         self.assertTrue(not f.isEqual(fCpy,1e-12,1e-12));
2625         for j in xrange(2):
2626             res=f.getValueOn(loc[2*j:2*j+2]);
2627             for i in xrange(3):
2628                 self.assertTrue(abs(expected1[i+3*j]-res[i])<1e-12);
2629                 pass
2630             pass
2631         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.]
2632         for i in xrange(27):
2633             self.assertTrue(abs(expected2[i]-f.getArray().getValues()[i])<1e-12);
2634             pass
2635         renumber2=[0,2,5,3,1,4,6,7,8]
2636         f.renumberNodes(renumber2);
2637         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2638         pass
2639
2640     def testConvertQuadraticCellsToLinear(self):
2641         mesh=MEDCouplingDataForTest.build2DTargetMesh_3();
2642         mesh.checkCoherency();
2643         types=mesh.getAllGeoTypes();
2644         types.sort()
2645         self.assertEqual(5,len(types));
2646         expected1=[NORM_POLYGON, NORM_TRI3, NORM_QUAD4, NORM_TRI6, NORM_QUAD8]
2647         expected1.sort()
2648         self.assertEqual(expected1,types);
2649         self.assertTrue(mesh.isPresenceOfQuadratic());
2650         self.assertEqual(62,mesh.getMeshLength());
2651         f1=mesh.getMeasureField(False);
2652         #
2653         mesh.convertQuadraticCellsToLinear();
2654         self.assertTrue(not mesh.isPresenceOfQuadratic());
2655         #
2656         mesh.checkCoherency();
2657         f2=mesh.getMeasureField(False);
2658         self.assertTrue(f1.getArray().isEqual(f2.getArray(),1e-12));
2659         self.assertEqual(48,mesh.getMeshLength());
2660         types2=mesh.getAllGeoTypes();
2661         types2.sort()
2662         self.assertEqual(3,len(types2));
2663         expected2=[NORM_POLYGON, NORM_TRI3, NORM_QUAD4]
2664         expected2.sort()
2665         self.assertEqual(expected2,types2);
2666         pass
2667
2668     def testCheckGeoEquivalWith(self):
2669         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2670         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2671         #First test mesh1
2672         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh1,0,1e-12);#deepEqual
2673         self.assertTrue(cellCor==None);
2674         self.assertTrue(nodeCor==None);
2675         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh1,1,1e-12);#fastEqual
2676         self.assertTrue(cellCor==None);
2677         self.assertTrue(nodeCor==None);
2678         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh1,10,1e-12);#deepEqual with geo permutations
2679         self.assertTrue(cellCor==None);
2680         self.assertTrue(nodeCor==None);
2681         #Second test mesh1 and mesh2 are 2 different meshes instance
2682         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,0,1e-12);#deepEqual
2683         self.assertTrue(cellCor==None);
2684         self.assertTrue(nodeCor==None);
2685         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,1,1e-12);#fastEqual
2686         self.assertTrue(cellCor==None);
2687         self.assertTrue(nodeCor==None);
2688         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);#deepEqual with geo permutations
2689         self.assertTrue(cellCor==None);
2690         self.assertTrue(nodeCor==None);
2691         #Third test : cell permutation by keeping the first the middle and the last as it is.
2692         renum=[0,2,1,3,4,5,6,8,7,9]
2693         mesh2.renumberCells(renum,False);
2694         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12);#deepEqual fails
2695         self.assertTrue(cellCor==None);
2696         self.assertTrue(nodeCor==None);
2697         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,1,1e-12);#fastEqual do not see anything
2698         self.assertTrue(cellCor==None);
2699         self.assertTrue(nodeCor==None);
2700         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);#deepEqual with geo permutations
2701         self.assertTrue(cellCor);
2702         self.assertEqual(10,cellCor.getNumberOfTuples());
2703         self.assertEqual(1,cellCor.getNumberOfComponents());
2704         self.assertEqual(renum,list(cellCor.getValues()))
2705         self.assertTrue(nodeCor==None);
2706         cellCor=0;
2707         self.assertTrue(nodeCor==None);
2708         a,b=mesh1.checkDeepEquivalWith(mesh2,0,1e-12);
2709         self.assertEqual(renum,list(a.getValues()))
2710         self.assertTrue(b==None);
2711         mesh2.setCoords(mesh1.getCoords())
2712         a=mesh1.checkDeepEquivalOnSameNodesWith(mesh2,0,1e-12);
2713         self.assertEqual(renum,list(a.getValues()))
2714         #4th test : cell and node permutation by keeping the first the middle and the last as it is.
2715         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2716         renum2=[0,2,1,3,4,5,6,8,7,9,10]
2717         mesh2.renumberCells(renum,False);
2718         mesh2.renumberNodes(renum2,11);
2719         cellCor=None
2720         nodeCor=None
2721         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12);#deepEqual fails
2722         self.assertTrue(cellCor==None);
2723         self.assertTrue(nodeCor==None);
2724         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,1,1e-12);#fastEqual do not see anything
2725         self.assertTrue(cellCor==None);
2726         self.assertTrue(nodeCor==None);
2727         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);#deepEqual with geo permutations
2728         self.assertTrue(cellCor);
2729         self.assertEqual(10,cellCor.getNumberOfTuples());
2730         self.assertEqual(1,cellCor.getNumberOfComponents());
2731         self.assertEqual(renum,list(cellCor.getValues()))
2732         self.assertTrue(nodeCor);
2733         self.assertEqual(11,nodeCor.getNumberOfTuples());
2734         self.assertEqual(1,nodeCor.getNumberOfComponents());
2735         self.assertEqual(renum2,list(nodeCor.getValues()))
2736         cellCor=0;
2737         nodeCor=0;
2738         #5th test : modification of the last cell to check fastCheck detection.
2739         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2740         renum3=[0,2,1,3,4,5,6,8,9,7]
2741         mesh2.renumberCells(renum3,False);
2742         mesh2.renumberNodes(renum2,11);
2743         cellCor=None
2744         nodeCor=None
2745         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12)
2746         self.assertTrue(cellCor==None);
2747         self.assertTrue(nodeCor==None);
2748         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,1,1e-12)
2749         self.assertTrue(cellCor==None);
2750         self.assertTrue(nodeCor==None);
2751         cellCor,nodeCor=mesh2.checkGeoEquivalWith(mesh1,10,1e-12);#deepEqual with geo permutations
2752         self.assertTrue(cellCor!=None);
2753         self.assertEqual(10,cellCor.getNumberOfTuples());
2754         self.assertEqual(1,cellCor.getNumberOfComponents());
2755         self.assertEqual(renum3,list(cellCor.getValues()))
2756         self.assertTrue(nodeCor!=None);
2757         self.assertEqual(11,nodeCor.getNumberOfTuples());
2758         self.assertEqual(1,nodeCor.getNumberOfComponents());
2759         self.assertEqual(renum2,list(nodeCor.getValues()));
2760         pass
2761
2762     def testCheckGeoEquivalWith2(self):
2763         mesh1=MEDCouplingDataForTest.build2DTargetMesh_4();
2764         mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
2765         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);
2766         self.assertEqual(None,cellCor);
2767         self.assertNotEqual(None,nodeCor);
2768         expected1=[0, 1, 3, 4, 5, 6, 7, 8, 9]
2769         for i in xrange(9):
2770             self.assertEqual(expected1[i],nodeCor.getIJ(i,0));
2771             pass
2772         pass
2773
2774     def testCopyTinyStringsFromOnFields(self):
2775         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2776         nbOfCells=m.getNumberOfCells();
2777         f=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
2778         f.setMesh(m);
2779         self.assertEqual(5,f.getNumberOfMeshPlacesExpected());
2780         f.setName("a");
2781         f.setDescription("b");
2782         a1=DataArrayDouble.New();
2783         a1.alloc(nbOfCells,2);
2784         a1.fillWithZero();
2785         a1.setInfoOnComponent(0,"c");
2786         a1.setInfoOnComponent(1,"d");
2787         a2=a1.deepCpy();
2788         a2.setInfoOnComponent(0,"e");
2789         a2.setInfoOnComponent(1,"f");
2790         f.setArray(a1);
2791         f.setEndArray(a2);
2792         f.setEndTime(3.,3,4);
2793         m.setName("g");
2794         m.getCoords().setInfoOnComponent(0,"h");
2795         m.getCoords().setInfoOnComponent(1,"i");
2796         m.getCoords().setInfoOnComponent(2,"j");
2797         #
2798         f.checkCoherency();
2799         f2=f.clone(True);
2800         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2801         f2.setName("smth");
2802         self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2803         f2.copyTinyStringsFrom(f);
2804         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2805         f2.setDescription("GGG");
2806         self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2807         f2.copyTinyStringsFrom(f);
2808         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2809         f2.getArray().setInfoOnComponent(0,"mmmm");
2810         self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2811         f2.copyTinyStringsFrom(f);
2812         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2813         f2.getEndArray().setInfoOnComponent(1,"mmmm");
2814         self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2815         f2.copyTinyStringsFrom(f);
2816         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2817         m2=m.clone(True);
2818         self.assertTrue(m2.isEqual(m,1e-12));
2819         m2.setName("123");
2820         self.assertTrue(not m2.isEqual(m,1e-12));
2821         m2.copyTinyStringsFrom(m);
2822         self.assertTrue(m2.isEqual(m,1e-12));
2823         m2.getCoords().setInfoOnComponent(1,"eee");
2824         self.assertTrue(not m2.isEqual(m,1e-12));
2825         m2.copyTinyStringsFrom(m);
2826         self.assertTrue(m2.isEqual(m,1e-12));
2827         pass
2828
2829     def testTryToShareSameCoordsPermute(self):
2830         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2831         m2=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2832         #self.assertTrue(m.getCoords()!=m2.getCoords());
2833         m.tryToShareSameCoordsPermute(m2,1e-12);
2834         #self.assertTrue(m.getCoords()==m2.getCoords());
2835         self.assertTrue(m2.isEqual(m,1e-12));
2836         renum1=[1,2,0,5,8,7,4,3,6]
2837         r1=DataArrayInt.New()
2838         r1.setValues(renum1,len(renum1),1)
2839         m.renumberNodes(r1,9);
2840         #self.assertTrue(m.getCoords()!=m2.getCoords());
2841         self.assertTrue(not m2.isEqual(m,1e-12));
2842         m.tryToShareSameCoordsPermute(m2,1e-12);
2843         #self.assertTrue(m.getCoords()==m2.getCoords());
2844         self.assertTrue(m2.isEqual(m,1e-12));
2845         pass
2846
2847     def testTryToShareSameCoordsPermute2(self):
2848         m1=MEDCouplingDataForTest.build2DTargetMesh_4();
2849         targetCoords=[-0.3,-0.3, 0.2,-0.3, -0.3,0.2, 0.2,0.2 ]
2850         targetConn=[0,2,3,1]
2851         m2=MEDCouplingUMesh.New();
2852         m2.setMeshDimension(2);
2853         m2.allocateCells(1);
2854         m2.insertNextCell(NORM_QUAD4,targetConn[0:4])
2855         m2.finishInsertingCells();
2856         myCoords=DataArrayDouble.New();
2857         myCoords.setValues(targetCoords,4,2);
2858         m2.setCoords(myCoords);
2859         m2.checkCoherency();
2860         m1.checkCoherency();
2861         #
2862         expected1=[0.25,0.125,0.125,0.25,0.25]
2863         f1=m1.getMeasureField(False);
2864         f2=m2.getMeasureField(False);
2865         self.assertEqual(5,f1.getArray().getNumberOfTuples());
2866         self.assertEqual(1,f2.getArray().getNumberOfTuples());
2867         for i in xrange(5):
2868             self.assertAlmostEqual(expected1[i],f1.getIJ(i,0),12);
2869             pass
2870         self.assertAlmostEqual(expected1[0],f2.getIJ(0,0),12);
2871         self.assertRaises(InterpKernelException,m1.tryToShareSameCoordsPermute,m2,1e-12);# <- here in this order the sharing is impossible.
2872         # Let's go for deeper test of tryToShareSameCoordsPermute
2873         m2.tryToShareSameCoordsPermute(m1,1e-12);
2874         f1=m1.getMeasureField(False);
2875         f2=m2.getMeasureField(False);
2876         self.assertEqual(5,f1.getArray().getNumberOfTuples());
2877         self.assertEqual(1,f2.getArray().getNumberOfTuples());
2878         for i in xrange(5):
2879             self.assertAlmostEqual(expected1[i],f1.getIJ(i,0),12);
2880             pass
2881         self.assertAlmostEqual(expected1[0],f2.getIJ(0,0),12);
2882         pass
2883
2884     def testChangeUnderlyingMesh1(self):
2885         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2886         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2887         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2888         f1.setMesh(mesh1);
2889         array=DataArrayDouble.New();
2890         arr=[7., 107., 8., 108., 9., 109., 10., 110., 11., 111., 12., 112., 13., 113., 14., 114., 15., 115., 16., 116.]
2891         array.setValues(arr,mesh1.getNumberOfCells(),2);
2892         f1.setArray(array);
2893         #
2894         renum=[0,2,1,3,4,5,6,8,7,9]
2895         mesh2.renumberCells(renum,False);
2896         #self.assertTrue(f1.getMesh()==mesh1);
2897         f1.changeUnderlyingMesh(mesh1,10,1e-12);# nothing done only to check that nothing done.
2898         #self.assertTrue(f1.getMesh()==mesh1);
2899         f1.changeUnderlyingMesh(mesh2,10,1e-12);
2900         #self.assertTrue(f1.getMesh()==mesh2);
2901         expected1=[7.,107.,9.,109.,8.,108.,10.,110.,11.,111.,12.,112.,13.,113.,15.,115.,14.,114.,16.,116.]
2902         for i in xrange(20):
2903             self.assertAlmostEqual(expected1[i],f1.getArray().getIJ(0,i),12);
2904             pass
2905         #
2906         f1=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
2907         f1.setMesh(mesh1);
2908         array=DataArrayDouble.New();
2909         arr2=[7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.,17.,117.]
2910         array.setValues(arr2,mesh1.getNumberOfNodes(),2);
2911         f1.setArray(array);
2912         #
2913         renum2=[0,2,10,3,4,5,6,8,7,9,1]
2914         mesh2.renumberNodes(renum2,11);
2915         #self.assertTrue(f1.getMesh()==mesh1);
2916         f1.changeUnderlyingMesh(mesh2,10,1e-12);
2917         #self.assertTrue(f1.getMesh()==mesh2);
2918         expected2=[7.,107.,17.,117.,8.,108.,10.,110.,11.,111.,12.,112.,13.,113.,15.,115.,14.,114.,16.,116.,9.,109.]
2919         for i in xrange(22):
2920             self.assertAlmostEqual(expected2[i],f1.getArray().getIJ(0,i),12);
2921             pass
2922         pass
2923
2924     def testGetMaxValue1(self):
2925         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2926         nbOfCells=m.getNumberOfCells();
2927         f=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
2928         f.setMesh(m);
2929         a1=DataArrayDouble.New();
2930         val1=[3.,4.,5.,6.,7.]
2931         a1.setValues(val1,nbOfCells,1);
2932         a2=DataArrayDouble.New();
2933         val2=[0.,1.,2.,8.,7.]
2934         a2.setValues(val2,nbOfCells,1);
2935         f.setArray(a1);
2936         f.setEndArray(a2);
2937         f.setEndTime(3.,3,4);
2938         f.checkCoherency();
2939         #
2940         self.assertAlmostEqual(8.,f.getMaxValue(),14);
2941         self.assertAlmostEqual(0.,f.getMinValue(),14);
2942         self.assertAlmostEqual(5.,f.getAverageValue(),14);
2943         self.assertAlmostEqual(5.125,f.getWeightedAverageValue(0,True),14);
2944         a1.setIJ(0,2,9.5);
2945         self.assertAlmostEqual(9.5,f.getMaxValue(),14);
2946         self.assertAlmostEqual(0.,f.getMinValue(),14);
2947         a2.setIJ(0,0,9.);
2948         self.assertAlmostEqual(9.5,f.getMaxValue(),14);
2949         self.assertAlmostEqual(1.,f.getMinValue(),14);
2950         pass
2951
2952     def testSubstractInPlaceDM1(self):
2953         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2954         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2955         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2956         f1.setMesh(mesh1);
2957         array=DataArrayDouble.New();
2958         arr=[7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.]
2959         array.setValues(arr,mesh1.getNumberOfCells(),2);
2960         f1.setArray(array);
2961         #
2962         self.assertEqual(10,f1.getNumberOfTuples());
2963         self.assertEqual(2,f1.getNumberOfComponents());
2964         self.assertEqual(20,f1.getNumberOfValues());
2965         #
2966         renum=[0,2,3,1,4,5,6,8,7,9]
2967         mesh2.renumberCells(renum,False);
2968         #
2969         f2=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2970         f2.setMesh(mesh2);
2971         array=DataArrayDouble.New();
2972         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]
2973         array.setValues(arr2,mesh2.getNumberOfCells(),2);
2974         f2.setArray(array);
2975         #
2976         f1.substractInPlaceDM(f2,10,1e-12);
2977         f1.applyFunc(1,"abs(x+y+0.2)");
2978         self.assertAlmostEqual(0.,f1.getMaxValue(),13);
2979         pass
2980
2981     def testDotCrossProduct1(self):
2982         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2983         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
2984         f1.setTime(2.3,5,6);
2985         f1.setMesh(mesh1);
2986         array=DataArrayDouble.New();
2987         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.]
2988         array.setValues(arr1,mesh1.getNumberOfCells(),3);
2989         f1.setArray(array);
2990         f2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
2991         f2.setTime(7.8,4,5);
2992         f2.setMesh(mesh1);
2993         array=DataArrayDouble.New();
2994         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.]
2995         array.setValues(arr2,mesh1.getNumberOfCells(),3);
2996         f2.setArray(array);
2997         #
2998         f3=f1.dot(f2);
2999         expected1=[842.,1820.,2816.,3830.,4862.,5912.,6980.,8066.,9170.,10292.]
3000         for i in xrange(10):
3001             self.assertAlmostEqual(expected1[i],f3.getIJ(i,0),9);
3002             pass
3003         #
3004         f4=f1.crossProduct(f2);
3005         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.]
3006         for i in xrange(30):
3007             self.assertAlmostEqual(expected2[i],f4.getIJ(0,i),9);
3008             pass
3009         pass
3010
3011     def testMinMaxFields1(self):
3012         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
3013         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3014         f1.setTime(2.3,5,6);
3015         f1.setMesh(mesh1);
3016         array=DataArrayDouble.New();
3017         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.]
3018         array.setValues(arr1,mesh1.getNumberOfCells(),3);
3019         f1.setArray(array);
3020         f2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3021         f2.setTime(7.8,4,5);
3022         f2.setMesh(mesh1);
3023         array=DataArrayDouble.New();
3024         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.]
3025         array.setValues(arr2,mesh1.getNumberOfCells(),3);
3026         f2.setArray(array);
3027         #
3028         f3=f1.max(f2);
3029         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.]
3030         for i in xrange(30):
3031             self.assertAlmostEqual(expected1[i],f3.getIJ(0,i),9);
3032             pass
3033         #
3034         f4=f1.min(f2);
3035         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.]
3036         for i in xrange(30):
3037             self.assertAlmostEqual(expected2[i],f4.getIJ(0,i),9);
3038             pass
3039         #
3040         pass
3041
3042     def testApplyLin1(self):
3043         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
3044         f1=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
3045         f1.setMesh(mesh1);
3046         array=DataArrayDouble.New();
3047         arr=[7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.]
3048         array.setValues(arr,mesh1.getNumberOfCells(),2);
3049         f1.setArray(array);
3050         #
3051         f1.applyLin(2.,3.,0);
3052         expected1=[17.,107.,19.,108.,21.,109.,23.,110.,25.,111.,27.,112.,29.,113.,31.,114.,33.,115.,35.,116.]
3053         for i in xrange(20):
3054             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),9);
3055             pass
3056         #
3057         arr2=[2.,102.,3.,103.,4.,104.,5.,105.,6.,106.,7.,107.,8.,108.,9.,109.,10.,110.,11.,111.]
3058         array=DataArrayDouble.New();
3059         array.setValues(arr2,mesh1.getNumberOfCells(),2);
3060         f1.setEndArray(array);
3061         #
3062         f1.applyLin(4.,5.,1);
3063         #
3064         expected2=[17.,433.,19.,437.,21.,441.,23.,445.,25.,449.,27.,453.,29.,457.,31.,461.,33.,465.,35.,469.]
3065         for i in xrange(20):
3066             self.assertAlmostEqual(expected2[i],f1.getIJ(0,i),9);
3067             pass
3068         expected3=[2.,413.,3.,417.,4.,421.,5.,425.,6.,429.,7.,433.,8.,437.,9.,441.,10.,445.,11.,449.]
3069         for i in xrange(20):
3070             self.assertAlmostEqual(expected3[i],f1.getEndArray().getIJ(0,i),9);
3071             pass
3072         #
3073         pass
3074
3075     def testGetIdsInRange1(self):
3076         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
3077         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3078         f1.setTime(2.3,5,6);
3079         f1.setMesh(mesh1);
3080         array=DataArrayDouble.New();
3081         arr1=[2.,8.,6.,5.,11.,7.,9.,3.,10.,4.]
3082         array.setValues(arr1,mesh1.getNumberOfCells(),1);
3083         f1.setArray(array);
3084         #
3085         f1.checkCoherency();
3086         da=f1.getIdsInRange(2.9,7.1);
3087         self.failUnlessEqual(5,da.getNbOfElems());
3088         expected1=[2,3,5,7,9]
3089         self.failUnlessEqual(expected1,list(da.getValues()));
3090         da=f1.getIdsInRange(8.,12.);
3091         self.failUnlessEqual(4,da.getNbOfElems());
3092         expected2=[1,4,6,8]
3093         self.failUnlessEqual(expected2,list(da.getValues()));
3094         #
3095         pass
3096
3097     def testBuildSubPart1(self):
3098         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3099         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3100         f1.setTime(2.3,5,6);
3101         f1.setMesh(mesh1);
3102         array=DataArrayDouble.New();
3103         arr1=[3.,103.,4.,104.,5.,105.,6.,106.,7.,107.]
3104         array.setValues(arr1,mesh1.getNumberOfCells(),2);
3105         f1.setArray(array);
3106         #
3107         part1=[2,1,4]
3108         f2=f1[part1];
3109         f2.zipCoords()
3110         self.failUnlessEqual(3,f2.getNumberOfTuples());
3111         self.failUnlessEqual(2,f2.getNumberOfComponents());
3112         expected1=[5.,105.,4.,104.,7.,107.]
3113         for i in xrange(6):
3114             self.assertAlmostEqual(f2.getIJ(0,i),expected1[i],12);
3115             pass
3116         self.failUnlessEqual(3,f2.getMesh().getNumberOfCells());
3117         self.failUnlessEqual(6,f2.getMesh().getNumberOfNodes());
3118         self.failUnlessEqual(2,f2.getMesh().getSpaceDimension());
3119         self.failUnlessEqual(2,f2.getMesh().getMeshDimension());
3120         m2C=f2.getMesh();
3121         self.failUnlessEqual(13,m2C.getMeshLength());
3122         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]
3123         for i in xrange(12):
3124             self.assertAlmostEqual(expected2[i],m2C.getCoords().getIJ(0,i),12);
3125             pass
3126         expected3=[3,2,3,1,3,0,2,1,4,4,5,3,2]
3127         self.failUnlessEqual(expected3,list(m2C.getNodalConnectivity().getValues()));
3128         expected4=[0,4,8,13]
3129         self.failUnlessEqual(expected4,list(m2C.getNodalConnectivityIndex().getValues()));
3130         # Test with field on nodes.
3131         f1=MEDCouplingFieldDouble.New(ON_NODES,ONE_TIME);
3132         f1.setTime(2.3,5,6);
3133         f1.setMesh(mesh1);
3134         array=DataArrayDouble.New();
3135         arr2=[3.,103.,4.,104.,5.,105.,6.,106.,7.,107.,8.,108.,9.,109.,10.,110.,11.,111.]
3136         array.setValues(arr2,mesh1.getNumberOfNodes(),2);
3137         f1.setArray(array);
3138         part2=[1,2]
3139         f2=f1.buildSubPart(part2);
3140         self.failUnlessEqual(4,f2.getNumberOfTuples());
3141         self.failUnlessEqual(2,f2.getNumberOfComponents());
3142         expected5=[4.,104.,5.,105.,7.,107.,8.,108.]
3143         for i in xrange(8):
3144             self.assertAlmostEqual(f2.getIJ(0,i),expected5[i],12);
3145             pass
3146         self.failUnlessEqual(2,f2.getMesh().getNumberOfCells());
3147         self.failUnlessEqual(4,f2.getMesh().getNumberOfNodes());
3148         self.failUnlessEqual(2,f2.getMesh().getSpaceDimension());
3149         self.failUnlessEqual(2,f2.getMesh().getMeshDimension());
3150         m2C=f2.getMesh();
3151         self.failUnlessEqual(8,m2C.getMeshLength());
3152         for i in xrange(8):#8 is not an error
3153             self.assertAlmostEqual(expected2[i],m2C.getCoords().getIJ(0,i),12);
3154             pass
3155         self.failUnlessEqual(expected3[:4],list(m2C.getNodalConnectivity().getValues())[4:]);
3156         self.failUnlessEqual(expected3[4:8],list(m2C.getNodalConnectivity().getValues())[:4]);
3157         self.failUnlessEqual(expected4[:3],list(m2C.getNodalConnectivityIndex().getValues()));
3158         #idem previous because nodes of cell#4 are not fully present in part3
3159         part3=[1,2]
3160         arrr=DataArrayInt.New();
3161         arrr.setValues(part3,2,1);
3162         f2=f1.buildSubPart(arrr);
3163         self.failUnlessEqual(4,f2.getNumberOfTuples());
3164         self.failUnlessEqual(2,f2.getNumberOfComponents());
3165         for i in xrange(8):
3166             self.assertAlmostEqual(f2.getIJ(0,i),expected5[i],12);
3167             pass
3168         self.failUnlessEqual(2,f2.getMesh().getNumberOfCells());
3169         self.failUnlessEqual(4,f2.getMesh().getNumberOfNodes());
3170         self.failUnlessEqual(2,f2.getMesh().getSpaceDimension());
3171         self.failUnlessEqual(2,f2.getMesh().getMeshDimension());
3172         m2C=f2.getMesh();
3173         self.failUnlessEqual(8,m2C.getMeshLength());
3174         for i in xrange(8):#8 is not an error
3175             self.assertAlmostEqual(expected2[i],m2C.getCoords().getIJ(0,i),12);
3176             pass
3177         self.failUnlessEqual(expected3[:4],list(m2C.getNodalConnectivity().getValues())[4:8]);
3178         self.failUnlessEqual(expected3[4:8],list(m2C.getNodalConnectivity().getValues())[:4]);
3179         self.failUnlessEqual(expected4[:3],list(m2C.getNodalConnectivityIndex().getValues()));
3180         #
3181         part4=[1,2,4]
3182         f2=f1.buildSubPart(part4);
3183         self.failUnlessEqual(6,f2.getNumberOfTuples());
3184         self.failUnlessEqual(2,f2.getNumberOfComponents());
3185         expected6=[4.,104.,5.,105.,7.,107.,8.,108.,10.,110.,11.,111.]
3186         for i in xrange(12):
3187             self.assertAlmostEqual(f2.getIJ(0,i),expected6[i],12);
3188             pass
3189         self.failUnlessEqual(3,f2.getMesh().getNumberOfCells());
3190         self.failUnlessEqual(6,f2.getMesh().getNumberOfNodes());
3191         self.failUnlessEqual(2,f2.getMesh().getSpaceDimension());
3192         self.failUnlessEqual(2,f2.getMesh().getMeshDimension());
3193         m2C=f2.getMesh();
3194         self.failUnlessEqual(13,m2C.getMeshLength());
3195         for i in xrange(12):
3196             self.assertAlmostEqual(expected2[i],m2C.getCoords().getIJ(0,i),12);
3197             pass
3198         self.failUnlessEqual(expected3[0:4],list(m2C.getNodalConnectivity().getValues())[4:8]);
3199         self.failUnlessEqual(expected3[4:8],list(m2C.getNodalConnectivity().getValues())[0:4]);
3200         self.failUnlessEqual(expected3[8:13],list(m2C.getNodalConnectivity().getValues())[8:13]);
3201         self.failUnlessEqual(expected4,list(m2C.getNodalConnectivityIndex().getValues()));
3202         pass
3203
3204     def testDoublyContractedProduct1(self):
3205         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3206         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3207         f1.setMesh(mesh1);
3208         array=DataArrayDouble.New();
3209         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]
3210         array.setValues(arr1,mesh1.getNumberOfCells(),6);
3211         f1.setArray(array);
3212         f1.checkCoherency();
3213         #
3214         f2=f1.doublyContractedProduct();
3215         f2.checkCoherency();
3216         self.assertEqual(1,f2.getNumberOfComponents());
3217         self.assertEqual(5,f2.getNumberOfTuples());
3218         for i in xrange(5):
3219             self.assertAlmostEqual(3906.56,f2.getIJ(i,0),9);
3220             pass
3221         #
3222         pass
3223
3224     def testDeterminant1(self):
3225         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3226         f1=MEDCouplingFieldDouble.New(ON_CELLS,CONST_ON_TIME_INTERVAL);
3227         f1.setTime(2.3,5,6);
3228         f1.setEndTime(3.8,7,3);
3229         f1.setMesh(mesh1);
3230         array=DataArrayDouble.New();
3231         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]
3232         array.setValues(arr1,mesh1.getNumberOfCells(),4);
3233         f1.setArray(array);
3234         #4 components
3235         f1.checkCoherency();
3236         f2=f1.determinant();
3237         f2.checkCoherency();
3238         self.assertEqual(CONST_ON_TIME_INTERVAL,f2.getTimeDiscretization());
3239         self.assertEqual(1,f2.getNumberOfComponents());
3240         self.assertEqual(5,f2.getNumberOfValues());
3241         for i in xrange(5):
3242             self.assertAlmostEqual(-2.42,f2.getIJ(i,0),13);
3243             pass
3244         #6 components multi arrays with end array not defined
3245         f1=MEDCouplingFieldDouble.New(ON_NODES,LINEAR_TIME);
3246         f1.setTime(2.3,5,6);
3247         f1.setEndTime(3.8,7,3);
3248         f1.setMesh(mesh1);
3249         array=DataArrayDouble.New();
3250         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,
3251               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]
3252         array.setValues(arr2,mesh1.getNumberOfNodes(),6);
3253         f1.setArray(array);
3254         self.assertRaises(InterpKernelException,f1.checkCoherency);#no end array specified !
3255         #
3256         f2=f1.determinant();
3257         self.assertEqual(LINEAR_TIME,f2.getTimeDiscretization());
3258         self.assertEqual(1,f2.getArray().getNumberOfComponents());
3259         self.assertEqual(9,f2.getNumberOfTuples());
3260         for i in xrange(9):
3261             self.assertAlmostEqual(137.335,f2.getIJ(i,0),10);
3262             pass
3263         #6 components multi arrays with end array defined
3264         array=DataArrayDouble.New();
3265         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,
3266               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]
3267         array.setValues(arr3,mesh1.getNumberOfNodes(),6);
3268         f1.setEndArray(array);
3269         f1.checkCoherency();
3270         f2=f1.determinant();
3271         f2.checkCoherency();
3272         self.assertEqual(LINEAR_TIME,f2.getTimeDiscretization());
3273         self.assertEqual(1,f2.getNumberOfComponents());
3274         self.assertEqual(9,f2.getNumberOfTuples());
3275         time2,it,order=f2.getTime()
3276         self.assertAlmostEqual(2.3,time2,12);
3277         self.assertEqual(5,it);
3278         self.assertEqual(6,order);
3279         time2,it,order=f2.getEndTime()
3280         self.assertAlmostEqual(3.8,time2,12);
3281         self.assertEqual(7,it);
3282         self.assertEqual(3,order);
3283         for i in xrange(9):
3284             self.assertAlmostEqual(137.335,f2.getIJ(i,0),10);
3285             self.assertAlmostEqual(1289.685,f2.getEndArray().getIJ(i,0),9);
3286             pass
3287         #9 components
3288         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3289         f1.setTime(7.8,10,2);
3290         f1.setMesh(mesh1);
3291         array=DataArrayDouble.New();
3292         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]
3293         array.setValues(arr4,mesh1.getNumberOfCells(),9);
3294         f1.setArray(array);
3295         #
3296         f1.checkCoherency();
3297         f2=f1.determinant();
3298         f2.checkCoherency();
3299         self.assertEqual(ONE_TIME,f2.getTimeDiscretization());
3300         self.assertEqual(1,f2.getNumberOfComponents());
3301         self.assertEqual(5,f2.getNumberOfTuples());
3302         time2,it,order=f2.getTime()
3303         self.assertAlmostEqual(7.8,time2,12);
3304         self.assertEqual(10,it);
3305         self.assertEqual(2,order);
3306         for i in xrange(5):
3307             self.assertAlmostEqual(3.267,f2.getIJ(i,0),13);
3308             pass
3309         pass
3310
3311     def testEigenValues1(self):
3312         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3313         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3314         f1.setMesh(mesh1);
3315         array=DataArrayDouble.New();
3316         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]
3317         array.setValues(arr1,mesh1.getNumberOfCells(),6);
3318         f1.setArray(array);
3319         f1.checkCoherency();
3320         #
3321         f2=f1.eigenValues();
3322         f2.checkCoherency();
3323         self.assertEqual(3,f2.getNumberOfComponents());
3324         self.assertEqual(5,f2.getNumberOfTuples());
3325         expected1=[13.638813677891717,-4.502313844635971,-2.2364998332557486]
3326         for i in xrange(5):
3327             self.assertAlmostEqual(expected1[0],f2.getIJ(i,0),13);
3328             self.assertAlmostEqual(expected1[1],f2.getIJ(i,1),13);
3329             self.assertAlmostEqual(expected1[2],f2.getIJ(i,2),13);
3330             pass
3331         pass
3332
3333     def testEigenVectors1(self):
3334         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3335         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3336         f1.setMesh(mesh1);
3337         array=DataArrayDouble.New();
3338         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]
3339         array.setValues(arr1,mesh1.getNumberOfCells(),6);
3340         f1.setArray(array);
3341         f1.checkCoherency();
3342         #
3343         f2=f1.eigenVectors();
3344         f2.checkCoherency();
3345         self.assertEqual(9,f2.getNumberOfComponents());
3346         self.assertEqual(5,f2.getNumberOfTuples());
3347         expected1=[0.5424262364180696, 0.5351201064614425, 0.6476266283176001,#eigenvect 0
3348                    0.7381111277307373, 0.06458838384003074, -0.6715804522117897,#eigenvect 1
3349                    -0.4012053603397987, 0.8423032781211455, -0.3599436712889738#eigenvect 2
3350                    ]
3351         for i in xrange(5):
3352             self.assertAlmostEqual(expected1[0],f2.getIJ(i,0),13);
3353             self.assertAlmostEqual(expected1[1],f2.getIJ(i,1),13);
3354             self.assertAlmostEqual(expected1[2],f2.getIJ(i,2),13);
3355             self.assertAlmostEqual(expected1[3],f2.getIJ(i,3),13);
3356             self.assertAlmostEqual(expected1[4],f2.getIJ(i,4),13);
3357             self.assertAlmostEqual(expected1[5],f2.getIJ(i,5),13);
3358             self.assertAlmostEqual(expected1[6],f2.getIJ(i,6),13);
3359             self.assertAlmostEqual(expected1[7],f2.getIJ(i,7),13);
3360             self.assertAlmostEqual(expected1[8],f2.getIJ(i,8),13);
3361             pass
3362         #
3363         pass
3364
3365     def testInverse1(self):
3366         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3367         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3368         f1.setMesh(mesh1);
3369         array=DataArrayDouble.New();
3370         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]
3371         array.setValues(arr1,mesh1.getNumberOfCells(),9);
3372         f1.setArray(array);
3373         f1.checkCoherency();
3374         #
3375         f2=f1.inverse();
3376         f2.checkCoherency();
3377         self.assertEqual(9,f2.getNumberOfComponents());
3378         self.assertEqual(5,f2.getNumberOfTuples());
3379         expected1=[-2.6538108356290113, 2.855831037649208, -1.1111111111111067, 3.461891643709813, -4.775022956841121, 2.2222222222222143, -1.1111111111111054, 2.222222222222214, -1.1111111111111072]
3380         for i in xrange(5):
3381             self.assertAlmostEqual(expected1[0],f2.getIJ(i,0),13);
3382             self.assertAlmostEqual(expected1[1],f2.getIJ(i,1),13);
3383             self.assertAlmostEqual(expected1[2],f2.getIJ(i,2),13);
3384             self.assertAlmostEqual(expected1[3],f2.getIJ(i,3),13);
3385             self.assertAlmostEqual(expected1[4],f2.getIJ(i,4),13);
3386             self.assertAlmostEqual(expected1[5],f2.getIJ(i,5),13);
3387             self.assertAlmostEqual(expected1[6],f2.getIJ(i,6),13);
3388             self.assertAlmostEqual(expected1[7],f2.getIJ(i,7),13);
3389             self.assertAlmostEqual(expected1[8],f2.getIJ(i,8),13);
3390             pass
3391         #
3392         array=DataArrayDouble.New();
3393         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]
3394         array.setValues(arr3,mesh1.getNumberOfCells(),6);
3395         f1.setArray(array);
3396         f1.checkCoherency();
3397         #
3398         f2=f1.inverse();
3399         f2.checkCoherency();
3400         self.assertEqual(6,f2.getNumberOfComponents());
3401         self.assertEqual(5,f2.getNumberOfTuples());
3402         expected3=[-0.3617705098531818, -0.8678630828458127, -0.026843764174972983, 0.5539957431465833, 0.13133439560823013, -0.05301294502145887]
3403         for i in xrange(5):
3404             self.assertAlmostEqual(expected3[0],f2.getIJ(i,0),13);
3405             self.assertAlmostEqual(expected3[1],f2.getIJ(i,1),13);
3406             self.assertAlmostEqual(expected3[2],f2.getIJ(i,2),13);
3407             self.assertAlmostEqual(expected3[3],f2.getIJ(i,3),13);
3408             self.assertAlmostEqual(expected3[4],f2.getIJ(i,4),13);
3409             self.assertAlmostEqual(expected3[5],f2.getIJ(i,5),13);
3410             pass
3411         #
3412         array=DataArrayDouble.New();
3413         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]
3414         array.setValues(arr2,mesh1.getNumberOfCells(),4);
3415         f1.setArray(array);
3416         f1.checkCoherency();
3417         #
3418         f2=f1.inverse();
3419         f2.checkCoherency();
3420         self.assertEqual(4,f2.getNumberOfComponents());
3421         self.assertEqual(5,f2.getNumberOfTuples());
3422         expected2=[-1.8595041322314059, 0.9504132231404963, 1.404958677685951, -0.49586776859504156]
3423         for i in xrange(5):
3424             self.assertAlmostEqual(expected2[0],f2.getIJ(i,0),13);
3425             self.assertAlmostEqual(expected2[1],f2.getIJ(i,1),13);
3426             self.assertAlmostEqual(expected2[2],f2.getIJ(i,2),13);
3427             self.assertAlmostEqual(expected2[3],f2.getIJ(i,3),13);
3428             pass
3429         #
3430         pass
3431
3432     def testTrace1(self):
3433         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3434         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3435         f1.setMesh(mesh1);
3436         array=DataArrayDouble.New();
3437         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]
3438         array.setValues(arr1,mesh1.getNumberOfCells(),9);
3439         f1.setArray(array);
3440         f1.checkCoherency();
3441         #
3442         f2=f1.trace();
3443         f2.checkCoherency();
3444         self.assertEqual(1,f2.getNumberOfComponents());
3445         self.assertEqual(5,f2.getNumberOfTuples());
3446         for i in xrange(5):
3447             self.assertAlmostEqual(15.9,f2.getIJ(i,0),13);
3448             pass
3449         #
3450         array=DataArrayDouble.New();
3451         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]
3452         array.setValues(arr3,mesh1.getNumberOfCells(),6);
3453         f1.setArray(array);
3454         f1.checkCoherency();
3455         #
3456         f2=f1.trace();
3457         f2.checkCoherency();
3458         self.assertEqual(1,f2.getNumberOfComponents());
3459         self.assertEqual(5,f2.getNumberOfTuples());
3460         for i in xrange(5):
3461             self.assertAlmostEqual(25.8,f2.getIJ(i,0),13);
3462             pass
3463         #
3464         array=DataArrayDouble.New();
3465         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]
3466         array.setValues(arr2,mesh1.getNumberOfCells(),4);
3467         f1.setArray(array);
3468         f1.checkCoherency();
3469         #
3470         f2=f1.trace();
3471         f2.checkCoherency();
3472         self.assertEqual(1,f2.getNumberOfComponents());
3473         self.assertEqual(5,f2.getNumberOfTuples());
3474         for i in xrange(5):
3475             self.assertAlmostEqual(5.7,f2.getIJ(i,0),13);
3476             pass
3477         #
3478         pass
3479
3480     def testDeviator1(self):
3481         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3482         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3483         f1.setMesh(mesh1);
3484         array=DataArrayDouble.New();
3485         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]
3486         array.setValues(arr1,mesh1.getNumberOfCells(),6);
3487         f1.setArray(array);
3488         f1.checkCoherency();
3489         #
3490         f2=f1.deviator();
3491         f2.checkCoherency();
3492         self.assertEqual(6,f2.getNumberOfComponents());
3493         self.assertEqual(5,f2.getNumberOfTuples());
3494         expected1=[-1.1,0.,1.1,4.5,5.6,6.7]
3495         for i in xrange(5):
3496             self.assertAlmostEqual(expected1[0],f2.getIJ(i,0),13);
3497             self.assertAlmostEqual(expected1[1],f2.getIJ(i,1),13);
3498             self.assertAlmostEqual(expected1[2],f2.getIJ(i,2),13);
3499             self.assertAlmostEqual(expected1[3],f2.getIJ(i,3),13);
3500             self.assertAlmostEqual(expected1[4],f2.getIJ(i,4),13);
3501             self.assertAlmostEqual(expected1[5],f2.getIJ(i,5),13);
3502             pass
3503         #
3504         pass
3505
3506     def testMagnitude1(self):
3507         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3508         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3509         f1.setMesh(mesh1);
3510         array=DataArrayDouble.New();
3511         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]
3512         array.setValues(arr1,mesh1.getNumberOfCells(),5);
3513         f1.setArray(array);
3514         f1.checkCoherency();
3515         #
3516         f2=f1.magnitude();
3517         f2.checkCoherency();
3518         self.assertEqual(1,f2.getNumberOfComponents());
3519         self.assertEqual(5,f2.getNumberOfTuples());
3520         for i in xrange(5):
3521             self.assertAlmostEqual(8.3606219864313918,f2.getIJ(i,0),13);
3522             pass
3523         #
3524         pass
3525
3526     def testMaxPerTuple1(self):
3527         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3528         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3529         f1.setMesh(mesh1);
3530         array=DataArrayDouble.New();
3531         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]
3532         array.setValues(arr1,mesh1.getNumberOfCells(),5);
3533         f1.setArray(array);
3534         f1.checkCoherency();
3535         #
3536         f2=f1.maxPerTuple();
3537         f2.checkCoherency();
3538         self.assertEqual(1,f2.getNumberOfComponents());
3539         self.assertEqual(5,f2.getNumberOfTuples());
3540         for i in xrange(5):
3541             self.assertAlmostEqual(5.6,f2.getIJ(i,0),13);
3542             pass
3543         #
3544         d2,d2I=array.maxPerTupleWithCompoId()
3545         self.assertEqual(1,d2.getNumberOfComponents());
3546         self.assertEqual(5,d2.getNumberOfTuples());
3547         for i in xrange(5):
3548             self.assertAlmostEqual(5.6,d2.getIJ(i,0),13);
3549             pass
3550         self.assertTrue(d2I.isEqual(DataArrayInt([4,3,2,0,1])))
3551         pass
3552
3553     def testChangeNbOfComponents(self):
3554         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3555         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3556         f1.setMesh(mesh1);
3557         array=DataArrayDouble.New();
3558         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]
3559         array.setValues(arr1,mesh1.getNumberOfCells(),5);
3560         f1.setArray(array);
3561         f1.checkCoherency();
3562         #
3563         f1.changeNbOfComponents(3,7.77);
3564         f1.checkCoherency();
3565         self.assertEqual(3,f1.getNumberOfComponents());
3566         self.assertEqual(5,f1.getNumberOfTuples());
3567         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]
3568         for i in xrange(15):
3569             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),13);
3570             pass
3571         f1.changeNbOfComponents(4,7.77);
3572         f1.checkCoherency();
3573         self.assertEqual(4,f1.getNumberOfComponents());
3574         self.assertEqual(5,f1.getNumberOfTuples());
3575         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]
3576         for i in xrange(20):
3577             self.assertAlmostEqual(expected2[i],f1.getIJ(0,i),13);
3578             pass
3579         #
3580         pass
3581
3582     def testSortPerTuple1(self):
3583         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3584         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3585         f1.setMesh(mesh1);
3586         array=DataArrayDouble.New();
3587         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]
3588         array.setValues(arr1,mesh1.getNumberOfCells(),5);
3589         f1.setArray(array);
3590         f1.checkCoherency();
3591         #
3592         f1.sortPerTuple(True);
3593         f1.checkCoherency();
3594         self.assertEqual(5,f1.getNumberOfComponents());
3595         self.assertEqual(5,f1.getNumberOfTuples());
3596         for i in xrange(5):
3597             self.assertAlmostEqual(arr1[0],f1.getIJ(i,0),13);
3598             self.assertAlmostEqual(arr1[1],f1.getIJ(i,1),13);
3599             self.assertAlmostEqual(arr1[2],f1.getIJ(i,2),13);
3600             self.assertAlmostEqual(arr1[3],f1.getIJ(i,3),13);
3601             self.assertAlmostEqual(arr1[4],f1.getIJ(i,4),13);
3602             pass
3603         #
3604         f1.sortPerTuple(False);
3605         f1.checkCoherency();
3606         self.assertEqual(5,f1.getNumberOfComponents());
3607         self.assertEqual(5,f1.getNumberOfTuples());
3608         for i in xrange(5):
3609             self.assertAlmostEqual(arr1[4],f1.getIJ(i,0),13);
3610             self.assertAlmostEqual(arr1[3],f1.getIJ(i,1),13);
3611             self.assertAlmostEqual(arr1[2],f1.getIJ(i,2),13);
3612             self.assertAlmostEqual(arr1[1],f1.getIJ(i,3),13);
3613             self.assertAlmostEqual(arr1[0],f1.getIJ(i,4),13);
3614             pass
3615         #
3616         pass
3617
3618     def testIsEqualWithoutConsideringStr1(self):
3619         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3620         mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
3621         #
3622         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3623         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3624         mesh2.setName("rr");
3625         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
3626         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3627         da1,da2=mesh1.checkGeoEquivalWith(mesh2,2,1e-12);
3628         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12);
3629         mesh2.setName("");
3630         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3631         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3632         mesh2.getCoords().setInfoOnComponent(0,"tty");
3633         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
3634         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3635         mesh2.getCoords().setInfoOnComponent(0,"");
3636         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3637         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3638         mesh2.getCoords().setInfoOnComponent(1,"tty");
3639         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
3640         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3641         mesh2.getCoords().setInfoOnComponent(1,"");
3642         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3643         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3644         tmp=mesh2.getCoords().getIJ(0,3);
3645         mesh2.getCoords().setIJ(0,3,9999.);
3646         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
3647         self.assertTrue(not mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3648         mesh2.getCoords().setIJ(0,3,tmp);
3649         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3650         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3651         tmp2=mesh2.getNodalConnectivity().getIJ(0,4);
3652         mesh2.getNodalConnectivity().setIJ(0,4,0);
3653         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
3654         self.assertTrue(not mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3655         mesh2.getNodalConnectivity().setIJ(0,4,tmp2);
3656         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3657         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3658         #
3659         f1=mesh1.getMeasureField(True);
3660         f2=mesh2.getMeasureField(True);
3661         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
3662         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3663         f2.setName("ftest");
3664         self.assertTrue(not f1.isEqual(f2,1e-12,1e-12));
3665         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3666         f1.setName("ftest");
3667         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
3668         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3669         #
3670         f2.getArray().setInfoOnComponent(0,"eee");
3671         self.assertTrue(not f1.isEqual(f2,1e-12,1e-12));
3672         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3673         f2.getArray().setInfoOnComponent(0,"");
3674         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
3675         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3676         #
3677         f2.getArray().setIJ(1,0,0.123);
3678         self.assertTrue(not f1.isEqual(f2,1e-12,1e-12));
3679         self.assertTrue(not f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3680         f2.getArray().setIJ(1,0,0.125);
3681         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
3682         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3683         #
3684         pass
3685
3686     def testGetNodeIdsOfCell1(self):
3687         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3688         li=mesh1.getNodeIdsOfCell(1)
3689         expected1=[1, 4, 2]
3690         self.assertEqual(expected1,list(li))
3691         li=mesh1.getCoordinatesOfNode(4)
3692         self.assertEqual(2,len(li))
3693         self.assertAlmostEqual(0.2,li[0],13);
3694         self.assertAlmostEqual(0.2,li[1],13);
3695         li=mesh1.getCoords().getValuesAsTuple()
3696         self.assertEqual(9,len(li))
3697         li2=mesh1.getNodalConnectivityIndex().getValuesAsTuple()
3698         self.assertEqual(6,len(li2))
3699         pass
3700
3701     def testGetEdgeRatioField1(self):
3702         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
3703         m1.setTime(3.4,5,6); m1.setTimeUnit("us");
3704         f1=m1.getEdgeRatioField();
3705         self.assertAlmostEqual(3.4,f1.getTime()[0],12) ; self.assertEqual(5,f1.getTime()[1]) ; self.assertEqual(6,f1.getTime()[2])
3706         self.assertEqual("us",f1.getTimeUnit())
3707         self.assertEqual(m1.getNumberOfCells(),f1.getNumberOfTuples());
3708         self.assertEqual(5,f1.getNumberOfTuples());
3709         self.assertEqual(1,f1.getNumberOfComponents());
3710         expected1=[1.,1.4142135623730951, 1.4142135623730951,1.,1.]
3711         for i in xrange(5):
3712             self.assertAlmostEqual(expected1[i],f1.getIJ(i,0),14);
3713             pass
3714         #
3715         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
3716         f1=m1.getEdgeRatioField();
3717         self.assertEqual(m1.getNumberOfCells(),f1.getNumberOfTuples());
3718         self.assertEqual(5,f1.getNumberOfTuples());
3719         self.assertEqual(1,f1.getNumberOfComponents());
3720         expected2=[1.4142135623730951, 1.7320508075688772, 1.7320508075688772, 1.4142135623730951, 1.4142135623730951]
3721         for i in xrange(5):
3722             self.assertAlmostEqual(expected2[i],f1.getIJ(i,0),14);
3723             pass
3724         pass
3725
3726     def testFillFromAnalytic3(self):
3727         m=MEDCouplingDataForTest.build2DTargetMesh_1()
3728         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME)
3729         self.assertRaises(InterpKernelException,f1.fillFromAnalytic,1,"y+x");
3730         f1.setMesh(m)
3731         f1.setName("myField");
3732         f1.fillFromAnalytic(1,"y+x");
3733         f1.checkCoherency();
3734         self.assertEqual(f1.getName(),"myField");
3735         self.assertEqual(f1.getTypeOfField(),ON_CELLS);
3736         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
3737         self.assertEqual(1,f1.getNumberOfComponents());
3738         self.assertEqual(5,f1.getNumberOfTuples());
3739         values1=[-0.1,0.23333333333333336,0.56666666666666665,0.4,0.9]
3740         tmp=f1.getArray().getValues();
3741         self.assertEqual(len(values1),len(tmp))
3742         for i in xrange(len(values1)):
3743             self.assertTrue(abs(values1[i]-tmp[i])<1.e-12);
3744             pass
3745         #
3746         f1=MEDCouplingFieldDouble.New(ON_NODES,CONST_ON_TIME_INTERVAL)
3747         f1.setMesh(m)
3748         f1.fillFromAnalytic(1,"y+2*x");
3749         f1.setEndTime(1.2,3,4);
3750         f1.checkCoherency();
3751         self.assertEqual(f1.getTypeOfField(),ON_NODES);
3752         self.assertEqual(f1.getTimeDiscretization(),CONST_ON_TIME_INTERVAL);
3753         self.assertEqual(1,f1.getNumberOfComponents());
3754         self.assertEqual(9,f1.getNumberOfTuples());
3755         values2=[-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1]
3756         tmp=f1.getArray().getValues();
3757         self.assertEqual(len(values2),len(tmp))
3758         for i in xrange(len(values2)):
3759             self.assertTrue(abs(values2[i]-tmp[i])<1.e-12);
3760             pass
3761         f1=MEDCouplingFieldDouble.New(ON_NODES,LINEAR_TIME);
3762         f1.setMesh(m)
3763         f1.fillFromAnalytic(1,"2.*x+y");
3764         f1.setEndTime(1.2,3,4);
3765         f1.checkCoherency();
3766         self.assertEqual(f1.getTypeOfField(),ON_NODES);
3767         self.assertEqual(f1.getTimeDiscretization(),LINEAR_TIME);
3768         self.assertEqual(1,f1.getNumberOfComponents());
3769         self.assertEqual(9,f1.getNumberOfTuples());
3770         tmp=f1.getArray().getValues();
3771         values2Bis=[-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1]
3772         self.assertEqual(len(values2Bis),len(tmp))
3773         for i in xrange(len(values2Bis)):
3774             self.assertTrue(abs(values2Bis[i]-tmp[i])<1.e-12);
3775             pass
3776         tmp=f1.getEndArray().getValues();
3777         self.assertEqual(len(values2Bis),len(tmp))
3778         for i in xrange(len(values2Bis)):
3779             self.assertTrue(abs(values2Bis[i]-tmp[i])<1.e-12);
3780             pass
3781         #
3782         f1=MEDCouplingFieldDouble.New(ON_NODES,ONE_TIME);
3783         f1.setMesh(m)
3784         f1.fillFromAnalytic(2,"(x+y)*IVec+2*(x+y)*JVec");
3785         f1.checkCoherency();
3786         self.assertEqual(f1.getTypeOfField(),ON_NODES);
3787         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
3788         self.assertEqual(2,f1.getNumberOfComponents());
3789         self.assertEqual(9,f1.getNumberOfTuples());
3790         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]
3791         tmp=f1.getArray().getValues();
3792         self.assertEqual(len(values3),len(tmp))
3793         for i in xrange(len(values3)):
3794             self.assertTrue(abs(values3[i]-tmp[i])<1.e-12);
3795             pass
3796         values4=f1.accumulate();
3797         self.assertTrue(abs(3.6-values4[0])<1.e-12);
3798         self.assertTrue(abs(7.2-values4[1])<1.e-12);
3799         values4=f1.integral(True);
3800         self.assertTrue(abs(0.5-values4[0])<1.e-12);
3801         self.assertTrue(abs(1.-values4[1])<1.e-12);
3802         #
3803         f1=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
3804         f1.setMesh(m);
3805         self.assertRaises(InterpKernelException,f1.fillFromAnalytic,1,"1./(x-0.2)");
3806         pass
3807
3808     def testFieldDoubleOpEqual1(self):
3809         m=MEDCouplingDataForTest.build2DTargetMesh_1();
3810         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3811         self.assertRaises(InterpKernelException,f1.assign,0.07);
3812         f1.setMesh(m);
3813         f1.assign(0.07);
3814         f1.checkCoherency();
3815         self.assertEqual(1,f1.getNumberOfComponents());
3816         self.assertEqual(5,f1.getNumberOfTuples());
3817         for i in xrange(5):
3818             self.assertAlmostEqual(0.07,f1.getIJ(i,0),16);
3819             pass
3820         f1.assign(0.09);
3821         f1.checkCoherency();
3822         self.assertEqual(1,f1.getNumberOfComponents());
3823         self.assertEqual(5,f1.getNumberOfTuples());
3824         for i in xrange(5):
3825             self.assertAlmostEqual(0.09,f1.getIJ(i,0),16);
3826             pass
3827         #
3828         f1=MEDCouplingFieldDouble.New(ON_NODES,LINEAR_TIME);
3829         f1.setEndTime(4.5,2,3);
3830         f1.setMesh(m);
3831         f1.assign(0.08);
3832         f1.checkCoherency();
3833         self.assertEqual(1,f1.getNumberOfComponents());
3834         self.assertEqual(9,f1.getNumberOfTuples());
3835         for i in xrange(9):
3836             self.assertAlmostEqual(0.08,f1.getIJ(i,0),16);
3837             pass
3838         self.assertEqual(1,f1.getEndArray().getNumberOfComponents());
3839         self.assertEqual(9,f1.getEndArray().getNumberOfTuples());
3840         for i in xrange(9):
3841             self.assertAlmostEqual(0.08,f1.getEndArray().getIJ(i,0),16);
3842             pass
3843         pass
3844
3845     def testAreaBary3D2(self):
3846         coordsForHexa8=[-75.45749305371, 180.95495078401, 39.515472018008,
3847                         -9.755591679144, 23.394927935279, 5.108794294848,
3848                         14.337630157832, 61.705351002702, 160.42422501908,
3849                         -27.273893776752, 167.567731083961, 192.830034145464,
3850                         99.857193154796,264.499264735586,-8.287335493412,
3851                         144.939882761126,156.38626563134,-31.896173894226,
3852                         161.34096835726,182.4654895809,73.832387065572,
3853                         132.680430393685,255.37973247196,96.15235602819];
3854         volHexa8=3258520.29637466;
3855         baryHexa8=[43.925705821778, 155.31893955289, 65.874418109644]
3856
3857         coordsForPenta6=[-68.199829618726,178.938498373416,62.608505919588,
3858                          8.461744647847,76.653979804423,165.00018874933,
3859                          -27.273893776752,167.567731083961,192.830034145464,
3860                          106.586501038965,262.629609408327,13.124533008813,
3861                          155.465082847275,197.414118382622,78.408350795821,
3862                          132.680430393685,255.37973247196,96.15235602819];
3863         volPenta6=944849.868507338;
3864         baryPenta6=[39.631002313543,182.692711783428,106.98540473964]
3865
3866         coordsForPyra5=[132.680430393685,255.37973247196,96.15235602819,
3867                         -27.273893776752,167.567731083961,192.830034145464,
3868                         8.461744647847,76.653979804423,165.00018874933,
3869                         155.465082847275,197.414118382622,78.408350795821,
3870                         -68.199829618726,178.938498373416,62.608505919588];
3871         volPyra5=756943.92980254;
3872         baryPyra5=[29.204294116618,172.540129749156,118.01035951483]
3873         mesh=MEDCouplingUMesh.New("Bary3D2",3);
3874         coo=DataArrayDouble.New();
3875         tmp=coordsForHexa8+coordsForPenta6+coordsForPyra5
3876         coo.setValues(tmp,19,3);
3877         mesh.setCoords(coo);
3878         #
3879         tmpConn=[0,1,2,3,4,5,6,7]
3880         mesh.allocateCells(3);
3881         self.assertRaises(InterpKernelException,mesh.insertNextCell,NORM_HEXA8,9,tmpConn[0:8])
3882         mesh.insertNextCell(NORM_HEXA8,tmpConn[0:8])
3883         mesh.insertNextCell(NORM_PENTA6,6,[i+8 for i in tmpConn])
3884         mesh.insertNextCell(NORM_PYRA5,5,[i+14 for i in tmpConn])
3885         mesh.finishInsertingCells();
3886         mesh.checkCoherency();
3887         mesh.mergeNodes(1e-7)
3888         self.assertEqual(12,mesh.getNumberOfNodes());
3889         vols=mesh.getMeasureField(True);
3890         self.assertEqual(3,vols.getNumberOfTuples());
3891         self.assertEqual(1,vols.getNumberOfComponents());
3892         self.assertAlmostEqual(volHexa8,vols.getIJ(0,0),6);
3893         self.assertAlmostEqual(volPenta6,vols.getIJ(1,0),7);
3894         self.assertAlmostEqual(volPyra5,vols.getIJ(2,0),7);
3895         bary=mesh.getBarycenterAndOwner();
3896         self.assertEqual(3,bary.getNumberOfTuples());
3897         self.assertEqual(3,bary.getNumberOfComponents());
3898         self.assertAlmostEqual(baryHexa8[0],bary.getIJ(0,0),11);
3899         self.assertAlmostEqual(baryHexa8[1],bary.getIJ(0,1),11);
3900         self.assertAlmostEqual(baryHexa8[2],bary.getIJ(0,2),11);
3901         self.assertAlmostEqual(baryPenta6[0],bary.getIJ(1,0),11);
3902         self.assertAlmostEqual(baryPenta6[1],bary.getIJ(1,1),11);
3903         self.assertAlmostEqual(baryPenta6[2],bary.getIJ(1,2),11);
3904         self.assertAlmostEqual(baryPyra5[0],bary.getIJ(2,0),11);
3905         self.assertAlmostEqual(baryPyra5[1],bary.getIJ(2,1),11);
3906         self.assertAlmostEqual(baryPyra5[2],bary.getIJ(2,2),11);
3907         pass
3908
3909     def testGetMeasureFieldCMesh1(self):
3910         m=MEDCouplingCMesh.New();
3911         da=DataArrayDouble.New();
3912         discX=[2.3,3.4,5.8,10.2]
3913         discY=[12.3,23.4,45.8]
3914         discZ=[-0.7,1.2,1.25,2.13,2.67]
3915         da.setValues(discX,4,1);
3916         m.setCoordsAt(0,da);
3917         m.checkCoherency();
3918         self.assertEqual(4,m.getNumberOfNodes());
3919         self.assertEqual(3,m.getNumberOfCells());
3920         self.assertEqual(1,m.getSpaceDimension());
3921         f=m.getMeasureField(True);
3922         self.assertEqual(3,f.getNumberOfTuples());
3923         self.assertEqual(1,f.getNumberOfComponents());
3924         expected1=[1.1,2.4,4.4]
3925         for i in xrange(3):
3926             self.assertAlmostEqual(expected1[i],f.getIJ(i,0),12);
3927             pass
3928         coords=m.getCoordinatesAndOwner();
3929         self.assertEqual(4,coords.getNumberOfTuples());
3930         self.assertEqual(1,coords.getNumberOfComponents());
3931         for i in xrange(4):
3932             self.assertAlmostEqual(discX[i],coords.getIJ(i,0),12);
3933             pass
3934         coords=m.getBarycenterAndOwner();
3935         self.assertEqual(3,coords.getNumberOfTuples());
3936         self.assertEqual(1,coords.getNumberOfComponents());
3937         expected1_3=[2.85,4.6,8.]
3938         for i in xrange(3):
3939             self.assertAlmostEqual(expected1_3[i],coords.getIJ(i,0),12);
3940             pass
3941         #
3942         da=DataArrayDouble.New();
3943         da.setValues(discY,3,1);
3944         m.setCoordsAt(1,da);
3945         m.checkCoherency();
3946         self.assertEqual(12,m.getNumberOfNodes());
3947         self.assertEqual(6,m.getNumberOfCells());
3948         self.assertEqual(2,m.getSpaceDimension());
3949         f=m.getMeasureField(True);
3950         self.assertEqual(6,f.getNumberOfTuples());
3951         self.assertEqual(1,f.getNumberOfComponents());
3952         expected2=[12.21,26.64,48.84,24.64,53.76,98.56]
3953         for i in xrange(6):
3954             self.assertAlmostEqual(expected2[i],f.getIJ(i,0),12);
3955             pass
3956         coords=m.getCoordinatesAndOwner();
3957         self.assertEqual(12,coords.getNumberOfTuples());
3958         self.assertEqual(2,coords.getNumberOfComponents());
3959         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]
3960         for i in xrange(24):
3961             self.assertAlmostEqual(expected2_2[i],coords.getIJ(0,i),12);
3962             pass
3963         coords=m.getBarycenterAndOwner();
3964         self.assertEqual(6,coords.getNumberOfTuples());
3965         self.assertEqual(2,coords.getNumberOfComponents());
3966         expected2_3=[2.85,17.85,4.6,17.85,8.,17.85, 2.85,34.6,4.6,34.6,8.,34.6]
3967         for i in xrange(12):
3968             self.assertAlmostEqual(expected2_3[i],coords.getIJ(0,i),12);
3969             pass
3970         #
3971         da=DataArrayDouble.New();
3972         da.setValues(discZ,5,1);
3973         m.setCoordsAt(2,da);
3974         m.checkCoherency();
3975         self.assertEqual(60,m.getNumberOfNodes());
3976         self.assertEqual(24,m.getNumberOfCells());
3977         self.assertEqual(3,m.getSpaceDimension());
3978         f=m.getMeasureField(True);
3979         self.assertEqual(24,f.getNumberOfTuples());
3980         self.assertEqual(1,f.getNumberOfComponents());
3981         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]
3982         for i in xrange(24):
3983             self.assertAlmostEqual(expected3[i],f.getIJ(i,0),12);
3984             pass
3985         coords=m.getCoordinatesAndOwner();
3986         self.assertEqual(60,coords.getNumberOfTuples());
3987         self.assertEqual(3,coords.getNumberOfComponents());
3988         expected3_2=[
3989             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,
3990             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,
3991             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,
3992             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,
3993             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];
3994         for i in xrange(180):
3995             self.assertAlmostEqual(expected3_2[i],coords.getIJ(0,i),12);
3996             pass
3997         coords=m.getBarycenterAndOwner();
3998         self.assertEqual(24,coords.getNumberOfTuples());
3999         self.assertEqual(3,coords.getNumberOfComponents());
4000         expected3_3=[
4001             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,
4002             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,
4003             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,
4004             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];
4005         for i in xrange(72):
4006             self.assertAlmostEqual(expected3_3[i],coords.getIJ(0,i),12);
4007             pass
4008         pass
4009
4010     def testFieldDoubleZipCoords1(self):
4011         m=MEDCouplingDataForTest.build2DTargetMeshMergeNode_1();
4012         f=m.fillFromAnalytic(ON_NODES,2,"x*2.");
4013         f.getArray().setInfoOnComponent(0,"titi");
4014         f.getArray().setInfoOnComponent(1,"tutu");
4015         f.checkCoherency();
4016         self.assertEqual(18,f.getNumberOfTuples());
4017         self.assertEqual(2,f.getNumberOfComponents());
4018         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]
4019         for i in xrange(36):
4020             self.assertAlmostEqual(expected1[i],f.getIJ(0,i),12);
4021             pass
4022         self.assertTrue(f.zipCoords());
4023         f.checkCoherency();
4024         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]
4025         for i in xrange(30):
4026             self.assertAlmostEqual(expected2[i],f.getIJ(0,i),12);
4027             pass
4028         self.assertTrue(not f.zipCoords());
4029         f.checkCoherency();
4030         for i in xrange(30):
4031             self.assertAlmostEqual(expected2[i],f.getIJ(0,i),12);
4032             pass
4033         self.assertTrue(f.getArray().getInfoOnComponent(0)=="titi");
4034         self.assertTrue(f.getArray().getInfoOnComponent(1)=="tutu");
4035         pass
4036
4037     def testFieldDoubleZipConnectivity1(self):
4038         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
4039         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
4040         cells1=[2,3,4]
4041         m3_1=m2.buildPartOfMySelf(cells1,True);
4042         m3=m3_1;
4043         m4=MEDCouplingDataForTest.build2DSourceMesh_1();
4044         m5=MEDCouplingUMesh.MergeUMeshes(m1,m3);
4045         m6=MEDCouplingUMesh.MergeUMeshes(m5,m4);
4046         #
4047         self.assertEqual(10,m6.getNumberOfCells());
4048         self.assertEqual(22,m6.getNumberOfNodes());
4049         arr,areNodesMerged,newNbOfNodes=m6.mergeNodes(1e-13);
4050         self.assertEqual(9,m6.getNumberOfNodes());
4051         f=m6.fillFromAnalytic(ON_CELLS,2,"x");
4052         f2=m6.fillFromAnalytic(ON_NODES,2,"x");
4053         self.assertEqual(10,f.getNumberOfTuples());
4054         self.assertEqual(2,f.getNumberOfComponents());
4055         expected1=[-0.05, -0.05, 0.3666666666666667, 0.3666666666666667, 0.53333333333333321, 0.53333333333333321,
4056                    -0.05, -0.05, 0.45, 0.45, 0.53333333333333321, 0.53333333333333321, -0.05, -0.05, 0.45, 0.45,
4057                    0.36666666666666659, 0.36666666666666659, 0.033333333333333326, 0.033333333333333326];
4058         for i in xrange(20):
4059             self.assertAlmostEqual(expected1[i],f.getIJ(0,i),12);
4060             pass
4061         f.getArray().setInfoOnComponent(0,"titi");
4062         f.getArray().setInfoOnComponent(1,"tutu");
4063         f.checkCoherency();
4064         self.assertTrue(f.zipConnectivity(0));
4065         expected2=[-0.05, -0.05, 0.3666666666666667, 0.3666666666666667, 0.53333333333333321, 0.53333333333333321,
4066                    -0.05, -0.05, 0.45, 0.45, 0.36666666666666659, 0.36666666666666659, 0.033333333333333326, 0.033333333333333326];
4067         self.assertEqual(7,f.getNumberOfTuples());
4068         self.assertEqual(2,f.getNumberOfComponents());
4069         for i in xrange(14):
4070             self.assertAlmostEqual(expected2[i],f.getIJ(0,i),12);
4071             pass
4072         self.assertTrue(f.getArray().getInfoOnComponent(0)=="titi");
4073         self.assertTrue(f.getArray().getInfoOnComponent(1)=="tutu");
4074         self.assertTrue(not f.zipConnectivity(0));
4075         #
4076         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,
4077                    -0.3, -0.3, 0.2, 0.2, 0.7, 0.7];
4078         self.assertEqual(9,f2.getNumberOfTuples());
4079         self.assertEqual(2,f2.getNumberOfComponents());
4080         for i in xrange(18):
4081             self.assertAlmostEqual(expected3[i],f2.getIJ(0,i),12);
4082             pass
4083         self.assertTrue(f2.zipConnectivity(0));
4084         self.assertEqual(9,f2.getNumberOfTuples());
4085         self.assertEqual(2,f2.getNumberOfComponents());
4086         for i in xrange(18):
4087             self.assertAlmostEqual(expected3[i],f2.getIJ(0,i),12);
4088             pass
4089         pass
4090
4091     def testDaDoubleRenumber1(self):
4092         a=DataArrayDouble.New();
4093         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]
4094         a.setValues(arr1,7,2);
4095         a.setInfoOnComponent(0,"toto");
4096         a.setInfoOnComponent(1,"tata");
4097         #
4098         arr2=[3,1,0,6,5,4,2]
4099         b=a.renumber(arr2);
4100         self.assertEqual(7,b.getNumberOfTuples());
4101         self.assertEqual(2,b.getNumberOfComponents());
4102         self.assertTrue(b.getInfoOnComponent(0)=="toto");
4103         self.assertTrue(b.getInfoOnComponent(1)=="tata");
4104         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]
4105         for i in xrange(14):
4106             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
4107             pass
4108         #
4109         c=DataArrayInt.New();
4110         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4111         c.setValues(arr3,7,2);
4112         c.setInfoOnComponent(0,"toto");
4113         c.setInfoOnComponent(1,"tata");
4114         d=c.renumber(arr2);
4115         self.assertEqual(7,d.getNumberOfTuples());
4116         self.assertEqual(2,d.getNumberOfComponents());
4117         self.assertTrue(d.getInfoOnComponent(0)=="toto");
4118         self.assertTrue(d.getInfoOnComponent(1)=="tata");
4119         expected2=[3, 13, 2, 12, 7, 17, 1, 11, 6, 16, 5, 15, 4, 14]
4120         for i in xrange(14):
4121             self.assertEqual(expected2[i],d.getIJ(0,i));
4122             pass
4123         pass
4124
4125     def testDaDoubleRenumberAndReduce1(self):
4126         a=DataArrayDouble.New();
4127         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]
4128         a.setValues(arr1,7,2);
4129         a.setInfoOnComponent(0,"toto");
4130         a.setInfoOnComponent(1,"tata");
4131         #
4132         arr2=[2,-1,1,-1,0,4,3]
4133         b=a.renumberAndReduce(arr2,5);
4134         self.assertEqual(5,b.getNumberOfTuples());
4135         self.assertEqual(2,b.getNumberOfComponents());
4136         self.assertTrue(b.getInfoOnComponent(0)=="toto");
4137         self.assertTrue(b.getInfoOnComponent(1)=="tata");
4138         expected1=[5.1,15.1,3.1,13.1,1.1,11.1,7.1,17.1,6.1,16.1]
4139         for i in xrange(10):
4140             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
4141             pass
4142         #
4143         c=DataArrayInt.New();
4144         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4145         c.setValues(arr3,7,2);
4146         c.setInfoOnComponent(0,"toto");
4147         c.setInfoOnComponent(1,"tata");
4148         d=c.renumberAndReduce(arr2,5);
4149         self.assertEqual(5,d.getNumberOfTuples());
4150         self.assertEqual(2,d.getNumberOfComponents());
4151         self.assertTrue(d.getInfoOnComponent(0)=="toto");
4152         self.assertTrue(d.getInfoOnComponent(1)=="tata");
4153         expected2=[5,15,3,13,1,11,7,17,6,16]
4154         for i in xrange(10):
4155             self.assertEqual(expected2[i],d.getIJ(0,i));
4156             pass
4157         pass
4158
4159     def testDaDoubleRenumberInPlace1(self):
4160         a=DataArrayDouble.New();
4161         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]
4162         a.setValues(arr1,7,2);
4163         #
4164         arr2=[3,1,0,6,5,4,2]
4165         a.renumberInPlace(arr2);
4166         self.assertEqual(7,a.getNumberOfTuples());
4167         self.assertEqual(2,a.getNumberOfComponents());
4168         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]
4169         for i in xrange(14):
4170             self.assertAlmostEqual(expected1[i],a.getIJ(0,i),14);
4171             pass
4172         #
4173         c=DataArrayInt.New();
4174         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4175         c.setValues(arr3,7,2);
4176         c.renumberInPlace(arr2);
4177         self.assertEqual(7,c.getNumberOfTuples());
4178         self.assertEqual(2,c.getNumberOfComponents());
4179         expected2=[3, 13, 2, 12, 7, 17, 1, 11, 6, 16, 5, 15, 4, 14]
4180         for i in xrange(14):
4181             self.assertEqual(expected2[i],c.getIJ(0,i));
4182             pass
4183         pass
4184
4185     def testDaDoubleRenumberR1(self):
4186         a=DataArrayDouble.New();
4187         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]
4188         a.setValues(arr1,7,2);
4189         a.setInfoOnComponent(0,"toto");
4190         a.setInfoOnComponent(1,"tata");
4191         #
4192         arr2=[3,1,0,6,5,4,2]
4193         b=a.renumberR(arr2);
4194         self.assertEqual(7,b.getNumberOfTuples());
4195         self.assertEqual(2,b.getNumberOfComponents());
4196         self.assertTrue(b.getInfoOnComponent(0)=="toto");
4197         self.assertTrue(b.getInfoOnComponent(1)=="tata");
4198         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]
4199         for i in xrange(14):
4200             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
4201             pass
4202         #
4203         c=DataArrayInt.New();
4204         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4205         c.setValues(arr3,7,2);
4206         c.setInfoOnComponent(0,"toto");
4207         c.setInfoOnComponent(1,"tata");
4208         d=c.renumberR(arr2);
4209         self.assertEqual(7,d.getNumberOfTuples());
4210         self.assertEqual(2,d.getNumberOfComponents());
4211         self.assertTrue(d.getInfoOnComponent(0)=="toto");
4212         self.assertTrue(d.getInfoOnComponent(1)=="tata");
4213         expected2=[4, 14, 2, 12, 1, 11, 7, 17, 6, 16, 5, 15, 3, 13]
4214         for i in xrange(14):
4215             self.assertEqual(expected2[i],d.getIJ(0,i));
4216             pass
4217         pass
4218
4219     def testDaDoubleRenumberInPlaceR1(self):
4220         a=DataArrayDouble.New();
4221         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]
4222         a.setValues(arr1,7,2);
4223         #
4224         arr2=[3,1,0,6,5,4,2]
4225         a.renumberInPlaceR(arr2);
4226         self.assertEqual(7,a.getNumberOfTuples());
4227         self.assertEqual(2,a.getNumberOfComponents());
4228         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]
4229         for i in xrange(14):
4230             self.assertAlmostEqual(expected1[i],a.getIJ(0,i),14);
4231             pass
4232         #
4233         c=DataArrayInt.New();
4234         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4235         c.setValues(arr3,7,2);
4236         c.renumberInPlaceR(arr2);
4237         self.assertEqual(7,c.getNumberOfTuples());
4238         self.assertEqual(2,c.getNumberOfComponents());
4239         expected2=[4, 14, 2, 12, 1, 11, 7, 17, 6, 16, 5, 15, 3, 13]
4240         for i in xrange(14):
4241             self.assertEqual(expected2[i],c.getIJ(0,i));
4242             pass
4243         pass
4244
4245     def testDaDoubleSelectByTupleId1(self):
4246         a=DataArrayDouble.New();
4247         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]
4248         a.setValues(arr1,7,2);
4249         a.setInfoOnComponent(0,"toto");
4250         a.setInfoOnComponent(1,"tata");
4251         #
4252         arr2=[4,2,0,6,5]
4253         b=a.selectByTupleId(arr2);
4254         self.assertEqual(5,b.getNumberOfTuples());
4255         self.assertEqual(2,b.getNumberOfComponents());
4256         self.assertTrue(b.getInfoOnComponent(0)=="toto");
4257         self.assertTrue(b.getInfoOnComponent(1)=="tata");
4258         expected1=[5.1,15.1,3.1,13.1,1.1,11.1,7.1,17.1,6.1,16.1]
4259         for i in xrange(10):
4260             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
4261             pass
4262         #
4263         c=DataArrayInt.New();
4264         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4265         c.setValues(arr3,7,2);
4266         c.setInfoOnComponent(0,"toto");
4267         c.setInfoOnComponent(1,"tata");
4268         d=c.selectByTupleId(arr2);
4269         self.assertEqual(5,d.getNumberOfTuples());
4270         self.assertEqual(2,d.getNumberOfComponents());
4271         self.assertTrue(d.getInfoOnComponent(0)=="toto");
4272         self.assertTrue(d.getInfoOnComponent(1)=="tata");
4273         expected2=[5,15,3,13,1,11,7,17,6,16]
4274         for i in xrange(10):
4275             self.assertEqual(expected2[i],d.getIJ(0,i));
4276             pass
4277         pass
4278
4279     def testDaDoubleGetMinMaxValues1(self):
4280         a=DataArrayDouble.New();
4281         arr1=[2.34,4.56,-6.77,4.55,4.56,2.24,2.34,1.02,4.56]
4282         a.setValues(arr1,9,1);
4283         m,where=a.getMaxValue();
4284         self.assertEqual(1,where);
4285         self.assertAlmostEqual(4.56,m,12);
4286         m,ws=a.getMaxValue2();
4287         self.assertAlmostEqual(4.56,m,12);
4288         self.assertEqual(3,ws.getNumberOfTuples());
4289         self.assertEqual(1,ws.getNumberOfComponents());
4290         expected1=[1,4,8]
4291         for i in xrange(3):
4292             self.assertEqual(expected1[i],ws.getIJ(i,0));
4293             pass
4294         a=DataArrayDouble.New();
4295         arr2=[-2.34,-4.56,6.77,-4.55,-4.56,-2.24,-2.34,-1.02,-4.56]
4296         a.setValues(arr2,9,1);
4297         m,where=a.getMinValue();
4298         self.assertEqual(1,where);
4299         self.assertAlmostEqual(-4.56,m,12);
4300         m,ws=a.getMinValue2();
4301         self.assertAlmostEqual(-4.56,m,12);
4302         self.assertEqual(3,ws.getNumberOfTuples());
4303         self.assertEqual(1,ws.getNumberOfComponents());
4304         for i in xrange(3):
4305             self.assertEqual(expected1[i],ws.getIJ(i,0));
4306             pass
4307         pass
4308
4309     def testFieldDoubleGetMinMaxValues2(self):
4310         m2,m1=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
4311         self.assertEqual(18,m2.getNumberOfCells());
4312         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]
4313         f=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
4314         a=DataArrayDouble.New();
4315         a.setValues(arr1,18,1);
4316         f.setArray(a);
4317         f.setMesh(m2);
4318         #
4319         f.checkCoherency();
4320         m=f.getMaxValue();
4321         self.assertAlmostEqual(8.71,m,12);
4322         m,ws=f.getMaxValue2();
4323         self.assertAlmostEqual(8.71,m,12);
4324         self.assertEqual(4,ws.getNumberOfTuples());
4325         self.assertEqual(1,ws.getNumberOfComponents());
4326         expected1=[0,3,7,17]
4327         for i in xrange(4):
4328             self.assertEqual(expected1[i],ws.getIJ(i,0));
4329             pass
4330         #
4331         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]
4332         a.setValues(arr2,18,1);
4333         f.checkCoherency();
4334         m=f.getMinValue();
4335         self.assertAlmostEqual(-8.71,m,12);
4336         m,ws=f.getMinValue2();
4337         self.assertAlmostEqual(-8.71,m,12);
4338         self.assertEqual(4,ws.getNumberOfTuples());
4339         self.assertEqual(1,ws.getNumberOfComponents());
4340         for i in xrange(4):
4341             self.assertEqual(expected1[i],ws.getIJ(i,0));
4342             pass
4343         pass
4344
4345     def testBuildUnstructuredCMesh1(self):
4346         m=MEDCouplingCMesh.New();
4347         da=DataArrayDouble.New();
4348         discX=[2.3,3.4,5.8,10.2]
4349         discY=[12.3,23.4,45.8]
4350         discZ=[-0.7,1.2,1.25,2.13,2.67]
4351         da.setValues(discX,4,1);
4352         m.setCoordsAt(0,da);
4353         m.checkCoherency();
4354         self.assertEqual(0,m.getCellContainingPoint([2.4],1e-12));
4355         self.assertEqual(1,m.getCellContainingPoint([3.7],1e-12));
4356         self.assertEqual(2,m.getCellContainingPoint([5.9],1e-12));
4357         self.assertEqual(-1,m.getCellContainingPoint([10.3],1e-12));
4358         self.assertEqual(-1,m.getCellContainingPoint([1.3],1e-12));
4359         #
4360         m2=m.buildUnstructured();
4361         m2.checkCoherency();
4362         f1=m.getMeasureField(False);
4363         f2=m2.getMeasureField(False);
4364         self.assertTrue(isinstance(f1.getMesh(),MEDCouplingCMesh))
4365         self.assertEqual(f1.getNumberOfTuples(),3);
4366         self.assertEqual(f2.getNumberOfTuples(),3);
4367         self.assertEqual(1,m2.getMeshDimension());
4368         self.assertEqual(1,m2.getSpaceDimension());
4369         for i in xrange(3):
4370             self.assertAlmostEqual(f1.getIJ(i,0),f2.getIJ(i,0),10);
4371             pass
4372         da=DataArrayDouble.New();
4373         da.setValues(discY,3,1);
4374         m.setCoordsAt(1,da);
4375         #
4376         m2=m.buildUnstructured();
4377         m2.checkCoherency();
4378         f1=m.getMeasureField(False);
4379         f2=m2.getMeasureField(False);
4380         self.assertEqual(f1.getNumberOfTuples(),6);
4381         self.assertEqual(f2.getNumberOfTuples(),6);
4382         self.assertEqual(2,m2.getMeshDimension());
4383         self.assertEqual(2,m2.getSpaceDimension());
4384         for i in xrange(6):
4385             self.assertAlmostEqual(f1.getIJ(i,0),f2.getIJ(i,0),10);
4386             pass
4387         #
4388         da=DataArrayDouble.New();
4389         da.setValues(discZ,5,1);
4390         m.setCoordsAt(2,da);
4391         m2=m.buildUnstructured();
4392         m2.checkCoherency();
4393         f1=m.getMeasureField(False);
4394         f2=m2.getMeasureField(False);
4395         self.assertEqual(f1.getNumberOfTuples(),24);
4396         self.assertEqual(f2.getNumberOfTuples(),24);
4397         self.assertEqual(3,m2.getMeshDimension());
4398         self.assertEqual(3,m2.getSpaceDimension());
4399         for i in xrange(24):
4400             self.assertAlmostEqual(f1.getIJ(i,0),f2.getIJ(i,0),10);
4401             pass
4402         #
4403         pos1=[5.,30.,2.]
4404         self.assertEqual(16,m.getCellContainingPoint(pos1,1e-12));
4405         #
4406         elems=m2.getCellsInBoundingBox([3.5,6.,12.2,25.,0.,1.5],1e-7)
4407         self.assertEqual([1, 2, 4, 5, 7, 8, 10, 11, 13, 14, 16, 17],elems.getValues())
4408         #
4409         pt=[2.4,12.7,-3.4]
4410         m.scale(pt,3.7);
4411         m3=m.buildUnstructured();
4412         m2.scale(pt,3.7);
4413         self.assertTrue(m3.isEqual(m2,1e-12));
4414         pass
4415
4416     def testDataArrayIntInvertO2NNO21(self):
4417         arr1=[2,0,4,1,5,3]
4418         da=DataArrayInt.New();
4419         da.setValues(arr1,6,1);
4420         da2=da.invertArrayO2N2N2O(6);
4421         self.assertEqual(6,da2.getNumberOfTuples());
4422         self.assertEqual(1,da2.getNumberOfComponents());
4423         expected1=[1,3,0,5,2,4]
4424         for i in xrange(6):
4425             self.assertEqual(expected1[i],da2.getIJ(i,0));
4426             pass
4427         da3=da2.invertArrayN2O2O2N(6);
4428         for i in xrange(6):
4429             self.assertEqual(arr1[i],da3.getIJ(i,0));
4430             pass
4431         #
4432         arr2=[3,-1,5,4,-1,0,-1,1,2,-1]
4433         da=DataArrayInt.New();
4434         da.setValues(arr2,10,1);
4435         da2=da.invertArrayO2N2N2O(6);
4436         self.assertEqual(6,da2.getNumberOfTuples());
4437         self.assertEqual(1,da2.getNumberOfComponents());
4438         expected2=[5,7,8,0,3,2]
4439         for i in xrange(6):
4440             self.assertEqual(expected2[i],da2.getIJ(i,0));
4441             pass
4442         da3=da2.invertArrayN2O2O2N(10);
4443         for i in xrange(10):
4444             self.assertEqual(arr2[i],da3.getIJ(i,0));
4445             pass
4446         pass
4447
4448     def testKeepSetSelectedComponent1(self):
4449         arr1=[1.,2.,3.,4., 11.,12.,13.,14., 21.,22.,23.,24., 31.,32.,33.,34., 41.,42.,43.,44.]
4450         a1=DataArrayDouble.New();
4451         a1.setValues(arr1,5,4);
4452         expp=[21.,22.,23.,24.]
4453         self.assertEqual(4,len(a1.getTuple(2)));
4454         for i in xrange(4):
4455             self.assertAlmostEqual(expp[i],a1.getTuple(2)[i],12)
4456             pass
4457         a1.setInfoOnComponent(0,"aaaa");
4458         a1.setInfoOnComponent(1,"bbbb");
4459         a1.setInfoOnComponent(2,"cccc");
4460         a1.setInfoOnComponent(3,"dddd");
4461         arr2V=[1,2,1,2,0,0]
4462         a2=a1.keepSelectedComponents(arr2V);
4463         self.assertEqual(6,a2.getNumberOfComponents());
4464         self.assertEqual(5,a2.getNumberOfTuples());
4465         self.assertTrue(a2.getInfoOnComponent(0)=="bbbb");
4466         self.assertTrue(a2.getInfoOnComponent(1)=="cccc");
4467         self.assertTrue(a2.getInfoOnComponent(2)=="bbbb");
4468         self.assertTrue(a2.getInfoOnComponent(3)=="cccc");
4469         self.assertTrue(a2.getInfoOnComponent(4)=="aaaa");
4470         self.assertTrue(a2.getInfoOnComponent(5)=="aaaa");
4471         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.]
4472         for i in xrange(30):
4473             self.assertAlmostEqual(expected1[i],a2.getIJ(0,i),14);
4474             pass
4475         a3=a1.convertToIntArr();
4476         self.assertEqual([21,22,23,24],a3.getTuple(2))
4477         a4=a3.keepSelectedComponents(arr2V);
4478         self.assertEqual(6,a4.getNumberOfComponents());
4479         self.assertEqual(5,a4.getNumberOfTuples());
4480         self.assertTrue(a4.getInfoOnComponent(0)=="bbbb");
4481         self.assertTrue(a4.getInfoOnComponent(1)=="cccc");
4482         self.assertTrue(a4.getInfoOnComponent(2)=="bbbb");
4483         self.assertTrue(a4.getInfoOnComponent(3)=="cccc");
4484         self.assertTrue(a4.getInfoOnComponent(4)=="aaaa");
4485         self.assertTrue(a4.getInfoOnComponent(5)=="aaaa");
4486         for i in xrange(30):
4487             self.assertEqual(int(expected1[i]),a4.getIJ(0,i));
4488             pass
4489         # setSelectedComponents
4490         arr3V=[3,2]
4491         a5=a1.keepSelectedComponents(arr3V);
4492         a5.setInfoOnComponent(0,"eeee");
4493         a5.setInfoOnComponent(1,"ffff");
4494         arr4V=[1,2]
4495         a2.setSelectedComponents(a5,arr4V);
4496         self.assertEqual(6,a2.getNumberOfComponents());
4497         self.assertEqual(5,a2.getNumberOfTuples());
4498         self.assertTrue(a2.getInfoOnComponent(0)=="bbbb");
4499         self.assertTrue(a2.getInfoOnComponent(1)=="eeee");
4500         self.assertTrue(a2.getInfoOnComponent(2)=="ffff");
4501         self.assertTrue(a2.getInfoOnComponent(3)=="cccc");
4502         self.assertTrue(a2.getInfoOnComponent(4)=="aaaa");
4503         self.assertTrue(a2.getInfoOnComponent(5)=="aaaa");
4504         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.]
4505         for i in xrange(30):
4506             self.assertAlmostEqual(expected2[i],a2.getIJ(0,i),14);
4507             pass
4508         a6=a5.convertToIntArr();
4509         a6.setInfoOnComponent(0,"eeee");
4510         a6.setInfoOnComponent(1,"ffff");
4511         a4.setSelectedComponents(a6,arr4V);
4512         self.assertEqual(6,a4.getNumberOfComponents());
4513         self.assertEqual(5,a4.getNumberOfTuples());
4514         self.assertTrue(a4.getInfoOnComponent(0)=="bbbb");
4515         self.assertTrue(a4.getInfoOnComponent(1)=="eeee");
4516         self.assertTrue(a4.getInfoOnComponent(2)=="ffff");
4517         self.assertTrue(a4.getInfoOnComponent(3)=="cccc");
4518         self.assertTrue(a4.getInfoOnComponent(4)=="aaaa");
4519         self.assertTrue(a4.getInfoOnComponent(5)=="aaaa");
4520         for i in xrange(30):
4521             self.assertEqual(int(expected2[i]),a4.getIJ(0,i));
4522             pass
4523         # test of throw
4524         arr5V=[2,3,6]
4525         arr6V=[2,7,5]
4526         arr7V=[2,1,4,6]
4527         self.assertRaises(InterpKernelException,a2.keepSelectedComponents,arr5V);
4528         self.assertRaises(InterpKernelException,a2.keepSelectedComponents,arr6V);
4529         self.assertRaises(InterpKernelException,a2.setSelectedComponents,a1,arr7V);
4530         arr7V=arr7V[0:3]
4531         self.assertRaises(InterpKernelException,a2.setSelectedComponents,a1,arr7V);
4532         #
4533         pass
4534
4535     def testKeepSetSelectedComponent2(self):
4536         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
4537         arr1=[1.,2.,3.,4., 11.,12.,13.,14., 21.,22.,23.,24., 31.,32.,33.,34., 41.,42.,43.,44.]
4538         a1=DataArrayDouble.New();
4539         a1.setValues(arr1,5,4);
4540         a1.setInfoOnComponent(0,"aaaa");
4541         a1.setInfoOnComponent(1,"bbbb");
4542         a1.setInfoOnComponent(2,"cccc");
4543         a1.setInfoOnComponent(3,"dddd");
4544         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
4545         f1.setTime(2.3,4,5);
4546         f1.setMesh(m1);
4547         f1.setName("f1");
4548         f1.setArray(a1);
4549         f1.checkCoherency();
4550         #
4551         arr2V=[1,2,1,2,0,0]
4552         f2=f1.keepSelectedComponents(arr2V);
4553         self.assertTrue(f2.getTimeDiscretization()==ONE_TIME);
4554         t,dt,it=f2.getTime()
4555         self.assertAlmostEqual(2.3,t,13);
4556         self.assertEqual(4,dt);
4557         self.assertEqual(5,it);
4558         f2.checkCoherency();
4559         self.assertEqual(6,f2.getNumberOfComponents());
4560         self.assertEqual(5,f2.getNumberOfTuples());
4561         self.assertTrue(f2.getArray().getInfoOnComponent(0)=="bbbb");
4562         self.assertTrue(f2.getArray().getInfoOnComponent(1)=="cccc");
4563         self.assertTrue(f2.getArray().getInfoOnComponent(2)=="bbbb");
4564         self.assertTrue(f2.getArray().getInfoOnComponent(3)=="cccc");
4565         self.assertTrue(f2.getArray().getInfoOnComponent(4)=="aaaa");
4566         self.assertTrue(f2.getArray().getInfoOnComponent(5)=="aaaa");
4567         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.]
4568         for i in xrange(30):
4569             self.assertAlmostEqual(expected1[i],f2.getIJ(0,i),14);
4570             pass
4571         #setSelectedComponents
4572         arr3V=[3,2]
4573         f5=f1.keepSelectedComponents(arr3V);
4574         f5.setTime(6.7,8,9);
4575         f5.getArray().setInfoOnComponent(0,"eeee");
4576         f5.getArray().setInfoOnComponent(1,"ffff");
4577         f5.checkCoherency();
4578         arr4V=[1,2]
4579         f2.setSelectedComponents(f5,arr4V);
4580         self.assertEqual(6,f2.getNumberOfComponents());
4581         self.assertEqual(5,f2.getNumberOfTuples());
4582         f2.checkCoherency();
4583         t,dt,it=f2.getTime()
4584         self.assertAlmostEqual(2.3,t,13);
4585         self.assertEqual(4,dt);
4586         self.assertEqual(5,it);
4587         self.assertTrue(f2.getArray().getInfoOnComponent(0)=="bbbb");
4588         self.assertTrue(f2.getArray().getInfoOnComponent(1)=="eeee");
4589         self.assertTrue(f2.getArray().getInfoOnComponent(2)=="ffff");
4590         self.assertTrue(f2.getArray().getInfoOnComponent(3)=="cccc");
4591         self.assertTrue(f2.getArray().getInfoOnComponent(4)=="aaaa");
4592         self.assertTrue(f2.getArray().getInfoOnComponent(5)=="aaaa");
4593         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.]
4594         for i in xrange(30):
4595             self.assertAlmostEqual(expected2[i],f2.getIJ(0,i),14);
4596             pass
4597         #
4598         pass
4599
4600     def testElementaryDAThrowAndSpecialCases(self):
4601         da=DataArrayInt.New();
4602         self.assertRaises(InterpKernelException, da.checkAllocated);
4603         self.assertRaises(InterpKernelException, da.fillWithValue, 1);
4604         self.assertRaises(InterpKernelException, da.iota, 1);
4605         da.alloc(7,1);
4606         da.fillWithValue(11); #11,11,11,11...
4607         da.iota(10); #10,11,12,13...
4608
4609         db=DataArrayInt.New();
4610         db.alloc(7,2);
4611
4612         dbl2=DataArrayDouble.New();
4613         dbl2.alloc(7,2);
4614         self.assertRaises(InterpKernelException, dbl2.isUniform, 10., 1e-15);
4615         self.assertRaises(InterpKernelException, dbl2.sort);
4616         self.assertRaises(InterpKernelException, dbl2.iota, 10.);
4617
4618         dbl=DataArrayDouble.New();
4619         #DataArrayDouble not allocated yet
4620         self.assertRaises(InterpKernelException, dbl.iota, 10.);
4621         self.assertRaises(InterpKernelException, dbl.isUniform, 10., 1e-15);
4622         self.assertRaises(InterpKernelException, dbl.sort);
4623         self.assertRaises(InterpKernelException, dbl.fromNoInterlace);
4624         self.assertRaises(InterpKernelException, dbl.toNoInterlace);
4625
4626         dbl.alloc(7,1);
4627         dbl.iota(10.);
4628         self.assertTrue(not dbl.isUniform(10.,1e-15));
4629         dbl.sort();
4630         self.assertTrue(dbl.isMonotonic(True, .99));
4631         self.assertTrue(dbl.isMonotonic(True, -.99));
4632         self.assertTrue(not dbl.isMonotonic(True, 1.1));
4633         self.assertTrue(not dbl.isMonotonic(True, -1.1));
4634         dbl.reverse();
4635         self.assertTrue(dbl.isMonotonic(False, .99));
4636         self.assertTrue(not dbl.isMonotonic(False, 1.1));
4637         self.assertTrue(not dbl.isMonotonic(False, -1.1));
4638
4639         dc=DataArrayInt.New();
4640         dc.alloc(14,1);
4641
4642         dd=DataArrayDouble.New();
4643         self.assertRaises(InterpKernelException, dd.checkAllocated);
4644         self.assertRaises(InterpKernelException, dd.fillWithValue, 1.);
4645         self.assertRaises(InterpKernelException, dd.iota, 1.);
4646         self.assertTrue(not ((dd.repr().find("No data"))==-1));
4647
4648         dd.alloc(0,1); #Allocated but nbOfElements==0!
4649         self.assertTrue(not ((dd.repr().find("Number of tuples : 0"))==-1));
4650         self.assertTrue(not ((dd.repr().find("Empty Data"))==-1));
4651         dd.fillWithValue(11); #?!...ok
4652         dd.iota(10); #?!...ok
4653         self.assertTrue(dd.isMonotonic(True, 1.));  #nothing is monotonic
4654         self.assertTrue(dd.isMonotonic(False, 1.));
4655
4656         self.assertRaises(InterpKernelException, db.copyStringInfoFrom, da);
4657         self.assertRaises(InterpKernelException, db.copyStringInfoFrom, da);
4658         cIds=[2,2]
4659         self.assertRaises(InterpKernelException, da.copyPartOfStringInfoFrom, db, cIds);
4660         cIds[0]=1;
4661         cIds[0]=-1;
4662         self.assertRaises(InterpKernelException, da.copyPartOfStringInfoFrom, db, cIds);
4663
4664         info=["infoOfOneComponent"]*2;
4665         self.assertRaises(InterpKernelException, da.setInfoOnComponents, info);
4666         self.assertRaises(InterpKernelException, da.setInfoOnComponent, 1, info[0]);
4667         db.setInfoOnComponents(info);
4668
4669         self.assertRaises(InterpKernelException, da.getInfoOnComponent, -1);
4670         self.assertRaises(InterpKernelException, da.getInfoOnComponent, 2);
4671         self.assertTrue(db.getInfoOnComponent(1)==db.getInfoOnComponent(0));
4672         self.assertRaises(InterpKernelException, db.getVarOnComponent, -1);
4673         self.assertRaises(InterpKernelException, db.getVarOnComponent, 2);
4674         self.assertRaises(InterpKernelException, db.getUnitOnComponent, -1);
4675         self.assertRaises(InterpKernelException, db.getUnitOnComponent, 2);
4676
4677         self.assertTrue(da.GetVarNameFromInfo("varname unit ")=="varname unit ");
4678         self.assertTrue(da.GetVarNameFromInfo("varname]unit[")=="varname]unit[");
4679         self.assertTrue(da.GetVarNameFromInfo("[unit]")=="");
4680         self.assertTrue(da.GetVarNameFromInfo("varname [unit]")=="varname");
4681
4682         self.assertTrue(da.GetUnitFromInfo("varname unit ")=="");
4683         self.assertTrue(da.GetUnitFromInfo("varname]unit[")=="");
4684         self.assertTrue(da.GetUnitFromInfo("[unit]")=="unit");
4685         self.assertTrue(da.GetUnitFromInfo("varname [unit]")=="unit");
4686
4687         self.assertRaises(InterpKernelException, da.checkNbOfTuplesAndComp, db, "theMessageInThrow");
4688         self.assertRaises(InterpKernelException, da.checkNbOfTuplesAndComp, dc, "theMessageInThrow");
4689         self.assertRaises(InterpKernelException, db.checkNbOfTuplesAndComp, dc, "theMessageInThrow");
4690
4691         self.assertRaises(InterpKernelException, da.checkNbOfTuplesAndComp, 7, 2, "theMessageInThrow");
4692         da.checkNbOfTuplesAndComp(7,1,"theMessageInThrow");
4693
4694         self.assertRaises(InterpKernelException, db.checkNbOfElems, 7*2+1, "theMessageInThrow");
4695         db.checkNbOfElems(7*2,"theMessageInThrow");
4696
4697         self.assertRaises(InterpKernelException, db.GetNumberOfItemGivenBES, 10, 9, 1, "theMessageInThrow");
4698         self.assertRaises(InterpKernelException, db.GetNumberOfItemGivenBES, 0, 1, -1, "theMessageInThrow");
4699         self.assertEqual(10,db.GetNumberOfItemGivenBES(0,10,1,"theMessageInThrow"));
4700         self.assertEqual(5,db.GetNumberOfItemGivenBES(0,10,2,"theMessageInThrow"));
4701         self.assertEqual(6,db.GetNumberOfItemGivenBES(0,11,2,"theMessageInThrow"));
4702
4703         self.assertTrue(not ((da.repr().find("Number of components : 1"))==-1));
4704         self.assertTrue(not ((dd.repr().find("Number of components : 1"))==-1));
4705         self.assertTrue(not ((dbl.repr().find("Number of components : 1"))==-1));
4706
4707         self.assertTrue(not ((da.reprZip().find("Number of components : 1"))==-1));
4708         self.assertTrue(not ((dd.reprZip().find("Number of components : 1"))==-1));
4709         self.assertTrue(not ((dbl.reprZip().find("Number of components : 1"))==-1));
4710
4711         self.assertRaises(InterpKernelException, dbl.selectByTupleId2, 0, 1, -1);
4712         self.assertRaises(InterpKernelException, dbl.substr, -1, 1);
4713         self.assertRaises(InterpKernelException, dbl.substr, 8, 1);
4714         self.assertRaises(InterpKernelException, dbl.substr, 0, 8);
4715         self.assertRaises(InterpKernelException, dbl.meldWith, dd);
4716
4717         self.assertRaises(InterpKernelException, dbl.setPartOfValuesAdv, dbl2, da); #dbl dbl2 not have the same number of components
4718         self.assertRaises(InterpKernelException, dbl.setPartOfValuesAdv, dd, da);  #da tuple selector DataArrayInt instance not have exactly 2 components
4719
4720         dbl3=DataArrayDouble.New();
4721         dbl3.alloc(6,2);
4722         dbl3.fillWithValue(11.);
4723         #bad number of components
4724         self.assertRaises(InterpKernelException, dbl3.getMaxValue);
4725         self.assertRaises(InterpKernelException, dd.getMaxValue);
4726         self.assertRaises(InterpKernelException, dbl3.getMinValue);
4727         self.assertRaises(InterpKernelException, dd.getMinValue);
4728         self.assertRaises(InterpKernelException, dbl3.getAverageValue);
4729         self.assertRaises(InterpKernelException, dd.getAverageValue);
4730         self.assertRaises(InterpKernelException, dd.accumulate, 100);
4731         self.assertRaises(InterpKernelException, dbl.fromPolarToCart);
4732         self.assertRaises(InterpKernelException, dbl3.fromCylToCart);
4733         self.assertRaises(InterpKernelException, dbl3.fromSpherToCart);
4734         self.assertRaises(InterpKernelException, dbl3.doublyContractedProduct);
4735         self.assertRaises(InterpKernelException, dbl3.determinant);
4736         self.assertRaises(InterpKernelException, dbl3.eigenValues);
4737         self.assertRaises(InterpKernelException, dbl3.eigenVectors);
4738         self.assertRaises(InterpKernelException, dbl3.inverse);
4739         self.assertRaises(InterpKernelException, dbl3.trace);
4740         self.assertRaises(InterpKernelException, dbl3.deviator);
4741
4742         dbl3.setIJ(5,1,12.);
4743         self.assertTrue(dbl3.getMaxValueInArray()==12.);
4744         self.assertTrue(dbl3.getMinValueInArray()==11.);
4745
4746         db.fillWithValue(100); #bad Ids
4747         self.assertRaises(InterpKernelException, dbl3.setPartOfValuesAdv, dbl2, db);
4748         db.fillWithValue(-1); #bad Ids
4749         self.assertRaises(InterpKernelException, dbl3.setPartOfValuesAdv, dbl2, db);
4750         db.fillWithValue(6); #bad Ids for dbl3
4751         self.assertRaises(InterpKernelException, dbl3.setPartOfValuesAdv, dbl2, db);
4752
4753         dbl3.checkNoNullValues();
4754         dbl3.setIJ(5,0,0.);
4755         self.assertRaises(InterpKernelException, dbl3.checkNoNullValues);
4756         self.assertRaises(InterpKernelException, dbl3.applyInv, 1.);  #div by zero
4757         self.assertRaises(InterpKernelException, dbl2.getIdsInRange, 1., 2.);
4758         a=[]
4759         self.assertRaises(InterpKernelException, DataArrayDouble_Aggregate, a);
4760         self.assertRaises(InterpKernelException, DataArrayDouble_Meld, a);
4761
4762         a=[dbl2,dbl]; #Nb of components mismatch
4763         self.assertRaises(InterpKernelException, DataArrayDouble_Aggregate, a);
4764
4765         self.assertRaises(InterpKernelException, DataArrayDouble_Dot, dbl2, dbl);
4766
4767         self.assertRaises(InterpKernelException, DataArrayDouble_CrossProduct, dbl2, dbl); #Nb of components mismatch
4768         self.assertRaises(InterpKernelException, DataArrayDouble_CrossProduct, dbl2, dbl2); #Nb of components must be equal to 3
4769         dbl4=DataArrayDouble.New();
4770         dbl4.alloc(6,3);
4771         dbl5=DataArrayDouble.New();
4772         dbl5.alloc(7,3);
4773         self.assertRaises(InterpKernelException, DataArrayDouble_CrossProduct, dbl4, dbl5); #Nb of tuples mismatch
4774
4775         a[0]=dbl4; #Nb of tuple mismatch
4776         a[1]=dbl5; #Nb of tuple mismatch
4777         self.assertRaises(InterpKernelException, DataArrayDouble_Meld, a);
4778         self.assertRaises(InterpKernelException, DataArrayDouble_Dot, dbl4, dbl5);
4779         pass
4780
4781     def testDAIGetIdsEqual1(self):
4782         tab1=[5,-2,-4,-2,3,2,-2];
4783         da=DataArrayInt.New();
4784         da.setValues(tab1,7,1);
4785         da2=da.getIdsEqual(-2);
4786         self.assertEqual(3,da2.getNumberOfTuples());
4787         self.assertEqual(1,da2.getNumberOfComponents());
4788         expected1=[1,3,6];
4789         self.assertEqual(expected1,da2.getValues());
4790         pass
4791
4792     def testDAIGetIdsEqualList1(self):
4793         tab1=[5,-2,-4,-2,3,2,-2];
4794         da=DataArrayInt.New();
4795         da.setValues(tab1,7,1);
4796         da2=da.getIdsEqualList([3,-2,0]);
4797         self.assertEqual(4,da2.getNumberOfTuples());
4798         self.assertEqual(1,da2.getNumberOfComponents());
4799         expected1=[1,3,4,6];
4800         self.assertEqual(expected1,da2.getValues());
4801         pass
4802
4803     def testDAFromNoInterlace1(self):
4804         tab1=[1,11,21,31,41,2,12,22,32,42,3,13,23,33,43]
4805         da=DataArrayInt.New();
4806         da.setValues(tab1,5,3);
4807         da2=da.fromNoInterlace();
4808         expected1=[1,2,3,11,12,13,21,22,23,31,32,33,41,42,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.fromNoInterlace();
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 testDAToNoInterlace1(self):
4822         tab1=[1,2,3,11,12,13,21,22,23,31,32,33,41,42,43]
4823         da=DataArrayInt.New();
4824         da.setValues(tab1,5,3);
4825         da2=da.toNoInterlace();
4826         expected1=[1,11,21,31,41,2,12,22,32,42,3,13,23,33,43]
4827         self.assertEqual(5,da2.getNumberOfTuples());
4828         self.assertEqual(3,da2.getNumberOfComponents());# it's not a bug. Avoid to have 1 million components !
4829         self.assertEqual(expected1,da2.getValues());
4830         da3=da.convertToDblArr();
4831         da4=da3.toNoInterlace();
4832         self.assertEqual(5,da4.getNumberOfTuples());
4833         self.assertEqual(3,da4.getNumberOfComponents());# it's not a bug. Avoid to have 1 million components !
4834         for i in xrange(15):
4835             self.assertAlmostEqual(expected1[i],da4.getIJ(0,i),14);
4836             pass
4837         pass
4838
4839     def testDAIsUniform1(self):
4840         tab1=[1,1,1,1,1]
4841         da=DataArrayInt.New();
4842         da.setValues(tab1,5,1);
4843         self.assertTrue(da.isUniform(1));
4844         da.setIJ(2,0,2);
4845         self.assertTrue(not da.isUniform(1));
4846         da.setIJ(2,0,1);
4847         self.assertTrue(da.isUniform(1));
4848         da2=da.convertToDblArr();
4849         self.assertTrue(da2.isUniform(1.,1.e-12));
4850         da2.setIJ(1,0,1.+1.e-13);
4851         self.assertTrue(da2.isUniform(1.,1.e-12));
4852         da2.setIJ(1,0,1.+1.e-11);
4853         self.assertTrue(not da2.isUniform(1.,1.e-12));
4854         pass
4855
4856     def testDADFromPolarToCart1(self):
4857         tab1=[2.,0.2,2.5,0.7]
4858         da=DataArrayDouble.New();
4859         da.setValues(tab1,2,2);
4860         da2=da.fromPolarToCart();
4861         expected1=[1.9601331556824833,0.39733866159012243, 1.9121054682112213,1.6105442180942275]
4862         for i in xrange(4):
4863             self.assertAlmostEqual(expected1[i],da2.getIJ(0,i),13);
4864             pass
4865         pass
4866
4867     def testDADFromCylToCart1(self):
4868         tab1=[2.,0.2,4.,2.5,0.7,9.]
4869         da=DataArrayDouble.New();
4870         da.setValues(tab1,2,3);
4871         da2=da.fromCylToCart();
4872         expected1=[1.9601331556824833,0.39733866159012243,4., 1.9121054682112213,1.6105442180942275,9.]
4873         for i in xrange(6):
4874             self.assertAlmostEqual(expected1[i],da2.getIJ(0,i),13);
4875             pass
4876         pass
4877
4878     def testDADFromSpherToCart1(self):
4879         tab1=[2.,0.2,0.3,2.5,0.7,0.8]
4880         da=DataArrayDouble.New();
4881         da.setValues(tab1,2,3);
4882         da2=da.fromSpherToCart();
4883         expected1=[0.37959212195737485,0.11742160338765303,1.9601331556824833, 1.1220769624465328,1.1553337045129035,1.9121054682112213]
4884         for i in xrange(6):
4885             self.assertAlmostEqual(expected1[i],da2.getIJ(0,i),13);
4886             pass
4887         pass
4888
4889     def testUnPolyze1(self):
4890         elts=[0,1,2,3,4,5,6,7]
4891         eltsV=elts;
4892         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
4893         mesh.convertToPolyTypes(eltsV);
4894         mesh.unPolyze();
4895         mesh2=MEDCouplingDataForTest.build3DTargetMesh_1();
4896         mesh.checkCoherency();
4897         self.assertTrue(mesh.isEqual(mesh2,1e-12));
4898         mesh.convertToPolyTypes(eltsV);
4899         self.assertTrue(not mesh.isEqual(mesh2,1e-12));
4900         mesh.getNodalConnectivity().setIJ(0,6,10);
4901         mesh.getNodalConnectivity().setIJ(0,7,9);
4902         mesh.getNodalConnectivity().setIJ(0,8,12);
4903         mesh.getNodalConnectivity().setIJ(0,9,13);
4904         mesh.unPolyze();
4905         self.assertTrue(mesh.isEqual(mesh2,1e-12));
4906         mesh.convertToPolyTypes(eltsV);
4907         mesh.getNodalConnectivity().setIJ(0,6,12);
4908         mesh.getNodalConnectivity().setIJ(0,7,13);
4909         mesh.getNodalConnectivity().setIJ(0,8,10);
4910         mesh.getNodalConnectivity().setIJ(0,9,9);
4911         mesh.unPolyze();
4912         self.assertTrue(mesh.isEqual(mesh2,1e-12));
4913         mesh.convertToPolyTypes(eltsV);
4914         mesh.getNodalConnectivity().setIJ(0,6,12);
4915         mesh.getNodalConnectivity().setIJ(0,7,10);
4916         mesh.getNodalConnectivity().setIJ(0,8,13);
4917         mesh.getNodalConnectivity().setIJ(0,9,9);
4918         mesh.unPolyze();
4919         self.assertTrue(not mesh.isEqual(mesh2,1e-12));
4920         # Test for 2D mesh
4921         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
4922         mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
4923         eltsV=eltsV[:5];
4924         mesh.convertToPolyTypes(eltsV);
4925         self.assertTrue(not mesh.isEqual(mesh2,1e-12));
4926         mesh.unPolyze();
4927         self.assertTrue(mesh.isEqual(mesh2,1e-12));
4928         pass
4929
4930     def testConvertDegeneratedCells1(self):
4931         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
4932         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]
4933         mesh.allocateCells(4);
4934         mesh.insertNextCell(NORM_HEXA8,8,conn[0:8])
4935         mesh.insertNextCell(NORM_HEXA8,8,conn[8:16])
4936         mesh.insertNextCell(NORM_HEXA8,8,conn[16:24])
4937         mesh.insertNextCell(NORM_HEXA8,8,conn[24:32])
4938         mesh.finishInsertingCells();
4939         mesh.checkCoherency();
4940         self.assertEqual(4,mesh.getNumberOfCells());
4941         self.assertEqual(NORM_HEXA8,mesh.getTypeOfCell(0));
4942         self.assertEqual(NORM_HEXA8,mesh.getTypeOfCell(1));
4943         self.assertEqual(NORM_HEXA8,mesh.getTypeOfCell(2));
4944         self.assertEqual(NORM_HEXA8,mesh.getTypeOfCell(3));
4945         f1=mesh.getMeasureField(True);
4946         mesh.convertDegeneratedCells();
4947         mesh.checkCoherency();
4948         f2=mesh.getMeasureField(True);
4949         self.assertEqual(4,mesh.getNumberOfCells());
4950         self.assertEqual(NORM_PENTA6,mesh.getTypeOfCell(0));
4951         self.assertEqual(NORM_PYRA5,mesh.getTypeOfCell(1));
4952         self.assertEqual(NORM_TETRA4,mesh.getTypeOfCell(2));
4953         self.assertEqual(NORM_PYRA5,mesh.getTypeOfCell(3));
4954         for i in xrange(4):
4955             self.assertAlmostEqual(f1.getArray().getIJ(0,i),f2.getArray().getIJ(0,i),5);
4956             pass
4957         pass
4958
4959     def testGetNodeIdsNearPoints1(self):
4960         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
4961         coords=mesh.getCoords();
4962         tmp=DataArrayDouble.New();
4963         vals=[0.2,0.2,0.1,0.2,0.2,0.2]
4964         tmp.setValues(vals,3,2);
4965         tmp2=DataArrayDouble.Aggregate(coords,tmp);
4966         mesh.setCoords(tmp2);
4967         pts=[0.2,0.2,0.1,0.3,-0.3,0.7]
4968         c=mesh.getNodeIdsNearPoint(pts[:2],1e-7);
4969         self.assertEqual([4,9,11],c.getValues());
4970         c,cI=mesh.getNodeIdsNearPoints(pts,3,1e-7);
4971         self.assertEqual([0,3,3,4],cI.getValues());
4972         self.assertEqual([4,9,11,6],c.getValues());
4973         c,cI=mesh.getNodeIdsNearPoints(pts,1e-7);
4974         self.assertEqual([0,3,3,4],cI.getValues());
4975         self.assertEqual([4,9,11,6],c.getValues());
4976         c,cI=mesh.getNodeIdsNearPoints(DataArrayDouble.New(pts,3,2),1e-7);
4977         self.assertEqual([0,3,3,4],cI.getValues());
4978         self.assertEqual([4,9,11,6],c.getValues());
4979         self.assertRaises(InterpKernelException,mesh.getNodeIdsNearPoints,DataArrayDouble.New(pts,2,3),1e-7);
4980         pass
4981
4982     def testFieldCopyTinyAttrFrom1(self):
4983         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
4984         f1.setName("f1");
4985         f1.setTimeTolerance(1.e-5);
4986         f1.setDescription("f1Desc");
4987         f1.setTime(1.23,4,5);
4988         f2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
4989         f2.setName("f2");
4990         f2.setDescription("f2Desc");
4991         f2.setTime(6.78,9,10);
4992         f2.setTimeTolerance(4.556e-12);
4993         #
4994         f1.copyTinyAttrFrom(f2);
4995         self.assertAlmostEqual(4.556e-12,f1.getTimeTolerance(),24);
4996         t,dt,it=f1.getTime()
4997         self.assertAlmostEqual(6.78,t,12);
4998         self.assertEqual(9,dt);
4999         self.assertEqual(10,it);
5000         self.assertTrue(f1.getName()=="f1");#name unchanged
5001         self.assertTrue(f1.getDescription()=="f1Desc");#description unchanged
5002         #
5003         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
5004         f1.setName("f1");
5005         f1.setTimeTolerance(1.e-5);
5006         f1.setDescription("f1Desc");
5007         f2=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
5008         f2.setName("f2");
5009         f2.setDescription("f2Desc");
5010         f2.setTimeTolerance(4.556e-12);
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         #
5017         f1=MEDCouplingFieldDouble.New(ON_CELLS,CONST_ON_TIME_INTERVAL);
5018         f1.setName("f1");
5019         f1.setTimeTolerance(1.e-5);
5020         f1.setDescription("f1Desc");
5021         f1.setTime(1.23,4,5);
5022         f1.setEndTime(5.43,2,1);
5023         f2=MEDCouplingFieldDouble.New(ON_CELLS,CONST_ON_TIME_INTERVAL);
5024         f2.setName("f2");
5025         f2.setDescription("f2Desc");
5026         f2.setTimeTolerance(4.556e-12);
5027         f2.setTime(6.78,9,10);
5028         f2.setEndTime(10.98,7,6);
5029         #
5030         f1.copyTinyAttrFrom(f2);
5031         self.assertAlmostEqual(4.556e-12,f1.getTimeTolerance(),24);
5032         self.assertTrue(f1.getName()=="f1");#name unchanged
5033         self.assertTrue(f1.getDescription()=="f1Desc");#description unchanged
5034         t,dt,it=f1.getTime()
5035         self.assertAlmostEqual(6.78,t,12);
5036         self.assertEqual(9,dt);
5037         self.assertEqual(10,it);
5038         t,dt,it=f1.getEndTime()
5039         self.assertAlmostEqual(10.98,t,12);
5040         self.assertEqual(7,dt);
5041         self.assertEqual(6,it);
5042         #
5043         f1=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
5044         f1.setName("f1");
5045         f1.setTimeTolerance(1.e-5);
5046         f1.setDescription("f1Desc");
5047         f1.setTime(1.23,4,5);
5048         f1.setEndTime(5.43,2,1);
5049         f2=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
5050         f2.setName("f2");
5051         f2.setDescription("f2Desc");
5052         f2.setTimeTolerance(4.556e-12);
5053         f2.setTime(6.78,9,10);
5054         f2.setEndTime(10.98,7,6);
5055         #
5056         f1.copyTinyAttrFrom(f2);
5057         self.assertAlmostEqual(4.556e-12,f1.getTimeTolerance(),24);
5058         self.assertTrue(f1.getName()=="f1");#name unchanged
5059         self.assertTrue(f1.getDescription()=="f1Desc");#description unchanged
5060         t,dt,it=f1.getTime()
5061         self.assertAlmostEqual(6.78,t,12);
5062         self.assertEqual(9,dt);
5063         self.assertEqual(10,it);
5064         t,dt,it=f1.getEndTime()
5065         self.assertAlmostEqual(10.98,t,12);
5066         self.assertEqual(7,dt);
5067         self.assertEqual(6,it);
5068         pass
5069
5070     def testExtrudedMesh5(self):
5071         coo1=[0.,1.,2.,3.5]
5072         a=DataArrayDouble.New();
5073         a.setValues(coo1,4,1);
5074         b=MEDCouplingCMesh.New();
5075         b.setCoordsAt(0,a);
5076         c=b.buildUnstructured();
5077         self.assertEqual(1,c.getSpaceDimension());
5078         c.changeSpaceDimension(2);
5079         #
5080         d=DataArrayDouble.New();
5081         d.alloc(13,1);
5082         d.iota();
5083         e=MEDCouplingCMesh.New();
5084         e.setCoordsAt(0,d);
5085         f=e.buildUnstructured();
5086         g=f.getCoords().applyFunc(2,"3.5*IVec+x/6*3.14159265359*JVec");
5087         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 !
5088         h=g.fromPolarToCart();
5089         f.setCoords(h);
5090         i=c.buildExtrudedMesh(f,1);
5091         self.assertEqual(52,i.getNumberOfNodes());
5092         tmp,tmp2,tmp3=i.mergeNodes(1e-9);
5093         self.assertTrue(tmp2);
5094         self.assertEqual(37,tmp3);
5095         i.convertDegeneratedCells();
5096         i.checkCoherency();
5097         self.assertEqual(36,i.getNumberOfCells());
5098         self.assertEqual(37,i.getNumberOfNodes());
5099         self.assertEqual(12,i.getNumberOfCellsWithType(NORM_TRI3));
5100         self.assertEqual(24,i.getNumberOfCellsWithType(NORM_QUAD4));
5101         expected1=[0.25,0.75,2.0625]
5102         j=i.getMeasureField(True);
5103         for ii in xrange(12):
5104             for k in xrange(3):
5105                 self.assertAlmostEqual(expected1[k],j.getIJ(0,ii*3+k),10);
5106                 pass
5107             pass
5108         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]
5109         m=i.getBarycenterAndOwner();
5110         for i in xrange(72):
5111             self.assertAlmostEqual(expected2[i],m.getIJ(0,i),10);
5112             pass
5113         #
5114         pass
5115
5116     def testExtrudedMesh6(self):
5117         coo1=[0.,1.,2.,3.5]
5118         a=DataArrayDouble.New();
5119         a.setValues(coo1,4,1);
5120         b=MEDCouplingCMesh.New();
5121         b.setCoordsAt(0,a);
5122         c=b.buildUnstructured();
5123         self.assertEqual(1,c.getSpaceDimension());
5124         c.changeSpaceDimension(2);
5125         #
5126         d=DataArrayDouble.New();
5127         d.alloc(5);
5128         d.iota();
5129         e=MEDCouplingCMesh.New();
5130         e.setCoordsAt(0,d);
5131         f=e.buildUnstructured();
5132         d2=f.getCoords().applyFunc("x*x/2");
5133         f.setCoords(d2);
5134         f.changeSpaceDimension(2);
5135         #
5136         center=[0.,0.]
5137         f.rotate(center,None,pi/3);
5138         g=c.buildExtrudedMesh(f,0);
5139         g.checkCoherency();
5140         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 ]
5141         f1=g.getMeasureField(True);
5142         for i in xrange(12):
5143             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),12);
5144             pass
5145         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]
5146         f2=g.getBarycenterAndOwner();
5147         for i in xrange(24):
5148             self.assertAlmostEqual(expected2[i],f2.getIJ(0,i),12);
5149             pass
5150         pass
5151
5152     def testExtrudedMesh7(self):
5153         coo1=[0.,1.,2.,3.5]
5154         a=DataArrayDouble.New();
5155         a.setValues(coo1,4,1);
5156         b=MEDCouplingCMesh.New();
5157         b.setCoordsAt(0,a);
5158         c=b.buildUnstructured();
5159         self.assertEqual(1,c.getSpaceDimension());
5160         c.changeSpaceDimension(2);
5161         #
5162         d=DataArrayDouble.New();
5163         d.alloc(13,1);
5164         d.iota();
5165         e=MEDCouplingCMesh.New();
5166         e.setCoordsAt(0,d);
5167         f=e.buildUnstructured();
5168         g=f.getCoords().applyFunc(2,"3.5*IVec+x/6*3.14159265359*JVec");
5169         h=g.fromPolarToCart();
5170         f.setCoords(h);
5171         i=c.buildExtrudedMesh(f,1);
5172         self.assertEqual(52,i.getNumberOfNodes());
5173         tmp,tmp2,tmp3=i.mergeNodes(1e-9);
5174         self.assertTrue(tmp2);
5175         self.assertEqual(37,tmp3);
5176         i.convertDegeneratedCells();
5177         vec1=[10.,0]
5178         i.translate(vec1);
5179         g2=h.applyFunc(3,"13.5/3.5*x*IVec+0*JVec+13.5/3.5*y*KVec");
5180         f.setCoords(g2);
5181         i.changeSpaceDimension(3);
5182         i3=i.buildExtrudedMesh(f,1);
5183         f2=i3.getMeasureField(True);
5184         tmp,tmp2,tmp3=i.mergeNodes(1e-9);
5185         self.assertTrue(tmp2);
5186         self.assertEqual(444,tmp3);
5187         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]
5188         for ii in xrange(12):
5189             for jj in xrange(36):
5190                 self.assertAlmostEqual(expected1[jj],f2.getIJ(0,ii*36+jj),9);
5191                 pass
5192         #
5193         pass
5194
5195     def testSimplexize1(self):
5196         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5197         m.convertToPolyTypes([3]);
5198         da=m.simplexize(0);
5199         self.assertEqual(7,da.getNumberOfTuples());
5200         self.assertEqual(1,da.getNumberOfComponents());
5201         expected2=[0,0,1,2,3,4,4]
5202         for i in xrange(7):
5203             self.assertEqual(expected2[i],da.getIJ(i,0));
5204             pass
5205         m.checkCoherency();
5206         self.assertEqual(7,m.getNumberOfCells());
5207         self.assertEqual(NORM_TRI3,m.getTypeOfCell(0));
5208         self.assertEqual(NORM_TRI3,m.getTypeOfCell(1));
5209         self.assertEqual(NORM_TRI3,m.getTypeOfCell(2));
5210         self.assertEqual(NORM_TRI3,m.getTypeOfCell(3));
5211         self.assertEqual(NORM_POLYGON,m.getTypeOfCell(4));
5212         self.assertEqual(NORM_TRI3,m.getTypeOfCell(5));
5213         self.assertEqual(NORM_TRI3,m.getTypeOfCell(6));
5214         expected1=[0.125,0.125,0.125,0.125,0.25,0.125,0.125]
5215         f=m.getMeasureField(False);
5216         for i in xrange(7):
5217             self.assertAlmostEqual(expected1[i]*sqrt(2.),f.getIJ(i,0),10);
5218             pass
5219         types=m.getAllGeoTypes();
5220         self.assertEqual([NORM_TRI3,NORM_POLYGON],types);
5221         #
5222         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5223         m.convertToPolyTypes([3]);
5224         da=m.simplexize(1);
5225         self.assertEqual(7,da.getNumberOfTuples());
5226         self.assertEqual(1,da.getNumberOfComponents());
5227         for i in xrange(7):
5228             self.assertEqual(expected2[i],da.getIJ(i,0));
5229             pass
5230         m.checkCoherency();
5231         types=m.getAllGeoTypes();
5232         self.assertEqual([NORM_TRI3,NORM_POLYGON],types);
5233         self.assertEqual(7,m.getNumberOfCells());
5234         self.assertEqual(NORM_TRI3,m.getTypeOfCell(0));
5235         self.assertEqual(NORM_TRI3,m.getTypeOfCell(1));
5236         self.assertEqual(NORM_TRI3,m.getTypeOfCell(2));
5237         self.assertEqual(NORM_TRI3,m.getTypeOfCell(3));
5238         self.assertEqual(NORM_POLYGON,m.getTypeOfCell(4));
5239         self.assertEqual(NORM_TRI3,m.getTypeOfCell(5));
5240         self.assertEqual(NORM_TRI3,m.getTypeOfCell(6));
5241         f=m.getMeasureField(False);
5242         for i in xrange(7):
5243             self.assertAlmostEqual(expected1[i]*sqrt(2.),f.getIJ(i,0),10);
5244             pass
5245         pass
5246
5247     def testSimplexize2(self):
5248         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5249         m.convertToPolyTypes([3]);
5250         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
5251         f1.setMesh(m);
5252         arr=DataArrayDouble.New();
5253         arr1=[10.,110.,20.,120.,30.,130.,40.,140.,50.,150.]
5254         arr.setValues(arr1,5,2);
5255         f1.setArray(arr);
5256         #
5257         f1.checkCoherency();
5258         self.assertTrue(f1.simplexize(0));
5259         f1.checkCoherency();
5260         expected1=[10.,110.,10.,110.,20.,120.,30.,130.,40.,140.,50.,150.,50.,150.]
5261         for i in xrange(14):
5262             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),10);
5263             pass
5264         self.assertTrue(not f1.simplexize(0));
5265         for i in xrange(14):
5266             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),10);
5267             pass
5268         #
5269         pass
5270
5271     def testDAMeld1(self):
5272         da1=DataArrayDouble.New();
5273         da1.alloc(7,2);
5274         da2=DataArrayDouble.New();
5275         da2.alloc(7,1);
5276         #
5277         da1.fillWithValue(7.);
5278         da2.iota(0.);
5279         da3=da2.applyFunc(3,"10*x*IVec+100*x*JVec+1000*x*KVec");
5280         #
5281         da1.setInfoOnComponent(0,"c0da1");
5282         da1.setInfoOnComponent(1,"c1da1");
5283         da3.setInfoOnComponent(0,"c0da3");
5284         da3.setInfoOnComponent(1,"c1da3");
5285         da3.setInfoOnComponent(2,"c2da3");
5286         #
5287         da1C=da1.deepCpy();
5288         da1.meldWith(da3);
5289         self.assertEqual(5,da1.getNumberOfComponents());
5290         self.assertEqual(7,da1.getNumberOfTuples());
5291         self.assertTrue(da1.getInfoOnComponent(0)=="c0da1");
5292         self.assertTrue(da1.getInfoOnComponent(1)=="c1da1");
5293         self.assertTrue(da1.getInfoOnComponent(2)=="c0da3");
5294         self.assertTrue(da1.getInfoOnComponent(3)=="c1da3");
5295         self.assertTrue(da1.getInfoOnComponent(4)=="c2da3");
5296         #
5297         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.]
5298         for i in xrange(35):
5299             self.assertAlmostEqual(expected1[i],da1.getIJ(0,i),10);
5300             pass
5301         #
5302         dai1=da1C.convertToIntArr();
5303         dai3=da3.convertToIntArr();
5304         dai1.meldWith(dai3);
5305         self.assertEqual(5,dai1.getNumberOfComponents());
5306         self.assertEqual(7,dai1.getNumberOfTuples());
5307         self.assertTrue(dai1.getInfoOnComponent(0)=="c0da1");
5308         self.assertTrue(dai1.getInfoOnComponent(1)=="c1da1");
5309         self.assertTrue(dai1.getInfoOnComponent(2)=="c0da3");
5310         self.assertTrue(dai1.getInfoOnComponent(3)=="c1da3");
5311         self.assertTrue(dai1.getInfoOnComponent(4)=="c2da3");
5312         for i in xrange(35):
5313             self.assertEqual(int(expected1[i]),dai1.getIJ(0,i));
5314             pass
5315         # test of static method DataArrayDouble::meld
5316         da4=DataArrayDouble.Meld(da1C,da3);
5317         tmp=DataArrayDouble.Meld([da1C,da3]);
5318         self.assertTrue(da4.isEqual(tmp,1e-10))
5319         self.assertEqual(5,da4.getNumberOfComponents());
5320         self.assertEqual(7,da4.getNumberOfTuples());
5321         self.assertTrue(da4.getInfoOnComponent(0)=="c0da1");
5322         self.assertTrue(da4.getInfoOnComponent(1)=="c1da1");
5323         self.assertTrue(da4.getInfoOnComponent(2)=="c0da3");
5324         self.assertTrue(da4.getInfoOnComponent(3)=="c1da3");
5325         self.assertTrue(da4.getInfoOnComponent(4)=="c2da3");
5326         for i in xrange(35):
5327             self.assertAlmostEqual(expected1[i],da4.getIJ(0,i),10);
5328             pass
5329         # test of static method DataArrayInt::meld
5330         dai1=da1C.convertToIntArr();
5331         dai4=DataArrayInt.Meld(dai1,dai3);
5332         tmp=DataArrayInt.Meld([dai1,dai3]);
5333         self.assertTrue(dai4.isEqual(tmp))
5334         self.assertEqual(5,dai4.getNumberOfComponents());
5335         self.assertEqual(7,dai4.getNumberOfTuples());
5336         self.assertTrue(dai4.getInfoOnComponent(0)=="c0da1");
5337         self.assertTrue(dai4.getInfoOnComponent(1)=="c1da1");
5338         self.assertTrue(dai4.getInfoOnComponent(2)=="c0da3");
5339         self.assertTrue(dai4.getInfoOnComponent(3)=="c1da3");
5340         self.assertTrue(dai4.getInfoOnComponent(4)=="c2da3");
5341         for i in xrange(35):
5342             self.assertEqual(int(expected1[i]),dai4.getIJ(0,i));
5343             pass
5344         pass
5345
5346     def testFieldMeld1(self):
5347         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5348         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
5349         f1.setMesh(m);
5350         da1=DataArrayDouble.New();
5351         arr1=[12.,23.,34.,45.,56.]
5352         da1.setValues(arr1,5,1);
5353         da1.setInfoOnComponent(0,"aaa");
5354         f1.setArray(da1);
5355         f1.setTime(3.4,2,1);
5356         f1.checkCoherency();
5357         #
5358         f2=f1.deepCpy();
5359         f2.setMesh(f1.getMesh());
5360         f2.checkCoherency();
5361         f2.changeNbOfComponents(2,5.);
5362         f2.assign(5.);
5363         f2.getArray().setInfoOnComponent(0,"bbb");
5364         f2.getArray().setInfoOnComponent(1,"ccc");
5365         f2.checkCoherency();
5366         #
5367         f3=MEDCouplingFieldDouble.MeldFields(f2,f1);
5368         f3.checkCoherency();
5369         self.assertEqual(5,f3.getNumberOfTuples());
5370         self.assertEqual(3,f3.getNumberOfComponents());
5371         self.assertTrue(f3.getArray().getInfoOnComponent(0)=="bbb");
5372         self.assertTrue(f3.getArray().getInfoOnComponent(1)=="ccc");
5373         self.assertTrue(f3.getArray().getInfoOnComponent(2)=="aaa");
5374         expected1=[5.,5.,12.,5.,5.,23.,5.,5.,34.,5.,5.,45.,5.,5.,56.]
5375         for i in xrange(15):
5376             self.assertAlmostEqual(expected1[i],f3.getIJ(0,i),12);
5377             pass
5378         time,dt,it=f3.getTime();
5379         self.assertAlmostEqual(3.4,time,14);
5380         self.assertEqual(2,dt);
5381         self.assertEqual(1,it);
5382         #
5383         f4=f2.buildNewTimeReprFromThis(NO_TIME,False);
5384         f5=f1.buildNewTimeReprFromThis(NO_TIME,False);
5385         f6=MEDCouplingFieldDouble.MeldFields(f4,f5);
5386         f6.checkCoherency();
5387         self.assertEqual(5,f6.getNumberOfTuples());
5388         self.assertEqual(3,f6.getNumberOfComponents());
5389         self.assertTrue(f6.getArray().getInfoOnComponent(0)=="bbb");
5390         self.assertTrue(f6.getArray().getInfoOnComponent(1)=="ccc");
5391         self.assertTrue(f6.getArray().getInfoOnComponent(2)=="aaa");
5392         for i in xrange(15):
5393             self.assertAlmostEqual(expected1[i],f6.getIJ(0,i),12);
5394             pass
5395         #
5396         pass
5397
5398     def testMergeNodes2(self):
5399         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5400         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
5401         vec=[0.002,0.]
5402         m2.translate(vec);
5403         #
5404         m3=MEDCouplingUMesh.MergeUMeshes([m1,m2]);
5405         da,b,newNbOfNodes=m3.mergeNodes2(0.01);
5406         self.assertEqual(9,m3.getNumberOfNodes());
5407         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]
5408         for i in xrange(18):
5409             self.assertAlmostEqual(expected1[i],m3.getCoords().getIJ(0,i),13);
5410             pass
5411         #
5412         pass
5413
5414     def testMergeField2(self):
5415         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5416         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
5417         f1.setMesh(m);
5418         arr=DataArrayDouble.New();
5419         arr.alloc(5,2);
5420         arr.fillWithValue(2.);
5421         f1.setArray(arr);
5422         f2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
5423         f2.setMesh(m);
5424         arr=DataArrayDouble.New();
5425         arr.alloc(5,2);
5426         arr.fillWithValue(5.);
5427         f2.setArray(arr);
5428         f3=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
5429         f3.setMesh(m);
5430         arr=DataArrayDouble.New();
5431         arr.alloc(5,2);
5432         arr.fillWithValue(7.);
5433         f3.setArray(arr);
5434         #
5435         f4=MEDCouplingFieldDouble.MergeFields([f1,f2,f3]);
5436         self.assertEqual(15,f4.getMesh().getNumberOfCells());
5437         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.]
5438         for i in xrange(30):
5439             self.assertAlmostEqual(expected1[i],f4.getIJ(0,i),13);
5440             pass
5441         #
5442         pass
5443
5444     def testDAIBuildComplement1(self):
5445         a=DataArrayInt.New();
5446         tab=[3,1,7,8]
5447         a.setValues(tab,4,1);
5448         b=a.buildComplement(12);
5449         self.assertEqual(8,b.getNumberOfTuples());
5450         self.assertEqual(1,b.getNumberOfComponents());
5451         expected1=[0,2,4,5,6,9,10,11]
5452         for i in xrange(8):
5453             self.assertEqual(expected1[i],b.getIJ(0,i));
5454             pass
5455         pass
5456
5457     def testDAIBuildUnion1(self):
5458         a=DataArrayInt.New();
5459         tab1=[3,1,7,8]
5460         a.setValues(tab1,4,1);
5461         c=DataArrayInt.New();
5462         tab2=[5,3,0,18,8]
5463         c.setValues(tab2,5,1);
5464         b=a.buildUnion(c);
5465         self.assertEqual(7,b.getNumberOfTuples());
5466         self.assertEqual(1,b.getNumberOfComponents());
5467         expected1=[0,1,3,5,7,8,18]
5468         for i in xrange(7):
5469             self.assertEqual(expected1[i],b.getIJ(0,i));
5470             pass
5471         b=DataArrayInt.BuildUnion([a,c]);
5472         self.assertEqual(7,b.getNumberOfTuples());
5473         self.assertEqual(1,b.getNumberOfComponents());
5474         expected1=[0,1,3,5,7,8,18]
5475         for i in xrange(7):
5476             self.assertEqual(expected1[i],b.getIJ(0,i));
5477             pass
5478         pass
5479
5480     def testDAIBuildIntersection1(self):
5481         a=DataArrayInt.New();
5482         tab1=[3,1,7,8]
5483         a.setValues(tab1,4,1);
5484         c=DataArrayInt.New();
5485         tab2=[5,3,0,18,8]
5486         c.setValues(tab2,5,1);
5487         b=a.buildIntersection(c);
5488         self.assertEqual(2,b.getNumberOfTuples());
5489         self.assertEqual(1,b.getNumberOfComponents());
5490         expected1=[3,8]
5491         for i in xrange(2):
5492             self.assertEqual(expected1[i],b.getIJ(0,i));
5493             pass
5494         b=DataArrayInt.BuildIntersection([a,c]);
5495         self.assertEqual(2,b.getNumberOfTuples());
5496         self.assertEqual(1,b.getNumberOfComponents());
5497         expected1=[3,8]
5498         for i in xrange(2):
5499             self.assertEqual(expected1[i],b.getIJ(0,i));
5500             pass
5501         pass
5502
5503     def testDAIDeltaShiftIndex1(self):
5504         a=DataArrayInt.New();
5505         tab=[1,3,6,7,7,9,15]
5506         a.setValues(tab,7,1);
5507         b=a.deltaShiftIndex();
5508         self.assertEqual(6,b.getNumberOfTuples());
5509         self.assertEqual(1,b.getNumberOfComponents());
5510         expected1=[2,3,1,0,2,6]
5511         for i in xrange(6):
5512             self.assertEqual(expected1[i],b.getIJ(0,i));
5513             pass
5514         pass
5515
5516     def testDaDoubleSelectByTupleIdSafe1(self):
5517         a=DataArrayDouble.New();
5518         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]
5519         a.setValues(arr1,7,2);
5520         a.setInfoOnComponent(0,"toto");
5521         a.setInfoOnComponent(1,"tata");
5522         #
5523         arr2=[4,2,0,6,5]
5524         b=a.selectByTupleIdSafe(arr2);
5525         self.assertEqual(5,b.getNumberOfTuples());
5526         self.assertEqual(2,b.getNumberOfComponents());
5527         self.assertTrue(b.getInfoOnComponent(0)=="toto");
5528         self.assertTrue(b.getInfoOnComponent(1)=="tata");
5529         expected1=[5.1,15.1,3.1,13.1,1.1,11.1,7.1,17.1,6.1,16.1]
5530         for i in xrange(10):
5531             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
5532             pass
5533         arr4=[4,-1,0,6,5]
5534         self.assertRaises(InterpKernelException,a.selectByTupleIdSafe,arr4);
5535         arr5=[4,2,0,6,7]
5536         self.assertRaises(InterpKernelException,a.selectByTupleIdSafe,arr5);
5537         #
5538         c=DataArrayInt.New();
5539         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
5540         c.setValues(arr3,7,2);
5541         c.setInfoOnComponent(0,"toto");
5542         c.setInfoOnComponent(1,"tata");
5543         d=c.selectByTupleIdSafe(arr2);
5544         self.assertEqual(5,d.getNumberOfTuples());
5545         self.assertEqual(2,d.getNumberOfComponents());
5546         self.assertTrue(d.getInfoOnComponent(0)=="toto");
5547         self.assertTrue(d.getInfoOnComponent(1)=="tata");
5548         expected2=[5,15,3,13,1,11,7,17,6,16]
5549         for i in xrange(10):
5550             self.assertEqual(expected2[i],d.getIJ(0,i));
5551             pass
5552         self.assertRaises(InterpKernelException,c.selectByTupleIdSafe,arr4);
5553         self.assertRaises(InterpKernelException,c.selectByTupleIdSafe,arr5);
5554         pass
5555
5556     def testAreCellsIncludedIn1(self):
5557         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5558         pt=[1,3]
5559         m2=m.buildPartOfMySelf(pt,True);
5560         ret,tmp=m.areCellsIncludedIn(m2,0)
5561         self.assertTrue(ret);
5562         self.assertEqual(2,tmp.getNumberOfTuples());
5563         self.assertEqual(1,tmp.getNumberOfComponents());
5564         self.assertEqual(pt[0],tmp.getIJ(0,0));
5565         self.assertEqual(pt[1],tmp.getIJ(0,1));
5566         ret,tmp=m2.areCellsIncludedIn(m,0)
5567         self.assertTrue(not ret);
5568         m3=MEDCouplingUMesh.MergeUMeshesOnSameCoords(m,m2)
5569         c,cI=m3.findCommonCells(2,m.getNumberOfCells())
5570         self.assertTrue(c.isEqual(DataArrayInt([1,5,3,6])))
5571         self.assertTrue(cI.isEqual(DataArrayInt([0,2,4])))
5572         pass
5573
5574     def testSwigErrorProtection1(self):
5575         m=MEDCouplingDataForTest.build3DTargetMesh_1();
5576         m.rotate([0.,0.,0.],[0.3,0.6,1.2],0.37)
5577         m.rotate([0.,0.,0.],[0.3,6,1.2],0.37)
5578         self.assertRaises(InterpKernelException,m.rotate,[0.,0.,0.],(0.3,6,"1.2"),0.37)
5579         self.assertRaises(InterpKernelException,m.rotate,[0.,"0.",0.],[0.3,0.6,1.2],0.37)
5580         self.assertRaises(InterpKernelException,m.rotate,[0.,0.,0.],[0.3,'0.6',1.2],0.37)
5581         m2=m.buildPartOfMySelf([2,5],True)
5582         m3=m.buildPartOfMySelf((2,5),True)
5583         self.assertTrue(m2.isEqual(m3,1e-12))
5584         self.assertRaises(InterpKernelException,m.buildPartOfMySelf,[2,5.],True)
5585         da1=m.getCoords().keepSelectedComponents([1])
5586         da2=m.getCoords().keepSelectedComponents((1,))
5587         self.assertTrue(da1.isEqual(da2,1e-12))
5588         self.assertRaises(InterpKernelException,m.getCoords().keepSelectedComponents,["1"])
5589         pass
5590
5591     def testDAIBuildSubstraction1(self):
5592         a=DataArrayInt.New()
5593         aa=[2,3,6,8,9]
5594         a.setValues(aa,5,1)
5595         b=DataArrayInt.New()
5596         bb=[1,3,5,9,11]
5597         b.setValues(bb,5,1)
5598         self.assertEqual([2,6,8],a.buildSubstraction(b).getValues())
5599         pass
5600
5601     def testBuildOrthogonalField2(self):
5602         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5603         d1=DataArrayInt.New();
5604         d2=DataArrayInt.New();
5605         d3=DataArrayInt.New();
5606         d4=DataArrayInt.New();
5607         m1=m.buildDescendingConnectivity(d1,d2,d3,d4);
5608         #
5609         f1=m1.buildOrthogonalField();
5610         da1=f1.getArray();
5611         self.assertEqual(2,da1.getNumberOfComponents());
5612         self.assertEqual(13,da1.getNumberOfTuples());
5613         #
5614         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.];
5615         for i in xrange(26):
5616             self.assertAlmostEqual(expected1[i],da1.getIJ(0,i),14);
5617             pass
5618         pass
5619
5620     def testSwigErrorProtection2(self):
5621         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5622         coo=m.getCoords()
5623         c=m.getNodalConnectivity()
5624         ci=m.getNodalConnectivityIndex()
5625         del m
5626         self.assertEqual(2,coo.getNumberOfComponents());
5627         self.assertEqual(6,ci.getNumberOfTuples());
5628         self.assertEqual(23,c.getNumberOfTuples());
5629         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5630         f=m.getMeasureField(True)
5631         c=f.getArray()
5632         del f
5633         self.assertEqual(1,c.getNumberOfComponents());
5634         m=MEDCouplingCMesh.New()
5635         x=DataArrayDouble.New()
5636         x.setValues([1.,2.,4.],3,1)
5637         m.setCoordsAt(0,x)
5638         del x
5639         xx=m.getCoordsAt(0)
5640         del m
5641         self.assertEqual(3,xx.getNumberOfTuples());
5642         #
5643         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5644         f=m.getMeasureField(True)
5645         m2=f.getMesh()
5646         del m
5647         del f
5648         self.assertEqual(5,m2.getNumberOfCells());
5649         pass
5650
5651     def testUMInsertNextCell1(self):
5652         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 ]
5653         targetConn=[0,3,4,1, 1,4,2, 4,5,2, 6,7,4,3, 7,8,5,4]
5654         targetMesh=MEDCouplingUMesh.New();
5655         targetMesh.allocateCells(5);
5656         self.assertRaises(InterpKernelException,targetMesh.insertNextCell,NORM_QUAD4,4,targetConn[0:4])
5657         targetMesh.setMeshDimension(2);
5658         targetMesh.insertNextCell(NORM_QUAD4,4,targetConn[0:4])
5659         self.assertRaises(InterpKernelException,targetMesh.insertNextCell,NORM_TETRA4,4,targetConn[0:4])
5660         self.assertRaises(InterpKernelException,targetMesh.insertNextCell,NORM_SEG2,2,targetConn[0:2])
5661         self.assertRaises(InterpKernelException,targetMesh.insertNextCell,NORM_POINT1,1,targetConn[0:1])
5662         targetMesh.insertNextCell(NORM_TRI3,3,targetConn[4:7])
5663         targetMesh.insertNextCell(NORM_TRI3,3,targetConn[7:10])
5664         targetMesh.insertNextCell(NORM_QUAD4,4,targetConn[10:14])
5665         targetMesh.insertNextCell(NORM_QUAD4,4,targetConn[14:18])
5666         targetMesh.finishInsertingCells();
5667         myCoords=DataArrayDouble.New();
5668         myCoords.setValues(targetCoords,9,2);
5669         targetMesh.setCoords(myCoords);
5670         targetMesh.checkCoherency();
5671         pass
5672
5673     def testFieldOperatorDivDiffComp1(self):
5674         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5675         m1,d0,d1,d2,d3=m.buildDescendingConnectivity();
5676         #
5677         f1=m1.buildOrthogonalField();
5678         arr1=[2.,3.,4.,5.,6.,7.,8.,9.,10.,11.,12.,13.,14.]
5679         arr=DataArrayDouble.New();
5680         arr.setValues(arr1,13,1);
5681         f2=MEDCouplingFieldDouble.New(ON_CELLS);
5682         f2.setArray(arr);
5683         f2.setMesh(m1);
5684         f2.checkCoherency();
5685         #
5686         f3=f1/f2;
5687         self.assertRaises(InterpKernelException,f2.__div__,f1)
5688         f3.checkCoherency();
5689         f1/=f2;
5690         #self.assertRaises(InterpKernelException,f2.__idiv__,f1) # mem leaks
5691         self.assertTrue(f1.isEqual(f3,1e-10,1e-10));
5692         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]
5693         for i in xrange(26):
5694             self.assertAlmostEqual(expected1[i],f3.getIJ(0,i),10);
5695             pass
5696         pass
5697
5698     def testDARearrange1(self):
5699         da1=DataArrayInt.New();
5700         da1.alloc(12,1);
5701         da1.iota(0);
5702         #
5703         self.assertEqual(12,da1.getNbOfElems());
5704         self.assertEqual(1,da1.getNumberOfComponents());
5705         self.assertEqual(12,da1.getNumberOfTuples());
5706         da1.rearrange(4);
5707         self.assertEqual(12,da1.getNbOfElems());
5708         self.assertEqual(4,da1.getNumberOfComponents());
5709         self.assertEqual(3,da1.getNumberOfTuples());
5710         for i in xrange(12):
5711             self.assertEqual(i,da1.getIJ(0,i));
5712         #
5713         da1.rearrange(6);
5714         self.assertEqual(12,da1.getNbOfElems());
5715         self.assertEqual(6,da1.getNumberOfComponents());
5716         self.assertEqual(2,da1.getNumberOfTuples());
5717         for i in xrange(12):
5718             self.assertEqual(i,da1.getIJ(0,i));
5719         #
5720         self.assertRaises(InterpKernelException,da1.rearrange,7);
5721         #
5722         da1.rearrange(12);
5723         self.assertEqual(12,da1.getNbOfElems());
5724         self.assertEqual(12,da1.getNumberOfComponents());
5725         self.assertEqual(1,da1.getNumberOfTuples());
5726         for i in xrange(12):
5727             self.assertEqual(i,da1.getIJ(0,i));
5728         #
5729         da1.rearrange(3);
5730         self.assertEqual(12,da1.getNbOfElems());
5731         self.assertEqual(3,da1.getNumberOfComponents());
5732         self.assertEqual(4,da1.getNumberOfTuples());
5733         for i in xrange(12):
5734             self.assertEqual(i,da1.getIJ(0,i));
5735         #double
5736         da2=da1.convertToDblArr();
5737         st=da2.getHiddenCppPointer()
5738         #
5739         self.assertEqual(12,da2.getNbOfElems());
5740         self.assertEqual(3,da2.getNumberOfComponents());
5741         self.assertEqual(4,da2.getNumberOfTuples());
5742         da2.rearrange(4);
5743         self.assertEqual(12,da2.getNbOfElems());
5744         self.assertEqual(4,da2.getNumberOfComponents());
5745         self.assertEqual(3,da2.getNumberOfTuples());
5746         for i in xrange(12):
5747             self.assertAlmostEqual(float(i),da2.getIJ(0,i),14);
5748         #
5749         da2.rearrange(6);
5750         self.assertEqual(12,da2.getNbOfElems());
5751         self.assertEqual(6,da2.getNumberOfComponents());
5752         self.assertEqual(2,da2.getNumberOfTuples());
5753         for i in xrange(12):
5754             self.assertAlmostEqual(float(i),da2.getIJ(0,i),14);
5755         #
5756         self.assertRaises(InterpKernelException,da2.rearrange,7);
5757         #
5758         da2.rearrange(1);
5759         self.assertEqual(st,da2.getHiddenCppPointer())
5760         self.assertEqual(12,da2.getNbOfElems());
5761         self.assertEqual(1,da2.getNumberOfComponents());
5762         self.assertEqual(12,da2.getNumberOfTuples());
5763         for i in xrange(12):
5764             self.assertAlmostEqual(float(i),da2.getIJ(0,i),14);
5765         #
5766         da2.rearrange(3);
5767         self.assertEqual(12,da2.getNbOfElems());
5768         self.assertEqual(3,da2.getNumberOfComponents());
5769         self.assertEqual(4,da2.getNumberOfTuples());
5770         for i in xrange(12):
5771             self.assertAlmostEqual(float(i),da2.getIJ(0,i),14);
5772         pass
5773
5774     def testDARearrange2(self):
5775         da1=DataArrayInt.New();
5776         arr=[1,2,3,2,2,3,5,1,5,5,2,2]
5777         da1.setValues(arr,4,3);
5778         s=da1.getDifferentValues();
5779         expected1=DataArrayInt([1,2,3,5])
5780         self.assertTrue(expected1.isEqual(s));
5781         pass
5782
5783     def testSwigErrorProtection3(self):
5784         da=DataArrayInt.New()
5785         da.setValues([1,2,3,4,0,0,0,0,0,0,0,0],4,3)
5786         self.assertEqual([1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0],da.getValues())
5787         self.assertEqual(3,da.getNumberOfComponents());
5788         self.assertEqual(4,da.getNumberOfTuples());
5789         da=DataArrayInt.New()
5790         da.setValues(((1,2,3),(4,4,3),(0,0,0),(0,0,0)),4,3)
5791         self.assertEqual([1, 2, 3, 4, 4, 3, 0, 0, 0, 0, 0, 0],da.getValues())
5792         self.assertEqual(3,da.getNumberOfComponents());
5793         self.assertEqual(4,da.getNumberOfTuples());
5794         da.setValues((10*[1]+290*[2])[:12],4,3)
5795         self.assertEqual(10*[1]+[2,2],da.getValues())
5796         self.assertEqual(3,da.getNumberOfComponents());
5797         self.assertEqual(4,da.getNumberOfTuples());
5798         #
5799         da=DataArrayDouble.New()
5800         da.setValues([1,2,3.,4,0,0,0,0,0,0,0,0],4,3)
5801         self.assertEqual([1., 2., 3., 4., 0., 0., 0., 0., 0., 0., 0., 0.],da.getValues())
5802         self.assertEqual(3,da.getNumberOfComponents());
5803         self.assertEqual(4,da.getNumberOfTuples());
5804         da=DataArrayDouble.New()
5805         da.setValues(((1,2,3),(4.,4,3),(0,0,0),(0,0,0)),4,3)
5806         self.assertEqual([1., 2., 3., 4., 4., 3., 0., 0., 0., 0., 0., 0.],da.getValues())
5807         self.assertEqual(3,da.getNumberOfComponents());
5808         self.assertEqual(4,da.getNumberOfTuples());
5809         da.setValues((10*[1]+290*[2])[:12],4,3)
5810         self.assertEqual(10*[1.]+[2.,2.],da.getValues())
5811         self.assertEqual(3,da.getNumberOfComponents());
5812         self.assertEqual(4,da.getNumberOfTuples());
5813         pass
5814
5815     def testDAIBuildPermutationArr1(self):
5816         a=DataArrayInt.New()
5817         a.setValues([4,5,6,7,8],5,1)
5818         b=DataArrayInt.New()
5819         b.setValues([5,4,8,6,7],5,1)
5820         c=a.buildPermutationArr(b)
5821         self.assertEqual([1,0,4,2,3],c.getValues())
5822         self.assertTrue(a.isEqualWithoutConsideringStrAndOrder(b))
5823         b.setIJ(0,0,9)
5824         self.assertTrue(not a.isEqualWithoutConsideringStrAndOrder(b))
5825         self.assertRaises(InterpKernelException,a.buildPermutationArr,b)
5826         a.setIJ(3,0,4)
5827         b.setIJ(0,0,5)
5828         b.setIJ(4,0,4)#a==[4,5,6,4,8] and b==[5,4,8,6,4]
5829         self.assertTrue(a.isEqualWithoutConsideringStrAndOrder(b))
5830         c=a.buildPermutationArr(b)
5831         self.assertEqual([1,3,4,2,3],c.getValues())
5832         d=b.convertToDblArr()
5833         expect3=[4,4,5,6,8]
5834         b.sort()
5835         self.assertEqual(expect3,b.getValues())
5836         d.sort()
5837         self.assertEqual(5,d.getNumberOfTuples());
5838         self.assertEqual(1,d.getNumberOfComponents());
5839         for i in xrange(5):
5840             self.assertAlmostEqual(float(expect3[i]),d.getIJ(i,0),14);
5841             pass
5842         pass
5843
5844     def testAreCellsIncludedIn2(self):
5845         myName="Vitoo";
5846         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5847         m2=m.buildPartOfMySelf([],True);
5848         self.assertEqual(0,m2.getNumberOfCells());
5849         self.assertEqual(3,m2.getSpaceDimension());
5850         self.assertEqual(2,m2.getMeshDimension());
5851         m2.setName(myName);
5852         test,tmp=m.areCellsIncludedIn(m2,0)
5853         self.assertTrue(test);
5854         self.assertEqual(myName,tmp.getName());
5855         self.assertEqual(0,tmp.getNumberOfTuples())
5856         self.assertEqual(1,tmp.getNumberOfComponents())
5857         pass
5858
5859     def testUMeshGetPartBarycenterAndOwner1(self):
5860         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5861         part1=[1,0,4];
5862         part=DataArrayInt.New();
5863         part.setValues(part1,3,1);
5864         b=m1.getPartBarycenterAndOwner(part);
5865         self.assertEqual(2,b.getNumberOfComponents());
5866         self.assertEqual(3,b.getNumberOfTuples());
5867         expected1=[0.36666666666666665,-0.13333333333333333,-0.05,-0.05,0.45,0.45];
5868         for i in xrange(6):
5869             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
5870             pass
5871         pass
5872
5873     def testUMeshGetPartMeasureField1(self):
5874         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5875         part1=[1,0,4];
5876         part=DataArrayInt.New();
5877         part.setValues(part1,3,1);
5878         b=m1.getPartMeasureField(True,part);
5879         self.assertEqual(1,b.getNumberOfComponents());
5880         self.assertEqual(3,b.getNumberOfTuples());
5881         expected1=[0.125,0.25,0.25];
5882         for i in xrange(3):
5883             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
5884             pass
5885         pass
5886
5887     def testUMeshBuildPartOrthogonalField1(self):
5888         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5889         m1.changeSpaceDimension(3);
5890         part1=[1,0,4];
5891         part=DataArrayInt.New();
5892         part.setValues(part1,3,1);
5893         b=m1.buildPartOrthogonalField(part);
5894         self.assertEqual(3,b.getArray().getNumberOfComponents());
5895         self.assertEqual(3,b.getArray().getNumberOfTuples());
5896         expected1=[0.,0.,-1.,0.,0.,-1.,0.,0.,-1.];
5897         for i in xrange(9):
5898             self.assertAlmostEqual(expected1[i],b.getArray().getIJ(0,i),14);
5899             pass
5900         pass
5901
5902     def testUMeshGetTypesOfPart1(self):
5903         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5904         part1=[0,3,4];
5905         p1=DataArrayInt.New()
5906         p1.setValues(part1,3,1)
5907         s=m1.getTypesOfPart(p1);
5908         self.assertEqual([NORM_QUAD4],s);
5909         part2=[2,2,2,1];
5910         p2=DataArrayInt.New()
5911         p2.setValues(part2,4,1)
5912         s=m1.getTypesOfPart(p2);
5913         self.assertEqual([NORM_TRI3],s);
5914         part3=[3,2,1];
5915         p3=DataArrayInt.New()
5916         p3.setValues(part3,3,1)
5917         s=m1.getTypesOfPart(p3);
5918         self.assertEqual(s,[NORM_TRI3,NORM_QUAD4]);
5919         pass
5920
5921     def testUMeshKeepCellIdsByType1(self):
5922         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5923         part1=[0,3,4]
5924         p1=DataArrayInt.New()
5925         p1.setValues(part1,3,1)
5926         p1.setName("p1")
5927         a=m1.keepCellIdsByType(NORM_TRI3,p1);
5928         self.assertEqual("p1",a.getName())
5929         self.assertEqual(1,a.getNumberOfComponents());
5930         self.assertEqual(0,a.getNumberOfTuples());
5931         #
5932         part2=[3,2,0,2,4]
5933         p2=DataArrayInt.New()
5934         p2.setValues(part2,5,1)
5935         p2.setName("p2")
5936         a=m1.keepCellIdsByType(NORM_TRI3,p2);
5937         self.assertEqual("p2",a.getName())
5938         self.assertEqual(1,a.getNumberOfComponents());
5939         self.assertEqual(2,a.getNumberOfTuples());
5940         self.assertEqual(2,a.getIJ(0,0));
5941         self.assertEqual(2,a.getIJ(1,0));
5942         #
5943         a=m1.keepCellIdsByType(NORM_QUAD4,p2);
5944         self.assertEqual("p2",a.getName())
5945         self.assertEqual(1,a.getNumberOfComponents());
5946         self.assertEqual(3,a.getNumberOfTuples());
5947         self.assertEqual(3,a.getIJ(0,0));
5948         self.assertEqual(0,a.getIJ(1,0));
5949         self.assertEqual(4,a.getIJ(2,0));
5950         pass
5951
5952     def testSwigErrorDaIntSelectByTupleId1(self):
5953         a=DataArrayInt.New();
5954         arr1=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
5955         a.setValues(arr1,7,2);
5956         a.setInfoOnComponent(0,"toto");
5957         a.setInfoOnComponent(1,"tata");
5958         #
5959         arr2=[4,2,0,6,5]
5960         b=a.selectByTupleId(arr2);
5961         self.assertEqual(5,b.getNumberOfTuples());
5962         self.assertEqual(2,b.getNumberOfComponents());
5963         self.assertTrue(b.getInfoOnComponent(0)=="toto");
5964         self.assertTrue(b.getInfoOnComponent(1)=="tata");
5965         expected1=[5,15,3,13,1,11,7,17,6,16]
5966         self.assertEqual(expected1,b.getValues())
5967         #
5968         a2=DataArrayInt.New()
5969         a2.setValues(arr2,5,1)
5970         b=a.selectByTupleId(a2);
5971         self.assertEqual(5,b.getNumberOfTuples());
5972         self.assertEqual(2,b.getNumberOfComponents());
5973         self.assertTrue(b.getInfoOnComponent(0)=="toto");
5974         self.assertTrue(b.getInfoOnComponent(1)=="tata");
5975         expected1=[5,15,3,13,1,11,7,17,6,16]
5976         self.assertEqual(expected1,b.getValues())
5977         pass
5978
5979     def testSwigErrorRenum(self):
5980         da=DataArrayDouble.New()
5981         da.setValues([7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.],10,2)
5982         d=DataArrayInt.New()
5983         d.setValues([0,2,3,1,4,5,6,8,7,9],10,1)
5984         da.renumberInPlace(d)
5985         da.renumber(d)
5986         pass
5987
5988     def testSwigGetItem1(self):
5989         da=DataArrayInt.New()
5990         da.alloc(16,3)
5991         da.rearrange(1)
5992         da.iota(7)
5993         da.rearrange(3)
5994         da.setInfoOnComponent(0,"X [m]")
5995         da.setInfoOnComponent(1,"Y [m]")
5996         da.setInfoOnComponent(2,"Z [km]")
5997         da2=da[5:-1]
5998         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())
5999         da2=da[4]
6000         self.assertEqual([19, 20, 21],da2.getValues())
6001         try:
6002             da2=da[4:17]
6003         except InterpKernelException as e:
6004             self.assertTrue(True)
6005         else:
6006             self.assertTrue(False)
6007             pass
6008         da2=da[5:-2,2]
6009         self.assertEqual([24, 27, 30, 33, 36, 39, 42, 45, 48],da2.getValues())
6010         da2=da[5:8,:]
6011         self.assertEqual([22, 23, 24, 25, 26, 27, 28, 29, 30],da2.getValues())
6012         da2=da[:]
6013         self.assertTrue(da2.isEqual(da))
6014         da2=da[:,:]
6015         self.assertTrue(da2.isEqual(da))
6016         try:
6017             da2=da[:,:,:]
6018         except InterpKernelException as e:
6019             self.assertTrue(True)
6020         else:
6021             self.assertTrue(False)
6022             pass
6023         self.assertTrue(da[5:8,-2].isEqualWithoutConsideringStr(DataArrayInt([23,26,29])))
6024         da2=da[5:8,:-2]
6025         self.assertEqual([22, 25, 28],da2.getValues())
6026         try:
6027             da2=da[5:-18,2]
6028         except InterpKernelException as e:
6029             self.assertTrue(True)
6030         else:
6031             self.assertTrue(False)
6032             pass
6033         da2=da[5:5,2]
6034         self.assertEqual([],da2.getValues())
6035         pass
6036
6037     def testSwigGetItem2(self):
6038         da=DataArrayDouble.New()
6039         da.alloc(16,3)
6040         da.rearrange(1)
6041         da.iota(7)
6042         da.rearrange(3)
6043         da.setInfoOnComponent(0,"X [m]")
6044         da.setInfoOnComponent(1,"Y [m]")
6045         da.setInfoOnComponent(2,"Z [km]")
6046         da2=da[5:-1]
6047         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())
6048         da2=da[4]
6049         self.assertEqual([19., 20., 21],da2.getValues())
6050         try:
6051             da2=da[4:17]
6052         except InterpKernelException as e:
6053             self.assertTrue(True)
6054         else:
6055             self.assertTrue(False)
6056             pass
6057         da2=da[5:-2,2]
6058         self.assertEqual([24., 27., 30., 33., 36., 39., 42., 45., 48.],da2.getValues())
6059         da2=da[5:8,:]
6060         self.assertEqual([22., 23., 24., 25., 26., 27., 28., 29., 30.],da2.getValues())
6061         da2=da[:]
6062         self.assertTrue(da2.isEqual(da,1e-12))
6063         da2=da[:,:]
6064         self.assertTrue(da2.isEqual(da,1e-12))
6065         try:
6066             da2=da[:,:,:]
6067         except InterpKernelException as e:
6068             self.assertTrue(True)
6069         else:
6070             self.assertTrue(False)
6071             pass
6072         self.assertTrue(da[5:8,-2].isEqualWithoutConsideringStr(DataArrayDouble([23.,26.,29.]),1e-12))
6073         da2=da[5:8,:-2]
6074         self.assertEqual([22., 25., 28.],da2.getValues())
6075         try:
6076             da2=da[5:-18,2]
6077         except InterpKernelException as e:
6078             self.assertTrue(True)
6079         else:
6080             self.assertTrue(False)
6081             pass
6082         da2=da[5:5,2]
6083         self.assertEqual([],da2.getValues())
6084         pass
6085
6086     def testSwigSetItem1(self):
6087         da=DataArrayInt.New()
6088         da.alloc(20,1)
6089         da.iota(7)
6090         da.rearrange(5)
6091         da.setInfoOnComponent(0,"X [m]") ; da.setInfoOnComponent(1,"Y [km]") ; da.setInfoOnComponent(2,"Y [m]")
6092         da.setInfoOnComponent(3,"Z [W]") ; da.setInfoOnComponent(4,"ZZ [km]") ;
6093         da[:,2]=3
6094         self.assertEqual([7, 8, 3, 10, 11, 12, 13, 3, 15, 16, 17, 18, 3, 20, 21, 22, 23, 3, 25, 26],da.getValues())
6095         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6096         da[2]=3
6097         self.assertEqual([7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 3, 3, 3, 3, 3, 22, 23, 24, 25, 26],da.getValues())
6098         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6099         da[[0,3]]=-1
6100         self.assertEqual([-1, -1, -1, -1, -1, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, -1, -1, -1, -1, -1],da.getValues())
6101         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6102         da[:,[1,3,4]]=-3
6103         self.assertEqual([7, -3, 9, -3, -3, 12, -3, 14, -3, -3, 17, -3, 19, -3, -3, 22, -3, 24, -3, -3],da.getValues())
6104         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6105         da2=DataArrayInt.New() ; da2.setValues([0,2,3],3,1)
6106         da[da2]=-7
6107         self.assertEqual([-7, -7, -7, -7, -7, 12, 13, 14, 15, 16, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7],da.getValues())
6108         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6109         da[da2,-2:]=-7
6110         self.assertEqual([7, 8, 9, -7, -7, 12, 13, 14, 15, 16, 17, 18, 19, -7, -7, 22, 23, 24, -7, -7],da.getValues())
6111         # Let's test with DAI right hand side
6112         da1=DataArrayInt.New()
6113         da1.setValues([25,26,27,125,126,127],2,3)
6114         #
6115         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6116         da[-2:,1:4]=da1
6117         self.assertEqual([7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 25, 26, 27, 21, 22, 125, 126, 127, 26],da.getValues())
6118         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6119         da[1:,3]=[225,226,227]
6120         self.assertEqual([7, 8, 9, 10, 11, 12, 13, 14, 225, 16, 17, 18, 19, 226, 21, 22, 23, 24, 227, 26],da.getValues())
6121         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6122         da[1,2:]=[225,226,227]
6123         self.assertEqual([7, 8, 9, 10, 11, 12, 13, 225, 226, 227, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26],da.getValues())
6124         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6125         da[da2,-2:]=[88,99,1010,1111,1212,1313]
6126         self.assertEqual([7, 8, 9, 88, 99, 12, 13, 14, 15, 16, 17, 18, 19, 1010, 1111, 22, 23, 24, 1212, 1313],da.getValues())
6127         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6128         da3=DataArrayInt.New(); da3.setValues([88,99,1010,1111,1212,1313],3,2)
6129         da[da2,-2:]=da3
6130         self.assertEqual([7, 8, 9, 88, 99, 12, 13, 14, 15, 16, 17, 18, 19, 1010, 1111, 22, 23, 24, 1212, 1313],da.getValues())
6131         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6132         da[da2,[0,2]]=da3
6133         self.assertEqual([88, 8, 99, 10, 11, 12, 13, 14, 15, 16, 1010, 18, 1111, 20, 21, 1212, 23, 1313, 25, 26],da.getValues())
6134         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6135         da[da2,0:3:2]=da3
6136         self.assertEqual([88, 8, 99, 10, 11, 12, 13, 14, 15, 16, 1010, 18, 1111, 20, 21, 1212, 23, 1313, 25, 26],da.getValues())
6137         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6138         da[da2,0:3:2]=-8
6139         self.assertEqual([-8, 8, -8, 10, 11, 12, 13, 14, 15, 16, -8, 18, -8, 20, 21, -8, 23, -8, 25, 26],da.getValues())
6140         pass
6141
6142     def testSwigSetItem2(self):
6143         da=DataArrayDouble.New()
6144         da.alloc(20,1)
6145         da.iota(7)
6146         da.rearrange(5)
6147         da.setInfoOnComponent(0,"X [m]") ; da.setInfoOnComponent(1,"Y [km]") ; da.setInfoOnComponent(2,"Y [m]")
6148         da.setInfoOnComponent(3,"Z [W]") ; da.setInfoOnComponent(4,"ZZ [km]") ;
6149         da[:,2]=3.
6150         self.assertEqual([7., 8., 3., 10., 11., 12., 13., 3., 15., 16., 17., 18., 3., 20., 21., 22., 23., 3., 25., 26.],da.getValues())
6151         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6152         da[2]=3.
6153         self.assertEqual([7., 8., 9., 10., 11., 12., 13., 14., 15., 16., 3., 3., 3., 3., 3., 22., 23., 24., 25., 26.],da.getValues())
6154         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6155         da[[0,3]]=-1.
6156         self.assertEqual([-1., -1., -1., -1., -1., 12., 13., 14., 15., 16., 17., 18., 19., 20., 21., -1., -1., -1., -1., -1.],da.getValues())
6157         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6158         da[:,[1,3,4]]=-3.
6159         self.assertEqual([7., -3., 9., -3., -3., 12., -3., 14., -3., -3., 17., -3., 19., -3., -3., 22., -3., 24., -3., -3.],da.getValues())
6160         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6161         da2=DataArrayInt.New() ; da2.setValues([0,2,3],3,1)
6162         da[da2]=-7.
6163         self.assertEqual([-7., -7., -7., -7., -7., 12., 13., 14., 15., 16., -7., -7., -7., -7., -7., -7., -7., -7., -7., -7.],da.getValues())
6164         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6165         da[da2,-2:]=-7
6166         self.assertEqual([7., 8., 9., -7., -7., 12., 13., 14., 15., 16., 17., 18., 19., -7., -7., 22., 23., 24., -7., -7.],da.getValues())
6167         # Let's test with DAI right hand side
6168         da1=DataArrayDouble.New()
6169         da1.setValues([25,26,27,125,126,127],2,3)
6170         #
6171         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6172         da[-2:,1:4]=da1
6173         self.assertEqual([7., 8., 9., 10., 11., 12., 13., 14., 15., 16., 17., 25., 26., 27., 21., 22., 125., 126., 127., 26.],da.getValues())
6174         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6175         da[1:,3]=[225.,226.,227.]
6176         self.assertEqual([7., 8., 9., 10., 11., 12., 13., 14., 225., 16., 17., 18., 19., 226., 21., 22., 23., 24., 227., 26.],da.getValues())
6177         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6178         da[1,2:]=[225,226,227]
6179         self.assertEqual([7., 8., 9., 10., 11., 12., 13., 225., 226., 227., 17., 18., 19., 20., 21., 22., 23., 24., 25., 26.],da.getValues())
6180         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6181         da[da2,-2:]=[88,99,1010,1111,1212,1313]
6182         self.assertEqual([7., 8., 9., 88., 99., 12., 13., 14., 15., 16., 17., 18., 19., 1010., 1111., 22., 23., 24., 1212., 1313.],da.getValues())
6183         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6184         da3=DataArrayDouble.New(); da3.setValues([88,99,1010,1111,1212,1313],3,2)
6185         da[da2,-2:]=da3
6186         self.assertEqual([7., 8., 9., 88., 99., 12., 13., 14., 15., 16., 17., 18., 19., 1010., 1111., 22., 23., 24., 1212., 1313.],da.getValues())
6187         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6188         da[da2,[0,2]]=da3
6189         self.assertEqual([88., 8., 99., 10., 11., 12., 13., 14., 15., 16., 1010., 18., 1111., 20., 21., 1212., 23., 1313., 25., 26.],da.getValues())
6190         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6191         da[da2,0:3:2]=da3
6192         self.assertEqual([88., 8., 99., 10., 11., 12., 13., 14., 15., 16., 1010., 18., 1111., 20., 21., 1212., 23., 1313., 25., 26.],da.getValues())
6193         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6194         da[da2,0:3:2]=-8.
6195         self.assertEqual([-8., 8., -8., 10., 11., 12., 13., 14., 15., 16., -8., 18., -8., 20., 21., -8., 23., -8., 25., 26.],da.getValues())
6196         pass
6197
6198     def testSwigDADOp(self):
6199         da=DataArrayDouble.New()
6200         da.alloc(12,1)
6201         da.iota(7.)
6202         da1=DataArrayDouble.New()
6203         da1.alloc(12,1)
6204         da1.iota(8.)
6205         da2=da+da1
6206         self.assertEqual([15., 17., 19., 21., 23., 25., 27., 29., 31., 33., 35., 37.],da2.getValues())
6207         da2=da+3
6208         da3=3+da
6209         self.assertTrue(da2.isEqual(da3,1e-12))
6210         da2=da-1.
6211         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())
6212         da2=1-da
6213         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())
6214         da2=da*3
6215         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())
6216         da2=3.*da
6217         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())
6218         da2=da*da1
6219         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())
6220         da2=da/4.
6221         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())
6222         da3=4./da
6223         da4=da3*da2
6224         self.assertTrue(da4.isUniform(1.,1e-12))
6225         st1=da.getHiddenCppPointer()
6226         da+=1
6227         st2=da.getHiddenCppPointer()
6228         self.assertEqual(st1,st2)
6229         self.assertTrue(da.isEqual(da1,1e-12))
6230         da-=8
6231         st2=da.getHiddenCppPointer()
6232         self.assertEqual(st1,st2)
6233         self.assertEqual(range(12),da.getValues())
6234         da+=da1
6235         st2=da.getHiddenCppPointer()
6236         self.assertEqual(st1,st2)
6237         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())
6238         da*=0.5
6239         st2=da.getHiddenCppPointer()
6240         self.assertEqual(st1,st2)
6241         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())
6242         da*=da1
6243         st2=da.getHiddenCppPointer()
6244         self.assertEqual(st1,st2)
6245         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())
6246         da/=da1
6247         self.assertEqual(st1,st2)
6248         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())
6249         da/=2
6250         st2=da.getHiddenCppPointer()
6251         self.assertEqual(st1,st2)
6252         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())
6253         da.rearrange(3)
6254         da5=DataArrayDouble.New()
6255         da5.setValues([5.,4.,3.,2.],4,1)
6256         da*=da5 # it works with unmathing number of compo
6257         st2=da.getHiddenCppPointer()
6258         self.assertEqual(st1,st2)
6259         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())
6260         #
6261         da.alloc(30,1)
6262         da.iota(7.)
6263         da.rearrange(3)
6264         ids=DataArrayInt.New()
6265         ids.setValues([3,4,7],3,1)
6266         da[ids,:]=[5.,8.,9.]
6267         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())
6268         #
6269         da.rearrange(1) ; da.iota(7) ; da.rearrange(3)
6270         da[ids,[1,2]]=[5,8]
6271         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())
6272         pass
6273
6274     def testSwigDAIOp(self):
6275         da=DataArrayInt.New()
6276         da.alloc(12,1)
6277         da.iota(7)
6278         da1=DataArrayInt.New()
6279         da1.alloc(12,1)
6280         da1.iota(8)
6281         da2=da+da1
6282         self.assertEqual([15,17,19,21,23,25,27,29,31,33,35,37],da2.getValues())
6283         da2=da+3
6284         da3=3+da
6285         self.assertTrue(da2.isEqual(da3))
6286         da2=da-1
6287         self.assertEqual([6,7,8,9,10,11,12,13,14,15,16,17],da2.getValues())
6288         da2=1-da
6289         self.assertEqual([-6,-7,-8,-9,-10,-11,-12,-13,-14,-15,-16,-17],da2.getValues())
6290         da2=da*3
6291         self.assertEqual([21,24,27,30,33,36,39,42,45,48,51,54.0],da2.getValues())
6292         da2=3*da
6293         self.assertEqual([21,24,27,30,33,36,39,42,45,48,51,54.0],da2.getValues())
6294         da2=da*da1
6295         self.assertEqual([56,72,90,110,132,156,182,210,240,272,306,342.0],da2.getValues())
6296         da2=da/4
6297         self.assertEqual([1,2,2,2,2,3,3,3,3,4,4,4],da2.getValues())
6298         da3=4/da
6299         da4=da3*da2
6300         self.assertTrue(da4.isUniform(0))
6301         st1=da.getHiddenCppPointer()
6302         da+=1
6303         st2=da.getHiddenCppPointer()
6304         self.assertEqual(st1,st2)
6305         self.assertTrue(da.isEqual(da1))
6306         da-=8
6307         st2=da.getHiddenCppPointer()
6308         self.assertEqual(st1,st2)
6309         self.assertEqual(range(12),da.getValues())
6310         da+=da1
6311         st2=da.getHiddenCppPointer()
6312         self.assertEqual(st1,st2)
6313         self.assertEqual([8,10,12,14,16,18,20,22,24,26,28,30],da.getValues())
6314         da/=2
6315         st2=da.getHiddenCppPointer()
6316         self.assertEqual(st1,st2)
6317         self.assertEqual([4,5,6,7,8,9,10,11,12,13,14,15],da.getValues())
6318         da*=da1
6319         st2=da.getHiddenCppPointer()
6320         self.assertEqual(st1,st2)
6321         self.assertEqual([32,45,60,77,96,117,140,165,192,221,252,285],da.getValues())
6322         da/=da1
6323         self.assertEqual(st1,st2)
6324         self.assertEqual([4,5,6,7,8,9,10,11,12,13,14,15],da.getValues())
6325         da/=2
6326         st2=da.getHiddenCppPointer()
6327         self.assertEqual(st1,st2)
6328         self.assertEqual([2,2, 3,3, 4,4, 5,5, 6,6, 7,7],da.getValues())
6329         da.rearrange(3)
6330         da5=DataArrayInt.New()
6331         da5.setValues([5,4,3,2],4,1)
6332         da*=da5 # it works with unmathing number of compo
6333         st2=da.getHiddenCppPointer()
6334         self.assertEqual(st1,st2)
6335         self.assertEqual([10,10, 15,12,16,16,15,15, 18,12,14,14],da.getValues())
6336         da%=6
6337         st2=da.getHiddenCppPointer()
6338         self.assertEqual(st1,st2)
6339         self.assertEqual([4,4,3,0,4,4,3,3,0,0,2,2],da.getValues())
6340         #
6341         da.alloc(30,1)
6342         da.iota(7)
6343         da.rearrange(3)
6344         ids=DataArrayInt.New()
6345         ids.setValues([3,4,7],3,1)
6346         da[ids,:]=[5,8,9]
6347         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())
6348         #
6349         da.rearrange(1) ; da.iota(7) ; da.rearrange(3)
6350         da[ids,[1,2]]=[5,8]
6351         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())
6352         pass
6353
6354     def testSwigDAIOp2(self):
6355         da=DataArrayInt.New()
6356         st=da.getHiddenCppPointer()
6357         da.alloc(10,3)
6358         da.rearrange(1)
6359         da.iota(0)
6360         da.rearrange(3)
6361         da[:,1]+=4
6362         da[-2:,2]+=10
6363         da[-2:,2]+=10
6364         da[:,2]+=da[:,0]
6365         da[da[0],:]=7
6366         self.assertEqual(st,da.getHiddenCppPointer())
6367         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])
6368         pass
6369
6370     def testSwigDAIOp3(self):
6371         da=DataArrayInt.New()
6372         self.assertRaises(InterpKernelException,da.__len__)
6373         self.assertRaises(InterpKernelException,da.__int__)
6374         for elt in da:
6375             self.assertTrue(False)
6376             pass
6377         da.alloc(12,3)
6378         da.rearrange(1) ; da.fillWithZero()
6379         l1=list(da)
6380         self.assertEqual(36,len(da));
6381         da.rearrange(3)
6382         tmp=da[0]
6383         self.assertRaises(InterpKernelException,tmp.__int__)
6384         self.assertEqual(12,len(da));
6385         l=list(da)
6386         for elt in enumerate(l):
6387             elt[1][2]=elt[0]
6388             pass
6389         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]
6390         self.assertEqual(ref,da.getValues());
6391         da.rearrange(1)
6392         l=[int(elt) for elt in l1]
6393         self.assertEqual(ref,da.getValues());
6394         self.assertEqual(11,int(da[-1:]))
6395         pass
6396
6397     def testSwigDADOp3(self):
6398         da=DataArrayDouble.New()
6399         self.assertRaises(InterpKernelException,da.__len__)
6400         self.assertRaises(InterpKernelException,da.__float__)
6401         for elt in da:
6402             self.assertTrue(False)
6403             pass
6404         da.alloc(12,3)
6405         da.rearrange(1) ; da.fillWithZero()
6406         l1=list(da)
6407         self.assertEqual(36,len(da));
6408         da.rearrange(3)
6409         tmp=da[0]
6410         self.assertRaises(InterpKernelException,tmp.__float__)
6411         self.assertEqual(12,len(da));
6412         l=list(da)
6413         for elt in enumerate(l):
6414             elt[1][2]=elt[0]
6415             pass
6416         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.]
6417         self.assertEqual(ref,da.getValues());
6418         da.rearrange(1)
6419         l=[float(elt) for elt in l1]
6420         self.assertEqual(ref,da.getValues());
6421         self.assertEqual(11.,float(da[-1:]))
6422         pass
6423
6424     def testSwigDataArrayIntIterator1(self):
6425         da=DataArrayInt.New()
6426         da.alloc(12,1)
6427         da.iota(2)
6428         da.rearrange(3)
6429         # __getitem__ testing
6430         li=[]
6431         for it in da:
6432             li+=it[1:]
6433             pass
6434         self.assertEqual([3, 4, 6, 7, 9, 10, 12, 13],li)
6435         li=[]
6436         for it in da:
6437             li+=[it[-1]]
6438             pass
6439         self.assertEqual([4, 7, 10, 13],li)
6440         li=[]
6441         for it in da:
6442             li+=it[[2,1,0]]
6443             pass
6444         self.assertEqual([4, 3, 2, 7, 6, 5, 10, 9, 8, 13, 12, 11],li)
6445         # __setitem__ testing
6446         da3=da.deepCpy()
6447         da2=DataArrayInt.New()
6448         da2.alloc(12,1)
6449         da2.iota(2002)
6450         da2.rearrange(3)
6451         it2=da2.__iter__()
6452         i=0
6453         for it in da:
6454             pt=it2.next()
6455             it[:]=pt
6456             pass
6457         self.assertTrue(da.isEqual(da2))
6458         da=da3
6459         da3=da.deepCpy()
6460         #
6461         for it in da:
6462             it[:]=5
6463             pass
6464         da.rearrange(1)
6465         self.assertTrue(da.isUniform(5))
6466         da=da3
6467         da3=da.deepCpy()
6468         #
6469         for it in da:
6470             it[:]=[8,9,12]
6471             pass
6472         self.assertEqual([8, 9, 12, 8, 9, 12, 8, 9, 12, 8, 9, 12],da.getValues())
6473         da=da3
6474         da3=da.deepCpy()
6475         #
6476         for it in da:
6477             it[2]=[7]
6478             pass
6479         self.assertEqual([2, 3, 7, 5, 6, 7, 8, 9, 7, 11, 12, 7],da.getValues())
6480         pass
6481
6482     def testSwigDataArrayDoubleIterator1(self):
6483         da=DataArrayDouble.New()
6484         da.alloc(12,1)
6485         da.iota(2)
6486         da.rearrange(3)
6487         # __getitem__ testing
6488         li=[]
6489         for it in da:
6490             li+=it[1:]
6491             pass
6492         self.assertEqual([3, 4, 6, 7, 9, 10, 12, 13],li)
6493         li=[]
6494         for it in da:
6495             li+=[it[-1]]
6496             pass
6497         self.assertEqual([4, 7, 10, 13],li)
6498         li=[]
6499         for it in da:
6500             li+=it[[2,1,0]]
6501             pass
6502         self.assertEqual([4, 3, 2, 7, 6, 5, 10, 9, 8, 13, 12, 11],li)
6503         # __setitem__ testing
6504         da3=da.deepCpy()
6505         da2=DataArrayDouble.New()
6506         da2.alloc(12,1)
6507         da2.iota(2002)
6508         da2.rearrange(3)
6509         it2=da2.__iter__()
6510         i=0
6511         for it in da:
6512             pt=it2.next()
6513             it[:]=pt
6514             pass
6515         self.assertTrue(da.isEqual(da2,1e-12))
6516         da=da3
6517         da3=da.deepCpy()
6518         #
6519         for it in da:
6520             it[:]=5
6521             pass
6522         da.rearrange(1)
6523         self.assertTrue(da.isUniform(5,1e-12))
6524         da=da3
6525         da3=da.deepCpy()
6526         #
6527         for it in da:
6528             it[:]=[8,9,12]
6529             pass
6530         self.assertEqual([8, 9, 12, 8, 9, 12, 8, 9, 12, 8, 9, 12],da.getValues())
6531         da=da3
6532         da3=da.deepCpy()
6533         #
6534         for it in da:
6535             it[2]=[7]
6536             pass
6537         self.assertEqual([2, 3, 7, 5, 6, 7, 8, 9, 7, 11, 12, 7],da.getValues())
6538         pass
6539
6540     def testSwigUMeshIterator1(self):
6541         m=MEDCouplingDataForTest.build2DTargetMesh_1()
6542         li1=[]
6543         li2=[]
6544         for cell in m:
6545             li1+=cell.getAllConn()[1:]
6546             li2+=[cell.getType()]
6547             pass
6548         self.assertEqual(li1,[0, 3, 4, 1, 1, 4, 2, 4, 5, 2, 6, 7, 4, 3, 7, 8, 5, 4])
6549         self.assertEqual(li2,[4, 3, 3, 4, 4])
6550         pass
6551
6552     def testSwigUMeshIterator2(self):
6553         m=MEDCouplingDataForTest.build2DTargetMesh_1()
6554         self.assertRaises(InterpKernelException,m.cellsByType);
6555         m.rearrange2ConsecutiveCellTypes()
6556         li1=[]
6557         li2=[]
6558         li3=[]
6559         for cellsByType in m.cellsByType():
6560             li1.append(cellsByType.getType())
6561             li2.append(cellsByType.getNumberOfElems())
6562             temp=[]
6563             for cell in cellsByType:
6564                 t=[None,None]
6565                 t[0]=cell.getType()
6566                 t[1]=cell.getAllConn()[1:]
6567                 temp.append(t)
6568                 pass
6569             li3.append(temp)
6570             pass
6571         self.assertEqual(li1,[4, 3])
6572         self.assertEqual(li2,[3, 2])
6573         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)]]])
6574         pass
6575
6576     def testDAIAggregateMulti1(self):
6577         a=DataArrayInt.New()
6578         a.setValues(range(4),2,2)
6579         a.setName("aa")
6580         b=DataArrayInt.New()
6581         b.setValues(range(6),3,2)
6582         c=DataArrayInt.Aggregate([a,b])
6583         self.assertEqual(range(4)+range(6),c.getValues())
6584         self.assertEqual("aa",c.getName())
6585         self.assertEqual(5,c.getNumberOfTuples())
6586         self.assertEqual(2,c.getNumberOfComponents())
6587         pass
6588
6589     def testMergeUMeshes2(self):
6590         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6591         m2=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6592         m3=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6593         #
6594         vec1=[0,2,3]
6595         m2_2=m2.buildPartOfMySelf(vec1,False);
6596         vec2=[1,1]
6597         m3_2=m3.buildPartOfMySelf(vec2,False);
6598         #
6599         ms=[m1,m2_2,m3_2];
6600         #
6601         self.assertRaises(InterpKernelException,MEDCouplingUMesh.MergeUMeshes,ms+[None]);
6602         self.assertRaises(InterpKernelException,MEDCouplingUMesh.MergeUMeshes,ms+[3.4])
6603         m4=MEDCouplingUMesh.MergeUMeshes(ms);
6604         m4.checkCoherency();
6605         self.assertEqual(10,m4.getNumberOfCells());
6606         self.assertEqual(20,m4.getNumberOfNodes());
6607         self.assertEqual(45,m4.getMeshLength());
6608         m4bis=MEDCouplingMesh.MergeMeshes(ms);
6609         self.assertTrue(m4.isEqual(m4bis,1e-12))
6610         del m4bis
6611         #
6612         vec3=[0,1,2,3,4]
6613         m4_1=m4.buildPartOfMySelf(vec3,False);
6614         m4_1.setName(m1.getName());
6615         self.assertTrue(m4_1.isEqual(m1,1e-12));
6616         #
6617         vec4=[5,6,7]
6618         m4_2=m4.buildPartOfMySelf(vec4,False);
6619         cellCor,nodeCor=m4_2.checkGeoEquivalWith(m2_2,10,1e-12);
6620         #
6621         vec5=[8,9]
6622         m4_3=m4.buildPartOfMySelf(vec5,False);
6623         self.assertEqual(2,m4_3.getNumberOfCells());
6624         self.assertEqual(3,m4_3.getNumberOfNodes());
6625         m3_2.zipCoords();
6626         m4_3.setName(m3_2.getName());
6627         self.assertTrue(m4_3.isEqual(m3_2,1e-12));
6628         #
6629         pass
6630
6631     def testBuild0DMeshFromCoords1(self):
6632         sourceCoords=[-0.3,-0.3,0., 0.7,-0.3,0., -0.3,0.7,0., 0.7,0.7,0.]
6633         coo=DataArrayDouble.New();
6634         coo.setValues(sourceCoords,4,3);
6635         coo.setName("My0D");
6636         m=MEDCouplingUMesh.Build0DMeshFromCoords(coo);
6637         m.checkCoherency();
6638         self.assertEqual(4,m.getNumberOfNodes());
6639         self.assertEqual(4,m.getNumberOfCells());
6640         self.assertEqual(3,m.getSpaceDimension());
6641         self.assertEqual(0,m.getMeshDimension());
6642         types1=m.getAllGeoTypes();
6643         self.assertEqual([NORM_POINT1],types1);
6644         for i in xrange(4):
6645             conn=m.getNodeIdsOfCell(i);
6646             self.assertEqual([i],conn);
6647             self.assertTrue(NORM_POINT1==m.getTypeOfCell(i));
6648             pass
6649         self.assertEqual(m.getName(),"My0D");
6650         pass
6651
6652     def testDescriptionInMeshTimeUnit1(self):
6653         text1="totoTTEDD";
6654         m=MEDCouplingDataForTest.build2DTargetMesh_1();
6655         m.setDescription(text1);
6656         self.assertEqual(m.getDescription(),text1);
6657         m2=m.deepCpy();
6658         self.assertTrue(m.isEqual(m2,1e-12));
6659         self.assertEqual(m2.getDescription(),text1);
6660         m2.setDescription("ggg");
6661         self.assertTrue(not m.isEqual(m2,1e-12));
6662         #
6663         f=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
6664         f.setTimeUnit(text1);
6665         self.assertEqual(f.getTimeUnit(),text1);
6666         f2=f.deepCpy();
6667         self.assertEqual(f2.getTimeUnit(),text1);
6668         #
6669         pass
6670
6671     def testMultiFields1(self):
6672         mfs=MEDCouplingDataForTest.buildMultiFields_1();
6673         ms=mfs.getMeshes();
6674         dms,refs=mfs.getDifferentMeshes()
6675         das=mfs.getArrays();
6676         das2,refs2=mfs.getDifferentArrays()
6677         self.assertEqual(5,len(mfs.getFields()))
6678         self.assertEqual(1,len(mfs.getFields()[0].getArrays()));
6679         self.assertEqual(2,len(mfs.getFields()[1].getArrays()));
6680         self.assertEqual(1,len(mfs.getFields()[2].getArrays()));
6681         self.assertEqual(1,len(mfs.getFields()[3].getArrays()));
6682         self.assertEqual(1,len(mfs.getFields()[4].getArrays()));
6683         self.assertEqual(5,len(ms));
6684         self.assertEqual(2,len(dms));
6685         self.assertEqual(6,len(das));
6686         self.assertEqual(5,len(das2));
6687         mfs2=mfs.deepCpy();
6688         self.assertTrue(mfs.isEqual(mfs2,1e-12,1e-12))
6689         pass
6690
6691     def testFieldOverTime1(self):
6692         fs=MEDCouplingDataForTest.buildMultiFields_2();
6693         self.assertRaises(InterpKernelException,MEDCouplingFieldOverTime.New,fs);
6694         f4bis=fs[4].buildNewTimeReprFromThis(ONE_TIME,False);
6695         fs[4]=f4bis;
6696         self.assertRaises(InterpKernelException,MEDCouplingFieldOverTime.New,fs);
6697         f4bis.setTime(2.7,20,21);
6698         fot=MEDCouplingFieldOverTime.New(fs);
6699         dt=fot.getDefinitionTimeZone();
6700         hs=dt.getHotSpotsTime();
6701         self.assertEqual(6,len(hs));
6702         expected1=[0.2,0.7,1.2,1.35,1.7,2.7]
6703         for i in xrange(6):
6704             self.assertAlmostEqual(expected1[i],hs[i],12);
6705             pass
6706         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(0.2);
6707         self.assertEqual(0,meshId);
6708         self.assertEqual(0,arrId);
6709         self.assertEqual(0,arrIdInField);
6710         self.assertEqual(0,fieldId);
6711         #
6712         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(0.7);
6713         self.assertEqual(0,meshId);
6714         self.assertEqual(1,arrId);
6715         self.assertEqual(0,arrIdInField);
6716         self.assertEqual(1,fieldId);
6717         #
6718         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeLeft(1.2);#**** WARNING left here
6719         self.assertEqual(0,meshId);
6720         self.assertEqual(2,arrId);
6721         self.assertEqual(1,arrIdInField);
6722         self.assertEqual(1,fieldId);
6723         #
6724         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(1.2);#**** WARNING right again here
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.35);
6731         self.assertEqual(1,meshId);
6732         self.assertEqual(3,arrId);
6733         self.assertEqual(0,arrIdInField);
6734         self.assertEqual(2,fieldId);
6735         #
6736         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(1.7);
6737         self.assertEqual(0,meshId);
6738         self.assertEqual(3,arrId);
6739         self.assertEqual(0,arrIdInField);
6740         self.assertEqual(3,fieldId);
6741         #
6742         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(2.7);
6743         self.assertEqual(1,meshId);
6744         self.assertEqual(4,arrId);
6745         self.assertEqual(0,arrIdInField);
6746         self.assertEqual(4,fieldId);
6747         #
6748         dt2=MEDCouplingDefinitionTime();
6749         self.assertTrue(not dt2.isEqual(dt));
6750         dt2.assign(dt);
6751         dt2.assign(dt);#to check memory management
6752         self.assertTrue(dt2.isEqual(dt));
6753         #
6754         dt3=MEDCouplingDefinitionTime();
6755         #
6756         pass
6757
6758     def testDAICheckAndPreparePermutation1(self):
6759         vals1=[9,10,0,6,4,11,3,7];
6760         expect1=[5,6,0,3,2,7,1,4];
6761         vals2=[9,10,0,6,10,11,3,7];
6762         da=DataArrayInt.New();
6763         da.setValues(vals1,8,1);
6764         da2=da.checkAndPreparePermutation();
6765         self.assertEqual(8,da2.getNumberOfTuples());
6766         self.assertEqual(1,da2.getNumberOfComponents());
6767         for i in xrange(8):
6768             self.assertEqual(expect1[i],da2.getIJ(i,0));
6769             pass
6770         #
6771         da=DataArrayInt.New();
6772         da.alloc(8,1);
6773         da.iota(0);
6774         da2=da.checkAndPreparePermutation();
6775         self.assertEqual(8,da2.getNumberOfTuples());
6776         self.assertEqual(1,da2.getNumberOfComponents());
6777         self.assertTrue(da2.isIdentity());
6778         #
6779         da=DataArrayInt.New();
6780         da.alloc(8,1);
6781         da.setValues(vals2,8,1);
6782         self.assertRaises(InterpKernelException,da.checkAndPreparePermutation);
6783         pass
6784
6785     def testDAIChangeSurjectiveFormat1(self):
6786         vals1=[0,3,2,3,2,2,1,2]
6787         expected1=[0,1,2,6,8]
6788         expected2=[0,  6,  2,4,5,7,  1,3]
6789         da=DataArrayInt.New();
6790         da.setValues(vals1,8,1);
6791         #
6792         da2,da2I=da.changeSurjectiveFormat(4);
6793         self.assertEqual(5,da2I.getNumberOfTuples());
6794         self.assertEqual(8,da2.getNumberOfTuples());
6795         self.assertEqual(expected1,da2I.getValues());
6796         self.assertEqual(expected2,da2.getValues());
6797         #
6798         self.assertRaises(InterpKernelException,da.changeSurjectiveFormat,3);
6799         #
6800         pass
6801
6802     def testUMeshGetCellIdsLyingOnNodes1(self):
6803         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6804         nodeIds1=[1,2,3,4,6]
6805         nodeIds2=[6,7]
6806         da=m.getCellIdsLyingOnNodes(nodeIds1,True);
6807         self.assertEqual(1,da.getNumberOfTuples());
6808         self.assertEqual(1,da.getNumberOfComponents());
6809         self.assertEqual(1,da.getIJ(0,0));
6810         da2=DataArrayInt.New()
6811         da2.setValues(nodeIds2,2,1)
6812         da=m.getCellIdsLyingOnNodes(da2,False);
6813         self.assertEqual(2,da.getNumberOfTuples());
6814         self.assertEqual(1,da.getNumberOfComponents());
6815         self.assertEqual(3,da.getIJ(0,0));
6816         self.assertEqual(4,da.getIJ(1,0));
6817         pass
6818
6819     def testUMeshFindCellIdsOnBoundary1(self):
6820         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6821         da5=m.findCellIdsOnBoundary();
6822         self.assertEqual(5,da5.getNumberOfTuples());
6823         self.assertTrue(da5.isIdentity());
6824         pass
6825
6826     def testMeshSetTime1(self):
6827         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6828         m2=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6829         #
6830         self.assertTrue(m1.isEqual(m2,1e-12));
6831         m1.setTime(3.14,6,7);
6832         tmp3,tmp1,tmp2=m1.getTime();
6833         self.assertEqual(6,tmp1);
6834         self.assertEqual(7,tmp2);
6835         self.assertAlmostEqual(3.14,tmp3,12);
6836         self.assertTrue(not m1.isEqual(m2,1e-12));
6837         m2.setTime(3.14,6,7);
6838         self.assertTrue(m1.isEqual(m2,1e-12));
6839         m1.setTimeUnit("ms");
6840         self.assertTrue(m1.getTimeUnit()=="ms");
6841         m1.setTimeUnit("us");
6842         self.assertTrue(m1.getTimeUnit()=="us");
6843         self.assertTrue(not m1.isEqual(m2,1e-12));
6844         m2.setTimeUnit("us");
6845         self.assertTrue(m1.isEqual(m2,1e-12));
6846         m2.setTime(3.14,6,8);
6847         self.assertTrue(not m1.isEqual(m2,1e-12));
6848         m2.setTime(3.14,7,7);
6849         self.assertTrue(not m1.isEqual(m2,1e-12));
6850         m2.setTime(3.15,6,7);
6851         self.assertTrue(not m1.isEqual(m2,1e-12));
6852         #
6853         m1.setTime(10.34,55,12);
6854         m3=m1.deepCpy();
6855         self.assertTrue(m1.isEqual(m3,1e-12));
6856         tmp3,tmp1,tmp2=m3.getTime();
6857         self.assertEqual(55,tmp1);
6858         self.assertEqual(12,tmp2);
6859         self.assertAlmostEqual(10.34,tmp3,12);
6860         #
6861         # testing CMesh
6862         coo1=[0.,1.,2.,3.5]
6863         a=DataArrayDouble.New();
6864         a.setValues(coo1,4,1);
6865         b=MEDCouplingCMesh.New();
6866         b.setCoordsAt(0,a);
6867         #
6868         b.setTime(5.67,8,100);
6869         tmp3,tmp1,tmp2=b.getTime();
6870         self.assertEqual(8,tmp1);
6871         self.assertEqual(100,tmp2);
6872         self.assertAlmostEqual(5.67,tmp3,12);
6873         c=b.deepCpy();
6874         self.assertTrue(c.isEqual(b,1e-12));
6875         tmp3,tmp1,tmp2=c.getTime();
6876         self.assertEqual(8,tmp1);
6877         self.assertEqual(100,tmp2);
6878         self.assertAlmostEqual(5.67,tmp3,12);
6879         pass
6880
6881     def testApplyFuncTwo1(self):
6882         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6883         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
6884         f1.setMesh(m1);
6885         #
6886         vals=[1.,11.,21.,2.,12.,22.,3.,13.,23.,4.,14.,24.,5.,15.,25.]
6887         da=DataArrayDouble.New();
6888         da.setValues(vals,5,3);
6889         f1.setArray(da);
6890         #
6891         self.assertRaises(InterpKernelException,da.applyFunc2,1,"y+z");
6892         da.setInfoOnComponent(0,"x [m]");
6893         da.setInfoOnComponent(1,"y [mm]");
6894         da.setInfoOnComponent(2,"z [km]");
6895
6896         self.assertRaises(InterpKernelException, da.applyFunc2, 1, "x+y+zz+zzz");
6897         self.assertRaises(InterpKernelException, da.applyFunc2, 1, "toto(x+y)");
6898         self.assertRaises(InterpKernelException, da.applyFunc2, 1, "x/0");
6899
6900         da2=da.applyFunc2(1,"y+z");
6901         self.assertEqual(1,da2.getNumberOfComponents());
6902         self.assertEqual(5,da2.getNumberOfTuples());
6903         expected1=[32.,34.,36.,38.,40.]
6904         for i in xrange(5):
6905             self.assertAlmostEqual(expected1[i],da2.getIJ(0,i),12);
6906             pass
6907         da2=da.applyFunc(1,"y+z");
6908         expected2=[12.,14.,16.,18.,20.]
6909         for i in xrange(5):
6910             self.assertAlmostEqual(expected2[i],da2.getIJ(0,i),12);
6911             pass
6912         #
6913         self.assertEqual(3,f1.getNumberOfComponents());
6914         self.assertEqual(5,f1.getNumberOfTuples());
6915         f1.applyFunc2(1,"y+z");
6916         self.assertEqual(1,f1.getNumberOfComponents());
6917         self.assertEqual(5,f1.getNumberOfTuples());
6918         for i in xrange(5):
6919             self.assertAlmostEqual(expected1[i],f1.getArray().getIJ(0,i),12);
6920             pass
6921         #
6922         pass
6923
6924     def testApplyFuncThree1(self):
6925         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6926         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
6927         f1.setMesh(m1);
6928         #
6929         vals=[1.,11.,21.,2.,12.,22.,3.,13.,23.,4.,14.,24.,5.,15.,25.]
6930         da=DataArrayDouble.New();
6931         da.setValues(vals,5,3);
6932         f1.setArray(da);
6933         #
6934         vs=3*[None];
6935         vs[0]="x"; vs[1]="Y"; vs[2]="z";
6936         self.assertRaises(InterpKernelException, da.applyFunc3, 1, vs, "y+z");
6937         self.assertRaises(InterpKernelException, da.applyFunc3, 1, vs, "x+Y+z+zz+zzz");
6938         self.assertRaises(InterpKernelException, da.applyFunc3, 1, vs, "x/0");
6939         vs[1]="y";
6940         da2=da.applyFunc3(1,vs,"y+z");
6941         expected1=[32.,34.,36.,38.,40.]
6942         for i in xrange(5):
6943             self.assertAlmostEqual(expected1[i],da2.getIJ(0,i),12);
6944             pass
6945         self.assertRaises(InterpKernelException, da.applyFunc3, 1, ["x","y","z","a"],"x+a")
6946         f1.setArray(da);
6947         self.assertEqual(3,f1.getNumberOfComponents());
6948         self.assertEqual(5,f1.getNumberOfTuples());
6949         f1.applyFunc3(1,vs,"y+z");
6950         self.assertEqual(1,f1.getNumberOfComponents());
6951         self.assertEqual(5,f1.getNumberOfTuples());
6952         for i in xrange(5):
6953             self.assertAlmostEqual(expected1[i],f1.getArray().getIJ(0,i),12);
6954             pass
6955         pass
6956
6957     def testFillFromAnalyticTwo1(self):
6958         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6959         m1.setTime(3.4,5,6); m1.setTimeUnit("us");
6960         self.assertRaises(InterpKernelException,m1.fillFromAnalytic2,ON_NODES,1,"y+z");
6961         m1.getCoords().setInfoOnComponent(0,"x [m]");
6962         m1.getCoords().setInfoOnComponent(1,"y");
6963         m1.getCoords().setInfoOnComponent(2,"z");
6964         f1=m1.fillFromAnalytic2(ON_NODES,1,"y+z");
6965         self.assertAlmostEqual(3.4,f1.getTime()[0],12) ; self.assertEqual(5,f1.getTime()[1]) ; self.assertEqual(6,f1.getTime()[2])
6966         self.assertEqual("us",f1.getTimeUnit())
6967         self.assertEqual(1,f1.getNumberOfComponents());
6968         self.assertEqual(9,f1.getNumberOfTuples());
6969         expected1=[0.2, 0.7, 1.2, 0.7, 1.2, 1.7, 1.2, 1.7, 2.2]
6970         for i in xrange(9):
6971             self.assertAlmostEqual(expected1[i],f1.getArray().getIJ(0,i),12);
6972             pass
6973         pass
6974
6975     def testFillFromAnalyticThree1(self):
6976         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6977         m1.setTime(3.4,5,6); m1.setTimeUnit("us");
6978         vs=3*[None];
6979         vs[0]="x"; vs[1]="Y"; vs[2]="z";
6980         self.assertRaises(InterpKernelException,m1.fillFromAnalytic3,ON_NODES,1,vs,"y+z");
6981         vs[1]="y";
6982         f1=m1.fillFromAnalytic3(ON_NODES,1,vs,"y+z");
6983         self.assertAlmostEqual(3.4,f1.getTime()[0],12) ; self.assertEqual(5,f1.getTime()[1]) ; self.assertEqual(6,f1.getTime()[2])
6984         self.assertEqual("us",f1.getTimeUnit())
6985         self.assertEqual(1,f1.getNumberOfComponents());
6986         self.assertEqual(9,f1.getNumberOfTuples());
6987         expected1=[0.2, 0.7, 1.2, 0.7, 1.2, 1.7, 1.2, 1.7, 2.2]
6988         for i in xrange(9):
6989             self.assertAlmostEqual(expected1[i],f1.getArray().getIJ(0,i),12);
6990             pass
6991         pass
6992
6993     def testDAUnitVar1(self):
6994         da=DataArrayDouble.New();
6995         da.alloc(1,3);
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,"XPS         [m]");
7003         st1=da.getVarOnComponent(0);
7004         self.assertTrue(st1=="XPS");
7005         st2=da.getUnitOnComponent(0);
7006         self.assertTrue(st2=="m");
7007         #
7008         da.setInfoOnComponent(0,"XPP         [m]");
7009         st1=da.getVarOnComponent(0);
7010         self.assertTrue(st1=="XPP");
7011         st2=da.getUnitOnComponent(0);
7012         self.assertTrue(st2=="m");
7013         #
7014         da.setInfoOnComponent(0,"XPP kdep  kefer   [ m  ]");
7015         st1=da.getVarOnComponent(0);
7016         self.assertTrue(st1=="XPP kdep  kefer");
7017         st2=da.getUnitOnComponent(0);
7018         self.assertTrue(st2==" m  ");
7019         #
7020         da.setInfoOnComponent(0,"     XPP k[  dep  k]efer   [ m^ 2/s^3*kJ  ]");
7021         st1=da.getVarOnComponent(0);
7022         self.assertTrue(st1=="     XPP k[  dep  k]efer");
7023         st2=da.getUnitOnComponent(0);
7024         self.assertTrue(st2==" m^ 2/s^3*kJ  ");
7025         #
7026         da.setInfoOnComponent(0,"     XPP kefer   ");
7027         st1=da.getVarOnComponent(0);
7028         self.assertTrue(st1=="     XPP kefer   ");
7029         st2=da.getUnitOnComponent(0);
7030         self.assertTrue(st2=="");
7031         #
7032         da.setInfoOnComponent(0,"temperature( bof)");
7033         st1=da.getVarOnComponent(0);
7034         self.assertTrue(st1=="temperature( bof)");
7035         st2=da.getUnitOnComponent(0);
7036         self.assertTrue(st2=="");
7037         #
7038         da.setInfoOnComponent(0,"kkk [m]");
7039         da.setInfoOnComponent(1,"ppp   [m^2/kJ]");
7040         da.setInfoOnComponent(2,"abcde   [MW/s]");
7041         #
7042         vs=da.getVarsOnComponent();
7043         self.assertEqual(3,len(vs));
7044         self.assertTrue(vs[0]=="kkk");
7045         self.assertTrue(vs[1]=="ppp");
7046         self.assertTrue(vs[2]=="abcde");
7047         vs=da.getUnitsOnComponent();
7048         self.assertEqual(3,len(vs));
7049         self.assertTrue(vs[0]=="m");
7050         self.assertTrue(vs[1]=="m^2/kJ");
7051         self.assertTrue(vs[2]=="MW/s");
7052         pass
7053
7054     def testGaussCoordinates1(self):
7055         #Testing 1D cell types
7056         m1=MEDCouplingDataForTest.build1DMultiTypes_1();
7057         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,ONE_TIME);
7058         f.setMesh(m1);
7059         wg1=[0.3];
7060         gsCoo1=[0.2];
7061         refCoo1=[-1.0,1.0];
7062         f.setGaussLocalizationOnType(NORM_SEG2,refCoo1,gsCoo1,wg1);
7063         wg2=wg1;
7064         gsCoo2=[0.2];
7065         refCoo2=[-1.0,1.0,0.0];
7066         f.setGaussLocalizationOnType(NORM_SEG3,refCoo2,gsCoo2,wg2);
7067         #
7068         resToTest=f.getLocalizationOfDiscr();
7069         self.assertEqual(3,resToTest.getNumberOfComponents());
7070         self.assertEqual(2,resToTest.getNumberOfTuples());
7071         expected1=[0.6,0.6,0.6, 0.6,0.6,0.6]
7072         for i in xrange(6):
7073             self.assertAlmostEqual(expected1[i],resToTest.getIJ(0,i),14);
7074             pass
7075         #
7076         #Testing 2D cell types
7077         m2=MEDCouplingDataForTest.build2DMultiTypes_1();
7078         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,ONE_TIME);
7079         f.setMesh(m2);
7080         wg3=[0.3,0.3];
7081         tria3CooGauss=[ 0.1, 0.8, 0.2, 0.7 ]
7082         gsCoo3=tria3CooGauss
7083         tria3CooRef=[ 0.0, 0.0, 1.0 , 0.0, 0.0, 1.0 ]
7084         refCoo3=tria3CooRef;
7085         f.setGaussLocalizationOnType(NORM_TRI3,refCoo3,gsCoo3,wg3);
7086         wg4=[0.3,0.3,0.3];
7087         tria6CooGauss=[ 0.3, 0.2, 0.2, 0.1, 0.2, 0.4 ]
7088         gsCoo4=tria6CooGauss;
7089         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]
7090         refCoo4=tria6CooRef;
7091         f.setGaussLocalizationOnType(NORM_TRI6,refCoo4,gsCoo4,wg4);
7092         wg5=[0.3,0.3,0.3,0.3];
7093         quad4CooGauss=[ 0.3, 0.2, 0.2, 0.1, 0.2, 0.4, 0.15, 0.27 ]
7094         gsCoo5=quad4CooGauss;
7095         quad4CooRef=[-1.0, 1.0, -1.0, -1.0, 1.0, -1.0, 1.0, 1.0]
7096         refCoo5=quad4CooRef;
7097         f.setGaussLocalizationOnType(NORM_QUAD4,refCoo5,gsCoo5,wg5);
7098         wg6=[0.3,0.3,0.3,0.3];
7099         quad8CooGauss=[ 0.34, 0.16, 0.21, 0.3, 0.23, 0.4, 0.14, 0.37 ]
7100         gsCoo6=quad8CooGauss;
7101         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]
7102         refCoo6=quad8CooRef;
7103         f.setGaussLocalizationOnType(NORM_QUAD8,refCoo6,gsCoo6,wg6);
7104         #
7105         resToTest=f.getLocalizationOfDiscr();
7106         self.assertEqual(3,resToTest.getNumberOfComponents());
7107         self.assertEqual(13,resToTest.getNumberOfTuples());#2+3+4+4 gauss points for resp TRI3,TRI6,QUAD4,QUAD8
7108         expected2=[5.1,1.55,0.0, 4.7,1.65,0.0,
7109                    2.32,1.52,0.0, 1.6,1.32,0.0, 3.52,1.26,0.0,#TRI6
7110                    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
7111                    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
7112         for i in xrange(39):
7113             self.assertAlmostEqual(expected2[i],resToTest.getIJ(0,i),14);
7114             pass
7115         #
7116         #Testing 3D cell types
7117         m3=MEDCouplingDataForTest.build3DMultiTypes_1();
7118         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,ONE_TIME);
7119         f.setMesh(m3);
7120         #
7121         wg7=[0.3];
7122         tetra4CooGauss=[0.34, 0.16, 0.21]
7123         gsCoo7=tetra4CooGauss;
7124         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]
7125         refCoo7=tetra4CooRef;
7126         f.setGaussLocalizationOnType(NORM_TETRA4,refCoo7,gsCoo7,wg7);
7127         wg8=[0.3];
7128         tetra10CooGauss=[0.2, 0.3, 0.1]
7129         gsCoo8=tetra10CooGauss;
7130         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]
7131         refCoo8=tetra10CooRef;
7132         f.setGaussLocalizationOnType(NORM_TETRA10,refCoo8,gsCoo8,wg8);
7133         wg9=[0.3];
7134         pyra5CooGauss=[0.2, 0.3, 0.1]
7135         gsCoo9=pyra5CooGauss;
7136         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]
7137         refCoo9=pyra5CooRef;
7138         f.setGaussLocalizationOnType(NORM_PYRA5,refCoo9,gsCoo9,wg9);
7139         wg10=[0.3];
7140         pyra13CooGauss=[0.1, 0.2, 0.7]
7141         gsCoo10=pyra13CooGauss;
7142         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]
7143         refCoo10=pyra13CooRef;
7144         f.setGaussLocalizationOnType(NORM_PYRA13,refCoo10,gsCoo10,wg10);
7145         wg11=[0.3];
7146         penta6CooGauss=[0.2, 0.3, 0.1]
7147         gsCoo11=penta6CooGauss;
7148         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]
7149         refCoo11=penta6CooRef;
7150         f.setGaussLocalizationOnType(NORM_PENTA6,refCoo11,gsCoo11,wg11);
7151         wg12=[0.3];
7152         penta15CooGauss=[0.2, 0.3,0.15]
7153         gsCoo12=penta15CooGauss;
7154         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]
7155         refCoo12=penta15CooRef;
7156         f.setGaussLocalizationOnType(NORM_PENTA15,refCoo12,gsCoo12,wg12);
7157         wg13=[0.3];
7158         hexa8CooGauss=[0.2,0.3,0.15]
7159         gsCoo13=hexa8CooGauss;
7160         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]
7161         refCoo13=hexa8CooRef;
7162         f.setGaussLocalizationOnType(NORM_HEXA8,refCoo13,gsCoo13,wg13);
7163         wg14=[0.3];
7164         hexa20CooGauss=[0.11,0.3,0.55]
7165         gsCoo14=hexa20CooGauss;
7166         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]
7167         refCoo14=hexa20CooRef;
7168         f.setGaussLocalizationOnType(NORM_HEXA20,refCoo14,gsCoo14,wg14);
7169         #
7170         resToTest=f.getLocalizationOfDiscr();
7171         self.assertEqual(3,resToTest.getNumberOfComponents());
7172         self.assertEqual(8,resToTest.getNumberOfTuples());#2+3+4+4 gauss points for resp TRI3,TRI6,QUAD4,QUAD8
7173         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]
7174         for i in xrange(24):
7175             self.assertAlmostEqual(expected3[i],resToTest.getIJ(0,i),14);
7176             pass
7177         #
7178         pass
7179
7180     def testP2Localization1(self):
7181         m=MEDCouplingUMesh.New("testP2",2);
7182         coords=[0.,2.,3.5,0.,4.5,1.5,1.2,0.32,3.4,1.,2.1,2.4]
7183         conn=[0,1,2,3,4,5]
7184         coo=DataArrayDouble.New();
7185         coo.setValues(coords,6,2);
7186         m.setCoords(coo);
7187         m.allocateCells(1);
7188         m.insertNextCell(NORM_TRI6,6,conn[0:6])
7189         m.finishInsertingCells();
7190         #
7191         f=MEDCouplingFieldDouble.New(ON_NODES,ONE_TIME);
7192         f.setMesh(m);
7193         da=DataArrayDouble.New();
7194         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]
7195         da.setValues(vals1,6,3);
7196         f.setArray(da);
7197         #
7198         loc=[2.27,1.3]
7199         locs=f.getValueOnMulti(loc);
7200         expected1=[6.0921164547752236, 7.1921164547752232, 8.2921164547752255]
7201         for i in xrange(3):
7202             self.assertAlmostEqual(expected1[i],locs.getIJ(0,i),12);
7203             pass
7204         pass
7205
7206     def testP2Localization2(self):
7207         m=MEDCouplingUMesh.New("testP2_2",3);
7208         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]
7209         conn=[0,1,2,3,4,5,6,7,8,9]
7210         coo=DataArrayDouble.New();
7211         coo.setValues(coords,10,3);
7212         m.setCoords(coo);
7213         m.allocateCells(1);
7214         m.insertNextCell(NORM_TETRA10,10,conn[0:10])
7215         m.finishInsertingCells();
7216         #
7217         f=MEDCouplingFieldDouble.New(ON_NODES,ONE_TIME);
7218         f.setMesh(m);
7219         da=DataArrayDouble.New();
7220         vals1=[1.1,2.1,3.1,4.1,5.2,6.2,7.2,8.2,9.2,10.2]
7221         da.setValues(vals1,10,1);
7222         f.setArray(da);
7223         #
7224         loc=[0.64637931739890486, -0.16185896817550552, 0.22678966365273748]
7225         locs=f.getValueOnMulti(loc);
7226         expected1=[10.0844021968047]
7227         for i in xrange(1):
7228             self.assertAlmostEqual(expected1[i],locs.getIJ(0,i),12);
7229             pass
7230         pass
7231
7232     def testGetValueOn2(self):
7233         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7234         f=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
7235         f.setMesh(m);
7236         arr=DataArrayDouble.New();
7237         nbOfCells=m.getNumberOfCells();
7238         f.setArray(arr);
7239         values1=[7.,107.,10007.,8.,108.,10008.,9.,109.,10009.,10.,110.,10010.,11.,111.,10011.]
7240         arr.setValues(values1,nbOfCells,3);
7241         loc=[-0.05,-0.05, 0.55,-0.25, 0.55,0.15, -0.05,0.45, 0.45,0.45]
7242         f.checkCoherency();
7243         locs=f.getValueOnMulti(loc);
7244         self.assertEqual(5,locs.getNumberOfTuples());
7245         self.assertEqual(3,locs.getNumberOfComponents());
7246         for j in xrange(15):
7247             self.assertAlmostEqual(values1[j],locs.getIJ(0,j),12);
7248             pass
7249         # Testing ON_NODES
7250         f=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
7251         f.setMesh(m);
7252         arr=DataArrayDouble.New();
7253         nbOfNodes=m.getNumberOfNodes();
7254         f.setArray(arr);
7255         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.]
7256         arr.setValues(values2,nbOfNodes,3);
7257         loc2=[0.5432,-0.2432, 0.5478,0.1528, 0.5432,-0.2432, 0.5432,-0.2432]
7258         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]
7259         f.checkCoherency();
7260         loc3=DataArrayDouble.New()
7261         loc3.setValues(loc2,4,2);
7262         locs=f.getValueOnMulti(loc3);
7263         self.assertEqual(4,locs.getNumberOfTuples());
7264         self.assertEqual(3,locs.getNumberOfComponents());
7265         for i in xrange(12):
7266             self.assertAlmostEqual(expected2[i],locs.getIJ(0,i),12);
7267             pass
7268         #
7269         pass
7270
7271     def testDAIGetIdsNotEqual1(self):
7272         d=DataArrayInt.New();
7273         vals1=[2,3,5,6,8,5,5,6,1,-5]
7274         d.setValues(vals1,10,1);
7275         d2=d.getIdsNotEqual(5);
7276         self.assertEqual(7,d2.getNumberOfTuples());
7277         self.assertEqual(1,d2.getNumberOfComponents());
7278         expected1=[0,1,3,4,7,8,9]
7279         for i in xrange(7):
7280             self.assertEqual(expected1[i],d2.getIJ(0,i));
7281             pass
7282         d.rearrange(2);
7283         self.assertRaises(InterpKernelException,d.getIdsNotEqual,5);
7284         vals2=[-4,5,6]
7285         vals3=vals2;
7286         d.rearrange(1);
7287         d3=d.getIdsNotEqualList(vals3);
7288         self.assertEqual(5,d3.getNumberOfTuples());
7289         self.assertEqual(1,d3.getNumberOfComponents());
7290         expected2=[0,1,4,8,9]
7291         for i in xrange(5):
7292             self.assertEqual(expected2[i],d3.getIJ(0,i));
7293             pass
7294         pass
7295
7296     def testDAIComputeOffsets1(self):
7297         d=DataArrayInt.New();
7298         vals1=[3,5,1,2,0,8]
7299         expected1=[0,3,8,9,11,11]
7300         d.setValues(vals1,6,1);
7301         d.computeOffsets();
7302         self.assertEqual(6,d.getNumberOfTuples());
7303         self.assertEqual(1,d.getNumberOfComponents());
7304         for i in xrange(6):
7305             self.assertEqual(expected1[i],d.getIJ(0,i));
7306             pass
7307         pass
7308
7309     def testUMeshHexagonPrism1(self):
7310         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,
7311                 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];
7312         conn=[1,2,3,4,5,0,7,8,9,10,11,6]
7313         mesh=MEDCouplingUMesh.New("MyFirstHexagonalPrism",3);
7314         coo=DataArrayDouble.New();
7315         coo.setValues(coords,12,3);
7316         mesh.setCoords(coo);
7317         mesh.allocateCells(1);
7318         mesh.insertNextCell(NORM_HEXGP12,12,conn[0:12])
7319         mesh.finishInsertingCells();
7320         #
7321         mesh.checkCoherency();
7322         vols=mesh.getMeasureField(False);
7323         self.assertEqual(1,vols.getNumberOfTuples());
7324         self.assertEqual(1,vols.getNumberOfComponents());
7325         self.assertAlmostEqual(-5.196152422706632,vols.getIJ(0,0),12);
7326         bary=mesh.getBarycenterAndOwner();
7327         self.assertEqual(1,bary.getNumberOfTuples());
7328         self.assertEqual(3,bary.getNumberOfComponents());
7329         expected1=[0.,0.,1.]
7330         for i in xrange(3):
7331             self.assertAlmostEqual(expected1[i],bary.getIJ(0,i),12);
7332             pass
7333         d1=DataArrayInt.New();
7334         d2=DataArrayInt.New();
7335         d3=DataArrayInt.New();
7336         d4=DataArrayInt.New();
7337         m2=mesh.buildDescendingConnectivity(d1,d2,d3,d4);
7338         self.assertEqual(8,m2.getNumberOfCells());
7339         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]];
7340         expected2=[NORM_POLYGON, NORM_POLYGON, NORM_QUAD4, NORM_QUAD4, NORM_QUAD4, NORM_QUAD4, NORM_QUAD4, NORM_QUAD4];
7341         expected3=[6,6,4,4,4,4,4,4]
7342         for i in xrange(8):
7343             self.assertTrue(m2.getTypeOfCell(i)==expected2[i]);
7344             v=m2.getNodeIdsOfCell(i);
7345             self.assertTrue(len(v)==expected3[i]);
7346             self.assertEqual(expected4[i],v);
7347         #
7348         mesh.convertAllToPoly();
7349         self.assertTrue(NORM_POLYHED==mesh.getTypeOfCell(0));
7350         mesh.unPolyze();
7351         self.assertTrue(NORM_HEXGP12==mesh.getTypeOfCell(0));
7352         self.assertEqual(13,mesh.getMeshLength());
7353         #
7354         pass
7355
7356     def testDADCheckIsMonotonic(self):
7357         da=DataArrayDouble.New();
7358         da.setValues([-1.,1.01,2.03,6.],2,2);
7359         self.assertRaises(InterpKernelException,da.isMonotonic,True,1e-12);
7360         da.rearrange(1);
7361         self.assertTrue(da.isMonotonic(True,1e-12));
7362         da.checkMonotonic(True,1e-12);
7363         da.setIJ(2,0,6.1);
7364         self.assertTrue(not da.isMonotonic(True,1e-12));
7365         self.assertRaises(InterpKernelException,da.checkMonotonic,True,1e-12);
7366         da.setIJ(2,0,5.99);
7367         self.assertTrue(da.isMonotonic(True,1e-12));
7368         self.assertTrue(not da.isMonotonic(True,1e-1));
7369         pass
7370
7371     def testCheckCoherencyDeeper1(self):
7372         m=MEDCouplingDataForTest.build3DSourceMesh_1();
7373         m.checkCoherency();
7374         m.checkCoherency1();
7375         m.getNodalConnectivity().setIJ(8,0,-1);
7376         m.checkCoherency();
7377         self.assertRaises(InterpKernelException,m.checkCoherency1);
7378         m.getNodalConnectivity().setIJ(8,0,-6);
7379         m.checkCoherency();
7380         self.assertRaises(InterpKernelException,m.checkCoherency1);
7381         m.getNodalConnectivity().setIJ(8,0,9);#9>=NbOfNodes
7382         m.checkCoherency();
7383         self.assertRaises(InterpKernelException,m.checkCoherency1);
7384         m.getNodalConnectivity().setIJ(8,0,8);#OK
7385         m.checkCoherency();
7386         m.checkCoherency1();
7387         elts=[1,5]
7388         m.convertToPolyTypes(elts);
7389         m.checkCoherency();
7390         m.checkCoherency1();
7391         m.getNodalConnectivity().setIJ(2,0,9);#9>=NbOfNodes
7392         m.checkCoherency();
7393         self.assertRaises(InterpKernelException,m.checkCoherency1);
7394         m.getNodalConnectivity().setIJ(2,0,-3);
7395         m.checkCoherency();
7396         self.assertRaises(InterpKernelException,m.checkCoherency1);
7397         m.getNodalConnectivity().setIJ(2,0,-1);
7398         m.checkCoherency();
7399         self.assertRaises(InterpKernelException,m.checkCoherency1);#Throw because cell#0 is not a polyhedron
7400         m.getNodalConnectivity().setIJ(2,0,4);
7401         m.checkCoherency();
7402         m.checkCoherency1();
7403         m.getNodalConnectivity().setIJ(7,0,-1);
7404         m.checkCoherency();
7405         m.checkCoherency1();#OK because we are in polyhedron connec
7406         m.getNodalConnectivity().setIJ(36,0,14);
7407         m.checkCoherency();
7408         self.assertRaises(InterpKernelException,m.checkCoherency1);#Throw beacause now cell 5 is a TETRA4 (14) so mimatch of number index and static type.
7409         pass
7410
7411     def testUnPolyze2(self):
7412         m=MEDCouplingUMesh.New("jjj",3);
7413         coo=DataArrayDouble.New();
7414         coo.alloc(4,3);
7415         coo.rearrange(1);
7416         coo.iota(0);
7417         coo.rearrange(3);
7418         m.setCoords(coo);
7419         m.allocateCells(2);
7420         m.insertNextCell(NORM_TETRA4,4,[0,1,2,3]);
7421         m.insertNextCell(NORM_TETRA4,4,[0,1,2,3]);
7422         m.finishInsertingCells();
7423         m2=MEDCouplingUMesh.MergeUMeshesOnSameCoords(4*[m]);
7424         m2.convertToPolyTypes([2]);
7425         m2.unPolyze();
7426         self.assertEqual(NORM_TETRA4,m2.getTypeOfCell(2));
7427         self.assertEqual(40,m2.getMeshLength());
7428         temp2=m2.getNodeIdsOfCell(2);
7429         self.assertEqual(temp2,[0,1,2,3]);
7430         m2.checkCoherency1();
7431         m3=m2.deepCpy();
7432         m2.unPolyze();
7433         self.assertTrue(m3.isEqual(m2,1e-12));
7434         pass
7435
7436     def testDACpyFrom1(self):
7437         d=DataArrayDouble.New();
7438         d.alloc(12,1);
7439         d.iota(14.);
7440         d.rearrange(3);
7441         d.setName("Toto");
7442         d.setInfoOnComponent(0,"X [m]");
7443         d.setInfoOnComponent(1,"Y [m]");
7444         d.setInfoOnComponent(2,"Z [m]");
7445         #
7446         d1=DataArrayDouble.New();
7447         self.assertTrue(not d.isEqual(d1,1e-12));
7448         d1.cpyFrom(d);
7449         self.assertTrue(d.isEqual(d1,1e-12));
7450         d1.cpyFrom(d);
7451         self.assertTrue(d.isEqual(d1,1e-12));
7452         d1.rearrange(2);
7453         self.assertTrue(not d.isEqual(d1,1e-12));
7454         d1.cpyFrom(d);
7455         self.assertTrue(d.isEqual(d1,1e-12));
7456         #
7457         d2=d.convertToIntArr();
7458         d4=DataArrayInt.New();
7459         self.assertTrue(not d2.isEqual(d4));
7460         d4.cpyFrom(d2);
7461         self.assertTrue(d2.isEqual(d4));
7462         d4.cpyFrom(d2);
7463         self.assertTrue(d2.isEqual(d4));
7464         d4.rearrange(2);
7465         self.assertTrue(not d2.isEqual(d4));
7466         d4.cpyFrom(d2);
7467         self.assertTrue(d2.isEqual(d4));
7468         pass
7469
7470     def testDAITransformWithIndArr1(self):
7471         tab1=[17,18,22,19]
7472         tab2=[0,1,1,3,3,0,1,3,2,2,3,0]
7473         expected=[17,18,18,19,19,17,18,19,22,22,19,17]
7474         d=DataArrayInt.New();
7475         d.setValues(tab1,4,1);
7476         d1=DataArrayInt.New();
7477         d1.setValues(tab2,12,1);
7478         d2=d1[:]
7479         #
7480         d1.transformWithIndArr(d);
7481         self.assertEqual(12,d1.getNumberOfTuples());
7482         self.assertEqual(1,d1.getNumberOfComponents());
7483         for i in xrange(12):
7484             self.assertEqual(expected[i],d1.getIJ(i,0));
7485             pass
7486         #
7487         d1=d2
7488         d1.transformWithIndArr(tab1)
7489         self.assertEqual(12,d1.getNumberOfTuples());
7490         self.assertEqual(1,d1.getNumberOfComponents());
7491         for i in xrange(12):
7492             self.assertEqual(expected[i],d1.getIJ(i,0));
7493             pass
7494         pass
7495
7496     def testDAIBuildPermArrPerLevel1(self):
7497         arr=[2,0,1,1,0,1,2,0,1,1,0,0]
7498         expected1=[10,0,5,6,1,7,11,2,8,9,3,4]
7499         da=DataArrayInt.New();
7500         da.setValues(arr,12,1);
7501         da2=da.buildPermArrPerLevel();
7502         self.assertEqual(12,da2.getNumberOfTuples());
7503         self.assertEqual(1,da2.getNumberOfComponents());
7504         for i in xrange(12):
7505             self.assertEqual(expected1[i],da2.getIJ(i,0));
7506             pass
7507         pass
7508
7509     def testDAIOperations1(self):
7510         arr1=[-1,-2,4,7,3,2,6,6,4,3,0,1]
7511         da=DataArrayInt.New();
7512         da.setValues(arr1,4,3);
7513         da1=DataArrayInt.New();
7514         da1.alloc(12,1);
7515         da1.iota(2);
7516         self.assertRaises(InterpKernelException,DataArrayInt.Add,da,da1);#not same number of tuples/Components
7517         da1.rearrange(3);
7518         da2=DataArrayInt.Add(da,da1);
7519         self.assertEqual(4,da2.getNumberOfTuples());
7520         self.assertEqual(3,da2.getNumberOfComponents());
7521         expected1=[1,1,8,12,9,9,14,15,14,14,12,14]
7522         for i in xrange(12):
7523             self.assertEqual(expected1[i],da2.getIJ(0,i));
7524             pass
7525         da1.substractEqual(da);
7526         expected2=[3,5,0,-2,3,5,2,3,6,8,12,12]
7527         for i in xrange(12):
7528             self.assertEqual(expected2[i],da1.getIJ(0,i));
7529             pass
7530         da1.rearrange(1); da1.iota(2); da1.rearrange(3);
7531         da1.addEqual(da);
7532         for i in xrange(12):
7533             self.assertEqual(expected1[i],da1.getIJ(0,i));
7534             pass
7535         da1.rearrange(1); da1.iota(2); da1.rearrange(3);
7536         da2=DataArrayInt.Multiply(da,da1);
7537         self.assertEqual(4,da2.getNumberOfTuples());
7538         self.assertEqual(3,da2.getNumberOfComponents());
7539         expected3=[-2,-6,16,35,18,14,48,54,40,33,0,13]
7540         for i in xrange(12):
7541             self.assertEqual(expected3[i],da2.getIJ(0,i));
7542             pass
7543         da.divideEqual(da1);
7544         self.assertEqual(4,da.getNumberOfTuples());
7545         self.assertEqual(3,da.getNumberOfComponents());
7546         expected4=[0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0]
7547         for i in xrange(12):
7548             self.assertEqual(expected4[i],da.getIJ(0,i));
7549             pass
7550         da.setValues(arr1,4,3);
7551         da1.multiplyEqual(da);
7552         self.assertEqual(4,da1.getNumberOfTuples());
7553         self.assertEqual(3,da1.getNumberOfComponents());
7554         for i in xrange(12):
7555             self.assertEqual(expected3[i],da1.getIJ(0,i));
7556             pass
7557         da1.rearrange(1); da1.iota(2); da1.rearrange(3);
7558         da2=DataArrayInt.Divide(da,da1);
7559         self.assertEqual(4,da2.getNumberOfTuples());
7560         self.assertEqual(3,da2.getNumberOfComponents());
7561         for i in xrange(12):
7562             self.assertEqual(expected4[i],da2.getIJ(0,i));
7563             pass
7564         da1.applyInv(321);
7565         self.assertEqual(4,da1.getNumberOfTuples());
7566         self.assertEqual(3,da1.getNumberOfComponents());
7567         expected5=[160,107,80,64,53,45,40,35,32,29,26,24]
7568         for i in xrange(12):
7569             self.assertEqual(expected5[i],da1.getIJ(0,i));
7570             pass
7571         da1.applyDivideBy(2);
7572         self.assertEqual(4,da1.getNumberOfTuples());
7573         self.assertEqual(3,da1.getNumberOfComponents());
7574         expected6=[80,53,40,32,26,22,20,17,16,14,13,12]
7575         for i in xrange(12):
7576             self.assertEqual(expected6[i],da1.getIJ(0,i));
7577             pass
7578         expected7=[3,4,5,4,5,1,6,3,2,0,6,5]
7579         da1.applyModulus(7);
7580         for i in xrange(12):
7581             self.assertEqual(expected7[i],da1.getIJ(0,i));
7582             pass
7583         da1.applyLin(1,1);
7584         expected8=[3,3,3,3,3,1,3,3,0,0,3,3]
7585         da1.applyRModulus(3);
7586         for i in xrange(12):
7587             self.assertEqual(expected8[i],da1.getIJ(0,i));
7588             pass
7589         pass
7590
7591     def testEmulateMEDMEMBDC1(self):
7592         m,m1=MEDCouplingDataForTest.buildPointe_1();
7593         m2,da1,da2,da3,da4,da5,da0=m.emulateMEDMEMBDC(m1)
7594         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]
7595         expected1=[1,32,29,23,41,36]
7596         self.assertEqual(47,da0.getNumberOfTuples());
7597         self.assertEqual(1,da0.getNumberOfComponents());
7598         for i in xrange(47):
7599             self.assertEqual(expected0[i],da0.getIJ(0,i));
7600             pass
7601         self.assertEqual(6,da5.getNumberOfTuples());
7602         self.assertEqual(1,da5.getNumberOfComponents());
7603         for i in xrange(6):
7604             self.assertEqual(expected1[i],da5.getIJ(0,i));
7605             pass
7606         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]
7607         self.assertEqual(70,da1.getNumberOfTuples());
7608         self.assertEqual(1,da1.getNumberOfComponents());
7609         for i in xrange(70):
7610             self.assertEqual(expected2[i],da1.getIJ(0,i));
7611             pass
7612         expected3=[0,4,8,12,16,20,24,28,32,36,40,44,48,53,58,64,70]
7613         self.assertEqual(17,da2.getNumberOfTuples());
7614         self.assertEqual(1,da2.getNumberOfComponents());
7615         for i in xrange(17):
7616             self.assertEqual(expected3[i],da2.getIJ(0,i));
7617             pass
7618         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]
7619         #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];
7620         self.assertEqual(48,da4.getNumberOfTuples());
7621         self.assertEqual(1,da4.getNumberOfComponents());
7622         for i in xrange(48):
7623             self.assertEqual(expected4[i],da4.getIJ(0,i));
7624             pass
7625         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]
7626         self.assertEqual(70,da3.getNumberOfTuples());
7627         self.assertEqual(1,da3.getNumberOfComponents());
7628         for i in xrange(70):
7629             self.assertEqual(expected5[i],da3.getIJ(0,i));
7630             pass
7631         pass
7632
7633     def testGetLevArrPerCellTypes1(self):
7634         m,m1=MEDCouplingDataForTest.buildPointe_1();
7635         m1,d0,d1,d2,d3=m.buildDescendingConnectivity();
7636         order=[NORM_TRI3,NORM_QUAD4];
7637         da0,da1=m1.getLevArrPerCellTypes(order);
7638         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]
7639         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]
7640         self.assertEqual(47,da0.getNumberOfTuples());
7641         self.assertEqual(1,da0.getNumberOfComponents());
7642         for i in xrange(47):
7643             self.assertEqual(expected0[i],da0.getIJ(0,i));
7644             pass
7645         self.assertEqual(2,da1.getNumberOfTuples());
7646         self.assertEqual(1,da1.getNumberOfComponents());
7647         self.assertEqual(36,da1.getIJ(0,0));#36 TRI3
7648         self.assertEqual(11,da1.getIJ(1,0));#11 QUAD4
7649         #
7650         da2=da0.buildPermArrPerLevel();
7651         #
7652         self.assertEqual(47,da2.getNumberOfTuples());
7653         self.assertEqual(1,da2.getNumberOfComponents());
7654         for i in xrange(47):
7655             self.assertEqual(expected1[i],da2.getIJ(0,i));
7656             pass
7657         pass
7658
7659     def testSortCellsInMEDFileFrmt1(self):
7660         m,m1=MEDCouplingDataForTest.buildPointe_1();
7661         m2=m.deepCpy()
7662         da=DataArrayInt.New()
7663         da.setValues([0,1,2,14,3,12,4,5,15,6,7,8,9,10,11,13],16,1)
7664         daa=da.invertArrayN2O2O2N(16)
7665         m.renumberCells(daa,False)
7666         da2=m.sortCellsInMEDFileFrmt()
7667         self.assertEqual(da2.getValues(),[0,1,2,14,3,12,4,5,15,6,7,8,9,10,11,13])
7668         self.assertTrue(m.isEqual(m2,1e-12))
7669         self.assertTrue(da.isEqual(da2))
7670         pass
7671
7672     def testBuildPartAndReduceNodes1(self):
7673         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7674         arr=[1,0]
7675         m2,da=m.buildPartAndReduceNodes(arr);
7676         self.assertEqual(5,m2.getNumberOfNodes());
7677         self.assertEqual(2,m2.getNumberOfCells());
7678         f=m2.getMeasureField(True);
7679         self.assertAlmostEqual(0.125,f.getArray().getIJ(0,0),12);
7680         self.assertAlmostEqual(0.25,f.getArray().getIJ(1,0),12);
7681         #
7682         arr2=DataArrayInt.New()
7683         arr2.setValues(arr,2,1)
7684         m2,da=m.buildPartAndReduceNodes(arr2);
7685         self.assertEqual(5,m2.getNumberOfNodes());
7686         self.assertEqual(2,m2.getNumberOfCells());
7687         f=m2.getMeasureField(True);
7688         self.assertAlmostEqual(0.125,f.getArray().getIJ(0,0),12);
7689         self.assertAlmostEqual(0.25,f.getArray().getIJ(1,0),12);
7690         pass
7691
7692     def testDAITransformWithIndArrR1(self):
7693         tab1=[2,4,5,3,6,7]
7694         tab2=[-1,-1,0,1,2,3,4,5,-1,-1,-1,-1]
7695         expected=[0,3,1,2,4,5]
7696         d=DataArrayInt.New();
7697         d.setValues(tab1,6,1);
7698         d1=DataArrayInt.New();
7699         d1.setValues(tab2,12,1);
7700         d2=d1[:]
7701         #
7702         d3=d.transformWithIndArrR(d1);
7703         self.assertEqual(6,d3.getNumberOfTuples());
7704         self.assertEqual(1,d3.getNumberOfComponents());
7705         for i in xrange(6):
7706             self.assertEqual(expected[i],d3.getIJ(i,0));
7707             pass
7708         #
7709         d1=d2
7710         d3=d.transformWithIndArrR(tab2)
7711         self.assertEqual(6,d3.getNumberOfTuples());
7712         self.assertEqual(1,d3.getNumberOfComponents());
7713         for i in xrange(6):
7714             self.assertEqual(expected[i],d3.getIJ(i,0));
7715             pass
7716         pass
7717
7718     def testDAISplitByValueRange1(self):
7719         val1=[6,5,0,3,2,7,8,1,4]
7720         val2=[0,4,9]
7721         d=DataArrayInt.New();
7722         d.setValues(val1,9,1);
7723         e,f,g=d.splitByValueRange(val2);
7724         self.assertEqual(9,e.getNumberOfTuples());
7725         self.assertEqual(1,e.getNumberOfComponents());
7726         self.assertEqual(9,f.getNumberOfTuples());
7727         self.assertEqual(1,f.getNumberOfComponents());
7728         self.assertEqual(2,g.getNumberOfTuples());
7729         self.assertEqual(1,g.getNumberOfComponents());
7730         #
7731         expected1=[1,1,0,0,0,1,1,0,1]
7732         expected2=[2,1,0,3,2,3,4,1,0]
7733         for i in xrange(9):
7734             self.assertEqual(expected1[i],e.getIJ(i,0));
7735             self.assertEqual(expected2[i],f.getIJ(i,0));
7736             pass
7737         self.assertEqual(0,g.getIJ(0,0));
7738         self.assertEqual(1,g.getIJ(1,0));
7739         #
7740         d.setIJ(6,0,9);
7741         self.assertRaises(InterpKernelException,d.splitByValueRange,val2);
7742         pass
7743
7744     def testUMeshSplitProfilePerType1(self):
7745         val0=[2,0,1,3,4]
7746         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7747         m.renumberCells(val0,False);
7748         #
7749         val1=[0,2,3]
7750         d=DataArrayInt.New();
7751         d.setValues(val1,3,1);
7752         d.setName("sup")
7753         code,idsInPflPerType,pfls=m.splitProfilePerType(d);
7754         self.assertEqual(2,len(code));
7755         self.assertEqual(2,len(idsInPflPerType));
7756         expected1=[[3,1,0], [4,2,1]]
7757         self.assertEqual(expected1,code)
7758         self.assertEqual(2,len(idsInPflPerType));
7759         self.assertEqual(1,idsInPflPerType[0].getNumberOfTuples());
7760         self.assertEqual(0,idsInPflPerType[0].getIJ(0,0));
7761         self.assertEqual(2,idsInPflPerType[1].getNumberOfTuples());
7762         self.assertEqual(1,idsInPflPerType[1].getIJ(0,0));
7763         self.assertEqual(2,idsInPflPerType[1].getIJ(1,0));
7764         #
7765         self.assertEqual(2,len(pfls));
7766         self.assertEqual("sup",pfls[0].getName())
7767         self.assertEqual(1,pfls[0].getNumberOfTuples());
7768         self.assertEqual(0,pfls[0].getIJ(0,0));
7769         self.assertEqual("sup",pfls[1].getName())
7770         self.assertEqual(2,pfls[1].getNumberOfTuples());
7771         self.assertEqual(0,pfls[1].getIJ(0,0));
7772         self.assertEqual(1,pfls[1].getIJ(1,0));
7773         #
7774         val2=[0,2,3,4]
7775         d=DataArrayInt.New();
7776         d.setValues(val2,4,1);
7777         code,idsInPflPerType,pfls=m.splitProfilePerType(d);
7778         self.assertEqual(2,len(code));
7779         self.assertEqual(2,len(idsInPflPerType));
7780         expected2=[[3,1,0], [4,3,-1]]
7781         self.assertEqual(expected2,code);
7782         self.assertEqual(2,len(idsInPflPerType));
7783         self.assertEqual(1,idsInPflPerType[0].getNumberOfTuples());
7784         self.assertEqual(0,idsInPflPerType[0].getIJ(0,0));
7785         self.assertEqual(3,idsInPflPerType[1].getNumberOfTuples());
7786         self.assertEqual(1,idsInPflPerType[1].getIJ(0,0));
7787         self.assertEqual(2,idsInPflPerType[1].getIJ(1,0));
7788         self.assertEqual(3,idsInPflPerType[1].getIJ(2,0));
7789         #
7790         self.assertEqual(1,len(pfls));
7791         self.assertEqual(1,pfls[0].getNumberOfTuples());
7792         self.assertEqual(0,pfls[0].getIJ(0,0));
7793         #
7794         val3=[1,0,2]
7795         d=DataArrayInt.New();
7796         d.setValues(val3,3,1);
7797         code,idsInPflPerType,pfls=m.splitProfilePerType(d);
7798         self.assertEqual(2,len(code));
7799         self.assertEqual(2,len(idsInPflPerType));
7800         expected3=[[3,2,0], [4,1,1]]
7801         self.assertEqual(expected3,code);
7802         self.assertEqual(2,len(idsInPflPerType));
7803         self.assertEqual(2,idsInPflPerType[0].getNumberOfTuples());
7804         self.assertEqual(0,idsInPflPerType[0].getIJ(0,0));
7805         self.assertEqual(1,idsInPflPerType[0].getIJ(1,0));
7806         self.assertEqual(1,idsInPflPerType[1].getNumberOfTuples());
7807         self.assertEqual(2,idsInPflPerType[1].getIJ(0,0));
7808         #
7809         self.assertEqual(2,len(pfls));
7810         self.assertEqual(2,pfls[0].getNumberOfTuples());
7811         self.assertEqual(1,pfls[0].getIJ(0,0));
7812         self.assertEqual(0,pfls[0].getIJ(1,0));
7813         self.assertEqual(0,pfls[1].getIJ(0,0));
7814         #
7815         val4=[3,4]
7816         d=DataArrayInt.New();
7817         d.setValues(val4,2,1);
7818         code,idsInPflPerType,pfls=m.splitProfilePerType(d);
7819         self.assertEqual(1,len(code));
7820         self.assertEqual(1,len(idsInPflPerType));
7821         expected4=[[4,2,0]]
7822         self.assertEqual(expected4,code);
7823         self.assertEqual(1,len(idsInPflPerType));
7824         self.assertEqual(2,idsInPflPerType[0].getNumberOfTuples());
7825         self.assertEqual(0,idsInPflPerType[0].getIJ(0,0));
7826         self.assertEqual(1,idsInPflPerType[0].getIJ(1,0));
7827         #
7828         self.assertEqual(1,len(pfls));
7829         self.assertEqual(2,pfls[0].getNumberOfTuples());
7830         self.assertEqual(1,pfls[0].getIJ(0,0));
7831         self.assertEqual(2,pfls[0].getIJ(1,0));
7832         pass
7833
7834     def testDAIBuildExplicitArrByRanges1(self):
7835         d=DataArrayInt.New();
7836         vals1=[0,2,3]
7837         d.setValues(vals1,3,1);
7838         e=DataArrayInt.New();
7839         vals2=[0,3,6,10,14,20]
7840         e.setValues(vals2,6,1);
7841         #
7842         f=d.buildExplicitArrByRanges(e);
7843         self.assertEqual(11,f.getNumberOfTuples());
7844         self.assertEqual(1,f.getNumberOfComponents());
7845         expected1=[0,1,2,6,7,8,9,10,11,12,13]
7846         for i in xrange(11):
7847             self.assertEqual(expected1[i],f.getIJ(i,0));
7848             pass
7849         pass
7850
7851     def testDAIComputeOffsets2(self):
7852         d=DataArrayInt.New();
7853         vals1=[3,5,1,2,0,8]
7854         expected1=[0,3,8,9,11,11,19]
7855         d.setValues(vals1,6,1);
7856         d.computeOffsets2();
7857         self.assertEqual(7,d.getNumberOfTuples());
7858         self.assertEqual(1,d.getNumberOfComponents());
7859         for i in xrange(7):
7860             self.assertEqual(expected1[i],d.getIJ(0,i));
7861             pass
7862         pass
7863
7864     def testMergeField3(self):
7865         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7866         m.getCoords().setInfoOnComponent(0,"x [m]");
7867         m.getCoords().setInfoOnComponent(1,"z [km]");
7868         m.setName("m");
7869         m.setDescription("desc");
7870         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
7871         f1.setName("f1");
7872         f1.setMesh(m);
7873         arr=DataArrayDouble.New();
7874         arr.alloc(5,2);
7875         arr.setInfoOnComponent(0,"X [m]");
7876         arr.setInfoOnComponent(1,"YY [mm]");
7877         arr.fillWithValue(2.);
7878         f1.setArray(arr);
7879         #
7880         f2=MEDCouplingFieldDouble.MergeFields([f1]);
7881         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
7882         #
7883         pass
7884
7885     def testGetDistributionOfTypes1(self):
7886         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7887         tab1=[2,0,1,3,4]
7888         self.assertRaises(InterpKernelException,m.getDistributionOfTypes);
7889         m.renumberCells(tab1,False);
7890         code=m.getDistributionOfTypes();
7891         self.assertEqual(2,len(code));
7892         self.assertEqual(3,code[0][0]);
7893         self.assertEqual(2,code[0][1]);
7894         self.assertEqual(-1,code[0][2]);
7895         self.assertEqual(4,code[1][0]);
7896         self.assertEqual(3,code[1][1]);
7897         self.assertEqual(-1,code[1][2]);
7898         pass
7899
7900     def testNorm2_1(self):
7901         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7902         f=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
7903         f.setMesh(m);
7904         #
7905         d=DataArrayDouble.New();
7906         tab=[1.2,1.3,2.2,2.3,3.2,3.3,4.2,4.3,5.2,5.3]
7907         d.setValues(tab,5,2);
7908         f.setArray(d);
7909         f.checkCoherency();
7910         #
7911         self.assertAlmostEqual(11.209371079592289,f.norm2(),14);
7912         #
7913         pass
7914
7915     def testNormMax1(self):
7916         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7917         f=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
7918         f.setMesh(m);
7919         #
7920         d=DataArrayDouble.New();
7921         tab=[2.3,-1.2,6.3,-7.8,2.9,7.7,2.1,0.,3.6,-7.6]
7922         d.setValues(tab,5,2);
7923         f.setArray(d);
7924         f.checkCoherency();
7925         #
7926         self.assertAlmostEqual(7.8,f.normMax(),14);
7927         #
7928         pass
7929
7930     def testFindAndCorrectBadOriented3DExtrudedCells1(self):
7931         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];
7932         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]
7933         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]
7934         invalidCells=[2,3,6,7]
7935         m=MEDCouplingUMesh.New("Example",3);
7936         coo=DataArrayDouble.New();
7937         coo.setValues(coords,38,3);
7938         m.setCoords(coo);
7939         m.allocateCells(8);
7940         m.insertNextCell(NORM_PENTA6,6,conn[0:6])
7941         m.insertNextCell(NORM_PENTA6,6,conn[6:12])
7942         m.insertNextCell(NORM_PENTA6,6,conn[12:18])
7943         m.insertNextCell(NORM_PENTA6,6,conn[18:24])
7944         m.insertNextCell(NORM_HEXA8,8,conn[24:32])
7945         m.insertNextCell(NORM_HEXA8,8,conn[32:40])
7946         m.insertNextCell(NORM_HEXA8,8,conn[40:48])
7947         m.insertNextCell(NORM_HEXA8,8,conn[48:56])
7948         m.finishInsertingCells();
7949         #
7950         v=m.findAndCorrectBadOriented3DExtrudedCells();
7951         self.assertEqual(4,len(v));
7952         self.assertEqual(v.getValues(),invalidCells);
7953         self.assertEqual(connExp,m.getNodalConnectivity().getValues());
7954         self.assertTrue(m.findAndCorrectBadOriented3DExtrudedCells().empty())
7955         #
7956         pass
7957
7958     def testConvertExtrudedPolyhedra1(self):
7959         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]
7960         m=MEDCouplingUMesh.New("Example",3);
7961         coo=DataArrayDouble.New();
7962         coo.alloc(73,3);
7963         coo.rearrange(1); coo.iota(0); coo.rearrange(3);
7964         m.setCoords(coo);
7965         m.allocateCells(9);
7966         m.insertNextCell(NORM_TETRA4,4,conn[0:4])
7967         m.insertNextCell(NORM_HEXA8,8,conn[4:12])
7968         m.insertNextCell(NORM_TETRA4,4,conn[12:16])
7969         m.insertNextCell(NORM_POLYHED,6,conn[16:22])
7970         m.insertNextCell(NORM_PENTA6,6,conn[22:28])
7971         m.insertNextCell(NORM_POLYHED,10,conn[28:38])
7972         m.insertNextCell(NORM_HEXA8,8,conn[38:46])
7973         m.insertNextCell(NORM_HEXGP12,12,conn[46:58])
7974         m.insertNextCell(NORM_POLYHED,14,conn[58:72])
7975         m.finishInsertingCells();
7976         #
7977         m.convertExtrudedPolyhedra();
7978         da=m.getNodalConnectivity();
7979         dai=m.getNodalConnectivityIndex();
7980         self.assertEqual(10,dai.getNbOfElems());
7981         self.assertEqual(159,da.getNbOfElems());
7982         #
7983         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];
7984         expected2=[0,5,14,19,42,49,86,95,108,159]
7985         self.assertEqual(expected1,da.getValues());
7986         self.assertEqual(expected2,dai.getValues());
7987         m.checkCoherency2()
7988         pass
7989
7990     def testNonRegressionCopyTinyStrings(self):
7991         m=MEDCouplingDataForTest.build2DTargetMesh_1()
7992         f1=m.getMeasureField(True)
7993         f1.getArray().setInfoOnComponent(0,"P [N/m^2]")
7994         bary=m.getBarycenterAndOwner()
7995         f2=f1.buildNewTimeReprFromThis(NO_TIME,False)
7996         f2.setArray(bary)
7997         self.assertRaises(InterpKernelException,f1.copyTinyAttrFrom,f2)
7998         pass
7999
8000     def testDaDSetPartOfValuesAdv1(self):
8001         tab1=[3.,4.,5., 13.,14.,15., 23.,24.,25., 33.,34.,35., 43.,44.,45., 53.,54.,55.]
8002         tab2=[6.,7.,8., 16.,17.,18., 26.,27.,28.]
8003         tab3=[4,1, 2,2, 3,0]
8004         a=DataArrayDouble.New();
8005         a.setValues(tab1,6,3);
8006         b=DataArrayDouble.New();
8007         b.setValues(tab2,3,3);
8008         c=DataArrayInt.New();
8009         c.setValues(tab3,3,2);
8010         #
8011         a.setPartOfValuesAdv(b,c);
8012         expected1=[3.,4.,5., 13.,14.,15., 26.,27.,28., 6.,7.,8., 16.,17.,18., 53.,54.,55.]
8013         self.assertEqual(expected1,a.getValues());
8014         pass
8015
8016     def testUMeshBuildSetInstanceFromThis1(self):
8017         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
8018         m2=m.buildSetInstanceFromThis(3);
8019         self.assertTrue(m.isEqual(m2,1e-12));
8020         #
8021         m=MEDCouplingUMesh.New("toto",2);
8022         m2=m.buildSetInstanceFromThis(3);
8023         self.assertEqual(0,m2.getNumberOfNodes());
8024         self.assertEqual(0,m2.getNumberOfCells());
8025         pass
8026
8027     def testUMeshMergeMeshesCVW1(self):
8028         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
8029         m2=MEDCouplingUMesh.New("toto",2);
8030         m3=MEDCouplingUMesh.MergeUMeshes([m,m2]);
8031         m3.setName(m.getName());
8032         self.assertTrue(m.isEqual(m3,1e-12));
8033         pass
8034
8035     def testChangeUnderlyingMeshWithCMesh1(self):
8036         mesh=MEDCouplingCMesh.New();
8037         coordsX=DataArrayDouble.New();
8038         arrX=[ -1., 1., 2., 4. ]
8039         coordsX.setValues(arrX,4,1);
8040         coordsY=DataArrayDouble.New();
8041         arrY=[ -2., 2., 4., 8. ]
8042         coordsY.setValues(arrY,4,1);
8043         coordsZ=DataArrayDouble.New();
8044         arrZ=[ -3., 3., 6., 12. ]
8045         coordsZ.setValues(arrZ,4,1);
8046         mesh.setCoords(coordsX,coordsY,coordsZ);
8047         f=mesh.getMeasureField(True)
8048         mesh2=mesh.deepCpy()
8049         for myId in [0,1,2,10,11,12,20,21,22]:
8050             f=mesh.getMeasureField(True)
8051             f.changeUnderlyingMesh(mesh2,myId,1e-12);
8052             pass
8053         mesh2.setName("uuuu")
8054         for myId in [1,2,10,11,12,20,21,22]:
8055             f=mesh.getMeasureField(True)
8056             f.changeUnderlyingMesh(mesh2,myId,1e-12);
8057             pass
8058         pass
8059
8060     def testDADFindCommonTuples1(self):
8061         da=DataArrayDouble.New();
8062         # nbOftuples=1
8063         array1=[2.3,1.2,1.3,2.3,2.301,0.8]
8064         da.setValues(array1,6,1)
8065         c,cI=da.findCommonTuples(1e-2);
8066         expected1=[0,3,4]
8067         expected2=[0,3]
8068         self.assertEqual(3,c.getNbOfElems());
8069         self.assertEqual(2,cI.getNbOfElems());
8070         self.assertEqual(expected1,c.getValues())
8071         self.assertEqual(expected2,cI.getValues())
8072         c,cI=da.findCommonTuples(2e-1)
8073         expected3=[0,3,4,1,2]
8074         expected4=[0,3,5]
8075         self.assertEqual(5,c.getNbOfElems());
8076         self.assertEqual(3,cI.getNbOfElems());
8077         self.assertEqual(expected3,c.getValues())
8078         self.assertEqual(expected4,cI.getValues())
8079         # nbOftuples=2
8080         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]
8081         da.setValues(array2,6,2)
8082         c,cI=da.findCommonTuples(1e-2);
8083         self.assertEqual(3,c.getNbOfElems());
8084         self.assertEqual(2,cI.getNbOfElems());
8085         self.assertEqual(expected1,c.getValues())
8086         self.assertEqual(expected2,cI.getValues())
8087         c,cI=da.findCommonTuples(2e-1)
8088         self.assertEqual(5,c.getNbOfElems());
8089         self.assertEqual(3,cI.getNbOfElems());
8090         self.assertEqual(expected3,c.getValues())
8091         self.assertEqual(expected4,cI.getValues())
8092         # nbOftuples=3
8093         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]
8094         da.setValues(array3,6,3)
8095         c,cI=da.findCommonTuples(1e-2);
8096         self.assertEqual(3,c.getNbOfElems());
8097         self.assertEqual(2,cI.getNbOfElems());
8098         self.assertEqual(expected1,c.getValues())
8099         self.assertEqual(expected2,cI.getValues())
8100         c,cI=da.findCommonTuples(2e-1)
8101         self.assertEqual(5,c.getNbOfElems());
8102         self.assertEqual(3,cI.getNbOfElems());
8103         self.assertEqual(expected3,c.getValues())
8104         self.assertEqual(expected4,cI.getValues())
8105         # nbOftuples=1, no common groups
8106         array11=[2.3,1.2,1.3,2.4,2.5,0.8]
8107         da.setValues(array11,6,1)
8108         c,cI=da.findCommonTuples(1e-2);
8109         self.assertEqual(0,c.getNbOfElems());
8110         self.assertEqual(1,cI.getNbOfElems());
8111         self.assertEqual([0],cI.getValues())
8112
8113         array12=[0.]*(6*5)
8114         da.setValues(array12,6,5) #bad NumberOfComponents
8115         self.assertRaises(InterpKernelException, da.findCommonTuples, 1e-2);
8116         pass
8117
8118     def testDABack1(self):
8119         da=DataArrayDouble.New();
8120         array1=[2.3,1.2,1.3,2.3,2.301,0.8]
8121         da.setValues(array1,6,1);
8122         self.assertAlmostEqual(0.8,da.back(),14);
8123         da.rearrange(2);
8124         self.assertRaises(InterpKernelException,da.back);
8125         da.alloc(0,1);
8126         self.assertRaises(InterpKernelException,da.back);
8127         #
8128         da=DataArrayInt.New();
8129         array2=[4,7,8,2]
8130         da.setValues(array2,4,1);
8131         self.assertEqual(2,da.back());
8132         da.rearrange(2);
8133         self.assertRaises(InterpKernelException,da.back);
8134         da.alloc(0,1);
8135         self.assertRaises(InterpKernelException,da.back);
8136         pass
8137
8138     def testDADGetDifferentValues1(self):
8139         da=DataArrayDouble.New();
8140         array1=[2.3,1.2,1.3,2.3,2.301,0.8]
8141         da.setValues(array1,6,1)
8142         #
8143         expected1=[2.301,1.2,1.3,0.8]
8144         dv=da.getDifferentValues(1e-2);
8145         self.assertEqual(4,dv.getNbOfElems());
8146         for i in xrange(4):
8147             self.assertAlmostEqual(expected1[i],dv.getIJ(i,0),14);
8148             pass
8149         #
8150         dv=da.getDifferentValues(2e-1);
8151         expected2=[2.301,1.3,0.8]
8152         self.assertEqual(3,dv.getNbOfElems());
8153         for i in xrange(3):
8154             self.assertAlmostEqual(expected2[i],dv.getIJ(i,0),14);
8155             pass
8156         pass
8157
8158     def testDAIBuildOld2NewArrayFromSurjectiveFormat2(self):
8159         arr=[0,3, 5,7,9]
8160         arrI=[0,2,5]
8161         a=DataArrayInt.New();
8162         a.setValues(arr,5,1);
8163         b=DataArrayInt.New();
8164         b.setValues(arrI,3,1);
8165         ret,newNbTuple=DataArrayInt.BuildOld2NewArrayFromSurjectiveFormat2(10,a,b);
8166         expected=[0,1,2,0,3,4,5,4,6,4]
8167         self.assertEqual(10,ret.getNbOfElems());
8168         self.assertEqual(7,newNbTuple);
8169         self.assertEqual(1,ret.getNumberOfComponents());
8170         self.assertEqual(expected,ret.getValues());
8171         self.assertRaises(InterpKernelException,DataArrayInt.BuildOld2NewArrayFromSurjectiveFormat2,9,a,b);
8172         pass
8173
8174     def testDADIReverse1(self):
8175         arr=[0,3,5,7,9,2]
8176         a=DataArrayInt.New();
8177         a.setValues(arr,6,1);
8178         self.assertEqual(2,a.back());
8179         a.reverse();
8180         for i in xrange(6):
8181             self.assertEqual(arr[5-i],a.getIJ(i,0));
8182             pass
8183         a.setValues(arr[:-1],5,1);
8184         a.reverse();
8185         for i in xrange(5):
8186             self.assertEqual(arr[4-i],a.getIJ(i,0));
8187             pass
8188         #
8189         arr2=[0.,3.,5.,7.,9.,2.]
8190         b=DataArrayDouble.New();
8191         b.setValues(arr2,6,1);
8192         b.reverse();
8193         for i in xrange(6):
8194             self.assertAlmostEqual(arr2[5-i],b.getIJ(i,0),14);
8195             pass
8196         b.setValues(arr2[:5],5,1);
8197         self.assertAlmostEqual(9.,b.back(),14)
8198         b.reverse();
8199         for i in xrange(5):
8200             self.assertAlmostEqual(arr2[4-i],b.getIJ(i,0),14);
8201             pass
8202         pass
8203
8204     def testGetNodeIdsInUse1(self):
8205         m0=MEDCouplingDataForTest.build2DTargetMesh_1();
8206         CellIds=[1,2]
8207         m1=m0.buildPartOfMySelf(CellIds,True);
8208         arr,newNbOfNodes=m1.getNodeIdsInUse();
8209         expected=[-1,0,1,-1,2,3,-1,-1,-1]
8210         self.assertEqual(4,newNbOfNodes);
8211         self.assertEqual(9,arr.getNbOfElems());
8212         self.assertEqual(expected,arr.getValues());
8213         arr2=arr.invertArrayO2N2N2O(newNbOfNodes);
8214         self.assertEqual(4,arr2.getNbOfElems());
8215         expected2=[1,2,4,5]
8216         self.assertEqual(expected2,arr2.getValues());
8217         pass
8218
8219     def testBuildDescendingConnec2(self):
8220         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
8221         #
8222         mesh2,desc,descIndx,revDesc,revDescIndx=mesh.buildDescendingConnectivity2();
8223         mesh2.checkCoherency();
8224         self.assertEqual(1,mesh2.getMeshDimension());
8225         self.assertEqual(13,mesh2.getNumberOfCells());
8226         self.assertEqual(14,revDescIndx.getNbOfElems()); self.assertEqual(14,revDescIndx.getNumberOfTuples());
8227         self.assertEqual(6,descIndx.getNbOfElems()); self.assertEqual(6,descIndx.getNumberOfTuples());
8228         self.assertEqual(18,desc.getNbOfElems()); self.assertEqual(18,desc.getNumberOfTuples());
8229         self.assertEqual(18,revDesc.getNbOfElems()); self.assertEqual(18,revDesc.getNumberOfTuples());
8230         expected1=[1,2,3,4,-3,5,6, 7,8,-5,9,10,-2,11, 12,13,-7,-10]
8231         self.assertEqual(expected1,desc.getValues());
8232         expected2=[0,4,7,10,14,18]
8233         self.assertEqual(expected2,descIndx.getValues());
8234         expected3=[0,1,3,5,6,8,9,11,12,13,15,16,17,18]
8235         self.assertEqual(expected3,revDescIndx.getValues());
8236         expected4=[0, 0,3, 0,1, 0, 1,2, 1, 2,4, 2, 3, 3,4, 3, 4, 4]
8237         self.assertEqual(expected4,revDesc.getValues());
8238         conn=mesh2.getNodalConnectivity();
8239         connIndex=mesh2.getNodalConnectivityIndex();
8240         expected5=[0,3,6,9,12,15,18,21,24,27,30,33,36,39]
8241         self.assertEqual(expected5,connIndex.getValues());
8242         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]
8243         self.assertEqual(expected6,conn.getValues());
8244         pass
8245
8246     def testIntersect2DMeshesTmp1(self):
8247         m1c=MEDCouplingCMesh.New();
8248         coordsX=DataArrayDouble.New();
8249         arrX=[ -1., 1., 2., 4. ]
8250         coordsX.setValues(arrX,4,1);
8251         m1c.setCoordsAt(0,coordsX);
8252         coordsY=DataArrayDouble.New();
8253         arrY=[ -2., 2., 4., 8. ]
8254         coordsY.setValues(arrY,4,1);
8255         m1c.setCoordsAt(1,coordsY);
8256         m1=m1c.buildUnstructured()
8257         m1bis=m1.buildPartOfMySelf([3,4,5],False)
8258         m2=m1.deepCpy()
8259         m2=m2.buildPartOfMySelf([0,1,2],False)
8260         m2.translate([0.5,0.5])
8261         #
8262         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m1bis,m2,1e-10)
8263         expected1=[0,0,1,1,1,2,2,2]
8264         expected2=[0,-1,0,1,-1,1,2,-1]
8265         self.assertEqual(8,d1.getNumberOfTuples());
8266         self.assertEqual(8,d2.getNumberOfTuples());
8267         self.assertEqual(8,m3.getNumberOfCells());
8268         self.assertEqual(22,m3.getNumberOfNodes());
8269         self.assertEqual(2,m3.getSpaceDimension());
8270         self.assertEqual(expected1,d1.getValues());
8271         self.assertEqual(expected2,d2.getValues());
8272         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]
8273         expected4=[0,5,12,17,22,28,33,38,44]
8274         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]
8275         self.assertEqual(44,m3.getNodalConnectivity().getNumberOfTuples());
8276         self.assertEqual(9,m3.getNodalConnectivityIndex().getNumberOfTuples());
8277         self.assertEqual(expected3,m3.getNodalConnectivity().getValues());
8278         self.assertEqual(expected4,m3.getNodalConnectivityIndex().getValues());
8279         for i in xrange(44):
8280             self.assertAlmostEqual(expected5[i],m3.getCoords().getIJ(0,i),12);
8281             pass
8282         pass
8283
8284     def testFindNodesOnLine1(self):
8285         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
8286         pt=[-0.3,-0.3]
8287         pt2=[0.,0.,0.]
8288         pt3=[-0.3,0.,0.]
8289         vec=[0.,1.]
8290         vec2=[1.,0.,0.]
8291         vec3=[0.,1.,1.]
8292         expected1=[0,3,6]
8293         res=mesh.findNodesOnLine(pt,vec,1e-12);
8294         self.assertEqual(3,len(res));
8295         self.assertEqual(expected1,res.getValues());
8296         #
8297         mesh.changeSpaceDimension(3);
8298         mesh.rotate(pt2,vec2,pi/4.);
8299         res=mesh.findNodesOnLine(pt3,vec3,1e-12);
8300         self.assertEqual(3,len(res));
8301         self.assertEqual(expected1,res.getValues());
8302         pass
8303
8304     def testIntersect2DMeshesTmp2(self):
8305         m1c=MEDCouplingCMesh.New();
8306         coordsX1=DataArrayDouble.New();
8307         arrX1=[ 0., 1., 1.5, 2. ]
8308         coordsX1.setValues(arrX1,4,1);
8309         m1c.setCoordsAt(0,coordsX1);
8310         coordsY1=DataArrayDouble.New();
8311         arrY1=[ 0., 1.5, 3.]
8312         coordsY1.setValues(arrY1,3,1);
8313         m1c.setCoordsAt(1,coordsY1);
8314         m1=m1c.buildUnstructured();
8315         m2c=MEDCouplingCMesh.New();
8316         coordsX2=DataArrayDouble.New();
8317         arrX2=[ 0., 1., 2. ]
8318         coordsX2.setValues(arrX2,3,1);
8319         m2c.setCoordsAt(0,coordsX2);
8320         coordsY2=DataArrayDouble.New();
8321         arrY2=[ 0., 1., 3.]
8322         coordsY2.setValues(arrY2,3,1);
8323         m2c.setCoordsAt(1,coordsY2);
8324         m2=m2c.buildUnstructured();
8325         #
8326         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m1,m2,1e-10)
8327         #
8328         expected1=[0,0,1,1,2,2,3,4,5]
8329         expected2=[0,2,1,3,1,3,2,3,3]
8330         self.assertEqual(9,d1.getNumberOfTuples());
8331         self.assertEqual(9,d2.getNumberOfTuples());
8332         self.assertEqual(9,m3.getNumberOfCells());
8333         self.assertEqual(22,m3.getNumberOfNodes());
8334         self.assertEqual(2,m3.getSpaceDimension());
8335         self.assertEqual(expected1,d1.getValues());
8336         self.assertEqual(expected2,d2.getValues());
8337         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]
8338         expected4=[0,5,10,15,20,25,30,35,40,45]
8339         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]
8340         self.assertEqual(45,m3.getNodalConnectivity().getNumberOfTuples());
8341         self.assertEqual(10,m3.getNodalConnectivityIndex().getNumberOfTuples());
8342         self.assertEqual(expected3,m3.getNodalConnectivity().getValues());
8343         self.assertEqual(expected4,m3.getNodalConnectivityIndex().getValues());
8344         for i in xrange(44):
8345             self.assertAlmostEqual(expected5[i],m3.getCoords().getIJ(0,i),12);
8346             pass
8347         pass
8348
8349     def testBuildPartOfMySelfSafe1(self):
8350         mesh=MEDCouplingDataForTest.build2DTargetMesh_1()
8351         self.assertRaises(InterpKernelException,mesh.buildPartOfMySelf,[0,-1,4,2],True)
8352         self.assertRaises(InterpKernelException,mesh.buildPartOfMySelf,[0,4,5,4],True)
8353         pass
8354
8355     def testIntersect2DMeshesTmp3(self):
8356         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];
8357         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];
8358         m1=MEDCouplingUMesh.New();
8359         m1.setMeshDimension(2);
8360         m1.allocateCells(8);
8361         m1.insertNextCell(NORM_TRI6,6,m1Conn[0:6]);
8362         m1.insertNextCell(NORM_QUAD8,8,m1Conn[6:14]);
8363         m1.insertNextCell(NORM_TRI6,6,m1Conn[14:20]);
8364         m1.insertNextCell(NORM_QUAD8,8,m1Conn[20:28]);
8365         m1.insertNextCell(NORM_TRI6,6,m1Conn[28:34]);
8366         m1.insertNextCell(NORM_QUAD8,8,m1Conn[34:42]);
8367         m1.insertNextCell(NORM_TRI6,6,m1Conn[42:48]);
8368         m1.insertNextCell(NORM_QUAD8,8,m1Conn[48:56]);
8369         m1.finishInsertingCells();
8370         myCoords1=DataArrayDouble.New();
8371         myCoords1.setValues(m1Coords,25,2);
8372         m1.setCoords(myCoords1);
8373         #
8374         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.]
8375         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]
8376         m2=MEDCouplingUMesh.New();
8377         m2.setMeshDimension(2);
8378         m2.allocateCells(8);
8379         for i in xrange(8):
8380             m2.insertNextCell(NORM_QUAD4,4,m2Conn[4*i:4*(i+1)])
8381             pass
8382         m2.finishInsertingCells();
8383         myCoords2=DataArrayDouble.New();
8384         myCoords2.setValues(m2Coords,15,2);
8385         m2.setCoords(myCoords2);
8386         #
8387         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m1,m2,1e-10)
8388         m3.unPolyze()
8389         #
8390         expected1=[0,1,1,1,2,3,3,3,4,5,5,5,6,7,7,7]
8391         expected2=[0,0,1,-1,2,2,3,-1,4,4,5,-1,6,6,7,-1]
8392         self.assertEqual(16,d1.getNumberOfTuples());
8393         self.assertEqual(16,d2.getNumberOfTuples());
8394         self.assertEqual(16,m3.getNumberOfCells());
8395         self.assertEqual(104,m3.getNumberOfNodes());
8396         self.assertEqual(2,m3.getSpaceDimension());
8397         self.assertEqual(expected1,d1.getValues());
8398         self.assertEqual(expected2,d2.getValues());
8399         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]
8400         expected4=[0,7,16,25,34,41,50,59,68,75,84,93,102,109,118,127,136]
8401         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]
8402         self.assertEqual(136,m3.getNodalConnectivity().getNumberOfTuples());
8403         self.assertEqual(17,m3.getNodalConnectivityIndex().getNumberOfTuples());
8404         self.assertEqual(expected3,m3.getNodalConnectivity().getValues());
8405         self.assertEqual(expected4,m3.getNodalConnectivityIndex().getValues());
8406         for i in xrange(208):
8407             self.assertAlmostEqual(expected5[i],m3.getCoords().getIJ(0,i),12);
8408             pass
8409         pass
8410
8411     def testUMeshTessellate2D1(self):
8412         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];
8413         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];
8414         m1=MEDCouplingUMesh.New();
8415         m1.setMeshDimension(2);
8416         m1.allocateCells(8);
8417         m1.insertNextCell(NORM_TRI6,6,m1Conn[0:6]);
8418         m1.insertNextCell(NORM_QUAD8,8,m1Conn[6:14]);
8419         m1.insertNextCell(NORM_TRI6,6,m1Conn[14:20]);
8420         m1.insertNextCell(NORM_QUAD8,8,m1Conn[20:28]);
8421         m1.insertNextCell(NORM_TRI6,6,m1Conn[28:34]);
8422         m1.insertNextCell(NORM_QUAD8,8,m1Conn[34:42]);
8423         m1.insertNextCell(NORM_TRI6,6,m1Conn[42:48]);
8424         m1.insertNextCell(NORM_QUAD8,8,m1Conn[48:56]);
8425         m1.finishInsertingCells();
8426         myCoords1=DataArrayDouble.New();
8427         myCoords1.setValues(m1Coords,25,2);
8428         m1.setCoords(myCoords1);
8429         #
8430         m11=m1.deepCpy();
8431         m11.tessellate2D(1.);
8432         self.assertTrue(m11.getCoords().isEqual(m11.getCoords(),1e-12));
8433         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]
8434         expected2=[0,5,12,17,24,29,36,41,48]
8435         self.assertEqual(48,m11.getNodalConnectivity().getNumberOfTuples());
8436         self.assertEqual(9,m11.getNodalConnectivityIndex().getNumberOfTuples());
8437         self.assertEqual(expected1,m11.getNodalConnectivity().getValues());
8438         self.assertEqual(expected2,m11.getNodalConnectivityIndex().getValues());
8439         #
8440         m12=m1.deepCpy();
8441         m12.tessellate2D(0.5);
8442         self.assertEqual(41,m12.getNumberOfNodes());
8443         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]
8444         expected4=[0,6,15,21,30,36,45,51,60]
8445         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]
8446         for i in xrange(82):
8447             self.assertAlmostEqual(expected5[i],m12.getCoords().getIJ(0,i),12);
8448             pass
8449         self.assertEqual(60,m12.getNodalConnectivity().getNumberOfTuples());
8450         self.assertEqual(9,m12.getNodalConnectivityIndex().getNumberOfTuples());
8451         self.assertEqual(expected3,m12.getNodalConnectivity().getValues());
8452         self.assertEqual(expected4,m12.getNodalConnectivityIndex().getValues());
8453         pass
8454
8455     def testUMeshTessellate2DCurve1(self):
8456         # A quarter of circle:
8457         mcoords = [0.4,0.0,   0.0,-0.4,   0.283,-0.283]
8458         mconnec = [0,1,2]
8459
8460         m1 = MEDCouplingUMesh.New()
8461         m1.setMeshDimension(1)
8462         m1.allocateCells(1)
8463         m1.insertNextCell(NORM_SEG3, mconnec)
8464
8465         myCoords = DataArrayDouble.New(mcoords, 3, 2)
8466         m1.setCoords(myCoords)
8467
8468         m2 = m1.deepCpy()
8469         m2.tessellate2DCurve(0.1)
8470         # If the following raises, the test will fail automatically:
8471         m2.checkCoherency1(0.0) # eps param not used
8472
8473     def testIntersect2DMeshesTmp4(self):
8474         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];
8475         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];
8476         m1=MEDCouplingUMesh.New();
8477         m1.setMeshDimension(2);
8478         m1.allocateCells(8);
8479         m1.insertNextCell(NORM_TRI6,6,m1Conn[0:6]);
8480         m1.insertNextCell(NORM_QUAD8,8,m1Conn[6:14]);
8481         m1.insertNextCell(NORM_TRI6,6,m1Conn[14:20]);
8482         m1.insertNextCell(NORM_QUAD8,8,m1Conn[20:28]);
8483         m1.insertNextCell(NORM_TRI6,6,m1Conn[28:34]);
8484         m1.insertNextCell(NORM_QUAD8,8,m1Conn[34:42]);
8485         m1.insertNextCell(NORM_TRI6,6,m1Conn[42:48]);
8486         m1.insertNextCell(NORM_QUAD8,8,m1Conn[48:56]);
8487         m1.finishInsertingCells();
8488         myCoords1=DataArrayDouble.New();
8489         myCoords1.setValues(m1Coords,25,2);
8490         m1.setCoords(myCoords1);
8491         #
8492         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.]
8493         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]
8494         m2=MEDCouplingUMesh.New();
8495         m2.setMeshDimension(2);
8496         m2.allocateCells(8);
8497         for i in xrange(8):
8498             m2.insertNextCell(NORM_QUAD4,4,m2Conn[4*i:4*(i+1)])
8499             pass
8500         m2.finishInsertingCells();
8501         myCoords2=DataArrayDouble.New();
8502         myCoords2.setValues(m2Coords,15,2);
8503         m2.setCoords(myCoords2);
8504         #
8505         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m2,m1,1e-10)
8506         m3.unPolyze()
8507         #
8508         expected1=[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
8509         expected2=[0,1,1,-1,2,3,3,-1,4,5,5,-1,6,7,7,-1]
8510         self.assertEqual(16,d1.getNumberOfTuples());
8511         self.assertEqual(16,d2.getNumberOfTuples());
8512         self.assertEqual(16,m3.getNumberOfCells());
8513         self.assertEqual(104,m3.getNumberOfNodes());
8514         self.assertEqual(2,m3.getSpaceDimension());
8515         self.assertEqual(expected1,d1.getValues());
8516         self.assertEqual(expected2,d2.getValues());
8517         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]
8518         expected4=[0,7,16,25,34,41,50,59,68,75,84,93,102,109,118,127,136]
8519         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]
8520         self.assertEqual(136,m3.getNodalConnectivity().getNumberOfTuples());
8521         self.assertEqual(17,m3.getNodalConnectivityIndex().getNumberOfTuples());
8522         self.assertEqual(expected3,m3.getNodalConnectivity().getValues());
8523         self.assertEqual(expected4,m3.getNodalConnectivityIndex().getValues());
8524         for i in xrange(208):
8525             self.assertAlmostEqual(expected5[i],m3.getCoords().getIJ(0,i),12);
8526             pass
8527         pass
8528
8529     def testGetCellIdsCrossingPlane1(self):
8530         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
8531         vec=[-0.07,1.,0.07]
8532         origin=[1.524,1.4552,1.74768]
8533         ids1=mesh3D.getCellIdsCrossingPlane(origin,vec,1e-10)
8534         self.assertEqual([1,3,4,7,9,10,13,15,16],ids1.getValues())
8535         vec2=[0.,0.,1.]
8536         ids2=mesh3D.getCellIdsCrossingPlane(origin,vec2,1e-10)
8537         self.assertEqual([6,7,8,9,10,11],ids2.getValues())
8538         pass
8539
8540     def testBuildSlice3D1(self):
8541         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
8542         vec1=[-0.07,1.,0.07]
8543         origin1=[1.524,1.4552,1.74768]
8544         slice1,ids=mesh3D.buildSlice3D(origin1,vec1,1e-10);
8545         expected1=[1,3,4,7,9,10,13,15,16]
8546         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]
8547         expected3=[0,6,11,17,22,27,32,37,42,47]
8548         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.]
8549         self.assertEqual(2,slice1.getMeshDimension());
8550         self.assertEqual(3,slice1.getSpaceDimension());
8551         self.assertEqual(57,slice1.getNumberOfNodes());
8552         self.assertEqual(9,slice1.getNumberOfCells());
8553         self.assertEqual(9,ids.getNumberOfTuples());
8554         self.assertEqual(47,slice1.getNodalConnectivity().getNumberOfTuples());
8555         self.assertEqual(10,slice1.getNodalConnectivityIndex().getNumberOfTuples());
8556         self.assertEqual(expected1,ids.getValues());
8557         self.assertEqual(expected2,slice1.getNodalConnectivity().getValues());
8558         self.assertEqual(expected3,slice1.getNodalConnectivityIndex().getValues());
8559         for i in xrange(171):
8560             self.assertAlmostEqual(expected4[i],slice1.getCoords().getIJ(0,i),12);
8561             pass
8562         # 2nd slice based on already existing nodes of mesh3D.
8563         vec2=[0.,3.,1.]
8564         origin2=[2.5,1.,3.]
8565         slice1,ids=mesh3D.buildSlice3D(origin2,vec2,1e-10);
8566         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]
8567         expected6=[0,5,10,15,21,26,32,38,43,49]
8568         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]
8569         self.assertEqual(2,slice1.getMeshDimension());
8570         self.assertEqual(3,slice1.getSpaceDimension());
8571         self.assertEqual(60,slice1.getNumberOfNodes());
8572         self.assertEqual(9,slice1.getNumberOfCells());
8573         self.assertEqual(9,ids.getNumberOfTuples());
8574         self.assertEqual(49,slice1.getNodalConnectivity().getNumberOfTuples());
8575         self.assertEqual(10,slice1.getNodalConnectivityIndex().getNumberOfTuples());
8576         self.assertEqual(expected1,ids.getValues());
8577         self.assertEqual(expected5,slice1.getNodalConnectivity().getValues());
8578         self.assertEqual(expected6,slice1.getNodalConnectivityIndex().getValues());
8579         for i in xrange(180):
8580             self.assertAlmostEqual(expected7[i],slice1.getCoords().getIJ(0,i),12);
8581             pass
8582         # 3rd slice based on shared face of mesh3D.
8583         vec3=[0.,0.,1.]
8584         origin3=[2.5,1.,2.]
8585         slice1,ids=mesh3D.buildSlice3D(origin3,vec3,1e-10);
8586         expected8=[6,7,8,9,10,11,12,13,14,15,16,17]
8587         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]
8588         expected10=[0,5,12,17,22,29,34,39,46,51,56,63,68]
8589         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.]
8590         self.assertEqual(2,slice1.getMeshDimension());
8591         self.assertEqual(3,slice1.getSpaceDimension());
8592         self.assertEqual(45,slice1.getNumberOfNodes());
8593         self.assertEqual(12,slice1.getNumberOfCells());
8594         self.assertEqual(12,ids.getNumberOfTuples());
8595         self.assertEqual(68,slice1.getNodalConnectivity().getNumberOfTuples());
8596         self.assertEqual(13,slice1.getNodalConnectivityIndex().getNumberOfTuples());
8597         self.assertEqual(expected8,ids.getValues());
8598         self.assertEqual(expected9,slice1.getNodalConnectivity().getValues());
8599         self.assertEqual(expected10,slice1.getNodalConnectivityIndex().getValues());
8600         for i in xrange(135):
8601             self.assertAlmostEqual(expected11[i],slice1.getCoords().getIJ(0,i),12);
8602             pass
8603         pass
8604
8605     def testBuildSlice3DSurf1(self):
8606         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
8607         mesh2D=mesh3D.buildDescendingConnectivity()[0];
8608         vec1=[-0.07,1.,0.07]
8609         origin1=[1.524,1.4552,1.74768]
8610         slice1,ids=mesh2D.buildSlice3DSurf(origin1,vec1,1e-10);
8611         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]
8612         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]
8613         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];
8614         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.]
8615         self.assertEqual(1,slice1.getMeshDimension());
8616         self.assertEqual(3,slice1.getSpaceDimension());
8617         self.assertEqual(57,slice1.getNumberOfNodes());
8618         self.assertEqual(25,slice1.getNumberOfCells());
8619         self.assertEqual(25,ids.getNumberOfTuples());
8620         self.assertEqual(75,slice1.getNodalConnectivity().getNumberOfTuples());
8621         self.assertEqual(26,slice1.getNodalConnectivityIndex().getNumberOfTuples());
8622         self.assertEqual(expected1,ids.getValues());
8623         self.assertEqual(expected2,slice1.getNodalConnectivity().getValues());
8624         self.assertEqual(expected3,slice1.getNodalConnectivityIndex().getValues());
8625         for i in xrange(171):
8626             self.assertAlmostEqual(expected4[i],slice1.getCoords().getIJ(0,i),12);
8627             pass
8628         #
8629         vec2=[0.,0.,1.]
8630         origin2=[2.5,1.,2.]
8631         slice1,ids=mesh2D.buildSlice3DSurf(origin2,vec2,1e-10);
8632         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]
8633         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]
8634         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];
8635         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.]
8636         self.assertEqual(1,slice1.getMeshDimension());
8637         self.assertEqual(3,slice1.getSpaceDimension());
8638         self.assertEqual(45,slice1.getNumberOfNodes());
8639         self.assertEqual(68,slice1.getNumberOfCells());
8640         self.assertEqual(68,ids.getNumberOfTuples());
8641         self.assertEqual(204,slice1.getNodalConnectivity().getNumberOfTuples());
8642         self.assertEqual(69,slice1.getNodalConnectivityIndex().getNumberOfTuples());
8643         self.assertEqual(expected5,ids.getValues());
8644         self.assertEqual(expected6,slice1.getNodalConnectivity().getValues());
8645         self.assertEqual(expected7,slice1.getNodalConnectivityIndex().getValues());
8646         for i in xrange(135):
8647             self.assertAlmostEqual(expected8[i],slice1.getCoords().getIJ(0,i),12);
8648             pass
8649         pass
8650
8651     def testDataArrayDoubleAdvSetting1(self):
8652         data1=[1.,11.,2.,12.,3.,13.,4.,14.,5.,15.,6.,16.,7.,17.]
8653         data2=[8.,38.,9.,39.,0.,30.,11.,41.,12.,42.]
8654         compsCpp=["comp1","comp2"]
8655         da=DataArrayDouble.New();
8656         da.setInfoAndChangeNbOfCompo(compsCpp);
8657         da.setName("da");
8658         da.alloc(7,2);
8659         compsCpp=compsCpp[:-1]
8660         self.assertRaises(InterpKernelException,da.setInfoAndChangeNbOfCompo,compsCpp);
8661         da.setValues(data1,7,2)
8662         #
8663         p=[(0,3),(3,5),(5,7)]
8664         tmp=da.selectByTupleRanges(p);
8665         self.assertTrue(tmp.isEqual(da,1e-14));
8666         p=[(0,2),(3,4),(5,7)]
8667         tmp=da.selectByTupleRanges(p);
8668         expected1=[1.,11.,2.,12.,4.,14.,6.,16.,7.,17.]
8669         self.assertEqual(5,tmp.getNumberOfTuples());
8670         self.assertEqual(2,tmp.getNumberOfComponents());
8671         for i in xrange(10):
8672             self.assertAlmostEqual(expected1[i],tmp.getIJ(0,i),14);
8673             pass
8674         p=[(0,2),(0,2),(5,6)]
8675         tmp=da.selectByTupleRanges(p);
8676         expected2=[1.,11.,2.,12.,1.,11.,2.,12.,6.,16.]
8677         self.assertEqual(5,tmp.getNumberOfTuples());
8678         self.assertEqual(2,tmp.getNumberOfComponents());
8679         for i in xrange(10):
8680             self.assertAlmostEqual(expected2[i],tmp.getIJ(0,i),14);
8681             pass
8682         p=[(0,2),(-1,2),(5,6)]
8683         self.assertRaises(InterpKernelException,da.selectByTupleRanges,p);
8684         p=[(0,2),(0,2),(5,8)]
8685         self.assertRaises(InterpKernelException,da.selectByTupleRanges,p);
8686         #
8687         da2=DataArrayDouble.New();
8688         da2.setValues(data2,5,2);
8689         #
8690         dac=da.deepCpy();
8691         dac.setContigPartOfSelectedValues2(1,da2,2,4,1);
8692         expected3=[1.,11.,0.,30.,11.,41.,4.,14.,5.,15.,6.,16.,7.,17.]
8693         for i in xrange(14):
8694             self.assertAlmostEqual(expected3[i],dac.getIJ(0,i),14);
8695             pass
8696         #
8697         dac=da.deepCpy();
8698         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,3,da2,0,5,1);
8699         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,0,da2,4,6,1);
8700         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,3,da2,5,0,1);
8701         dac.setContigPartOfSelectedValues2(3,da2,1,5,1);
8702         expected4=[1.,11.,2.,12.,3.,13.,9.,39.,0.,30.,11.,41.,12.,42.]
8703         for i in xrange(14):
8704             self.assertAlmostEqual(expected4[i],dac.getIJ(0,i),14);
8705             pass
8706         #
8707         ids=DataArrayInt.New();
8708         ids.alloc(3,1);
8709         dac=da.deepCpy();
8710         ids.setIJ(0,0,2); ids.setIJ(1,0,0); ids.setIJ(2,0,4);
8711         dac.setContigPartOfSelectedValues(2,da2,ids);
8712         expected5=[1.,11.,2.,12.,0.,30.,8.,38.,12.,42.,6.,16.,7.,17.]
8713         for i in xrange(14):
8714             self.assertAlmostEqual(expected5[i],dac.getIJ(0,i),14);
8715             pass
8716         #
8717         dac=da.deepCpy();
8718         ids.setIJ(0,0,2); ids.setIJ(1,0,5); ids.setIJ(2,0,4);
8719         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,1,da2,ids);
8720         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,-1);
8721         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,1,da2,ids);
8722         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,1);
8723         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,5,da2,ids);
8724         #
8725         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,1);
8726         dac=da.deepCpy();
8727         dac.setContigPartOfSelectedValues(4,da2,ids);
8728         expected6=[1.,11.,2.,12.,3.,13.,4.,14.,0.,30.,0.,30.,9.,39.]
8729         for i in xrange(14):
8730             self.assertAlmostEqual(expected6[i],dac.getIJ(0,i),14);
8731             pass
8732         pass
8733
8734     def testDataArrayIntAdvSetting1(self):
8735         data1=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
8736         data2=[8,38,9,39,0,30,11,41,12,42]
8737         compsCpp=["comp1","comp2"]
8738         da=DataArrayInt.New();
8739         da.setInfoAndChangeNbOfCompo(compsCpp);
8740         da.setName("da");
8741         da.alloc(7,2);
8742         compsCpp=compsCpp[:-1]
8743         self.assertRaises(InterpKernelException,da.setInfoAndChangeNbOfCompo,compsCpp);
8744         da.setValues(data1,7,2)
8745         #
8746         p=[(0,3),(3,5),(5,7)]
8747         tmp=da.selectByTupleRanges(p);
8748         self.assertTrue(tmp.isEqual(da));
8749         p=[(0,2),(3,4),(5,7)]
8750         tmp=da.selectByTupleRanges(p);
8751         expected1=[1,11,2,12,4,14,6,16,7,17]
8752         self.assertEqual(5,tmp.getNumberOfTuples());
8753         self.assertEqual(2,tmp.getNumberOfComponents());
8754         for i in xrange(10):
8755             self.assertEqual(expected1[i],tmp.getIJ(0,i));
8756             pass
8757         p=[(0,2),(0,2),(5,6)]
8758         tmp=da.selectByTupleRanges(p);
8759         expected2=[1,11,2,12,1,11,2,12,6,16]
8760         self.assertEqual(5,tmp.getNumberOfTuples());
8761         self.assertEqual(2,tmp.getNumberOfComponents());
8762         for i in xrange(10):
8763             self.assertEqual(expected2[i],tmp.getIJ(0,i));
8764             pass
8765         p=[(0,2),(-1,2),(5,6)]
8766         self.assertRaises(InterpKernelException,da.selectByTupleRanges,p);
8767         p=[(0,2),(0,2),(5,8)]
8768         self.assertRaises(InterpKernelException,da.selectByTupleRanges,p);
8769         #
8770         da2=DataArrayInt.New();
8771         da2.setValues(data2,5,2);
8772         #
8773         dac=da.deepCpy();
8774         dac.setContigPartOfSelectedValues2(1,da2,2,4,1);
8775         expected3=[1,11,0,30,11,41,4,14,5,15,6,16,7,17]
8776         for i in xrange(14):
8777             self.assertEqual(expected3[i],dac.getIJ(0,i));
8778             pass
8779         #
8780         dac=da.deepCpy();
8781         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,3,da2,0,5,1);
8782         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,0,da2,4,6,1);
8783         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,3,da2,5,0,1);
8784         dac.setContigPartOfSelectedValues2(3,da2,1,5,1);
8785         expected4=[1,11,2,12,3,13,9,39,0,30,11,41,12,42]
8786         for i in xrange(14):
8787             self.assertEqual(expected4[i],dac.getIJ(0,i));
8788             pass
8789         #
8790         ids=DataArrayInt.New();
8791         ids.alloc(3,1);
8792         dac=da.deepCpy();
8793         ids.setIJ(0,0,2); ids.setIJ(1,0,0); ids.setIJ(2,0,4);
8794         dac.setContigPartOfSelectedValues(2,da2,ids);
8795         expected5=[1,11,2,12,0,30,8,38,12,42,6,16,7,17]
8796         for i in xrange(14):
8797             self.assertEqual(expected5[i],dac.getIJ(0,i));
8798             pass
8799         #
8800         dac=da.deepCpy();
8801         ids.setIJ(0,0,2); ids.setIJ(1,0,5); ids.setIJ(2,0,4);
8802         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,1,da2,ids);
8803         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,-1);
8804         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,1,da2,ids);
8805         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,1);
8806         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,5,da2,ids);
8807         #
8808         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,1);
8809         dac=da.deepCpy();
8810         dac.setContigPartOfSelectedValues(4,da2,ids);
8811         expected6=[1,11,2,12,3,13,4,14,0,30,0,30,9,39]
8812         for i in xrange(14):
8813             self.assertEqual(expected6[i],dac.getIJ(0,i));
8814             pass
8815         pass
8816
8817     def testBuildDescendingConnec2Of3DMesh1(self):
8818         mesh=MEDCouplingDataForTest.build3DSourceMesh_1();
8819         #
8820         mesh2,desc,descIndx,revDesc,revDescIndx=mesh.buildDescendingConnectivity2();
8821         mesh2.checkCoherency();
8822         self.assertEqual(2,mesh2.getMeshDimension());
8823         self.assertEqual(30,mesh2.getNumberOfCells());
8824         self.assertEqual(31,revDescIndx.getNbOfElems()); self.assertEqual(31,revDescIndx.getNumberOfTuples());
8825         self.assertEqual(13,descIndx.getNbOfElems()); self.assertEqual(13,descIndx.getNumberOfTuples());
8826         self.assertEqual(48,desc.getNbOfElems()); self.assertEqual(48,desc.getNumberOfTuples());
8827         self.assertEqual(48,revDesc.getNbOfElems()); self.assertEqual(48,revDesc.getNumberOfTuples());
8828         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]
8829         self.assertEqual(expected1,desc.getValues());
8830         expected2=[0,4,8,12,16,20,24,28,32,36,40,44,48]
8831         self.assertEqual(expected2,descIndx.getValues());
8832         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]
8833         self.assertEqual(expected3,revDescIndx.getValues());
8834         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]
8835         self.assertEqual(expected4,revDesc.getValues());
8836         conn=mesh2.getNodalConnectivity();
8837         connIndex=mesh2.getNodalConnectivityIndex();
8838         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]
8839         self.assertEqual(expected5,connIndex.getValues());
8840         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]
8841         self.assertEqual(expected6,conn.getValues());
8842         pass
8843
8844     def testAre2DCellsNotCorrectlyOriented1(self):
8845         m1Coords=[1.,1.,-1.,-1.,-1.,-1.,1.,-1.]
8846         m1Conn=[0,3,1,2]
8847         m1=MEDCouplingUMesh.New();
8848         m1.setMeshDimension(2);
8849         m1.allocateCells(1);
8850         m1.insertNextCell(NORM_QUAD4,4,m1Conn[0:4])
8851         m1.finishInsertingCells();
8852         myCoords1=DataArrayDouble.New();
8853         myCoords1.setValues(m1Coords,4,2);
8854         m1.setCoords(myCoords1);
8855         #
8856         vec1=[0.,0.,1.]
8857         for i in xrange(18):
8858             vec2=[3.*cos(pi/9.*i),3.*sin(pi/9.*i)];
8859             m1Cpy=m1.deepCpy();
8860             m1Cpy.translate(vec2);
8861             self.assertRaises(InterpKernelException,m1Cpy.are2DCellsNotCorrectlyOriented,vec1,False);
8862             m1Cpy.changeSpaceDimension(3);
8863             res=m1Cpy.are2DCellsNotCorrectlyOriented(vec1,False)
8864             self.assertEqual([0],res.getValues());
8865             pass
8866         pass
8867
8868     def testDataArrayAbs1(self):
8869         d1=DataArrayDouble.New();
8870         val1=[2.,-3.,-5.,6.,-7.,-8.,9.,10.,-11.,-12.,-13.,-15.]
8871         expected1=[2.,3.,5.,6.,7.,8.,9.,10.,11.,12.,13.,15.]
8872         d1.setValues(val1,6,2);
8873         d2=d1.convertToIntArr();
8874         #
8875         d1.abs();
8876         for i in xrange(12):
8877             self.assertAlmostEqual(expected1[i],d1.getIJ(0,i),14);
8878             pass
8879         #
8880         expected2=[2,3,5,6,7,8,9,10,11,12,13,15]
8881         d2.abs();
8882         for i in xrange(12):
8883             self.assertEqual(expected2[i],d2.getIJ(0,i));
8884             pass
8885         #
8886         pass
8887
8888     # test on 1D
8889     def testGetValueOn3(self):
8890         v=[0.,1.,1.5,2.]
8891         v2=[0.7,1.25,0.,2.,1.5]
8892         disp=[5.,50.,500.,6.,60.,600.,7.,70.,700.,8.,80.,800.]
8893         m=MEDCouplingUMesh.New("myMesh",1)
8894         nbNodes=len(v)
8895         nbCells=nbNodes-1
8896         m.allocateCells(nbCells)
8897         coords=DataArrayDouble.New() ; coords.setValues(v,nbNodes,1)
8898         m.setCoords(coords)
8899         m.insertNextCell(NORM_SEG2,2,[0,1])
8900         m.insertNextCell(NORM_SEG2,2,[2,1])
8901         m.insertNextCell(NORM_SEG2,2,[2,3])
8902         m.finishInsertingCells()
8903         f=MEDCouplingFieldDouble.New(ON_NODES)
8904         f.setMesh(m)
8905         array=DataArrayDouble.New(); array.setValues(disp,m.getNumberOfNodes(),3)
8906         f.setArray(array)
8907         arr1=f.getValueOnMulti(v2)
8908         self.assertEqual(5,arr1.getNumberOfTuples());
8909         self.assertEqual(3,arr1.getNumberOfComponents());
8910         expected1=[5.7,57.,570.,6.5,65.,650.,5.,50.,500.,8.,80.,800.,7.,70.,700.]
8911         for i in xrange(15):
8912             self.assertAlmostEqual(expected1[i],arr1.getIJ(0,i),14);
8913             pass
8914         pass
8915
8916     def testGetNodeIdsOfCell2(self):
8917         m1c=MEDCouplingCMesh.New();
8918         coordsX=DataArrayDouble.New();
8919         arrX=[ -1., 1., 2., 4., 4.5 ]
8920         coordsX.setValues(arrX,5,1);
8921         coordsY=DataArrayDouble.New();
8922         arrY=[ -2., 2., 4., 8.]
8923         coordsY.setValues(arrY,4,1);
8924         coordsZ=DataArrayDouble.New();
8925         arrZ=[ -2., 2., 4.]
8926         coordsZ.setValues(arrZ,3,1);
8927         # test in 1D
8928         m1c.setCoordsAt(0,coordsX);
8929         expected1=[[0,1],[1,2],[2,3],[3,4]]
8930         self.assertEqual(4,m1c.getNumberOfCells())
8931         for i in xrange(m1c.getNumberOfCells()):
8932             self.assertEqual(expected1[i],m1c.getNodeIdsOfCell(i))
8933             pass
8934         # test in 2D
8935         m1c.setCoordsAt(1,coordsY);
8936         self.assertEqual(12,m1c.getNumberOfCells())
8937         self.assertEqual(20,m1c.getNumberOfNodes())
8938         expected2=[[0,1,6,5],[1,2,7,6],[2,3,8,7],[3,4,9,8],[5,6,11,10],[6,7,12,11],[7,8,13,12],[8,9,14,13],[10,11,16,15],[11,12,17,16],[12,13,18,17],[13,14,19,18]]
8939         for i in xrange(m1c.getNumberOfCells()):
8940             self.assertEqual(expected2[i],m1c.getNodeIdsOfCell(i))
8941             pass
8942         # test in 3D
8943         m1c.setCoordsAt(2,coordsZ);
8944         self.assertEqual(24,m1c.getNumberOfCells())
8945         self.assertEqual(60,m1c.getNumberOfNodes())
8946         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],[5,6,11,10,25,26,31,30],[6,7,12,11,26,27,32,31],[7,8,13,12,27,28,33,32],[8,9,14,13,28,29,34,33],[10,11,16,15,30,31,36,35],[11,12,17,16,31,32,37,36],[12,13,18,17,32,33,38,37],[13,14,19,18,33,34,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],[25,26,31,30,45,46,51,50],[26,27,32,31,46,47,52,51],[27,28,33,32,47,48,53,52],[28,29,34,33,48,49,54,53],[30,31,36,35,50,51,56,55],[31,32,37,36,51,52,57,56],[32,33,38,37,52,53,58,57],[33,34,39,38,53,54,59,58]]
8947         self.assertEqual(24,m1c.getNumberOfCells())
8948         for i in xrange(m1c.getNumberOfCells()):
8949             self.assertEqual(expected3[i],m1c.getNodeIdsOfCell(i))
8950             pass
8951         pass
8952
8953     def testSwigDADOp4(self):
8954         da=DataArrayDouble.New(range(6,30),12,2)
8955         self.assertEqual(12,da.getNumberOfTuples());
8956         self.assertEqual(2,da.getNumberOfComponents());
8957         for i in xrange(24):
8958             self.assertAlmostEqual(da.getIJ(0,i),float(i+6),13)
8959             pass
8960         # operator transpose
8961         da.transpose()
8962         self.assertEqual(2,da.getNumberOfTuples());
8963         self.assertEqual(12,da.getNumberOfComponents());
8964         for i in xrange(24):
8965             self.assertAlmostEqual(da.getIJ(0,i),float(i+6),13)
8966             pass
8967         da.transpose()
8968         # operator __neg__
8969         da2=DataArrayDouble.New(12,1)
8970         da2.iota(0.)
8971         dabis=-da
8972         for i in xrange(24):
8973             self.assertAlmostEqual(dabis.getIJ(0,i),-float(i+6),13)
8974             pass
8975         # operator+=
8976         da+=da2
8977         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.]
8978         for i in xrange(24):
8979             self.assertAlmostEqual(da.getIJ(0,i),expected1[i],13)
8980             pass
8981         da=-dabis
8982         da+=[100.,101.]
8983         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.]
8984         self.assertEqual(12,da.getNumberOfTuples());
8985         self.assertEqual(2,da.getNumberOfComponents());
8986         for i in xrange(24):
8987             self.assertAlmostEqual(da.getIJ(0,i),expected2[i],13)
8988             pass
8989         for pos,elt in enumerate(dabis):
8990             da[pos]+=elt
8991             pass
8992         self.assertEqual(12,da.getNumberOfTuples());
8993         self.assertEqual(2,da.getNumberOfComponents());
8994         for elt in da:
8995             li=elt[:]
8996             self.assertAlmostEqual(li[0],100.,13) ; self.assertAlmostEqual(li[1],101.,13)
8997             pass
8998         # operator-=
8999         da=DataArrayDouble.New(range(6,30),12,2)
9000         da2=DataArrayDouble.New(range(12),12,1)
9001         dabis=-da
9002         da-=da2
9003         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.]
9004         for i in xrange(24):
9005             self.assertAlmostEqual(da.getIJ(0,i),expected1[i],13)
9006             pass
9007         da=-dabis
9008         da-=[100.,101.]
9009         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.]
9010         self.assertEqual(12,da.getNumberOfTuples());
9011         self.assertEqual(2,da.getNumberOfComponents());
9012         for i in xrange(24):
9013             self.assertAlmostEqual(da.getIJ(0,i),expected2[i],13)
9014             pass
9015         for pos,elt in enumerate(dabis):
9016             da[pos]-=elt
9017             pass
9018         self.assertEqual(12,da.getNumberOfTuples());
9019         self.assertEqual(2,da.getNumberOfComponents());
9020         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.]
9021         for i in xrange(24):
9022             self.assertAlmostEqual(da.getIJ(0,i),expected3[i],13)
9023             pass
9024         # operator*=
9025         da=DataArrayDouble.New(range(6,30),12,2)
9026         da2=DataArrayDouble.New(range(12),12,1)
9027         dabis=-da
9028         da*=da2
9029         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.]
9030         for i in xrange(24):
9031             self.assertAlmostEqual(da.getIJ(0,i),expected1[i],13)
9032             pass
9033         da=-dabis
9034         da*=[100.,101.]
9035         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.]
9036         self.assertEqual(12,da.getNumberOfTuples());
9037         self.assertEqual(2,da.getNumberOfComponents());
9038         for i in xrange(24):
9039             self.assertAlmostEqual(da.getIJ(0,i),expected2[i],13)
9040             pass
9041         for pos,elt in enumerate(dabis):
9042             da[pos]*=elt
9043             pass
9044         self.assertEqual(12,da.getNumberOfTuples());
9045         self.assertEqual(2,da.getNumberOfComponents());
9046         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]
9047         for i in xrange(24):
9048             self.assertAlmostEqual(da.getIJ(0,i),expected3[i],13)
9049             pass
9050         # operator/=
9051         da=DataArrayDouble.New(range(6,30),12,2)
9052         da2=DataArrayDouble.New(range(1,13),12,1)
9053         dabis=-da
9054         da/=da2
9055         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]
9056         for i in xrange(24):
9057             self.assertAlmostEqual(da.getIJ(0,i),expected1[i],13)
9058             pass
9059         da=-dabis
9060         da/=[100.,101.]
9061         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]
9062         self.assertEqual(12,da.getNumberOfTuples());
9063         self.assertEqual(2,da.getNumberOfComponents());
9064         for i in xrange(24):
9065             self.assertAlmostEqual(da.getIJ(0,i),expected2[i],13)
9066             pass
9067         for pos,elt in enumerate(dabis):
9068             da[pos]/=elt
9069             pass
9070         self.assertEqual(12,da.getNumberOfTuples());
9071         self.assertEqual(2,da.getNumberOfComponents());
9072         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]
9073         for i in xrange(24):
9074             self.assertAlmostEqual(da.getIJ(0,i),expected3[i],13)
9075             pass
9076         pass
9077
9078     def testSwigDAIOp4(self):
9079         da=DataArrayInt.New(range(6,30),12,2)
9080         self.assertEqual(12,da.getNumberOfTuples());
9081         self.assertEqual(2,da.getNumberOfComponents());
9082         for i in xrange(24):
9083             self.assertEqual(da.getIJ(0,i),i+6)
9084             pass
9085         # operator transpose
9086         da.transpose()
9087         self.assertEqual(2,da.getNumberOfTuples());
9088         self.assertEqual(12,da.getNumberOfComponents());
9089         for i in xrange(24):
9090             self.assertEqual(da.getIJ(0,i),i+6)
9091             pass
9092         da.transpose()
9093         # operator __neg__
9094         da2=DataArrayInt.New(12,1)
9095         da2.iota(0)
9096         dabis=-da
9097         for i in xrange(24):
9098             self.assertEqual(dabis.getIJ(0,i),-(i+6))
9099             pass
9100         # operator+=
9101         da+=da2
9102         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]
9103         for i in xrange(24):
9104             self.assertEqual(da.getIJ(0,i),expected1[i])
9105             pass
9106         da=-dabis
9107         da+=[100,101]
9108         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]
9109         self.assertEqual(12,da.getNumberOfTuples());
9110         self.assertEqual(2,da.getNumberOfComponents());
9111         for i in xrange(24):
9112             self.assertEqual(da.getIJ(0,i),expected2[i])
9113             pass
9114         for pos,elt in enumerate(dabis):
9115             da[pos]+=elt
9116             pass
9117         self.assertEqual(12,da.getNumberOfTuples());
9118         self.assertEqual(2,da.getNumberOfComponents());
9119         for elt in da:
9120             li=elt[:]
9121             self.assertEqual(li[0],100) ; self.assertEqual(li[1],101)
9122             pass
9123         # operator-=
9124         da=DataArrayInt.New(range(6,30),12,2)
9125         da2=DataArrayInt.New(range(12),12,1)
9126         dabis=-da
9127         da-=da2
9128         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]
9129         for i in xrange(24):
9130             self.assertEqual(da.getIJ(0,i),expected1[i])
9131             pass
9132         da=-dabis
9133         da-=[100,101]
9134         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]
9135         self.assertEqual(12,da.getNumberOfTuples());
9136         self.assertEqual(2,da.getNumberOfComponents());
9137         for i in xrange(24):
9138             self.assertEqual(da.getIJ(0,i),expected2[i])
9139             pass
9140         for pos,elt in enumerate(dabis):
9141             da[pos]-=elt
9142             pass
9143         self.assertEqual(12,da.getNumberOfTuples());
9144         self.assertEqual(2,da.getNumberOfComponents());
9145         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]
9146         for i in xrange(24):
9147             self.assertEqual(da.getIJ(0,i),expected3[i])
9148             pass
9149         # operator*=
9150         da=DataArrayInt.New(range(6,30),12,2)
9151         da2=DataArrayInt.New(range(12),12,1)
9152         dabis=-da
9153         da*=da2
9154         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]
9155         for i in xrange(24):
9156             self.assertEqual(da.getIJ(0,i),expected1[i])
9157             pass
9158         da=-dabis
9159         da*=[100,101]
9160         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]
9161         self.assertEqual(12,da.getNumberOfTuples());
9162         self.assertEqual(2,da.getNumberOfComponents());
9163         for i in xrange(24):
9164             self.assertEqual(da.getIJ(0,i),expected2[i])
9165             pass
9166         for pos,elt in enumerate(dabis):
9167             da[pos]*=elt
9168             pass
9169         self.assertEqual(12,da.getNumberOfTuples());
9170         self.assertEqual(2,da.getNumberOfComponents());
9171         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]
9172         for i in xrange(24):
9173             self.assertEqual(da.getIJ(0,i),expected3[i])
9174             pass
9175         # operator/=
9176         da=DataArrayInt.New(range(6,30),12,2)
9177         da2=DataArrayInt.New(range(1,13),12,1)
9178         dabis=-da
9179         da/=da2
9180         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]
9181         for i in xrange(24):
9182             self.assertEqual(da.getIJ(0,i),expected1[i])
9183             pass
9184         da=-dabis
9185         da/=DataArrayInt.New([2,3],1,2)
9186         self.assertEqual(12,da.getNumberOfTuples());
9187         self.assertEqual(2,da.getNumberOfComponents());
9188         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]
9189         for i in xrange(24):
9190             self.assertEqual(da.getIJ(0,i),expected2[i])
9191             pass
9192         pass
9193
9194     def testSwigDADOp5(self):
9195         da=DataArrayDouble.New([5,6,7,8,9,6,7,-2,3,9,8,10])
9196         da.rearrange(3)
9197         da2=DataArrayDouble.New([5.,8.,10.,12])
9198         self.assertEqual(4,da2.getNumberOfTuples());
9199         self.assertEqual(1,da2.getNumberOfComponents());
9200         da3=da+da2
9201         self.assertEqual(4,da3.getNumberOfTuples());
9202         self.assertEqual(3,da3.getNumberOfComponents());
9203         expected1=[10.,11.,12.,16.,17.,14.,17.,8.,13.,21.,20.,22.]
9204         for i in xrange(12):
9205             self.assertAlmostEqual(da3.getIJ(0,i),expected1[i],13)
9206             pass
9207         da3=da2+da
9208         self.assertEqual(4,da3.getNumberOfTuples());
9209         self.assertEqual(3,da3.getNumberOfComponents());
9210         for i in xrange(12):
9211             self.assertAlmostEqual(da3.getIJ(0,i),expected1[i],13)
9212             pass
9213         # Test new API of classmethod DataArrayDouble.New
9214         vals=[5,6,7,8,9,6,7,-2,3,9,8,10]
9215         da=DataArrayDouble.New(vals)
9216         self.assertEqual(12,da.getNumberOfTuples());
9217         self.assertEqual(1,da.getNumberOfComponents());
9218         for i in xrange(12):
9219             self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
9220             pass
9221         da=DataArrayDouble.New(vals,12)
9222         self.assertEqual(12,da.getNumberOfTuples());
9223         self.assertEqual(1,da.getNumberOfComponents());
9224         for i in xrange(12):
9225             self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
9226             pass
9227         da=DataArrayDouble.New(vals,1,12)
9228         self.assertEqual(1,da.getNumberOfTuples());
9229         self.assertEqual(12,da.getNumberOfComponents());
9230         for i in xrange(12):
9231             self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
9232             pass
9233         da=DataArrayDouble.New(vals,6,2)
9234         self.assertEqual(6,da.getNumberOfTuples());
9235         self.assertEqual(2,da.getNumberOfComponents());
9236         for i in xrange(12):
9237             self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
9238             pass
9239         da=DataArrayDouble.New(vals,4,3)
9240         self.assertEqual(4,da.getNumberOfTuples());
9241         self.assertEqual(3,da.getNumberOfComponents());
9242         for i in xrange(12):
9243             self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
9244             pass
9245         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,11);
9246         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,13);
9247         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,5,2);
9248         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,7,2);
9249         pass
9250
9251     def testSwigDADOp6(self):
9252         da=DataArrayInt.New([5,6,7,8,9,6,7,-2,3,9,8,10])
9253         da.rearrange(3)
9254         da2=DataArrayInt.New([5,8,10,12])
9255         self.assertEqual(4,da2.getNumberOfTuples());
9256         self.assertEqual(1,da2.getNumberOfComponents());
9257         da3=da+da2
9258         self.assertEqual(4,da3.getNumberOfTuples());
9259         self.assertEqual(3,da3.getNumberOfComponents());
9260         expected1=[10,11,12,16,17,14,17,8,13,21,20,22]
9261         for i in xrange(12):
9262             self.assertEqual(da3.getIJ(0,i),expected1[i])
9263             pass
9264         da3=da2+da
9265         self.assertEqual(4,da3.getNumberOfTuples());
9266         self.assertEqual(3,da3.getNumberOfComponents());
9267         for i in xrange(12):
9268             self.assertEqual(da3.getIJ(0,i),expected1[i])
9269             pass
9270         da3=da+DataArrayInt.New(da2.getValues())
9271         # Test new API of classmethod DataArrayInt.New
9272         vals=[5,6,7,8,9,6,7,-2,3,9,8,10]
9273         da=DataArrayDouble.New(vals)
9274         self.assertEqual(12,da.getNumberOfTuples());
9275         self.assertEqual(1,da.getNumberOfComponents());
9276         for i in xrange(12):
9277             self.assertEqual(da.getIJ(0,i),vals[i])
9278             pass
9279         da=DataArrayDouble.New(vals,12)
9280         self.assertEqual(12,da.getNumberOfTuples());
9281         self.assertEqual(1,da.getNumberOfComponents());
9282         for i in xrange(12):
9283             self.assertEqual(da.getIJ(0,i),vals[i])
9284             pass
9285         da=DataArrayDouble.New(vals,1,12)
9286         self.assertEqual(1,da.getNumberOfTuples());
9287         self.assertEqual(12,da.getNumberOfComponents());
9288         for i in xrange(12):
9289             self.assertEqual(da.getIJ(0,i),vals[i])
9290             pass
9291         da=DataArrayDouble.New(vals,6,2)
9292         self.assertEqual(6,da.getNumberOfTuples());
9293         self.assertEqual(2,da.getNumberOfComponents());
9294         for i in xrange(12):
9295             self.assertEqual(da.getIJ(0,i),vals[i])
9296             pass
9297         da=DataArrayDouble.New(vals,4,3)
9298         self.assertEqual(4,da.getNumberOfTuples());
9299         self.assertEqual(3,da.getNumberOfComponents());
9300         for i in xrange(12):
9301             self.assertEqual(da.getIJ(0,i),vals[i])
9302             pass
9303         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,11);
9304         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,13);
9305         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,5,2);
9306         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,7,2);
9307         pass
9308
9309     def testSwigDADOp9(self):
9310         l1=[(1.,2.,3),(4.,5.,6.),(7.,8.,9.),[10.,11.,12.]]
9311         da1=DataArrayDouble(l1,4,3)
9312         self.assertEqual(4,da1.getNumberOfTuples());
9313         self.assertEqual(3,da1.getNumberOfComponents());
9314         da2=DataArrayDouble(12) ; da2.iota(1.) ; da2.rearrange(3)
9315         self.assertTrue(da2.isEqual(da1,1e-12))
9316         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,3,4);
9317         da3=DataArrayDouble(l1,4)
9318         self.assertTrue(da3.isEqual(da1,1e-12))
9319         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,3);
9320         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,5);
9321         l1=[(1.,2.,3),(4.,(5.),((6.))),(7.,8.,9.),[10.,11.,12.]]
9322         da1=DataArrayDouble(l1,4,3)
9323         self.assertEqual(4,da1.getNumberOfTuples());
9324         self.assertEqual(3,da1.getNumberOfComponents());
9325         da2=DataArrayDouble(12) ; da2.iota(1.) ; da2.rearrange(3)
9326         self.assertTrue(da2.isEqual(da1,1e-12))
9327         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,3,4);
9328         da3=DataArrayDouble(l1,4)
9329         self.assertTrue(da3.isEqual(da1,1e-12))
9330         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,3);
9331         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,5);
9332         #
9333         l1=[(1,2,3),(4,5,6),(7,8,9),[10,11,12]]
9334         da1=DataArrayInt(l1,4,3)
9335         self.assertEqual(4,da1.getNumberOfTuples());
9336         self.assertEqual(3,da1.getNumberOfComponents());
9337         da2=DataArrayInt(12) ; da2.iota(1) ; da2.rearrange(3)
9338         self.assertTrue(da2.isEqual(da1))
9339         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,3,4);
9340         da3=DataArrayInt(l1,4)
9341         self.assertTrue(da3.isEqual(da1))
9342         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,3);
9343         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,5);
9344         l1=[(1,[2],3),(4,[(5)],6),((([7])),8,9),[10,11,12]]
9345         da1=DataArrayInt(l1,4,3)
9346         self.assertEqual(4,da1.getNumberOfTuples());
9347         self.assertEqual(3,da1.getNumberOfComponents());
9348         da2=DataArrayInt(12) ; da2.iota(1) ; da2.rearrange(3)
9349         self.assertTrue(da2.isEqual(da1))
9350         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,3,4);
9351         da3=DataArrayInt(l1,4)
9352         self.assertTrue(da3.isEqual(da1))
9353         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,3);
9354         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,5);
9355         pass
9356
9357     def testRenumberNodesInConn1(self):
9358         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. ]
9359         mesh2DConn=[1,4,2, 4,5,2, 0,3,4,1, 6,7,4,3, 7,8,5,4]
9360         mesh2D=MEDCouplingUMesh.New("mesh",2);
9361         mesh2D.allocateCells(5);
9362         mesh2D.insertNextCell(NORM_TRI3,3,mesh2DConn[0:3])
9363         mesh2D.insertNextCell(NORM_TRI3,3,mesh2DConn[3:6])
9364         mesh2D.insertNextCell(NORM_QUAD4,4,mesh2DConn[6:10])
9365         mesh2D.insertNextCell(NORM_QUAD4,4,mesh2DConn[10:14])
9366         mesh2D.insertNextCell(NORM_QUAD4,4,mesh2DConn[14:18])
9367         mesh2D.finishInsertingCells();
9368         myCoords=DataArrayDouble.New(mesh2DCoords,9,3);
9369         mesh2D.setCoords(myCoords);
9370         mesh2D.checkCoherency();
9371         #
9372         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. ]
9373         mesh3DConn=[0,1,2,3,4,5,6,7]
9374         mesh3D=MEDCouplingUMesh.New("mesh",3);
9375         mesh3D.allocateCells(1);
9376         mesh3D.insertNextCell(NORM_HEXA8,8,mesh3DConn[:])
9377         mesh3D.finishInsertingCells();
9378         myCoords3D=DataArrayDouble.New(mesh3DCoords,8,3);
9379         mesh3D.setCoords(myCoords3D);
9380         mesh3D.checkCoherency();
9381         #
9382         mesh3D_2=mesh3D.deepCpy();
9383         mesh2D_2=mesh2D.deepCpy();
9384         mesh3D_4=mesh3D.deepCpy();
9385         mesh2D_4=mesh2D.deepCpy();
9386         oldNbOf3DNodes=mesh3D.getNumberOfNodes();
9387         renumNodes=DataArrayInt.New();
9388         renumNodes.alloc(mesh2D.getNumberOfNodes(),1);
9389         renumNodes.iota(oldNbOf3DNodes);
9390         coo=DataArrayDouble.Aggregate(mesh3D.getCoords(),mesh2D.getCoords());
9391         mesh3D.setCoords(coo);
9392         mesh2D.setCoords(coo);
9393         mesh2DCpy=mesh2D.deepCpy()
9394         mesh2D_3=mesh2D.deepCpy();
9395         mesh2D_3.shiftNodeNumbersInConn(oldNbOf3DNodes);
9396         mesh2D.renumberNodesInConn(renumNodes);
9397         mesh2DCpy.renumberNodesInConn(renumNodes.getValues());
9398         self.assertTrue(mesh2D.isEqual(mesh2DCpy,1e-12))
9399         self.assertTrue(mesh2D.isEqual(mesh2D_3,1e-12))
9400         #
9401         da1,da2=mesh3D.checkGeoEquivalWith(mesh3D_2,10,1e-12);
9402         self.assertTrue(da1==None);
9403         self.assertEqual(8,da2.getNumberOfTuples());
9404         self.assertEqual(1,da2.getNumberOfComponents());
9405         expected1=[8,11,12,9,4,5,6,7]
9406         for i in xrange(8):
9407             self.assertEqual(expected1[i],da2.getIJ(i,0));
9408             pass
9409         #
9410         da1,da2=mesh2D.checkGeoEquivalWith(mesh2D_2,10,1e-12);
9411         self.assertTrue(da1==None);
9412         self.assertEqual(9,da2.getNumberOfTuples());
9413         self.assertEqual(1,da2.getNumberOfComponents());
9414         for i in xrange(9):
9415             self.assertEqual(8+i,da2.getIJ(i,0));
9416             pass
9417         #
9418         mesh2D_5=mesh2D_4.deepCpy();
9419         mesh2D_5.translate([1.,0.,0.]);
9420         meshes=[mesh3D_4,mesh2D_4,mesh2D_5];
9421         MEDCouplingUMesh.PutUMeshesOnSameAggregatedCoords(meshes);
9422         self.assertTrue(mesh3D_4.getCoords().getHiddenCppPointer()==mesh2D_4.getCoords().getHiddenCppPointer());
9423         self.assertTrue(mesh2D_4.getCoords().getHiddenCppPointer()==mesh2D_5.getCoords().getHiddenCppPointer());
9424         mesh3D_4.checkCoherency(); mesh2D_4.checkCoherency(); mesh2D_5.checkCoherency();
9425         self.assertEqual(26,mesh3D_4.getNumberOfNodes());
9426         self.assertEqual(3,mesh3D_4.getSpaceDimension());
9427         self.assertEqual(9,mesh3D_4.getNodalConnectivity().getNumberOfTuples());
9428         self.assertEqual(23,mesh2D_4.getNodalConnectivity().getNumberOfTuples());
9429         self.assertEqual(23,mesh2D_5.getNodalConnectivity().getNumberOfTuples());
9430         expected2=[18,0,1,2,3,4,5,6,7]
9431         expected3=[3,9,12,10, 3,12,13,10, 4,8,11,12,9, 4,14,15,12,11, 4,15,16,13,12]
9432         expected4=[3,18,21,19, 3,21,22,19, 4,17,20,21,18, 4,23,24,21,20, 4,24,25,22,21]
9433         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]
9434         self.assertEqual(expected2,mesh3D_4.getNodalConnectivity().getValues());
9435         self.assertEqual(expected3,mesh2D_4.getNodalConnectivity().getValues());
9436         self.assertEqual(expected4,mesh2D_5.getNodalConnectivity().getValues());
9437         for i in xrange(78):
9438             self.assertAlmostEqual(expected5[i],mesh3D_4.getCoords().getIJ(0,i),12);
9439             pass
9440         #
9441         MEDCouplingUMesh.MergeNodesOnUMeshesSharingSameCoords(meshes,1e-12);
9442         mesh3D_4.checkCoherency(); mesh2D_4.checkCoherency(); mesh2D_5.checkCoherency();
9443         self.assertTrue(mesh3D_4.getCoords().getHiddenCppPointer()==mesh2D_4.getCoords().getHiddenCppPointer());
9444         self.assertTrue(mesh2D_4.getCoords().getHiddenCppPointer()==mesh2D_5.getCoords().getHiddenCppPointer());
9445         self.assertEqual(19,mesh3D_4.getNumberOfNodes());
9446         self.assertEqual(3,mesh3D_4.getSpaceDimension());
9447         self.assertEqual(9,mesh3D_4.getNodalConnectivity().getNumberOfTuples());
9448         self.assertEqual(23,mesh2D_4.getNodalConnectivity().getNumberOfTuples());
9449         self.assertEqual(23,mesh2D_5.getNodalConnectivity().getNumberOfTuples());
9450         expected6=[18,0,1,2,3,4,5,6,7]
9451         expected7=[3,3,2,8, 3,2,9,8, 4,0,1,2,3, 4,10,11,2,1, 4,11,12,9,2]
9452         expected8=[3,13,15,14, 3,15,16,14, 4,8,9,15,13, 4,12,17,15,9, 4,17,18,16,15]
9453         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.,
9454                     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.,
9455                     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.]
9456         self.assertEqual(expected6,mesh3D_4.getNodalConnectivity().getValues());
9457         self.assertEqual(expected7,mesh2D_4.getNodalConnectivity().getValues());
9458         self.assertEqual(expected8,mesh2D_5.getNodalConnectivity().getValues());
9459         for i in xrange(57):
9460             self.assertAlmostEqual(expected9[i],mesh3D_4.getCoords().getIJ(0,i),12);
9461             pass
9462         #
9463         pass
9464
9465     def testComputeNeighborsOfCells1(self):
9466         m=MEDCouplingDataForTest.build2DTargetMesh_1();
9467         d1,d2=m.computeNeighborsOfCells();
9468         self.assertEqual(6,d2.getNumberOfTuples());
9469         self.assertEqual(10,d1.getNumberOfTuples());
9470         expected1=[0,2,4,6,8,10]
9471         expected2=[3,1,0,2,4,1,4,0,2,3]
9472         self.assertEqual(expected1,d2.getValues());
9473         self.assertEqual(expected2,d1.getValues());
9474         pass
9475
9476     def testCheckButterflyCellsBug1(self):
9477         mesh2DCoords=[323.85,120.983748908684,317.5,131.982271536747,336.55,120.983748908686,330.2,131.982271536751,323.85,142.98079416481]
9478         mesh2DConn=[4,1,0,2,3]
9479         mesh2D=MEDCouplingUMesh.New("mesh",2);
9480         mesh2D.allocateCells(1);
9481         mesh2D.insertNextCell(NORM_POLYGON,5,mesh2DConn[0:5])
9482         mesh2D.finishInsertingCells();
9483         myCoords=DataArrayDouble.New(mesh2DCoords,5,2);
9484         mesh2D.setCoords(myCoords);
9485         mesh2D.checkCoherency();
9486         #
9487         v=mesh2D.checkButterflyCells();
9488         self.assertTrue(v.empty());
9489         pass
9490
9491     def testDataArrayIntRange1(self):
9492         d=DataArrayInt.Range(2,17,7);
9493         expected1=[2,9,16]
9494         self.assertEqual(3,d.getNumberOfTuples());
9495         self.assertEqual(1,d.getNumberOfComponents());
9496         self.assertEqual(expected1,d.getValues());
9497         #
9498         d=DataArrayInt.Range(2,23,7);
9499         self.assertEqual(3,d.getNumberOfTuples());
9500         self.assertEqual(1,d.getNumberOfComponents());
9501         self.assertEqual(expected1,d.getValues());
9502         #
9503         d=DataArrayInt.Range(2,24,7);
9504         expected2=[2,9,16,23]
9505         self.assertEqual(4,d.getNumberOfTuples());
9506         self.assertEqual(1,d.getNumberOfComponents());
9507         self.assertEqual(expected2,d.getValues());
9508         #
9509         d=DataArrayInt.Range(24,2,-7);
9510         expected3=[24,17,10,3]
9511         self.assertEqual(4,d.getNumberOfTuples());
9512         self.assertEqual(1,d.getNumberOfComponents());
9513         self.assertEqual(expected3,d.getValues());
9514         #
9515         d=DataArrayInt.Range(23,2,-7);
9516         expected4=[23,16,9]
9517         self.assertEqual(3,d.getNumberOfTuples());
9518         self.assertEqual(1,d.getNumberOfComponents());
9519         self.assertEqual(expected4,d.getValues());
9520         #
9521         d=DataArrayInt.Range(23,22,-7);
9522         self.assertEqual(1,d.getNumberOfTuples());
9523         self.assertEqual(1,d.getNumberOfComponents());
9524         self.assertEqual(23,d.getIJ(0,0));
9525         #
9526         d=DataArrayInt.Range(22,23,7);
9527         self.assertEqual(1,d.getNumberOfTuples());
9528         self.assertEqual(1,d.getNumberOfComponents());
9529         self.assertEqual(22,d.getIJ(0,0));
9530         #
9531         d=DataArrayInt.Range(22,22,7);
9532         self.assertEqual(0,d.getNumberOfTuples());
9533         self.assertEqual(1,d.getNumberOfComponents());
9534         #
9535         d=DataArrayInt.Range(22,22,-7);
9536         self.assertEqual(0,d.getNumberOfTuples());
9537         self.assertEqual(1,d.getNumberOfComponents());
9538         #
9539         self.assertRaises(InterpKernelException,DataArrayInt.Range,22,23,-7);
9540         self.assertRaises(InterpKernelException,DataArrayInt.Range,23,22,7);
9541         self.assertRaises(InterpKernelException,DataArrayInt.Range,23,22,0);
9542         self.assertRaises(InterpKernelException,DataArrayInt.Range,22,23,0);
9543         pass
9544
9545     def testSwigUMeshGetItem1(self):
9546         m=MEDCouplingDataForTest.build2DTargetMesh_1();
9547         subMesh=m.buildPartOfMySelf([1,3],True);
9548         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
9549         m1=m[[1,3]]
9550         self.assertTrue(isinstance(m1,MEDCouplingUMesh))
9551         m2=m[(1,3)]
9552         self.assertTrue(isinstance(m2,MEDCouplingUMesh))
9553         m3=m[1::2]
9554         self.assertTrue(isinstance(m3,MEDCouplingUMesh))
9555         m4=m[DataArrayInt.New([1,3])]
9556         m5_1=m[1]
9557         self.assertTrue(isinstance(m5_1,MEDCouplingUMesh))
9558         m5_2=m[3]
9559         self.assertTrue(isinstance(m5_2,MEDCouplingUMesh))
9560         m5=MEDCouplingUMesh.MergeUMeshesOnSameCoords([m5_1,m5_2]);
9561         m5.setName(subMesh.getName())
9562         self.assertTrue(isinstance(m4,MEDCouplingUMesh))
9563         self.assertTrue(subMesh.isEqual(m1,1e-12))
9564         self.assertTrue(subMesh.isEqual(m2,1e-12))
9565         self.assertTrue(subMesh.isEqual(m3,1e-12))
9566         self.assertTrue(subMesh.isEqual(m4,1e-12))
9567         self.assertTrue(subMesh.isEqual(m5,1e-12))
9568         self.assertRaises(InterpKernelException,m.buildPartOfMySelf,[1,5],True);
9569         pass
9570
9571     def testSwigGetItem3(self):
9572         da=DataArrayInt.New([4,5,6])
9573         self.assertEqual(5,da[1])
9574         self.assertEqual(6,da[-1])
9575         self.assertRaises(InterpKernelException,da.__getitem__,3)
9576         da=DataArrayInt.New([4,5,6,7,8,9],2,3)
9577         self.assertEqual(9,da[1,2])
9578         da=DataArrayDouble.New([4.1,5.2,6.3])
9579         self.assertAlmostEqual(5.2,da[1],12)
9580         self.assertAlmostEqual(6.3,da[-1],12)
9581         self.assertRaises(InterpKernelException,da.__getitem__,3)
9582         da=DataArrayDouble.New([4.12,5.12,6.12,7.12,8.12,9.12],2,3)
9583         self.assertAlmostEqual(9.12,da[1,2],12)
9584         pass
9585
9586     def testSwigDADISub1(self):
9587         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
9588         bary=mesh3D.getBarycenterAndOwner()
9589         bary=bary[:,:2]
9590         pts=bary.getDifferentValues(1e-12)
9591         expected=[[0,6,12],[1,7,13],[2,8,14],[3,9,15],[4,10,16],[5,11,17]]
9592         for pos,pt in enumerate(pts):
9593             bary2=bary[:,:2]
9594             bary2[:]-=pt
9595             norm=bary2.magnitude()
9596             self.assertEqual(expected[pos],norm.getIdsInRange(-1.,1e-5).getValues())
9597             pass
9598         expected2=[[3.,54.],[-141.,180.],[21.,54.],[39.,72.],[-15.,90.],[21.,90.]]
9599         for pos,pt in enumerate(pts):
9600             bary2=bary[:,:2]
9601             bary2[:]+=pt
9602             self.assertAlmostEqual(expected2[pos][0],bary2.accumulate()[0],12);
9603             self.assertAlmostEqual(expected2[pos][1],bary2.accumulate()[1],12);
9604             pass
9605         expected3=[[-3.,22.5],[45.,337.5],[-9., 22.5],[-15.,67.5],[3.,112.5],[-9.,112.5]]
9606         for pos,pt in enumerate(pts):
9607             bary2=bary[:,:2]
9608             bary2[:]*=pt
9609             self.assertAlmostEqual(expected3[pos][0],bary2.accumulate()[0],12);
9610             self.assertAlmostEqual(expected3[pos][1],bary2.accumulate()[1],12);
9611             pass
9612         expected4=[[-12.,90.],[0.8,6.],[-4,90.],[-2.4,30.],[12.,18],[-4,18.]]
9613         for pos,pt in enumerate(pts):
9614             bary2=bary[:,:2]
9615             bary2[:]/=pt
9616             self.assertAlmostEqual(expected4[pos][0],bary2.accumulate()[0],12);
9617             self.assertAlmostEqual(expected4[pos][1],bary2.accumulate()[1],12);
9618             pass
9619         #
9620         d=DataArrayInt.New([1,2,0,1,0,2],3,2)
9621         e=DataArrayInt.New([1,11,101,2,12,102,3,13,103,4,14,104],4,3)
9622         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]]
9623         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]]
9624         for pos,tup in enumerate(d):
9625             f=e[:]
9626             self.assertTrue(isinstance(f,DataArrayInt))
9627             f[tup]=77
9628             self.assertEqual(expected5[pos],f.getValues())
9629             self.assertEqual(6*[77],f[tup].getValues())
9630             f=e[:]
9631             f[:,tup]=77
9632             self.assertEqual(expected6[pos],f.getValues())
9633             self.assertEqual(8*[77],f[:,tup].getValues())
9634             pass
9635         #
9636         e=e.convertToDblArr()
9637         for pos,tup in enumerate(d):
9638             f=e[:]
9639             self.assertTrue(isinstance(f,DataArrayDouble))
9640             f[tup]=77.
9641             self.assertEqual(expected5[pos],f.convertToIntArr().getValues())
9642             self.assertEqual(6*[77],f[tup].convertToIntArr().getValues())
9643             f=e[:]
9644             f[:,tup]=77.
9645             self.assertEqual(expected6[pos],f.convertToIntArr().getValues())
9646             self.assertEqual(8*[77],f[:,tup].convertToIntArr().getValues())
9647             pass
9648         pass
9649
9650     def testDataArrayDoubleGetMinMaxPerComponent1(self):
9651         values1=[1.,2.,3.,-0.9,2.1,3.,1.3,1.7,3.,1.,1.8,3.]
9652         d1=DataArrayDouble.New();
9653         self.assertRaises(InterpKernelException,d1.getMinMaxPerComponent)
9654         d1=DataArrayDouble.New(values1,4,3);
9655         res=d1.getMinMaxPerComponent();
9656         self.assertTrue(isinstance(res,list))
9657         self.assertEqual(3,len(res))
9658         for i in xrange(3):
9659             self.assertTrue(isinstance(res[i],tuple))
9660             self.assertEqual(2,len(res[i]))
9661             pass
9662         expected1=[-0.9,1.3,1.7,2.1,3.,3.]
9663         for i in xrange(6):
9664             self.assertAlmostEqual(expected1[i],res[i/2][i%2],14)
9665             pass
9666         #
9667         d1.rearrange(2);
9668         res=d1.getMinMaxPerComponent();
9669         self.assertTrue(isinstance(res,list))
9670         self.assertEqual(2,len(res))
9671         for i in xrange(2):
9672             self.assertTrue(isinstance(res[i],tuple))
9673             self.assertEqual(2,len(res[i]))
9674             pass
9675         expected2=[1.,3.,-0.9,3.]
9676         for i in xrange(4):
9677             self.assertAlmostEqual(expected2[i],res[i/2][i%2],14)
9678             pass
9679         #
9680         d1.rearrange(1);
9681         res=d1.getMinMaxPerComponent();
9682         self.assertTrue(isinstance(res,list))
9683         self.assertEqual(1,len(res))
9684         for i in xrange(1):
9685             self.assertTrue(isinstance(res[i],tuple))
9686             self.assertEqual(2,len(res[i]))
9687             pass
9688         expected3=[-0.9,3.]
9689         for i in xrange(2):
9690             self.assertAlmostEqual(expected3[i],res[i/2][i%2],14)
9691             pass
9692         pass
9693
9694     def testDataArrayIntGetHashCode1(self):
9695         d1=DataArrayInt.New(range(3545))
9696         d2=DataArrayInt.New(range(3545))
9697         self.assertEqual(d2.getHashCode(),d1.getHashCode())
9698         self.assertEqual(232341068,d1.getHashCode())
9699         d1[886]=6
9700         self.assertEqual(232340188,d1.getHashCode())
9701         pass
9702
9703     def testZipConnectivityPol1(self):
9704         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
9705         cells1=[2,3,4]
9706         m2_1=m1.buildPartOfMySelf(cells1,True);
9707         m2=m2_1
9708         self.assertTrue(isinstance(m2,MEDCouplingUMesh))
9709         # no permutation policy 0
9710         isOk,arr=m1.areCellsIncludedIn(m2,0)
9711         self.assertTrue(isOk);
9712         self.assertEqual(3,arr.getNumberOfTuples());
9713         self.assertEqual(1,arr.getNumberOfComponents());
9714         self.assertEqual(cells1,arr.getValues())
9715         # no permutation policy 1
9716         isOk,arr=m1.areCellsIncludedIn(m2,1)
9717         self.assertTrue(isOk);
9718         self.assertEqual(3,arr.getNumberOfTuples());
9719         self.assertEqual(1,arr.getNumberOfComponents());
9720         self.assertEqual(cells1,arr.getValues())
9721         # no permutation policy 2
9722         isOk,arr=m1.areCellsIncludedIn(m2,2)
9723         self.assertTrue(isOk);
9724         self.assertEqual(3,arr.getNumberOfTuples());
9725         self.assertEqual(1,arr.getNumberOfComponents());
9726         self.assertEqual(cells1,arr.getValues())
9727         # some modification into m2
9728         modif1=[2,4,5]
9729         m2.getNodalConnectivity()[1:4]=modif1
9730         #policy 0 fails because cell0 in m2 has same orientation be not same connectivity
9731         expected1=[5,3,4]
9732         isOk,arr=m1.areCellsIncludedIn(m2,0)
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 1 succeeds because cell0 in m2 has not exactly the same conn
9738         isOk,arr=m1.areCellsIncludedIn(m2,1)
9739         self.assertTrue(isOk);
9740         self.assertEqual(3,arr.getNumberOfTuples());
9741         self.assertEqual(1,arr.getNumberOfComponents());
9742         self.assertEqual(cells1,arr.getValues())
9743         #policy 2 succeeds because cell0 in m2 has same nodes in connectivity
9744         isOk,arr=m1.areCellsIncludedIn(m2,2)
9745         self.assertTrue(isOk);
9746         self.assertEqual(3,arr.getNumberOfTuples());
9747         self.assertEqual(1,arr.getNumberOfComponents());
9748         self.assertEqual(cells1,arr.getValues())
9749         #some new modification into m2
9750         modif2=[2,5,4]
9751         m2.getNodalConnectivity()[1:4]=modif2
9752         #policy 0 fails because cell0 in m2 has not exactly the same conn
9753         isOk,arr=m1.areCellsIncludedIn(m2,0)
9754         self.assertTrue(not isOk);
9755         self.assertEqual(3,arr.getNumberOfTuples());
9756         self.assertEqual(1,arr.getNumberOfComponents());
9757         self.assertEqual(expected1,arr.getValues())
9758         #policy 1 fails too because cell0 in m2 has not same orientation
9759         isOk,arr=m1.areCellsIncludedIn(m2,1)
9760         self.assertTrue(not isOk);
9761         self.assertEqual(3,arr.getNumberOfTuples());
9762         self.assertEqual(1,arr.getNumberOfComponents());
9763         self.assertEqual(expected1,arr.getValues())
9764         #policy 2 succeeds because cell0 in m2 has same nodes in connectivity
9765         isOk,arr=m1.areCellsIncludedIn(m2,2)
9766         self.assertTrue(isOk);
9767         self.assertEqual(3,arr.getNumberOfTuples());
9768         self.assertEqual(1,arr.getNumberOfComponents());
9769         self.assertEqual(cells1,arr.getValues())
9770         # Now 1D
9771         cells2=[3,2]
9772         m1=MEDCouplingDataForTest.build1DSourceMesh_2();
9773         m2_1=m1.buildPartOfMySelf(cells2,True);
9774         m2=m2_1
9775         self.assertTrue(isinstance(m2,MEDCouplingUMesh))
9776         # no permutation policy 0
9777         isOk,arr=m1.areCellsIncludedIn(m2,0)
9778         self.assertTrue(isOk);
9779         self.assertEqual(2,arr.getNumberOfTuples());
9780         self.assertEqual(1,arr.getNumberOfComponents());
9781         self.assertEqual(cells2,arr.getValues())
9782         # no permutation policy 1
9783         isOk,arr=m1.areCellsIncludedIn(m2,1)
9784         self.assertTrue(isOk);
9785         self.assertEqual(2,arr.getNumberOfTuples());
9786         self.assertEqual(1,arr.getNumberOfComponents());
9787         self.assertEqual(cells2,arr.getValues())
9788         # no permutation policy 2
9789         isOk,arr=m1.areCellsIncludedIn(m2,2)
9790         self.assertTrue(isOk);
9791         self.assertEqual(2,arr.getNumberOfTuples());
9792         self.assertEqual(1,arr.getNumberOfComponents());
9793         self.assertEqual(cells2,arr.getValues())
9794         # some modification into m2
9795         modif3=[4,3]
9796         m2.getNodalConnectivity()[1:3]=modif3
9797         #policy 0 fails because cell0 in m2 has not exactly the same conn
9798         expected2=[4,2]
9799         isOk,arr=m1.areCellsIncludedIn(m2,0)
9800         self.assertTrue(not isOk);
9801         self.assertEqual(2,arr.getNumberOfTuples());
9802         self.assertEqual(1,arr.getNumberOfComponents());
9803         self.assertEqual(expected2,arr.getValues())
9804         #policy 1 fails too because cell0 in m2 has not same orientation
9805         isOk,arr=m1.areCellsIncludedIn(m2,1)
9806         self.assertTrue(not isOk);
9807         self.assertEqual(2,arr.getNumberOfTuples());
9808         self.assertEqual(1,arr.getNumberOfComponents());
9809         self.assertEqual(expected2,arr.getValues())
9810         #policy 2 succeeds because cell0 in m2 has same nodes in connectivity
9811         isOk,arr=m1.areCellsIncludedIn(m2,2)
9812         self.assertTrue(isOk);
9813         self.assertEqual(2,arr.getNumberOfTuples());
9814         self.assertEqual(1,arr.getNumberOfComponents());
9815         self.assertEqual(cells2,arr.getValues())
9816         pass
9817
9818     def toSeeIfDaIIopsAreOK(self,d):
9819         d+=5
9820         d*=6
9821         d/=3
9822         d-=2
9823         d%=7
9824         pass
9825
9826     def testSwigDAIOp5(self):
9827         d=DataArrayInt.New([4,5,6,10,3,-1],2,3)
9828         self.toSeeIfDaIIopsAreOK(d)
9829         dExp=DataArrayInt.New([2,4,6,0,0,6],2,3)
9830         self.assertTrue(d.isEqual(dExp));
9831         pass
9832
9833     def toSeeIfDaDIopsAreOK(self,d):
9834         d+=5
9835         d*=6
9836         d/=3
9837         d-=2
9838         pass
9839
9840     def testSwigDADOp7(self):
9841         d=DataArrayDouble.New([4.,5.,6.,10.,3.,-1.],2,3)
9842         self.toSeeIfDaDIopsAreOK(d)
9843         dExp=DataArrayDouble.New([16.,18.,20.,28.,14.,6.],2,3)
9844         self.assertTrue(d.isEqual(dExp,1e-14));
9845         pass
9846
9847     def testConvexEnvelop2D1(self):
9848         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]
9849         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]
9850         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]
9851         #
9852         m=MEDCouplingUMesh.New("convexhull",2);
9853         m.allocateCells(331);
9854         for i in xrange(331):
9855             m.insertNextCell(NORM_POLYGON,conn[connI[i]:connI[i+1]]);
9856             pass
9857         m.finishInsertingCells();
9858         coordsDa=DataArrayDouble.New(coords,331,2);
9859         m.setCoords(coordsDa);
9860         m.checkCoherency();
9861         #
9862         da=m.convexEnvelop2D();
9863         m.checkCoherency()
9864         self.assertEqual(coordsDa.getHiddenCppPointer(),m.getCoords().getHiddenCppPointer())
9865         daC=da.buildComplement(m.getNumberOfCells());
9866         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]);
9867         self.assertTrue(expected2.isEqual(daC));
9868         #
9869         vals=m.getMeasureField(ON_CELLS).getArray()
9870         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]
9871         vals-=DataArrayDouble.New(ref)
9872         vals.abs()
9873         theTest=vals.getIdsInRange(-1.,1e-7)
9874         self.assertTrue(theTest.isIdentity())
9875         self.assertEqual(331,len(theTest))
9876         pass
9877
9878     def testSwigDAIOp8(self):
9879         da=DataArrayInt.New([7,5,6,7,8,9,9,10,12,13,47,15])
9880         self.assertTrue(7 in da)
9881         self.assertTrue(47 in da)
9882         self.assertTrue(15 in da)
9883         self.assertEqual(0,da.index(7))
9884         self.assertEqual(10,da.index(47))
9885         self.assertTrue(14 not in da)
9886         self.assertEqual(5,da.search([9,9]))
9887         self.assertEqual(-1,da.search([5,8]))
9888         da.rearrange(2)
9889         self.assertTrue([47,16] not in da)
9890         self.assertTrue([5,6] not in da)
9891         self.assertTrue([6,7] in da)
9892         self.assertEqual(4,da.index([12,13]))
9893         pass
9894
9895     def testDataArraySort1(self):
9896         arr=DataArrayInt.New();
9897         self.assertRaises(InterpKernelException,arr.sort,True)
9898         self.assertRaises(InterpKernelException,arr.sort,False)
9899         values=[2,1,6,5,4,7]
9900         arr.alloc(3,2);
9901         self.assertRaises(InterpKernelException,arr.sort,True)
9902         self.assertRaises(InterpKernelException,arr.sort,False)
9903         arr.rearrange(1);
9904         arr.setValues(values,6,1)
9905         arr1=arr.deepCpy();
9906         arr2=arr.deepCpy();
9907         arr1.sort(True);
9908         expected1=[1,2,4,5,6,7]
9909         self.assertEqual(6,arr1.getNumberOfTuples());
9910         self.assertEqual(1,arr1.getNumberOfComponents());
9911         self.assertEqual(expected1,arr1.getValues());
9912         arr2.sort(False);
9913         expected2=[7,6,5,4,2,1]
9914         self.assertEqual(6,arr2.getNumberOfTuples());
9915         self.assertEqual(1,arr2.getNumberOfComponents());
9916         self.assertTrue(expected2,arr2.getValues());
9917         #
9918         ard=DataArrayDouble.New();
9919         self.assertRaises(InterpKernelException,ard.sort,True)
9920         self.assertRaises(InterpKernelException,ard.sort,False)
9921         valuesD=[2.,1.,6.,5.,4.,7.]
9922         ard.alloc(3,2);
9923         self.assertRaises(InterpKernelException,ard.sort,True)
9924         self.assertRaises(InterpKernelException,ard.sort,False)
9925         ard.rearrange(1);
9926         ard.setValues(valuesD,6,1)
9927         ard1=ard.deepCpy();
9928         ard2=ard.deepCpy();
9929         ard1.sort(True);
9930         expected3=[1.,2.,4.,5.,6.,7.]
9931         self.assertEqual(6,ard1.getNumberOfTuples());
9932         self.assertEqual(1,ard1.getNumberOfComponents());
9933         for i in xrange(6):
9934             self.assertAlmostEqual(expected3[i],ard1.getIJ(i,0),12)
9935             pass
9936         ard2.sort(False);
9937         expected4=[7.,6.,5.,4.,2.,1.]
9938         self.assertEqual(6,ard2.getNumberOfTuples());
9939         self.assertEqual(1,ard2.getNumberOfComponents());
9940         for i in xrange(6):
9941             self.assertAlmostEqual(expected4[i],ard2.getIJ(i,0),12)
9942             pass
9943         pass
9944
9945     def testPartitionBySpreadZone1(self):
9946         m=MEDCouplingDataForTest.build2DTargetMesh_1();
9947         m4=MEDCouplingUMesh.MergeUMeshes([m,m[-3:],m[0:2]]);
9948         m4.renumberCells([5,2,9,6,4,7,0,1,3,8]);
9949         #
9950         v2=m4.partitionBySpreadZone();
9951         self.assertTrue(3,len(v2));
9952         self.assertTrue(v2[0].isEqual(DataArrayInt.New([0,1,7])))
9953         self.assertTrue(v2[1].isEqual(DataArrayInt.New([2,4,5,6,9])))
9954         self.assertTrue(v2[2].isEqual(DataArrayInt.New([3,8])))
9955         #
9956         m5=m4.buildSpreadZonesWithPoly();
9957         self.assertEqual(3,m5.getNumberOfCells());
9958         self.assertTrue(m5.getCoords().getHiddenCppPointer()==m4.getCoords().getHiddenCppPointer());
9959         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())
9960         self.assertEqual([0,8,17,23],m5.getNodalConnectivityIndex().getValues())
9961         #
9962         pass
9963
9964     def testGiveCellsWithType1(self):
9965         expected0=[1,2]
9966         expected1=[0,3,4]
9967         m=MEDCouplingDataForTest.build2DTargetMesh_1();
9968         da=m.giveCellsWithType(NORM_TRI3);
9969         self.assertEqual(2,da.getNumberOfTuples());
9970         self.assertEqual(1,da.getNumberOfComponents());
9971         self.assertEqual(expected0,da.getValues())
9972         #
9973         da=m.giveCellsWithType(NORM_QUAD4);
9974         self.assertEqual(3,da.getNumberOfTuples());
9975         self.assertEqual(1,da.getNumberOfComponents());
9976         self.assertEqual(expected1,da.getValues())
9977         #
9978         da=m.giveCellsWithType(NORM_TRI6);
9979         self.assertEqual(0,da.getNumberOfTuples());
9980         self.assertEqual(1,da.getNumberOfComponents());
9981         #
9982         self.assertRaises(InterpKernelException,m.giveCellsWithType,NORM_SEG2)
9983         self.assertRaises(InterpKernelException,m.giveCellsWithType,NORM_HEXA8)
9984         pass
9985
9986     def testSwigDAOp1(self):
9987         d=DataArrayDouble.New(5,2)
9988         d.rearrange(1) ; d.iota(2.) ; d.rearrange(2)
9989         d.setInfoOnComponents(["X [m]","Y [m]"])
9990         d.setName("AName")
9991         #
9992         d1=d+[8,9]
9993         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))
9994         d1bis=DataArrayDouble.New([8,9],1,2)+d
9995         self.assertTrue(d1bis.isEqual(d1,1e-12))
9996         d1ter=[8,9]+d
9997         self.assertTrue(d1ter.isEqual(d1,1e-12))
9998         #
9999         d2=d1-[8,9]
10000         self.assertTrue(d2.isEqual(d,1e-12))
10001         self.assertRaises(InterpKernelException,d1.__rsub__,[8,9])#[8,9]-d1
10002         #
10003         d3=d*[8,9]
10004         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))
10005         d3bis=DataArrayDouble.New([8,9],1,2)*d
10006         self.assertTrue(d3bis.isEqual(d3,1e-12))
10007         d3ter=[8,9]*d
10008         self.assertTrue(d3ter.isEqual(d3,1e-12))
10009         #
10010         d4=d3/[8,9]
10011         self.assertTrue(d4.isEqual(d,1e-12))
10012         #
10013         d=DataArrayInt.New(5,2)
10014         d.rearrange(1) ; d.iota(2) ; d.rearrange(2)
10015         d.setInfoOnComponents(["X [m]","Y [m]"])
10016         d.setName("AName")
10017         #
10018         d1=d+[8,9]
10019         self.assertEqual(d1.getValues(),[10,12,12,14,14,16,16,18,18,20])
10020         d1bis=DataArrayInt.New([8,9],1,2)+d
10021         self.assertTrue(d1bis.isEqual(d1))
10022         d1ter=[8,9]+d
10023         self.assertTrue(d1ter.isEqual(d1))
10024         #
10025         d2=d1-[8,9]
10026         self.assertTrue(d2.isEqual(d))
10027         self.assertRaises(InterpKernelException,d1.__rsub__,[8,9])
10028         #
10029         d3=d*[8,9]
10030         self.assertEqual(d3.getValues(),[16,27,32,45,48,63,64,81,80,99])
10031         d3bis=DataArrayInt.New([8,9],1,2)*d
10032         self.assertTrue(d3bis.isEqual(d3))
10033         d3ter=[8,9]*d
10034         self.assertTrue(d3ter.isEqual(d3))
10035         #
10036         d4=d3/[8,9]
10037         self.assertTrue(d4.isEqual(d))
10038         #
10039         d5=d%[4,5]
10040         self.assertEqual(d5.getValues(),[2,3,0,0,2,2,0,4,2,1])
10041         pass
10042
10043     def testSwigSelectTupleId2DAIBug1(self):
10044         da=DataArrayInt.New([0,1,2,3,12,13,4,5,6,7,14,15,8,9,10,11,16,17])
10045         self.assertEqual([2,6,10],da[2::6].getValues())
10046         self.assertEqual([0,4,8],da[::6].getValues())
10047         self.assertEqual([5,9],da[7::6].getValues())
10048         self.assertEqual([5],da[7:-5:6].getValues())
10049         pass
10050
10051     def testSwigCpp5Safe1(self):
10052         m=MEDCouplingUMesh.New("toto",2)
10053         coords=DataArrayDouble.New([0.,0.,1.,0.,1.,1.,0.,1.],4,2)
10054         m.setCoords(coords)
10055         vecs=DataArrayDouble.New([2.,3.,4.,5.,6.,7.],3,2)
10056         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]]
10057         for pos,vec in enumerate(vecs):
10058             m2=m.deepCpy()
10059             m2.translate(vec)
10060             self.assertTrue(m2.getCoords().isEqual(DataArrayDouble.New(expected1[pos],4,2),1e-12))
10061             pass
10062         for pos,vec in enumerate(vecs):
10063             m2=m.deepCpy()
10064             m2.translate(vec.buildDADouble())
10065             self.assertTrue(m2.getCoords().isEqual(DataArrayDouble.New(expected1[pos],4,2),1e-12))
10066             pass
10067         pass
10068
10069     def testSwigBugNonRegressionZipDA(self):
10070         angles=map(lambda x:pi/3*x,xrange(6))
10071         radius=3
10072         #
10073         dad=DataArrayDouble.New(6, 2)
10074         dad[:,0]=radius
10075         dad[:,1]=angles
10076         #
10077         dad2=dad.fromPolarToCart()
10078         dads=[dad2.deepCpy() for elt in 7*[None]]
10079         #
10080         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.)]]
10081         for d,t in zip(dads,translationToPerform):
10082             d+=t
10083             pass
10084         for elt in dads:
10085             self.assertTrue(not dad2.isEqual(elt,1e-12))
10086             pass
10087         for d,t in zip(dads,translationToPerform):
10088             d-=t
10089             pass
10090         for elt in dads:
10091             self.assertTrue(dad2.isEqual(elt,1e-12))
10092             pass
10093         pass
10094
10095     def testBuildSlice3D2(self):
10096         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
10097         vec1=[-0.07,1.,0.07]
10098         origin1=[1.524,1.4552,1.74768]
10099         slice1,ids=mesh3D.buildSlice3D(origin1,vec1,1e-10);
10100         f=MEDCouplingFieldDouble(ON_CELLS,ONE_TIME)
10101         f.setTime(4.5,6,7) ; f.setMesh(mesh3D)
10102         arr=DataArrayDouble(mesh3D.getNumberOfCells(),2)
10103         arr.rearrange(1) ; arr.iota(2.) ; arr.rearrange(2)
10104         f.setArray(arr)
10105         f.checkCoherency()
10106         expected1=DataArrayInt([1,3,4,7,9,10,13,15,16])
10107         self.assertTrue(expected1.isEqual(ids))
10108         arr2=arr[expected1]
10109         #
10110         f2=f.extractSlice3D(origin1,vec1,1e-10)
10111         self.assertTrue(f2.getArray().isEqual(arr2,1e-12));
10112         self.assertTrue(slice1.isEqual(f2.getMesh(),1e-12))
10113         self.assertEqual(6,f2.getTime()[1]) ; self.assertEqual(7,f2.getTime()[2])
10114         self.assertAlmostEqual(4.5,f2.getTime()[0],12);
10115         pass
10116
10117     def testComputeTupleIdsToSelectFromCellIds1(self):
10118         m=MEDCouplingDataForTest.build2DTargetMesh_3()
10119         f=MEDCouplingFieldDouble.New(ON_GAUSS_NE,NO_TIME);
10120         f.setMesh(m);
10121         arr=DataArrayDouble(52,2) ; arr.rearrange(1) ; arr.iota(7.) ; arr.rearrange(2)
10122         f.setArray(arr)
10123         #
10124         f2=f.buildSubPart([1,5,9])
10125         f2.checkCoherency()
10126         cI=m.computeNbOfNodesPerCell()
10127         cI.computeOffsets2()
10128         sel=DataArrayInt([1,5,9])
10129         res=sel.buildExplicitArrByRanges(cI)
10130         arr2=arr[res]
10131         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))
10132         self.assertTrue(arr2.isEqual(f2.getArray(),1e-12))
10133         pass
10134
10135     def testComputeSkin1(self):
10136         arrX=DataArrayDouble([2.,3.4,5.6,7.7,8.0]) ; arrY=DataArrayDouble([2.,3.4,5.6,7.7,9.0,14.2])
10137         cmesh=MEDCouplingCMesh() ; cmesh.setCoordsAt(0,arrX) ; cmesh.setCoordsAt(1,arrY)
10138         umesh=cmesh.buildUnstructured()
10139         #
10140         skin=umesh.computeSkin()
10141         self.assertEqual(18,skin.getNumberOfCells())
10142         self.assertEqual(1,skin.getMeshDimension())
10143         self.assertTrue(skin.getCoords().getHiddenCppPointer()==umesh.getCoords().getHiddenCppPointer())
10144         self.assertEqual([0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48,51,54],skin.getNodalConnectivityIndex().getValues())
10145         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())
10146         ids=skin.computeFetchedNodeIds()
10147         self.assertEqual([0,1,2,3,4,5,9,10,14,15,19,20,24,25,26,27,28,29],ids.getValues())
10148         part=umesh.buildFacePartOfMySelfNode(ids,True)
10149         part.setName(skin.getName());
10150         self.assertTrue(part.isEqual(skin,1e-12))
10151         part2=part[1::2]
10152         part[::2]=part2
10153         self.assertTrue(not part.isEqual(skin,1e-12))
10154         trad=part.zipConnectivityTraducer(0)
10155         self.assertEqual(9,part.getNumberOfCells())
10156         self.assertEqual([0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8],trad.getValues())
10157         pass
10158
10159     def testUMeshSetPartOfMySelf2(self):
10160         # resize with explicit ids list
10161         m=MEDCouplingDataForTest.build2DTargetMesh_1()
10162         self.assertEqual([3,4],m.getAllGeoTypes())
10163         part=m[[0,3,4]]
10164         part.simplexize(0)
10165         part2=part[[1,2,5]]
10166         m[[0,3,4]]=part2
10167         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())
10168         self.assertEqual([0,4,8,12,16,20],m.getNodalConnectivityIndex().getValues())
10169         self.assertEqual([3],m.getAllGeoTypes())
10170         # no resize with explicit ids list
10171         m=MEDCouplingDataForTest.build2DTargetMesh_1()
10172         part=m[[0,3]]
10173         part.convertAllToPoly()
10174         m[[3,4]]=part
10175         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())
10176         self.assertEqual([0,5,9,13,18,23],m.getNodalConnectivityIndex().getValues())
10177         self.assertEqual([3,4,5],m.getAllGeoTypes())
10178         # resize with range ids
10179         m=MEDCouplingDataForTest.build2DTargetMesh_1()
10180         part=m[3:]
10181         m[1:3]=part
10182         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())
10183         self.assertEqual([0,5,10,15,20,25],m.getNodalConnectivityIndex().getValues())
10184         self.assertEqual([4],m.getAllGeoTypes())
10185         # no resize with range ids
10186         m=MEDCouplingDataForTest.build2DTargetMesh_1()
10187         part=m[0::3]
10188         part.convertAllToPoly()
10189         m[3:]=part
10190         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())
10191         self.assertEqual([0,5,9,13,18,23],m.getNodalConnectivityIndex().getValues())
10192         self.assertEqual([3,4,5],m.getAllGeoTypes())
10193         # no resize with range ids negative direction
10194         m=MEDCouplingDataForTest.build2DTargetMesh_1()
10195         part=m[3::-3]
10196         part.convertAllToPoly()
10197         m[:-3:-1]=part
10198         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())
10199         self.assertEqual([0,5,9,13,18,23],m.getNodalConnectivityIndex().getValues())
10200         self.assertEqual([3,4,5],m.getAllGeoTypes())
10201         pass
10202
10203     def testUnPolyze3(self):
10204         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]
10205         conn=[1,2,5,4,-1,4,3,0,1,-1,2,0,3,5,-1,0,2,1,-1,4,5,3]
10206         m=MEDCouplingUMesh.New("a mesh",3);
10207         m.allocateCells(1);
10208         m.insertNextCell(NORM_POLYHED,22,conn[0:22])
10209         m.finishInsertingCells();
10210         coords=DataArrayDouble(coord,6,3);
10211         m.setCoords(coords);
10212         m.checkCoherency();
10213         #
10214         vol=m.getMeasureField(ON_CELLS);
10215         self.assertEqual(1,vol.getArray().getNumberOfTuples());
10216         self.assertAlmostEqual(0.5,vol.getArray().getIJ(0,0),12)
10217         #
10218         m.unPolyze();
10219         #
10220         self.assertEqual([NORM_PENTA6],m.getAllGeoTypes())
10221         self.assertTrue(DataArrayInt([0,7]).isEqual(m.getNodalConnectivityIndex()))
10222         self.assertTrue(DataArrayInt([16,0,2,1,3,5,4]).isEqual(m.getNodalConnectivity()))
10223         #
10224         vol=m.getMeasureField(ON_CELLS);
10225         self.assertEqual(1,vol.getArray().getNumberOfTuples());
10226         self.assertAlmostEqual(0.5,vol.getArray().getIJ(0,0),12)
10227         pass
10228
10229     def testKrSpatialDiscretization1(self):
10230         srcPointCoordsX=[0.8401877171547095, 0.7830992237586059, 0.9116473579367843, 0.335222755714889, 0.2777747108031878, 0.4773970518621602, 0.3647844727918433, 0.9522297251747128, 0.6357117279599009, 0.1416025553558034]
10231         srcFieldValsOnPoints=[2.129892434968836, 2.295320474540621, 1.931948594981134, 2.728013590937196, 2.715603240418478, 2.661778472822935, 2.695696990104364, 1.893710234970982, 2.529628016549284, 2.728432341300668]
10232         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]
10233         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]
10234         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])
10235         #
10236         nbOfInputPoints=10;
10237         f=MEDCouplingFieldDouble.New(ON_NODES_KR,ONE_TIME);
10238         srcArrX=DataArrayDouble.New(srcPointCoordsX,nbOfInputPoints,1);
10239         cmesh=MEDCouplingCMesh.New("aMesh");
10240         cmesh.setCoordsAt(0,srcArrX);
10241         umesh=cmesh.buildUnstructured();
10242         f.setMesh(umesh);
10243         srcVals=DataArrayDouble.New(srcFieldValsOnPoints,nbOfInputPoints,1);
10244         f.setArray(srcVals);
10245         f.checkCoherency();
10246         #
10247         res0=f.getValueOn(targetPointCoordsX[:1]);
10248         self.assertAlmostEqual(targetFieldValsExpected[0],res0[0],10)
10249         #
10250         valuesToTest=f.getValueOnMulti(targetPointCoordsX);
10251         self.assertEqual(40,valuesToTest.getNumberOfTuples());
10252         self.assertEqual(1,valuesToTest.getNumberOfComponents());
10253         for i in xrange(40):
10254             self.assertAlmostEqual(targetFieldValsExpected[i],valuesToTest.getIJ(i,0),10)
10255             pass
10256         fd=f.getDiscretization()
10257         del f
10258         self.assertTrue(isinstance(fd,MEDCouplingFieldDiscretizationKriging))
10259         coeffs,isDrift=fd.computeVectorOfCoefficients(umesh,srcVals)
10260         self.assertEqual(2,isDrift)
10261         self.assertTrue(coeffsExpected.isEqual(coeffs,1e-8))
10262         #
10263         pass
10264
10265     def testDuplicateEachTupleNTimes1(self):
10266         d=DataArrayDouble.New([9.,8.,7.,6.],4,1) ; d.setInfoOnComponents(["mass [kg]"]) ; d.setName("aname")
10267         d2=d.duplicateEachTupleNTimes(3)
10268         self.assertTrue(d2.isEqualWithoutConsideringStr(DataArrayDouble.New([9.,9.,9.,8.,8.,8.,7.,7.,7.,6.,6.,6.],4*3,1),1e-14))
10269         self.assertEqual("aname",d2.getName())
10270         self.assertEqual(["mass [kg]"],d2.getInfoOnComponents())
10271         #
10272         d=DataArrayInt.New([9,8,7,6],4,1) ; d.setInfoOnComponents(["mass [kg]"]) ; d.setName("aname")
10273         d2=d.duplicateEachTupleNTimes(3)
10274         self.assertTrue(d2.isEqualWithoutConsideringStr(DataArrayInt.New([9,9,9,8,8,8,7,7,7,6,6,6],4*3,1)))
10275         self.assertEqual("aname",d2.getName())
10276         self.assertEqual(["mass [kg]"],d2.getInfoOnComponents())
10277         pass
10278
10279     def testSwigComputeTupleIdsNearTuples1(self):
10280         da=DataArrayDouble([5.,6.,-5.,-6.,5.,-6.,-5.,6.,5.,6.],5,2)
10281         arr,arrI=da.computeTupleIdsNearTuples(DataArrayDouble([5.,-6.,5.,6.,-5.,-6.],3,2),1e-10)
10282         self.assertEqual([2,0,4,1],arr.getValues())
10283         self.assertEqual([0,1,3,4],arrI.getValues())
10284         arr,arrI=da.computeTupleIdsNearTuples([5.,-6.,5.,6.,-5.,-6.],1e-10)
10285         self.assertEqual([2,0,4,1],arr.getValues())
10286         self.assertEqual([0,1,3,4],arrI.getValues())
10287         expected0=[[2],[0,4],[1]]
10288         expected1=[[0,1],[0,2],[0,1]]
10289         for pos,it in enumerate(DataArrayDouble([5.,-6.,5.,6.,-5.,-6.],3,2)):
10290             arr,arrI=da.computeTupleIdsNearTuples(it,1e-10)
10291             self.assertEqual(expected0[pos],arr.getValues())
10292             self.assertEqual(expected1[pos],arrI.getValues())
10293             pass
10294         pass
10295
10296     def testSwigDataTupleIOp1(self):
10297         d=DataArrayDouble(10,1)
10298         d.iota(7.)
10299         for elt in d:
10300             elt+=2.
10301             pass
10302         toTest=DataArrayDouble([9.0,10.0,11.0,12.0,13.0,14.0,15.0,16.0,17.0,18.0])
10303         self.assertTrue(toTest.isEqual(d,1e-12))
10304         for elt in d:
10305             elt-=2.
10306             pass
10307         toTest=DataArrayDouble([7.0,8.0,9.0,10.0,11.0,12.0,13.0,14.0,15.0,16.0])
10308         self.assertTrue(toTest.isEqual(d,1e-12))
10309         for elt in d:
10310             elt*=2.
10311             pass
10312         toTest=DataArrayDouble([14.0,16.0,18.0,20.0,22.0,24.0,26.0,28.0,30.0,32.0])
10313         self.assertTrue(toTest.isEqual(d,1e-12))
10314         for elt in d:
10315             elt/=2.
10316             pass
10317         toTest=DataArrayDouble([7.0,8.0,9.0,10.0,11.0,12.0,13.0,14.0,15.0,16.0])
10318         self.assertTrue(toTest.isEqual(d,1e-12))
10319         #
10320         d=DataArrayInt(10,1)
10321         d.iota(7)
10322         for elt in d:
10323             elt+=2
10324             pass
10325         self.assertEqual(d.getValues(),[9,10,11,12,13,14,15,16,17,18])
10326         for elt in d:
10327             elt-=2
10328             pass
10329         self.assertEqual(d.getValues(),[7,8,9,10,11,12,13,14,15,16])
10330         for elt in d:
10331             elt*=2
10332             pass
10333         self.assertEqual(d.getValues(),[14,16,18,20,22,24,26,28,30,32])
10334         for elt in d:
10335             elt/=2
10336             pass
10337         self.assertEqual(d.getValues(),[7,8,9,10,11,12,13,14,15,16])
10338         for elt in d:
10339             elt%=3
10340             pass
10341         self.assertEqual(d.getValues(),[1,2,0,1,2,0,1,2,0,1])
10342         pass
10343
10344     def testIntersect2DMeshesTmp5(self):
10345         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)
10346         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)
10347         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)
10348         #
10349         m1=MEDCouplingUMesh.New("Fix",2);
10350         m1.setCoords(coords);
10351         m1.setConnectivity(conn,connI,True);
10352         #
10353         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)
10354         # connectivity
10355         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);
10356         conn.setName("");
10357         connI=DataArrayInt([0,9,18,27,36,45,54,63,72],9)
10358         m2=MEDCouplingUMesh.New("Mobile",2);
10359         m2.setCoords(coords);
10360         m2.setConnectivity(conn,connI,True);
10361         #
10362         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m1,m2,1e-10);
10363         self.assertEqual(105,m3.getNumberOfCells());
10364         self.assertEqual(105,d1.getNumberOfTuples());
10365         self.assertEqual(105,d2.getNumberOfTuples());
10366         self.assertEqual(704,m3.getNumberOfNodes());
10367         #
10368         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]
10369         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]
10370         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]
10371         f3=m3.getMeasureField(ON_CELLS).getArray().getValues();
10372         for i in xrange(105):
10373             self.assertAlmostEqual(areaExpected[i],f3[i],10)
10374             pass
10375         self.assertEqual(expected1,d1.getValues())
10376         self.assertEqual(expected2,d2.getValues())
10377         pass
10378
10379     def testSwig2Intersect2DMeshesQuadra1(self):
10380         import cmath
10381         def createDiagCircle(lX, lY, R, cells=[0,1]):
10382             """ A circle in a square box, cut along the diagonal.
10383             """
10384             c = []
10385             for i in range(8):
10386               c.append(cmath.rect(R, i*pi/4))
10387
10388             coords = [0.0,0.0,          c[3].real,c[3].imag,       -lX/2.0, lY/2.0,
10389                       0.0, lY/2.0,      lX/2.0,lY/2.0,             lX/2.0,0.0,
10390                       #   6                  7                              8
10391                       lX/2.0,-lY/2.0,   c[7].real,c[7].imag,       c[1].real,c[1].imag,
10392                       #   9                  10                            11
10393                       c[5].real,c[5].imag,   -lX/2.0,-lY/2.0,      0.0, -lY/2.0,
10394                       #   12                  13                            14
10395                       -lX/2.0,0.0,         0.0,0.0,                  0.0, 0.0]
10396             # Points 13 (reps. 14) are average of points (6,7) (resp (1,2))
10397             coords[13*2]   = 0.5*(coords[6*2]+coords[7*2])
10398             coords[13*2+1] = 0.5*(coords[6*2+1]+coords[7*2+1])
10399             coords[14*2]   = 0.5*(coords[1*2]+coords[2*2])
10400             coords[14*2+1] = 0.5*(coords[1*2+1]+coords[2*2+1])
10401             connec  = [1,7,8,0]      # half circle up right
10402             connec3 = [6,7,1,2,4,13,8,14,3,5]
10403
10404             baseMesh = MEDCouplingUMesh.New("box_circle", 2)
10405             baseMesh.allocateCells(2)
10406             meshCoords = DataArrayDouble.New(coords, len(coords)/2, 2)
10407             meshCoords.setInfoOnComponents(["X [au]", "Y [au]"])
10408             baseMesh.setCoords(meshCoords)
10409
10410             if 0 in cells:
10411               baseMesh.insertNextCell(NORM_QPOLYG, connec)
10412             if 1 in cells:
10413               baseMesh.insertNextCell(NORM_QPOLYG, connec3)
10414             baseMesh.finishInsertingCells()
10415             baseMesh.checkCoherency()
10416             return baseMesh
10417
10418         eps = 1.0e-7
10419         m1 = createDiagCircle(1.0, 1.0, 0.5*0.90, cells=[0,1])
10420         m2 = createDiagCircle(1.0, 1.0, 0.5*0.95, cells=[0])
10421         m3, _, _= MEDCouplingUMesh.Intersect2DMeshes(m1, m2, eps)
10422         m3.mergeNodes(eps)
10423         m3.convertDegeneratedCells()
10424         m3.zipCoords()
10425         m4 = m3.deepCpy()
10426         m5, _, _ = MEDCouplingUMesh.Intersect2DMeshes(m3, m4, eps)
10427         m5.mergeNodes(eps)
10428         # Check coordinates:
10429         self.assertTrue(m3.getCoords().isEqual(m5.getCoords(), eps))
10430
10431     def testIntersect2DMeshesTmp7(self):
10432         eps = 1.0e-8
10433         coords = [-0.5,-0.5,   -0.5, 0.5, 0.5, 0.5,    0.5,-0.5]
10434         connec = range(4)
10435         m1 = MEDCouplingUMesh.New("box", 2)
10436         m1.allocateCells(1)
10437         meshCoords = DataArrayDouble.New(coords, len(coords)/2, 2)
10438         m1.setCoords(meshCoords)
10439         m1.insertNextCell(NORM_POLYGON, connec)
10440         m1.finishInsertingCells()
10441
10442         m2 = MEDCouplingDataForTest.buildCircle(0.25, 0.2, 0.4)
10443         # Was looping indefinitly:
10444         m_intersec, resToM1, resToM2 = MEDCouplingUMesh.Intersect2DMeshes(m1, m2, eps)
10445         m_intersec.zipCoords()
10446         coo_tgt = DataArrayDouble([-0.5, -0.5, -0.5, 0.5, 0.5, 0.5, 0.5, -0.5, -0.03284271247461901, 0.4828427124746191,
10447           -0.014575131106459124, 0.5000000000000001, 0.5, -0.11224989991991996, 0.24271243444677046, 0.5, 0.5, 0.19387505004004,
10448           -0.04799910280454185, -0.06682678787499614, -0.023843325638122054, 0.4915644577163915, 0.5, -0.30612494995996, 0.0, -0.5,
10449           -0.5, 0.0, -0.25728756555322957, 0.5, -0.023843325638122026, 0.49156445771639157, -0.04799910280454181, -0.06682678787499613], 17 ,2)
10450         conn_tgt = [32, 5, 2, 6, 4, 7, 8, 9, 10, 32, 6, 3, 0, 1, 5, 4, 11, 12, 13, 14, 15, 16]
10451         connI_tgt = [0, 9, 22]
10452         res1_tgt  = [0, 0]
10453         res2_tgt = [0, -1]
10454         self.assert_(coo_tgt.isEqualWithoutConsideringStr(m_intersec.getCoords(), 1e-12))
10455         self.assertEqual(conn_tgt, m_intersec.getNodalConnectivity().getValues())
10456         self.assertEqual(connI_tgt, m_intersec.getNodalConnectivityIndex().getValues())
10457         self.assertEqual(res1_tgt, resToM1.getValues())
10458         self.assertEqual(res2_tgt, resToM2.getValues())
10459
10460     def testDAIBuildUnique1(self):
10461         d=DataArrayInt([1,2,2,3,3,3,3,4,5,5,7,7,7,19])
10462         e=d.buildUnique()
10463         self.assertTrue(e.isEqual(DataArrayInt([1,2,3,4,5,7,19])))
10464         pass
10465
10466     def testDAIPartitionByDifferentValues1(self):
10467         d=DataArrayInt([1,0,1,2,0,2,2,-3,2])
10468         expected=[[-3,[7]],[0,[1,4]],[1,[0,2]],[2,[3,5,6,8]]]
10469         for i,elt in enumerate(zip(*d.partitionByDifferentValues())):
10470             self.assertEqual(expected[i][0],elt[1])
10471             self.assertEqual(expected[i][1],elt[0].getValues())
10472             pass
10473         pass
10474
10475     def testFieldGaussMultiDiscPerType1(self):
10476         coords=DataArrayDouble([0.,0.,0.,1.,1.,1.,1.,0.,0.,0.5,0.5,1.,1.,0.5,0.5,0.],8,2)
10477         mQ8=MEDCouplingUMesh("",2) ; mQ8.setCoords(coords)
10478         mQ8.allocateCells(1)
10479         mQ8.insertNextCell(NORM_QUAD8,range(8))
10480         mQ8.finishInsertingCells()
10481         mQ4=MEDCouplingUMesh("",2) ; mQ4.setCoords(coords)
10482         mQ4.allocateCells(1)
10483         mQ4.insertNextCell(NORM_QUAD4,range(4))
10484         mQ4.finishInsertingCells()
10485         mT3=MEDCouplingUMesh("",2) ; mT3.setCoords(coords)
10486         mT3.allocateCells(1)
10487         mT3.insertNextCell(NORM_TRI3,range(3))
10488         mT3.finishInsertingCells()
10489
10490         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.]]
10491         ms=2*[mQ4]+7*[mQ8]+11*[mT3]
10492         ms[:]=(elt.deepCpy() for elt in ms)
10493         for m,t in zip(ms,tr):
10494             d=m.getCoords() ; d+= t
10495             pass
10496         m=MEDCouplingUMesh.MergeUMeshes(ms)
10497         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,NO_TIME)
10498         f.setMesh(m)
10499         # throw because cell 0,1 are QUAD4 and cell 3 is QUAD8
10500         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])
10501         f.setGaussLocalizationOnCells([0,1],[0.,0.,1.,0.,1.,1.,0.,1.],[0.3,0.3,0.7,0.7],[0.8,0.2])
10502         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])
10503         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])
10504         f.setGaussLocalizationOnCells([9,10,11,12,13],[0.,0.,1.,0.,1.,1.],[0.4,0.4],[1.])
10505         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])
10506         self.assertEqual(46,f.getNumberOfTuplesExpected())
10507         vals=DataArrayDouble.New(46*3,1) ; vals.iota(7.7) ; vals.rearrange(3)
10508         f.setArray(vals)
10509         f.checkCoherency()
10510         #f.getLocalizationOfDiscr()
10511         self.assertRaises(InterpKernelException,f.getGaussLocalizationIdOfOneType,NORM_QUAD8) #throw because several loc
10512         self.assertEqual([1,2],f.getGaussLocalizationIdsOfOneType(NORM_QUAD8))
10513         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())
10514         fc=f[[1,2,3,8]]
10515         fc.checkCoherency()
10516         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))
10517         fc.renumberCells([3,2,0,1])
10518         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))
10519         fc.getArray()
10520         pass
10521
10522     def testSwigRotate(self):
10523         d=DataArrayDouble([1.,2.,3.,4.,6.,5.],2,3)
10524         MEDCouplingPointSet.Rotate3DAlg([0.,0.,0.],[0.,1.,0.],1.5707963267948966,d)
10525         self.assertTrue(d.isEqual(DataArrayDouble([3.,2.,-1.,5.,6.,-4.],2,3),1e-12))
10526         d=DataArrayDouble([1.,2.,3.,4.,6.,5.],3,2)
10527         MEDCouplingPointSet.Rotate2DAlg([0.,0.],1.5707963267948966,d)
10528         self.assertTrue(d.isEqual(DataArrayDouble([-2.,1.,-4.,3.,-5.,6.],3,2),1e-12))
10529         pass
10530
10531     def testSwigCMeshProtection(self):
10532         cm=MEDCouplingCMesh()
10533         self.assertRaises(InterpKernelException,cm.setCoordsAt,0,DataArrayDouble([4.,4.5,6.,7.],2,2))
10534         self.assertRaises(InterpKernelException,cm.setCoords,DataArrayDouble([4.,4.5,6.,7.],2,2))
10535         pass
10536
10537     def testSwigCellsInBoundingBox1(self):
10538         m3D=MEDCouplingDataForTest.build3DExtrudedUMesh_1()[0]
10539         self.assertTrue(m3D.getCellsInBoundingBox([(0,3),(0,3),(0,1)],-1e-12).isEqual(DataArrayInt([0,1,2,3,4,5])))
10540         self.assertRaises(InterpKernelException,m3D.getCellsInBoundingBox,[(0,3,0),(3,0,1)],-1e-12)
10541         pass
10542
10543     def testDAICheckMonotonic1(self):
10544         data1=[-1,0,2,2,4,5]
10545         data2=[6,2,0,-8,-9,-56]
10546         data3=[-1,0,3,2,4,6]
10547         data4=[7,5,2,3,0,-6]
10548         d=DataArrayInt.New(data1);
10549         self.assertTrue(d.isMonotonic(True));
10550         self.assertTrue(not d.isMonotonic(False));
10551         d.checkMonotonic(True);
10552         self.assertRaises(InterpKernelException,d.checkMonotonic,False)
10553         d=DataArrayInt.New(data2);
10554         self.assertTrue(d.isMonotonic(False));
10555         self.assertTrue(not d.isMonotonic(True));
10556         d.checkMonotonic(False);
10557         self.assertRaises(InterpKernelException,d.checkMonotonic,True)
10558         d=DataArrayInt.New(data3);
10559         self.assertTrue(not d.isMonotonic(False));
10560         self.assertTrue(not d.isMonotonic(True));
10561         self.assertRaises(InterpKernelException,d.checkMonotonic,True)
10562         self.assertRaises(InterpKernelException,d.checkMonotonic,False)
10563         d=DataArrayInt.New(data4);
10564         self.assertTrue(not d.isMonotonic(False));
10565         self.assertTrue(not d.isMonotonic(True));
10566         self.assertRaises(InterpKernelException,d.checkMonotonic,True)
10567         self.assertRaises(InterpKernelException,d.checkMonotonic,False)
10568         d=DataArrayInt.New(0,1)
10569         self.assertTrue(d.isMonotonic(True));
10570         self.assertTrue(d.isMonotonic(False));
10571         d.checkMonotonic(True);
10572         d.checkMonotonic(False);
10573         d=DataArrayInt.New(data4,3,2);#throw because nbComp!=1
10574         self.assertRaises(InterpKernelException,d.isMonotonic,True)
10575         self.assertRaises(InterpKernelException,d.isMonotonic,False)
10576         self.assertRaises(InterpKernelException,d.checkMonotonic,True)
10577         self.assertRaises(InterpKernelException,d.checkMonotonic,False)
10578         pass
10579
10580     def testSwigDASetItemOnEmpty1(self):
10581         d=DataArrayInt(0,1)
10582         isThrow=False
10583         try:
10584             d[0:1000:2]=4
10585         except InterpKernelException as e:
10586             isThrow=True
10587             pass
10588         self.assertTrue(isThrow)
10589         d[:]=4
10590         d[::2]=5
10591         #
10592         d=DataArrayDouble(0,1)
10593         isThrow=False
10594         try:
10595             d[0:1000:2]=4
10596         except InterpKernelException as e:
10597             isThrow=True
10598             pass
10599         self.assertTrue(isThrow)
10600         d[:]=4
10601         d[::2]=5
10602         d=DataArrayInt([],0,1)
10603         d2=DataArrayInt(0)
10604         self.assertTrue(d2.isEqual(d))
10605         d=DataArrayDouble([],0,1)
10606         d2=DataArrayDouble(0)
10607         self.assertTrue(d2.isEqual(d,1e-12))
10608         pass
10609
10610     def testSwigDAITransformWithIndArr1(self):
10611         arr=DataArrayInt([0,4,5,1])
10612         d=DataArrayInt([7,8,9,10])
10613         self.assertRaises(InterpKernelException,arr.transformWithIndArr,d)
10614         pass
10615
10616     def testIntersect2DMeshesTmp6(self):
10617         # coordinates
10618         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);
10619         # connectivity
10620         conn=DataArrayInt.New([8,0,3,5,1,4,6,7,2])
10621         connI=DataArrayInt.New([0,9]);
10622         m1=MEDCouplingUMesh.New("Fixe",2);
10623         m1.setCoords(coords);
10624         m1.setConnectivity(conn,connI,True);
10625         #
10626         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);
10627         # connectivity
10628         conn=DataArrayInt.New([8,0,1,2,3,4,5,6,7,8,3,2,8,9,6,10,11,12]);
10629         connI=DataArrayInt.New([0,9,18]);
10630         #
10631         m2=MEDCouplingUMesh.New("Mobile",2);
10632         m2.setCoords(coords);
10633         m2.setConnectivity(conn,connI,True);
10634         #
10635         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m1,m2,1e-10);
10636         self.assertTrue(d1.isEqual(DataArrayInt([0,0,0,0])));
10637         self.assertTrue(d2.isEqual(DataArrayInt([0,1,-1,-1])));
10638         self.assertEqual(4,m3.getNumberOfCells());
10639         self.assertEqual(4,d1.getNumberOfTuples());
10640         self.assertEqual(4,d2.getNumberOfTuples());
10641         self.assertEqual(43,m3.getNumberOfNodes());
10642         dI,areMerged,newNbOfNodes=m3.mergeNodes(1e-12)
10643         self.assertEqual(35,m3.getNumberOfNodes());
10644         m3.zipCoords();
10645         self.assertEqual(23,m3.getNumberOfNodes());
10646         #
10647         f=m3.getMeasureField(True);
10648         valuesExpected=DataArrayDouble([1.6603638692585716,5.747555728471923,129.68907101754394,7.4162714498559694])
10649         self.assertTrue(f.getArray().isEqual(valuesExpected,1e-12))
10650         pass
10651
10652     def testDAPushBack(self):
10653         d=DataArrayDouble(0,1)
10654         for i in xrange(8):
10655             d.pushBackSilent(i)
10656             pass
10657         self.assertEqual(d.getNumberOfTuples(),8)
10658         self.assertEqual(d.getNbOfElemAllocated(),8)
10659         d.pushBackSilent(4.44)
10660         self.assertEqual(d.getNumberOfTuples(),9)
10661         self.assertEqual(d.getNbOfElemAllocated(),16)
10662         self.assertTrue(d.isEqual(DataArrayDouble([0.,1.,2.,3.,4.,5.,6.,7.,4.44]),1e-12))
10663         e=d.deepCpy()
10664         self.assertEqual(e.getNumberOfTuples(),9)
10665         self.assertEqual(e.getNbOfElemAllocated(),9)
10666         self.assertTrue(e.isEqual(DataArrayDouble([0.,1.,2.,3.,4.,5.,6.,7.,4.44]),1e-12))
10667         self.assertAlmostEqual(d.popBackSilent(),4.44,12)
10668         self.assertEqual(d.getNumberOfTuples(),8)
10669         self.assertEqual(d.getNbOfElemAllocated(),16)
10670         self.assertTrue(d.isEqual(DataArrayDouble([0.,1.,2.,3.,4.,5.,6.,7.]),1e-12))
10671         f=DataArrayDouble()
10672         f.reserve(1000)
10673         f.pushBackSilent(4.)
10674         self.assertTrue(f.isEqual(DataArrayDouble([4.]),1e-12))
10675         self.assertEqual(f.getNumberOfTuples(),1)
10676         self.assertEqual(f.getNbOfElemAllocated(),1000)
10677         ff=f[:]
10678         self.assertTrue(ff.isEqual(DataArrayDouble([4.]),1e-12))
10679         self.assertEqual(ff.getNumberOfTuples(),1)
10680         self.assertEqual(ff.getNbOfElemAllocated(),1)
10681         d=DataArrayDouble()
10682         d.pushBackSilent(4.44)
10683         d.pushBackSilent(5.55)
10684         d.pushBackSilent(6.66)
10685         self.assertTrue(d.isEqual(DataArrayDouble([4.44,5.55,6.66]),1e-12))
10686         #
10687         d=DataArrayInt(0,1)
10688         for i in xrange(8):
10689             d.pushBackSilent(i)
10690             pass
10691         self.assertEqual(d.getNumberOfTuples(),8)
10692         self.assertEqual(d.getNbOfElemAllocated(),8)
10693         d.pushBackSilent(444)
10694         self.assertEqual(d.getNumberOfTuples(),9)
10695         self.assertEqual(d.getNbOfElemAllocated(),16)
10696         self.assertTrue(d.isEqual(DataArrayInt([0,1,2,3,4,5,6,7,444])))
10697         e=d.deepCpy()
10698         self.assertEqual(e.getNumberOfTuples(),9)
10699         self.assertEqual(e.getNbOfElemAllocated(),9)
10700         self.assertTrue(e.isEqual(DataArrayInt([0,1,2,3,4,5,6,7,444])))
10701         self.assertEqual(d.popBackSilent(),444)
10702         self.assertEqual(d.getNumberOfTuples(),8)
10703         self.assertEqual(d.getNbOfElemAllocated(),16)
10704         self.assertTrue(d.isEqual(DataArrayInt([0,1,2,3,4,5,6,7])))
10705         f=DataArrayInt()
10706         f.reserve(1000)
10707         f.pushBackSilent(4)
10708         self.assertTrue(f.isEqual(DataArrayInt([4])))
10709         self.assertEqual(f.getNumberOfTuples(),1)
10710         self.assertEqual(f.getNbOfElemAllocated(),1000)
10711         ff=f[:]
10712         self.assertTrue(ff.isEqual(DataArrayInt([4])))
10713         self.assertEqual(ff.getNumberOfTuples(),1)
10714         self.assertEqual(ff.getNbOfElemAllocated(),1)
10715         d=DataArrayInt()
10716         d.pushBackSilent(444)
10717         d.pushBackSilent(555)
10718         d.pushBackSilent(666)
10719         self.assertTrue(d.isEqual(DataArrayInt([444,555,666])))
10720         #
10721         d=DataArrayInt()
10722         d.alloc(10,1)
10723         d.setInfoOnComponent(0,"ABC")
10724         d.setName("dEf")
10725         d.iota(7)
10726         e=DataArrayInt([7,8,9,10,11,12,13,14,15,16]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
10727         self.assertEqual(10,d.getNbOfElemAllocated())
10728         d.pushBackSilent(55)
10729         e=DataArrayInt([7,8,9,10,11,12,13,14,15,16,55]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
10730         self.assertEqual(20,d.getNbOfElemAllocated())
10731         d.reserve(4)
10732         e=DataArrayInt([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
10733         self.assertEqual(4,d.getNbOfElemAllocated())
10734         d.pushBackSilent(5)
10735         e=DataArrayInt([7,8,9,10,5]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
10736         self.assertEqual(8,d.getNbOfElemAllocated())
10737         self.assertEqual(5,d.popBackSilent())
10738         e=DataArrayInt([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
10739         self.assertEqual(8,d.getNbOfElemAllocated())
10740         self.assertRaises(OverflowError,d.reserve,-1)
10741         e=DataArrayInt([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
10742         self.assertEqual(8,d.getNbOfElemAllocated())
10743         d.reserve(0)
10744         e=DataArrayInt([]) ; e.setInfoOnComponent(0,"ABC") ; e.setName("dEf") ; self.assertTrue(d.isEqual(e))
10745         self.assertEqual(0,d.getNbOfElemAllocated())
10746         #
10747         d=DataArrayDouble()
10748         d.alloc(10,1)
10749         d.setInfoOnComponent(0,"ABC")
10750         d.setName("dEf")
10751         d.iota(7)
10752         e=DataArrayDouble([7,8,9,10,11,12,13,14,15,16]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
10753         self.assertEqual(10,d.getNbOfElemAllocated())
10754         d.pushBackSilent(55)
10755         e=DataArrayDouble([7,8,9,10,11,12,13,14,15,16,55]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
10756         self.assertEqual(20,d.getNbOfElemAllocated())
10757         d.reserve(4)
10758         e=DataArrayDouble([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
10759         self.assertEqual(4,d.getNbOfElemAllocated())
10760         d.pushBackSilent(5)
10761         e=DataArrayDouble([7,8,9,10,5]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
10762         self.assertEqual(8,d.getNbOfElemAllocated())
10763         self.assertEqual(5.,d.popBackSilent())
10764         e=DataArrayDouble([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
10765         self.assertEqual(8,d.getNbOfElemAllocated())
10766         self.assertRaises(OverflowError,d.reserve,-1)
10767         e=DataArrayDouble([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
10768         self.assertEqual(8,d.getNbOfElemAllocated())
10769         d.reserve(0)
10770         e=DataArrayDouble([]) ; e.setInfoOnComponent(0,"ABC") ; e.setName("dEf") ; self.assertTrue(d.isEqual(e,1e-14))
10771         self.assertEqual(0,d.getNbOfElemAllocated())
10772         pass
10773
10774     def testDAIBuildSubstractionOptimized1(self):
10775         da1=DataArrayInt.New([1,3,5,6,7,9,13])
10776         da2=DataArrayInt.New([3,5,9])
10777         da3=DataArrayInt.New([1,3,5])
10778         da4=DataArrayInt.New([1,3,5,6,7,9,13])
10779         #
10780         a=da1.buildSubstractionOptimized(da2);
10781         self.assertTrue(a.isEqual(DataArrayInt([1,6,7,13])));
10782         #
10783         a=da1.buildSubstractionOptimized(da3);
10784         self.assertTrue(a.isEqual(DataArrayInt([6,7,9,13])));
10785         #
10786         a=da1.buildSubstractionOptimized(da4);
10787         self.assertTrue(a.isEqual(DataArrayInt([])));
10788         pass
10789
10790     def testDAIIsStrictlyMonotonic1(self):
10791         da1=DataArrayInt.New([1,3,5,6,7,9,13])
10792         self.assertTrue(da1.isStrictlyMonotonic(True));
10793         da1.checkStrictlyMonotonic(True);
10794         self.assertTrue(da1.isMonotonic(True));
10795         da1.checkMonotonic(True);
10796         self.assertTrue(not da1.isStrictlyMonotonic(False));
10797         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,False)
10798         self.assertTrue(not da1.isMonotonic(False));
10799         self.assertRaises(InterpKernelException,da1.checkMonotonic,False)
10800         #
10801         da1=DataArrayInt.New([1,3,5,6,6,9,13])
10802         self.assertTrue(not da1.isStrictlyMonotonic(True));
10803         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,True)
10804         self.assertTrue(da1.isMonotonic(True));
10805         da1.checkMonotonic(True);
10806         self.assertTrue(not da1.isStrictlyMonotonic(False));
10807         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,False)
10808         self.assertTrue(not da1.isMonotonic(False));
10809         self.assertRaises(InterpKernelException,da1.checkMonotonic,False)
10810         #
10811         da1=DataArrayInt.New([1,3,5,6,5,9,13])
10812         self.assertTrue(not da1.isStrictlyMonotonic(True));
10813         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,True)
10814         self.assertTrue(not da1.isMonotonic(True));
10815         self.assertRaises(InterpKernelException,da1.checkMonotonic,True)
10816         self.assertTrue(not da1.isStrictlyMonotonic(False));
10817         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,False)
10818         self.assertTrue(not da1.isMonotonic(False));
10819         self.assertRaises(InterpKernelException,da1.checkMonotonic,False)
10820         #
10821         da1=DataArrayInt.New([13,9,7,6,5,3,1])
10822         self.assertTrue(not da1.isStrictlyMonotonic(True));
10823         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,True)
10824         self.assertTrue(not da1.isMonotonic(True));
10825         self.assertRaises(InterpKernelException,da1.checkMonotonic,True)
10826         self.assertTrue(da1.isStrictlyMonotonic(False));
10827         da1.checkStrictlyMonotonic(False);
10828         self.assertTrue(da1.isMonotonic(False));
10829         da1.checkMonotonic(False);
10830         #
10831         da1=DataArrayInt.New([13,9,6,6,5,3,1])
10832         self.assertTrue(not da1.isStrictlyMonotonic(True));
10833         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,True)
10834         self.assertTrue(not da1.isMonotonic(True));
10835         self.assertRaises(InterpKernelException,da1.checkMonotonic,True)
10836         self.assertTrue(not da1.isStrictlyMonotonic(False));
10837         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,False)
10838         self.assertTrue(da1.isMonotonic(False));
10839         da1.checkMonotonic(False);
10840         #
10841         da1=DataArrayInt.New([13,9,5,6,5,3,1])
10842         self.assertTrue(not da1.isStrictlyMonotonic(True));
10843         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,True)
10844         self.assertTrue(not da1.isMonotonic(True));
10845         self.assertRaises(InterpKernelException,da1.checkMonotonic,True)
10846         self.assertTrue(not da1.isStrictlyMonotonic(False));
10847         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,False)
10848         self.assertTrue(not da1.isMonotonic(False));
10849         self.assertRaises(InterpKernelException,da1.checkMonotonic,False)
10850         #
10851         da1=DataArrayInt.New([])
10852         self.assertTrue(da1.isStrictlyMonotonic(True));
10853         da1.checkStrictlyMonotonic(True);
10854         self.assertTrue(da1.isMonotonic(True));
10855         da1.checkMonotonic(True);
10856         self.assertTrue(da1.isStrictlyMonotonic(False));
10857         da1.checkStrictlyMonotonic(False);
10858         self.assertTrue(da1.isMonotonic(False));
10859         da1.checkMonotonic(False);
10860         #
10861         da1=DataArrayInt.New([13])
10862         self.assertTrue(da1.isStrictlyMonotonic(True));
10863         da1.checkStrictlyMonotonic(True);
10864         self.assertTrue(da1.isMonotonic(True));
10865         da1.checkMonotonic(True);
10866         self.assertTrue(da1.isStrictlyMonotonic(False));
10867         da1.checkStrictlyMonotonic(False);
10868         self.assertTrue(da1.isMonotonic(False));
10869         da1.checkMonotonic(False);
10870         pass
10871
10872     def testFindAndCorrectBadOriented3DCells1(self):
10873         nbOfDisc=20
10874         vects=([0,0,-1],[0.3,0.7,0.2],[-0.3,0.7,0.2],[-0.3,-0.7,0.2])
10875         #
10876         m0=MEDCouplingUMesh("m",3) ; m0.allocateCells(0); m0.insertNextCell(NORM_TETRA4,[0,1,2,3]); #Well oriented
10877         m1=MEDCouplingUMesh("m",3) ; m1.allocateCells(0); m1.insertNextCell(NORM_PYRA5,[0,1,2,3,4]); #Well oriented
10878         m2=MEDCouplingUMesh("m",3) ; m2.allocateCells(0); m2.insertNextCell(NORM_PENTA6,[0,1,2,3,4,5]); #Well oriented
10879         m3=MEDCouplingUMesh("m",3) ; m3.allocateCells(0); m3.insertNextCell(NORM_HEXA8,[0,1,2,3,4,5,6,7]); #Well oriented
10880         m4=MEDCouplingUMesh("m",3) ; m4.allocateCells(0)
10881         self.assertRaises(InterpKernelException,m4.insertNextCell,NORM_HEXGP12,[0,1,2,3,4,5,6,7,8,9,10,11,12]);
10882         m4.insertNextCell(NORM_HEXGP12,[0,1,2,3,4,5,6,7,8,9,10,11]); #Well oriented
10883         c0=DataArrayDouble([0.,0.,0.,0.,1.,0.,1.,0.,0.,0.,0.,1.],4,3) ; m0.setCoords(c0)
10884         c1=DataArrayDouble([0.,0.,0.,0.,1.,0.,1.,1.,0.,1.,0.,0.,0.,0.,1.],5,3) ; m1.setCoords(c1)
10885         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)
10886         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)
10887         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)
10888         m=MEDCouplingMesh.MergeMeshes([m0,m1,m2,m3,m4])
10889         expected1=DataArrayDouble([0.16666666666666666,0.3333333333333333,0.5,1.,1.])
10890         for v in vects:
10891             for i in xrange(nbOfDisc):
10892                 mm=m.deepCpy()
10893                 mm.rotate([0.,0.,0.],[0.3,0.7,0.2],float(i)/float(nbOfDisc)*2*pi)
10894                 mm2=mm.deepCpy()
10895                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
10896                 self.assertTrue(mm.findAndCorrectBadOriented3DCells().empty())
10897                 self.assertTrue(mm.isEqual(mm2,1e-14))
10898                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
10899                 mm.convertAllToPoly()
10900                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
10901                 pass
10902             pass
10903         #
10904         mOK=m.deepCpy()
10905         m0=MEDCouplingUMesh("m",3) ; m0.allocateCells(0); m0.insertNextCell(NORM_TETRA4,[0,2,1,3]); #Not well oriented
10906         m1=MEDCouplingUMesh("m",3) ; m1.allocateCells(0); m1.insertNextCell(NORM_PYRA5,[0,1,2,3,4]); #Well oriented
10907         m2=MEDCouplingUMesh("m",3) ; m2.allocateCells(0); m2.insertNextCell(NORM_PENTA6,[0,1,2,3,4,5]); #Well oriented
10908         m3=MEDCouplingUMesh("m",3) ; m3.allocateCells(0); m3.insertNextCell(NORM_HEXA8,[0,3,2,1,4,7,6,5]); #Not well oriented
10909         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
10910         m0.setCoords(c0) ; m1.setCoords(c1) ; m2.setCoords(c2) ; m3.setCoords(c3) ; m4.setCoords(c4)
10911         m=MEDCouplingMesh.MergeMeshes([m0,m1,m2,m3,m4])
10912         expected2=DataArrayDouble([-0.16666666666666666,0.3333333333333333,0.5,-1.,-1.])
10913         for v in vects:
10914             for i in xrange(nbOfDisc):
10915                 mm=m.deepCpy()
10916                 mm.rotate([0.,0.,0.],[0.3,0.7,0.2],float(i)/float(nbOfDisc)*2*pi)
10917                 mm2=mm.deepCpy() ; mm3=mm.deepCpy() ; mm3.convertAllToPoly()
10918                 self.assertTrue(mm3.getMeasureField(False).getArray().isEqual(expected2,1e-14))
10919                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected2,1e-14))
10920                 self.assertTrue(mm.findAndCorrectBadOriented3DCells().isEqual(DataArrayInt([0,3,4])))
10921                 mOK.setCoords(mm.getCoords())
10922                 self.assertTrue(mm.isEqual(mOK,1e-14))
10923                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
10924                 mmm=mm.deepCpy()
10925                 self.assertTrue(mmm.findAndCorrectBadOriented3DCells().empty())
10926                 mm.convertAllToPoly()
10927                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
10928                 pass
10929             pass
10930         #
10931         m0=MEDCouplingUMesh("m",3) ; m0.allocateCells(0); m0.insertNextCell(NORM_TETRA4,[0,1,2,3]); #Well oriented
10932         m1=MEDCouplingUMesh("m",3) ; m1.allocateCells(0); m1.insertNextCell(NORM_PYRA5,[0,3,2,1,4]); #Not well oriented
10933         m2=MEDCouplingUMesh("m",3) ; m2.allocateCells(0); m2.insertNextCell(NORM_PENTA6,[0,2,1,3,5,4]); #Not well oriented
10934         m3=MEDCouplingUMesh("m",3) ; m3.allocateCells(0); m3.insertNextCell(NORM_HEXA8,[0,1,2,3,4,5,6,7]); #Well oriented
10935         m4=MEDCouplingUMesh("m",3) ; m4.allocateCells(0); m4.insertNextCell(NORM_HEXGP12,range(12)); #Well oriented
10936         m0.setCoords(c0) ; m1.setCoords(c1) ; m2.setCoords(c2) ; m3.setCoords(c3) ; m4.setCoords(c4)
10937         m=MEDCouplingMesh.MergeMeshes([m0,m1,m2,m3,m4])
10938         expected3=DataArrayDouble([0.16666666666666666,-0.3333333333333333,-0.5,1.,1.])
10939         for v in vects:
10940             for i in xrange(nbOfDisc):
10941                 mm=m.deepCpy()
10942                 mm.rotate([0.,0.,0.],[0.3,0.7,0.2],float(i)/float(nbOfDisc)*2*pi)
10943                 mm2=mm.deepCpy() ; mm3=mm.deepCpy() ; mm3.convertAllToPoly()
10944                 self.assertTrue(mm3.getMeasureField(False).getArray().isEqual(expected3,1e-14))
10945                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected3,1e-14))
10946                 self.assertTrue(mm.findAndCorrectBadOriented3DCells().isEqual(DataArrayInt([1,2])))
10947                 mOK.setCoords(mm.getCoords())
10948                 self.assertTrue(mm.isEqual(mOK,1e-14))
10949                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
10950                 mmm=mm.deepCpy()
10951                 self.assertTrue(mmm.findAndCorrectBadOriented3DCells().empty())
10952                 mm.convertAllToPoly()
10953                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
10954                 pass
10955             pass
10956         pass
10957
10958     def testSwig2CellOrientation1(self):
10959         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)
10960         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]]
10961         for i in xrange(256):
10962             mesh=MEDCouplingUMesh("FluidMesh_1",3);
10963             mesh.allocateCells(0)
10964             conn2=[elt[:] for elt in conn]
10965             code=bin(i)[2:] ; code='0'*(8-len(code))+code
10966             for face,rev in zip(conn2,code):
10967                 if bool(int(rev)):
10968                     face.reverse()
10969                     pass
10970                 pass
10971             conn3=[elt+[-1] for elt in conn2]
10972             conn3=sum(conn3,[])[:-1]
10973             mesh.insertNextCell(NORM_POLYHED,conn3)
10974             mesh.setCoords(coords)
10975             mesh.orientCorrectlyPolyhedrons()
10976             self.assertTrue(mesh.getBarycenterAndOwner().isEqual(DataArrayDouble([-0.10803,0.,0.3385],1,3),1e-12))
10977             pass
10978         pass
10979
10980     def testSwig2CheckConsecutiveCellTypesForMEDFileFrmt1(self):
10981         m1=MEDCouplingUMesh("",2) ; m1.allocateCells(0)
10982         m1.insertNextCell(NORM_QUAD4,[0,1,2,3])
10983         m1.insertNextCell(NORM_TRI3,[0,1,2])
10984         d=DataArrayDouble(4,3) ; d[:]=0.
10985         m1.setCoords(d)
10986         self.assertTrue(m1.checkConsecutiveCellTypes())
10987         self.assertTrue(not m1.checkConsecutiveCellTypesForMEDFileFrmt())
10988         m1.renumberCells([1,0])
10989         self.assertTrue(m1.checkConsecutiveCellTypes())
10990         self.assertTrue(m1.checkConsecutiveCellTypesForMEDFileFrmt())
10991         pass
10992
10993     def testSwig2DAAccumulate1(self):
10994         d=DataArrayInt(10) ; d.iota(0)
10995         self.assertEqual([45],d.accumulate())
10996         self.assertEqual(45,d.accumulate(0))
10997         d=DataArrayInt(30) ; d.iota(0) ; d.rearrange(3)
10998         self.assertEqual([135,145,155],d.accumulate())
10999         self.assertEqual(135,d.accumulate(0))
11000         self.assertEqual(145,d.accumulate(1))
11001         self.assertEqual(155,d.accumulate(2))
11002         d=DataArrayDouble(10) ; d.iota(0.)
11003         self.assertEqual([45.],d.accumulate())
11004         self.assertEqual(45.,d.accumulate(0))
11005         d=DataArrayDouble(30) ; d.iota(0) ; d.rearrange(3)
11006         self.assertEqual([135.,145.,155.],d.accumulate())
11007         self.assertEqual(135.,d.accumulate(0))
11008         self.assertEqual(145.,d.accumulate(1))
11009         self.assertEqual(155.,d.accumulate(2))
11010         pass
11011
11012     def testSwig2UMeshDistanceToMesh1(self):
11013         m=MEDCouplingUMesh("toto",2)
11014         coords=DataArrayDouble([2.3,3.4,5.6,6.5,-4.3,3.2,-9.8,7.6,-5.4],3,3)
11015         m.setCoords(coords)
11016         m.allocateCells(0)
11017         m.insertNextCell(NORM_TRI3,[0,1,2])
11018         a,b=m.distanceToPoint([-0.335,2.27,1.21])
11019         self.assertEqual(0,b)
11020         self.assertAlmostEqual(0.022360988100374124,a,14);
11021         a,b=m.distanceToPoint(DataArrayDouble([-0.335,2.27,1.21],1,3))
11022         self.assertEqual(0,b)
11023         self.assertAlmostEqual(0.022360988100374124,a,14);
11024         a,b=coords.distanceToTuple([-0.335,2.27,1.21])
11025         self.assertAlmostEqual(5.243302871282566,a,14)
11026         self.assertEqual(0,b)
11027         #
11028         m=MEDCouplingUMesh("toto",2)
11029         coords=DataArrayDouble([0.,0.,0., 8.,0.,0., 8.,8.,0., 0.,8.,0.],4,3)
11030         m.setCoords(coords)
11031         m.allocateCells(0)
11032         m.insertNextCell(NORM_QUAD4,[0,1,2,3])
11033         m.checkCoherency2()
11034         self.assertEqual([4,0,1,2,3],m.getNodalConnectivity().getValues())
11035         a,b=m.distanceToPoint([5.,2.,0.1])
11036         self.assertAlmostEqual(0.1,a,14) ; self.assertEqual(0,b)
11037         a,b=m.distanceToPoint([5.,-2.,4.])
11038         self.assertAlmostEqual(sqrt(2*2+4*4),a,14) ; self.assertEqual(0,b)
11039         m.allocateCells(0)
11040         m.insertNextCell(NORM_POLYGON,[0,1,2,3])
11041         m.checkCoherency2()
11042         self.assertEqual([5,0,1,2,3],m.getNodalConnectivity().getValues())
11043         a,b=m.distanceToPoint([11.,3.,4.])
11044         self.assertAlmostEqual(sqrt(3*3+4*4),a,14) ; self.assertEqual(0,b)
11045         a,b=m.distanceToPoint([4.,12.,5.])
11046         self.assertAlmostEqual(sqrt(4*4+5*5),a,14) ; self.assertEqual(0,b)
11047         d=DataArrayDouble([-1.2,3.,2.],1,3)
11048         for elt in d:
11049             a,b=m.distanceToPoint(d)
11050             self.assertAlmostEqual(sqrt(1.2*1.2+2*2),a,14) ; self.assertEqual(0,b)
11051             pass
11052         #
11053         m=MEDCouplingUMesh("toto",1)
11054         coords=DataArrayDouble([0.,0.,4.,0.,0.,4.],3,2) ; m.setCoords(coords)
11055         m.allocateCells(0) ; m.insertNextCell(NORM_SEG2,[0,1]) ; m.insertNextCell(NORM_SEG2,[1,2])
11056         a,b=m.distanceToPoint([-0.1,4.1])
11057         self.assertAlmostEqual(0.14142135623730925,a,14)  # b==1 self.assertEqual(2,c)
11058         a,b=m.distanceToPoint([0.,3.9])
11059         self.assertAlmostEqual(0.07071067811865482,a,14) ; self.assertEqual(1,b) # self.assertEqual(2,c)
11060         pass
11061
11062     def testSwig2NonRegressionPartitionBySpreadZone1(self):
11063         m=MEDCouplingCMesh()
11064         arr=DataArrayDouble(6) ; arr.iota(0.)
11065         m.setCoords(arr,arr,arr)
11066         m=m.buildUnstructured()
11067         mPart=m[50,80,85,87,92,122]
11068         zones=mPart.partitionBySpreadZone()
11069         self.assertEqual(4,len(zones))
11070         self.assertTrue(zones[0].isEqual(DataArrayInt([0])))
11071         self.assertTrue(zones[1].isEqual(DataArrayInt([1,2])))
11072         self.assertTrue(zones[2].isEqual(DataArrayInt([3,4])))
11073         self.assertTrue(zones[3].isEqual(DataArrayInt([5])))
11074         #
11075         n,ni=m.computeNeighborsOfCells()
11076         a,b=MEDCouplingUMesh.ComputeSpreadZoneGraduallyFromSeed(0,n,ni)
11077         self.assertEqual(13,b) ; self.assertEqual(125,len(a)) ; self.assertTrue(a.isIdentity())
11078         a,b=MEDCouplingUMesh.ComputeSpreadZoneGraduallyFromSeed([1],n,ni)
11079         self.assertEqual(12,b) ; self.assertEqual(125,len(a)) ; self.assertTrue(a.isIdentity())
11080         a,b=MEDCouplingUMesh.ComputeSpreadZoneGraduallyFromSeed((2,),n,ni)
11081         self.assertEqual(11,b) ; self.assertEqual(125,len(a)) ; self.assertTrue(a.isIdentity())
11082         a,b=MEDCouplingUMesh.ComputeSpreadZoneGraduallyFromSeed(DataArrayInt([3]),n,ni)
11083         self.assertEqual(12,b) ; self.assertEqual(125,len(a)) ; self.assertTrue(a.isIdentity())
11084         pass
11085
11086     def testSwigUMeshInsertNextCell1(self):
11087         m=MEDCouplingUMesh("toto",2)
11088         #
11089         coords=DataArrayDouble([0.,0.,1.,1.,1.,0.]) ; m.setCoords(coords)
11090         da=DataArrayInt([0,1,2])
11091         m.allocateCells(0)
11092         for i in xrange(5):
11093             m.insertNextCell(NORM_TRI3,da)
11094             pass
11095         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])))
11096         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4,8,12,16,20])))
11097         #
11098         da=DataArrayInt([0,1,2,3])
11099         m.allocateCells(0)
11100         for i in xrange(5):
11101             m.insertNextCell(NORM_TRI3,3,da)
11102             pass
11103         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])))
11104         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4,8,12,16,20])))
11105         #
11106         da=DataArrayInt([0,1])
11107         m.allocateCells(0)
11108         self.assertRaises(InterpKernelException,m.insertNextCell,NORM_TRI3,3,da)
11109         #
11110         da=DataArrayInt([0,1,2,0,1,3,0,1,4,0,1,5,0,1,6],5,3)
11111         m.allocateCells(0)
11112         for t in da:
11113             m.insertNextCell(NORM_TRI3,t)
11114             pass
11115         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])))
11116         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4,8,12,16,20])))
11117         self.assertRaises(InterpKernelException,m.insertNextCell,NORM_TRI3,None)
11118         pass
11119
11120     def testSwigCurveLinearMesh1(self):
11121         m=MEDCouplingCurveLinearMesh("toto")
11122         m.setNodeGridStructure([2,3])
11123         coords=DataArrayDouble([0.,0., 2.,0., 0.,1., 1.9,1.1, 0.3,1.9, 2.2,2.1],6,2)
11124         m.setCoords(coords)
11125         m.checkCoherency()
11126         m0=m.deepCpy()
11127         self.assertTrue(m0.isEqual(m,1e-12))
11128         m.getCoords().setInfoOnComponents(["X [m]","Y [m]"])
11129         self.assertTrue(not m0.isEqual(m,1e-12))
11130         m0=m.deepCpy()
11131         self.assertTrue(m0.isEqual(m,1e-12))
11132         self.assertEqual(m.getNodeGridStructure(),(2,3))
11133         pass
11134
11135     def testSimplexize3(self):
11136         m=MEDCouplingUMesh("toto",3)
11137         m.allocateCells(0)
11138         m.insertNextCell(NORM_TETRA4,[0,1,2,3])
11139         self.assertEqual([NORM_TETRA4],m.getAllGeoTypesSorted())
11140         m.insertNextCell(NORM_HEXA8,[4,5,6,7,8,9,10,11])
11141         self.assertEqual([NORM_TETRA4,NORM_HEXA8],m.getAllGeoTypesSorted())
11142         m.insertNextCell(NORM_HEXA8,[12,13,14,15,16,17,18,19])
11143         self.assertEqual([NORM_TETRA4,NORM_HEXA8],m.getAllGeoTypesSorted())
11144         m.insertNextCell(NORM_TETRA4,[20,21,22,23])
11145         self.assertEqual([NORM_TETRA4,NORM_HEXA8,NORM_TETRA4],m.getAllGeoTypesSorted())
11146         c1=DataArrayDouble([0.,0.,0.,0.,1.,0.,1.,0.,0.,0.,0.,1.],4,3)
11147         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.]
11148         c3=c2+[2.,0.,0.]
11149         c4=c1+[6.,0.,0.]
11150         c=DataArrayDouble.Aggregate([c1,c2,c3,c4])
11151         m.setCoords(c)
11152         m.checkCoherency2()
11153         #
11154         m1=m.deepCpy()
11155         d1=m1.simplexize(PLANAR_FACE_5)
11156         m1.checkCoherency2()
11157         vol1=m1.getMeasureField(ON_CELLS).getArray()
11158         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))
11159         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])
11160         self.assertEqual(m1.getNodalConnectivityIndex().getValues(),[0,5,10,15,20,25,30,35,40,45,50,55,60])
11161         self.assertTrue(d1.isEqual(DataArrayInt([0,1,1,1,1,1,2,2,2,2,2,3])))
11162         #
11163         m2=m.deepCpy()
11164         d2=m2.simplexize(PLANAR_FACE_6)
11165         m2.checkCoherency2()
11166         vol2=m2.getMeasureField(ON_CELLS).getArray()
11167         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))
11168         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])
11169         self.assertEqual(m2.getNodalConnectivityIndex().getValues(),[0,5,10,15,20,25,30,35,40,45,50,55,60,65,70])
11170         self.assertTrue(d2.isEqual(DataArrayInt([0,1,1,1,1,1,1,2,2,2,2,2,2,3])))
11171         pass
11172
11173     def testSwig2CurveLinearMesh2(self):
11174         c=MEDCouplingCMesh()
11175         #2D
11176         arr1=DataArrayDouble([0,1,3,7])
11177         arr2=DataArrayDouble([0,1,1.5])
11178         c.setCoords(arr1,arr2)
11179         u=c.buildUnstructured()
11180         coo=u.getCoords()
11181         cl=MEDCouplingCurveLinearMesh()
11182         cl.setCoords(coo)
11183         cl.setNodeGridStructure([4,3])
11184         cl.checkCoherency2()
11185         li1=[1.,2.,4.,0.5,1.,2.]
11186         self.assertTrue(cl.getMeasureField(False).getArray().isEqual(DataArrayDouble(li1),1e-14))
11187         self.assertTrue(u.getMeasureField(False).getArray().isEqual(DataArrayDouble(li1),1e-14))
11188         li1_1=[0.5,0.5,2.,0.5,5.,0.5,0.5,1.25,2.,1.25,5.,1.25]
11189         self.assertTrue(cl.getBarycenterAndOwner().isEqual(DataArrayDouble(li1_1,6,2),1e-14))
11190         self.assertTrue(u.getBarycenterAndOwner().isEqual(DataArrayDouble(li1_1,6,2),1e-14))
11191         #3D
11192         c.setCoords(arr1,arr2,arr2)
11193         u=c.buildUnstructured()
11194         coo=u.getCoords()
11195         cl=MEDCouplingCurveLinearMesh()
11196         cl.setCoords(coo)
11197         cl.setNodeGridStructure([4,3,3])
11198         cl.checkCoherency2()
11199         li2=[1.,2.,4.,0.5, 1.,2.,0.5,1.,2.,0.25,0.5,1.]
11200         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]
11201         self.assertTrue(cl.getMeasureField(False).getArray().isEqual(DataArrayDouble(li2),1e-14))
11202         self.assertTrue(u.getMeasureField(False).getArray().isEqual(DataArrayDouble(li2),1e-14))
11203         self.assertTrue(cl.getBarycenterAndOwner().isEqual(DataArrayDouble(li2_1,12,3),1e-14))
11204         self.assertTrue(u.getBarycenterAndOwner().isEqual(DataArrayDouble(li2_1,12,3),1e-14))
11205         #1D spaceDim 1
11206         coo=DataArrayDouble(5) ; coo.iota(0.)
11207         coo=coo*coo
11208         cl.setCoords(coo)
11209         cl.setNodeGridStructure([5])
11210         cl.checkCoherency2()
11211         li3=[1.,3.,5.,7.]
11212         li3_1=[0.5,2.5,6.5,12.5]
11213         self.assertTrue(cl.getMeasureField(False).getArray().isEqual(DataArrayDouble(li3),1e-14))
11214         self.assertTrue(cl.buildUnstructured().getMeasureField(False).getArray().isEqual(DataArrayDouble(li3),1e-14))
11215         self.assertTrue(cl.getBarycenterAndOwner().isEqual(DataArrayDouble(li3_1),1e-14))
11216         self.assertTrue(cl.buildUnstructured().getBarycenterAndOwner().isEqual(DataArrayDouble(li3_1),1e-14))
11217         #1D spaceDim 2
11218         coo=DataArrayDouble.Meld(coo,coo)
11219         cl.setCoords(coo)
11220         cl.checkCoherency2()
11221         li4=[sqrt(2.)*elt for elt in [1.,3.,5.,7.]]
11222         li4_1=[0.5,0.5,2.5,2.5,6.5,6.5,12.5,12.5]
11223         self.assertEqual(2,cl.getSpaceDimension())
11224         self.assertEqual(1,cl.getMeshDimension())
11225         self.assertEqual(4,cl.getNumberOfCells())
11226         self.assertEqual(5,cl.getNumberOfNodes())
11227         self.assertTrue(cl.getMeasureField(False).getArray().isEqual(DataArrayDouble(li4),1e-14))
11228         self.assertTrue(cl.buildUnstructured().getMeasureField(False).getArray().isEqual(DataArrayDouble(li4),1e-14))
11229         self.assertTrue(cl.getBarycenterAndOwner().isEqual(DataArrayDouble(li4_1,4,2),1e-14))
11230         self.assertTrue(cl.buildUnstructured().getBarycenterAndOwner().isEqual(DataArrayDouble(li4_1,4,2),1e-14))
11231         pass
11232
11233     def testSwig2CurveLinearMeshNonRegression1(self):
11234         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)
11235         m=MEDCouplingCurveLinearMesh("toto")
11236         m.setCoords(coords)
11237         m.setNodeGridStructure([3,3,3])
11238         #
11239         vol=m.getMeasureField(False).getArray()
11240         self.assertTrue(vol.isEqual(DataArrayDouble([0.11450000709295281, 0.10583334351579375,0.11149999939029423,0.08866666863113633, 0.1404166805123294,0.1250000135352219,0.1270833433481557,0.13258334288001067]),1e-12))
11241         self.assertTrue(vol.isEqual(m.buildUnstructured().getMeasureField(False).getArray(),1e-12))
11242         #
11243         self.assertTrue(m.getBarycenterAndOwner().isEqual(m.buildUnstructured().getBarycenterAndOwner(),1e-12))
11244         pass
11245
11246     def testSwig2NonRegressionDASetSelectedComponents1(self):
11247         da=DataArrayDouble.New([1.,2.,3.,4.,5.,6.],3,2)
11248         dv=DataArrayDouble.New();
11249         dv.alloc(4,4)
11250         dv.fillWithZero()
11251         # da has less tuples than dv
11252         dv.setSelectedComponents(da,[1,0])
11253         #
11254         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))
11255         #
11256         da=DataArrayInt.New([1,2,3,4,5,6],3,2)
11257         dv=DataArrayInt.New();
11258         dv.alloc(4,4)
11259         dv.fillWithZero()
11260         # da has less tuples than dv
11261         dv.setSelectedComponents(da,[1,0])
11262         #
11263         self.assertTrue(dv.isEqual(DataArrayInt([2,1,0,0,4,3,0,0,6,5,0,0,0,0,0,0],4,4)))
11264         pass
11265
11266     def testSwigSetItem3(self):
11267         # 1-2
11268         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11269         d[3]=[1,2]
11270         self.assertTrue(d.isEqual(DataArrayDouble([0,0,0,0,0,0,1,2,0,0,0,0],6,2),1e-14))
11271         # 2-2 false
11272         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11273         d[[5,3,2]]=[1,2]
11274         self.assertTrue(d.isEqual(DataArrayDouble([0,0,0,0,1,2,1,2,0,0,1,2],6,2),1e-14))
11275         # 3-2 false
11276         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11277         d[:]=[1,2]
11278         self.assertTrue(d.isEqual(DataArrayDouble([1,2,1,2,1,2,1,2,1,2,1,2],6,2),1e-14))
11279         # 4-2 false
11280         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11281         d[DataArrayInt([0,3,4])]=[1,2]
11282         self.assertTrue(d.isEqual(DataArrayDouble([1,2,0,0,0,0,1,2,1,2,0,0],6,2),1e-14))
11283         # 5-2
11284         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11285         d[5,1]=[7]
11286         self.assertTrue(d.isEqual(DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,7],6,2),1e-14))
11287         # 6-2 false
11288         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11289         d[[3,5],1]=[7]
11290         self.assertTrue(d.isEqual(DataArrayDouble([0,0,0,0,0,0,0,7,0,0,0,7],6,2),1e-14))
11291         # 7-2 false
11292         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11293         d[:-1:2,1]=[7]
11294         self.assertTrue(d.isEqual(DataArrayDouble([0,7,0,0,0,7,0,0,0,7,0,0],6,2),1e-14))
11295         # 8-2 false
11296         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11297         d[DataArrayInt([0,3,4]),1]=[7]
11298         self.assertTrue(d.isEqual(DataArrayDouble([0,7,0,0,0,0,0,7,0,7,0,0],6,2),1e-14))
11299         # 9-2
11300         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11301         d[3,[1,0]]=[7,8]
11302         self.assertTrue(d.isEqual(DataArrayDouble([0,0,0,0,0,0,8,7,0,0,0,0],6,2),1e-14))
11303         # 10-2 false
11304         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11305         d[[1,3,4],[1,0]]=[7,8]
11306         self.assertTrue(d.isEqual(DataArrayDouble([0,0,8,7,0,0,8,7,8,7,0,0],6,2),1e-14))
11307         # 11-2 false
11308         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11309         d[1::2,[1,0]]=[7,8]
11310         self.assertTrue(d.isEqual(DataArrayDouble([0,0,8,7,0,0,8,7,0,0,8,7],6,2),1e-14))
11311         # 12-2 false
11312         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11313         d[DataArrayInt([1,4]),[1,0]]=[7,8]
11314         self.assertTrue(d.isEqual(DataArrayDouble([0,0,8,7,0,0,0,0,8,7,0,0],6,2),1e-14))
11315         # 13-2
11316         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11317         d[1,:-1]=[9]
11318         self.assertTrue(d.isEqual(DataArrayDouble([0,0,9,0,0,0,0,0,0,0,0,0],6,2),1e-14))
11319         # 14-2 false
11320         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11321         d[[1,4,5],:]=[7,8]
11322         self.assertTrue(d.isEqual(DataArrayDouble([0,0,7,8,0,0,0,0,7,8,7,8],6,2),1e-14))
11323         # 15-2 false
11324         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11325         d[1::2,:]=[3,9]
11326         self.assertTrue(d.isEqual(DataArrayDouble([0,0,3,9,0,0,3,9,0,0,3,9],6,2),1e-14))
11327         # 1-2
11328         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11329         d[3]=[1,2]
11330         self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,0,0,1,2,0,0,0,0],6,2)))
11331         # 2-2 false
11332         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11333         d[[5,3,2]]=[1,2]
11334         self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,1,2,1,2,0,0,1,2],6,2)))
11335         # 3-2 false
11336         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11337         d[:]=[1,2]
11338         self.assertTrue(d.isEqual(DataArrayInt([1,2,1,2,1,2,1,2,1,2,1,2],6,2)))
11339         # 4-2 false
11340         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11341         d[DataArrayInt([0,3,4])]=[1,2]
11342         self.assertTrue(d.isEqual(DataArrayInt([1,2,0,0,0,0,1,2,1,2,0,0],6,2)))
11343         # 5-2
11344         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11345         d[5,1]=[7]
11346         self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,7],6,2)))
11347         # 6-2 false
11348         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11349         d[[3,5],1]=[7]
11350         self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,0,0,0,7,0,0,0,7],6,2)))
11351         # 7-2 false
11352         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11353         d[:-1:2,1]=[7]
11354         self.assertTrue(d.isEqual(DataArrayInt([0,7,0,0,0,7,0,0,0,7,0,0],6,2)))
11355         # 8-2 false
11356         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11357         d[DataArrayInt([0,3,4]),1]=[7]
11358         self.assertTrue(d.isEqual(DataArrayInt([0,7,0,0,0,0,0,7,0,7,0,0],6,2)))
11359         # 9-2
11360         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11361         d[3,[1,0]]=[7,8]
11362         self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,0,0,8,7,0,0,0,0],6,2)))
11363         # 10-2 false
11364         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11365         d[[1,3,4],[1,0]]=[7,8]
11366         self.assertTrue(d.isEqual(DataArrayInt([0,0,8,7,0,0,8,7,8,7,0,0],6,2)))
11367         # 11-2 false
11368         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11369         d[1::2,[1,0]]=[7,8]
11370         self.assertTrue(d.isEqual(DataArrayInt([0,0,8,7,0,0,8,7,0,0,8,7],6,2)))
11371         # 12-2 false
11372         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11373         d[DataArrayInt([1,4]),[1,0]]=[7,8]
11374         self.assertTrue(d.isEqual(DataArrayInt([0,0,8,7,0,0,0,0,8,7,0,0],6,2)))
11375         # 13-2
11376         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11377         d[1,:-1]=[9]
11378         self.assertTrue(d.isEqual(DataArrayInt([0,0,9,0,0,0,0,0,0,0,0,0],6,2)))
11379         # 14-2 false
11380         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11381         d[[1,4,5],:]=[7,8]
11382         self.assertTrue(d.isEqual(DataArrayInt([0,0,7,8,0,0,0,0,7,8,7,8],6,2)))
11383         # 15-2 false
11384         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11385         d[1::2,:]=[3,9]
11386         self.assertTrue(d.isEqual(DataArrayInt([0,0,3,9,0,0,3,9,0,0,3,9],6,2)))
11387         pass
11388
11389     def testSwig2ConvertLinearCellsToQuadratic1(self):
11390         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)
11391         # 2D
11392         m2D=MEDCouplingDataForTest.build2DTargetMesh_1()
11393         m2D.convertLinearCellsToQuadratic(0)
11394         m2D.checkCoherency1()
11395         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])
11396         self.assertEqual(m2D.getNodalConnectivityIndex().getValues(),[0,9,16,23,32,41])
11397         self.assertTrue(m2D.getCoords().isEqual(coordsExp,1e-14))
11398         # 1D
11399         m1D=MEDCouplingDataForTest.build2DTargetMesh_1().buildDescendingConnectivity()[0]
11400         m1D.convertLinearCellsToQuadratic(0)
11401         m1D.checkCoherency1()
11402         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])
11403         self.assertEqual(m1D.getNodalConnectivityIndex().getValues(),[0,4,8,12,16,20,24,28,32,36,40,44,48,52])
11404         self.assertTrue(m1D.getCoords().isEqual(coordsExp,1e-14))
11405         # 3D
11406         m2D=MEDCouplingDataForTest.build2DTargetMesh_1()
11407         m2D.changeSpaceDimension(3)
11408         arr=DataArrayDouble(4);  arr.iota(0) ; z=MEDCouplingCMesh() ; z.setCoords(arr)
11409         m1D=z.buildUnstructured() ; m1D.setCoords(arr.changeNbOfComponents(3,0.))
11410         m1D.getCoords()[:]=m1D.getCoords()[:,[1,2,0]]
11411         cooTmp=m2D.getCoords()[:]
11412         m3D=m2D.buildExtrudedMesh(m1D,0)
11413         m3D.convertLinearCellsToQuadratic(0)
11414         m3D.checkCoherency1()
11415         # check of new m3D content
11416         coordsExp2=[coordsExp.changeNbOfComponents(3,i) for i in xrange(4)]
11417         coordsExp3=[DataArrayDouble.Meld(cooTmp[:,[0,1]],cooTmp[:,2]+(0.5+float(i))) for i in xrange(3)]
11418         coordsExp4=DataArrayDouble.Aggregate([coordsExp2[0],coordsExp3[0],coordsExp2[1],coordsExp3[1],coordsExp2[2],coordsExp3[2],coordsExp2[3]])
11419         c=DataArrayDouble.Aggregate(m3D.getCoords(),coordsExp4)
11420         self.assertEqual(len(coordsExp4),115)
11421         self.assertEqual(len(m3D.getCoords()),115)
11422         a,b=c.findCommonTuples(1e-14)
11423         self.assertEqual(len(b),len(coordsExp4)+1)
11424         e,f=DataArrayInt.BuildOld2NewArrayFromSurjectiveFormat2(2*115,a,b)
11425         self.assertEqual(f,115)
11426         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])))
11427         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()))
11428         self.assertTrue(DataArrayInt([0,21,37,53,74,95,116,132,148,169,190,211,227,243,264,285]).isEqual(m3D.getNodalConnectivityIndex()))
11429         # testing explode3DMeshTo1D
11430         m3DSlice0=m3D[:5]
11431         m3DSlice0.zipCoords()
11432         a,b,c,d,e=m3DSlice0.explode3DMeshTo1D()
11433         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])))
11434         self.assertTrue(c.isEqual(DataArrayInt([0,12,21,30,42,54])))
11435         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])))
11436         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])))
11437         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])))
11438         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])))
11439         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))
11440         pass
11441
11442     def testSwig2DataArrayPushBackValsSilent1(self):
11443         d=DataArrayDouble()
11444         d.pushBackValsSilent([4,5,6])
11445         self.assertTrue(d.isEqual(DataArrayDouble([4.,5.,6.]),1e-14))
11446         e=DataArrayDouble([1,2,3],1,3)
11447         for t in e: d.pushBackValsSilent(t)
11448         self.assertTrue(d.isEqual(DataArrayDouble([4.,5.,6.,1.,2.,3.]),1e-14))
11449         d.pushBackValsSilent(DataArrayDouble([9,10.]))
11450         self.assertTrue(d.isEqual(DataArrayDouble([4.,5.,6.,1.,2.,3.,9.,10.]),1e-14))
11451         d.pushBackValsSilent(DataArrayDouble(0,1))
11452         self.assertTrue(d.isEqual(DataArrayDouble([4.,5.,6.,1.,2.,3.,9.,10.]),1e-14))
11453         e=DataArrayDouble([1,2,3],3,1)
11454         for t in e: d.pushBackValsSilent(t)
11455         self.assertTrue(d.isEqual(DataArrayDouble([4.,5.,6.,1.,2.,3.,9.,10.,1.,2.,3.]),1e-14))
11456         d.pushBackValsSilent(77)
11457         self.assertTrue(d.isEqual(DataArrayDouble([4.,5.,6.,1.,2.,3.,9.,10.,1.,2.,3.,77.]),1e-14))
11458         #
11459         d=DataArrayInt()
11460         d.pushBackValsSilent([4,5,6])
11461         self.assertTrue(d.isEqual(DataArrayInt([4,5,6])))
11462         e=DataArrayInt([1,2,3],1,3)
11463         for t in e: d.pushBackValsSilent(t)
11464         self.assertTrue(d.isEqual(DataArrayInt([4,5,6,1,2,3])))
11465         d.pushBackValsSilent(DataArrayInt([9,10]))
11466         self.assertTrue(d.isEqual(DataArrayInt([4,5,6,1,2,3,9,10])))
11467         d.pushBackValsSilent(DataArrayInt(0,1))
11468         self.assertTrue(d.isEqual(DataArrayInt([4,5,6,1,2,3,9,10])))
11469         e=DataArrayInt([1,2,3],3,1)
11470         for t in e: d.pushBackValsSilent(t)
11471         self.assertTrue(d.isEqual(DataArrayInt([4,5,6,1,2,3,9,10,1,2,3])))
11472         d.pushBackValsSilent(77)
11473         self.assertTrue(d.isEqual(DataArrayInt([4,5,6,1,2,3,9,10,1,2,3,77])))
11474         pass
11475
11476     def testSwig2ConvertLinearCellsToQuadratic2(self):
11477         m2D=MEDCouplingDataForTest.build2DTargetMesh_1()
11478         ret=m2D.convertLinearCellsToQuadratic(1)
11479         self.assertTrue(ret.isIdentity())
11480         self.assertEqual(5,len(ret))
11481         m2D.checkCoherency1()
11482         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)
11483         self.assertTrue(m2D.getCoords().isEqual(coordsExp,1e-14))
11484         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])))
11485         self.assertTrue(m2D.getNodalConnectivityIndex().isEqual(DataArrayInt([0,10,18,26,36,46])))
11486         #
11487         m2D=MEDCouplingDataForTest.build2DTargetMesh_1()[(0,3)] ; m2D.zipCoords()
11488         m2D.changeSpaceDimension(3)
11489         arr=DataArrayDouble(3);  arr.iota(0) ; z=MEDCouplingCMesh() ; z.setCoords(arr)
11490         m1D=z.buildUnstructured() ; m1D.setCoords(arr.changeNbOfComponents(3,0.))
11491         m1D.getCoords()[:]=m1D.getCoords()[:,[1,2,0]]
11492         cooTmp=m2D.getCoords()[:]
11493         m3D=m2D.buildExtrudedMesh(m1D,0)
11494         ret=m3D.convertLinearCellsToQuadratic(1)
11495         self.assertTrue(ret.isIdentity())
11496         self.assertEqual(4,len(ret))
11497         m3D.checkCoherency1()
11498         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)
11499         self.assertTrue(m3D.getCoords().isEqual(coordsExp2,1e-14))
11500         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])))
11501         self.assertTrue(m3D.getNodalConnectivityIndex().isEqual(DataArrayInt([0,28,56,84,112])))
11502         pass
11503
11504     def testSwig2GaussNEIntegral1(self):
11505         m2D=MEDCouplingDataForTest.build2DTargetMesh_1()
11506         m0=m2D[0] ; m0.zipCoords()
11507         m1=m2D[[1,2]] ; m1.zipCoords()
11508         m2=m2D[[3,4]] ; m2.zipCoords()
11509         m0.convertLinearCellsToQuadratic(1)
11510         m1.convertLinearCellsToQuadratic(0)
11511         m2.convertLinearCellsToQuadratic(1)
11512         m=MEDCouplingUMesh.MergeUMeshes([m0,m1,m2])
11513         m.mergeNodes(1e-12)
11514         f=MEDCouplingFieldDouble(ON_GAUSS_NE)
11515         f.setMesh(m)
11516         arr=DataArrayDouble([1.1,2.2,3.3,4.4,5.5,6.6,7.7,8.8,9.9,
11517                              11.1,12.2,13.3,14.4,15.5,16.6,
11518                              21.1,22.2,23.3,24.4,25.5,26.6,
11519                              31.1,32.2,33.3,34.4,35.5,36.6,37.7,38.8,39.9,
11520                              41.1,42.2,43.3,44.4,45.5,46.6,47.7,48.8,49.9])
11521         arr2=DataArrayDouble(len(arr),2)
11522         arr2[:,0]=arr ; arr2[:,1]=arr+100
11523         f.setArray(arr2)
11524         f.checkCoherency()
11525         res=f.integral(False)
11526         # a=25./81 ; b=40./81 ; c=64./81
11527         # p1=0.11169079483905 ; p2=0.0549758718227661
11528         # 1st compo
11529         # 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
11530         # c1=(p2*(11.1+12.2+13.3)+p1*(14.4+15.5+16.6))*0.125/0.4999999999854482 ; c1=1.8014347172346943
11531         # c2=(p2*(21.1+22.2+23.3)+p1*(24.4+25.5+26.6))*0.125/0.4999999999854482 ; c2=3.0514347172346943
11532         # 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
11533         # 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
11534         # c0+c1+c2+c3+c4=27.104258323358287
11535         integExp0=27.104258323358287
11536         self.assertAlmostEqual(res[0],integExp0,13)
11537         # 2nd compo
11538         # 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
11539         # c1=(p2*(111.1+112.2+113.3)+p1*(114.4+115.5+116.6))*0.125/0.4999999999854482 ; c1=14.301434717234699
11540         # c2=(p2*(121.1+122.2+123.3)+p1*(124.4+125.5+126.6))*0.125/0.4999999999854482 ; c2=15.5514347172347
11541         # 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
11542         # 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
11543         # c0+c1+c2+c3+c4=127.10425832335835
11544         integExp1=127.10425832335835
11545         self.assertAlmostEqual(res[1],integExp1,12)
11546         meas=f.getDiscretization().getMeasureField(f.getMesh(),False)
11547         intPerTuple=meas*f
11548         res2=intPerTuple.accumulate()
11549         self.assertAlmostEqual(res2[0],integExp0,13)
11550         self.assertAlmostEqual(res2[1],integExp1,12)
11551         #
11552         meas2=f.buildMeasureField(False)
11553         intPerTuple=meas2*f
11554         res3=intPerTuple.accumulate()
11555         self.assertAlmostEqual(res3[0],integExp0,13)
11556         self.assertAlmostEqual(res3[1],integExp1,12)
11557         #
11558         res4=f.getWeightedAverageValue(False) # res4==res2 because sum of area of mesh is equal to 1
11559         self.assertAlmostEqual(res4[0],integExp0,13)
11560         self.assertAlmostEqual(res4[1],integExp1,12)
11561         #
11562         m.scale([0,0],2.)
11563         #
11564         res5=f.getWeightedAverageValue() # res4==res4 because weighted average is not sensitive to the scaling
11565         self.assertAlmostEqual(res5[0],integExp0,13)
11566         self.assertAlmostEqual(res5[1],integExp1,12)
11567         meas3=f.buildMeasureField(False)
11568         delta=4*meas2.getArray()-meas3.getArray()
11569         delta.abs()
11570         self.assertTrue(delta.isUniform(0.,1e-16))
11571         res6=f.integral(False)
11572         self.assertAlmostEqual(res6[0],4.*integExp0,12)
11573         self.assertAlmostEqual(res6[1],4.*integExp1,11)
11574         pass
11575
11576     def testSwig2SlowDADFindClosestTupleId(self):
11577         nbPts=[10,]
11578         for nbPt in nbPts:
11579             d=DataArrayDouble(nbPt) ; d.iota() ; d*=1./(nbPt-1)
11580             c=MEDCouplingCMesh() ; c.setCoords(d,d) ; m=c.buildUnstructured() ; pts=m.getCoords() ; del m
11581             #
11582             d0=DataArrayDouble((nbPt-1)*(nbPt-1)) ; d0.iota() ; d0*=(3./((nbPt-1)*(nbPt-1))) ; d0=d0.applyFunc("exp(x)-1")
11583             d1=DataArrayDouble((nbPt-1)*(nbPt-1)) ; d1.iota()
11584             d2=DataArrayDouble.Meld(d0,d1) ; d2=d2.fromPolarToCart() ; d2+=[0.32,0.73]
11585             ids=pts.findClosestTupleId(d2)
11586             #print "Start of costly computation"
11587             idsExpected=DataArrayInt(len(d2))
11588             tmp=1e300
11589             for i,elt in enumerate(d2):
11590                 l,m=(pts-elt).magnitude().getMinValue()
11591                 idsExpected.setIJSilent(i,0,m)
11592                 if l<tmp:
11593                     tmp=l ; tmp1=m ; tmp2=i
11594                     pass
11595                 pass
11596             #print "End of costly computation"
11597             self.assertTrue(idsExpected.isEqual(ids))
11598             a,b,c=pts.minimalDistanceTo(d2)
11599             self.assertEqual(tmp,a)
11600             self.assertEqual(tmp1,b)
11601             self.assertEqual(tmp2,c)
11602             #
11603             l=[d2[:,i] for i in [0,1]]
11604             for elt in l: elt.reverse()
11605             d2i=DataArrayDouble.Meld(l)
11606             ids1=pts.findClosestTupleId(d2i)
11607             idsExpectedI=idsExpected.deepCpy() ; idsExpectedI.reverse()
11608             self.assertTrue(idsExpectedI.isEqual(ids1))
11609             #
11610             l=[pts[:,i] for i in [0,1]]
11611             for elt in l: elt.reverse()
11612             ptsi=DataArrayDouble.Meld(l)
11613             ids2=ptsi.findClosestTupleId(d2)
11614             idsExpected2=nbPt*nbPt-1-ids
11615             self.assertTrue(idsExpected2.isEqual(ids2))
11616             #
11617             ids3=ptsi.findClosestTupleId(d2i)
11618             idsExpected3=idsExpected2.deepCpy() ; idsExpected3.reverse()
11619             self.assertTrue(idsExpected3.isEqual(ids3))
11620             pass
11621
11622     def testSwig2DataArrayAsciiChar1(self):
11623         alpha=DataArrayInt(26) ; alpha.iota(ord("A"))
11624         d=DataArrayAsciiChar(alpha.getValues(),2,13)
11625         d.setInfoOnComponents(["c%i"%(v) for v in xrange(13)])
11626         self.assertEqual('ABCDEFGHIJKLM',d.getTuple(0))
11627         self.assertEqual('NOPQRSTUVWXYZ',d.getTuple(1))
11628         self.assertEqual(2,d.getNumberOfTuples())
11629         self.assertEqual(26,d.getNbOfElems())
11630         self.assertEqual(13,d.getNumberOfComponents())
11631         dd=d.deepCpy()
11632         self.assertTrue(d.isEqual(dd))
11633         dd.setIJ(0,3,'d')
11634         self.assertTrue(not d.isEqual(dd))
11635         d.setIJ(0,3,ord('d'))
11636         self.assertTrue(d.isEqual(dd))
11637         d.rearrange(1)
11638         d.reserve(20)
11639         self.assertEqual(20,d.getNumberOfTuples())
11640         self.assertEqual(20,d.getNbOfElems())
11641         self.assertEqual(1,d.getNumberOfComponents())
11642         #
11643         d0=DataArrayAsciiChar([ord('a')],1,1)
11644         self.assertEqual('a',d0.asciiCharValue())
11645         self.assertTrue(not d0.empty())
11646         d0=DataArrayAsciiChar(0,3)
11647         self.assertTrue(d0.empty())
11648         d.pushBackSilent("U") ; d.pushBackSilent("V") ; d.pushBackSilent("W")
11649         self.assertEqual("W",d.popBackSilent())
11650         d.rearrange(2)
11651         self.assertEqual(['AB','Cd','EF','GH','IJ','KL','MN','OP','QR','ST','UV'],d.toStrList())
11652         d.fillWithZero()
11653         self.assertEqual(11*[''],d.toStrList())
11654         d.fillWithValue('T')
11655         self.assertEqual(11*["TT"],d.toStrList())
11656         d.rearrange(1)
11657         self.assertTrue(d.isUniform("T"))
11658         d.rearrange(2)
11659         #
11660         dd.rearrange(2)
11661         dd2=dd.deepCpy()
11662         dd.renumberInPlace([3,1,2,4,0,11,10,9,8,7,5,12,6])
11663         self.assertEqual(dd.toStrList(),['IJ','Cd','EF','AB','GH','UV','YZ','ST','QR','OP','MN','KL','WX'])
11664         dd.renumberInPlaceR([3,1,2,4,0,11,10,9,8,7,5,12,6])
11665         self.assertEqual(['AB','Cd','EF','GH','IJ','KL','MN','OP','QR','ST','UV','WX','YZ'],dd.toStrList())
11666         e=dd.renumber([3,1,2,4,0,11,10,9,8,7,5,12,6])
11667         self.assertEqual(e.toStrList(),['IJ','Cd','EF','AB','GH','UV','YZ','ST','QR','OP','MN','KL','WX'])
11668         e=dd.renumberR([3,1,2,4,0,11,10,9,8,7,5,12,6])
11669         self.assertEqual(e.toStrList(),['GH','Cd','EF','IJ','AB','WX','UV','ST','QR','OP','KL','YZ','MN'])
11670         e=dd.renumberAndReduce([1,1,1,1,1,1,1,2,0,0,0,0,0],3)
11671         self.assertEqual(['YZ','MN','OP'],e.toStrList())
11672         self.assertEqual(['GH','IJ'],dd.selectByTupleIdSafe([3,4]).toStrList())
11673         self.assertEqual(['AB','GH','MN','ST','YZ'],dd.selectByTupleId2(0,13,3).toStrList())
11674         dd3=dd.changeNbOfComponents(3,"G")
11675         self.assertEqual(['ABG','CdG','EFG','GHG','IJG','KLG','MNG','OPG','QRG','STG','UVG','WXG','YZG'],dd3.toStrList())
11676         dd3.rearrange(1) ; self.assertEqual("G",dd3.back()) ; dd3.rearrange(3)
11677         self.assertTrue(dd3.changeNbOfComponents(2,"\0").isEqual(dd))
11678         self.assertEqual(len(dd),13)
11679         d=DataArrayAsciiChar(13,2) ; d.fillWithValue('Y')
11680         dd3.meldWith(d)
11681         self.assertEqual(['ABGYY','CdGYY','EFGYY','GHGYY','IJGYY','KLGYY','MNGYY','OPGYY','QRGYY','STGYY','UVGYY','WXGYY','YZGYY'],dd3.toStrList())
11682         self.assertEqual("d",dd3.getIJ(0,6))
11683         self.assertRaises(InterpKernelException,dd3.getIJSafe,0,6)
11684         self.assertEqual("d",dd3.getIJSafe(1,1))
11685         dd3.rearrange(1)
11686         e=dd3.getIdsEqual("Y")
11687         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])))
11688         e=dd3.getIdsNotEqual("Y")
11689         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])))
11690         self.assertEqual(("d",6),dd3.getMaxValue())
11691         self.assertEqual(("A",0),dd3.getMinValue())
11692         self.assertEqual(26,dd3.search("LGYYM"))
11693         self.assertEqual(-1,dd3.search("LGYYN"))
11694         dd3.rearrange(5)
11695         self.assertEqual(7,dd3.locateTuple("OPGYY"))
11696         self.assertTrue("OPGYY" in dd3)
11697         self.assertEqual(7,dd3.index("OPGYY"))
11698         self.assertEqual(-1,dd3.locateTuple("OPGYP"))
11699         dd3.rearrange(1)
11700         self.assertEqual(2,dd3.locateValue("OPGYY"))
11701         self.assertTrue(dd3.presenceOfValue("OPGYY"))
11702         self.assertTrue("O" in dd3)
11703         self.assertTrue(not dd3.presenceOfValue("z"))
11704         self.assertTrue("z" not in dd3)
11705         dd3.rearrange(5)
11706         l=list(dd3)
11707         self.assertEqual([e.buildDAAsciiChar().toStrList()[0] for e in list(dd3)],dd3.toStrList())
11708         dd3.reAlloc(5)
11709         dd4=DataArrayChar.Aggregate(dd3,dd3)
11710         self.assertEqual(['ABGYY','CdGYY','EFGYY','GHGYY','IJGYY','ABGYY','CdGYY','EFGYY','GHGYY','IJGYY'],dd4.toStrList())
11711         dd5=DataArrayChar.Aggregate([dd4,dd3,dd4])
11712         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())
11713         # getitem,__iter__,__setitem__
11714         a=list(dd3)
11715         self.assertEqual("ABGYY",str(a[0]))
11716         dd4=dd3[::2]
11717         self.assertEqual(['ABGYY','EFGYY','IJGYY'],dd4.toStrList())
11718         dd4=dd3[(3,2,1)]
11719         self.assertEqual(['GHGYY','EFGYY','CdGYY'],dd4.toStrList())
11720         dd4=dd3[:]
11721         dd4[::2]=["12","345","67890"]
11722         self.assertEqual(['12   ','CdGYY','345  ','GHGYY','67890'],dd4.toStrList())
11723         dd4=dd3[:]
11724         dd4[[1,2]]=" "
11725         self.assertEqual(['ABGYY','     ','     ','GHGYY','IJGYY'],dd4.toStrList())
11726         dd4=dd3[:]
11727         dd4[4]='12345'
11728         self.assertEqual(['ABGYY','CdGYY','EFGYY','GHGYY','12345'],dd4.toStrList())
11729         dd4[0]=dd4[1]
11730         self.assertEqual(['CdGYY','CdGYY','EFGYY','GHGYY','12345'],dd4.toStrList())
11731         dd4=DataArrayAsciiChar(["abc","de","fghi"])
11732         self.assertEqual(['abc ','de  ','fghi'],dd4.toStrList())
11733         dd4=DataArrayAsciiChar(["abc","de","fghi"],"t")
11734         self.assertEqual(['abct','dett','fghi'],dd4.toStrList())
11735         pass
11736
11737     def testSwig2GaussNELocalizationOfDiscValues(self):
11738         m=MEDCouplingDataForTest.build2DTargetMesh_3()[[0,1,3,4,5,6,8,9]] # suppression of polygons
11739         f=MEDCouplingFieldDouble(ON_GAUSS_NE)
11740         f.setMesh(m)
11741         loc=f.getLocalizationOfDiscr()
11742         self.assertEqual(42,len(loc))
11743         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))
11744         m.changeSpaceDimension(3)
11745         m.getCoords()[:,2]=7.
11746         loc=f.getLocalizationOfDiscr()
11747         self.assertEqual(42,len(loc))
11748         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))
11749         pass
11750
11751     def testSwig2GaussMeasureAndIntegral(self):
11752         ft=MEDCouplingDataForTest.buildFieldOnGauss_1()
11753         mea=ft.buildMeasureField(False)
11754         mea.checkCoherency()
11755         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))
11756         f=MEDCouplingFieldDouble(ft)
11757         arr=DataArrayDouble(126,2)
11758         arr[:,0]=range(126)
11759         arr[:,1]=range(126)
11760         arr[:,1]+=1000
11761         f.setArray(arr)
11762         f.checkCoherency()
11763         self.assertTrue(DataArrayDouble(f.integral(False)).isEqual(DataArrayDouble([-211.66121638700983,-4863.9563007698835]),1e-11))
11764         self.assertTrue(DataArrayDouble(f.getWeightedAverageValue()).isEqual(DataArrayDouble([45.496085813113595,1045.496085813114]),1e-11))
11765         self.assertTrue(DataArrayDouble(f.normL1()).isEqual(DataArrayDouble([45.49608581311362,1045.496085813114]),1e-11))
11766         self.assertTrue(DataArrayDouble(f.normL2()).isEqual(DataArrayDouble([58.16846378340898,1046.1241521947334]),1e-11))
11767         pass
11768
11769     def testSwig2FieldDiscretizationComputeMeshRestrictionFromTupleIds1(self):
11770         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1()
11771         f=MEDCouplingFieldDouble(ON_GAUSS_NE)
11772         f.setMesh(m)
11773         a,b=f.getDiscretization().computeMeshRestrictionFromTupleIds(f.getMesh(),[3,4,5,6,8,9,10,14,15,16,17])
11774         self.assertTrue(a.isEqual(DataArrayInt([1,4])))
11775         self.assertTrue(b.isEqual(DataArrayInt([4,5,6,14,15,16,17])))
11776         a,b=f.getDiscretization().computeMeshRestrictionFromTupleIds(f.getMesh(),DataArrayInt([0,1,2,3,5,7,8,9,10,11,12,18]))
11777         self.assertTrue(a.isEqual(DataArrayInt([0,2])))
11778         self.assertTrue(b.isEqual(DataArrayInt([0,1,2,3,7,8,9])))
11779         #
11780         f=MEDCouplingFieldDouble(ON_CELLS)
11781         f.setMesh(m)
11782         a,b=f.getDiscretization().computeMeshRestrictionFromTupleIds(f.getMesh(),[3,4])
11783         self.assertTrue(a.isEqual(DataArrayInt([3,4])))
11784         self.assertTrue(b.isEqual(DataArrayInt([3,4])))
11785         #
11786         f=MEDCouplingFieldDouble(ON_NODES)
11787         f.setMesh(m)
11788         a,b=f.getDiscretization().computeMeshRestrictionFromTupleIds(f.getMesh(),[1,2,3,4])
11789         self.assertTrue(a.isEqual(DataArrayInt([1])))
11790         self.assertTrue(b.isEqual(DataArrayInt([1,2,4])))
11791         #
11792         f=MEDCouplingDataForTest.buildFieldOnGauss_1()
11793         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])
11794         self.assertTrue(a.isEqual(DataArrayInt([0,11,12,18,35])))
11795         self.assertTrue(b.isEqual(DataArrayInt([0,11,12,13,14,15,36,37,38,117,118,119,120,121,122,123,124,125])))
11796         #
11797         d=DataArrayInt([0,3,7,9,15,18])
11798         e=DataArrayInt([0,1,2,3,7,8,15,16,17])
11799         a,b=d.searchRangesInListOfIds(e)
11800         self.assertTrue(a.isEqual(DataArrayInt([0,2,4])))
11801         self.assertTrue(b.isEqual(DataArrayInt([0,1,2,7,8,15,16,17])))
11802         pass
11803
11804     def testSwig2BigMem(self):
11805         if MEDCouplingSizeOfVoidStar()==64:
11806             d=DataArrayAsciiChar(223456789,16)
11807             self.assertTrue(d.getNumberOfTuples(),223456789)
11808             self.assertTrue(d.getNumberOfComponents(),16)
11809             d.setIJ(223456788,5,"r")
11810             self.assertTrue(d.getIJ(223456788,5),'r')
11811             d[223456787]="1234567890123456"
11812             self.assertTrue(d[223456787],'1234567890123456')
11813             self.assertRaises(InterpKernelException,d.rearrange,1)# fails because it would lead to nb of tuples > 2147483647
11814             pass
11815         pass
11816
11817     def testSwig2DAReverseMultiCompo1(self):
11818         d=DataArrayDouble(6,2)
11819         d[:,0]=range(6)
11820         d[:,1]=range(10,16)
11821         d.reverse()
11822         self.assertTrue(d.isEqual(DataArrayDouble([5.,15.,4.,14.,3.,13.,2.,12.,1.,11.,0.,10.],6,2),1e-14))
11823         d=DataArrayDouble(7,2)
11824         d[:,0]=range(7)
11825         d[:,1]=range(10,17)
11826         d.reverse()
11827         self.assertTrue(d.isEqual(DataArrayDouble([6.,16.,5.,15.,4.,14.,3.,13.,2.,12.,1.,11.,0.,10.],7,2),1e-14))
11828         #
11829         d=DataArrayInt(6,2)
11830         d[:,0]=range(6)
11831         d[:,1]=range(10,16)
11832         d.reverse()
11833         self.assertTrue(d.isEqual(DataArrayInt([5,15,4,14,3,13,2,12,1,11,0,10],6,2)))
11834         d=DataArrayInt(7,2)
11835         d[:,0]=range(7)
11836         d[:,1]=range(10,17)
11837         d.reverse()
11838         self.assertTrue(d.isEqual(DataArrayInt([6,16,5,15,4,14,3,13,2,12,1,11,0,10],7,2)))
11839         pass
11840
11841     def testSwigDAPow1(self):
11842         d=DataArrayInt(10)
11843         d.iota(0)
11844         d1=d.deepCpy()
11845         d.setIJ(2,0,-2)
11846         self.assertTrue((d**2).isEqual(DataArrayInt([0,1,4,9,16,25,36,49,64,81])))
11847         self.assertTrue((d**3).isEqual(DataArrayInt([0,1,-8,27,64,125,216,343,512,729])))
11848         for elt in [d]:
11849             elt**=2
11850             pass
11851         self.assertTrue(d.isEqual(DataArrayInt([0,1,4,9,16,25,36,49,64,81])))
11852         self.assertTrue((d1[:4]**d1[:4]).isEqual(DataArrayInt([1,1,4,27])))
11853         self.assertTrue((3**d1[:4]).isEqual(DataArrayInt([1,3,9,27])))
11854         d2=d1[:4]
11855         d2**=d2
11856         self.assertTrue(d2.isEqual(DataArrayInt([1,1,4,27])))
11857         self.assertRaises(InterpKernelException,d2.__pow__,-1)#non supporting negative pow in DataArrayInt.__pow__
11858         self.assertRaises(InterpKernelException,d2.__ipow__,-1)#non supporting negative pow in DataArrayInt.__pow__
11859         #
11860         d=DataArrayDouble(10)
11861         d.iota(0)
11862         d1=d.deepCpy()
11863         d.setIJ(2,0,-2.)
11864         self.assertTrue((d**2).isEqual(DataArrayDouble([0,1,4,9,16,25,36,49,64,81]),1e-12))
11865         self.assertTrue((d**3).isEqual(DataArrayDouble([0,1,-8,27,64,125,216,343,512,729]),1e-12))
11866         self.assertRaises(InterpKernelException,d.__pow__,3.1)#3.1 is double not integer -> not supporting negative values in d
11867         for elt in [d]:
11868             elt**=2
11869             pass
11870         self.assertTrue(d.isEqual(DataArrayDouble([0,1,4,9,16,25,36,49,64,81]),1e-12))
11871         self.assertTrue((d1[:4]**d1[:4]).isEqual(DataArrayDouble([1,1,4,27]),1e-12))
11872         self.assertTrue((3**d1[:4]).isEqual(DataArrayDouble([1,3,9,27]),1e-12))
11873         d2=d1[:4]
11874         d2**=d2
11875         self.assertTrue(d2.isEqual(DataArrayDouble([1,1,4,27]),1e-12))
11876         d2**=-0.5
11877         self.assertTrue(d2.isEqual(DataArrayDouble([1,1,1./2,1./sqrt(27.)]),1e-14))
11878         d3=-1./d1[1:5]
11879         self.assertTrue((3**d3).isEqual(DataArrayDouble([0.3333333333333333,0.5773502691896257,0.6933612743506348,0.7598356856515925]),1e-14))
11880         d4=d3.deepCpy() ; d4.abs()
11881         self.assertTrue((d4**d3).isEqual(DataArrayDouble([1.,sqrt(2.),1.4422495703074083,sqrt(2.)]),1e-14))
11882         d4**=d3
11883         self.assertTrue(d4.isEqual(DataArrayDouble([1.,sqrt(2.),1.4422495703074083,sqrt(2.)]),1e-14))
11884         pass
11885
11886     def testSwig2Baryenter3DForCellsWithVolumeZero1(self):
11887         coo=DataArrayDouble([0.,0.,0.,1.,0.,0.,0.,1.,0.],3,3)
11888         m2=MEDCouplingUMesh("mesh",2)
11889         m2.allocateCells(0)
11890         m2.insertNextCell(NORM_POLYGON,[0,1,2])
11891         m2.setCoords(coo)
11892         m2.checkCoherency1()
11893         #
11894         coo2=DataArrayDouble([0.,0.,0.,0.,0.,0.,0.,0.,2.],3,3)
11895         m1=MEDCouplingUMesh("mesh",1)
11896         m1.allocateCells(0)
11897         m1.insertNextCell(NORM_SEG2,[0,1])
11898         m1.insertNextCell(NORM_SEG2,[1,2])
11899         m1.setCoords(coo2)
11900         m1.checkCoherency1()
11901         #
11902         m3=m2.buildExtrudedMesh(m1,0)
11903         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
11904         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))
11905         m4,a,b,c,d=m3.buildDescendingConnectivity()
11906         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))
11907         pass
11908
11909     def testSwigRepr1(self):
11910         d=DataArrayDouble()
11911         self.assertTrue(len(d.__repr__())<120)
11912         d.alloc(1000,0) ; self.assertTrue(len(d.__repr__())<100)
11913         for i in xrange(100):
11914             d.alloc(i,1) ; d.iota(1.1234567890123456) ; d*=1e123
11915             self.assertTrue(len(d.__repr__())<500)
11916             pass
11917         for i in xrange(50):
11918             d.alloc(i,2) ; d.rearrange(1) ; d.iota(1.1234567890123456) ; d.rearrange(2) ; d*=1e123
11919             self.assertTrue(len(d.__repr__())<500)
11920             pass
11921         d.alloc(4000,1) ; d.iota() ; self.assertTrue(len(d.__repr__())<500)
11922         for i in xrange(2,4):
11923             d.alloc(362880,1) ; d.iota() ; d.rearrange(i) ; self.assertTrue(len(d.__repr__())<500)
11924             pass
11925         d.alloc(0,9)
11926         self.assertTrue(len(d.__repr__())<120)
11927         #
11928         d=DataArrayInt()
11929         self.assertTrue(len(d.__repr__())<100)
11930         d.alloc(1000,0) ; self.assertTrue(len(d.__repr__())<100)
11931         for i in xrange(100):
11932             d.alloc(i,1) ; d.iota(123456789)
11933             self.assertTrue(len(d.__repr__())<500)
11934             pass
11935         for i in xrange(50):
11936             d.alloc(i,2) ; d.rearrange(1) ; d.iota(123456789) ; d.rearrange(2)
11937             self.assertTrue(len(d.__repr__())<500)
11938             pass
11939         d.alloc(4000,1) ; d.iota() ; self.assertTrue(len(d.__repr__())<500)
11940         for i in xrange(2,10):
11941             d.alloc(362880,1) ; d.iota() ; d.rearrange(i) ; self.assertTrue(len(d.__repr__())<500)
11942             pass
11943         d.alloc(0,9)
11944         self.assertTrue(len(d.__repr__())<100)
11945         #
11946         d=DataArrayAsciiChar()
11947         d.alloc(1000,0) ; self.assertTrue(len(d.__repr__())<100)
11948         d.alloc(2,16) ; d[:]='1234567890ABCDEF'
11949         self.assertTrue(len(d.__repr__())<500)
11950         d.alloc(2000,16) ; d[:]='1234567890ABCDEF'
11951         self.assertTrue(len(d.__repr__())<500)
11952         d.alloc(0,16) ; d[:]='1234567890ABCDEF'
11953         self.assertTrue(len(d.__repr__())<120)
11954         #
11955         d=DataArrayByte()
11956         self.assertTrue(len(d.__repr__())<100)
11957         d.alloc(1000,0) ; self.assertTrue(len(d.__repr__())<100)
11958         d.alloc(0,16) ; self.assertTrue(len(d.__repr__())<100)
11959         d.alloc(5,1) ; d.fillWithValue(127)
11960         self.assertTrue(len(d.__repr__())<200)
11961         d.alloc(1000,1) ; d.fillWithValue(127)
11962         self.assertTrue(len(d.__repr__())<500)
11963         d.alloc(1000,3) ; d.fillWithValue(127)
11964         self.assertTrue(len(d.__repr__())<500)
11965         pass
11966
11967     def testSwig2MeshComputeIsoBarycenterOfNodesPerCell1(self):
11968         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)
11969         m=MEDCouplingUMesh.New("toto",3)
11970         m.allocateCells(0)
11971         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])
11972         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])
11973         m.setCoords(coo)
11974         m.checkCoherency1()
11975         #
11976         dReference=DataArrayDouble([(34.900130952189848,0.,200),(17.450065476094931,30.2244,200.)])
11977         self.assertTrue(m.computeIsoBarycenterOfNodesPerCell().isEqual(dReference,1e-12))
11978         m.getNodalConnectivity().setIJ(87,0,24)
11979         self.assertRaises(InterpKernelException,m.computeIsoBarycenterOfNodesPerCell)
11980         m.getNodalConnectivity().setIJ(87,0,-2)
11981         self.assertRaises(InterpKernelException,m.computeIsoBarycenterOfNodesPerCell)
11982         m.getNodalConnectivity().setIJ(87,0,21)# put again 21 as at the beginning
11983         #
11984         self.assertTrue(m.unPolyze())
11985         self.assertEqual([NORM_HEXGP12],m.getAllGeoTypes())
11986         self.assertTrue(m.computeIsoBarycenterOfNodesPerCell().isEqual(dReference,1e-12))
11987         m.getNodalConnectivity().setIJ(25,0,24)
11988         self.assertRaises(InterpKernelException,m.computeIsoBarycenterOfNodesPerCell)
11989         m.getNodalConnectivity().setIJ(25,0,-1)
11990         self.assertRaises(InterpKernelException,m.computeIsoBarycenterOfNodesPerCell)
11991         pass
11992
11993     def testSwig2NonRegressionBugDescHexa20(self):
11994         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)
11995         m=MEDCouplingUMesh('mesh',3)
11996         m.allocateCells(0)
11997         m.insertNextCell(NORM_HEXA20,[0,3,5,1,12,18,16,14,7,4,6,2,19,17,15,13,8,11,10,9])
11998         m.setCoords(coo)
11999         m.checkCoherency1()
12000         #
12001         a,b,c,d,e=m.buildDescendingConnectivity()
12002         m2=MEDCouplingUMesh('mesh',2)
12003         m2.allocateCells(0)
12004         m2.setCoords(coo)
12005         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]]
12006         for i in xrange(6):
12007             m2.insertNextCell(NORM_QUAD8,conn2[i])
12008             pass
12009         self.assertTrue(m2.isEqual(a,1e-12))
12010         self.assertTrue(b.isEqual(DataArrayInt([0,1,2,3,4,5])))
12011         self.assertTrue(c.isEqual(DataArrayInt([0,6])))
12012         self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,0,0])))
12013         self.assertTrue(e.isEqual(DataArrayInt([0,1,2,3,4,5,6])))
12014         #
12015         m.convertQuadraticCellsToLinear() ; m.zipCoords()
12016         m.convertLinearCellsToQuadratic(1)
12017         #
12018         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)
12019         m3=MEDCouplingUMesh("mesh",3)
12020         m3.allocateCells(1)
12021         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])
12022         m3.setCoords(coo2)
12023         self.assertTrue(m3.isEqual(m,1e-12))
12024         #
12025         a,b,c,d,e=m.buildDescendingConnectivity()
12026         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]]
12027         m4=MEDCouplingUMesh("mesh",2)
12028         m4.allocateCells(0)
12029         for i in xrange(6):
12030             m4.insertNextCell(NORM_QUAD9,conn4[i])
12031             pass
12032         m4.setCoords(coo2)
12033         self.assertTrue(m4.isEqual(a,1e-12))
12034         self.assertTrue(b.isEqual(DataArrayInt([0,1,2,3,4,5])))
12035         self.assertTrue(c.isEqual(DataArrayInt([0,6])))
12036         self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,0,0])))
12037         self.assertTrue(e.isEqual(DataArrayInt([0,1,2,3,4,5,6])))
12038         pass
12039
12040     def testSwigAdvGauss(self):
12041         f=MEDCouplingFieldTemplate(ON_GAUSS_PT)
12042         f.setDiscretization(None)
12043         f.__repr__() ; f.__str__()
12044         #
12045         f=MEDCouplingFieldTemplate(ON_GAUSS_PT)
12046         d=f.getDiscretization()
12047         i=DataArrayInt() ; i.alloc(10,1) ; i.iota(1)
12048         d.setArrayOfDiscIds(i)
12049         f.__repr__() ; f.__str__()
12050         i2=d.getArrayOfDiscIds()
12051         self.assertEqual(i.__repr__(),i2.__repr__())
12052         #
12053         f=MEDCouplingFieldDouble(ON_GAUSS_PT)
12054         f.setDiscretization(None)
12055         f.__repr__() ; f.__str__()
12056         #
12057         f=MEDCouplingFieldDouble(ON_GAUSS_PT)
12058         d=f.getDiscretization()
12059         i=DataArrayInt() ; i.alloc(10,1) ; i.iota(1)
12060         d.setArrayOfDiscIds(i)
12061         f.__repr__() ; f.__str__()
12062         #
12063         gl=MEDCouplingGaussLocalization(NORM_SEG2,[0,1],[0.5],[1.])
12064         gl.setWeights([3.])
12065         gl.__repr__() ; gl.__str__()
12066         gl=MEDCouplingGaussLocalization(NORM_ERROR)
12067         gl.setWeights([3.])
12068         gl.__repr__() ; gl.__str__()
12069         pass
12070
12071     def testSwig2NonRegressionBugSubstractInPlaceDM(self):
12072         m0=MEDCouplingCMesh()
12073         arr=DataArrayDouble(5,1) ; arr.iota(0.)
12074         m0.setCoords(arr,arr)
12075         m0=m0.buildUnstructured()
12076         m00=m0[::2] ; m00.simplexize(0) ; m01=m0[1::2]
12077         m0=MEDCouplingUMesh.MergeUMeshes([m00,m01])
12078         m0.getCoords()[:]*=1/4.
12079         m0.setName("mesh")
12080         #
12081         NodeField=MEDCouplingFieldDouble(ON_NODES,ONE_TIME) ; NodeField.setTime(5.6,5,6) ; NodeField.setMesh(m0)
12082         NodeField.setName("NodeField")
12083         NodeField.fillFromAnalytic(1,"exp(-((x-1)*(x-1)+(y-1)*(y-1)))") ; NodeField.getArray().setInfoOnComponent(0,"powernode [W]")
12084         proc0=m0.getCellsInBoundingBox([(0.,0.4),(0.,0.4)],1e-10)
12085         proc1=proc0.buildComplement(m0.getNumberOfCells())
12086         #
12087         NodeField0=NodeField[proc0] ; NodeField0.getMesh().setName(m0.getName())
12088         NodeField1=NodeField[proc1] ; NodeField1.getMesh().setName(m0.getName())
12089         #
12090         NodeField_read=MEDCouplingFieldDouble.MergeFields([NodeField0,NodeField1])
12091         NodeField_read.mergeNodes(1e-10)
12092         NodeFieldCpy=NodeField.deepCpy()
12093         NodeFieldCpy.mergeNodes(1e-10)
12094         NodeField.checkCoherency()
12095         self.assertTrue(not NodeField.getArray().isUniform(0.,1e-12))
12096         NodeField.substractInPlaceDM(NodeField_read,10,1e-12)
12097         self.assertTrue(NodeField.getArray().isUniform(0.,1e-12))
12098         pass
12099
12100     def testSwigFieldOperationOpen1(self):
12101         ## MEDCouplingFieldDouble.__add__
12102         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12103         f=MEDCouplingFieldDouble(ON_CELLS)
12104         f.setMesh(m)
12105         arr=DataArrayDouble(5,2)
12106         arr[:,0]=range(5) ; arr[:,1]=2*arr[:,0]
12107         f2=f.clone(True)
12108         self.assertRaises(InterpKernelException,f.__add__,2)
12109         self.assertRaises(InterpKernelException,f.__add__,range(5))
12110         self.assertRaises(InterpKernelException,f.__add__,arr)
12111         self.assertRaises(InterpKernelException,f.__add__,f2)
12112         f.setArray(DataArrayDouble())
12113         self.assertRaises(InterpKernelException,f.__add__,2)
12114         self.assertRaises(InterpKernelException,f.__add__,range(5))
12115         self.assertRaises(InterpKernelException,f.__add__,arr)
12116         self.assertRaises(InterpKernelException,f.__add__,f2)
12117         self.assertRaises(InterpKernelException,f.__getitem__,(slice(None),0))
12118         f.getArray().alloc(5,2)
12119         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
12120         ff=f+2
12121         ff.checkCoherency()
12122         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(2,9),(3,10),(4,11),(5,12),(6,13)]),1e-12))
12123         ff=f+arr
12124         ff.checkCoherency()
12125         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,7),(2,10),(4,13),(6,16),(8,19)]),1e-12))
12126         self.assertRaises(InterpKernelException,f.__add__,f2)
12127         f2.setArray(arr)
12128         ff=f+f2
12129         ff.checkCoherency()
12130         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,7),(2,10),(4,13),(6,16),(8,19)]),1e-12))
12131         ff=f+[5,8]
12132         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(5,15),(6,16),(7,17),(8,18),(9,19)]),1e-12))
12133         ### MEDCouplingFieldDouble.__sub__
12134         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12135         f=MEDCouplingFieldDouble(ON_CELLS)
12136         f.setMesh(m)
12137         arr=DataArrayDouble(5,2)
12138         arr[:,0]=range(5) ; arr[:,1]=2*arr[:,0]
12139         f2=f.clone(True)
12140         self.assertRaises(InterpKernelException,f.__sub__,2)
12141         self.assertRaises(InterpKernelException,f.__sub__,range(5))
12142         self.assertRaises(InterpKernelException,f.__sub__,arr)
12143         self.assertRaises(InterpKernelException,f.__sub__,f2)
12144         f.setArray(DataArrayDouble())
12145         self.assertRaises(InterpKernelException,f.__sub__,2)
12146         self.assertRaises(InterpKernelException,f.__sub__,range(5))
12147         self.assertRaises(InterpKernelException,f.__sub__,arr)
12148         self.assertRaises(InterpKernelException,f.__sub__,f2)
12149         self.assertRaises(InterpKernelException,f.__getitem__,(slice(None),0))
12150         f.getArray().alloc(5,2)
12151         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
12152         ff=f-2
12153         ff.checkCoherency()
12154         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(-2,5),(-1,6),(0,7),(1,8),(2,9)]),1e-12))
12155         ff=f-arr
12156         ff.checkCoherency()
12157         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,7),(0,6),(0,5),(0,4),(0,3)]),1e-12))
12158         self.assertRaises(InterpKernelException,f.__sub__,f2)
12159         f2.setArray(arr)
12160         ff=f-f2
12161         ff.checkCoherency()
12162         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,7),(0,6),(0,5),(0,4),(0,3)]),1e-12))
12163         ff=f-[5,8]
12164         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(-5,-1),(-4,0),(-3,1),(-2,2),(-1,3)]),1e-12))
12165         ### MEDCouplingFieldDouble.__mul__
12166         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12167         f=MEDCouplingFieldDouble(ON_CELLS)
12168         f.setMesh(m)
12169         arr=DataArrayDouble(5,2)
12170         arr[:,0]=range(5) ; arr[:,1]=2*arr[:,0]
12171         f2=f.clone(True)
12172         self.assertRaises(InterpKernelException,f.__mul__,2)
12173         self.assertRaises(InterpKernelException,f.__mul__,range(5))
12174         self.assertRaises(InterpKernelException,f.__mul__,arr)
12175         self.assertRaises(InterpKernelException,f.__mul__,f2)
12176         f.setArray(DataArrayDouble())
12177         self.assertRaises(InterpKernelException,f.__mul__,2)
12178         self.assertRaises(InterpKernelException,f.__mul__,range(5))
12179         self.assertRaises(InterpKernelException,f.__mul__,arr)
12180         self.assertRaises(InterpKernelException,f.__mul__,f2)
12181         self.assertRaises(InterpKernelException,f.__getitem__,(slice(None),0))
12182         f.getArray().alloc(5,2)
12183         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
12184         ff=f*2
12185         ff.checkCoherency()
12186         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,14),(2,16),(4,18),(6,20),(8,22)]),1e-12))
12187         ff=f*arr
12188         ff.checkCoherency()
12189         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,0),(1,16),(4,36),(9,60),(16,88)]),1e-12))
12190         self.assertRaises(InterpKernelException,f.__mul__,f2)
12191         f2.setArray(arr)
12192         ff=f*f2
12193         ff.checkCoherency()
12194         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,0),(1,16),(4,36),(9,60),(16,88)]),1e-12))
12195         ff=f*[5,8]
12196         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,56),(5,64),(10,72),(15,80),(20,88)]),1e-12))
12197         ### MEDCouplingFieldDouble.__div__
12198         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12199         f=MEDCouplingFieldDouble(ON_CELLS)
12200         f.setMesh(m)
12201         arr=DataArrayDouble(5,2)
12202         arr[:,0]=range(1,6) ; arr[:,1]=2*arr[:,0]
12203         f2=f.clone(True)
12204         self.assertRaises(InterpKernelException,f.__div__,2)
12205         self.assertRaises(InterpKernelException,f.__div__,range(5))
12206         self.assertRaises(InterpKernelException,f.__div__,arr)
12207         self.assertRaises(InterpKernelException,f.__div__,f2)
12208         f.setArray(DataArrayDouble())
12209         self.assertRaises(InterpKernelException,f.__div__,2)
12210         self.assertRaises(InterpKernelException,f.__div__,range(5))
12211         self.assertRaises(InterpKernelException,f.__div__,arr)
12212         self.assertRaises(InterpKernelException,f.__div__,f2)
12213         self.assertRaises(InterpKernelException,f.__getitem__,(slice(None),0))
12214         f.getArray().alloc(5,2)
12215         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
12216         self.assertRaises(InterpKernelException,f.__div__,0)
12217         ff=f/2
12218         ff.checkCoherency()
12219         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,3.5),(0.5,4),(1,4.5),(1.5,5),(2,5.5)]),1e-12))
12220         ff=f/arr
12221         ff.checkCoherency()
12222         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))
12223         self.assertRaises(InterpKernelException,f.__div__,f2)
12224         f2.setArray(arr)
12225         ff=f/f2
12226         ff.checkCoherency()
12227         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))
12228         ff=f/[5,8]
12229         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))
12230         ### MEDCouplingFieldDouble.__pow__
12231         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12232         f=MEDCouplingFieldDouble(ON_CELLS)
12233         f.setMesh(m)
12234         arr=DataArrayDouble(5)
12235         arr[:]=[1,1,3,2,0]
12236         f2=f.clone(True)
12237         self.assertRaises(InterpKernelException,f.__div__,2)
12238         self.assertRaises(InterpKernelException,f.__div__,range(5))
12239         self.assertRaises(InterpKernelException,f.__div__,arr)
12240         self.assertRaises(InterpKernelException,f.__div__,f2)
12241         f.setArray(DataArrayDouble())
12242         self.assertRaises(InterpKernelException,f.__div__,2)
12243         self.assertRaises(InterpKernelException,f.__div__,range(5))
12244         self.assertRaises(InterpKernelException,f.__div__,arr)
12245         self.assertRaises(InterpKernelException,f.__div__,f2)
12246         self.assertRaises(InterpKernelException,f.__getitem__,(slice(None),0))
12247         f.getArray().alloc(5,1)
12248         f.getArray()[:]=range(2,7)
12249         ff=f**2
12250         ff.checkCoherency()
12251         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([4,9,16,25,36]),1e-12))
12252         ff=f**arr
12253         ff.checkCoherency()
12254         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([2,3,64,25,1]),1e-12))
12255         f2.setArray(arr)
12256         ff=f**f2
12257         ff.checkCoherency()
12258         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([2,3,64,25,1]),1e-12))
12259         ## MEDCouplingFieldDouble.__iadd__
12260         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12261         f=MEDCouplingFieldDouble(ON_CELLS)
12262         f.setMesh(m)
12263         arr=DataArrayDouble(5,2)
12264         arr[:,0]=range(5) ; arr[:,1]=2*arr[:,0]
12265         f2=f.clone(True)
12266         self.assertRaises(InterpKernelException,f.__iadd__,2)
12267         self.assertRaises(InterpKernelException,f.__iadd__,range(5))
12268         self.assertRaises(InterpKernelException,f.__iadd__,arr)
12269         self.assertRaises(InterpKernelException,f.__iadd__,f2)
12270         f.setArray(DataArrayDouble())
12271         self.assertRaises(InterpKernelException,f.__iadd__,2)
12272         self.assertRaises(InterpKernelException,f.__iadd__,range(5))
12273         self.assertRaises(InterpKernelException,f.__iadd__,arr)
12274         self.assertRaises(InterpKernelException,f.__iadd__,f2)
12275         f.getArray().alloc(5,2)
12276         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
12277         f.checkCoherency()
12278         f+=2
12279         f.checkCoherency()
12280         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(2,9),(3,10),(4,11),(5,12),(6,13)]),1e-12))
12281         f+=arr
12282         f.checkCoherency()
12283         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(2,9),(4,12),(6,15),(8,18),(10,21)]),1e-12))
12284         f2.setArray(arr)
12285         f+=f2
12286         f.checkCoherency()
12287         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(2,9),(5,14),(8,19),(11,24),(14,29)]),1e-12))
12288         f+=[0.1,0.2]
12289         f.checkCoherency()
12290         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))
12291         ## MEDCouplingFieldDouble.__isub__
12292         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12293         f=MEDCouplingFieldDouble(ON_CELLS)
12294         f.setMesh(m)
12295         arr=DataArrayDouble(5,2)
12296         arr[:,0]=range(5) ; arr[:,1]=2*arr[:,0]
12297         f2=f.clone(True)
12298         self.assertRaises(InterpKernelException,f.__isub__,2)
12299         self.assertRaises(InterpKernelException,f.__isub__,range(5))
12300         self.assertRaises(InterpKernelException,f.__isub__,arr)
12301         self.assertRaises(InterpKernelException,f.__isub__,f2)
12302         f.setArray(DataArrayDouble())
12303         self.assertRaises(InterpKernelException,f.__isub__,2)
12304         self.assertRaises(InterpKernelException,f.__isub__,range(5))
12305         self.assertRaises(InterpKernelException,f.__isub__,arr)
12306         self.assertRaises(InterpKernelException,f.__isub__,f2)
12307         f.getArray().alloc(5,2)
12308         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
12309         f.checkCoherency()
12310         f-=2
12311         f.checkCoherency()
12312         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(-2,5),(-1,6),(0,7),(1,8),(2,9)]),1e-12))
12313         f-=arr
12314         f.checkCoherency()
12315         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(-2,5),(-2,4),(-2,3),(-2,2),(-2,1)]),1e-12))
12316         f2.setArray(arr)
12317         f-=f2
12318         f.checkCoherency()
12319         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(-2,5),(-3,2),(-4,-1),(-5,-4),(-6,-7)]),1e-12))
12320         f-=[0.1,0.2]
12321         f.checkCoherency()
12322         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))
12323         ## MEDCouplingFieldDouble.__imul__
12324         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12325         f=MEDCouplingFieldDouble(ON_CELLS)
12326         f.setMesh(m)
12327         arr=DataArrayDouble(5,2)
12328         arr[:,0]=range(5) ; arr[:,1]=2*arr[:,0]
12329         f2=f.clone(True)
12330         self.assertRaises(InterpKernelException,f.__imul__,2)
12331         self.assertRaises(InterpKernelException,f.__imul__,range(5))
12332         self.assertRaises(InterpKernelException,f.__imul__,arr)
12333         self.assertRaises(InterpKernelException,f.__imul__,f2)
12334         f.setArray(DataArrayDouble())
12335         self.assertRaises(InterpKernelException,f.__imul__,2)
12336         self.assertRaises(InterpKernelException,f.__imul__,range(5))
12337         self.assertRaises(InterpKernelException,f.__imul__,arr)
12338         self.assertRaises(InterpKernelException,f.__imul__,f2)
12339         f.getArray().alloc(5,2)
12340         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
12341         f.checkCoherency()
12342         f*=2
12343         f.checkCoherency()
12344         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(0,14),(2,16),(4,18),(6,20),(8,22)]),1e-12))
12345         f*=arr
12346         f.checkCoherency()
12347         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(0,0),(2,32),(8,72),(18,120),(32,176)]),1e-12))
12348         f2.setArray(arr)
12349         f*=f2
12350         f.checkCoherency()
12351         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(0,0),(2,64),(16,288),(54,720),(128,1408)]),1e-12))
12352         f*=[0.1,0.2]
12353         f.checkCoherency()
12354         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))
12355         ## MEDCouplingFieldDouble.__idiv__
12356         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12357         f=MEDCouplingFieldDouble(ON_CELLS)
12358         f.setMesh(m)
12359         arr=DataArrayDouble(5,2)
12360         arr[:,0]=range(1,6) ; arr[:,1]=2*arr[:,0]
12361         f2=f.clone(True)
12362         self.assertRaises(InterpKernelException,f.__idiv__,2)
12363         self.assertRaises(InterpKernelException,f.__idiv__,range(5))
12364         self.assertRaises(InterpKernelException,f.__idiv__,arr)
12365         self.assertRaises(InterpKernelException,f.__idiv__,f2)
12366         f.setArray(DataArrayDouble())
12367         self.assertRaises(InterpKernelException,f.__idiv__,2)
12368         self.assertRaises(InterpKernelException,f.__idiv__,range(5))
12369         self.assertRaises(InterpKernelException,f.__idiv__,arr)
12370         self.assertRaises(InterpKernelException,f.__idiv__,f2)
12371         f.getArray().alloc(5,2)
12372         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
12373         f.checkCoherency()
12374         f/=2
12375         f.checkCoherency()
12376         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(0,3.5),(0.5,4),(1,4.5),(1.5,5),(2,5.5)]),1e-12))
12377         f/=arr
12378         f.checkCoherency()
12379         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))
12380         f2.setArray(arr)
12381         f/=f2
12382         f.checkCoherency()
12383         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))
12384         f/=[0.1,0.2]
12385         f.checkCoherency()
12386         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))
12387         ## MEDCouplingFieldDouble.__ipow__
12388         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12389         f=MEDCouplingFieldDouble(ON_CELLS)
12390         f.setMesh(m)
12391         arr=DataArrayDouble(5,2)
12392         arr[:,0]=range(1,6) ; arr[:,1]=2*arr[:,0]
12393         f2=f.clone(True)
12394         self.assertRaises(InterpKernelException,f.__ipow__,2)
12395         self.assertRaises(InterpKernelException,f.__ipow__,range(5))
12396         self.assertRaises(InterpKernelException,f.__ipow__,arr)
12397         self.assertRaises(InterpKernelException,f.__ipow__,f2)
12398         f.setArray(DataArrayDouble())
12399         self.assertRaises(InterpKernelException,f.__ipow__,2)
12400         self.assertRaises(InterpKernelException,f.__ipow__,range(5))
12401         self.assertRaises(InterpKernelException,f.__ipow__,arr)
12402         self.assertRaises(InterpKernelException,f.__ipow__,f2)
12403         f.getArray().alloc(5,2)
12404         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
12405         f.checkCoherency()
12406         f**=2
12407         f.checkCoherency()
12408         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(0,49),(1,64),(4,81),(9,100),(16,121)]),1e-12))
12409          ## MEDCouplingFieldDouble.__radd__
12410         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12411         f=MEDCouplingFieldDouble(ON_CELLS)
12412         f.setMesh(m)
12413         arr=DataArrayDouble(5,2)
12414         arr[:,0]=range(5) ; arr[:,1]=2*arr[:,0]
12415         f2=f.clone(True)
12416         self.assertRaises(InterpKernelException,f.__radd__,2)
12417         self.assertRaises(InterpKernelException,f.__radd__,range(5))
12418         self.assertRaises(InterpKernelException,f.__radd__,arr)
12419         self.assertRaises(InterpKernelException,f.__radd__,f2)
12420         f.setArray(DataArrayDouble())
12421         self.assertRaises(InterpKernelException,f.__radd__,2)
12422         self.assertRaises(InterpKernelException,f.__radd__,range(5))
12423         self.assertRaises(InterpKernelException,f.__radd__,arr)
12424         self.assertRaises(InterpKernelException,f.__radd__,f2)
12425         self.assertRaises(InterpKernelException,f.__getitem__,(slice(None),0))
12426         f.getArray().alloc(5,2)
12427         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
12428         ff=2+f
12429         ff.checkCoherency()
12430         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(2,9),(3,10),(4,11),(5,12),(6,13)]),1e-12))
12431         ff=arr+f
12432         ff.checkCoherency()
12433         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,7),(2,10),(4,13),(6,16),(8,19)]),1e-12))
12434         self.assertRaises(InterpKernelException,f.__radd__,f2)
12435         ff=[5,8]+f
12436         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(5,15),(6,16),(7,17),(8,18),(9,19)]),1e-12))
12437         ### MEDCouplingFieldDouble.__rsub__
12438         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12439         f=MEDCouplingFieldDouble(ON_CELLS)
12440         f.setMesh(m)
12441         arr=DataArrayDouble(5,2)
12442         arr[:,0]=range(5) ; arr[:,1]=2*arr[:,0]
12443         f2=f.clone(True)
12444         self.assertRaises(InterpKernelException,f.__rsub__,2)
12445         self.assertRaises(InterpKernelException,f.__rsub__,range(5))
12446         self.assertRaises(InterpKernelException,f.__rsub__,arr)
12447         self.assertRaises(InterpKernelException,f.__rsub__,f2)
12448         f.setArray(DataArrayDouble())
12449         self.assertRaises(InterpKernelException,f.__rsub__,2)
12450         self.assertRaises(InterpKernelException,f.__rsub__,range(5))
12451         self.assertRaises(InterpKernelException,f.__rsub__,arr)
12452         self.assertRaises(InterpKernelException,f.__rsub__,f2)
12453         self.assertRaises(InterpKernelException,f.__getitem__,(slice(None),0))
12454         f.getArray().alloc(5,2)
12455         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
12456         ff=2-f
12457         ff.checkCoherency()
12458         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(2,-5),(1,-6),(0,-7),(-1,-8),(-2,-9)]),1e-12))
12459         ff=arr-f
12460         ff.checkCoherency()
12461         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,-7),(0,-6),(0,-5),(0,-4),(0,-3)]),1e-12))
12462         self.assertRaises(InterpKernelException,f.__rsub__,f2)
12463         ### MEDCouplingFieldDouble.__rmul__
12464         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12465         f=MEDCouplingFieldDouble(ON_CELLS)
12466         f.setMesh(m)
12467         arr=DataArrayDouble(5,2)
12468         arr[:,0]=range(5) ; arr[:,1]=2*arr[:,0]
12469         f2=f.clone(True)
12470         self.assertRaises(InterpKernelException,f.__rmul__,2)
12471         self.assertRaises(InterpKernelException,f.__rmul__,range(5))
12472         self.assertRaises(InterpKernelException,f.__rmul__,arr)
12473         self.assertRaises(InterpKernelException,f.__rmul__,f2)
12474         f.setArray(DataArrayDouble())
12475         self.assertRaises(InterpKernelException,f.__rmul__,2)
12476         self.assertRaises(InterpKernelException,f.__rmul__,range(5))
12477         self.assertRaises(InterpKernelException,f.__rmul__,arr)
12478         self.assertRaises(InterpKernelException,f.__rmul__,f2)
12479         self.assertRaises(InterpKernelException,f.__getitem__,(slice(None),0))
12480         f.getArray().alloc(5,2)
12481         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
12482         ff=2*f
12483         ff.checkCoherency()
12484         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,14),(2,16),(4,18),(6,20),(8,22)]),1e-12))
12485         ff=arr*f
12486         ff.checkCoherency()
12487         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,0),(1,16),(4,36),(9,60),(16,88)]),1e-12))
12488         self.assertRaises(InterpKernelException,f.__rmul__,f2)
12489         ff=f*[5,8]
12490         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,56),(5,64),(10,72),(15,80),(20,88)]),1e-12))
12491         ### MEDCouplingFieldDouble.__rdiv__
12492         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12493         f=MEDCouplingFieldDouble(ON_CELLS)
12494         f.setMesh(m)
12495         arr=DataArrayDouble(5,2)
12496         arr[:,0]=range(1,6) ; arr[:,1]=2*arr[:,0]
12497         f2=f.clone(True)
12498         self.assertRaises(InterpKernelException,f.__rdiv__,2)
12499         self.assertRaises(InterpKernelException,f.__rdiv__,range(5))
12500         self.assertRaises(InterpKernelException,f.__rdiv__,arr)
12501         self.assertRaises(InterpKernelException,f.__rdiv__,f2)
12502         f.setArray(DataArrayDouble())
12503         self.assertRaises(InterpKernelException,f.__rdiv__,2)
12504         self.assertRaises(InterpKernelException,f.__rdiv__,range(5))
12505         self.assertRaises(InterpKernelException,f.__rdiv__,arr)
12506         self.assertRaises(InterpKernelException,f.__rdiv__,f2)
12507         self.assertRaises(InterpKernelException,f.__getitem__,(slice(None),0))
12508         f.getArray().alloc(5,2)
12509         f.getArray()[:,0]=range(1,6) ; f.getArray()[:,1]=f.getArray()[:,0]+7
12510         ff=2/f
12511         ff.checkCoherency()
12512         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))
12513         ff=arr/f
12514         ff.checkCoherency()
12515         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(1,0.25),(1,0.44444444444444442),(1,0.59999999999999998),(1,0.72727272727272729),(1,0.83333333333333337)]),1e-12))
12516         self.assertRaises(InterpKernelException,f.__rdiv__,f2)
12517         pass
12518
12519     def testSwig2FieldDoubleBuildSubPartRange1(self):
12520         #ON_CELLS
12521         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12522         f=MEDCouplingFieldDouble(ON_CELLS)
12523         f.setMesh(m)
12524         arr=DataArrayDouble(5,2) ; arr[:,0]=range(7,12) ; arr[:,1]=100+arr[:,0]
12525         f.setArray(arr)
12526         f.checkCoherency()
12527         ff=f[1:-1:2]
12528         ff.checkCoherency()
12529         self.assertTrue((m.buildPartOfMySelf([1,3],True)).isEqual(ff.getMesh(),1e-12))
12530         self.assertTrue(9,ff.getMesh().getNumberOfNodes())
12531         self.assertTrue(2,ff.getMesh().getNumberOfCells())
12532         self.assertTrue(ff.getArray().isEqual(arr[[1,3]],1e-12))
12533         #
12534         a,b=f.buildSubMeshDataRange(2,5,1)
12535         self.assertTrue(m.buildPartOfMySelf([2,3,4],True).isEqual(a,1e-12))
12536         self.assertEqual(b,slice(2,5,1))
12537         ff=f[2:]
12538         ff.checkCoherency()
12539         self.assertTrue((m.buildPartOfMySelf([2,3,4],True)).isEqual(ff.getMesh(),1e-12))
12540         self.assertTrue(9,ff.getMesh().getNumberOfNodes())
12541         self.assertTrue(3,ff.getMesh().getNumberOfCells())
12542         self.assertTrue(ff.getArray().isEqual(arr[[2,3,4]],1e-12))
12543         #
12544         ff=f[-2:0:-1]
12545         ff.checkCoherency()
12546         self.assertTrue((m.buildPartOfMySelf([3,2,1],True)).isEqual(ff.getMesh(),1e-12))
12547         self.assertTrue(9,ff.getMesh().getNumberOfNodes())
12548         self.assertTrue(3,ff.getMesh().getNumberOfCells())
12549         self.assertTrue(ff.getArray().isEqual(arr[[3,2,1]],1e-12))
12550         self.assertTrue(f[-2:0:-1,1].getArray().isEqual(arr[[3,2,1],1],1e-12))
12551         #ON_NODES
12552         f=MEDCouplingFieldDouble(ON_NODES)
12553         f.setMesh(m)
12554         arr=DataArrayDouble(9,2) ; arr[:,0]=range(7,16) ; arr[:,1]=100+arr[:,0]
12555         f.setArray(arr)
12556         f.checkCoherency()
12557         ff=f[1:-1:2]
12558         ff.checkCoherency()
12559         self.assertTrue((m.buildPartOfMySelf([1,3],False)).isEqual(ff.getMesh(),1e-12))
12560         self.assertTrue(6,ff.getMesh().getNumberOfNodes())
12561         self.assertTrue(2,ff.getMesh().getNumberOfCells())
12562         self.assertTrue(ff.getArray().isEqual(arr[[1,2,3,4,6,7]],1e-12))
12563         #
12564         m2=m.buildPartRange(2,5,1)
12565         self.assertTrue(m.buildPartOfMySelf([2,3,4],True).isEqual(m2,1e-12))
12566         m2,b=m.buildPartRangeAndReduceNodes(2,5,1)
12567         self.assertTrue(m.buildPartOfMySelf([2,3,4],False).isEqual(m2,1e-12))
12568         self.assertTrue(b.isEqual(DataArrayInt([-1,-1,0,1,2,3,4,5,6])))
12569         a,b=f.buildSubMeshDataRange(2,5,1)
12570         self.assertTrue(m.buildPartOfMySelf([2,3,4],False).isEqual(a,1e-12))
12571         self.assertTrue(b.isEqual(DataArrayInt([2,3,4,5,6,7,8])))
12572         ff=f[2:]
12573         ff.checkCoherency()
12574         self.assertTrue((m.buildPartOfMySelf([2,3,4],False)).isEqual(ff.getMesh(),1e-12))
12575         self.assertTrue(7,ff.getMesh().getNumberOfNodes())
12576         self.assertTrue(3,ff.getMesh().getNumberOfCells())
12577         self.assertTrue(ff.getArray().isEqual(arr[[2,3,4,5,6,7,8]],1e-12))
12578         #
12579         ff=f[-2:0:-1]
12580         ff.checkCoherency()
12581         self.assertTrue((m.buildPartOfMySelf([3,2,1],False)).isEqual(ff.getMesh(),1e-12))
12582         self.assertTrue(7,ff.getMesh().getNumberOfNodes())
12583         self.assertTrue(3,ff.getMesh().getNumberOfCells())
12584         self.assertTrue(ff.getArray().isEqual(arr[[1,2,3,4,5,6,7]],1e-12))
12585         self.assertTrue(f[-2:0:-1,1].getArray().isEqual(arr[[1,2,3,4,5,6,7],1],1e-12))
12586         #ON_GAUSS_NE
12587         f=MEDCouplingFieldDouble(ON_GAUSS_NE)
12588         f.setMesh(m)
12589         arr=DataArrayDouble(18,2) ; arr[:,0]=range(7,25) ; arr[:,1]=100+arr[:,0]
12590         f.setArray(arr)
12591         f.checkCoherency()
12592         ff=f[1:-1:2]
12593         ff.checkCoherency()
12594         self.assertTrue((m.buildPartOfMySelf([1,3],True)).isEqual(ff.getMesh(),1e-12))
12595         self.assertTrue(9,ff.getMesh().getNumberOfNodes())
12596         self.assertTrue(2,ff.getMesh().getNumberOfCells())
12597         self.assertTrue(ff.getArray().isEqual(arr[[4,5,6,10,11,12,13]],1e-12))
12598         #
12599         a,b=f.buildSubMeshDataRange(2,5,1)
12600         self.assertTrue(m.buildPartOfMySelf([2,3,4],True).isEqual(a,1e-12))
12601         self.assertEqual(b,slice(7,18,1))
12602         ff=f[2:]
12603         ff.checkCoherency()
12604         self.assertTrue((m.buildPartOfMySelf([2,3,4],True)).isEqual(ff.getMesh(),1e-12))
12605         self.assertTrue(9,ff.getMesh().getNumberOfNodes())
12606         self.assertTrue(3,ff.getMesh().getNumberOfCells())
12607         self.assertTrue(ff.getArray().isEqual(arr[[7,8,9,10,11,12,13,14,15,16,17]],1e-12))
12608         #
12609         ff=f[-2:0:-1]
12610         ff.checkCoherency()
12611         self.assertTrue((m.buildPartOfMySelf([3,2,1],True)).isEqual(ff.getMesh(),1e-12))
12612         self.assertTrue(9,ff.getMesh().getNumberOfNodes())
12613         self.assertTrue(3,ff.getMesh().getNumberOfCells())
12614         self.assertTrue(ff.getArray().isEqual(arr[[10,11,12,13,7,8,9,4,5,6]],1e-12))
12615         self.assertTrue(f[-2:0:-1,1].getArray().isEqual(arr[[10,11,12,13,7,8,9,4,5,6],1],1e-12))
12616         #ON_GAUSS_PT
12617         f=MEDCouplingFieldDouble(ON_GAUSS_PT)
12618         f.setMesh(m)
12619         f.setGaussLocalizationOnCells([0,4],[0,0,1,0,1,1,1,0],[1.1,1.1,2.2,2.2],[0.2,0.8]);
12620         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]);
12621         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]);
12622         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]);
12623         arr=DataArrayDouble(16,2) ; arr[:,0]=range(7,23) ; arr[:,1]=100+arr[:,0]
12624         f.setArray(arr)
12625         f.checkCoherency()
12626         ff=f[1:-1:2]
12627         ff.checkCoherency()
12628         self.assertTrue((m.buildPartOfMySelf([1,3],True)).isEqual(ff.getMesh(),1e-12))
12629         self.assertTrue(9,ff.getMesh().getNumberOfNodes())
12630         self.assertTrue(2,ff.getMesh().getNumberOfCells())
12631         self.assertTrue(ff.getArray().isEqual(arr[[2,3,4,5,11,12,13]],1e-12))
12632         #
12633         a,b=f.buildSubMeshDataRange(2,5,1)
12634         self.assertTrue(m.buildPartOfMySelf([2,3,4],True).isEqual(a,1e-12))
12635         self.assertEqual(b,slice(6,16,1))
12636         ff=f[2:]
12637         ff.checkCoherency()
12638         self.assertTrue((m.buildPartOfMySelf([2,3,4],True)).isEqual(ff.getMesh(),1e-12))
12639         self.assertTrue(9,ff.getMesh().getNumberOfNodes())
12640         self.assertTrue(3,ff.getMesh().getNumberOfCells())
12641         self.assertTrue(ff.getArray().isEqual(arr[[6,7,8,9,10,11,12,13,14,15]],1e-12))
12642         #
12643         ff=f[-2:0:-1]
12644         ff.checkCoherency()
12645         self.assertTrue((m.buildPartOfMySelf([3,2,1],True)).isEqual(ff.getMesh(),1e-12))
12646         self.assertTrue(9,ff.getMesh().getNumberOfNodes())
12647         self.assertTrue(3,ff.getMesh().getNumberOfCells())
12648         self.assertTrue(ff.getArray().isEqual(arr[[11,12,13,6,7,8,9,10,2,3,4,5]],1e-12))
12649         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))
12650         pass
12651
12652     def testSwig2FieldDoubleApplyFuncBug1(self):
12653         f=MEDCouplingFieldDouble(ON_CELLS)
12654         f.setMesh(MEDCouplingDataForTest.build2DTargetMesh_1())
12655         f.applyFunc(3,700.)
12656         f.checkCoherency()
12657         self.assertEqual(3,f.getArray().getNumberOfComponents())
12658         f.getArray().rearrange(1)
12659         self.assertTrue(f.getArray().isUniform(700.,1e-10))
12660         f.getArray().rearrange(3)
12661         f.checkCoherency()
12662         f.applyFunc(4,800.)
12663         f.checkCoherency()
12664         self.assertEqual(4,f.getArray().getNumberOfComponents())
12665         f.getArray().rearrange(1)
12666         self.assertTrue(f.getArray().isUniform(800.,1e-10))
12667         f.getArray().rearrange(4)
12668         f.checkCoherency()
12669         pass
12670
12671     def testSwig2ComputeTupleIdsNearTupleBug1(self):
12672         coords=[1.1,0.0, 1.1,0.0 ];
12673         coordsArr=DataArrayDouble(coords,2,2);
12674         mesh=MEDCouplingUMesh();
12675         mesh.setCoords(coordsArr);
12676         points=[1.1, 0.002]
12677         c,cI=mesh.getNodeIdsNearPoints(points,0.00185);
12678         self.assertTrue(c.isEqual(DataArrayInt([])))
12679         self.assertTrue(cI.isEqual(DataArrayInt([0,0])))
12680         c,cI=mesh.getNodeIdsNearPoints(points,0.00200000000000001);
12681         self.assertTrue(c.isEqual(DataArrayInt([0,1])))
12682         self.assertTrue(cI.isEqual(DataArrayInt([0,2])))
12683         pass
12684
12685     def testSwig2NonRegressionBugChangeUnderlyingWithZeroCells(self):
12686         coords1=[0.,1.,2.,3.]
12687         coords2=[2.,1.,0.,3.] #0 <==> #2
12688         # mesh 1
12689         mesh1=MEDCouplingUMesh.New();
12690         coordsArr=DataArrayDouble.New(coords1,4,1);
12691         mesh1.setCoords(coordsArr);
12692         mesh1.setMeshDimension(0);
12693         mesh1.allocateCells(0);
12694         mesh1.finishInsertingCells();
12695         # mesh 2
12696         mesh2=mesh1.deepCpy();
12697         coordsArr=DataArrayDouble.New(coords2,4,1);
12698         mesh2.setCoords(coordsArr);
12699         field = mesh1.fillFromAnalytic(ON_NODES,1,"x")
12700         field.checkCoherency()
12701         levOfCheck = 10
12702         field.changeUnderlyingMesh( mesh2, levOfCheck, 1e-13, 0 )
12703         self.assertTrue( field.getArray().getValues() == coords2 )
12704         pass
12705
12706     def testSwig2UMeshDistanceToMesh2(self):
12707         sz=5
12708         m=MEDCouplingCMesh()
12709         arr=DataArrayDouble(sz+1) ; arr.iota() ; arr/=sz
12710         m.setCoords(arr,arr,arr)
12711         m=m.buildUnstructured()
12712         m1=m.computeSkin()
12713         m1.zipCoords()
12714         c=m1.getCoords()[:]
12715         d=2*(c-[0.5,0.5,0.5])+[0.5,0.5,0.5]
12716         time_deb = datetime.now()
12717         #print "go.."
12718         a,b=m1.distanceToPoints(d)
12719         #print 'time spent in distanceToPoints %s ' %str(datetime.now() - time_deb)
12720         time_deb = datetime.now()
12721         a1=DataArrayDouble(len(d))
12722         b1=DataArrayInt(len(d))
12723         m1s=[m1[i] for i in xrange(m1.getNumberOfCells())]
12724         for j,pt in enumerate(d):
12725             eter=1e308
12726             fter=-1
12727             for i,miter in enumerate(m1s):
12728                 e,f=miter.distanceToPoint(pt)
12729                 self.assertEqual(0,f)
12730                 if e<eter:
12731                     eter=e ; fter=i
12732                     pass
12733                 pass
12734             a1[j]=eter
12735             b1[j]=fter
12736             pass
12737         #print 'time spent in naive distanceToPoints  %s ' %str(datetime.now() - time_deb)
12738         self.assertTrue(a.isEqual(a1,1e-12))
12739         self.assertTrue(b.isEqual(b1))
12740         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))
12741         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])))
12742         pass
12743
12744     def testSwig2NonRegressionBugDistance1(self):
12745         pt=DataArrayDouble([(8.8452994616207476,3.1547005383792515,3.1547005383792515)])
12746         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)])
12747         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])
12748         m=MEDCouplingUMesh("mesh",2)
12749         m.setCoords(coo)
12750         m.allocateCells()
12751         for i in xrange(24):
12752             m.insertNextCell(NORM_QUAD4,conn[4*i:4*i+4])
12753             pass
12754         m.checkCoherency2()
12755         m0=m[3] ; m0.zipCoords()
12756         expectedDist=0.8452994616207476
12757         a,b=m0.distanceToPoint(pt)
12758         self.assertAlmostEqual(expectedDist,a,14)
12759         self.assertEqual(0,b)
12760         #
12761         a,b=m.distanceToPoint(pt)
12762         self.assertAlmostEqual(expectedDist,a,14)
12763         self.assertEqual(3,b)
12764         #
12765         fd=MEDCouplingFieldDiscretization.New(ON_CELLS)
12766         self.assertEqual(24,fd.getNumberOfTuples(m))
12767         fd=MEDCouplingFieldDiscretization.New(ON_NODES)
12768         self.assertEqual(26,fd.getNumberOfTuples(m))
12769         pass
12770
12771     def testSwig2AreaBarySeg3Quad8Tri6QPolyg(self):
12772         #QUAD8 representing a circle of center zeBary and radius zeRadius
12773         zeBary=[5,6]
12774         zeRadius=3
12775         d=DataArrayDouble(8,2)
12776         d[:,0]=zeRadius
12777         d[:,1]=[87,-100,-170,110,5,-130,175,95] # angle in degree
12778         d[:,1]*=pi/180. # angle in radian
12779         d=d.fromPolarToCart()
12780         d+=zeBary
12781         m=MEDCouplingUMesh("quad8",2) ; m.allocateCells() ; m.insertNextCell(NORM_QUAD8,range(8)) ; m.setCoords(d)
12782         self.assertTrue(m.getBarycenterAndOwner().isEqual(DataArrayDouble(zeBary,1,2),1e-13))
12783         self.assertAlmostEqual(float(m.getMeasureField(False).getArray()),pi*zeRadius*zeRadius,12)
12784         tri32D=m.buildDescendingConnectivity()[0][0] ; tri32D.zipCoords()
12785         # spaceDim=3 QUAD8 becomes QUAD4 ... for the moment
12786         m.setCoords(m.getCoords().changeNbOfComponents(3,0.))
12787         m2=m.deepCpy()
12788         m2.convertQuadraticCellsToLinear()
12789         self.assertAlmostEqual(float(m.getMeasureField(False).getArray()),float(m2.getMeasureField(False).getArray()),12)
12790         self.assertTrue(m.getBarycenterAndOwner().isEqual(m2.getBarycenterAndOwner(),1e-13))
12791         #TRI6 representing a circle of center zeBary and radius zeRadius
12792         zeBary=[5,6]
12793         zeRadius=3
12794         d=DataArrayDouble(6,2)
12795         d[:,0]=zeRadius
12796         d[:,1]=[87,-100,110,5,175,95] # angle in degree
12797         d[:,1]*=pi/180. # angle in radian
12798         d=d.fromPolarToCart()
12799         d+=zeBary
12800         m=MEDCouplingUMesh("tri6",2) ; m.allocateCells() ; m.insertNextCell(NORM_TRI6,range(6)) ; m.setCoords(d)
12801         self.assertTrue(m.getBarycenterAndOwner().isEqual(DataArrayDouble(zeBary,1,2),1e-13))
12802         self.assertAlmostEqual(float(m.getMeasureField(False).getArray()),pi*zeRadius*zeRadius,12)
12803         # spaceDim=3 TRI6 becomes TRI3 ... for the moment
12804         m.setCoords(m.getCoords().changeNbOfComponents(3,0.))
12805         m2=m.deepCpy()
12806         m2.convertQuadraticCellsToLinear()
12807         self.assertAlmostEqual(float(m.getMeasureField(False).getArray()),float(m2.getMeasureField(False).getArray()),12)
12808         self.assertTrue(m.getBarycenterAndOwner().isEqual(m2.getBarycenterAndOwner(),1e-13))
12809         # QPOLYG representing a circle of center zeBary and radius zeRadius
12810         zeBary=[5,6]
12811         zeRadius=3
12812         d=DataArrayDouble(10,2)
12813         d[:,0]=zeRadius
12814         d[:,1]=[87,-80,-100,-170,110,5,-90,-130,175,95] # angle in degree
12815         d[:,1]*=pi/180. # angle in radian
12816         d=d.fromPolarToCart()
12817         d+=zeBary
12818         m=MEDCouplingUMesh("qpolyg",2) ; m.allocateCells() ; m.insertNextCell(NORM_QPOLYG,range(10)) ; m.setCoords(d)
12819         self.assertTrue(m.getBarycenterAndOwner().isEqual(DataArrayDouble(zeBary,1,2),1e-13))
12820         self.assertAlmostEqual(float(m.getMeasureField(False).getArray()),pi*zeRadius*zeRadius,12)
12821         # spaceDim=3 QPOLYG becomes POLYG ... for the moment
12822         m.setCoords(m.getCoords().changeNbOfComponents(3,0.))
12823         m2=m.deepCpy()
12824         m2.convertQuadraticCellsToLinear() ; m2.checkCoherency2()
12825         self.assertTrue(m2.getAllGeoTypes()==[NORM_POLYGON] and m2.getNodalConnectivity().getValues()==[5,0,1,2,3,4])
12826         self.assertAlmostEqual(float(m.getMeasureField(False).getArray()),float(m2.getMeasureField(False).getArray()),12)
12827         self.assertTrue(m.getBarycenterAndOwner().isEqual(m2.getBarycenterAndOwner(),1e-13))
12828         # TRI3
12829         self.assertAlmostEqual(float(tri32D.getMeasureField(False).getArray()),(87+100)*pi/180*zeRadius,13)
12830         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)
12831         self.assertTrue(tri32D.getBarycenterAndOwner().isEqual(exp,1e-12))
12832         # spaceDim=3 TRI3 becomes TRI2 ... for the moment
12833         tri32D.changeSpaceDimension(3)
12834         tri2=tri32D.deepCpy() ; tri2.convertQuadraticCellsToLinear()
12835         self.assertAlmostEqual(float(tri32D.getMeasureField(False).getArray()),float(tri2.getMeasureField(False).getArray()),13)
12836         self.assertTrue(tri32D.getBarycenterAndOwner().isEqual(tri2.getBarycenterAndOwner(),1e-12))
12837         tri32D.changeSpaceDimension(1)
12838         self.assertAlmostEqual(float(tri32D.getMeasureField(False).getArray()),-0.67795240172962323,12)
12839         pass
12840
12841     # this bug 5/6/2013 is swig specific
12842     def testSwigNonRegressionBugRotate3D1(self):
12843         m=MEDCouplingUMesh.New()
12844         dataArray=DataArrayDouble.New(100,3)
12845         dataArray[:]=0.
12846         dataArray[0]=[0.,1,3]
12847         m.setCoords(dataArray[0])
12848         m1=m.deepCpy()
12849         m.rotate([0.,0.,3.],[1.,0.,0.],0.5*pi)
12850         self.assertTrue(m.getCoords().isEqual(DataArrayDouble([0.,0.,4.],1,3),1e-15))
12851         #
12852         d1=DataArrayDouble([0.,0.,3.],1,3) ; d2=DataArrayDouble([1.,0.,0.],1,3)
12853         pts=[[0.,0.,3.],[(0.,0.,3.)],DataArrayDouble([0.,0.,3.],1,3),list(d1)[0]]
12854         vec=[[1.,0.,0.],[(1.,0.,0.)],DataArrayDouble([1.,0.,0.],1,3),list(d2)[0]]
12855         for p in pts:
12856             for v in vec:
12857                 m2=m1.deepCpy()
12858                 m2.rotate(p,v,0.5*pi)
12859                 self.assertTrue(m2.getCoords().isEqual(DataArrayDouble([0.,0.,4.],1,3),1e-15))
12860                 pass
12861         pass
12862
12863     def testSwig2DataArrayCount1(self):
12864         d=DataArrayInt([])
12865         self.assertEqual(0,d.getNumberOfTuples())
12866         self.assertEqual(1,d.getNumberOfComponents())
12867         self.assertEqual(0,d.count(0))
12868         self.assertEqual(0,d.count(1))
12869         self.assertEqual(0,d.count(-1))
12870         d=DataArrayInt([2,1,-2,-3,2,0,0,7,2,-2,3,0])
12871         self.assertEqual(12,d.getNumberOfTuples())
12872         self.assertEqual(1,d.getNumberOfComponents())
12873         self.assertEqual(3,d.count(0))
12874         self.assertEqual(1,d.count(1))
12875         self.assertEqual(0,d.count(-1))
12876         self.assertEqual(2,d.count(-2))
12877         self.assertEqual(3,d.count(2))
12878         e=d.getDifferentValues()
12879         f=DataArrayInt()
12880         for it in e:
12881             f.pushBackSilent(d.count(int(it)))
12882             pass
12883         self.assertEqual(12,f.accumulate()[0])
12884         #
12885         eps=1e-12
12886         d=DataArrayDouble([])
12887         self.assertEqual(0,d.getNumberOfTuples())
12888         self.assertEqual(1,d.getNumberOfComponents())
12889         self.assertEqual(0,d.count(0,eps))
12890         self.assertEqual(0,d.count(1,eps))
12891         self.assertEqual(0,d.count(-1,eps))
12892         d=DataArrayDouble([2,1,-2,-3,2,0,eps/10,7,2+eps/10,-2,3,0])
12893         self.assertEqual(12,d.getNumberOfTuples())
12894         self.assertEqual(1,d.getNumberOfComponents())
12895         self.assertEqual(3,d.count(0,eps))
12896         self.assertEqual(1,d.count(1,eps))
12897         self.assertEqual(0,d.count(-1,eps))
12898         self.assertEqual(2,d.count(-2,eps))
12899         self.assertEqual(3,d.count(2,eps))
12900         self.assertEqual(3,d.count(2,eps))
12901         self.assertEqual(2,d.count(2,eps/100))
12902         e=d.getDifferentValues(eps)
12903         f=DataArrayInt()
12904         for it in e:
12905             f.pushBackSilent(d.count(float(it),eps))
12906             pass
12907         self.assertEqual(12,f.accumulate()[0])
12908         pass
12909
12910     def testSwig2DataArrayGetSlice1(self):
12911         s=slice(2,18,1)
12912         self.assertEqual(DataArray.GetNumberOfItemGivenBESRelative(s),16)
12913         self.assertEqual(DataArray.GetNumberOfItemGivenBES(s),16)
12914         self.assertEqual(DataArray.GetSlice(s,0,4),slice(2,6,1))
12915         self.assertEqual(DataArray.GetSlice(s,1,4),slice(6,10,1))
12916         self.assertEqual(DataArray.GetSlice(s,2,4),slice(10,14,1))
12917         self.assertEqual(DataArray.GetSlice(s,3,4),slice(14,18,1))
12918         #
12919         s=slice(2,18,2)
12920         self.assertEqual(DataArray.GetNumberOfItemGivenBESRelative(s),8)
12921         self.assertEqual(DataArray.GetNumberOfItemGivenBES(s),8)
12922         self.assertEqual(DataArray.GetSlice(s,0,4),slice(2,6,2))
12923         self.assertEqual(DataArray.GetSlice(s,1,4),slice(6,10,2))
12924         self.assertEqual(DataArray.GetSlice(s,2,4),slice(10,14,2))
12925         self.assertEqual(DataArray.GetSlice(s,3,4),slice(14,18,2))
12926         #
12927         s=slice(1,18,1)
12928         self.assertEqual(DataArray.GetSlice(s,0,4),slice(1,5,1))
12929         self.assertEqual(DataArray.GetSlice(s,1,4),slice(5,9,1))
12930         self.assertEqual(DataArray.GetSlice(s,2,4),slice(9,13,1))
12931         self.assertEqual(DataArray.GetSlice(s,3,4),slice(13,18,1))# 18 not 17
12932         #
12933         s=slice(1,18,2)
12934         self.assertEqual(DataArray.GetNumberOfItemGivenBESRelative(s),9)
12935         self.assertEqual(DataArray.GetNumberOfItemGivenBES(s),9)
12936         self.assertEqual(DataArray.GetSlice(s,0,4),slice(1,5,2))
12937         self.assertEqual(DataArray.GetSlice(s,1,4),slice(5,9,2))
12938         self.assertEqual(DataArray.GetSlice(s,2,4),slice(9,13,2))
12939         self.assertEqual(DataArray.GetSlice(s,3,4),slice(13,18,2))# 18 not 17
12940         #
12941         s=slice(18,2,-1)
12942         self.assertEqual(DataArray.GetSlice(s,0,4),slice(18,14,-1))
12943         self.assertEqual(DataArray.GetSlice(s,1,4),slice(14,10,-1))
12944         self.assertEqual(DataArray.GetSlice(s,2,4),slice(10,6,-1))
12945         self.assertEqual(DataArray.GetSlice(s,3,4),slice(6,2,-1))
12946         #
12947         s=slice(18,2,-2)
12948         self.assertEqual(DataArray.GetSlice(s,0,4),slice(18,14,-2))
12949         self.assertEqual(DataArray.GetSlice(s,1,4),slice(14,10,-2))
12950         self.assertEqual(DataArray.GetSlice(s,2,4),slice(10,6,-2))
12951         self.assertEqual(DataArray.GetSlice(s,3,4),slice(6,2,-2))
12952         #
12953         s=slice(18,1,-1)
12954         self.assertEqual(DataArray.GetSlice(s,0,4),slice(18,14,-1))
12955         self.assertEqual(DataArray.GetSlice(s,1,4),slice(14,10,-1))
12956         self.assertEqual(DataArray.GetSlice(s,2,4),slice(10,6,-1))
12957         self.assertEqual(DataArray.GetSlice(s,3,4),slice(6,1,-1))# 1 not 2
12958         #
12959         s=slice(18,1,-2)
12960         self.assertEqual(DataArray.GetNumberOfItemGivenBESRelative(s),9)
12961         self.assertRaises(InterpKernelException,DataArray.GetNumberOfItemGivenBES,s)
12962         self.assertEqual(sum([DataArray.GetNumberOfItemGivenBESRelative(DataArray.GetSlice(s,i,4)) for i in xrange(4)]),DataArray.GetNumberOfItemGivenBESRelative(s))
12963         self.assertEqual(DataArray.GetSlice(s,0,4),slice(18,14,-2))
12964         self.assertEqual(DataArray.GetSlice(s,1,4),slice(14,10,-2))
12965         self.assertEqual(DataArray.GetSlice(s,2,4),slice(10,6,-2))
12966         self.assertEqual(DataArray.GetSlice(s,3,4),slice(6,1,-2))# 1 not 2
12967         self.assertRaises(InterpKernelException,DataArray.GetSlice,slice(0,None,2),0,4)
12968         #
12969         d=DataArrayInt.Range(0,18,1)
12970         s=slice(2,None,1)
12971         self.assertEqual(d.getNumberOfItemGivenBES(s),16)
12972         self.assertEqual(d.getNumberOfItemGivenBESRelative(s),16)
12973         self.assertEqual(d.getSlice(s,0,4),slice(2,6,1))
12974         self.assertEqual(d.getSlice(s,1,4),slice(6,10,1))
12975         self.assertEqual(d.getSlice(s,2,4),slice(10,14,1))
12976         self.assertEqual(d.getSlice(s,3,4),slice(14,18,1))
12977         #
12978         d=DataArrayInt.Range(0,18,1)
12979         s=slice(2,-2,1)
12980         self.assertEqual(d.getSlice(s,0,4),slice(2,5,1))
12981         self.assertEqual(d.getSlice(s,1,4),slice(5,8,1))
12982         self.assertEqual(d.getSlice(s,2,4),slice(8,11,1))
12983         self.assertEqual(d.getSlice(s,3,4),slice(11,16,1))
12984         #
12985         d=DataArrayInt.Range(0,18,1)
12986         s=slice(None,None,1)
12987         self.assertEqual(d.getSlice(s,0,4),slice(0,4,1))
12988         self.assertEqual(d.getSlice(s,1,4),slice(4,8,1))
12989         self.assertEqual(d.getSlice(s,2,4),slice(8,12,1))
12990         self.assertEqual(d.getSlice(s,3,4),slice(12,18,1))
12991         #
12992         d=DataArrayInt.Range(0,18,1)
12993         s=slice(None,2,-2)
12994         self.assertRaises(InterpKernelException,d.getNumberOfItemGivenBES,s)
12995         self.assertEqual(d.getNumberOfItemGivenBESRelative(s),8)
12996         self.assertEqual(d.getSlice(s,0,4),slice(17,13,-2))
12997         self.assertEqual(d.getSlice(s,1,4),slice(13,9,-2))
12998         self.assertEqual(d.getSlice(s,2,4),slice(9,5,-2))
12999         self.assertEqual(d.getSlice(s,3,4),slice(5,2,-2))
13000         pass
13001
13002     def testSwig2AccumulatePerChunk1(self):
13003         arr=DataArrayDouble(11) ; arr.iota()
13004         m=MEDCouplingCMesh() ; m.setCoords(arr,arr)
13005         m=m.buildUnstructured()
13006         m0=m[::2] ; ids0=m0.simplexize(0) ; m1=m[1::2]
13007         m=MEDCouplingUMesh.MergeUMeshesOnSameCoords(m0,m1) ; m.setName("mesh")
13008         m.checkConsecutiveCellTypesForMEDFileFrmt()
13009         #
13010         formula="7-sqrt((x-5.)*(x-5.)+(y-5.)*(y-5.))"
13011         f=MEDCouplingFieldDouble(ON_CELLS,ONE_TIME) ; f.setMesh(m)
13012         f.fillFromAnalytic(1,formula)
13013         f.setName("Field1") ; f.setTime(1.1,1,-1)
13014         f.checkCoherency()
13015         #
13016         arr=f.getArray()
13017         arr2=DataArrayDouble(len(arr),2) ; arr2[:,0]=arr
13018         arr2=DataArrayDouble(len(arr),2) ; arr2[:,0]=arr ; arr2[:,1]=2*arr
13019         f.setArray(arr2)
13020         f.checkCoherency()
13021         # here the compact code to obviously put field on cell to nodes
13022         rn,rni=f.getMesh().getReverseNodalConnectivity()
13023         arr2=f.getArray()[rn]
13024         arr4=arr2.accumulatePerChunck(rni)
13025         nbOfCellsSharingNodes=rni.deltaShiftIndex()
13026         arr4/=nbOfCellsSharingNodes.convertToDblArr()
13027         #
13028         maxNbCSN=nbOfCellsSharingNodes.getMaxValue()[0]
13029         arr3=DataArrayDouble(f.getMesh().getNumberOfNodes(),f.getArray().getNumberOfComponents()) ; arr3[:]=0.
13030         for i in xrange(1,maxNbCSN+1):
13031             ids=nbOfCellsSharingNodes.getIdsEqual(i)
13032             if len(ids)==0:
13033                 continue
13034             for j in range(i):
13035                 rni2=rni[ids] ; rni2+=j
13036                 arr3[ids]+=arr2[rni2]
13037                 pass
13038             arr3[ids]/=i
13039             pass
13040         fNode=MEDCouplingFieldDouble(ON_NODES,ONE_TIME) ; fNode.setMesh(m)
13041         fNode.setName("Field1Node") ; fNode.setTime(1.1,1,-1)
13042         fNode.setArray(arr3) ; fNode.checkCoherency()
13043         self.assertTrue(arr3.isEqual(arr4,1e-12))
13044         #
13045         d=DataArrayInt.Range(0,20,1)
13046         self.assertTrue(d.accumulatePerChunck([2,4,12]).isEqual(DataArrayInt([5,60])))
13047         #
13048         a=DataArrayDouble(12) ; a.iota() ; a.rearrange(3)
13049         b=DataArrayDouble(12) ; b.iota(20) ; b.rearrange(3)
13050         ids=DataArrayInt([])
13051         self.assertEqual(len(a[ids]),0)
13052         self.assertEqual(len(b[ids]),0)
13053         a2=a.deepCpy() ;  a2[ids]+=b[ids] ; self.assertTrue(a2.isEqual(a,1e-15))
13054         a2=a.deepCpy() ;  a2[ids]*=b[ids] ; self.assertTrue(a2.isEqual(a,1e-15))
13055         a2=a.deepCpy() ;  a2[ids]/=b[ids] ; self.assertTrue(a2.isEqual(a,1e-15))
13056         a2=a.deepCpy() ;  a2[ids]-=b[ids] ; self.assertTrue(a2.isEqual(a,1e-15))
13057         pass
13058
13059     def testSwig2CheckAndPreparePermutation1(self):
13060         a=DataArrayInt([10003,9999999,5,67])
13061         self.assertTrue(a.checkAndPreparePermutation().isEqual(DataArrayInt([2,3,0,1])))
13062         a=DataArrayInt([10003,-9999999,5,67])
13063         self.assertTrue(a.checkAndPreparePermutation().isEqual(DataArrayInt([3,0,1,2])))
13064         a=DataArrayInt([])
13065         self.assertTrue(a.checkAndPreparePermutation().isEqual(DataArrayInt([])))
13066         a=DataArrayInt([])
13067         a.iota();
13068         self.assertTrue(a.isEqual(DataArrayInt([])))
13069         pass
13070
13071     def testSwig21SGTUMesh1(self):
13072         m=MEDCoupling1GTUMesh.New("m",NORM_PENTA6)
13073         m.__repr__() ; m.__str__()
13074         self.assertTrue(isinstance(m,MEDCoupling1SGTUMesh))
13075         m.setCoords(DataArrayDouble(20,3))
13076         m.allocateCells()
13077         m.__repr__() ; m.__str__()
13078         m.insertNextCell([0,1,2,5,7,2])
13079         self.assertEqual(1,m.getNumberOfCells())
13080         self.assertTrue(DataArrayInt([6]).isEqual(m.computeNbOfNodesPerCell()))
13081         self.assertTrue(DataArrayInt([5]).isEqual(m.computeNbOfFacesPerCell()))
13082         m.__repr__() ; m.__str__()
13083         m.checkCoherency()
13084         m.checkCoherency2()
13085         #
13086         cm=MEDCouplingCMesh() ; cm.setName("m")
13087         arr0=DataArrayDouble(6) ; arr0.iota()
13088         arr1=DataArrayDouble([0,1])
13089         cm.setCoords(arr0,arr1,arr1) ; um=cm.buildUnstructured()
13090         #
13091         m=MEDCoupling1SGTUMesh("m",NORM_QUAD4)
13092         mem_m=m.getHeapMemorySize()
13093         m.allocateCells(5)
13094         self.assertIn(m.getHeapMemorySize()-mem_m,xrange(5*4*4,5*4*4+32))
13095         self.assertEqual(m.getNodalConnectivity().getNbOfElemAllocated(),20)
13096         m.setCoords(um.getCoords())
13097         m.insertNextCell([1,0,6,7])
13098         self.assertEqual(1,m.getNumberOfCells())
13099         m.insertNextCell([2,1,7,8])
13100         m.insertNextCell([3,2,8,9])
13101         m.insertNextCell([4,3,9,10])
13102         m.insertNextCell([5,4,10,11])
13103         self.assertEqual(5,m.getNumberOfCells())
13104         self.assertRaises(InterpKernelException,m.insertNextCell,[0,6,7])
13105         self.assertRaises(InterpKernelException,m.insertNextCell,[0,6,7,1,2])
13106         self.assertEqual(m.getNodalConnectivity().getNbOfElemAllocated(),20)
13107         f=m.getMeasureField(ON_CELLS)
13108         self.assertEqual(f.getMesh().getHiddenCppPointer(),m.getHiddenCppPointer())
13109         self.assertTrue(f.getArray().isUniform(1,1e-14))
13110         self.assertEqual(m.getType(),10)
13111         self.assertEqual(m.getCellModelEnum(),NORM_QUAD4)
13112         mo=MEDCoupling1SGTUMesh("m",NORM_QUAD4) ; mo.setCoords(m.getCoords())
13113         mo.setNodalConnectivity(DataArrayInt([1,0,6,7,2,1,7,8,3,2,8,9,4,3,9,10,5,4,10,11]))
13114         self.assertTrue(m.isEqual(mo,1e-12))
13115         #
13116         mo2=MEDCoupling1SGTUMesh.Merge1SGTUMeshesOnSameCoords([m[[0,1]],m[[2]],m[[3,4]]])
13117         mo2.setName(m.getName())
13118         self.assertTrue(m.isEqual(mo2,1e-12))
13119         #
13120         mp0=m[[0]] ; mp0.zipCoords() ; mp1=m[2] ; mp1.zipCoords() ; mp2=m[4] ; mp2.zipCoords()
13121         mo3=MEDCoupling1SGTUMesh.Merge1SGTUMeshes([mp0,mp1,mp2])
13122         self.assertTrue(isinstance(mo3,MEDCoupling1SGTUMesh))
13123         mo3.setName(m.getName())
13124         m_ref=m[(0,2,4)] ; m_ref.zipCoords()
13125         m_ref.tryToShareSameCoordsPermute(mo3,1e-12)
13126         self.assertTrue(m_ref.isEqual(mo3,1e-12))
13127         #
13128         m1=um.buildDescendingConnectivity()[0]
13129         ids=m1.getCellIdsFullyIncludedInNodeIds(DataArrayInt.Range(0,12,1))
13130         m1=m1[ids]
13131         m1c=m1.convertIntoSingleGeoTypeMesh()
13132         self.assertTrue(isinstance(m1c,MEDCoupling1SGTUMesh))
13133         self.assertEqual(m1c.getCoords().getHiddenCppPointer(),m.getCoords().getHiddenCppPointer())
13134         m1c.checkCoherency2()
13135         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])))
13136         self.assertEqual(20,m1c.getNodalConnectivityLength())
13137         self.assertTrue(m.isEqual(m1c,1e-12))
13138         m.getNodalConnectivity().setIJ(1,0,1)
13139         self.assertTrue(not m.isEqual(m1c,1e-12))
13140         m.getNodalConnectivity().setIJ(1,0,0)
13141         self.assertTrue(m.isEqual(m1c,1e-12))
13142         m1c.setCoords(m.getCoords().deepCpy())
13143         self.assertTrue(m.isEqual(m1c,1e-12))
13144         m1c.getCoords().setIJ(0,1,0.1)
13145         self.assertTrue(not m.isEqual(m1c,1e-12))
13146         m1c.getCoords().setIJ(0,1,0)
13147         self.assertTrue(m.isEqual(m1c,1e-12))
13148         m1c.getCoords().setInfoOnComponent(1,"X")
13149         self.assertTrue(not m.isEqual(m1c,1e-12) and m.isEqualWithoutConsideringStr(m1c,1e-12))
13150         m.getCoords().setInfoOnComponent(1,"X")
13151         self.assertTrue(m.isEqual(m1c,1e-12) and m.isEqualWithoutConsideringStr(m1c,1e-12))
13152         m.setName("m2")
13153         self.assertTrue(not m.isEqual(m1c,1e-12) and m.isEqualWithoutConsideringStr(m1c,1e-12))
13154         #
13155         m.checkCoherency() ; m.checkCoherency1() ; m.checkCoherency2()
13156         self.assertEqual(m.getMeshDimension(),2)
13157         self.assertTrue(m.giveCellsWithType(NORM_QUAD4).isEqual(DataArrayInt([0,1,2,3,4])))
13158         self.assertTrue(m.giveCellsWithType(NORM_TRI3).isEqual(DataArrayInt([])))
13159         self.assertEqual(m.getNumberOfCellsWithType(NORM_QUAD4),5)
13160         self.assertEqual(m.getNumberOfCellsWithType(NORM_TRI3),0)
13161         self.assertEqual(m.getTypeOfCell(3),NORM_QUAD4)
13162         self.assertRaises(InterpKernelException,m.getTypeOfCell,5)
13163         self.assertEqual(m.getAllGeoTypes(),[NORM_QUAD4])
13164         self.assertEqual(m.getDistributionOfTypes(),[[NORM_QUAD4,5,-1]])
13165         ##
13166         pfl1=DataArrayInt([1,3,4])
13167         a,b,c=m.splitProfilePerType(pfl1)
13168         d,e,f=m.buildUnstructured().splitProfilePerType(pfl1)
13169         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())
13170         self.assertTrue(a==d and len(b)==1 and b[0].isEqual(e[0]) and len(c)==1 and c[0].isEqual(f[0]))
13171         #
13172         pfl2=DataArrayInt([0,1,2,3])
13173         a,b,c=m.splitProfilePerType(pfl2)
13174         d,e,f=m.buildUnstructured().splitProfilePerType(pfl2)
13175         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())
13176         self.assertTrue(a==d and len(b)==1 and b[0].isEqual(e[0]) and len(c)==1 and c[0].isEqual(f[0]))
13177         #
13178         pfl3=DataArrayInt([0,1,2,3,4])
13179         a,b,c=m.splitProfilePerType(pfl3)
13180         d,e,f=m.buildUnstructured().splitProfilePerType(pfl3)
13181         self.assertTrue(a==[[4,5,-1]] and len(b)==1 and b[0].isEqual(DataArrayInt([0,1,2,3,4])) and c==[])
13182         self.assertTrue(a==d and len(b)==1 and b[0].isEqual(e[0]) and c==[])
13183         #
13184         invalidPfl=DataArrayInt([1,2,3,4,5])
13185         self.assertRaises(InterpKernelException,m.splitProfilePerType,invalidPfl)
13186         self.assertRaises(InterpKernelException,m.buildUnstructured().splitProfilePerType,invalidPfl)
13187         ##
13188         pfl1=DataArrayInt([1,2,3])
13189         a=m.checkTypeConsistencyAndContig([NORM_QUAD4,3,0],[pfl1])
13190         b=m.buildUnstructured().checkTypeConsistencyAndContig([NORM_QUAD4,3,0],[pfl1])
13191         self.assertTrue(a.isEqual(b) and pfl1.getHiddenCppPointer(),a.getHiddenCppPointer())
13192         #
13193         pfl2=DataArrayInt([0,1,2,3])
13194         a=m.checkTypeConsistencyAndContig([NORM_QUAD4,4,0],[pfl2])
13195         b=m.buildUnstructured().checkTypeConsistencyAndContig([NORM_QUAD4,4,0],[pfl2])
13196         self.assertTrue(a.isEqual(b) and pfl2.getHiddenCppPointer()==a.getHiddenCppPointer())
13197         #
13198         pfl3=DataArrayInt([0,1,2,3,4])
13199         a=m.checkTypeConsistencyAndContig([NORM_QUAD4,4,0],[pfl3])
13200         b=m.buildUnstructured().checkTypeConsistencyAndContig([NORM_QUAD4,5,0],[pfl3])
13201         self.assertTrue(a.isEqual(b) and pfl3.getHiddenCppPointer()==a.getHiddenCppPointer())
13202         #
13203         invalidPfl=DataArrayInt([1,2,3,4,5])
13204         self.assertRaises(InterpKernelException,m.checkTypeConsistencyAndContig,[NORM_QUAD4,5,0],[invalidPfl])
13205         self.assertRaises(InterpKernelException,m.buildUnstructured().checkTypeConsistencyAndContig,[NORM_QUAD4,5,0],[invalidPfl])
13206         ##
13207         self.assertTrue(DataArrayInt([4,4,4,4,4]).isEqual(m.computeNbOfNodesPerCell()))
13208         ##
13209         self.assertEqual(m.getNodeIdsOfCell(1),[2,1,7,8])
13210         ##
13211         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))
13212         ##
13213         ref=m.getCoords().getHiddenCppPointer()
13214         mcpy=m.deepCpy() ; mcpy.insertNextCell([1,0,6,7])
13215         c=m.getNodalConnectivity().deepCpy()
13216         o2n=DataArrayInt([2,0,1,4,3])
13217         m.renumberCells(o2n,False)
13218         c.rearrange(4) ; c.renumberInPlace(o2n) ; c.rearrange(1)
13219         self.assertTrue(c.isEqual(m.getNodalConnectivity()))
13220         self.assertEqual(ref,m.getCoords().getHiddenCppPointer())
13221         m2=mcpy.mergeMyselfWith(m)
13222         self.assertTrue(isinstance(m2,MEDCoupling1SGTUMesh))
13223         self.assertEqual(11,m2.getNumberOfCells())
13224         self.assertEqual(48,m2.getNumberOfNodes())
13225         self.assertTrue(m2.getCoords().isEqual(DataArrayDouble.Aggregate([m.getCoords(),m.getCoords()]),1e-12))
13226         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])))
13227         ##
13228         mu=m.buildUnstructured()
13229         mu.checkCoherency2()
13230         self.assertEqual(mu.getCoords().getHiddenCppPointer(),m.getCoords().getHiddenCppPointer())
13231         self.assertEqual(2,mu.getMeshDimension())
13232         self.assertEqual([NORM_QUAD4],mu.getAllGeoTypes())
13233         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])))
13234         self.assertTrue(mu.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5,10,15,20,25])))
13235         ##
13236         for typ in [0,1]:
13237             mcpy2=m.deepCpy() ; umcpy2=mcpy2.buildUnstructured()
13238             ids=mcpy2.simplexize(typ) ; ids2=umcpy2.simplexize(typ)
13239             self.assertTrue(ids.isEqual(ids2))
13240             mcpy3=umcpy2.convertIntoSingleGeoTypeMesh()
13241             self.assertTrue(mcpy2.isEqual(mcpy3,1e-14))
13242             pass
13243         um1=um.convertIntoSingleGeoTypeMesh()
13244         self.assertEqual(8,um1.getNumberOfNodesPerCell())
13245         for typ in [PLANAR_FACE_5,PLANAR_FACE_6]:
13246             mcpy2=um1.deepCpy() ; umcpy2=mcpy2.buildUnstructured()
13247             ids=mcpy2.simplexize(typ) ; ids2=umcpy2.simplexize(typ)
13248             self.assertTrue(ids.isEqual(ids2))
13249             mcpy3=umcpy2.convertIntoSingleGeoTypeMesh()
13250             self.assertTrue(mcpy2.isEqual(mcpy3,1e-14))
13251             pass
13252         ##
13253         self.assertRaises(InterpKernelException,mcpy.mergeMyselfWithOnSameCoords,m)
13254         mcpy.tryToShareSameCoords(m,1e-14)
13255         m3=mcpy.mergeMyselfWithOnSameCoords(m)
13256         self.assertTrue(isinstance(m3,MEDCoupling1SGTUMesh))
13257         self.assertEqual(11,m3.getNumberOfCells())
13258         self.assertEqual(24,m3.getNumberOfNodes())
13259         self.assertEqual(m3.getCoords().getHiddenCppPointer(),mcpy.getCoords().getHiddenCppPointer())
13260         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])))
13261         ##
13262         ref=mcpy.getCoords().deepCpy()
13263         c3=mcpy.getNodalConnectivity()[:]
13264         mcpy.getNodalConnectivity().setIJ(int(c3.getIdsEqual(11)),0,24)
13265         c2=DataArrayDouble.Aggregate([mcpy.getCoords(),mcpy.getCoords()[11:]])
13266         mcpy.setCoords(c2)
13267         mcpy.checkCoherency2()
13268         a,b=mcpy.getNodeIdsInUse()
13269         self.assertEqual(12,b)
13270         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])))
13271         ids=mcpy.zipCoordsTraducer()
13272         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])))
13273         self.assertTrue(mcpy.getCoords().isEqual(ref[:12],1e-12))
13274         self.assertTrue(mcpy.getNodalConnectivity().isEqual(c3))
13275         mcpy.checkCoherency2()
13276         ##
13277         m4=mcpy[DataArrayInt([0,3,4])]
13278         m5=mcpy.buildPartOfMySelfKeepCoords(DataArrayInt([0,3,4]))
13279         self.assertTrue(isinstance(m4,MEDCoupling1SGTUMesh))
13280         self.assertTrue(m4.isEqual(m5,-1e-14))# < 0 not a bug it proves that coordinates pointer are equal
13281         self.assertTrue(m4.getNodalConnectivity().isEqual(DataArrayInt([1,0,6,7,4,3,9,10,5,4,10,11])))
13282         m6=mcpy[::2]
13283         self.assertTrue(isinstance(m6,MEDCoupling1SGTUMesh))
13284         self.assertTrue(m6.getNodalConnectivity().isEqual(DataArrayInt([1,0,6,7,3,2,8,9,5,4,10,11])))
13285         ##
13286         mcpy.setCoords(DataArrayDouble.Aggregate([mcpy.getCoords(),mcpy.getCoords()]))
13287         mcpy.checkCoherency2()
13288         ##
13289         mcppy=mcpy.deepCpyConnectivityOnly()
13290         self.assertTrue(mcppy.isEqual(mcpy,1e-12))
13291         self.assertTrue(mcppy.getCoords().getHiddenCppPointer()==mcpy.getCoords().getHiddenCppPointer())
13292         self.assertTrue(mcppy.getNodalConnectivity().isEqual(mcpy.getNodalConnectivity()))
13293         self.assertTrue(mcppy.getNodalConnectivity().getHiddenCppPointer()!=mcpy.getNodalConnectivity().getHiddenCppPointer())
13294         ##
13295         a,b=mcpy.getReverseNodalConnectivity()
13296         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])))
13297         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])))
13298         self.assertTrue(mcpy.fillCellIdsToKeepFromNodeIds([0,1,6,7],False).isEqual(DataArrayInt([0,1,5])))
13299         self.assertTrue(mcpy.fillCellIdsToKeepFromNodeIds([0,1,6,7],True).isEqual(DataArrayInt([0,5])))
13300         self.assertTrue(mcpy.getCellsInBoundingBox([(0,1),(0,1),(0,1)],1e-12).isEqual(DataArrayInt([0,1,5])))
13301         f=mcpy.buildOrthogonalField()
13302         self.assertEqual(f.getMesh().getHiddenCppPointer(),mcpy.getHiddenCppPointer())
13303         self.assertTrue(f.getArray().isEqual(DataArrayDouble(6*[(0,0,-1)]),1e-12))
13304         mcpy.changeSpaceDimension(2)
13305         self.assertEqual(1,mcpy.getCellContainingPoint([1.5,0.5],1e-12))
13306         ##
13307         self.assertTrue(mcpy.fillCellIdsToKeepFromNodeIds(DataArrayInt([6,7]),False).isEqual(DataArrayInt([0,1,5])))
13308         ##
13309         mcpy2=mcpy.deepCpy()
13310         self.assertEqual([None,None],mcpy.checkGeoEquivalWith(mcpy2,1,1e-12))#fast equal
13311         mcpy.checkFastEquivalWith(mcpy2,1e-12)
13312         mcpy2.renumberCells([0,2,4,3,1,5])
13313         mcpy.checkFastEquivalWith(mcpy2,1e-12)
13314         self.assertEqual([None,None],mcpy.checkGeoEquivalWith(mcpy2,1,1e-12))#fast equal
13315         mcpy2.renumberCells([0,2,4,3,1,5])
13316         mcpy2.renumberCells([1,3,5,0,2,4])
13317         self.assertRaises(InterpKernelException,mcpy.checkFastEquivalWith,mcpy2,1e-12)
13318         self.assertRaises(InterpKernelException,mcpy.checkGeoEquivalWith,mcpy2,1,1e-12)#fast equal
13319         pass
13320
13321     def testSwig21DGTUMesh1(self):
13322         a0=DataArrayInt([0,2,3,5,6,8])
13323         a1=DataArrayInt([0,4,7,11,14,18,21,25])
13324         a2=DataArrayInt([0,1,4,5])
13325         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])))
13326         self.assertEqual(a1[3:].front(),11)
13327         self.assertEqual(a1[4:].convertToDblArr().front(),14.)
13328         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])
13329         d,e=MEDCouplingUMesh.ExtractFromIndexedArrays2(1,5,2,a1c,a1)
13330         self.assertTrue(d.isEqual(DataArrayInt([8,11,0,1,5,2])))
13331         self.assertTrue(e.isEqual(DataArrayInt([0,3,6])))
13332         #
13333         m=MEDCouplingDataForTest.build2DTargetMesh_1()[0,3,4]
13334         ref=DataArrayInt([0,3,4,1,6,7,4,3,7,8,5,4])
13335         self.assertTrue(m.convertNodalConnectivityToStaticGeoTypeMesh().isEqual(ref))
13336         d,e=m.convertNodalConnectivityToDynamicGeoTypeMesh()
13337         self.assertTrue(d.isEqual(ref))
13338         self.assertTrue(e.isEqual(DataArrayInt.Range(0,13,4)))
13339         self.assertTrue(m.fillCellIdsToKeepFromNodeIds(DataArrayInt([6,7]),False).isEqual(DataArrayInt([1,2])))
13340         #
13341         m=MEDCoupling1GTUMesh.New("m",NORM_POLYHED)
13342         self.assertTrue(isinstance(m,MEDCoupling1DGTUMesh))
13343         m.__repr__() ; m.__str__()
13344         m.setCoords(DataArrayDouble(20,3))
13345         m.allocateCells()
13346         m.__repr__() ; m.__str__()
13347         m.insertNextCell([0,1,2,5,7,2,-1,1,3])
13348         self.assertEqual(1,m.getNumberOfCells())
13349         self.assertTrue(DataArrayInt([8]).isEqual(m.computeNbOfNodesPerCell()))
13350         self.assertTrue(DataArrayInt([2]).isEqual(m.computeNbOfFacesPerCell()))
13351         m.__repr__() ; m.__str__()
13352         m.checkCoherency()
13353         m.checkCoherency2()
13354         #
13355         cm=MEDCouplingCMesh() ; cm.setName("m")
13356         arr0=DataArrayDouble(6) ; arr0.iota()
13357         arr1=DataArrayDouble([0,1])
13358         cm.setCoords(arr0,arr1,arr1) ; um=cm.buildUnstructured() ; um.convertAllToPoly()
13359         um2=um.deepCpyConnectivityOnly()
13360         self.assertTrue(um2.isEqual(um,1e-12))
13361         self.assertEqual(um2.getCoords().getHiddenCppPointer(),um.getCoords().getHiddenCppPointer())
13362         self.assertTrue(um2.getNodalConnectivity().isEqual(um.getNodalConnectivity()))
13363         self.assertTrue(um2.getNodalConnectivity().getHiddenCppPointer()!=um.getNodalConnectivity().getHiddenCppPointer())
13364         self.assertTrue(um2.getNodalConnectivityIndex().isEqual(um.getNodalConnectivityIndex()))
13365         self.assertTrue(um2.getNodalConnectivityIndex().getHiddenCppPointer()!=um.getNodalConnectivityIndex().getHiddenCppPointer())
13366         #
13367         self.assertRaises(InterpKernelException,MEDCoupling1SGTUMesh.New,"m",NORM_POLYHED)
13368         m=MEDCoupling1DGTUMesh("m",NORM_POLYHED)
13369         m.allocateCells(5)
13370         self.assertEqual(15,m.getNodalConnectivity().getNbOfElemAllocated())
13371         self.assertEqual(6,m.getNodalConnectivityIndex().getNbOfElemAllocated())
13372         m.setCoords(um.getCoords())
13373         m.insertNextCell([1,0,6,7,-1,7,6,1])
13374         self.assertEqual(1,m.getNumberOfCells())
13375         m.insertNextCell([2,1,7,8,-1,2,1,-1,8,-1,7])
13376         m.insertNextCell([3,2,8,9])
13377         m.insertNextCell([4,3,9,10,-1,5,3,9])
13378         m.insertNextCell([5,4,10,11,-1,11,10,-1,5])
13379         m.checkCoherency()
13380         m.checkCoherency2()
13381         self.assertEqual(5,m.getNumberOfCells())
13382         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,8,19,23,31,40])))
13383         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])))
13384         #
13385         m4=m.deepCpy()
13386         self.assertTrue(m.isEqual(m4,1e-12))
13387         m4.getNodalConnectivity().setIJ(2,0,5)
13388         self.assertTrue(not m.isEqual(m4,1e-12))
13389         m4.getNodalConnectivity().setIJ(2,0,6)
13390         self.assertTrue(m.isEqual(m4,1e-12))
13391         m4.getNodalConnectivityIndex().setIJ(2,0,21)
13392         self.assertTrue(not m.isEqual(m4,1e-12))
13393         m4.getNodalConnectivityIndex().setIJ(2,0,19)
13394         self.assertTrue(m.isEqual(m4,1e-12))
13395         m4.getCoords().setIJ(10,1,1.1)
13396         self.assertTrue(not m.isEqual(m4,1e-12))
13397         m4.getCoords().setIJ(10,1,1.)
13398         self.assertTrue(m.isEqual(m4,1e-12))
13399         m4.getNodalConnectivity().pushBackSilent(7)
13400         self.assertTrue(not m.isEqual(m4,1e-12))
13401         self.assertEqual(7,m4.getNodalConnectivity().popBackSilent())
13402         self.assertTrue(m.isEqual(m4,1e-12))
13403         m4.setName("m4")
13404         self.assertTrue(not m.isEqual(m4,1e-12))
13405         m4.setName("m")
13406         self.assertTrue(m.isEqual(m4,1e-12))
13407         #
13408         self.assertEqual(6,m.getNodalConnectivityIndex().getNbOfElemAllocated())
13409         self.assertEqual(60,m.getNodalConnectivity().getNbOfElemAllocated())
13410         self.assertTrue(m.computeNbOfNodesPerCell().isEqual(DataArrayInt([7,8,4,7,7])))
13411         self.assertTrue(m.computeNbOfFacesPerCell().isEqual(DataArrayInt([2,4,1,2,3])))
13412         self.assertEqual(m.getNodeIdsOfCell(1),[2,1,7,8,-1,2,1,-1,8,-1,7])
13413         f=m.computeIsoBarycenterOfNodesPerCell()
13414         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))
13415         mu0=m.buildUnstructured()
13416         o2n=[1,2,0,4,3]
13417         m2=m.deepCpy()
13418         m3=m.deepCpyConnectivityOnly()
13419         self.assertTrue(m3.isEqual(m,1e-12))
13420         self.assertEqual(m3.getCoords().getHiddenCppPointer(),m.getCoords().getHiddenCppPointer())
13421         self.assertTrue(m3.getNodalConnectivity().getHiddenCppPointer()!=m.getNodalConnectivity().getHiddenCppPointer())
13422         self.assertTrue(m3.getNodalConnectivity().isEqual(m.getNodalConnectivity()))
13423         self.assertTrue(m3.getNodalConnectivityIndex().getHiddenCppPointer()!=m.getNodalConnectivityIndex().getHiddenCppPointer())
13424         self.assertTrue(m3.getNodalConnectivityIndex().isEqual(m.getNodalConnectivityIndex()))
13425         m.renumberCells(o2n)
13426         mu0.renumberCells(o2n)
13427         self.assertTrue(mu0.isEqual(m.buildUnstructured(),1e-12))
13428         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4,12,23,32,40])))
13429         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])))
13430         #
13431         mcpy0=m.buildUnstructured()
13432         self.assertTrue(isinstance(mcpy0,MEDCouplingUMesh))
13433         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])))
13434         self.assertTrue(mcpy0.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5,14,26,36,45])))
13435         self.assertEqual(mcpy0.getAllGeoTypes(),[NORM_POLYHED])
13436         mcpy0.checkCoherency()
13437         mcpy0.checkCoherency2()
13438         mcpy1=mcpy0.convertIntoSingleGeoTypeMesh()
13439         self.assertTrue(mcpy1.isEqual(m,1e-12))
13440         #
13441         m_mrg=MEDCoupling1DGTUMesh.Merge1DGTUMeshes([m2,m,m2])
13442         self.assertTrue(m_mrg.getNodalConnectivityIndex().isEqual(DataArrayInt([0,8,19,23,31,40,44,52,63,72,80,88,99,103,111,120])))
13443         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])))
13444         m_mrg2=MEDCoupling1DGTUMesh.Merge1DGTUMeshesOnSameCoords([m3,m,m3])
13445         self.assertTrue(m_mrg2.getNodalConnectivityIndex().isEqual(DataArrayInt([0,8,19,23,31,40,44,52,63,72,80,88,99,103,111,120])))
13446         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])))
13447         a,b=m_mrg2.getReverseNodalConnectivity()
13448         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])))
13449         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])))
13450         self.assertTrue(m_mrg2.fillCellIdsToKeepFromNodeIds([7],False).isEqual(DataArrayInt([0,1,6,7,10,11])))
13451         self.assertTrue(m_mrg2.fillCellIdsToKeepFromNodeIds([0,1,6,7],True).isEqual(DataArrayInt([0,6,10])))
13452         #
13453         self.assertTrue(m_mrg2.isPacked())
13454         self.assertEqual(120,m_mrg2.getNodalConnectivityIndex().popBackSilent())
13455         self.assertEqual(m_mrg2.getNumberOfCells(),14)
13456         m_mrg2.checkCoherency2()
13457         self.assertTrue(not m_mrg2.isPacked())
13458         m_mrg4,b=m_mrg2.copyWithNodalConnectivityPacked()
13459         self.assertTrue(not b)
13460         m_mrg4.checkCoherency2()
13461         self.assertEqual(m_mrg4.getNumberOfCells(),14)
13462         self.assertTrue(m_mrg4.getNodalConnectivityIndex().isEqual(m_mrg2.getNodalConnectivityIndex()))
13463         self.assertEqual(len(m_mrg4.getNodalConnectivity()),111)
13464         self.assertEqual(len(m_mrg2.getNodalConnectivity()),120)
13465         self.assertTrue(m_mrg4.getNodalConnectivity().isEqual(m_mrg2.getNodalConnectivity()[:111]))
13466         #
13467         m0=m_mrg2[:5]
13468         m1=m_mrg2[[5,6,7,8,9]]
13469         m2=m_mrg2[10:]
13470         self.assertTrue(m1.isEqualWithoutConsideringStr(m,1e-12))
13471         a,b=m.checkGeoEquivalWith(m0,12,1e-12)
13472         self.assertTrue(a.isEqual(DataArrayInt(o2n)))
13473         self.assertTrue(b is None)
13474         pass
13475
13476     def testSwig2DADAreIncludedInMe1(self):
13477         a=DataArrayDouble(30) ; a.iota() ; a.rearrange(3)
13478         p=DataArrayInt([5,2,1,9])
13479         b,c=a.areIncludedInMe(a[p],1e-12)
13480         self.assertTrue(b)
13481         self.assertTrue(c.isEqual(p))
13482         d=a[p]
13483         d.setIJ(3,1,28.1)
13484         b,c=a.areIncludedInMe(d,1e-12)
13485         self.assertTrue(not b)
13486         self.assertTrue(c.isEqual(DataArrayInt([5,2,1,10])))
13487         pass
13488
13489     def testSwig2DADesallocate1(self):
13490         d=DataArrayDouble([(1,2),(6,7),(6,8)]) ; d.setInfoOnComponents(["aa","bbb"])
13491         self.assertTrue(d.isAllocated())
13492         d.checkAllocated()
13493         self.assertEqual(d.getInfoOnComponents(),["aa","bbb"])
13494         ref=d.getHeapMemorySize()
13495         d.desallocate()
13496         self.assertEqual(ref-d.getHeapMemorySize(),6*8)
13497         self.assertTrue(not d.isAllocated())
13498         self.assertEqual(d.getInfoOnComponents(),["aa","bbb"])
13499         self.assertRaises(InterpKernelException,d.checkAllocated)
13500         #
13501         d=DataArrayInt([(1,2),(6,7),(6,8)]) ; d.setInfoOnComponents(["aa","bbb"])
13502         self.assertTrue(d.isAllocated())
13503         d.checkAllocated()
13504         self.assertEqual(d.getInfoOnComponents(),["aa","bbb"])
13505         ref=d.getHeapMemorySize()
13506         d.desallocate()
13507         self.assertEqual(ref-d.getHeapMemorySize(),6*4)
13508         self.assertTrue(not d.isAllocated())
13509         self.assertEqual(d.getInfoOnComponents(),["aa","bbb"])
13510         self.assertRaises(InterpKernelException,d.checkAllocated)
13511         pass
13512
13513     def testSwig2IsPartStructured1(self):
13514         #dim 1
13515         d10=DataArrayInt([2,3,4,5,6,7,8,9,10,11])
13516         a,b=MEDCouplingStructuredMesh.IsPartStructured(d10,[13])
13517         self.assertTrue(a) ; self.assertEqual(b,[(2,12)])
13518         d11=DataArrayInt([2,3,4,5,6,7,8,10,9,11])
13519         a,b=MEDCouplingStructuredMesh.IsPartStructured(d11,[13])
13520         self.assertTrue(not a)
13521         self.assertRaises(InterpKernelException,MEDCouplingStructuredMesh.IsPartStructured,d10,[11])
13522         #dim 2
13523         st=[10,4]
13524         d20=DataArrayInt([1,2,3,4,11,12,13,14,21,22,23,24])
13525         a,b=MEDCouplingStructuredMesh.IsPartStructured(d20,st)
13526         self.assertTrue(a) ; self.assertEqual(b,[(1,5),(0,3)])
13527         self.assertEqual(12,MEDCouplingStructuredMesh.DeduceNumberOfGivenRangeInCompactFrmt(b))
13528         self.assertEqual(8,MEDCouplingStructuredMesh.DeduceNumberOfGivenRangeInCompactFrmt([(1,5),(1,3),(2,2)]))
13529         self.assertEqual(0,MEDCouplingStructuredMesh.DeduceNumberOfGivenRangeInCompactFrmt([(5,5),(3,3),(2,2)]))
13530         self.assertEqual(36,MEDCouplingStructuredMesh.DeduceNumberOfGivenStructure([3,2,6]))
13531         self.assertEqual(126,MEDCouplingStructuredMesh.DeduceNumberOfGivenStructure((3,7,6)))
13532         d20=DataArrayInt([1,2,3,4,12,11,13,14,21,22,23,24])
13533         a,b=MEDCouplingStructuredMesh.IsPartStructured(d20,st)
13534         self.assertTrue(not a)
13535         d20=DataArrayInt([1,2,3,4,11,12,13,15,21,22,23,24])
13536         a,b=MEDCouplingStructuredMesh.IsPartStructured(d20,st)
13537         self.assertTrue(not a)
13538         d21=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])
13539         a,b=MEDCouplingStructuredMesh.IsPartStructured(d21,st)
13540         self.assertTrue(a) ; self.assertEqual(b,[(0,10),(0,4)])
13541         d22=DataArrayInt([1,2,3,4,11,12,13,14,21,22,23,24,31,32,33,34,41,42,43,44])
13542         self.assertRaises(InterpKernelException,MEDCouplingStructuredMesh.IsPartStructured,d22,st)
13543         a,b=MEDCouplingStructuredMesh.IsPartStructured(d22,[10,5])
13544         self.assertTrue(a) ; self.assertEqual(b,[(1,5),(0,5)])
13545         #dim 3
13546         d30=DataArrayInt([11,12,13,14,21,22,23,24,51,52,53,54,61,62,63,64])
13547         a,b=MEDCouplingStructuredMesh.IsPartStructured(d30,[10,4,2])
13548         self.assertTrue(a) ; self.assertEqual(b,[(1,5),(1,3),(0,2)])
13549         d31=DataArrayInt([11,12,13,14,21,22,24,23,51,52,53,54,61,62,63,64])
13550         a,b=MEDCouplingStructuredMesh.IsPartStructured(d31,[10,4,2])
13551         self.assertTrue(not a)
13552         self.assertRaises(InterpKernelException,MEDCouplingStructuredMesh.IsPartStructured,d30,[10,4,1])
13553         pass
13554
13555     def testSwig2PartStructured1(self):
13556         c=MEDCouplingCMesh() ; c.setName("toto")
13557         arr0=DataArrayDouble(10); arr0.iota()
13558         arr1=DataArrayDouble(4) ; arr1.iota(3)
13559         c.setCoords(arr0,arr1)
13560         self.assertEqual(c.getNodeGridStructure(),(10,4))
13561         self.assertEqual(c.getCellGridStructure(),(9,3))
13562         d20=DataArrayInt([1,2,3,4,10,11,12,13,19,20,21,22])
13563         self.assertEqual(27,c.getNumberOfCells())
13564         self.assertEqual(40,c.getNumberOfNodes())
13565         self.assertEqual(2,c.getMeshDimension())
13566         c.checkCoherency()
13567         #
13568         arr2=MEDCouplingStructuredMesh.BuildExplicitIdsFrom([9,3],[(1,5),(0,3)])
13569         self.assertTrue(arr2.isEqual(DataArrayInt([1,2,3,4,10,11,12,13,19,20,21,22])))
13570         # CMesh
13571         c2=c.buildStructuredSubPart([(1,5),(0,3)])
13572         c2.checkCoherency()
13573         self.assertTrue(isinstance(c2,MEDCouplingCMesh))
13574         self.assertEqual(12,c2.getNumberOfCells())
13575         self.assertEqual(20,c2.getNumberOfNodes())
13576         self.assertEqual(2,c2.getMeshDimension())
13577         self.assertEqual("toto",c2.getName())
13578         self.assertTrue(c2.getCoordsAt(0).isEqual(DataArrayDouble([1.,2.,3.,4.,5.]),1e-12))
13579         self.assertTrue(c2.getCoordsAt(1).isEqual(DataArrayDouble([3.,4.,5.,6.]),1e-12))
13580         #
13581         a,b=c.buildPartAndReduceNodes(d20)
13582         a.checkCoherency()
13583         exp2=DataArrayInt([-1,0,1,2,3,4,-1,-1,-1,-1,-1,5,6,7,8,9,-1,-1,-1,-1,-1,10,11,12,13,14,-1,-1,-1,-1,-1,15,16,17,18,19,-1,-1,-1,-1])
13584         self.assertTrue(exp2.isEqual(b))
13585         self.assertTrue(isinstance(a,MEDCouplingCMesh))
13586         self.assertTrue(a.buildUnstructured().isEqual(c.buildUnstructured().buildPartAndReduceNodes(d20)[0],1e-12))
13587         # CurveLinearMesh
13588         c2=MEDCouplingCurveLinearMesh() ; c2.setName("toto")
13589         c2.setCoords(c.buildUnstructured().getCoords())
13590         c2.setNodeGridStructure([10,4])
13591         c2.checkCoherency()
13592         a,b=c2.buildPartAndReduceNodes(d20)
13593         a.checkCoherency()
13594         self.assertTrue(exp2.isEqual(b))
13595         self.assertTrue(isinstance(a,MEDCouplingCurveLinearMesh))
13596         self.assertTrue(a.buildUnstructured().isEqual(c2.buildUnstructured().buildPartAndReduceNodes(d20)[0],1e-12))
13597         pass
13598
13599     def testSwig2FindPermutationFromFirstToSecond1(self):
13600         ids1=DataArrayInt([3,1,103,4,6,10,-7,205])
13601         ids2=DataArrayInt([-7,1,205,10,6,3,103,4])
13602         ids3=DataArrayInt.FindPermutationFromFirstToSecond(ids1,ids2)
13603         self.assertTrue(ids3.isEqual(DataArrayInt([5,1,6,7,4,3,0,2])))
13604         ids2ToTest=ids1.renumber(ids3)
13605         self.assertTrue(ids2ToTest.isEqual(ids2))
13606         self.assertRaises(InterpKernelException,DataArrayInt.FindPermutationFromFirstToSecond,DataArrayInt([3,1,103]),DataArrayInt([1,103]))
13607         self.assertRaises(InterpKernelException,DataArrayInt.FindPermutationFromFirstToSecond,DataArrayInt([3,1,103]),DataArrayInt([1,103,2]))
13608         self.assertRaises(InterpKernelException,DataArrayInt.FindPermutationFromFirstToSecond,DataArrayInt([3,1,103]),DataArrayInt([1,103,1]))
13609         self.assertTrue(DataArrayInt.FindPermutationFromFirstToSecond(DataArrayInt([]),DataArrayInt([])).empty())
13610         pass
13611
13612     def testSwig2BugStructuredMeshGetNodeIdsOfCell1(self):
13613         m=MEDCouplingCMesh("mesh")
13614         coordsX=DataArrayDouble([0,1.1,2.2,3.3,4.4]) ; coordsX.setInfoOnComponents(["XX [m]"])
13615         coordsY=DataArrayDouble([0,1.7,3.4]) ; coordsY.setInfoOnComponents(["YYY [km]"])
13616         m.setCoords(coordsX,coordsY)
13617         self.assertEqual([2,3,8,7],m.getNodeIdsOfCell(2))
13618         self.assertEqual([3,4,9,8],m.getNodeIdsOfCell(3))
13619         self.assertEqual([7,8,13,12],m.getNodeIdsOfCell(6))
13620         self.assertEqual([8,9,14,13],m.getNodeIdsOfCell(7))
13621         pass
13622
13623     def testSwig2ThrowOnDAIInvertN2O2ON2(self):
13624         p1=DataArrayInt([3,5,8])
13625         p2=DataArrayInt([0,3,4,5,6,7,8,9,10])
13626         p1.transformWithIndArr(p2.invertArrayN2O2O2N(11))
13627         self.assertTrue(p1.isEqual(DataArrayInt([1,3,6])))
13628         self.assertTrue(p2.invertArrayN2O2O2N(11).isEqual(DataArrayInt([0,-1,-1,1,2,3,4,5,6,7,8])))
13629         self.assertRaises(InterpKernelException,p2.invertArrayN2O2O2N,10)
13630         pass
13631
13632     def testSwig2ComputeEffectiveNbOfNodesPerCell1(self):
13633         coords=DataArrayDouble([ 0.241310763507 , 0.0504777305619 , 0.0682283524903 , 0.252501053866 , -0.0625176732937 , 0.137272639894 ,
13634                  0.152262663601 , 0.241816569527 , 0.133812556197 , 0.18047750211 , -0.0789949051358 , 0.339098173401 ,
13635                  0.151741971857 , 0.238885278571 , 0.137715037333 , 0.242532155481 , -0.0928169086456 , 0.0678043417367 ,
13636                  0.240941965335 , -0.015461491464 , 0.0617186345825 , 0.24127650112 , 0.0499427876717 , 0.0679634099148 ,
13637                  -0.145828917428 , 0.206291632565 , 0.0310071927543 , 0.0125651775307 , 0.266262085828 , 0.105228430543 ,
13638                  -0.0994066533286 , 0.233224271238 , 0.0572213839567 , -0.0951345338317 , 0.234819509426 , 0.0592126284538 ,
13639                  0.136580574205 , -0.205486212579 , 0.0572866072014 , 0.0637270784978 , -0.168886355238 , 0.446614057077 ,
13640                  0.041337157151 , -0.213402568198 , 0.372407095999 , 0.0411601970268 , -0.202387875756 , 0.411334979491 ,
13641                  -0.108355701857 , 0.193636239335 , 0.204886756738 , 0.00639779029829 , 0.155296981517 , 0.252585892979 ,
13642                  0.0262473111702 , -0.112919732543 , 0.424286639249 ,-0.224103052733 , -0.139430015438 , -0.0122352295701 ,
13643                 -0.0312760589481 , -0.274272003594 , 0.0323959636568 , -0.166663422532 , -0.217754445175 , 0.00392109070364 ,
13644                  -0.30586619777 , -0.0475168041091 , -0.0144585228182 , -0.280881480586 , 0.135571293538 , 0.00623923647986 ,
13645                  -0.25548538234 , 0.156819217766 , 0.0645277879769 , -0.131567009284 , 0.184133752309 , 0.206021802753 ,
13646                  -0.196204010965 , 0.151602971681 , 0.212974777736 , -0.183713879463 , 0.0802946639531 , 0.260115662599 ,
13647                  -0.244241178767 , -0.0738873389604 , 0.144590565817 , -0.155804057829 , -0.164892720025 , 0.210613950558 ,
13648                  -0.170950800428 , -0.215099334026 , 0.00610122860092 , -0.30552634869 , -0.0490020791904 , -0.0132786533145 ,
13649                  0.271831011884 , 0.15105657296 , 0.0230534827908 , 0.281919192283 , 0.0898544306288 , -0.0625201489143 ,
13650                  0.260240727276 , -0.0120688706637 , -0.0532316588626 , 0.244947737722 , 0.0197984684293 , 0.0309341209233 ,
13651                  0.23439631578 , 0.229825279875 , 0.0508520585381 , 0.160921316875 , 0.265078502128 , 0.121716560626 ,
13652                  -0.315088694175 , 0.0747700471918 , -0.245836615071 , -0.327728781776 , 0.0857114674649 , -0.239431905957 ,
13653                  -0.308385460634 , 0.145142997084 , -0.149886828433 , 0.0488236045164 , 0.309462801914 , 0.0849169148265 ,
13654                 -0.0244964803395 , 0.33145611751 , -0.0476415818061 , 0.0060567994229 , 0.32418412014 , 0.0367779543812 ,
13655                  -0.0950221448063 , 0.236675326003 , 0.0572594453983 , 0.248723023186 , 0.0886648784791 , -0.176629430538 ,
13656                  0.116796984 , 0.256596599567 , -0.292863523603 , 0.118024552914 , 0.229154257843 , -0.34233232501 ,
13657                  0.217507892549 , -0.0417822335742 , -0.176771782888 , -0.224429321304 , 0.0125595300114 , -0.362064725588 ,
13658                  0.0937301100955 , -0.0500824832657 , -0.299713548444 , -0.244162220397 , 0.0383853931293 , -0.389856984411 ,
13659                  -0.0281989366102 , 0.097392811563 , -0.458244577284 , -0.385010847162 , 0.10122766194 , -0.140052859922 ,
13660                  -0.377936358012 , 0.110875172128 , -0.176207095463 , 0.244483045556 , -0.0991073977045 , 0.0575134372934 ,
13661                 0.262605120167 , -0.100243191645 , -0.0495620806935 , 0.240306880972 , -0.136153701579 , -0.114745281696 ,
13662                  0.215763176129 , -0.0836766059189 , -0.183249640616 , 0.237870396603 , -0.132449578286 , -0.121598854639 ,
13663                  -0.0637683083097 , -0.27921020214 , -0.149112321992 , -0.0856211014977 , -0.2973233473 , -0.0446878139589 ,
13664                  0.104675342288 , -0.0625908305324 , -0.290346256534 , 0.0248264249186 , -0.247797708548 , -0.165830884019 ,
13665                  0.0719302438309 , -0.178468260473 , -0.211432157345 , 0.142871843159 , -0.208769948542 , 0.0454101128246 ,
13666                  0.167803379307 , -0.207851396623 , -0.088802726124 , 0.12868717152 , -0.230920439715 , 0.00760508389036 ,
13667                  -0.0372812069535 , -0.286740286332 , 0.00963701291166 ], 69, 3)
13668         connN = [ #polyhedron 0
13669             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
13670             , 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
13671             , 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
13672             , 22 , 19 , 21 , 30 , 31 , -1 , 22 , 31 , 28 , 27 , 26 , 24 , 23 , -1 , 31 , 30 , 29 , 28,
13673             # polyhedron 1
13674             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
13675             , 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
13676             , 33 , 34 , 48 , 45 , -1 , 35 , 34 , 48 , 50 , 49 , 38 , -1 , 41 , 43 , 42 , 46 , 36 , 37 , -1 , 38 , 39 , 51 , 49 , -1
13677             , 39 , 40 , 42 , 46 , 47 , 52 , 51 , -1 , 45 , 47 , 52 , 50 , 48 , -1 , 52 , 51 , 49 , 50,
13678             # polyhedron 2
13679             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
13680             , 23 , 53 , 54 , 40 , 8 , -1 , 53 , 22 , 23 , -1 , 39 , 54 , 40,
13681             # polyhedron 3
13682             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
13683             , 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
13684             , 55 , 5 , 12 , 65 , -1 , 66 , 67 , 65 , 55 , 56 , 57 , -1 , 63 , 66 , 57 , 59 , 64 , -1 , 64 , 62 , 58 , 59 , -1
13685             , 60 , 63 , 66 , 67 , 68 , 61 , -1 , 61 , 68 , 20 , 21 , -1 , 67 , 68 , 20 , 12 , 65]
13686         meshN=MEDCouplingUMesh.New()
13687         meshN.setName("ForBary")
13688         meshN.setMeshDimension(3) ; meshN.setCoords(coords)
13689         meshN.allocateCells(4)
13690         meshN.insertNextCell(NORM_POLYHED,113,connN);
13691         meshN.insertNextCell(NORM_POLYHED,99,connN[113:])
13692         meshN.insertNextCell(NORM_POLYHED,43,connN[212:])
13693         meshN.insertNextCell(NORM_POLYHED,92,connN[255:])
13694         d=meshN.computeEffectiveNbOfNodesPerCell()
13695         e=meshN.computeNbOfNodesPerCell()
13696         self.assertTrue(d.isEqual(DataArrayInt([32,28,12,26])))
13697         self.assertTrue(e.isEqual(DataArrayInt([96,84,36,78])))
13698         m0=MEDCoupling1DGTUMesh(meshN)
13699         c=MEDCouplingCMesh()
13700         arr=DataArrayDouble(3) ; arr.iota(10)
13701         c.setCoords(arr,arr,arr)
13702         m10=c.buildUnstructured()
13703         m11=c.build1SGTUnstructured()
13704         m12=MEDCoupling1SGTUMesh.New(m10)
13705         self.assertTrue(m12.isEqual(m11,1e-12))
13706         m12.setCoords(m0.getCoords()) # m12 is not OK geometrically but the aim of the test is only connectivity values
13707         m3=MEDCoupling1GTUMesh.AggregateOnSameCoordsToUMesh([m12,m0])
13708         m3.checkCoherency()
13709         self.assertEqual(m3.getCoords().getHiddenCppPointer(),m12.getCoords().getHiddenCppPointer())
13710         self.assertTrue(m3.getNodalConnectivity().isEqual(DataArrayInt([18,1,0,3,4,10,9,12,13,18,2,1,4,5,11,10,13,14,18,4,3,6,7,13,12,15,16,18,5,4,7,8,14,13,16,17,18,10,9,12,13,19,18,21,22,18,11,10,13,14,20,19,22,23,18,13,12,15,16,22,21,24,25,18,14,13,16,17,23,22,25,26,31,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,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,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,22,19,21,30,31,-1,22,31,28,27,26,24,23,-1,31,30,29,28,31,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,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,33,34,48,45,-1,35,34,48,50,49,38,-1,41,43,42,46,36,37,-1,38,39,51,49,-1,39,40,42,46,47,52,51,-1,45,47,52,50,48,-1,52,51,49,50,31,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,23,53,54,40,8,-1,53,22,23,-1,39,54,40,31,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,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,55,5,12,65,-1,66,67,65,55,56,57,-1,63,66,57,59,64,-1,64,62,58,59,-1,60,63,66,67,68,61,-1,61,68,20,21,-1,67,68,20,12,65])))
13711         self.assertTrue(m3.getNodalConnectivityIndex().isEqual(DataArrayInt([0,9,18,27,36,45,54,63,72,186,286,330,423])))
13712         pass
13713
13714     def testSwig2Tetrahedrize1(self):
13715         d=DataArrayInt([0,3,6,10,14,20])
13716         d2=d.buildExplicitArrOfSliceOnScaledArr(slice(0,5,2))
13717         self.assertTrue(d2.isEqual(DataArrayInt([0,0,0, 2,2,2,2, 4,4,4,4,4,4])))
13718         m=MEDCouplingUMesh("Penta6",3)
13719         m.setCoords(DataArrayDouble([0,0,0,0,1,0,1,0,0,0,0,2,0,1,2,1,0,2],6,3)) ; m.getCoords().setInfoOnComponents(["X","YY","ZZZ"])
13720         m.allocateCells()
13721         m.insertNextCell(NORM_PENTA6,[1,2,0,4,5,3])
13722         st=m.getCoords().getHiddenCppPointer()
13723         c,a,b=m.tetrahedrize(PLANAR_FACE_5)
13724         c.checkCoherency2()
13725         self.assertTrue(a.isEqual(DataArrayInt([0,0,0])))
13726         self.assertEqual(0,b)
13727         self.assertEqual(m.getCoords().getHiddenCppPointer(),c.getCoords().getHiddenCppPointer())
13728         self.assertTrue(c.getNodalConnectivity().isEqual(DataArrayInt([1,2,0,4,4,3,5,0,5,0,2,4])))
13729         del m,c
13730         #
13731         m2=MEDCouplingUMesh("octa12",3)
13732         coords=DataArrayDouble([1.,0.,0.,0.5,0.8660254037844386,0.,-0.5,0.8660254037844387,0.,-1.,1.2246467991473532e-16,0.,-0.5,-0.8660254037844384,0.,0.5,-0.866025403784439,0.,1.,0.,2.,0.5,0.8660254037844386,2.,-0.5,0.8660254037844387,2.,-1.,1.2246467991473532e-16,2.,-0.5,-0.8660254037844384,2.,0.5,-0.866025403784439,2.0],12,3)
13733         m2.setCoords(coords)
13734         m2.allocateCells()
13735         m2.insertNextCell(NORM_HEXGP12,[3,2,1,0,5,4,9,8,7,6,11,10])
13736         c,a,b=m2.tetrahedrize(PLANAR_FACE_5)
13737         c.checkCoherency2()
13738         self.assertTrue(a.isEqual(DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0])))
13739         self.assertEqual(0,b)
13740         self.assertEqual(c.getCoords().getHiddenCppPointer(),coords.getHiddenCppPointer())
13741         self.assertTrue(c.getNodalConnectivity().isEqual(DataArrayInt([3,2,4,9,9,10,8,4,8,4,2,9,2,5,4,8,8,10,11,4,11,4,5,8,2,1,5,8,8,11,7,5,7,5,1,8,1,0,5,7,7,11,6,5,6,5,0,7])))
13742         del m2,coords,c
13743         #
13744         coords=DataArrayDouble([0.,0.,0.,1.,0.,0.,1.,1.,0.,0.,1.,0.,0.,0.,2.,1.,0.,2.,1.,1.,2.,0.,1.,2.],8,3) ; coords.setInfoOnComponents(["X","YY","ZZZ"])
13745         m3=MEDCouplingUMesh("hexa8",3)
13746         m3.setCoords(coords)
13747         m3.allocateCells(0)
13748         m3.insertNextCell(NORM_HEXA8,[3,2,1,0,7,6,5,4])
13749         st=m3.getCoords().getHiddenCppPointer()
13750         c,a,b=m3.tetrahedrize(PLANAR_FACE_5)
13751         c.checkCoherency2()
13752         a.isEqual(DataArrayInt([0,0,0,0,0]))
13753         self.assertEqual(0,b)
13754         self.assertEqual(m3.getCoords().getHiddenCppPointer(),coords.getHiddenCppPointer())
13755         self.assertTrue(c.getNodalConnectivity().isEqual(DataArrayInt([3,6,2,1,3,7,6,4,3,0,4,1,6,4,5,1,3,6,1,4])))
13756         #
13757         m4=MEDCouplingUMesh("hexa8",3)
13758         m4.setCoords(coords)
13759         m4.allocateCells(0)
13760         m4.insertNextCell(NORM_HEXA8,[3,2,1,0,7,6,5,4])
13761         c,a,b=m4.tetrahedrize(PLANAR_FACE_6)
13762         c.checkCoherency2()
13763         a.isEqual(DataArrayInt([0,0,0,0,0,0]))
13764         self.assertEqual(0,b)
13765         self.assertEqual(c.getCoords().getHiddenCppPointer(),coords.getHiddenCppPointer())
13766         self.assertTrue(c.getNodalConnectivity().isEqual(DataArrayInt([3,6,2,5,3,2,1,5,3,7,6,5,3,4,7,5,3,1,0,5,3,0,4,5])))
13767         #
13768         m4=MEDCouplingUMesh("hexa8",3)
13769         m4.setCoords(coords)
13770         m4.allocateCells(0)
13771         m4.insertNextCell(NORM_HEXA8,[3,2,1,0,7,6,5,4])
13772         st=m4.getCoords().getHiddenCppPointer()
13773         c,a,b=m4.tetrahedrize(GENERAL_24)
13774         c.checkCoherency2()
13775         a.isEqual(DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]))
13776         self.assertEqual(7,b)
13777         self.assertTrue(c.getCoords().getHiddenCppPointer()!=coords.getHiddenCppPointer())
13778         self.assertTrue(c.getCoords()[:8].isEqual(coords,0))
13779         self.assertTrue(c.getNodalConnectivity().isEqual(DataArrayInt([3,7,8,14,7,6,8,14,6,2,8,14,2,3,8,14,3,2,9,14,2,1,9,14,1,0,9,14,0,3,9,14,3,0,10,14,0,4,10,14,4,7,10,14,7,3,10,14,2,6,11,14,6,5,11,14,5,1,11,14,1,2,11,14,7,4,12,14,4,5,12,14,5,6,12,14,6,7,12,14,1,5,13,14,5,4,13,14,4,0,13,14,0,1,13,14])))
13780         m4CoordsExp=DataArrayDouble([0.,0.,0.,1.,0.,0.,1.,1.,0.,0.,1.,0.,0.,0.,2.,1.,0.,2.,1.,1.,2.,0.,1.,2.,0.5,1.,1.,0.5,0.5,0.,0.,0.5,1.,1.,0.5,1.,0.5,0.5,2.,0.5,0.,1.,0.5,0.5,1.],15,3)
13781         m4CoordsExp.setInfoOnComponents(["X","YY","ZZZ"])
13782         self.assertTrue(c.getCoords().isEqual(m4CoordsExp,1e-12))
13783         self.assertAlmostEqual(2.,c.getMeasureField(False).accumulate()[0],12)
13784         #
13785         m6=MEDCouplingUMesh("hexa8",3)
13786         m6.setCoords(coords)
13787         m6.allocateCells(0)
13788         m6.insertNextCell(NORM_HEXA8,[3,2,1,0,7,6,5,4])
13789         st=m6.getCoords().getHiddenCppPointer()
13790         c,a,b=m6.tetrahedrize(GENERAL_48)
13791         c.checkCoherency2()
13792         a.isEqual(DataArrayInt([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,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]))
13793         self.assertEqual(19,b)
13794         self.assertTrue(c.getCoords().getHiddenCppPointer()!=coords.getHiddenCppPointer())
13795         self.assertTrue(c.getCoords()[:8].isEqual(coords,0))
13796         self.assertTrue(c.getNodalConnectivity().isEqual(DataArrayInt([3,20,8,26,3,8,21,26,3,9,20,26,3,22,9,26,3,21,12,26,3,12,22,26,8,10,2,23,8,2,13,23,8,20,10,23,8,26,20,23,8,13,21,23,8,21,26,23,12,26,21,25,12,21,16,25,12,22,26,25,12,17,22,25,12,16,0,25,12,0,17,25,21,23,13,18,21,13,1,18,21,26,23,18,21,25,26,18,21,1,16,18,21,16,25,18,9,11,20,24,9,20,26,24,9,7,11,24,9,14,7,24,9,26,22,24,9,22,14,24,20,6,10,15,20,10,23,15,20,11,6,15,20,24,11,15,20,23,26,15,20,26,24,15,22,24,26,19,22,26,25,19,22,14,24,19,22,4,14,19,22,25,17,19,22,17,4,19,26,15,23,5,26,23,18,5,26,24,15,5,26,19,24,5,26,18,25,5,26,25,19,5])))
13797         m6CoordsExp=DataArrayDouble([0.,0.,0.,1.,0.,0.,1.,1.,0.,0.,1.,0.,0.,0.,2.,1.,0.,2.,1.,1.,2.,0.,1.,2.,0.5,1.,0.,0.,1.,1.,1.,1.,1.,0.5,1.,2.,0.,0.5,0.,1.,0.5,0.,0.,0.5,2.,1.,0.5,2.,0.5,0.,0.,0.,0.,1.,1.,0.,1.,0.5,0.,2.,0.5,1.,1.,0.5,0.5,0.,0.,0.5,1.,1.,0.5,1.,0.5,0.5,2.,0.5,0.,1.,0.5,0.5,1.],27,3)
13798         m6CoordsExp.setInfoOnComponents(["X","YY","ZZZ"])
13799         self.assertTrue(c.getCoords().isEqual(m6CoordsExp,1e-12))
13800         self.assertAlmostEqual(2.,c.getMeasureField(False).accumulate()[0],12)
13801         #
13802         m7=MEDCouplingUMesh("polyhed",3)
13803         coords=DataArrayDouble([1.,0.,0.,0.5,0.8660254037844386,0.,-0.5,0.8660254037844387,0.,-1.,0.,0.,-0.5,-0.8660254037844384,0.,0.5,-0.866025403784439,0.,1.,0.,2.,0.5,0.8660254037844386,2.,-0.5,0.8660254037844387,2.,-1.,0.,2.,-0.5,-0.8660254037844384,2.,0.5,-0.866025403784439,2.0],12,3) ; coords.setInfoOnComponents(["X","YY","ZZZ"])
13804         m7.setCoords(coords)
13805         m7.allocateCells()
13806         m7.insertNextCell(NORM_POLYHED,[3,2,1,0,5,4,-1,9,10,11,6,7,8,-1,3,9,8,2,-1,2,8,7,1,-1,1,7,6,0,-1,0,6,11,5,-1,5,11,10,4,-1,4,10,9,3])
13807         c,a,b=m7.tetrahedrize(PLANAR_FACE_5)
13808         c.checkCoherency2()
13809         self.assertTrue(a.isEqual(DataArrayInt([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,0,0,0,0])))
13810         self.assertEqual(9,b)
13811         self.assertTrue(c.getNodalConnectivity().isEqual(DataArrayInt([3,2,12,20,2,1,12,20,1,0,12,20,0,5,12,20,5,4,12,20,4,3,12,20,9,10,13,20,10,11,13,20,11,6,13,20,6,7,13,20,7,8,13,20,8,9,13,20,3,9,14,20,9,8,14,20,8,2,14,20,2,3,14,20,2,8,15,20,8,7,15,20,7,1,15,20,1,2,15,20,1,7,16,20,7,6,16,20,6,0,16,20,0,1,16,20,0,6,17,20,6,11,17,20,11,5,17,20,5,0,17,20,5,11,18,20,11,10,18,20,10,4,18,20,4,5,18,20,4,10,19,20,10,9,19,20,9,3,19,20,3,4,19,20])))
13812         self.assertAlmostEqual(5.196152422706635,c.getMeasureField(False).accumulate()[0],12)
13813         m7CoordsExp=DataArrayDouble([1.0,0.0,0.0,0.5,0.8660254037844386,0.0,-0.5,0.8660254037844387,0.0,-1.0,0.,0.0,-0.5,-0.8660254037844384,0.0,0.5,-0.866025403784439,0.0,1.0,0.0,2.0,0.5,0.8660254037844386,2.0,-0.5,0.8660254037844387,2.0,-1.0,0.,2.0,-0.5,-0.8660254037844384,2.0,0.5,-0.866025403784439,2.0,0.0,0.0,0.0,0.0,0.,2.0,-0.75,0.4330127018922194,1.0,0.0,0.8660254037844386,1.0,0.75,0.4330127018922193,1.0,0.75,-0.4330127018922195,1.0,0.0,-0.8660254037844387,1.0,-0.75,-0.4330127018922191,1.0,0.0,0.,1.0],21,3)
13814         m7CoordsExp.setInfoOnComponents(["X","YY","ZZZ"])
13815         self.assertTrue(c.getCoords().isEqual(m7CoordsExp,1e-12))
13816         del m7,coords,c
13817         #
13818         coords=DataArrayDouble([0.,0.,0.,1.,0.,0.,1.,1.,0.,0.,1.,0.,0.,0.,2.,1.,0.,2.,1.,1.,2.,0.,1.,2.],8,3) ; coords.setInfoOnComponents(["X","YY","ZZZ"])
13819         m8=MEDCouplingUMesh("pyra5",3)
13820         m8.setCoords(coords)
13821         m8.allocateCells(0)
13822         m8.insertNextCell(NORM_PYRA5,[3,2,1,0,7])
13823         st=m8.getCoords().getHiddenCppPointer()
13824         c,a,b=m8.tetrahedrize(PLANAR_FACE_5)
13825         self.assertEqual(m8.getCoords().getHiddenCppPointer(),coords.getHiddenCppPointer())
13826         c.checkCoherency2()
13827         self.assertTrue(a.isEqual(DataArrayInt([0,0])))
13828         self.assertEqual(0,b)
13829         self.assertTrue(c.getNodalConnectivity().isEqual(DataArrayInt([3,2,1,7,3,1,0,7])))
13830         self.assertAlmostEqual(0.6666666666666667,c.getMeasureField(False).accumulate()[0],12)
13831         pass
13832
13833     def testDualMesh3D1(self):
13834         arr=DataArrayDouble(2) ; arr.iota()
13835         c=MEDCouplingCMesh() ; c.setCoords(arr,arr,arr)
13836         m=c.buildUnstructured()
13837         t=m.tetrahedrize(PLANAR_FACE_5)[0]
13838         d=t.computeDualMesh()
13839         self.assertTrue(d.getNodalConnectivityIndex().isEqual(DataArrayInt([0,29,118,207,236,325,354,383,472])))
13840         self.assertTrue(d.getNodalConnectivity().isEqual(DataArrayInt([26,11,42,8,-1,25,8,42,10,-1,29,10,42,11,-1,0,26,8,25,-1,0,25,10,29,-1,0,29,11,26,24,9,42,8,-1,26,8,42,11,-1,27,11,42,9,-1,1,24,8,26,-1,1,26,11,27,-1,30,13,43,12,-1,24,12,43,15,-1,32,15,43,13,-1,1,30,12,24,-1,1,32,13,30,-1,35,17,44,16,-1,32,16,44,19,-1,27,19,44,17,-1,1,35,16,32,-1,1,27,17,35,-1,24,15,46,9,-1,27,9,46,19,-1,32,19,46,15,27,9,42,11,-1,29,11,42,10,-1,28,10,42,9,-1,2,29,10,28,-1,2,27,11,29,-1,27,17,44,19,-1,38,19,44,18,-1,37,18,44,17,-1,2,37,17,27,-1,2,38,18,37,-1,28,21,45,23,-1,41,23,45,22,-1,38,22,45,21,-1,2,41,22,38,-1,2,28,23,41,-1,27,19,46,9,-1,28,9,46,21,-1,38,21,46,19,35,16,44,17,-1,36,18,44,16,-1,37,17,44,18,-1,3,36,16,35,-1,3,35,17,37,-1,3,37,18,36,24,8,42,9,-1,25,10,42,8,-1,28,9,42,10,-1,4,25,8,24,-1,4,28,10,25,-1,24,15,43,12,-1,31,12,43,14,-1,34,14,43,15,-1,4,24,12,31,-1,4,31,14,34,-1,34,21,45,20,-1,40,20,45,23,-1,28,23,45,21,-1,4,34,20,40,-1,4,40,23,28,-1,24,9,46,15,-1,28,21,46,9,-1,34,15,46,21,30,12,43,13,-1,31,14,43,12,-1,33,13,43,14,-1,5,31,12,30,-1,5,30,13,33,-1,5,33,14,31,40,23,45,20,-1,39,20,45,22,-1,41,22,45,23,-1,6,40,20,39,-1,6,39,22,41,-1,6,41,23,40,32,13,43,15,-1,34,15,43,14,-1,33,14,43,13,-1,7,33,13,32,-1,7,34,14,33,-1,32,19,44,16,-1,36,16,44,18,-1,38,18,44,19,-1,7,32,16,36,-1,7,36,18,38,-1,34,20,45,21,-1,39,22,45,20,-1,38,21,45,22,-1,7,39,20,34,-1,7,38,22,39,-1,32,15,46,19,-1,38,19,46,21,-1,34,21,46,15])))
13841         self.assertTrue(d.getCoords().isEqual(DataArrayDouble([0.,0.,0.,1.,0.,0.,0.,1.,0.,1.,1.,0.,0.,0.,1.,1.,0.,1.,0.,1.,1.,1.,1.,1.,0.3333333333333333,0.,0.3333333333333333,0.3333333333333333,0.3333333333333333,0.3333333333333333,0.,0.3333333333333333,0.3333333333333333,0.3333333333333333,0.3333333333333333,0.,0.6666666666666666,0.,0.6666666666666666,1.,0.3333333333333333,0.6666666666666666,0.6666666666666666,0.3333333333333333,1.,0.6666666666666666,0.3333333333333333,0.6666666666666666,1.,0.6666666666666666,0.3333333333333333,0.6666666666666666,0.6666666666666666,0.,0.6666666666666666,1.,0.3333333333333333,0.6666666666666666,0.6666666666666666,0.3333333333333333,0.3333333333333333,0.6666666666666666,1.,0.3333333333333333,0.6666666666666666,0.6666666666666666,0.3333333333333333,1.,0.6666666666666666,0.,0.6666666666666666,0.6666666666666666,0.5,0.,0.5,0.,0.,0.5,0.5,0.,0.,0.5,0.5,0.,0.,0.5,0.5,0.,0.5,0.,1.,0.,0.5,0.5,0.,1.,1.,0.5,0.5,1.,0.5,1.,0.5,0.5,1.,1.,0.5,0.,1.,1.,0.5,0.5,1.,0.,0.5,1.,0.5,0.5,1.,1.,0.,0.5,1.,0.,1.,0.5,0.25,0.25,0.25,0.75,0.25,0.75,0.75,0.75,0.25,0.25,0.75,0.75,0.5,0.5,0.5],47,3),1e-12))
13842         self.assertAlmostEqual(1.,d.getMeasureField(False).accumulate()[0],1e-13)
13843         pass
13844
13845     def testDualMesh2D1(self):
13846         arr=DataArrayDouble(5) ; arr.iota()
13847         c=MEDCouplingCMesh() ; c.setCoords(arr,arr)
13848         m=c.buildUnstructured()
13849         m.simplexize(0)
13850         t=MEDCoupling1SGTUMesh(m)
13851         d=t.computeDualMesh()
13852         self.assertTrue(d.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4,12,20,28,34,42,54,66,78,86,94,106,118,130,138,146,158,170,182,190,196,204,212,220,224])))
13853         self.assertTrue(d.getNodalConnectivity().isEqual(DataArrayInt([26,81,25,0,25,81,27,82,29,83,30,1,30,83,31,84,33,85,34,2,34,85,35,86,37,87,38,3,38,87,39,88,41,4,27,81,26,5,42,89,28,82,29,82,28,89,43,90,45,91,32,84,31,83,33,84,32,91,46,92,48,93,36,86,35,85,37,86,36,93,49,94,51,95,40,88,39,87,41,88,40,95,52,96,54,9,43,89,42,10,55,97,44,90,45,90,44,97,56,98,58,99,47,92,46,91,48,92,47,99,59,100,61,101,50,94,49,93,51,94,50,101,62,102,64,103,53,96,52,95,54,96,53,103,65,104,67,14,56,97,55,15,68,105,57,98,58,98,57,105,69,106,71,107,60,100,59,99,61,100,60,107,72,108,74,109,63,102,62,101,64,102,63,109,75,110,77,111,66,104,65,103,67,104,66,111,78,112,80,19,69,105,68,20,70,106,71,106,70,21,73,108,72,107,74,108,73,22,76,110,75,109,77,110,76,23,79,112,78,111,80,112,79,24])))
13854         self.assertTrue(d.getCoords().isEqual(DataArrayDouble([0.,0.,1.,0.,2.,0.,3.,0.,4.,0.,0.,1.,1.,1.,2.,1.,3.,1.,4.,1.,0.,2.,1.,2.,2.,2.,3.,2.,4.,2.,0.,3.,1.,3.,2.,3.,3.,3.,4.,3.,0.,4.,1.,4.,2.,4.,3.,4.,4.,4.,0.5,0.,0.,0.5,0.5,0.5,0.5,1.,1.,0.5,1.5,0.,1.5,0.5,1.5,1.,2.,0.5,2.5,0.,2.5,0.5,2.5,1.,3.,0.5,3.5,0.,3.5,0.5,3.5,1.,4.,0.5,0.,1.5,0.5,1.5,0.5,2.,1.,1.5,1.5,1.5,1.5,2.,2.,1.5,2.5,1.5,2.5,2.,3.,1.5,3.5,1.5,3.5,2.,4.,1.5,0.,2.5,0.5,2.5,0.5,3.,1.,2.5,1.5,2.5,1.5,3.,2.,2.5,2.5,2.5,2.5,3.,3.,2.5,3.5,2.5,3.5,3.,4.,2.5,0.,3.5,0.5,3.5,0.5,4.,1.,3.5,1.5,3.5,1.5,4.,2.,3.5,2.5,3.5,2.5,4.,3.,3.5,3.5,3.5,3.5,4.,4.,3.5,0.3333333333333333,0.3333333333333333,0.6666666666666666,0.6666666666666666,1.3333333333333333,0.3333333333333333,1.6666666666666665,0.6666666666666666,2.333333333333333,0.3333333333333333,2.6666666666666665,0.6666666666666666,3.333333333333333,0.3333333333333333,3.6666666666666665,0.6666666666666666,0.3333333333333333,1.3333333333333333,0.6666666666666666,1.6666666666666665,1.3333333333333333,1.3333333333333333,1.6666666666666665,1.6666666666666665,2.333333333333333,1.3333333333333333,2.6666666666666665,1.6666666666666665,3.333333333333333,1.3333333333333333,3.6666666666666665,1.6666666666666665,0.3333333333333333,2.333333333333333,0.6666666666666666,2.6666666666666665,1.3333333333333333,2.333333333333333,1.6666666666666665,2.6666666666666665,2.333333333333333,2.333333333333333,2.6666666666666665,2.6666666666666665,3.333333333333333,2.333333333333333,3.6666666666666665,2.6666666666666665,0.3333333333333333,3.333333333333333,0.6666666666666666,3.6666666666666665,1.3333333333333333,3.333333333333333,1.6666666666666665,3.6666666666666665,2.333333333333333,3.333333333333333,2.6666666666666665,3.6666666666666665,3.333333333333333,3.333333333333333,3.6666666666666665,3.6666666666666665],113,2),1e-12))
13855         self.assertAlmostEqual(16.,d.getMeasureField(False).accumulate()[0],1e-13)
13856         pass
13857
13858     def testSwig2LoadBalanceBBox1(self):
13859         arr=DataArrayDouble(5) ; arr.iota()
13860         t=MEDCouplingCMesh() ; t.setCoords(arr,arr)
13861         arr=DataArrayDouble(16) ; arr.iota() ; arr*=2./15
13862         s=MEDCouplingCMesh() ; s.setCoords(arr,arr[:]) ; s.translate([2.,1.])
13863         #
13864         s1=s.build1SGTUnstructured()
13865         t1=t.build1SGTUnstructured()
13866         w=MEDCouplingPointSet.ComputeNbOfInteractionsWithSrcCells(s1,t1,1e-12)
13867         wExp=DataArrayInt([0,0,0,0,0,0,64,64,0,0,64,64,0,0,0,0])
13868         self.assertTrue(w.isEqual(wExp))
13869         slcs=w.splitInBalancedSlices(4)
13870         self.assertEqual(len(slcs),4)
13871         self.assertEqual(slcs,[slice(0,7,1),slice(7,8,1),slice(8,11,1),slice(11,16,1)])
13872         bbs=s1.getBoundingBoxForBBTree()
13873         bbt=t1.getBoundingBoxForBBTree()
13874         self.assertTrue(bbt.computeNbOfInteractionsWith(bbs,1e-12).isEqual(wExp))
13875         pass
13876
13877     def testKrSpatialDiscretization2(self):
13878         srcPointCoordsXY=DataArrayDouble([0.8401877171547095,0.39438292681909304,0.7830992237586059,0.7984400334760733,0.9116473579367843,0.19755136929338396,0.335222755714889,0.768229594811904,0.2777747108031878,0.5539699557954305,0.47739705186216025,0.6288709247619244,0.36478447279184334,0.5134009101956155,0.9522297251747128,0.9161950680037007,0.6357117279599009,0.7172969294326831,0.14160255535580338,0.6069688762570586,0.01630057162432958,0.24288677062973696,0.13723157678601872,0.8041767542269904,0.15667908925408455,0.4009443942461835,0.12979044678145574,0.10880880202576929,0.998924518003559,0.21825690531090688,0.5129323944043984,0.8391122346926072,0.6126398325956612,0.29603161769734304,0.6375522677030192,0.5242871900667843,0.493582986990727,0.9727750238835695,0.29251678441302703,0.7713576977939148,0.5267449792133388,0.7699138362751873,0.4002286220901779,0.8915294520051822,0.2833147460051415,0.3524583472648907,0.8077245200088827,0.9190264739650424,0.06975527623191256,0.9493270753646861,0.5259953502221011,0.08605584785624214,0.19221384599442307,0.6632269270081198,0.8902326025488938,0.3488929352485076,0.06417132078864207,0.02002304886468828,0.4577017372742769,0.06309583832653977,0.23827995417559517,0.9706341316786754,0.9022080734848082,0.8509197867712563,0.2666657493760184,0.5397603407221662,0.3752069763723793,0.7602487363667454,0.5125353641400744,0.6677237607854063,0.5316064341606602,0.039280343353413204,0.4376375965949323,0.9318350562508382,0.9308097953585953,0.7209523430657351,0.28429340305006756,0.7385343149018168,0.6399788165651163,0.3540486797476414,0.687861390266503,0.16597416632155615,0.4401045276038835,0.880075236260926,0.829201093329676,0.3303371296871161,0.22896817104377232,0.8933724145839793,0.35036017855180435,0.6866699083180492,0.9564682529105192,0.5886401331930609,0.6573040395310633,0.8586763259296661,0.4395599194986559,0.9239697889070817,0.39843666665183225,0.8147668963366965,0.6842185252738271,0.9109720307919067,0.4824906566564416,0.21582495896882609,0.9502523741453198,0.9201282537170352,0.14766001475400292,0.8810621695039152,0.641080596317109,0.43195341826973177,0.6195964839400707,0.281059412416564,0.7860020980173732,0.3074578737409124,0.44703357920378145,0.22610662515559543,0.18753310953617705,0.27623467206779617,0.5564437553083728,0.4165012805799494,0.16960708618611428,0.9068039338601771,0.10317118843233734,0.1260753390966334,0.49544406658757667,0.7604752284290619,0.9847516650262995,0.9350039865518939,0.6844450168704823,0.3831883312124705,0.7497708824229291,0.36866354167864823,0.2941603620043771,0.2322615386137094,0.5844885006474743,0.24441273568403568,0.15238979186508328,0.7321485158671385,0.12547490472228962,0.7934703881821923,0.164101933671209,0.7450713891280216,0.07452980059875632,0.9501040316885822,0.05252926240327268,0.5215633798025378,0.1762106563785163,0.24006237240511102,0.797798051870334,0.732654411686889,0.6565636529850605,0.9674051385221095,0.6394583455470663,0.7597348418830591,0.09348047715308166,0.13490241166898162,0.5202100698464597,0.07823214171371988,0.06990639775521419,0.2046550862512808,0.4614204733918516,0.8196772801781433,0.5733186283955903,0.7555808353962288,0.05193881879185271,0.1578071285774033,0.9999935710802644,0.204328610656936,0.8899556444445419,0.12546847580255405,0.9977989993047895,0.054057577650089554,0.8705398649305757,0.07232879943788462,0.004161608873010431,0.9230691273338484,0.5938921792404224,0.180372265717188,0.16313149927329806,0.3916902306450951,0.9130266774040771,0.8196951527240198,0.35909536870154335,0.552485022485482,0.5794299941414176,0.452575845854625,0.687387434620125,0.09964006352221597,0.5308079880340062,0.7572938323753392,0.30429514977349675,0.9922284614258579,0.5769711125534824,0.877613778169087,0.7478092963564253,0.6289099313453351,0.03542090674649035,0.7478028669710285,0.8332385420022712,0.9253765511910322,0.8732713427735824,0.8310375408413995],100,2)
13879         srcFieldValsOnPoints=DataArrayDouble([0.7643742528498438,-0.023507696856211995,1.1082895131907775,0.6299357452572031,0.8892623544912389,0.72212114810697,0.9196401044320336,-0.759961711221917,0.40801932617748826,0.8441134300809151,0.982483804252809,0.6752368914020778,0.9924403977479798,1.1063334970204484,0.9403055261137516,0.3624481886322733,1.1344772505996308,0.7522965618948239,0.17077741651388564,0.6504551671311436,0.45843479588425423,0.41098905950326753,1.0681420394050904,-0.3483587903820091,0.5620151050607809,1.384969776596035,0.7948875141132845,0.7931192000237167,1.062498042490183,1.3709072529577366,0.44929346605311893,-0.4469683401788374,0.9035857424514101,0.6137249300593463,0.6355610879026966,1.4318174829507697,0.3097567072129551,-0.20515052260807165,0.6922559820922779,1.0341638749443423,1.3072652153341024,0.38511367353000436,0.9160514929274943,0.54513408530581,0.722252267913328,0.06684522818576251,0.10571899758067793,0.3193844999960903,0.5213532270828706,-0.04834998649603944,1.2408805068350615,-0.7632951295676795,0.5980054665011202,0.9064738717547436,1.1541070755096696,1.008234260272265,1.2225806960553827,1.0788560195121106,0.9818990282104452,0.5621951325841853,1.0796757508374188,0.5082872315589883,-0.9153702001062469,0.9560418838920791,0.9251098559152824,1.1603063610984021,1.2122303611181837,0.7379539363312343,0.6877611899207183,0.723966552446608,0.5596025827162566,0.8849725005989729,1.0908363665075547,0.08956512916455672,-0.10247645571248344,0.3236718069555875,1.069478546398975,1.3900071080692746,1.0322398863403262,0.45315515354558034,0.4249870238786733,1.030226761858634,0.974024629584669,1.2838885424020365,1.3451943506525155,1.4029933267831995,0.6025539675442462,1.2947650597767038,1.0006061239483002,-0.4017336259949164,0.8771165113201297,0.9158909024218246,1.403798605551443,0.4742904006425974,0.3671787905896653,0.20646491720419674,0.40739337434288925,0.7341932402033597,-0.4295893651836911,-0.3187777570661546],100,1)
13880         targetPointCoordsXY=DataArrayDouble([-0.5,-0.5,-0.5,-0.35,-0.5,-0.2,-0.5,-0.05,-0.5,0.1,-0.5,0.25,-0.5,0.4,-0.5,0.55,-0.5,0.7,-0.5,0.85,-0.5,1.0,-0.5,1.15,-0.5,1.3,-0.5,1.45,-0.35,-0.5,-0.35,-0.35,-0.35,-0.2,-0.35,-0.05,-0.35,0.1,-0.35,0.25,-0.35,0.4,-0.35,0.55,-0.35,0.7,-0.35,0.85,-0.35,1.0,-0.35,1.15,-0.35,1.3,-0.35,1.45,-0.2,-0.5,-0.2,-0.35,-0.2,-0.2,-0.2,-0.05,-0.2,0.1,-0.2,0.25,-0.2,0.4,-0.2,0.55,-0.2,0.7,-0.2,0.85,-0.2,1.0,-0.2,1.15,-0.2,1.3,-0.2,1.45,-0.05,-0.5,-0.05,-0.35,-0.05,-0.2,-0.05,-0.05,-0.05,0.1,-0.05,0.25,-0.05,0.4,-0.05,0.55,-0.05,0.7,-0.05,0.85,-0.05,1.0,-0.05,1.15,-0.05,1.3,-0.05,1.45,0.1,-0.5,0.1,-0.35,0.1,-0.2,0.1,-0.05,0.1,0.1,0.1,0.25,0.1,0.4,0.1,0.55,0.1,0.7,0.1,0.85,0.1,1.0,0.1,1.15,0.1,1.3,0.1,1.45,0.25,-0.5,0.25,-0.35,0.25,-0.2,0.25,-0.05,0.25,0.1,0.25,0.25,0.25,0.4,0.25,0.55,0.25,0.7,0.25,0.85,0.25,1.0,0.25,1.15,0.25,1.3,0.25,1.45,0.4,-0.5,0.4,-0.35,0.4,-0.2,0.4,-0.05,0.4,0.1,0.4,0.25,0.4,0.4,0.4,0.55,0.4,0.7,0.4,0.85,0.4,1.0,0.4,1.15,0.4,1.3,0.4,1.45,0.55,-0.5,0.55,-0.35,0.55,-0.2,0.55,-0.05,0.55,0.1,0.55,0.25,0.55,0.4,0.55,0.55,0.55,0.7,0.55,0.85,0.55,1.0,0.55,1.15,0.55,1.3,0.55,1.45,0.7,-0.5,0.7,-0.35,0.7,-0.2,0.7,-0.05,0.7,0.1,0.7,0.25,0.7,0.4,0.7,0.55,0.7,0.7,0.7,0.85,0.7,1.0,0.7,1.15,0.7,1.3,0.7,1.45,0.85,-0.5,0.85,-0.35,0.85,-0.2,0.85,-0.05,0.85,0.1,0.85,0.25,0.85,0.4,0.85,0.55,0.85,0.7,0.85,0.85,0.85,1.0,0.85,1.15,0.85,1.3,0.85,1.45,1.0,-0.5,1.0,-0.35,1.0,-0.2,1.0,-0.05,1.0,0.1,1.0,0.25,1.0,0.4,1.0,0.55,1.0,0.7,1.0,0.85,1.0,1.0,1.0,1.15,1.0,1.3,1.0,1.45,1.15,-0.5,1.15,-0.35,1.15,-0.2,1.15,-0.05,1.15,0.1,1.15,0.25,1.15,0.4,1.15,0.55,1.15,0.7,1.15,0.85,1.15,1.0,1.15,1.15,1.15,1.3,1.15,1.45,1.3,-0.5,1.3,-0.35,1.3,-0.2,1.3,-0.05,1.3,0.1,1.3,0.25,1.3,0.4,1.3,0.55,1.3,0.7,1.3,0.85,1.3,1.0,1.3,1.15,1.3,1.3,1.3,1.45,1.45,-0.5,1.45,-0.35,1.45,-0.2,1.45,-0.05,1.45,0.1,1.45,0.25,1.45,0.4,1.45,0.55,1.45,0.7,1.45,0.85,1.45,1.0,1.45,1.15,1.45,1.3,1.45,1.45],196,2)
13881         targetFieldValsExpected=DataArrayDouble([1.645976003316459, 1.454458180060204, 1.286087532859835, 1.147305389930914, 1.040143042030752, 0.9592075185603157, 0.8932542207607532, 0.8296417057622609, 0.7572539678257579, 0.6669048311361028, 0.551329882743212, 0.4064445075734602, 0.2323703965460786, 0.03253142054561309, 1.615321686989539, 1.414941300553572, 1.238383118538708, 1.096701655702075, 0.9955792747382535, 0.9271194507282707, 0.8741000712825546, 0.8201879508155141, 0.7537335933761495, 0.6656210809234322, 0.5470285414729397, 0.3927301586610237, 0.2044036897887453, -0.01181672742825013, 1.609602552867195, 1.400625195269133, 1.213287847440801, 1.065318574929208, 0.9717609562002842, 0.9182626517777217, 0.8760698972315855, 0.8258196104516153, 0.7586487405165288, 0.6686168424854784, 0.5434121624038266, 0.3741815029337978, 0.1661376046619205, -0.0704038088420833, 1.635421686625182, 1.422642113482769, 1.225977424080963, 1.066864693789366, 0.9864801043792362, 0.9486639217909161, 0.9075176697327381, 0.8471248730261529, 0.7660983406349626, 0.6675300501188994, 0.5320013361909732, 0.3404583135353376, 0.1074346390951333, -0.1520751802856468, 1.695346918429566, 1.489526279573347, 1.297678617961701, 1.139921240332637, 1.080508463804929, 1.036847769764088, 0.9687840669352359, 0.8790397822170175, 0.76938768351059, 0.6441978169925557, 0.4915328571013788, 0.2742929463574293, 0.0148214290833748, -0.2671755287427691, 1.782761788232491, 1.59423004798623, 1.422317125787222, 1.286999529473285, 1.20500638941831, 1.127058114031519, 1.022332539190471, 0.8945753999401338, 0.7469190939381181, 0.582396906110898, 0.4015920181411496, 0.1584700483835366, -0.1251860255418387, -0.4254052799545267, 1.881794862747652, 1.712890309994015, 1.557517508390291, 1.422727414977963, 1.308048056353061, 1.187569766723152, 1.03942150436647, 0.8677583087532357, 0.6766652050643343, 0.4703897480238999, 0.2497994532908829, -0.02005989176786582, -0.3224387891441491, -0.6331519303649853, 1.973114284621266, 1.820187301531605, 1.673403730111759, 1.528504440482262, 1.379693463484634, 1.207642134784147, 1.008217764780293, 0.7863328498822348, 0.5465383049529959, 0.2944879513187435, 0.03250657765404452, -0.2670900851421072, -0.5806516907976924, -0.8911331026431459, 2.038729888975378, 1.895652364645637, 1.751759791756183, 1.594035761810714, 1.403016809171641, 1.171403152610878, 0.913267035125007, 0.6343281031932027, 0.3434843176189371, 0.04195410032095204, -0.2645533663891493, -0.58577400250975, -0.8958218846257981, -1.192230697656513, 2.064018033720731, 1.922048791644444, 1.773847180028208, 1.600340336378483, 1.361620036333164, 1.060873411411508, 0.7373484802125152, 0.3868966266761109, 0.04316272760227413, -0.3009370030949727, -0.6505233805563486, -0.9669887470696283, -1.250005719852354, -1.519122595631787, 2.039938287785342, 1.887400820799651, 1.722008733683987, 1.523879290022419, 1.23834392230135, 0.8606985727866472, 0.4844892131548788, 0.08077959236877175, -0.3195742594962179, -0.726291368696764, -1.094357645641832, -1.359078900303776, -1.604725656501341, -1.845297168323687, 1.965762248218393, 1.791665198563286, 1.595056719739704, 1.353692777435502, 1.033006623003495, 0.6416349531117889, 0.2290046916364761, -0.1993180965088852, -0.6311618804827295, -1.051489875129883, -1.409404344854132, -1.681249363331096, -1.917859637689007, -2.145034400762945, 1.849053542205925, 1.648479366622312, 1.418493963148431, 1.141939527533839, 0.8042385795619003, 0.4127534639189761, -0.008572116677791453, -0.4428317297963555, -0.8745477268718713, -1.281769237471681, -1.635421857742795, -1.926210204560556, -2.175577364628722, -2.405762639746138, 1.701519686999922, 1.475879908746998, 1.219065416294153, 0.9203732349759972, 0.5740137315474942, 0.1856460506119944, -0.2298288912529738, -0.6558565521653752, -1.075391078040103, -1.469402631469075, -1.820558929095151, -2.123592211415966, -2.388177455227765, -2.628832075944413])
13882         coeffsExpected=DataArrayDouble([0.3953237723894342,-0.17220705170185724,0.620727139132215,-0.01938292763088709,-0.007524685306185282,0.0016277944443884584,-0.0005209587893117361,-1.8992696595839718,-0.13154330748345855,0.11248800965389728,-0.47310750305033406,0.03685741122098605,0.21362468750754374,0.8082608687799991,-0.6775548200221704,-0.027683208482275873,-0.007806877014495724,-0.013539239795959668,0.3478535665778018,0.005145793726360813,0.03708618549628136,-0.18235332489209385,-0.04517273339177797,-0.081755114492025,0.12791746560435255,0.09659355695676189,-0.024809653129318366,0.08327587452569823,-1.790380673650165,-0.10622983512164165,0.14989029282340274,0.05949513762355707,0.004548072841131278,0.011252095917834793,-0.004848057194721367,-0.2658537133108412,0.016651579133606154,-0.021640915366981317,0.008975511042160175,-0.021052213988815974,-0.09347841701844657,0.03533229488135717,-0.014556185287109863,-0.27228591670520086,0.002989987191209683,-0.5489428537951813,-0.02134456783001304,-0.22462281620064825,0.005230853443767429,-0.1894678262257301,0.0033140729457334884,5.295483062326795,-0.2724500716060311,0.026433905662192683,0.01368706308878908,-0.03014264855048227,0.053679001877659956,0.08109477254132096,-0.005004603067203444,0.016907143132293558,0.2105509502082437,0.003657404455024417,-4.904755847017426,0.01634808163992959,-0.008325515865305198,0.062188432751569676,-0.013114633511406406,0.11020519384963083,-0.008599402366091309,-0.012125149710784723,0.31723729052927313,-0.10298398036815914,-0.07250078775612204,0.39976713701763433,0.45897498107347223,0.01018626210400031,0.20163425809089347,0.19729093298588943,0.42863333455911523,0.015595097081693168,0.06060353651437489,-0.16379444813161725,-0.43290344196574165,-0.5931022701412187,1.1906610004748832,0.44418106894148945,0.06536220001548931,0.010261694323554562,-0.05943099382075491,-0.04939614579484797,0.002234505477641322,-0.011262130967449935,0.09644905007708474,-0.029518792883267808,0.41564004027396634,-0.18459770295961597,0.3100981306103734,-0.2509873737065425,0.5434321443668653,0.3009912967350914,1.9560655796099518,-0.7143435150084513,-1.5123449469879784])
13883         #
13884         nbOfInputPoints=100;
13885         f=MEDCouplingFieldDouble.New(ON_NODES_KR,ONE_TIME);
13886         mesh=MEDCoupling1SGTUMesh.New("aMesh",NORM_POINT1);
13887         mesh.setCoords(srcPointCoordsXY);
13888         f.setMesh(mesh);
13889         f.setArray(srcFieldValsOnPoints);
13890         f.checkCoherency();
13891         #
13892         res0=f.getValueOn([-0.5,-0.5]);
13893         self.assertAlmostEqual(targetFieldValsExpected.getIJ(0,0),res0[0],10)
13894         #
13895         valuesToTest=f.getValueOnMulti(targetPointCoordsXY);
13896         self.assertEqual(196,valuesToTest.getNumberOfTuples());
13897         self.assertEqual(1,valuesToTest.getNumberOfComponents());
13898         for i in xrange(40):
13899             self.assertAlmostEqual(targetFieldValsExpected[i],valuesToTest.getIJ(i,0),10)
13900             pass
13901         fd=f.getDiscretization()
13902         del f
13903         self.assertTrue(isinstance(fd,MEDCouplingFieldDiscretizationKriging))
13904         coeffs,isDrift=fd.computeVectorOfCoefficients(mesh,srcFieldValsOnPoints)
13905         self.assertEqual(3,isDrift)
13906         self.assertTrue(coeffsExpected.isEqual(coeffs,1e-8))
13907         # testing matrix
13908         pts3=[-0.5,-0.5,-0.5,-0.35,-0.35,-0.2]
13909         mesh.setCoords(srcPointCoordsXY[:4])
13910         m,nbCols=fd.computeEvaluationMatrixOnGivenPts(mesh,pts3)
13911         self.assertTrue(m.isEqual(DataArrayDouble([0.05768877688524917,-4.438982030395039,1.9495386255911573,3.431754627918642,0.11803848510231275,-4.138339658420563,1.6630742187104417,3.357226954607818,0.14630203028580618,-3.5156045565871734,1.414680070737206,2.954622455564169]),1e-12))
13912         if MEDCouplingHasNumPyBindings():
13913             import numpy as np
13914             m0=m.toNumPyArray() ; m0=m0.reshape(3,nbCols) ; m0=np.matrix(m0)
13915             srcFieldValsOnPoints2=DataArrayDouble(4,2) ; srcFieldValsOnPoints2[:,0]=srcFieldValsOnPoints[:4] ; srcFieldValsOnPoints2[:,1]=2*srcFieldValsOnPoints[:4]
13916             n0=srcFieldValsOnPoints2.toNumPyArray() ; n0=n0.reshape(4,2) ; n0=np.matrix(n0)
13917             #
13918             f=MEDCouplingFieldDouble.New(ON_NODES_KR,ONE_TIME) ;  f.setMesh(mesh) ; f.setArray(srcFieldValsOnPoints2) ; f.checkCoherency()
13919             self.assertTrue(DataArrayDouble(np.array((m0*n0))).isEqual(f.getValueOnMulti(pts3),1e-14))
13920             pass
13921         #
13922         pass
13923
13924     # test the when input slice is all the same object is return by MEDCouplingMesh.buildPartRange
13925     def testSwig2MeshPartSlice1(self):
13926         a=DataArrayDouble(4) ; a.iota()
13927         c=MEDCouplingCMesh() ; c.setCoords(a,a) ; m=c.buildUnstructured()
13928         fc0=c.getMeasureField(False) ; fc1=fc0[:] ; fc2=fc0*fc1 ; fc2.setName(fc0.getName())
13929         self.assertEqual(fc0.getMesh().getHiddenCppPointer(),fc1.getMesh().getHiddenCppPointer())
13930         self.assertEqual(fc2.getMesh().getHiddenCppPointer(),fc1.getMesh().getHiddenCppPointer())
13931         self.assertTrue(fc2.isEqual(fc1,1e-12,1e-12))
13932         #
13933         fm0=m.getMeasureField(False) ; fm1=fm0[:] ; fm2=fm0*fm1 ; fm2.setName(fm0.getName())
13934         self.assertEqual(fm0.getMesh().getHiddenCppPointer(),fm1.getMesh().getHiddenCppPointer())
13935         self.assertEqual(fm2.getMesh().getHiddenCppPointer(),fm1.getMesh().getHiddenCppPointer())
13936         self.assertTrue(fm2.isEqual(fm1,1e-12,1e-12))
13937         pass
13938
13939     # test the correct behaviour when attempting to aggregate two fields whose mesh is null
13940     def testSwig2MergeFieldsOnFieldsHavingNoMesh(self):
13941         a=DataArrayDouble(4) ; a.iota() ; a*=1.5
13942         c=MEDCouplingCMesh() ; c.setCoords(a,a) ; f1=c.getMeasureField(False)
13943         f1.setMesh(None) ; f2=f1.deepCpy() ; f2*=2
13944         f3=MEDCouplingFieldDouble.MergeFields(f1,f2)
13945         daExp=DataArrayDouble([2.25,2.25,2.25,2.25,2.25,2.25,2.25,2.25,2.25,4.5,4.5,4.5,4.5,4.5,4.5,4.5,4.5,4.5])
13946         self.assertTrue(f3.getArray().isEqual(daExp,1e-12))
13947         self.assertEqual(f3.getTypeOfField(),ON_CELLS)
13948         self.assertEqual(f3.getMesh(),None)
13949         f4=MEDCouplingFieldDouble.MergeFields([f1,f2])
13950         self.assertTrue(f4.getArray().isEqual(daExp,1e-12))
13951         self.assertEqual(f4.getTypeOfField(),ON_CELLS)
13952         self.assertEqual(f4.getMesh(),None)
13953         pass
13954
13955     # test a simple node to cell convertion of a field
13956     def testSwig2NodeToCellDiscretization1(self):
13957         f=MEDCouplingFieldDouble(ON_NODES) ; f.setTime(1.1,2,3)
13958         a1=DataArrayDouble(4) ; a1.iota()
13959         a2=DataArrayDouble(3) ; a2.iota()
13960         m=MEDCouplingCMesh() ; m.setCoords(a1,a2)
13961         f.setMesh(m)
13962         arr=DataArrayDouble([21.,121.,20.,120.,19.,119.,18.,118.,17.,117.,16.,116.,15.,115.,14.,114.,13.,113.,12.,112.,11.,111.,10.,110.],12,2) ; arr.setInfoOnComponents(["aa [km]","bbb [kJ]"])
13963         f.setArray(arr) ; f.setName("toto")
13964         #
13965         f2=f.nodeToCellDiscretization()
13966         self.assertEqual(ON_CELLS,f2.getTypeOfField())
13967         self.assertEqual("toto",f2.getName())
13968         self.assertEqual([1.1,2,3],f2.getTime())
13969         self.assertEqual(["aa [km]","bbb [kJ]"],f2.getArray().getInfoOnComponents())
13970         self.assertEqual(6,f2.getArray().getNumberOfTuples())
13971         self.assertEqual(f.getMesh().getHiddenCppPointer(),f2.getMesh().getHiddenCppPointer())
13972         exp=DataArrayDouble([18.5,118.5,17.5,117.5,16.5,116.5,14.5,114.5,13.5,113.5,12.5,112.5],6,2) ; exp.setInfoOnComponents(["aa [km]","bbb [kJ]"])
13973         self.assertTrue(f2.getArray().isEqual(exp,1e-13))
13974         pass
13975
13976     def testSwig2NonRegressionBugIntersectMeshes1(self):
13977         src=MEDCouplingUMesh("src",2)
13978         src.setCoords(DataArrayDouble([-2.5,-3,-2.5,3,2.5,3],3,2))
13979         src.allocateCells()
13980         src.insertNextCell(NORM_TRI3,[0,1,2])
13981         #
13982         trg=MEDCouplingUMesh("trg",2)
13983         trg.setCoords(DataArrayDouble([-2.5,-3.,0.,-3.,0.,-2.,-2.,0.,-2.25,0.,-2.5,0.,-2.5,-1.5,0.,-2.5,-1.25,-3.,-1.414213562373095,-1.414213562373095],10,2))
13984         trg.allocateCells()
13985         trg.insertNextCell(NORM_QPOLYG,[2,1,0,5,3,7,8,6,4,9])
13986         #
13987         a,b,c=MEDCouplingUMesh.Intersect2DMeshes(src,trg,1.0e-8)
13988         a.mergeNodes(1e-8)
13989         self.assertTrue(a.getCoords().isEqual(DataArrayDouble([-2.5,-3.,-2.5,3.,2.5,3.,0.,-3.,0.,-2.,-2.,0.,-2.25,0.,-2.5,0.,-2.5,-1.5,0.,-2.5,-1.25,-3.,-1.414213562373095,-1.414213562373095,-1.2803687993289596,-1.5364425591947515,-1.8901843996644798,-2.2682212795973755,-1.81117884244736,-0.8483107924994473,-2.5,1.5,0.,3.,0.6098156003355202,0.7317787204026243],18,2),1e-12))
13990         self.assertTrue(a.getNodalConnectivity().isEqual(DataArrayInt([32,12,0,7,5,13,8,6,14,32,7,1,2,12,5,15,16,17,14,6])))
13991         self.assertTrue(a.getNodalConnectivityIndex().isEqual(DataArrayInt([0,9,20])))
13992         self.assertTrue(b.isEqual(DataArrayInt([0,0])))
13993         self.assertTrue(c.isEqual(DataArrayInt([0,-1])))
13994         pass
13995
13996     def testSwig2MeshOrientCorrectly2DCells1(self):
13997         m=MEDCouplingUMesh("mesh",2)
13998         coo=DataArrayDouble([1.,0.,0.5,-0.1,0.,1.,0.,0.,0.07,0.5,0.59,0.5],6,2)
13999         m.setCoords(coo)
14000         m.allocateCells()
14001         m.insertNextCell(NORM_TRI6,[3,0,2,1,5,4])
14002         m.insertNextCell(NORM_QPOLYG,[3,0,2,1,5,4])
14003         self.assertTrue(DataArrayDouble([-0.58093333350930543,-0.58093333350930543]).isEqual(m.getMeasureField(False).getArray(),1e-12))
14004         m.changeSpaceDimension(3)
14005         m.orientCorrectly2DCells([0.,0.,-1.],False)
14006         #
14007         m.checkCoherency()
14008         self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([6,3,2,0,4,5,1, 32,3,2,0,4,5,1])))
14009         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,7,14])))
14010         m.changeSpaceDimension(2)
14011         self.assertTrue(DataArrayDouble([0.58093333350930543,0.58093333350930543]).isEqual(m.getMeasureField(False).getArray(),1e-12))
14012         pass
14013
14014     def testSwig2Hexa8HavingFacesWarped1(self):
14015         """ This test is bases on a "error" of interpolation detected. After investigation cell #3 of src is warped that leads to the fact that when trg is
14016         intersected with src the sum of intersection volume is greater than the volume of the trg cell.
14017         A test that can be done is to split the cell #3 of src into tetrohedrons and by summing all the volumes it does not fit the volume computed of cell#3 unsplitted (expect for
14018         GENERAL_24).
14019         """
14020         srcCoo=DataArrayDouble([0.15694071546650565,0.09383333333333337,6.920842121738133,0.15774332475430292,0.185486666666667,6.920682472824616,0.1585459340420992,0.27713999999999994,6.9205228239111,0.07427195882345167,0.05782666666666668,6.937285959830335,0.06343673343819695,0.11347333333333297,6.939441220162809,0.05260150805294228,0.16911999999999996,6.941596480495282,0.014076262238703396,0.04800666666666667,6.949259628344076,0.014076262238703396,0.07092000000000007,6.949259628344076,0.15407499632681992,0.09383333333333338,6.897607484780063,0.15489234394181514,0.18548666666666702,6.897567331066572,0.15570969155680933,0.27714,6.897527177353081,0.06988819198237989,0.05782666666666669,6.901743317269663,0.05885399917995321,0.11347333333333298,6.9022853924017955,0.047819806377526586,0.16912,6.902827467533927,0.0085871208577874,0.048006666666666684,6.9047548457815076,0.0085871208577874,0.07092000000000008,6.9047548457815076,0.153883333333333,0.09383333333333338,6.820902,0.154701666666667,0.18548666666666702,6.820902,0.15551999999999996,0.27714,6.820902,0.06959499999999999,0.05782666666666669,6.820902,0.058547499999999975,0.11347333333333298,6.820902,0.04749999999999999,0.16912,6.820902],22,3)
14021         src=MEDCouplingUMesh("TBmesh3D",3) ; src.setCoords(srcCoo)
14022         src.allocateCells()
14023         src.insertNextCell(NORM_HEXA8,[0,1,4,3,8,9,12,11])
14024         src.insertNextCell(NORM_HEXA8,[1,2,5,4,9,10,13,12])
14025         src.insertNextCell(NORM_HEXA8,[4,5,7,6,12,13,15,14])
14026         src.insertNextCell(NORM_HEXA8,[8,9,12,11,16,17,20,19])
14027         src.insertNextCell(NORM_HEXA8,[9,10,13,12,17,18,21,20])
14028         src.checkCoherency2()
14029         # trg is useless here but I keep it in case of MEDCouplingRemapper were expected to do something about warped NORM_HEXA8
14030         trgCoo=DataArrayDouble([0.0960891897852753,0.105088620541845,6.8598,0.0599574480546212,0.118434267436059,6.8598,0.113514510609589,0.14874473653263,6.8598,0.0831322609794463,0.167319109733883,6.8598,0.0960891897852753,0.105088620541845,6.92146666666667,0.0599574480546212,0.118434267436059,6.92146666666667,0.113514510609589,0.14874473653263,6.92146666666667,0.0831322609794463,0.167319109733883,6.92146666666667],8,3)
14031         trg=MEDCouplingUMesh("MESH",3) ; trg.setCoords(trgCoo)
14032         trg.allocateCells()
14033         trg.insertNextCell(NORM_HEXA8,[0,1,3,2,4,5,7,6])
14034         #
14035         srcFace=src.buildDescendingConnectivity()[0]
14036         conn=MEDCoupling1SGTUMesh(srcFace).getNodalConnectivity() ; conn.rearrange(4)
14037         eqFaces=srcFace.computePlaneEquationOf3DFaces()
14038         nodeIdInCell=3
14039         e=(srcFace.getCoords()[conn[:,nodeIdInCell]]*eqFaces[:,:-1]).sumPerTuple()+eqFaces[:,3]# e represent the error between the expected 'a*X+b*Y+c*Z+d' in eqFaces and 0. Closer e to 0. is closer the 4th point is to the plane built with the 3 first points
14040         lambd=-e/(eqFaces[:,:3]**2).sumPerTuple()
14041         pts=lambd*eqFaces[:,:-1]+srcFace.getCoords()[conn[:,nodeIdInCell]]#pts represent the projection of the last points of each NORM_QUAD4 to the plane defined by the 3 first points of the NORM_QUAD4 cell
14042         shouldBeZero=(pts*eqFaces[:,:-1]).sumPerTuple()+eqFaces[:,3]# this line is useless only to be sure that pts are on the plane.
14043         check=(pts-srcFace.getCoords()[conn[:,nodeIdInCell]]).magnitude() # check contains the distance of the last point to its plane
14044         idsToTest=check.getIdsNotInRange(0.,1e-10)
14045         self.assertTrue(idsToTest.isEqual(DataArrayInt([17,18,19,20,22,23,24])))
14046         idsToTest2=idsToTest.getIdsNotInRange(18,22)
14047         self.assertTrue(idsToTest2.isEqual(DataArrayInt([0,4,5,6])))
14048         idsToTest2.rearrange(2)
14049         self.assertTrue(idsToTest2.sumPerTuple().isEqual(DataArrayInt([4,11])))
14050         pass
14051
14052     def testSwig2SortHexa8EachOther1(self):
14053         """
14054         testing MEDCoupling1SGTUMesh.sortHexa8EachOther method
14055         """
14056         coords1=DataArrayDouble([(-0.5,0.5,-0.5),(0.5,-0.5,-0.5),(-0.5,-0.5,0.5),(-0.5,-0.5,-0.5),(0.5,-0.5,0.5),(-0.5,0.5,0.5),(0.5,0.5,0.5),(0.5,0.5,-0.5)])
14057         m1=MEDCouplingUMesh("m1",3) ; m1.setCoords(coords1)
14058         m1.allocateCells() ; m1.insertNextCell(NORM_HEXA8,[7,1,3,0,6,4,2,5])
14059         m1.checkCoherency()
14060         #
14061         m2=m1.deepCpy() ; m2.setName("m2")
14062         #
14063         trs=[[0.,0.,-1.],[0.,0.,1.],[1.,0.,0.],[0.,-1.,0.],[-1.,0.,0.],[0.,1.,0.]]
14064         for i,t in enumerate(trs):
14065             for j in xrange(64):
14066                 j2=(j//16) ; j1=((j%16)//4) ; j0=(j%4)
14067                 m11=m1.deepCpy()
14068                 m11.rotate([0.,0.,0.],[0.,0.,1.],float(j0)*pi/2)
14069                 m11.rotate([0.,0.,0.],[0.,1.,0.],float(j1)*pi/2)
14070                 m11.rotate([0.,0.,0.],[1.,0.,0.],float(j2)*pi/2)
14071                 m11.translate(t)
14072                 #
14073                 m=MEDCouplingUMesh.MergeUMeshes(m2,m11)
14074                 m.mergeNodes(1e-12)
14075                 self.assertEqual(12,m.getNumberOfNodes())
14076                 m=MEDCoupling1SGTUMesh(m)
14077                 m.sortHexa8EachOther()
14078                 tmp0=m.buildUnstructured().tetrahedrize(PLANAR_FACE_6)[0].buildUnstructured()
14079                 self.assertEqual(20,tmp0.computeSkin().getNumberOfCells())
14080                 pass
14081             pass
14082         pass
14083
14084     def testSwig2normMinComputeAbs1(self):
14085         d=DataArrayDouble([4,-5,2,6.1,-7.33,1,-1,3e2,0.07,-0.009,-6,-1e30],4,3)
14086         d.setInfoOnComponents(["XX [m]","YYY [km]","ABSJJ [MW]"])
14087         d0=d.computeAbs()
14088         dExp=d.deepCpy() ; dExp.abs()
14089         self.assertTrue(dExp.isEqual(d0,1e-12))
14090         e=d0-DataArrayDouble([4,5,2,6.1,7.33,1,1,3e2,0.07,0.009,6,1e30],4,3)
14091         self.assertAlmostEqual(0.,e.normMin(),13)
14092         self.assertAlmostEqual(0.009,d.normMin(),13)
14093         #
14094         di=DataArrayInt([3,-12,5,6,14,16,-23,100,23,-1,0,-6],4,3)
14095         di.setInfoOnComponents(["XX [m]","YYY [km]","ABSJJ [MW]"])
14096         d0i=di.computeAbs()
14097         diExp=di.deepCpy() ; diExp.abs()
14098         self.assertTrue(diExp.isEqual(d0i))
14099         self.assertEqual([3,12,5,6,14,16,23,100,23,1,0,6],d0i.getValues())
14100         pass
14101
14102     def testSwig2GetCellsContainingPointsForNonConvexPolygon1(self):
14103         coo=DataArrayDouble([-0.5,-0.5,-0.5,0.5,0.5,0.5,0.5,-0.5,0.,-0.5,0.,0.,0.5,0.,],7,2)
14104         m=MEDCouplingUMesh("Intersect2D",2) ; m.setCoords(coo) ; m.allocateCells()
14105         m.insertNextCell(NORM_POLYGON,[6,3,4,5])
14106         m.insertNextCell(NORM_POLYGON,[4,0,1,2,6,5])
14107         m.checkCoherency2()
14108         #
14109         self.assertTrue(m.getCellsContainingPoint((0.4,-0.4),1e-12).isEqual(DataArrayInt([0])))
14110         self.assertTrue(m.getCellsContainingPoint((-0.4,-0.4),1e-12).isEqual(DataArrayInt([1])))
14111         self.assertTrue(m.getCellsContainingPoint((0.,-0.4),1e-12).isEqual(DataArrayInt([0,1])))
14112         pass
14113
14114     def testSwig2GetCellsContainingPointsForNonConvexPolygon2(self):
14115         coo=DataArrayDouble([-0.5,-0.5,-0.5,0.5,0.5,0.5,0.5,-0.5,-2.0816681711721685e-17,-2.0816681711721685e-17,-0.17677669529663687,0.1767766952966369,0.,0.5,0.5,0.,0.17677669529663684,-0.17677669529663692,0.17677669529663692,0.17677669529663684,-0.17677669529663692,-0.17677669529663687,0.,-0.5,-0.5,0.,0.33838834764831843,-0.3383883476483185,-0.33838834764831843,0.33838834764831843,-0.21213203435596423,0.21213203435596426,0.2121320343559642,-0.2121320343559643,0.21213203435596426,0.2121320343559642,-0.21213203435596423,-0.21213203435596428,0.3560660171779821,-0.35606601717798214,-0.35606601717798214,0.35606601717798214,0.19445436482630052,-0.19445436482630063,-0.19445436482630055,0.19445436482630057,0.,0.27],24,2)
14116         m=MEDCouplingUMesh("mesh",2) ; m.setCoords(coo) ; m.allocateCells()
14117         m.insertNextCell(NORM_QPOLYG,[8,5,4,9])
14118         m.insertNextCell(NORM_QPOLYG,[5,8,4,10])
14119         m.insertNextCell(NORM_QPOLYG,[16,8,5,15,21,9,22,17])
14120         m.insertNextCell(NORM_QPOLYG,[15,1,2,3,16,20,6,7,19,17])
14121         m.insertNextCell(NORM_QPOLYG,[15,5,8,16,22,10,21,18])
14122         m.insertNextCell(NORM_QPOLYG,[16,3,0,1,15,19,11,12,20,18])
14123         m.checkCoherency2()
14124         self.assertTrue(m.getCellsContainingPoint([0.,0.27],1e-12).isEqual(DataArrayInt([2])))
14125         pass
14126
14127     def testSwig2DAIGetIdsEqualTuple1(self):
14128         da=DataArrayInt([0,7,1,2,4,1,2,1,1,2,0,1,2,1,5,1,1,2],9,2)
14129         self.assertTrue(da.getIdsEqualTuple([1,2]).isEqual(DataArrayInt([1,4,8])))
14130         self.assertTrue(da.getIdsEqualTuple((1,2)).isEqual(DataArrayInt([1,4,8])))
14131         self.assertTrue(da.getIdsEqualTuple(DataArrayInt([1,2])).isEqual(DataArrayInt([1,4,8])))
14132         da.rearrange(3)
14133         self.assertRaises(InterpKernelException,da.getIdsEqualTuple,[1,2])# mismatch nb of compo (3) and nb of elts in input tuple (2)
14134         self.assertTrue(da.getIdsEqualTuple([2,0,1]).isEqual(DataArrayInt([3])))
14135         self.assertTrue(da.getIdsEqualTuple([2,0,7]).isEqual(DataArrayInt([])))
14136         da.rearrange(1)
14137         self.assertTrue(da.getIdsEqualTuple(2).isEqual(DataArrayInt([3,6,9,12,17])))
14138         self.assertTrue(da.getIdsEqualTuple(2).isEqual(da.getIdsEqual(2)))
14139         pass
14140
14141     def testSwig2GaussNEStaticInfo1(self):
14142         self.assertTrue(DataArrayDouble(MEDCouplingFieldDiscretizationGaussNE.GetWeightArrayFromGeometricType(NORM_TRI3)).isEqual(DataArrayDouble([0.16666666666666666,0.16666666666666666,0.16666666666666666]),1e-12))
14143         self.assertTrue(DataArrayDouble(MEDCouplingFieldDiscretizationGaussNE.GetRefCoordsFromGeometricType(NORM_TRI3)).isEqual(DataArrayDouble([0.,0.,1.,0.,0.,1.]),1e-12))
14144         self.assertTrue(DataArrayDouble(MEDCouplingFieldDiscretizationGaussNE.GetLocsFromGeometricType(NORM_TRI3)).isEqual(DataArrayDouble([0.16666666666666666,0.16666666666666666,0.6666666666666667,0.16666666666666666,0.16666666666666666,0.6666666666666667]),1e-12))
14145         pass
14146
14147     def testSwigReverseNodalConnOnStructuredMesh(self):
14148         # 1D - standard
14149         c=MEDCouplingCMesh() ; arr=DataArrayDouble(10) ; arr.iota()
14150         c.setCoordsAt(0,arr)
14151         rn,rni=c.getReverseNodalConnectivity()
14152         rn2,rni2=c.buildUnstructured().getReverseNodalConnectivity()
14153         self.assertTrue(rn.isEqual(DataArrayInt([0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8])))
14154         self.assertTrue(rni.isEqual(DataArrayInt([0,1,3,5,7,9,11,13,15,17,18])))
14155         self.assertTrue(rn.isEqual(rn2)) ; self.assertTrue(rni.isEqual(rni2))
14156         # 1D - limit
14157         c=MEDCouplingCMesh() ; arr=DataArrayDouble(1) ; arr.iota()
14158         c.setCoordsAt(0,arr)
14159         rn,rni=c.getReverseNodalConnectivity()
14160         rn2,rni2=c.buildUnstructured().getReverseNodalConnectivity()
14161         self.assertTrue(rn.isEqual(DataArrayInt([0])))
14162         self.assertTrue(rni.isEqual(DataArrayInt([0,1])))
14163         self.assertTrue(rn.isEqual(rn2)) ; self.assertTrue(rni.isEqual(rni2))
14164         # 1D - limit
14165         c=MEDCouplingCMesh() ; arr=DataArrayDouble(0) ; arr.iota()
14166         c.setCoordsAt(0,arr)
14167         rn,rni=c.getReverseNodalConnectivity()
14168         rn.isEqual(DataArrayInt([]))
14169         rni.isEqual(DataArrayInt([0]))
14170         # 2D - standard
14171         c=MEDCouplingCMesh() ; arr=DataArrayDouble(5) ; arr.iota() ; arr2=DataArrayDouble(4) ; arr.iota()
14172         c.setCoords(arr,arr2)
14173         rn,rni=c.getReverseNodalConnectivity()
14174         rn2,rni2=c.buildUnstructured().getReverseNodalConnectivity()
14175         self.assertTrue(rn.isEqual(DataArrayInt([0,0,1,1,2,2,3,3,0,4,0,1,4,5,1,2,5,6,2,3,6,7,3,7,4,8,4,5,8,9,5,6,9,10,6,7,10,11,7,11,8,8,9,9,10,10,11,11])))
14176         self.assertTrue(rni.isEqual(DataArrayInt([0,1,3,5,7,8,10,14,18,22,24,26,30,34,38,40,41,43,45,47,48])))
14177         self.assertTrue(rn.isEqual(rn2)) ; self.assertTrue(rni.isEqual(rni2))
14178         # 2D - limit
14179         c=MEDCouplingCMesh() ; arr=DataArrayDouble(10) ; arr.iota() ; arr2=DataArrayDouble(1) ; arr.iota()
14180         c.setCoords(arr,arr2)
14181         rn,rni=c.getReverseNodalConnectivity()
14182         self.assertTrue(rn.isEqual(DataArrayInt([0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8])))
14183         self.assertTrue(rni.isEqual(DataArrayInt([0,1,3,5,7,9,11,13,15,17,18])))
14184         # 2D - limit
14185         c=MEDCouplingCMesh() ; arr=DataArrayDouble(10) ; arr.iota() ; arr2=DataArrayDouble(1) ; arr.iota()
14186         c.setCoords(arr2,arr)
14187         rn,rni=c.getReverseNodalConnectivity()
14188         self.assertTrue(rn.isEqual(DataArrayInt([0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8])))
14189         self.assertTrue(rni.isEqual(DataArrayInt([0,1,3,5,7,9,11,13,15,17,18])))
14190         # 3D - standard
14191         c=MEDCouplingCMesh() ; arr0=DataArrayDouble(5) ; arr0.iota() ; arr1=DataArrayDouble(3) ; arr1.iota() ; arr2=DataArrayDouble(4) ; arr2.iota()
14192         c.setCoords(arr0,arr1,arr2)
14193         rn,rni=c.getReverseNodalConnectivity()
14194         self.assertTrue(rn.isEqual(DataArrayInt([0,0,1,1,2,2,3,3,0,4,0,1,4,5,1,2,5,6,2,3,6,7,3,7,4,4,5,5,6,6,7,7,0,8,0,1,8,9,1,2,9,10,2,3,10,11,3,11,0,4,8,12,0,1,4,5,8,9,12,13,1,2,5,6,9,10,13,14,2,3,6,7,10,11,14,15,3,7,11,15,4,12,4,5,12,13,5,6,13,14,6,7,14,15,7,15,8,16,8,9,16,17,9,10,17,18,10,11,18,19,11,19,8,12,16,20,8,9,12,13,16,17,20,21,9,10,13,14,17,18,21,22,10,11,14,15,18,19,22,23,11,15,19,23,12,20,12,13,20,21,13,14,21,22,14,15,22,23,15,23,16,16,17,17,18,18,19,19,16,20,16,17,20,21,17,18,21,22,18,19,22,23,19,23,20,20,21,21,22,22,23,23])))
14195         self.assertTrue(rni.isEqual(DataArrayInt([0,1,3,5,7,8,10,14,18,22,24,25,27,29,31,32,34,38,42,46,48,52,60,68,76,80,82,86,90,94,96,98,102,106,110,112,116,124,132,140,144,146,150,154,158,160,161,163,165,167,168,170,174,178,182,184,185,187,189,191,192])))
14196         rn2,rni2=c.buildUnstructured().getReverseNodalConnectivity()
14197         self.assertTrue(rn.isEqual(rn2)) ; self.assertTrue(rni.isEqual(rni2))
14198         pass
14199
14200     def testSwig2CellToNodeDiscretization1(self):
14201         m=MEDCouplingCMesh() ; arr0=DataArrayDouble(5) ; arr0.iota() ; arr1=DataArrayDouble(4) ; arr1.iota() ; m.setCoords(arr0,arr1)
14202         f=MEDCouplingFieldDouble(ON_CELLS) ; f.setMesh(m) ; f.setTime(1.1,5,6)
14203         arr=DataArrayDouble(12) ; arr.iota()
14204         arr=DataArrayDouble.Meld(arr,arr+100.) ; arr.setInfoOnComponents(["aaa","bbb"])
14205         f.setArray(arr)
14206         f.checkCoherency()
14207         #
14208         ref=DataArrayDouble([0.,0.5,1.5,2.5,3.,2.,2.5,3.5,4.5,5.,6.,6.5,7.5,8.5,9.,8.,8.5,9.5,10.5,11.])
14209         ref=DataArrayDouble.Meld(ref,ref+100.) ; ref.setInfoOnComponents(["aaa","bbb"])
14210         f2=f.cellToNodeDiscretization()
14211         f2.checkCoherency()
14212         self.assertEqual(f2.getTime()[1:],[5,6])
14213         self.assertAlmostEqual(f2.getTime()[0],1.1,15)
14214         self.assertEqual(f2.getMesh().getHiddenCppPointer(),m.getHiddenCppPointer())
14215         self.assertTrue(f2.getArray().isEqual(ref,1e-12))
14216         rn,rni=m.getReverseNodalConnectivity()
14217         rni2=(rni.deltaShiftIndex()).convertToDblArr()
14218         arr2=(f.getArray()[rn]).accumulatePerChunck(rni)/rni2
14219         self.assertTrue(f2.getArray().isEqual(arr2,1e-12))
14220         del f2
14221         #
14222         u=m.buildUnstructured() ; f.setMesh(u) ; del m
14223         f3=f.cellToNodeDiscretization()
14224         f3.checkCoherency()
14225         self.assertEqual(f3.getTime()[1:],[5,6])
14226         self.assertAlmostEqual(f3.getTime()[0],1.1,15)
14227         self.assertEqual(f3.getMesh().getHiddenCppPointer(),u.getHiddenCppPointer())
14228         self.assertTrue(f3.getArray().isEqual(ref,1e-12))
14229         pass
14230
14231     def testSwig2GetMeshSpaceDimensionCMesh1(self):
14232         c=MEDCouplingCMesh()
14233         arr0=DataArrayDouble([0,1,2])
14234         arr1=DataArrayDouble([0])
14235         c.setCoords(arr0,arr0,arr0)
14236         self.assertEqual(c.getMeshDimension(),3)
14237         self.assertEqual(c.getSpaceDimension(),3)
14238         #
14239         c.setCoords(arr0,arr0,arr1)
14240         self.assertEqual(c.getMeshDimension(),2)
14241         self.assertEqual(c.getSpaceDimension(),3)
14242         #
14243         c.setCoords(arr0,arr0)
14244         self.assertEqual(c.getMeshDimension(),2)
14245         self.assertEqual(c.getSpaceDimension(),2)
14246         #
14247         c.setCoords(arr0,arr1)
14248         self.assertEqual(c.getMeshDimension(),1)
14249         self.assertEqual(c.getSpaceDimension(),2)
14250         #
14251         c.setCoords(arr0)
14252         self.assertEqual(c.getMeshDimension(),1)
14253         self.assertEqual(c.getSpaceDimension(),1)
14254         #
14255         c.setCoords(arr1)
14256         self.assertEqual(c.getMeshDimension(),0)
14257         self.assertEqual(c.getSpaceDimension(),1)
14258         pass
14259
14260     def testSwig2BuildSpreadZonesWithPolyOnQPolyg1(self):
14261         nx=6
14262         ny=6
14263         m=MEDCouplingCMesh()
14264         arr1=DataArrayDouble(nx) ; arr1.iota()
14265         arr2=DataArrayDouble(ny) ; arr2.iota()
14266         m.setCoords(arr1,arr2)
14267         m=m.buildUnstructured()
14268         da=DataArrayInt.Range(nx-1,(nx-1)*(ny-1),nx)
14269         m2=m[da] ; m2.simplexize(0)
14270         dan=da.buildComplement(m.getNumberOfCells())
14271         m1=m[dan]
14272         m=MEDCouplingUMesh.MergeUMeshesOnSameCoords(m1,m2)
14273         #
14274         m.convertLinearCellsToQuadratic()
14275         m1=m[::2] ; m2=m[1::2] ; m2.convertAllToPoly()
14276         m=MEDCouplingUMesh.MergeUMeshesOnSameCoords(m1,m2)
14277         p=m.buildSpreadZonesWithPoly()
14278         self.assertTrue(p.getNodalConnectivity().isEqual(DataArrayInt([32,1,0,6,12,18,24,30,31,32,33,34,35,29,23,17,11,5,4,3,2,36,37,94,62,72,83,84,86,89,99,92,93,82,71,60,51,49,46,43,40])))
14279         self.assertTrue(p.getNodalConnectivityIndex().isEqual(DataArrayInt([0,41])))
14280         self.assertTrue(p.getCoords().isEqual(DataArrayDouble([0.,0.,1.,0.,2.,0.,3.,0.,4.,0.,5.,0.,0.,1.,1.,1.,2.,1.,3.,1.,4.,1.,5.,1.,0.,2.,1.,2.,2.,2.,3.,2.,4.,2.,5.,2.,0.,3.,1.,3.,2.,3.,3.,3.,4.,3.,5.,3.,0.,4.,1.,4.,2.,4.,3.,4.,4.,4.,5.,4.,0.,5.,1.,5.,2.,5.,3.,5.,4.,5.,5.,5.,0.5,0.,0.,0.5,0.5,1.,1.,0.5,1.5,0.,1.5,1.,2.,0.5,2.5,0.,2.5,1.,3.,0.5,3.5,0.,3.5,1.,4.,0.5,4.5,0.,4.5,1.,5.,0.5,1.,1.5,1.5,2.,2.,1.5,2.5,2.,3.,1.5,3.5,2.,4.,1.5,4.5,2.,5.,1.5,0.5,2.,0.,2.5,0.5,3.,1.,2.5,2.,2.5,2.5,3.,3.,2.5,3.5,3.,4.,2.5,4.5,3.,5.,2.5,0.,3.5,0.5,4.,1.,3.5,1.5,3.,1.5,4.,2.,3.5,3.,3.5,3.5,4.,4.,3.5,4.5,4.,5.,3.5,0.,4.5,0.5,5.,1.,4.5,1.5,5.,2.,4.5,2.5,4.,2.5,5.,3.,4.5,4.,4.5,4.5,5.,5.,4.5,0.,1.5,0.5,1.5,1.5,2.5,2.5,3.5,3.5,4.5,3.5,5.0],100,2),1e-13))
14281         pass
14282
14283     def testSwig2Conformize2D1(self):
14284         eps = 1.0e-8
14285         coo = [0.,-0.5,0.,0.,0.5,0.,0.5,-0.5,0.25,
14286                -0.1,0.25,0.,0.5,-0.1,0.,0.5,0.5,0.5,0.25,0.4,0.25,0.5,0.5,0.4]
14287         conn = [5,5,2,6,4,5,6,3,0,1,5,4,5,10,8,11,9,5,11,2,1,7,10,9]
14288         connI = [0,5,12,17,24]
14289         m = MEDCouplingUMesh("box",2)
14290         cooArr = DataArrayDouble(coo,len(coo)/2,2)
14291         m.setCoords(cooArr)
14292         m.setConnectivity(DataArrayInt(conn),DataArrayInt(connI))
14293         m.mergeNodes(eps)
14294         m.checkCoherency()
14295         self.assertTrue(m.conformize2D(eps).isEqual(DataArrayInt([3])))
14296         self.assertEqual(m.getCoords().getHiddenCppPointer(),cooArr.getHiddenCppPointer()) # check that coordinates remain the same here
14297         self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([5,5,2,6,4,5,6,3,0,1,5,4,5,10,8,11,9,5,11,2,5,1,7,10,9])))
14298         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5,12,17,25])))
14299         pass
14300
14301     def testSwig2Conformize2D2(self):
14302         eps = 1.0e-8
14303         coo=DataArrayDouble([-10,-6,0,-6,0,0,7,0,-10,2,0,2,0,6,7,6,0,8,7,8,-10,12,-4,12,0,12,0,11,7,11,-4,16,0,16,7,16],18,2)
14304         conn=DataArrayInt([2,3,7,6, 13,16,17,14, 4,10,12,5, 9,14,13,8, 8,9,7,6, 5,4,0,1, 16,12,11,15])
14305         m=MEDCoupling1SGTUMesh("mesh",NORM_QUAD4)
14306         m.setCoords(coo)
14307         m.setNodalConnectivity(conn)
14308         m=m.buildUnstructured()
14309         self.assertTrue(m.conformize2D(eps).isEqual(DataArrayInt([0,1,2,5])))
14310         self.assertEqual(m.getCoords().getHiddenCppPointer(),coo.getHiddenCppPointer()) # check that coordinates remain the same here
14311         self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([5,2,3,7,6,5, 5,13,12,16,17,14, 5,4,10,11,12,13,8,6,5, 4,9,14,13,8, 4,8,9,7,6, 5,5,4,0,1,2, 4,16,12,11,15])))
14312         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,6,12,21,26,31,37,42])))
14313         pass
14314
14315     def testSwigSplit2DCells1(self):
14316         coo=DataArrayDouble([[0,0],[1,0],[1,1],[0,1],[0.5,0],[1,0.5],[0.5,1],[0.,0.5]])
14317         m=MEDCouplingUMesh("mesh",2)
14318         m.setCoords(coo)
14319         m.allocateCells()
14320         m.insertNextCell(NORM_QUAD8,[0,1,2,3,4,5,6,7])
14321         _,d,di,_,_=m.buildDescendingConnectivity()
14322         subb=DataArrayInt([5])
14323         subbi=DataArrayInt([0,0,1,1,1])
14324         mid=DataArrayInt([-1,-1])
14325         midi=DataArrayInt([0,0,2,2,2])
14326         self.assertEqual(2,m.split2DCells(d,di,subb,subbi,mid,midi))
14327         self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([32,0,1,5,2,3,4,8,9,6,7])))
14328         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,11])))
14329         self.assertTrue(m.getCoords().isEqual(DataArrayDouble([[0,0],[1,0],[1,1],[0,1],[0.5,0],[1,0.5],[0.5,1],[0.,0.5],[1.,0.25],[1.,0.75]]),1e-12))
14330         pass
14331
14332     def testSwig2Conformize2D3(self):
14333         eps = 1.0e-8
14334         coo=DataArrayDouble([-10,-6,0,-6,0,0,7,0,-10,2,0,2,0,6.5,7,6.5,0,8,7,8,-10,12,-4,12,0,12,0,11,7,11,-4,16,0,16,7,16],18,2)
14335         conn=DataArrayInt([2,3,7,6, 13,16,17,14, 4,10,12,5, 9,14,13,8, 8,9,7,6, 5,4,0,1, 16,12,11,15])
14336         m=MEDCoupling1SGTUMesh("mesh",NORM_QUAD4)
14337         m.setCoords(coo)
14338         m.setNodalConnectivity(conn)
14339         m=m.buildUnstructured()
14340         m.convertLinearCellsToQuadratic()
14341         self.assertTrue(m.conformize2D(eps).isEqual(DataArrayInt([0,1,2,5])))
14342         self.assertTrue(m.getCoords().getHiddenCppPointer()!=coo.getHiddenCppPointer()) # coordinates are not the same here contrary to testSwig2Conformize2D2 ...
14343         self.assertTrue(m.getCoords()[:18].isEqual(coo,1e-12)) # but the 18 first nodes are the same
14344         pass
14345
14346     def testSwig2Conformize2D4(self):
14347         eps = 1.0e-8
14348         coo=DataArrayDouble([-10,-6,0,-6,0,0,7,0,-10,2,0,2,0,6.5,7,6.5,0,8,7,8,-10,12,-4,12,0,12,0,11,7,11,-4,16,0,16,7,16],18,2)
14349         conn=DataArrayInt([2,3,7,6, 13,16,17,14, 4,10,12,5, 9,14,13,8, 8,9,7,6, 5,4,0,1, 16,12,11,15])
14350         m=MEDCoupling1SGTUMesh("mesh",NORM_QUAD4)
14351         m.setCoords(coo)
14352         m.setNodalConnectivity(conn)
14353         m=m.buildUnstructured()
14354         m.convertLinearCellsToQuadratic()
14355         self.assertEqual(42,m.getNumberOfNodes())
14356         oldCoo=m.getCoords().deepCpy()
14357         m.conformize2D(eps)
14358         self.assertTrue(m.getCoords()[:42].isEqual(oldCoo,1e-12))
14359         self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([32,2,3,7,6,5,18,19,20,42,43,32,13,12,16,17,14,44,38,23,24,25,32,4,10,11,12,13,8,6,5,26,45,39,44,31,34,42,29,8,9,14,13,8,30,25,31,32,8,8,9,7,6,32,33,20,34,32,5,4,0,1,2,29,35,36,46,43,8,16,12,11,15,38,39,40,41])))
14360         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,11,22,39,48,57,68,77])))
14361         self.assertTrue(m.getCoords().isEqual(DataArrayDouble([[-10.,-6.0],[0.,-6.0],[0.,0.0],[7.,0.0],[-10.,2.0],[0.,2.0],[0.,6.5],[7.,6.5],[0.,8.0],[7.,8.0],[-10.,12.0],[-4.,12.0],[0.,12.0],[0.,11.0],[7.,11.0],[-4.,16.0],[0.,16.0],[7.,16.0],[3.5, 0.0],[7.,3.25],[3.5, 6.5],[0.,3.25],[0.,13.5],[3.5, 16.0],[7.,13.5],[3.5, 11.0],[-10.,7.0],[-5.,12.0],[0.,7.0],[-5.,2.0],[7.,9.5],[0.,9.5],[3.5, 8.0],[7.,7.25],[0.,7.25],[-10.,-2.0],[-5.,-6.0],[0.,-2.0],[0.,14.0],[-2.,12.0],[-4.,14.0],[-2.,16.0],[0.,4.25],[0.,1.0],[0.,11.5],[-7.,12.0],[0.,-3.]]),1e-12))
14362         pass
14363
14364     def testSwig2Conformize2D5(self):
14365         eps=1e-8
14366         coo=DataArrayDouble([[2,2],[2,-6],[10,-2],[-2,-2],[6,0],[6,-4],[2,7],[2,4.5],[-1.4641016151377544,0],[-1.950753362380551,-1.3742621398390762],[-7,-3],[-0.8284271247461898,-4.82842712474619],[0.26794919243112281,3.5],[0,1.4641016151377548],[-4.4753766811902755,-2.1871310699195381],[-3.9142135623730949,-3.9142135623730949],[-1.8042260651806146,-3.23606797749979]])
14367         m=MEDCouplingUMesh("mesh",2)
14368         m.allocateCells()
14369         m.setCoords(coo)
14370         m.insertNextCell(NORM_TRI6,[1,2,0,5,4,3])
14371         m.insertNextCell(NORM_TRI6,[8,6,0,12,7,13])
14372         m.insertNextCell(NORM_TRI6,[11,9,10,16,14,15])
14373         self.assertTrue(m.conformize2D(eps).isEqual(DataArrayInt([0])))
14374         self.assertTrue(m.getCoords().isEqual(DataArrayDouble([2.,2.,2.,-6.,10.,-2.,-2.,-2.,6.,0.,6.,-4.,2.,7.,2.,4.5,-1.4641016151377544,0.,-1.950753362380551,-1.3742621398390762,-7.,-3.,-0.8284271247461898,-4.82842712474619,0.2679491924311228,3.5,8.881784197001252e-16,1.4641016151377548,-4.4753766811902755,-2.187131069919538,-3.914213562373095,-3.914213562373095,-1.8042260651806146,-3.236067977499789,-1.7705659643687133,-0.6647725630649153,0.46926627053963865,-5.695518130045146],19,2),1e-12))
14375         self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([32,1,2,0,8,9,11,5,4,13,17,16,18,6,8,6,0,12,7,13,6,11,9,10,16,14,15])))
14376         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,13,20,27])))
14377         pass
14378
14379     def testSwigExtendedSlice1(self):
14380         d=DataArrayInt([5,6,7])
14381         self.assertTrue(d[2:].isEqual(DataArrayInt([7])))
14382         self.assertTrue(d[3:].isEqual(DataArrayInt([])))
14383         try:
14384             d[4:]
14385         except InterpKernelException as e:
14386             self.assertTrue(True)
14387         else:
14388             self.assertTrue(False)
14389             pass
14390         d=DataArrayInt([5,6,7,8])
14391         self.assertEqual(d[-1],8)
14392         self.assertEqual(d[-4],5)
14393         try:
14394             d[-5]
14395         except InterpKernelException as e:
14396             self.assertTrue(True)
14397         else:
14398             self.assertTrue(False)
14399             pass
14400         self.assertTrue(d[2::-1].isEqual(DataArrayInt([7,6,5])))
14401         self.assertTrue(d[0::-1].isEqual(DataArrayInt([5])))
14402         self.assertTrue(d[-1::-1].isEqual(DataArrayInt([8,7,6,5])))
14403         self.assertTrue(d[-3::-1].isEqual(DataArrayInt([6,5])))
14404         self.assertTrue(d[-5::-1].isEqual(DataArrayInt([])))
14405         try:
14406             d[-6::-1]
14407         except InterpKernelException as e:
14408             self.assertTrue(True)
14409         else:
14410             self.assertTrue(False)
14411             pass
14412         d=DataArrayInt([])
14413         self.assertTrue(d[0:].isEqual(DataArrayInt([])))
14414         #
14415         d=DataArrayDouble([5,6,7])
14416         self.assertTrue(d[2:].isEqual(DataArrayDouble([7]),1e-12))
14417         self.assertTrue(d[3:].isEqual(DataArrayDouble([]),1e-12))
14418         try:
14419             d[4:]
14420         except InterpKernelException as e:
14421             self.assertTrue(True)
14422         else:
14423             self.assertTrue(False)
14424             pass
14425         d=DataArrayDouble([5,6,7,8])
14426         self.assertAlmostEqual(d[-1],8.,12)
14427         self.assertAlmostEqual(d[-4],5.,12)
14428         try:
14429             d[-5]
14430         except InterpKernelException as e:
14431             self.assertTrue(True)
14432         else:
14433             self.assertTrue(False)
14434             pass
14435         self.assertTrue(d[2::-1].isEqual(DataArrayDouble([7,6,5]),1e-12))
14436         self.assertTrue(d[0::-1].isEqual(DataArrayDouble([5]),1e-12))
14437         self.assertTrue(d[-1::-1].isEqual(DataArrayDouble([8,7,6,5]),1e-12))
14438         self.assertTrue(d[-3::-1].isEqual(DataArrayDouble([6,5]),1e-12))
14439         self.assertTrue(d[-5::-1].isEqual(DataArrayDouble([]),1e-12))
14440         try:
14441             d[-6::-1]
14442         except InterpKernelException as e:
14443             self.assertTrue(True)
14444         else:
14445             self.assertTrue(False)
14446             pass
14447         d=DataArrayDouble([])
14448         self.assertTrue(d[0:].isEqual(DataArrayDouble([]),1e-12))
14449         pass
14450
14451     def testSwig2Hexa27GP1(self):
14452         """ This test focused on shape functions of hexa27.
14453         """
14454         coo=DataArrayDouble([[0.,2.,2.],[0.,0.,2.],[2.,0.,2.],[2.,2.,2.],[0.,2.,0.],[0.,0.,0.],[2.,0.,0.],[2.,2.,0.], [0.,1.,2.],[1.,0.,2.],[2.,1.,2.],[1.,2.,2.], [0.,1.,0.],[1.,0.,0.],[2.,1.,0.],[1.,2.,0.], [0.,2.,1.],[0.,0.,1.],[2.,0.,1.],[2.,2.,1.], [1.,1.,2.], [0.,1.,1.],[1.,0.,1.],[2.,1.,1.],[1.,2.,1.], [1.,1.,0.], [1.,1.,1.]])
14455         m=MEDCouplingUMesh("mesh",3) ; m.setCoords(coo)
14456         m.allocateCells()
14457         # the cell description is exactly those described in the description of HEXA27 in MED file 3.0.7 documentation
14458         m.insertNextCell(NORM_HEXA27,[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])
14459         refCoo=[-1.,-1.,-1.,-1.,1.,-1.,1.,1.,-1.,1.,-1.,-1.,-1.,-1.,1.,-1.,1.,1.,1.,1.,1.,1.,-1.,1.,-1.,0.,-1.,0.,1.,-1.,1.,0.,-1.,0.,-1.,-1.,-1.,0.,1.,0.,1.,1.,1.,0.,1.,0.,-1.,1.,-1.,-1.,0.,-1.,1.,0.,1.,1.,0.,1.,-1.,0.,0.,0.,-1.,-1.,0.,0.,0.,1.,0.,1.,0.,0.,0.,-1.,0.,0.,0.,1.,0.,0.,0.]
14460         weights=[0.1714677640603571,0.27434842249657115,0.1714677640603571,0.27434842249657115,0.43895747599451346,0.27434842249657115,0.1714677640603571,0.27434842249657115,0.1714677640603571,0.27434842249657115,0.43895747599451346,0.27434842249657115,0.43895747599451346,0.7023319615912209,0.43895747599451346,0.27434842249657115,0.43895747599451346,0.27434842249657115,0.1714677640603571,0.27434842249657115,0.1714677640603571,0.27434842249657115,0.43895747599451346,0.27434842249657115,0.1714677640603571,0.27434842249657115,0.1714677640603571]
14461         gCoords=[-0.774596669241483,-0.774596669241483,-0.774596669241483,-0.774596669241483,-0.774596669241483,0.0,-0.774596669241483,-0.774596669241483,0.774596669241483,-0.774596669241483,0.0,-0.774596669241483,-0.774596669241483,0.0,0.0,-0.774596669241483,0.0,0.774596669241483,-0.774596669241483,0.774596669241483,-0.774596669241483,-0.774596669241483,0.774596669241483,0.0,-0.774596669241483,0.774596669241483,0.774596669241483,0.0,-0.774596669241483,-0.774596669241483,0.0,-0.774596669241483,0.0,0.0,-0.774596669241483,0.774596669241483,0.0,0.0,-0.774596669241483,0.0,0.0,0.0,0.0,0.0,0.774596669241483,0.0,0.774596669241483,-0.774596669241483,0.0,0.774596669241483,0.0,0.0,0.774596669241483,0.774596669241483,0.774596669241483,-0.774596669241483,-0.774596669241483,0.774596669241483,-0.774596669241483,0.0,0.774596669241483,-0.774596669241483,0.774596669241483,0.774596669241483,0.0,-0.774596669241483,0.774596669241483,0.0,0.0,0.774596669241483,0.0,0.774596669241483,0.774596669241483,0.774596669241483,-0.774596669241483,0.774596669241483,0.774596669241483,0.0,0.774596669241483,0.774596669241483,0.774596669241483]
14462         fGauss=MEDCouplingFieldDouble(ON_GAUSS_PT) ; fGauss.setName("fGauss")
14463         fGauss.setMesh(m)
14464         fGauss.setGaussLocalizationOnType(NORM_HEXA27,refCoo,gCoords,weights)
14465         arr=DataArrayDouble(fGauss.getNumberOfTuplesExpected()) ; arr.iota()
14466         fGauss.setArray(arr)
14467         arrOfDisc=fGauss.getLocalizationOfDiscr()
14468         # the test is here
14469         self.assertTrue(arrOfDisc.isEqual(DataArrayDouble([0.2254033307585172,1.7745966692414836,1.7745966692414834,0.22540333075851715,1.7745966692414834,1.,0.22540333075851715,1.7745966692414836,0.22540333075851715,0.22540333075851715,1.,1.7745966692414834,0.2254033307585171,1.,1.,0.22540333075851715,1.0000000000000002,0.2254033307585171,0.22540333075851715,0.22540333075851715,1.7745966692414838,0.22540333075851715,0.22540333075851715,1.,0.22540333075851715,0.22540333075851715,0.22540333075851715,1.,1.7745966692414832,1.7745966692414834,1.,1.774596669241483,1.,1.0000000000000002,1.7745966692414832,0.22540333075851712,1.,1.,1.774596669241483,1.,1.,1.,1.,1.,0.2254033307585171,1.,0.22540333075851715,1.7745966692414834,1.,0.2254033307585171,1.,1.0000000000000002,0.22540333075851715,0.2254033307585171,1.7745966692414834,1.7745966692414834,1.7745966692414836,1.7745966692414832,1.7745966692414834,1.0000000000000002,1.7745966692414834,1.7745966692414836,0.22540333075851712,1.7745966692414832,1.,1.7745966692414834,1.774596669241483,1.,1.,1.7745966692414832,1.0000000000000002,0.22540333075851712,1.7745966692414836,0.22540333075851715,1.7745966692414836,1.7745966692414832,0.22540333075851715,1.,1.7745966692414836,0.22540333075851715,0.22540333075851715],27,3),1e-12))
14470         #
14471         weights=27*[1]
14472         gCoords=refCoo
14473         fGauss.setGaussLocalizationOnType(NORM_HEXA27,refCoo,gCoords,weights)
14474         arrOfDisc2=fGauss.getLocalizationOfDiscr()
14475         self.assertTrue(arrOfDisc2.isEqual(coo,1e-12))
14476         pass
14477
14478     def testSwig2Pyra13GP1(self):
14479         coo=DataArrayDouble([[0.,2.,0.],[2.,2.,0.],[2.,0.,0.],[0.,0.,0.],[1.,1.,2.],[1.,2.,0.],[2.,1.,0.],[1.,0.,0.],[0.,1.,0.],[0.5,1.5,1.],[1.5,1.5,1.],[1.5,0.5,1.],[0.5,0.5,1.]])
14480         m=MEDCouplingUMesh("mesh",3) ; m.setCoords(coo)
14481         m.allocateCells()
14482         # the cell description is exactly those described in the description of PYRA13 in MED file 3.0.7 documentation
14483         m.insertNextCell(NORM_PYRA13,[0,1,2,3,4,5,6,7,8,9,10,11,12])
14484         refCoords=[1.,0.,0.,0.,-1.,0.,-1.,0.,0.,0.,1.,0.,0.,0.,1.,0.5,-0.5,0.,-0.5,-0.5,0.,-0.5,0.5,0.,0.5,0.5,0.,0.5,0.,0.5,0.,-0.5,0.5,-0.5,0.,0.5,0.,0.5,0.5]
14485         gaussCoords=[0.,0.,0.5,0.21210450275,0.21210450275,0.5,-0.21210450275,0.21210450275,0.5,-0.21210450275,-0.21210450275,0.5,0.21210450275,-0.21210450275,0.5,0.,0.,0.07579099449999999,0.,0.,0.9242090055000001,0.5394929090572634,0.,0.17359176399999998,0.,0.5394929090572634,0.17359176399999998,-0.5394929090572634,0.,0.17359176399999998,0.,-0.5394929090572634,0.17359176399999998,0.1133235629427366,0.,0.826408236,0.,0.1133235629427366,0.826408236,-0.1133235629427366,0.,0.826408236,0.,-0.1133235629427366,0.826408236,0.5826406005183961,0.5826406005183961,-0.053206449499999975,-0.5826406005183961,0.5826406005183961,-0.053206449499999975,-0.5826406005183961,-0.5826406005183961,-0.053206449499999975,0.5826406005183961,-0.5826406005183961,-0.053206449499999975,0.5532064495,0.,0.5,0.,0.5532064495,0.5,-0.5532064495,0.,0.5,0.,-0.5532064495,0.5,-0.029434151018396033,-0.029434151018396033,1.0532064495,0.029434151018396033,-0.029434151018396033,1.0532064495,0.029434151018396033,0.029434151018396033,1.0532064495,-0.029434151018396033,0.029434151018396033,1.0532064495]
14486         weights=[0.0492545926875,0.031210562625,0.031210562625,0.031210562625,0.031210562625,0.10663554205740113,0.0007171281994273535,0.0816994048010844,0.0816994048010844,0.0816994048010844,0.0816994048010844,0.0036048554264914074,0.0036048554264914074,0.0036048554264914074,0.0036048554264914074,0.008958181586640837,0.008958181586640837,0.008958181586640837,0.008958181586640837,0.002018983875,0.002018983875,0.002018983875,0.002018983875,2.286237794882217e-05,2.286237794882217e-05,2.286237794882217e-05,2.286237794882217e-05]
14487         fGauss=MEDCouplingFieldDouble(ON_GAUSS_PT) ; fGauss.setName("fGauss")
14488         fGauss.setMesh(m)
14489         fGauss.setGaussLocalizationOnType(NORM_PYRA13,refCoords,gaussCoords,weights)
14490         arr=DataArrayDouble(fGauss.getNumberOfTuplesExpected()) ; arr.iota()
14491         fGauss.setArray(arr)
14492         arrOfDisc=fGauss.getLocalizationOfDiscr()
14493         # the test is here
14494         self.assertTrue(arrOfDisc.isEqual(DataArrayDouble([1.,1.,1.,0.5757909945,1.,1.,1.,0.5757909945,1.,1.4242090055,1.,1.,1.,1.4242090055,1.,1.,1.,0.151581989,1.,1.,1.848418011,0.4605070909427367,1.5394929090572635,0.347183528,0.4605070909427367,0.4605070909427367,0.347183528,1.5394929090572638,0.4605070909427366,0.347183528,1.5394929090572635,1.5394929090572638,0.347183528,0.8866764370572636,1.1133235629427367,1.652816472,0.8866764370572636,0.8866764370572636,1.652816472,1.1133235629427367,0.8866764370572636,1.652816472,1.1133235629427365,1.1133235629427367,1.652816472,-0.16528120103679209,1.,-0.106412899,1.,-0.1652812010367921,-0.106412899,2.1652812010367914,1.,-0.106412899,1.,2.165281201036791,-0.106412899,0.4467935505,1.5532064495,1.,0.4467935505,0.4467935505,1.,1.5532064495,0.4467935505,1.,1.5532064495,1.5532064495,1.,1.0588683020367922,1.,2.106412899,1.,1.0588683020367922,2.106412899,0.9411316979632077,1.,2.106412899,1.,0.9411316979632078,2.106412899],27,3),1e-12))
14495         #
14496         weights=13*[1]
14497         gaussCoords=refCoords[:] ; gaussCoords[14]=0.9999999999999 # change z of point #4 0.999... instead of 1. because with shape function it leads to division by 0. !
14498         fGauss.setGaussLocalizationOnType(NORM_PYRA13,refCoords,gaussCoords,weights)
14499         arrOfDisc2=fGauss.getLocalizationOfDiscr()
14500         self.assertTrue(arrOfDisc2.isEqual(coo,1e-10)) # be less exigent 1e-10 instead of 1e-12 due to shape function sensitivity arount 0.,0.,1. !
14501         pass
14502
14503     def testSwig2Tri7GP1(self):
14504         coo=DataArrayDouble([[0,0],[0,2],[2,0],[0,1],[1,1],[1,0],[0.6666666666666667,0.6666666666666667]])
14505         m=MEDCouplingUMesh("mesh",2) ; m.setCoords(coo)
14506         m.allocateCells()
14507         # the cell description is exactly those described in the description of TRI7 in MED file 3.0.7 documentation
14508         m.insertNextCell(NORM_TRI7,range(7))
14509         refCoords=[0.,0.,1.,0.,0.,1.,0.5,0.,0.5,0.5,0.,0.5,0.3333333333333333,0.3333333333333333]
14510         gaussCoords=[0.3333333333333333,0.3333333333333333,0.470142064105115,0.470142064105115,0.05971587178977,0.470142064105115,0.470142064105115,0.05971587178977,0.101286507323456,0.101286507323456,0.797426985353088,0.101286507323456,0.101286507323456,0.797426985353088]
14511         weights=[0.062969590272413,0.062969590272413,0.062969590272413,0.066197076394253,0.066197076394253,0.066197076394253,0.1125]
14512         fGauss=MEDCouplingFieldDouble(ON_GAUSS_PT) ; fGauss.setName("fGauss")
14513         fGauss.setMesh(m)
14514         fGauss.setGaussLocalizationOnType(NORM_TRI7,refCoords,gaussCoords,weights)
14515         arr=DataArrayDouble(fGauss.getNumberOfTuplesExpected()) ; arr.iota()
14516         fGauss.setArray(arr)
14517         arrOfDisc=fGauss.getLocalizationOfDiscr()
14518         self.assertTrue(arrOfDisc.isEqual(DataArrayDouble([0.666666666666667,0.666666666666667,0.9402841282102293,0.9402841282102293,0.9402841282102299,0.11943174357954002,0.11943174357953992,0.9402841282102299,0.20257301464691194,0.20257301464691196,0.20257301464691205,1.5948539707061757,1.5948539707061757,0.20257301464691202],7,2),1e-12))
14519         #
14520         weights=7*[1]
14521         gaussCoords=refCoords
14522         fGauss.setGaussLocalizationOnType(NORM_TRI7,refCoords,gaussCoords,weights)
14523         arrOfDisc2=fGauss.getLocalizationOfDiscr()
14524         self.assertTrue(arrOfDisc2.isEqual(coo,1e-12))
14525         pass
14526
14527     def testSwig2StructuredDesc1(self):
14528         c=MEDCouplingCMesh()
14529         arr0=DataArrayDouble(3) ; arr0.iota()
14530         arr1=DataArrayDouble(4) ; arr1.iota()
14531         arr2=DataArrayDouble(5) ; arr2.iota()
14532         c.setCoords(arr0,arr1,arr2)
14533         #
14534         self.assertEqual(98,c.getNumberOfCellsOfSubLevelMesh())
14535         m=c.build1SGTSubLevelMesh()
14536         self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([0,12,15,3,12,24,27,15,24,36,39,27,36,48,51,39,3,15,18,6,15,27,30,18,27,39,42,30,39,51,54,42,6,18,21,9,18,30,33,21,30,42,45,33,42,54,57,45,1,13,16,4,13,25,28,16,25,37,40,28,37,49,52,40,4,16,19,7,16,28,31,19,28,40,43,31,40,52,55,43,7,19,22,10,19,31,34,22,31,43,46,34,43,55,58,46,2,14,17,5,14,26,29,17,26,38,41,29,38,50,53,41,5,17,20,8,17,29,32,20,29,41,44,32,41,53,56,44,8,20,23,11,20,32,35,23,32,44,47,35,44,56,59,47,0,12,13,1,12,24,25,13,24,36,37,25,36,48,49,37,1,13,14,2,13,25,26,14,25,37,38,26,37,49,50,38,3,15,16,4,15,27,28,16,27,39,40,28,39,51,52,40,4,16,17,5,16,28,29,17,28,40,41,29,40,52,53,41,6,18,19,7,18,30,31,19,30,42,43,31,42,54,55,43,7,19,20,8,19,31,32,20,31,43,44,32,43,55,56,44,9,21,22,10,21,33,34,22,33,45,46,34,45,57,58,46,10,22,23,11,22,34,35,23,34,46,47,35,46,58,59,47,0,1,4,3,3,4,7,6,6,7,10,9,1,2,5,4,4,5,8,7,7,8,11,10,12,13,16,15,15,16,19,18,18,19,22,21,13,14,17,16,16,17,20,19,19,20,23,22,24,25,28,27,27,28,31,30,30,31,34,33,25,26,29,28,28,29,32,31,31,32,35,34,36,37,40,39,39,40,43,42,42,43,46,45,37,38,41,40,40,41,44,43,43,44,47,46,48,49,52,51,51,52,55,54,54,55,58,57,49,50,53,52,52,53,56,55,55,56,59,58])))
14537         self.assertEqual(NORM_QUAD4,m.getCellModelEnum())
14538         #
14539         self.assertTrue(MEDCouplingStructuredMesh.Build1GTNodalConnectivityOfSubLevelMesh([3,7]).isEqual(DataArrayInt([0,3,3,6,6,9,9,12,12,15,15,18,1,4,4,7,7,10,10,13,13,16,16,19,2,5,5,8,8,11,11,14,14,17,17,20,0,1,1,2,3,4,4,5,6,7,7,8,9,10,10,11,12,13,13,14,15,16,16,17,18,19,19,20])))
14540         pass
14541
14542     def testSwig2Colinearize2D1(self):
14543         coo=DataArrayDouble([-5.,0.,-1.,0.,4.,3.,7.,0.,1.,6.,1.,0.,-3.,0.,6.,1.,5.,0.,3.,0.],10,2)
14544         #
14545         m=MEDCouplingUMesh("mesh",2) ; m.setCoords(coo) ; m.allocateCells()
14546         m.insertNextCell(NORM_POLYGON,[5,9,8,3,7,2,4,0,6,1])
14547         refPtr=m.getCoords().getHiddenCppPointer()
14548         self.assertTrue(m.colinearize2D(1e-12).isEqual(DataArrayInt([0])))
14549         self.assertEqual(refPtr,m.getCoords().getHiddenCppPointer())
14550         self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([5,0,3,4])))
14551         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4])))
14552         self.assertTrue(m.colinearize2D(1e-12).isEqual(DataArrayInt([])))
14553         self.assertEqual(refPtr,m.getCoords().getHiddenCppPointer())
14554         self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([5,0,3,4])))
14555         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4])))
14556         #
14557         m=MEDCouplingUMesh("mesh",2) ; m.setCoords(coo) ; m.allocateCells()
14558         m.insertNextCell(NORM_POLYGON,[8,3,7,2,4,0,6,1,5,9])
14559         refPtr=m.getCoords().getHiddenCppPointer()
14560         self.assertTrue(m.colinearize2D(1e-12).isEqual(DataArrayInt([0])))
14561         self.assertEqual(refPtr,m.getCoords().getHiddenCppPointer())
14562         self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([5,0,3,4])))
14563         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4])))
14564         #
14565         m=MEDCouplingUMesh("mesh",2) ; m.setCoords(coo) ; m.allocateCells()
14566         m.insertNextCell(NORM_POLYGON,[3,7,2,4,0,6,1,5,9,8])
14567         refPtr=m.getCoords().getHiddenCppPointer()
14568         self.assertTrue(m.colinearize2D(1e-12).isEqual(DataArrayInt([0])))
14569         self.assertEqual(refPtr,m.getCoords().getHiddenCppPointer())
14570         self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([5,3,4,0])))
14571         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4])))
14572         #
14573         m=MEDCouplingUMesh("mesh",2) ; m.setCoords(coo) ; m.allocateCells()
14574         m.insertNextCell(NORM_POLYGON,[4,0,6,1,5,9,8,3,7,2,])
14575         refPtr=m.getCoords().getHiddenCppPointer()
14576         self.assertTrue(m.colinearize2D(1e-12).isEqual(DataArrayInt([0])))
14577         self.assertEqual(refPtr,m.getCoords().getHiddenCppPointer())
14578         self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([5,4,0,3])))
14579         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4])))
14580         ## false quadratic
14581         coo2=DataArrayDouble([(-5,0),(-1,0),(4,3),(7,0),(1,6),(1,0),(-3,0),(6,1),(5,0),(3,0),(2,0),(4,0),(6,0),(6.5,0.5),(5,2),(2.5,4.5),(-2,3),(-4,0),(-2,0),(0,0)])
14582         coo2.setInfoOnComponents(["aa","bbbb"])
14583         m=MEDCouplingUMesh("mesh",2) ; m.setCoords(coo2) ; m.allocateCells()
14584         m.insertNextCell(NORM_QPOLYG,[5,9,8,3,7,2,4,0,6,1,10,11,12,13,14,15,16,17,18,19])
14585         refPtr=m.getCoords().getHiddenCppPointer()
14586         self.assertTrue(m.colinearize2D(1e-12).isEqual(DataArrayInt([0])))
14587         self.assertNotEqual(refPtr,m.getCoords().getHiddenCppPointer())#not same coordinates here
14588         self.assertEqual(["aa","bbbb"],m.getCoords().getInfoOnComponents())
14589         refPtr=m.getCoords().getHiddenCppPointer()
14590         self.assertTrue(coo2.isEqual(m.getCoords()[:20],1e-12))
14591         self.assertTrue(m.getCoords()[20:].isEqualWithoutConsideringStr(DataArrayDouble([(1.,0.),(4.,3.)]),1e-12))
14592         self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([32,0,3,4,20,21,16])))
14593         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,7])))
14594         self.assertTrue(m.colinearize2D(1e-12).isEqual(DataArrayInt([])))
14595         self.assertEqual(refPtr,m.getCoords().getHiddenCppPointer())
14596         self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([32,0,3,4,20,21,16])))
14597         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,7])))
14598         # mix of quadratic and linear inside a QPOLYG cell
14599         coo2=DataArrayDouble([(-5,0),(-1,0),(7.,6.),(7,0),(1,6),(1,0),(-3,0),(8.2426406871192839,3),(5,0),(3,0),  (2,0),(4,0),(6,0),(7.9196888946291288,1.3764116995614091),(7.9196888946291288,4.6235883004385911),(4,7.2426406871192848),(-2,3),(-4,0),(-2,0),(0,0)])
14600         m=MEDCouplingUMesh("mesh",2) ; m.setCoords(coo2) ; m.allocateCells()
14601         m.insertNextCell(NORM_QPOLYG,[5,9,8,3,7,2,4,0,6,1,10,11,12,13,14,15,16,17,18,19])
14602         refPtr=m.getCoords().getHiddenCppPointer()
14603         self.assertTrue(m.colinearize2D(1e-12).isEqual(DataArrayInt([0])))
14604         self.assertNotEqual(refPtr,m.getCoords().getHiddenCppPointer())#not same coordinates here
14605         self.assertTrue(coo2.isEqual(m.getCoords()[:20],1e-12))
14606         self.assertTrue(m.getCoords()[20:].isEqual(DataArrayDouble([(1.,0.),(7.,6.)]),1e-12))
14607         self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([32,0,3,4,20,21,16])))
14608         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,7])))
14609         pass
14610
14611     def testSwig2BoundingBoxForBBTree1(self):
14612         """ This test appears simple but it checks that bounding box are correctly computed for quadratic polygons. It can help a lot to reduce the amount of intersections !
14613         """
14614         coo=DataArrayDouble([-0.5,-0.5,-0.5,0.5,0.5,0.5,0.5,-0.5,0.45,0.,0.3181980515339464,0.31819805153394637,0.,0.45,-0.31819805153394637,0.3181980515339464,-0.45,0.,-0.3181980515339465,-0.31819805153394637,0.,-0.45,0.3181980515339463,-0.3181980515339465,-0.5,0.0,0.0,0.5,0.5,0.0,0.0,-0.5,-0.4090990257669732,-0.4090990257669732,0.40909902576697316,-0.4090990257669732],18,2)
14615         m=MEDCouplingUMesh("mesh",2) ; m.setCoords(coo)
14616         m.allocateCells()
14617         m.insertNextCell(NORM_QPOLYG,[0,1,2,3,11,5,7,9,12,13,14,17,4,6,8,16])
14618         m.insertNextCell(NORM_QPOLYG,[3,0,9,11,15,16,10,17])
14619         self.assertTrue(m.getBoundingBoxForBBTree().isEqual(DataArrayDouble([-0.5,0.5,-0.5,0.5,-0.5,0.5,-0.5,-0.31819805153394637],2,4),1e-12))
14620         pass
14621
14622     def testSwig2CartBuildUnstructuredOnExoticCases1(self):
14623         """ Test focusing on traduction from cartesian to unstructured mesh when spaceDim greater than meshDim.
14624         """
14625         #
14626         m=MEDCouplingCMesh()
14627         arrX=DataArrayDouble(3) ; arrX.iota()
14628         arrY=DataArrayDouble(4) ; arrY.iota()
14629         arrZ=DataArrayDouble(1) ; arrZ.iota()
14630         m.setCoords(arrX,arrY,arrZ)
14631         self.assertEqual(2,m.getMeshDimension())
14632         self.assertEqual(3,m.getSpaceDimension())
14633         mu=m.buildUnstructured()
14634         self.assertTrue(mu.getNodalConnectivity().isEqual(DataArrayInt([4,1,0,3,4,4,2,1,4,5,4,4,3,6,7,4,5,4,7,8,4,7,6,9,10,4,8,7,10,11])))
14635         self.assertTrue(mu.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5,10,15,20,25,30])))
14636         coo0=DataArrayDouble([(0,0,0),(1,0,0),(2,0,0),(0,1,0),(1,1,0),(2,1,0),(0,2,0),(1,2,0),(2,2,0),(0,3,0),(1,3,0),(2,3,0)])
14637         self.assertTrue(mu.getCoords().isEqual(coo0,1e-12))
14638         mu.writeVTK("tutu.vtu")
14639         #
14640         m=MEDCouplingCMesh()
14641         arrX=DataArrayDouble(3) ; arrX.iota()
14642         arrY=DataArrayDouble(1) ; arrY.iota()
14643         arrZ=DataArrayDouble(4) ; arrZ.iota()
14644         m.setCoords(arrX,arrY,arrZ)
14645         self.assertEqual(2,m.getMeshDimension())
14646         self.assertEqual(3,m.getSpaceDimension())
14647         mu=m.buildUnstructured()
14648         self.assertTrue(mu.getNodalConnectivity().isEqual(DataArrayInt([4,1,0,3,4,4,2,1,4,5,4,4,3,6,7,4,5,4,7,8,4,7,6,9,10,4,8,7,10,11])))
14649         self.assertTrue(mu.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5,10,15,20,25,30])))
14650         coo1=DataArrayDouble([(0,0,0),(1,0,0),(2,0,0),(0,0,1),(1,0,1),(2,0,1),(0,0,2),(1,0,2),(2,0,2),(0,0,3),(1,0,3),(2,0,3)])
14651         self.assertTrue(mu.getCoords().isEqual(coo1,1e-12))
14652         #
14653         m=MEDCouplingCMesh()
14654         arrX=DataArrayDouble(1) ; arrX.iota() ; arrX+=9
14655         arrY=DataArrayDouble(3) ; arrY.iota()
14656         arrZ=DataArrayDouble(4) ; arrZ.iota()
14657         m.setCoords(arrX,arrY,arrZ)
14658         self.assertEqual(2,m.getMeshDimension())
14659         self.assertEqual(3,m.getSpaceDimension())
14660         mu=m.buildUnstructured()
14661         self.assertTrue(mu.getNodalConnectivity().isEqual(DataArrayInt([4,1,0,3,4,4,2,1,4,5,4,4,3,6,7,4,5,4,7,8,4,7,6,9,10,4,8,7,10,11])))
14662         self.assertTrue(mu.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5,10,15,20,25,30])))
14663         coo2=DataArrayDouble([(9,0,0),(9,1,0),(9,2,0),(9,0,1),(9,1,1),(9,2,1),(9,0,2),(9,1,2),(9,2,2),(9,0,3),(9,1,3),(9,2,3)])
14664         self.assertTrue(mu.getCoords().isEqual(coo2,1e-12))
14665         #
14666         m=MEDCouplingCMesh()
14667         arrX=DataArrayDouble(3) ; arrX.iota()
14668         arrY=DataArrayDouble(1) ; arrY.iota(7)
14669         arrZ=DataArrayDouble(1) ; arrZ.iota(8)
14670         m.setCoords(arrX,arrY,arrZ)
14671         self.assertEqual(1,m.getMeshDimension())
14672         self.assertEqual(3,m.getSpaceDimension())
14673         mu=m.buildUnstructured()
14674         self.assertTrue(mu.getNodalConnectivity().isEqual(DataArrayInt([1,0,1,1,1,2])))
14675         self.assertTrue(mu.getNodalConnectivityIndex().isEqual(DataArrayInt([0,3,6])))
14676         coo3=DataArrayDouble([(0,7,8),(1,7,8),(2,7,8)])
14677         self.assertTrue(mu.getCoords().isEqual(coo3,1e-12))
14678         #
14679         m=MEDCouplingCMesh()
14680         arrX=DataArrayDouble(1) ; arrX.iota(7)
14681         arrY=DataArrayDouble(1) ; arrY.iota(8)
14682         arrZ=DataArrayDouble(3) ; arrZ.iota()
14683         m.setCoords(arrX,arrY,arrZ)
14684         self.assertEqual(1,m.getMeshDimension())
14685         self.assertEqual(3,m.getSpaceDimension())
14686         mu=m.buildUnstructured()
14687         self.assertTrue(mu.getNodalConnectivity().isEqual(DataArrayInt([1,0,1,1,1,2])))
14688         self.assertTrue(mu.getNodalConnectivityIndex().isEqual(DataArrayInt([0,3,6])))
14689         coo4=DataArrayDouble([(7,8,0),(7,8,1),(7,8,2)])
14690         self.assertTrue(mu.getCoords().isEqual(coo4,1e-12))
14691         #
14692         m=MEDCouplingCMesh()
14693         arrX=DataArrayDouble(3) ; arrX.iota()
14694         arrY=DataArrayDouble(1) ; arrY.iota(7)
14695         m.setCoords(arrX,arrY)
14696         self.assertEqual(1,m.getMeshDimension())
14697         self.assertEqual(2,m.getSpaceDimension())
14698         mu=m.buildUnstructured()
14699         self.assertTrue(mu.getNodalConnectivity().isEqual(DataArrayInt([1,0,1,1,1,2])))
14700         self.assertTrue(mu.getNodalConnectivityIndex().isEqual(DataArrayInt([0,3,6])))
14701         coo5=DataArrayDouble([(0,7),(1,7),(2,7)])
14702         self.assertTrue(mu.getCoords().isEqual(coo5,1e-12))
14703         #
14704         m=MEDCouplingCMesh()
14705         arrX=DataArrayDouble(1) ; arrX.iota(7)
14706         arrY=DataArrayDouble(3) ; arrY.iota()
14707         m.setCoords(arrX,arrY)
14708         self.assertEqual(1,m.getMeshDimension())
14709         self.assertEqual(2,m.getSpaceDimension())
14710         mu=m.buildUnstructured()
14711         self.assertTrue(mu.getNodalConnectivity().isEqual(DataArrayInt([1,0,1,1,1,2])))
14712         self.assertTrue(mu.getNodalConnectivityIndex().isEqual(DataArrayInt([0,3,6])))
14713         coo6=DataArrayDouble([(7,0),(7,1),(7,2)])
14714         self.assertTrue(mu.getCoords().isEqual(coo6,1e-12))
14715         pass
14716
14717     def testSwig2Colinearize2D2(self):
14718         """ simple non regression test but that has revealed a bug"""
14719         coo=DataArrayDouble([(0,0),(0,0.5),(0,1),(1,1),(1,0),(0.5,0)])
14720         m=MEDCouplingUMesh("mesh",2) ; m.setCoords(coo)
14721         m.allocateCells() ; m.insertNextCell(NORM_POLYGON,[0,1,2,3,4,5])
14722         m.checkCoherency2()
14723         refPtr=m.getCoords().getHiddenCppPointer()
14724         #
14725         m.colinearize2D(1e-12)
14726         m.checkCoherency2()
14727         self.assertEqual(refPtr,m.getCoords().getHiddenCppPointer())
14728         self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([5,0,2,3,4])))
14729         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5])))
14730         pass
14731
14732     def testSwig2CheckAndPreparePermutation2(self):
14733         a=DataArrayInt([10003,9999999,5,67])
14734         self.assertTrue(DataArrayInt.CheckAndPreparePermutation(a).isEqual(DataArrayInt([2,3,0,1])))
14735         a=DataArrayInt([10003,-9999999,5,67])
14736         self.assertTrue(DataArrayInt.CheckAndPreparePermutation(a).isEqual(DataArrayInt([3,0,1,2])))
14737         a=DataArrayInt([])
14738         self.assertTrue(DataArrayInt.checkAndPreparePermutation(a).isEqual(DataArrayInt([])))
14739         pass
14740
14741     def testSwig2ComputeNeighborsOfNodes1(self):
14742         arrX=DataArrayDouble(3) ; arrX.iota()
14743         arrY=DataArrayDouble(4) ; arrY.iota()
14744         arrZ=DataArrayDouble(5) ; arrZ.iota()
14745         m=MEDCouplingCMesh() ; m.setCoords(arrX,arrY,arrZ) ; m=m.buildUnstructured()
14746         # 3D
14747         a,b=m.computeNeighborsOfNodes()
14748         self.assertTrue(a.isEqual(DataArrayInt([1,3,12,0,4,13,2,1,5,14,0,4,15,6,3,1,16,5,7,4,2,17,8,3,7,18,9,6,4,19,8,10,7,5,20,11,6,10,21,9,7,22,11,10,8,23,13,15,0,24,12,16,1,14,25,13,17,2,26,12,16,3,18,27,15,13,4,17,19,28,16,14,5,20,29,15,19,6,21,30,18,16,7,20,22,31,19,17,8,23,32,18,22,9,33,21,19,10,23,34,22,20,11,35,25,27,12,36,24,28,13,26,37,25,29,14,38,24,28,15,30,39,27,25,16,29,31,40,28,26,17,32,41,27,31,18,33,42,30,28,19,32,34,43,31,29,20,35,44,30,34,21,45,33,31,22,35,46,34,32,23,47,37,39,24,48,36,40,25,38,49,37,41,26,50,36,40,27,42,51,39,37,28,41,43,52,40,38,29,44,53,39,43,30,45,54,42,40,31,44,46,55,43,41,32,47,56,42,46,33,57,45,43,34,47,58,46,44,35,59,49,51,36,48,52,37,50,49,53,38,48,52,39,54,51,49,40,53,55,52,50,41,56,51,55,42,57,54,52,43,56,58,55,53,44,59,54,58,45,57,55,46,59,58,56,47])))
14749         self.assertTrue(b.isEqual(DataArrayInt([0,3,7,10,14,19,23,27,32,36,39,43,46,50,55,59,64,70,75,80,86,91,95,100,104,108,113,117,122,128,133,138,144,149,153,158,162,166,171,175,180,186,191,196,202,207,211,216,220,223,227,230,234,239,243,247,252,256,259,263,266])))
14750         # 2D
14751         m=MEDCouplingCMesh() ; m.setCoords(arrX,arrY) ; m=m.buildUnstructured()
14752         a,b=m.computeNeighborsOfNodes()
14753         self.assertTrue(a.isEqual(DataArrayInt([1,3,0,4,2,1,5,0,4,6,3,1,5,7,4,2,8,3,7,9,6,4,8,10,7,5,11,6,10,9,7,11,10,8])))
14754         self.assertTrue(b.isEqual(DataArrayInt([0,2,5,7,10,14,17,20,24,27,29,32,34])))
14755         # 1D
14756         m=m.buildDescendingConnectivity()[0]
14757         a,b=m.computeNeighborsOfNodes()
14758         self.assertTrue(a.isEqual(DataArrayInt([1,3,0,4,2,1,5,0,4,6,3,1,5,7,4,2,8,3,7,9,6,4,8,10,7,5,11,6,10,9,7,11,10,8])))
14759         self.assertTrue(b.isEqual(DataArrayInt([0,2,5,7,10,14,17,20,24,27,29,32,34])))
14760         pass
14761
14762     def testSwigBugOnUnpackingTuplesInDataArray1(self):
14763         inp=DataArrayDouble([(1,2,3),(4,5,6),(7,8,9),(10,11,12)])
14764         it=inp.__iter__()
14765         r=it.next()
14766         self.assertRaises(StopIteration,r.__getitem__,4)
14767         self.assertEqual(len(r),3)
14768         a,b,c=r
14769         r=it.next()
14770         self.assertEqual(len(r),3)
14771         d,e,f=r
14772         r=it.next()
14773         self.assertEqual(len(r),3)
14774         g,h,i=r
14775         r=it.next()
14776         self.assertEqual(len(r),3)
14777         j,k,l=r
14778         assert(inp.isEqual(DataArrayDouble([a,b,c,d,e,f,g,h,i,j,k,l],4,3),1e-12))
14779         ########
14780         inp=DataArrayInt([(1,2,3),(4,5,6),(7,8,9),(10,11,12)])
14781         it=inp.__iter__()
14782         r=it.next()
14783         self.assertRaises(StopIteration,r.__getitem__,4)
14784         self.assertEqual(len(r),3)
14785         a,b,c=r
14786         r=it.next()
14787         self.assertEqual(len(r),3)
14788         d,e,f=r
14789         r=it.next()
14790         self.assertEqual(len(r),3)
14791         g,h,i=r
14792         r=it.next()
14793         self.assertEqual(len(r),3)
14794         j,k,l=r
14795         assert(inp.isEqual(DataArrayInt([a,b,c,d,e,f,g,h,i,j,k,l],4,3)))
14796         pass
14797
14798     def testSwig2IMesh1(self):
14799         """ 1st test of image grid mesh.
14800         """
14801         m=MEDCouplingIMesh()
14802         self.assertEqual(m.getSpaceDimension(),-1)
14803         self.assertEqual(1,len(m.__repr__().split("\n")))
14804         self.assertEqual(6,len(m.__str__().split("\n")))
14805         self.assertRaises(InterpKernelException,m.getNodeStruct)
14806         self.assertRaises(InterpKernelException,m.getOrigin)
14807         self.assertRaises(InterpKernelException,m.getDXYZ)
14808         m.setSpaceDimension(3)
14809         self.assertEqual(9,len(m.__str__().split("\n")))
14810         self.assertEqual(4,len(m.__repr__().split("\n")))
14811         self.assertEqual((0,0,0),m.getNodeStruct())
14812         self.assertEqual((0.,0.,0.),m.getOrigin())
14813         self.assertEqual((0.,0.,0.),m.getDXYZ())
14814         self.assertRaises(InterpKernelException,m.setNodeStruct,[3,4])
14815         m.setNodeStruct([3,4,2])
14816         self.assertEqual((3,4,2),m.getNodeStruct())
14817         m.setOrigin(DataArrayDouble([1.5,2.5,3.5]))
14818         self.assertEqual((1.5,2.5,3.5),m.getOrigin())
14819         m.setDXYZ((0.5,1.,0.25))
14820         self.assertEqual((0.5,1.,0.25),m.getDXYZ())
14821         for it in DataArrayDouble([(1.5,2.5,3.5)]):
14822             m2=MEDCouplingIMesh("",3,DataArrayInt([3,4,2]),it,DataArrayDouble((0.5,1.,0.25)))
14823             pass
14824         self.assertEqual(3,m.getSpaceDimension())
14825         self.assertEqual((3,4,2),m2.getNodeStruct())
14826         self.assertEqual((1.5,2.5,3.5),m2.getOrigin())
14827         self.assertEqual((0.5,1.,0.25),m2.getDXYZ())
14828         self.assertEqual(24,m2.getNumberOfNodes())
14829         self.assertEqual(6,m2.getNumberOfCells())
14830         self.assertTrue(m.isEqual(m2,1e-12)) ; self.assertTrue(m.isEqualWithoutConsideringStr(m2,1e-12))
14831         m2.setAxisUnit("m")
14832         self.assertTrue(not m.isEqual(m2,1e-12)) ; self.assertTrue(m.isEqualWithoutConsideringStr(m2,1e-12))
14833         m.setAxisUnit("m")
14834         self.assertTrue(m.isEqual(m2,1e-12)) ; self.assertTrue(m.isEqualWithoutConsideringStr(m2,1e-12))
14835         m.setName("mesh")
14836         self.assertTrue(not m.isEqual(m2,1e-12)) ; self.assertTrue(m.isEqualWithoutConsideringStr(m2,1e-12))
14837         m2.setName("mesh")
14838         self.assertTrue(m.isEqual(m2,1e-12)) ; self.assertTrue(m.isEqualWithoutConsideringStr(m2,1e-12))
14839         m2.setTime(1.1,0,3)
14840         self.assertTrue(not m.isEqual(m2,1e-12))
14841         m.setTime(1.1,0,3)
14842         self.assertTrue(m.isEqual(m2,1e-12))
14843         m.setTimeUnit("ms")
14844         self.assertTrue(not m.isEqual(m2,1e-12)) ; self.assertTrue(m.isEqualWithoutConsideringStr(m2,1e-12))
14845         m2.setTimeUnit("ms")
14846         self.assertTrue(m.isEqual(m2,1e-12)) ; self.assertTrue(m.isEqualWithoutConsideringStr(m2,1e-12))
14847         #
14848         m2.setNodeStruct([3,2,4])
14849         self.assertTrue(not m.isEqual(m2,1e-12))
14850         m.setNodeStruct([3,2,4])
14851         self.assertTrue(m.isEqual(m2,1e-12))
14852         m.setOrigin(DataArrayDouble([1.5,3.5,2.5]))
14853         self.assertTrue(not m.isEqual(m2,1e-12))
14854         m2.setOrigin([1.5,3.5,2.5])
14855         self.assertTrue(m.isEqual(m2,1e-12))
14856         m.setDXYZ((0.5,0.25,1.))
14857         self.assertTrue(not m.isEqual(m2,1e-12))
14858         m2.setDXYZ(DataArrayDouble((0.5,0.25,1.)))
14859         self.assertTrue(m.isEqual(m2,1e-12))
14860         m2bis=m2.deepCpy()
14861         self.assertTrue(m2bis.isEqual(m2,1e-12))
14862         #
14863         self.assertEqual(6,m2bis.getNumberOfCells())#3,2,4
14864         m2bis.refineWithFactor([3,3,3])
14865         self.assertEqual(162,m2bis.getNumberOfCells())
14866         self.assertEqual((7,4,10),m2bis.getNodeStruct())
14867         self.assertEqual((1.5,3.5,2.5),m2bis.getOrigin())
14868         self.assertTrue(DataArrayDouble([0.16666666666666666,0.08333333333333333,0.3333333333333333]).isEqual(DataArrayDouble(m2bis.getDXYZ()),1e-12))
14869         #
14870         self.assertEqual(3,m.getMeshDimension())
14871         self.assertAlmostEqual(0.125,m.getMeasureOfAnyCell(),16);
14872         mu=MEDCoupling1SGTUMesh(m.buildUnstructured())
14873         mu.checkCoherency2()
14874         cooExp=DataArrayDouble([(1.5,3.5,2.5),(2,3.5,2.5),(2.5,3.5,2.5),(1.5,3.75,2.5),(2,3.75,2.5),(2.5,3.75,2.5),(1.5,3.5,3.5),(2,3.5,3.5),(2.5,3.5,3.5),(1.5,3.75,3.5),(2,3.75,3.5),(2.5,3.75,3.5),(1.5,3.5,4.5),(2,3.5,4.5),(2.5,3.5,4.5),(1.5,3.75,4.5),(2,3.75,4.5),(2.5,3.75,4.5),(1.5,3.5,5.5),(2,3.5,5.5),(2.5,3.5,5.5),(1.5,3.75,5.5),(2,3.75,5.5),(2.5,3.75,5.5)]) ; cooExp.setInfoOnComponents(["X [m]","Y [m]","Z [m]"])
14875         self.assertTrue(isinstance(mu,MEDCoupling1SGTUMesh))
14876         self.assertEqual(NORM_HEXA8,mu.getCellModelEnum())
14877         self.assertTrue(mu.getCoords().isEqual(cooExp,1e-12))
14878         self.assertTrue(mu.getNodalConnectivity().isEqual(DataArrayInt([1,0,3,4,7,6,9,10,2,1,4,5,8,7,10,11,7,6,9,10,13,12,15,16,8,7,10,11,14,13,16,17,13,12,15,16,19,18,21,22,14,13,16,17,20,19,22,23])))
14879         bary=m.getBarycenterAndOwner()
14880         baryExp=DataArrayDouble([(1.75,3.625,3),(2.25,3.625,3),(1.75,3.625,4),(2.25,3.625,4),(1.75,3.625,5),(2.25,3.625,5)]) ; baryExp.setInfoOnComponents(["X [m]","Y [m]","Z [m]"])
14881         self.assertTrue(bary.isEqual(baryExp,1e-12))
14882         #
14883         c=m.convertToCartesian()
14884         c.checkCoherency()
14885         self.assertEqual([1.1,0,3],c.getTime())
14886         self.assertEqual("ms",c.getTimeUnit())
14887         self.assertEqual(3,c.getMeshDimension())
14888         self.assertEqual(3,c.getSpaceDimension())
14889         arrX=DataArrayDouble([1.5,2.,2.5]) ; arrX.setInfoOnComponents(["X [m]"])
14890         self.assertTrue(c.getCoordsAt(0).isEqual(arrX,1e-12))
14891         arrY=DataArrayDouble([3.5,3.75]) ; arrY.setInfoOnComponents(["Y [m]"])
14892         self.assertTrue(c.getCoordsAt(1).isEqual(arrY,1e-12))
14893         arrZ=DataArrayDouble([2.5,3.5,4.5,5.5]) ; arrZ.setInfoOnComponents(["Z [m]"])
14894         self.assertTrue(c.getCoordsAt(2).isEqual(arrZ,1e-12))
14895         self.assertTrue(c.buildUnstructured().isEqual(m.buildUnstructured(),1e-12))
14896         #
14897         a,b=m.getCellsContainingPoints(baryExp,1e-12)
14898         self.assertTrue(a.isEqual(DataArrayInt([0,1,2,3,4,5])))
14899         self.assertTrue(b.isEqual(DataArrayInt([0,1,2,3,4,5,6])))
14900         for a,b in enumerate(baryExp):
14901             self.assertEqual(a,m.getCellContainingPoint(b,1e-12))
14902             pass
14903         #
14904         m.translate([1.,2.,4.])
14905         self.assertEqual((3,2,4),m.getNodeStruct())
14906         self.assertEqual((2.5,5.5,6.5),m.getOrigin())
14907         self.assertEqual((0.5,0.25,1.),m.getDXYZ())
14908         m.scale([0.,1.,3.],2.)
14909         self.assertAlmostEqual(1.,m.getMeasureOfAnyCell(),16);
14910         self.assertEqual((3,2,4),m.getNodeStruct())
14911         self.assertEqual((5.,10.,10.),m.getOrigin())
14912         self.assertEqual((1.,0.5,2.),m.getDXYZ())
14913         #
14914         f=m.getMeasureField(False)
14915         f2=MEDCouplingFieldDouble(ON_CELLS) ; f2.setTime(1.1,0,3) ; f2.setMesh(m) ; arr=DataArrayDouble(6) ; arr[:]=1. ; f2.setArray(arr) ; f2.setTimeUnit("ms")
14916         f2.setName("MeasureOfMesh_mesh")
14917         self.assertTrue(f.isEqual(f2,1e-12,1e-12))
14918         #
14919         m3=m.buildStructuredSubPart([(1,2),(0,1),(1,3)])
14920         self.assertEqual((2,2,3),m3.getNodeStruct())
14921         self.assertEqual((6.,10.,12.),m3.getOrigin())
14922         self.assertEqual((1.,0.5,2.),m3.getDXYZ())
14923         # now playing with 3D surf
14924         m4=MEDCouplingIMesh("",3,DataArrayInt([3,1,4]),DataArrayDouble([1.5,2.5,3.5]),DataArrayDouble((0.5,1.,0.25))) ; m4.setAxisUnit("km")
14925         self.assertEqual(3,m4.getSpaceDimension())
14926         self.assertEqual(2,m4.getMeshDimension())
14927         self.assertEqual(12,m4.getNumberOfNodes())
14928         self.assertEqual(6,m4.getNumberOfCells())
14929         mu=MEDCoupling1SGTUMesh(m4.buildUnstructured())
14930         mu.checkCoherency2()
14931         self.assertTrue(isinstance(mu,MEDCoupling1SGTUMesh))
14932         self.assertEqual(NORM_QUAD4,mu.getCellModelEnum())
14933         coordsExp=DataArrayDouble([(1.5,2.5,3.5),(2,2.5,3.5),(2.5,2.5,3.5),(1.5,2.5,3.75),(2,2.5,3.75),(2.5,2.5,3.75),(1.5,2.5,4),(2,2.5,4),(2.5,2.5,4),(1.5,2.5,4.25),(2,2.5,4.25),(2.5,2.5,4.25)]) ; coordsExp.setInfoOnComponents(["X [km]","Y [km]","Z [km]"])
14934         self.assertTrue(mu.getCoords().isEqual(coordsExp,1e-12))
14935         self.assertTrue(mu.getNodalConnectivity().isEqual(DataArrayInt([1,0,3,4,2,1,4,5,4,3,6,7,5,4,7,8,7,6,9,10,8,7,10,11])))
14936         pass
14937
14938     def testSwig2AMR1(self):
14939         self.assertEqual((1,3,12),MEDCouplingStructuredMesh.GetSplitVectFromStruct([3,4,5]))
14940         self.assertEqual((3,2),MEDCouplingStructuredMesh.GetDimensionsFromCompactFrmt([(1,4),(2,4)]))
14941         #
14942         amr=MEDCouplingCartesianAMRMesh("",2,[3,3],[0,0],[1,1])
14943         self.assertEqual(4,amr.getNumberOfCellsAtCurrentLevel())
14944         self.assertEqual(4,amr.getNumberOfCellsRecursiveWithOverlap())
14945         self.assertEqual(4,amr.getNumberOfCellsRecursiveWithoutOverlap())
14946         self.assertEqual(0,amr.getNumberOfPatches())
14947         self.assertEqual(1,amr.getMaxNumberOfLevelsRelativeToThis())
14948         self.assertEqual(2,amr.getSpaceDimension())
14949         amr.addPatch([(1,2),(0,1)],[4,4])
14950         self.assertEqual(4,amr.getNumberOfCellsAtCurrentLevel())
14951         self.assertEqual(20,amr.getNumberOfCellsRecursiveWithOverlap())
14952         self.assertEqual(19,amr.getNumberOfCellsRecursiveWithoutOverlap())
14953         self.assertEqual(1,amr.getNumberOfPatches())
14954         self.assertEqual(2,amr.getMaxNumberOfLevelsRelativeToThis())
14955         self.assertEqual(2,amr.getSpaceDimension())
14956         amr[0].addPatch([(2,3),(1,3)],[2,2])
14957         self.assertEqual(amr[0].getBLTRRange(),[(1,2),(0,1)])
14958         self.assertEqual(4,amr.getNumberOfCellsAtCurrentLevel())
14959         self.assertEqual(28,amr.getNumberOfCellsRecursiveWithOverlap())
14960         self.assertEqual(25,amr.getNumberOfCellsRecursiveWithoutOverlap())
14961         self.assertEqual(1,amr.getNumberOfPatches())
14962         self.assertEqual(3,amr.getMaxNumberOfLevelsRelativeToThis())
14963         self.assertEqual(2,amr.getSpaceDimension())
14964         amr[0].addPatch([(0,2),(3,4)],[3,3])
14965         self.assertEqual(16,amr[0].getMesh().getNumberOfCellsAtCurrentLevel())
14966         self.assertEqual(46,amr.getNumberOfCellsRecursiveWithOverlap())
14967         self.assertEqual(41,amr.getNumberOfCellsRecursiveWithoutOverlap())
14968         self.assertEqual(2,amr[0].getMesh().getNumberOfPatches())
14969         self.assertEqual(3,amr.getMaxNumberOfLevelsRelativeToThis())
14970         self.assertEqual(2,amr.getSpaceDimension())
14971         del amr[0][1]
14972         self.assertEqual(amr[0].getBLTRRange(),[(1,2),(0,1)])
14973         self.assertEqual(4,amr.getNumberOfCellsAtCurrentLevel())
14974         self.assertEqual(28,amr.getNumberOfCellsRecursiveWithOverlap())
14975         self.assertEqual(25,amr.getNumberOfCellsRecursiveWithoutOverlap())
14976         self.assertEqual(1,amr.getNumberOfPatches())
14977         self.assertEqual(3,amr.getMaxNumberOfLevelsRelativeToThis())
14978         self.assertEqual(2,amr.getSpaceDimension())
14979         pass
14980
14981     def testSwig2NonRegressionTestPAL1164(self):
14982         """ Test PAL1164 Protection of applyLin against error in compoId ( #CEA22584 ) """
14983         xarr=DataArrayDouble(3,1)
14984         xarr.iota(0.)
14985         cmesh=MEDCouplingCMesh()
14986         cmesh.setCoords(xarr,xarr,xarr)
14987         mesh=cmesh.buildUnstructured()
14988         f=mesh.fillFromAnalytic(ON_CELLS,1,"(x-5.)*(x-5.)+(y-5.)*(y-5.)+(z-5.)*(z-5.)")
14989         f.setName("MyField")
14990         self.assertTrue(f.getArray().isEqual(DataArrayDouble([60.75,52.75,52.75,44.75,52.75,44.75,44.75,36.75]),1e-12))
14991         self.assertRaises(InterpKernelException,f.applyLin,2.,0.,1)# compoId 1 whereas f has only one component !
14992         self.assertTrue(f.getArray().isEqual(DataArrayDouble([60.75,52.75,52.75,44.75,52.75,44.75,44.75,36.75]),1e-12))
14993         f.applyLin(2.,0.,0)# here it is OK !
14994         self.assertTrue(f.getArray().isEqual(DataArrayDouble([121.5,105.5,105.5,89.5,105.5,89.5,89.5,73.5]),1e-12))
14995         f.applyLin(2.,0.)
14996         self.assertTrue(f.getArray().isEqual(DataArrayDouble([243.,211.,211.,179.,211.,179.,179.,147.]),1e-12))
14997         pass
14998
14999     def testSwig2StructurizeMe1(self):
15000         arrx=DataArrayDouble(3) ; arrx.iota() ; arrx*=2.
15001         arry=DataArrayDouble(4) ; arry.iota() ; arry+=3.
15002         arrz=DataArrayDouble(5) ; arrz.iota() ; arrz*=0.5 ; arrz+=2.
15003         c=MEDCouplingCMesh() ; c.setCoords(arrx,arry,arrz)
15004         c.setName("mesh") ; c.setDescription("mesh descr") ; c.setTimeUnit("us") ; c.setTime(1.2,3,4)
15005         u=c.buildUnstructured()
15006         cp=DataArrayInt([3,5,6,1,0,9,8,7,12,11,16,10,17,23,22,21,19,20,18,14,13,2,4,15])
15007         np=DataArrayInt([3,33,5,35,6,36,1,31,0,30,9,39,8,38,7,37,12,42,11,41,16,46,10,40,17,47,23,53,22,52,21,51,19,49,20,50,18,48,14,44,13,43,2,32,4,34,15,45,29,59,28,58,27,57,26,56,25,55,24,54])
15008         u.renumberCells(cp)
15009         u.renumberNodes(np,len(np))
15010         u=MEDCoupling1SGTUMesh(u)
15011         #
15012         e,d,f=u.structurizeMe()
15013         self.assertTrue(c.isEqual(e,1e-12))
15014         self.assertTrue(d.isEqual(cp))
15015         self.assertTrue(f.isEqual(np))
15016         pass
15017
15018     def testSwig2DenseMatrix1(self):
15019         m0=DenseMatrix(DataArrayDouble([2,3,4,5,1,6]),2,3)
15020         self.assertEqual(m0.getNumberOfRows(),2)
15021         self.assertEqual(m0.getNumberOfCols(),3)
15022         self.assertEqual(m0.getNbOfElems(),6)
15023         ref=m0.getData().getHiddenCppPointer()
15024         m00=m0.deepCpy()
15025         self.assertTrue(m0.isEqual(m00,1e-12))
15026         m00.getData().setIJ(0,0,2.1)
15027         self.assertTrue(not m0.isEqual(m00,1e-12))
15028         m00.getData().setIJ(0,0,2.)
15029         self.assertTrue(m0.isEqual(m00,1e-12))
15030         self.assertTrue(m0.getData().isEqual(DataArrayDouble([2,3,4,5,1,6]),1e-12))
15031         #
15032         m000=m0*DataArrayDouble([5,9,3])
15033         self.assertTrue(m000.getData().isEqual(DataArrayDouble([49.,52.]),1e-12))
15034         #
15035         m0.reShape(3,2)
15036         self.assertTrue(not m0.isEqual(m00,1e-12))
15037         self.assertEqual(m0.getNumberOfRows(),3)
15038         self.assertEqual(m0.getNumberOfCols(),2)
15039         self.assertEqual(ref,m0.getData().getHiddenCppPointer())
15040         self.assertTrue(m0.getData().isEqual(DataArrayDouble([2,3,4,5,1,6]),1e-12))
15041         m0.reShape(2,3)
15042         self.assertTrue(m0.isEqual(m00,1e-12))
15043         self.assertEqual(ref,m0.getData().getHiddenCppPointer())
15044         self.assertEqual(m0.getNumberOfRows(),2)
15045         self.assertEqual(m0.getNumberOfCols(),3)
15046         self.assertTrue(m0.getData().isEqual(DataArrayDouble([2,3,4,5,1,6]),1e-12))
15047         #m0np=m0.getData().toNumPyArray() ; m0np=matrix(m0np.reshape(m0.getNumberOfRows(),m0.getNumberOfCols()))
15048         m1=m0.deepCpy()
15049         self.assertEqual(m1.getNumberOfRows(),2)
15050         self.assertEqual(m1.getNumberOfCols(),3)
15051         self.assertTrue(m1.getData().isEqual(DataArrayDouble([2,3,4,5,1,6]),1e-12))
15052         m11=m0.deepCpy() ; m11+=m1
15053         self.assertEqual(m11.getNumberOfRows(),2)
15054         self.assertEqual(m11.getNumberOfCols(),3)
15055         self.assertTrue(m11.getData().isEqual(DataArrayDouble([4,6,8,10,2,12]),1e-12))
15056         m11=m11+m1
15057         self.assertEqual(m11.getNumberOfRows(),2)
15058         self.assertEqual(m11.getNumberOfCols(),3)
15059         self.assertTrue(m11.getData().isEqual(DataArrayDouble([6,9,12,15,3,18]),1e-12))
15060         m11=m11-m1
15061         self.assertEqual(m11.getNumberOfRows(),2)
15062         self.assertEqual(m11.getNumberOfCols(),3)
15063         self.assertTrue(m11.getData().isEqual(DataArrayDouble([4,6,8,10,2,12]),1e-12))
15064         m11-=m1
15065         self.assertEqual(m1.getNumberOfRows(),2)
15066         self.assertEqual(m1.getNumberOfCols(),3)
15067         self.assertTrue(m1.getData().isEqual(DataArrayDouble([2,3,4,5,1,6]),1e-12))
15068         m1.transpose()
15069         self.assertEqual(m1.getNumberOfRows(),3)
15070         self.assertEqual(m1.getNumberOfCols(),2)
15071         self.assertTrue(m1.getData().isEqual(DataArrayDouble([2,5,3,1,4,6]),1e-12))
15072         #m1np=m0np.transpose()
15073         m2=m0*m1
15074         self.assertEqual(m2.getNumberOfRows(),2)
15075         self.assertEqual(m2.getNumberOfCols(),2)
15076         self.assertTrue(m2.getData().isEqual(DataArrayDouble([29,37,37,62]),1e-12))
15077         pass
15078
15079     def testAMR2(self):
15080         """ Test condensation of fine IMesh instance into a coarse one, with a factor. See testRemapperAMR1 in MEDCouplingRemapperTest.py file to see how the expected value is obtained."""
15081         coarse=DataArrayDouble(35) ; coarse.iota(0) #X=5,Y=7
15082         fine=DataArrayDouble(3*2*4*4) ; fine.iota(0) #X=3,Y=2 refined by 4
15083         MEDCouplingIMesh.CondenseFineToCoarse(coarse,[5,7],fine,[(1,4),(2,4)],[4,4])
15084         self.assertTrue(coarse.isEqual(DataArrayDouble([0,1,2,3,4,5,6,7,8,9,10,312,376,440,14,15,1080,1144,1208,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34]),1e-12))
15085         # 3D
15086         coarse=DataArrayDouble(175) ; coarse.iota(0) #X=5,Y=7,Z=5
15087         fine=DataArrayDouble(3*2*3*4*4*4) ; fine.iota(0) #X=3,Y=2,Z=3 refined by 4
15088         MEDCouplingIMesh.CondenseFineToCoarse(coarse,[5,7,5],fine,[(1,4),(2,4),(1,4)],[4,4,4])
15089         self.assertTrue(coarse.isEqual(DataArrayDouble([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.,10464.,10720.,10976.,49.,50.,13536.,13792.,14048.,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.,35040.,35296.,35552.,84.,85.,38112.,38368.,38624.,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.,115.,59616.,59872.,60128.,119.,120.,62688.,62944.,63200.,124.,125.,126.,127.,128.,129.,130.,131.,132.,133.,134.,135.,136.,137.,138.,139.,140.,141.,142.,143.,144.,145.,146.,147.,148.,149.,150.,151.,152.,153.,154.,155.,156.,157.,158.,159.,160.,161.,162.,163.,164.,165.,166.,167.,168.,169.,170.,171.,172.,173.,174.]),1e-12))
15090         # 1D
15091         coarse=DataArrayDouble(5) ; coarse.iota(0) #X=5
15092         fine=DataArrayDouble(3*4) ; fine.iota(0) #X=3 refined by 4
15093         MEDCouplingIMesh.CondenseFineToCoarse(coarse,[5],fine,[(1,4)],[4])
15094         self.assertTrue(coarse.isEqual(DataArrayDouble([0,6,22,38,4]),1e-12))
15095         pass
15096
15097     def testAMR3(self):
15098         """ Test spread of coarse IMesh instance into a fine one, with a factor."""
15099         coarse=DataArrayDouble(35) ; coarse.iota(0) #X=5,Y=7
15100         fine=DataArrayDouble(3*2*4*4) ; fine.iota(0) #X=3,Y=2 refined by 4
15101         MEDCouplingIMesh.SpreadCoarseToFine(coarse,[5,7],fine,[(1,4),(2,4)],[4,4])
15102         self.assertTrue(fine.isEqual(DataArrayDouble([11.,11.,11.,11.,12.,12.,12.,12.,13.,13.,13.,13.,11.,11.,11.,11.,12.,12.,12.,12.,13.,13.,13.,13.,11.,11.,11.,11.,12.,12.,12.,12.,13.,13.,13.,13.,11.,11.,11.,11.,12.,12.,12.,12.,13.,13.,13.,13.,16.,16.,16.,16.,17.,17.,17.,17.,18.,18.,18.,18.,16.,16.,16.,16.,17.,17.,17.,17.,18.,18.,18.,18.,16.,16.,16.,16.,17.,17.,17.,17.,18.,18.,18.,18.,16.,16.,16.,16.,17.,17.,17.,17.,18.,18.,18.,18.]),1e-12))
15103         # 3D
15104         coarse=DataArrayDouble(175) ; coarse.iota(0) #X=5,Y=7,Z=5
15105         fine=DataArrayDouble(3*2*3*4*4*4) ; fine.iota(0) #X=3,Y=2,Z=3 refined by 4
15106         MEDCouplingIMesh.SpreadCoarseToFine(coarse,[5,7,5],fine,[(1,4),(2,4),(1,4)],[4,4,4])
15107         self.assertTrue(fine.isEqual(DataArrayDouble([46.,46.,46.,46.,47.,47.,47.,47.,48.,48.,48.,48.,46.,46.,46.,46.,47.,47.,47.,47.,48.,48.,48.,48.,46.,46.,46.,46.,47.,47.,47.,47.,48.,48.,48.,48.,46.,46.,46.,46.,47.,47.,47.,47.,48.,48.,48.,48.,51.,51.,51.,51.,52.,52.,52.,52.,53.,53.,53.,53.,51.,51.,51.,51.,52.,52.,52.,52.,53.,53.,53.,53.,51.,51.,51.,51.,52.,52.,52.,52.,53.,53.,53.,53.,51.,51.,51.,51.,52.,52.,52.,52.,53.,53.,53.,53.,46.,46.,46.,46.,47.,47.,47.,47.,48.,48.,48.,48.,46.,46.,46.,46.,47.,47.,47.,47.,48.,48.,48.,48.,46.,46.,46.,46.,47.,47.,47.,47.,48.,48.,48.,48.,46.,46.,46.,46.,47.,47.,47.,47.,48.,48.,48.,48.,51.,51.,51.,51.,52.,52.,52.,52.,53.,53.,53.,53.,51.,51.,51.,51.,52.,52.,52.,52.,53.,53.,53.,53.,51.,51.,51.,51.,52.,52.,52.,52.,53.,53.,53.,53.,51.,51.,51.,51.,52.,52.,52.,52.,53.,53.,53.,53.,46.,46.,46.,46.,47.,47.,47.,47.,48.,48.,48.,48.,46.,46.,46.,46.,47.,47.,47.,47.,48.,48.,48.,48.,46.,46.,46.,46.,47.,47.,47.,47.,48.,48.,48.,48.,46.,46.,46.,46.,47.,47.,47.,47.,48.,48.,48.,48.,51.,51.,51.,51.,52.,52.,52.,52.,53.,53.,53.,53.,51.,51.,51.,51.,52.,52.,52.,52.,53.,53.,53.,53.,51.,51.,51.,51.,52.,52.,52.,52.,53.,53.,53.,53.,51.,51.,51.,51.,52.,52.,52.,52.,53.,53.,53.,53.,46.,46.,46.,46.,47.,47.,47.,47.,48.,48.,48.,48.,46.,46.,46.,46.,47.,47.,47.,47.,48.,48.,48.,48.,46.,46.,46.,46.,47.,47.,47.,47.,48.,48.,48.,48.,46.,46.,46.,46.,47.,47.,47.,47.,48.,48.,48.,48.,51.,51.,51.,51.,52.,52.,52.,52.,53.,53.,53.,53.,51.,51.,51.,51.,52.,52.,52.,52.,53.,53.,53.,53.,51.,51.,51.,51.,52.,52.,52.,52.,53.,53.,53.,53.,51.,51.,51.,51.,52.,52.,52.,52.,53.,53.,53.,53.,81.,81.,81.,81.,82.,82.,82.,82.,83.,83.,83.,83.,81.,81.,81.,81.,82.,82.,82.,82.,83.,83.,83.,83.,81.,81.,81.,81.,82.,82.,82.,82.,83.,83.,83.,83.,81.,81.,81.,81.,82.,82.,82.,82.,83.,83.,83.,83.,86.,86.,86.,86.,87.,87.,87.,87.,88.,88.,88.,88.,86.,86.,86.,86.,87.,87.,87.,87.,88.,88.,88.,88.,86.,86.,86.,86.,87.,87.,87.,87.,88.,88.,88.,88.,86.,86.,86.,86.,87.,87.,87.,87.,88.,88.,88.,88.,81.,81.,81.,81.,82.,82.,82.,82.,83.,83.,83.,83.,81.,81.,81.,81.,82.,82.,82.,82.,83.,83.,83.,83.,81.,81.,81.,81.,82.,82.,82.,82.,83.,83.,83.,83.,81.,81.,81.,81.,82.,82.,82.,82.,83.,83.,83.,83.,86.,86.,86.,86.,87.,87.,87.,87.,88.,88.,88.,88.,86.,86.,86.,86.,87.,87.,87.,87.,88.,88.,88.,88.,86.,86.,86.,86.,87.,87.,87.,87.,88.,88.,88.,88.,86.,86.,86.,86.,87.,87.,87.,87.,88.,88.,88.,88.,81.,81.,81.,81.,82.,82.,82.,82.,83.,83.,83.,83.,81.,81.,81.,81.,82.,82.,82.,82.,83.,83.,83.,83.,81.,81.,81.,81.,82.,82.,82.,82.,83.,83.,83.,83.,81.,81.,81.,81.,82.,82.,82.,82.,83.,83.,83.,83.,86.,86.,86.,86.,87.,87.,87.,87.,88.,88.,88.,88.,86.,86.,86.,86.,87.,87.,87.,87.,88.,88.,88.,88.,86.,86.,86.,86.,87.,87.,87.,87.,88.,88.,88.,88.,86.,86.,86.,86.,87.,87.,87.,87.,88.,88.,88.,88.,81.,81.,81.,81.,82.,82.,82.,82.,83.,83.,83.,83.,81.,81.,81.,81.,82.,82.,82.,82.,83.,83.,83.,83.,81.,81.,81.,81.,82.,82.,82.,82.,83.,83.,83.,83.,81.,81.,81.,81.,82.,82.,82.,82.,83.,83.,83.,83.,86.,86.,86.,86.,87.,87.,87.,87.,88.,88.,88.,88.,86.,86.,86.,86.,87.,87.,87.,87.,88.,88.,88.,88.,86.,86.,86.,86.,87.,87.,87.,87.,88.,88.,88.,88.,86.,86.,86.,86.,87.,87.,87.,87.,88.,88.,88.,88.,116.,116.,116.,116.,117.,117.,117.,117.,118.,118.,118.,118.,116.,116.,116.,116.,117.,117.,117.,117.,118.,118.,118.,118.,116.,116.,116.,116.,117.,117.,117.,117.,118.,118.,118.,118.,116.,116.,116.,116.,117.,117.,117.,117.,118.,118.,118.,118.,121.,121.,121.,121.,122.,122.,122.,122.,123.,123.,123.,123.,121.,121.,121.,121.,122.,122.,122.,122.,123.,123.,123.,123.,121.,121.,121.,121.,122.,122.,122.,122.,123.,123.,123.,123.,121.,121.,121.,121.,122.,122.,122.,122.,123.,123.,123.,123.,116.,116.,116.,116.,117.,117.,117.,117.,118.,118.,118.,118.,116.,116.,116.,116.,117.,117.,117.,117.,118.,118.,118.,118.,116.,116.,116.,116.,117.,117.,117.,117.,118.,118.,118.,118.,116.,116.,116.,116.,117.,117.,117.,117.,118.,118.,118.,118.,121.,121.,121.,121.,122.,122.,122.,122.,123.,123.,123.,123.,121.,121.,121.,121.,122.,122.,122.,122.,123.,123.,123.,123.,121.,121.,121.,121.,122.,122.,122.,122.,123.,123.,123.,123.,121.,121.,121.,121.,122.,122.,122.,122.,123.,123.,123.,123.,116.,116.,116.,116.,117.,117.,117.,117.,118.,118.,118.,118.,116.,116.,116.,116.,117.,117.,117.,117.,118.,118.,118.,118.,116.,116.,116.,116.,117.,117.,117.,117.,118.,118.,118.,118.,116.,116.,116.,116.,117.,117.,117.,117.,118.,118.,118.,118.,121.,121.,121.,121.,122.,122.,122.,122.,123.,123.,123.,123.,121.,121.,121.,121.,122.,122.,122.,122.,123.,123.,123.,123.,121.,121.,121.,121.,122.,122.,122.,122.,123.,123.,123.,123.,121.,121.,121.,121.,122.,122.,122.,122.,123.,123.,123.,123.,116.,116.,116.,116.,117.,117.,117.,117.,118.,118.,118.,118.,116.,116.,116.,116.,117.,117.,117.,117.,118.,118.,118.,118.,116.,116.,116.,116.,117.,117.,117.,117.,118.,118.,118.,118.,116.,116.,116.,116.,117.,117.,117.,117.,118.,118.,118.,118.,121.,121.,121.,121.,122.,122.,122.,122.,123.,123.,123.,123.,121.,121.,121.,121.,122.,122.,122.,122.,123.,123.,123.,123.,121.,121.,121.,121.,122.,122.,122.,122.,123.,123.,123.,123.,121.,121.,121.,121.,122.,122.,122.,122.,123.,123.,123.,123.]),1e-12))
15108         #f=MEDCouplingFieldDouble(ON_CELLS) ; f.setMesh(MEDCouplingIMesh("",3,DataArrayInt([6,8,6]),[0.,0.,0.],DataArrayDouble((1.,1.,1.)))) ; f.setArray(coarse) ; f.setName("tutu") ; f.checkCoherency() ; f.writeVTK("coarse.vti")
15109         #f=MEDCouplingFieldDouble(ON_CELLS) ; f.setMesh(MEDCouplingIMesh("",3,DataArrayInt([13,9,13]),[1.,2.,1.],DataArrayDouble((0.25,0.25,0.25)))) ; f.setArray(fine) ; f.setName("tutu") ; f.checkCoherency() ; f.writeVTK("fine.vti")
15110         # 1D
15111         coarse=DataArrayDouble(5) ; coarse.iota(0) #X=5
15112         fine=DataArrayDouble(3*4) ; fine.iota(0) #X=3 refined by 4
15113         MEDCouplingIMesh.SpreadCoarseToFine(coarse,[5],fine,[(1,4)],[4])
15114         self.assertTrue(fine.isEqual(DataArrayDouble([1.,1.,1.,1.,2.,2.,2.,2.,3.,3.,3.,3.]),1e-12))
15115         pass
15116
15117     def setUp(self):
15118         pass
15119     pass
15120
15121 if __name__ == '__main__':
15122     unittest.main()