src/MEDCoupling_Swig/MEDCouplingBasicsTest.py

   1 #  -*- coding: iso-8859-1 -*-
   2 # Copyright (C) 2007-2015  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 testNatureOperations(self):
 675         """ Check nature constraints on field operations """
 676         m = MEDCouplingCMesh()
 677         m.setCoordsAt(0, DataArrayDouble([1.0,2.0,3.0]))
 678         m.setCoordsAt(1, DataArrayDouble([1.0,2.0,3.0]))
 679         m = m.buildUnstructured()
 680         f1, f2 = MEDCouplingFieldDouble.New(ON_CELLS, NO_TIME), MEDCouplingFieldDouble.New(ON_CELLS, NO_TIME)
 681         f1.setNature(Integral)
 682         f2.setNature(ConservativeVolumic)
 683         self.assertEqual(Integral, f1.getNature())
 684         self.assertEqual(ConservativeVolumic, f2.getNature())
 685
 686         da = DataArrayDouble([1.0,2.0,3.0,4.0])
 687         f1.setMesh(m); f2.setMesh(m)
 688         f1.setArray(da); f2.setArray(da.deepCpy())
 689         # All this should complain about nature:
 690         self.assertRaises(InterpKernelException, f1.__add__, f2)
 691         self.assertRaises(InterpKernelException, f1.__iadd__, f2)
 692         self.assertRaises(InterpKernelException, f1.__sub__, f2)
 693         self.assertRaises(InterpKernelException, f1.__isub__, f2)
 694         self.assertRaises(InterpKernelException, f1.__radd__, f2)
 695         self.assertRaises(InterpKernelException, f1.__rsub__, f2)
 696         self.assertRaises(InterpKernelException, MEDCouplingFieldDouble.AddFields, f1, f2)
 697         self.assertRaises(InterpKernelException, MEDCouplingFieldDouble.SubstractFields, f1, f2)
 698         self.assertRaises(InterpKernelException, MEDCouplingFieldDouble.MaxFields, f1, f2)
 699         self.assertRaises(InterpKernelException, MEDCouplingFieldDouble.MinFields, f1, f2)
 700         # Not those ones:
 701         f3 = MEDCouplingFieldDouble.MultiplyFields(f1,f2)
 702         self.assertEqual(NoNature, f3.getNature())
 703         f3 = f1*f2
 704         self.assertEqual(NoNature, f3.getNature())
 705         f1Tmp = f1.deepCpy(); f1Tmp.setMesh(m);  f1Tmp *= f2
 706         self.assertEqual(NoNature, f1Tmp.getNature())
 707         f3 = MEDCouplingFieldDouble.DivideFields(f1,f2)
 708         self.assertEqual(NoNature, f3.getNature())
 709         f3 = f1/f2
 710         self.assertEqual(NoNature, f3.getNature())
 711         f1Tmp = f1.deepCpy();  f1Tmp.setMesh(m);  f1Tmp /= f2
 712         self.assertEqual(NoNature, f1Tmp.getNature())
 713 #         f3 = MEDCouplingFieldDouble.PowFields(f1,f2)
 714 #         self.assertEqual(NoNature, f3.getNature())
 715         f3 = f1**f2
 716         self.assertEqual(NoNature, f3.getNature())
 717         f1Tmp = f1.deepCpy();  f1Tmp.setMesh(m);  f1Tmp **= f2
 718         self.assertEqual(NoNature, f1Tmp.getNature())
 719         f3 = MEDCouplingFieldDouble.DotFields(f1,f2)
 720         self.assertEqual(NoNature, f3.getNature())
 721         f3 = f1.dot(f2)
 722         self.assertEqual(NoNature, f3.getNature())
 723
 724         da = DataArrayDouble.Meld([da, da, da])
 725         f1.setArray(da); f2.setArray(da.deepCpy())
 726         f3 = MEDCouplingFieldDouble.CrossProductFields(f1,f2)
 727         self.assertEqual(NoNature, f3.getNature())
 728         f3 = f1.crossProduct(f2)
 729
 730     def testBuildSubMeshData(self):
 731         targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1()
 732         #check buildSubMesh on field on cells
 733         fieldCells=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
 734         fieldCells.setMesh(targetMesh);
 735         elts=[1,2,4]
 736         ret1,di=fieldCells.buildSubMeshData(elts);
 737         self.assertTrue(isinstance(ret1,MEDCouplingUMesh))
 738         self.assertEqual(3,ret1.getNumberOfCells());
 739         self.assertEqual(9,ret1.getNumberOfNodes());
 740         self.assertEqual(3,di.getNumberOfTuples());
 741         self.assertEqual(1,di.getNumberOfComponents());
 742         toCheck=di.getValues();
 743         self.assertTrue(elts,toCheck);
 744         #check buildSubMesh on field on nodes
 745         fieldNodes=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
 746         fieldNodes.setMesh(targetMesh);
 747         ret2,di=fieldNodes.buildSubMeshData(elts);
 748         self.assertTrue(isinstance(ret2,MEDCouplingUMesh))
 749         self.assertEqual(3,ret2.getNumberOfCells());
 750         self.assertEqual(6,ret2.getNumberOfNodes());
 751         self.assertEqual(6,di.getNumberOfTuples());
 752         self.assertEqual(1,di.getNumberOfComponents());
 753         toCheck=di.getValues();
 754         expected=[1,2,4,5,7,8]
 755         self.assertEqual(expected,list(toCheck));
 756         pass
 757
 758     def testExtrudedMesh1(self):
 759         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
 760         ext=MEDCouplingExtrudedMesh.New(mesh3D,mesh2D,1);
 761         self.assertEqual(18,ext.getNumberOfCells());
 762         self.assertEqual(60,ext.getNumberOfNodes());
 763         ids3D=ext.getMesh3DIds();
 764         ids3DExpected=[5,4,3,2,1,0, 11,10,9,8,7,6, 17,16,15,14,13,12]
 765         self.assertEqual(18,ids3D.getNumberOfTuples());
 766         self.assertEqual(1,ids3D.getNumberOfComponents());
 767         self.assertEqual(ids3DExpected,list(ids3D.getValues()));
 768         mesh1D=ext.getMesh1D();
 769         self.assertEqual(4,mesh1D.getNumberOfNodes());
 770         self.assertEqual(3,mesh1D.getNumberOfCells());
 771         mesh1DExpected=[0.66666666666666663, 1.4583333333333333, 0, 0.66666666666666663,
 772                         1.4583333333333333, 1, 0.66666666666666663, 1.4583333333333333,
 773                         2, 0.66666666666666663, 1.4583333333333333, 3]
 774         mesh1DCoords=mesh1D.getCoords();
 775         self.assertEqual(4,mesh1DCoords.getNumberOfTuples());
 776         self.assertEqual(3,mesh1DCoords.getNumberOfComponents());
 777         self.assertEqual(mesh1DExpected,mesh1DCoords.getValues());
 778         conn1D=mesh1D.getNodalConnectivity();
 779         self.assertEqual(9,conn1D.getNumberOfTuples());
 780         self.assertEqual(1,conn1D.getNumberOfComponents());
 781         conn1DExpected=[1,0,1,1,1,2,1,2,3]
 782         self.assertEqual(conn1DExpected,list(conn1D.getValues()));
 783         pass
 784
 785     def testExtrudedMesh3(self):
 786         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
 787         m1.changeSpaceDimension(3);
 788         m2=MEDCouplingDataForTest.buildCU1DMesh_U();
 789         m2.changeSpaceDimension(3);
 790         center=[0.,0.,0.]
 791         vector=[0.,1.,0.]
 792         m2.rotate(center,vector,-pi/2.);
 793         m3=m1.buildExtrudedMesh(m2,0);
 794         #
 795         m4=MEDCouplingExtrudedMesh.New(m3,m1,0);
 796         self.assertEqual(15,m4.getNumberOfCells());
 797         self.assertEqual(5,m4.getMesh2D().getNumberOfCells());
 798         self.assertEqual(3,m4.getMesh1D().getNumberOfCells());
 799         m3DIds=m4.getMesh3DIds().getValues();
 800         self.assertEqual(range(15),list(m3DIds));
 801         #some random in cells to check that extrusion alg find it correctly
 802         expected1=[1,3,2,0,6,5,7,10,11,8,12,9,14,13,4]
 803         m3.renumberCells(expected1,False);
 804         m4=MEDCouplingExtrudedMesh.New(m3,m1,0);
 805         self.assertEqual(15,m4.getNumberOfCells());
 806         self.assertEqual(5,m4.getMesh2D().getNumberOfCells());
 807         self.assertEqual(3,m4.getMesh1D().getNumberOfCells());
 808         m3DIds=m4.getMesh3DIds().getValues();
 809         self.assertEqual(expected1,list(m3DIds));
 810         #play with polygons and polyedrons
 811         cells=[2,3]
 812         m1.convertToPolyTypes(cells);
 813         m3=m1.buildExtrudedMesh(m2,0);
 814         self.assertEqual(NORM_HEXA8,m3.getTypeOfCell(0));
 815         self.assertEqual(NORM_PENTA6,m3.getTypeOfCell(1));
 816         self.assertEqual(NORM_POLYHED,m3.getTypeOfCell(2));
 817         self.assertEqual(NORM_POLYHED,m3.getTypeOfCell(3));
 818         self.assertEqual(NORM_HEXA8,m3.getTypeOfCell(4));
 819         m3.renumberCells(expected1,False);
 820         m4=MEDCouplingExtrudedMesh.New(m3,m1,0);
 821         self.assertEqual(15,m4.getNumberOfCells());
 822         self.assertEqual(5,m4.getMesh2D().getNumberOfCells());
 823         self.assertEqual(3,m4.getMesh1D().getNumberOfCells());
 824         m3DIds=m4.getMesh3DIds().getValues();
 825         self.assertEqual(expected1,list(m3DIds));
 826         pass
 827
 828     def testExtrudedMesh4(self):
 829         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
 830         cells=[2,4];
 831         m1.convertToPolyTypes(cells);
 832         m1.changeSpaceDimension(3);
 833         m2=MEDCouplingDataForTest.buildCU1DMesh_U();
 834         m2.changeSpaceDimension(3);
 835         center=[0.,0.,0.]
 836         vector=[0.,1.,0.]
 837         m2.rotate(center,vector,-pi/2.);
 838         m1.zipCoords()
 839         m3=m1.buildExtrudedMesh(m2,0);
 840         expected1=[1,3,2,0,6,5,7,10,11,8,12,9,14,13,4]
 841         rexpected1=[3, 0, 2, 1, 14, 5, 4, 6, 9, 11, 7, 8, 10, 13, 12]
 842         m3.renumberCells(expected1,False);
 843         m4=MEDCouplingExtrudedMesh.New(m3,m1,0);
 844         self.assertEqual(NORM_HEXA8,m4.getTypeOfCell(0));
 845         self.assertEqual(NORM_HEXA8,m4.getTypeOfCell(1));
 846         self.assertEqual(NORM_POLYHED,m4.getTypeOfCell(2));
 847         self.assertEqual(NORM_PENTA6,m4.getTypeOfCell(7));
 848         f=m4.getMeasureField(True);
 849         arr=f.getArray();
 850         self.assertEqual(15,arr.getNumberOfTuples());
 851         self.assertEqual(1,arr.getNumberOfComponents());
 852         arrPtr=arr.getValues();
 853         expected2=[0.075,0.0375,0.0375,0.075,0.075,
 854                    0.1125,0.05625,0.05625,0.1125,0.1125,
 855                    0.0625,0.03125,0.03125,0.0625,0.0625]
 856         for i in xrange(15):
 857             self.assertAlmostEqual(expected2[rexpected1[i]],arrPtr[i],16);
 858             pass
 859         m5=m4.build3DUnstructuredMesh();
 860         m5.zipCoords()
 861         self.assertTrue(m5.isEqual(m3,1e-12));
 862         f=m5.getMeasureField(True);
 863         f.setMesh(m4)
 864         self.assertTrue(isinstance(f.getMesh(),MEDCouplingExtrudedMesh))
 865         arr=f.getArray();
 866         arrPtr=arr.getValues();
 867         for i in xrange(15):
 868             self.assertAlmostEqual(expected2[rexpected1[i]],arrPtr[i],15);
 869             pass
 870         pass
 871
 872     def testFindCommonNodes(self):
 873         targetMesh=MEDCouplingDataForTest.build3DTargetMesh_1();
 874         comm,commI=targetMesh.findCommonNodes(1e-10,-1);
 875         self.assertEqual(1,commI.getNumberOfTuples());
 876         self.assertEqual(0,comm.getNumberOfTuples());
 877         o2n,newNbOfNodes=targetMesh.buildNewNumberingFromCommonNodesFormat(comm,commI);
 878         self.assertEqual(27,newNbOfNodes);
 879         self.assertEqual(27,o2n.getNumberOfTuples());
 880         o2nExp1=range(27)
 881         self.assertEqual(o2nExp1,list(o2n.getValues()));
 882         #
 883         targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
 884         self.assertEqual(31,targetMesh.getNumberOfNodes());
 885         comm,commI=targetMesh.findCommonNodes(1e-10);# testing default parameter
 886         self.assertEqual(3,commI.getNumberOfTuples());
 887         self.assertEqual(6,comm.getNumberOfTuples());
 888         commExpected=[1,27,28,29,23,30]
 889         commIExpected=[0,4,6]
 890         self.assertEqual(commExpected,list(comm.getValues()));
 891         self.assertEqual(commIExpected,list(commI.getValues()));
 892         o2n,newNbOfNodes=targetMesh.buildNewNumberingFromCommonNodesFormat(comm,commI);
 893         self.assertEqual(31,o2n.getNumberOfTuples());
 894         self.assertEqual(27,newNbOfNodes);
 895         o2nExp2=[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,
 896                  21,22,23,24,25,26,1,1,1,23]
 897         self.assertEqual(o2nExp2,list(o2n.getValues()));
 898         #
 899         targetMesh=MEDCouplingDataForTest.build3DTargetMesh_1();
 900         time=targetMesh.getTimeOfThis();
 901         o2n,areNodesMerged,newNbOfNodes=targetMesh.mergeNodes(1e-10);
 902         targetMesh.updateTime();
 903         self.assertEqual(time,targetMesh.getTimeOfThis());
 904         self.assertTrue(not areNodesMerged);
 905         #
 906         targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
 907         time=targetMesh.getTimeOfThis();
 908         o2n,areNodesMerged,newNbOfNodes=targetMesh.mergeNodes(1e-10);
 909         targetMesh.updateTime();
 910         self.assertTrue(time!=targetMesh.getTimeOfThis());
 911         self.assertTrue(areNodesMerged);
 912         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,
 913                  18,4,5,8,7,13,14,17,16,
 914                  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,
 915                  18,13,14,17,16,22,23,26,25]
 916         self.assertEqual(72,targetMesh.getNodalConnectivity().getNumberOfTuples());
 917         self.assertEqual(connExp,list(targetMesh.getNodalConnectivity().getValues()));
 918         self.assertEqual(27,targetMesh.getCoords().getNumberOfTuples());
 919         coordsExp=[ 0., 0., 0., 50., 0., 0. , 200., 0., 0.  , 0., 50., 0., 50., 50., 0. ,
 920                     200., 50., 0.,   0., 200., 0., 50., 200., 0. , 200., 200., 0. ,
 921                     0., 0., 50., 50., 0., 50. , 200., 0., 50.  , 0., 50., 50., 50.,
 922                     50., 50. , 200., 50., 50.,   0., 200., 50., 50., 200., 50. ,
 923                     200., 200., 50. , 0., 0., 200., 50., 0., 200. , 200., 0., 200.
 924                     , 0., 50., 200., 50., 50., 200. , 200., 50., 200.,
 925                     0., 200., 200., 50., 200., 200. , 200., 200., 200. ]
 926         self.assertEqual(coordsExp,targetMesh.getCoords().getValues());
 927         # 2D
 928         targetMesh=MEDCouplingDataForTest.build2DTargetMeshMergeNode_1();
 929         self.assertEqual(18,targetMesh.getNumberOfNodes());
 930         time=targetMesh.getTimeOfThis();
 931         o2n,areNodesMerged,newNbOfNodes=targetMesh.mergeNodes(1e-10);
 932         self.assertTrue(time!=targetMesh.getTimeOfThis());
 933         self.assertTrue(areNodesMerged);
 934         self.assertEqual(9,targetMesh.getNumberOfNodes());
 935         connExp2=[4,0,4,3,1, 3,1,3,2, 3,3,5,2, 4,4,6,7,3, 4,7,8,5,3]
 936         self.assertEqual(23,targetMesh.getNodalConnectivity().getNumberOfTuples());
 937         self.assertEqual(connExp2,list(targetMesh.getNodalConnectivity().getValues()));
 938         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]
 939         self.assertEqual(9,targetMesh.getCoords().getNumberOfTuples());
 940         self.assertEqual(coordsExp2,targetMesh.getCoords().getValues());
 941         pass
 942
 943     def testCheckButterflyCells(self):
 944         sourceMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
 945         cells=sourceMesh.checkButterflyCells();
 946         self.assertEqual(0,len(cells));
 947         conn=sourceMesh.getNodalConnectivity()
 948         tmp=conn.getIJ(15,0)
 949         conn.setIJ(15,0,conn.getIJ(16,0))
 950         conn.setIJ(16,0,tmp)
 951         cells=sourceMesh.checkButterflyCells();
 952         self.assertEqual(1,len(cells));
 953         self.assertEqual([3],cells.getValues());
 954         tmp=conn.getIJ(15,0)
 955         conn.setIJ(15,0,conn.getIJ(16,0))
 956         conn.setIJ(16,0,tmp)
 957         cells=sourceMesh.checkButterflyCells();
 958         self.assertEqual(0,len(cells));
 959         # 3D surf
 960         sourceMesh=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
 961         cells=sourceMesh.checkButterflyCells();
 962         self.assertEqual(0,len(cells));
 963         conn=sourceMesh.getNodalConnectivity()
 964         tmp=conn.getIJ(15,0)
 965         conn.setIJ(15,0,conn.getIJ(16,0))
 966         conn.setIJ(16,0,tmp)
 967         cells=sourceMesh.checkButterflyCells();
 968         self.assertEqual(1,len(cells));
 969         self.assertEqual([3],cells.getValues());
 970         tmp=conn.getIJ(15,0)
 971         conn.setIJ(15,0,conn.getIJ(16,0))
 972         conn.setIJ(16,0,tmp)
 973         cells=sourceMesh.checkButterflyCells();
 974         self.assertEqual(0,len(cells));
 975         pass
 976
 977     def testMergeMesh1(self):
 978         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
 979         m2=MEDCouplingDataForTest.build2DSourceMesh_1();
 980         vec=[1.,0.]
 981         m2.translate(vec);
 982         m3=m1.mergeMyselfWith(m2);
 983         self.assertTrue(isinstance(m3,MEDCouplingUMesh));
 984         m3.checkCoherency();
 985         m4=MEDCouplingDataForTest.build2DTargetMeshMerged_1();
 986         self.assertTrue(m3.isEqual(m4,1.e-12));
 987         da,isMerged,newNbOfNodes=m3.mergeNodes(1.e-12);
 988         self.assertEqual(11,m3.getNumberOfNodes());
 989         self.assertTrue(isMerged);
 990         pass
 991
 992     def testMergeMeshOnSameCoords1(self):
 993         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
 994         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
 995         cells=range(5);
 996         m2.convertToPolyTypes(cells);
 997         m1.tryToShareSameCoords(m2,1e-12);
 998         m3=MEDCouplingDataForTest.build2DTargetMesh_1();
 999         m3.tryToShareSameCoords(m2,1e-12);
1000         meshes=[m1,m2,m3]
1001         m4=MEDCouplingUMesh.MergeUMeshesOnSameCoords(meshes);
1002         m4.checkCoherency();
1003         self.assertEqual(15,m4.getNumberOfCells());
1004         cells1=[0,1,2,3,4]
1005         m1_1=m4.buildPartOfMySelf(cells1,True);
1006         m1_1.setName(m1.getName());
1007         self.assertTrue(m1.isEqual(m1_1,1e-12));
1008         cells2=[5,6,7,8,9]
1009         m2_1=m4.buildPartOfMySelf(cells2,True);
1010         m2_1.setName(m2.getName());
1011         self.assertTrue(m2.isEqual(m2_1,1e-12));
1012         cells3=[10,11,12,13,14]
1013         m3_1=m4.buildPartOfMySelf(cells3,True);
1014         m3_1.setName(m3.getName());
1015         self.assertTrue(m3.isEqual(m3_1,1e-12));
1016         pass
1017
1018     def testMergeField1(self):
1019         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
1020         m2=MEDCouplingDataForTest.build2DSourceMesh_1();
1021         vec=[1.,0.]
1022         m2.translate(vec);
1023         f1=m1.getMeasureField(True);
1024         f2=m2.getMeasureField(True);
1025         f3=MEDCouplingFieldDouble.MergeFields(f1,f2);
1026         f3.checkCoherency();
1027         m4=MEDCouplingDataForTest.build2DTargetMeshMerged_1();
1028         self.assertTrue(f3.getMesh().isEqual(m4,1.e-12));
1029         name=f3.getName();
1030         self.assertEqual(name,"MeasureOfMesh_");
1031         self.assertEqual(f3.getTypeOfField(),ON_CELLS);
1032         self.assertEqual(f3.getTimeDiscretization(),ONE_TIME);
1033         self.assertEqual(1,f3.getNumberOfComponents());
1034         self.assertEqual(7,f3.getNumberOfTuples());
1035         values=[0.25,0.125,0.125,0.25,0.25,0.5,0.5]
1036         tmp=f3.getArray().getValues();
1037         self.assertEqual(len(values),len(tmp))
1038         for i in xrange(7):
1039             self.assertTrue(abs(values[i]-tmp[i])<1e-12)
1040             pass
1041         pass
1042
1043     def testFillFromAnalytic(self):
1044         m=MEDCouplingDataForTest.build2DTargetMesh_1();
1045         m.setTime(3.4,5,6); m.setTimeUnit("us");
1046         f1=m.fillFromAnalytic(ON_CELLS,1,"x+y");
1047         self.assertAlmostEqual(3.4,f1.getTime()[0],12) ; self.assertEqual(5,f1.getTime()[1]) ; self.assertEqual(6,f1.getTime()[2])
1048         self.assertEqual("us",f1.getTimeUnit())
1049         f1.checkCoherency();
1050         self.assertEqual(f1.getTypeOfField(),ON_CELLS);
1051         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1052         self.assertEqual(1,f1.getNumberOfComponents());
1053         self.assertEqual(5,f1.getNumberOfTuples());
1054         values1=[-0.1,0.23333333333333336,0.56666666666666665,0.4,0.9]
1055         tmp=f1.getArray().getValues();
1056         self.assertEqual(len(values1),len(tmp))
1057         for i in xrange(len(tmp)):
1058             self.assertTrue(abs(tmp[i]-values1[i])<1.e-12)
1059             pass
1060         #
1061         f1=m.fillFromAnalytic(ON_NODES,1,"x+y");
1062         f1.checkCoherency();
1063         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1064         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1065         self.assertEqual(1,f1.getNumberOfComponents());
1066         self.assertEqual(9,f1.getNumberOfTuples());
1067         values2=[-0.6,-0.1,0.4,-0.1,0.4,0.9,0.4,0.9,1.4]
1068         tmp=f1.getArray().getValues();
1069         self.assertEqual(len(values2),len(tmp))
1070         for i in xrange(len(tmp)):
1071             self.assertTrue(abs(tmp[i]-values2[i])<1.e-12)
1072             pass
1073         #
1074         f1=m.fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+(2*(x+y))*JVec");
1075         f1.checkCoherency();
1076         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1077         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1078         self.assertEqual(2,f1.getNumberOfComponents());
1079         self.assertEqual(9,f1.getNumberOfTuples());
1080         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]
1081         tmp=f1.getArray().getValues();
1082         self.assertEqual(len(values3),len(tmp))
1083         for i in xrange(len(tmp)):
1084             self.assertTrue(abs(tmp[i]-values3[i])<1.e-12)
1085             pass
1086         values4=f1.accumulate();
1087         self.assertEqual(2,len(values4))
1088         self.assertTrue(abs(3.6-values4[0])<1.e-12);
1089         self.assertTrue(abs(7.2-values4[1])<1.e-12);
1090         values4=f1.integral(True);
1091         self.assertEqual(2,len(values4))
1092         self.assertTrue(abs(0.5-values4[0])<1.e-12);
1093         self.assertTrue(abs(1.-values4[1])<1.e-12);
1094         #
1095         self.assertRaises(InterpKernelException,m.fillFromAnalytic,ON_NODES,1,"1./(x-0.2)");
1096         pass
1097
1098     def testFillFromAnalytic2(self):
1099         m=MEDCouplingDataForTest.build2DTargetMesh_1();
1100         f1=m.fillFromAnalytic(ON_CELLS,1,"y+x");
1101         f1.checkCoherency();
1102         self.assertEqual(f1.getTypeOfField(),ON_CELLS);
1103         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1104         self.assertEqual(1,f1.getNumberOfComponents());
1105         self.assertEqual(5,f1.getNumberOfTuples());
1106         values1=[-0.1,0.23333333333333336,0.56666666666666665,0.4,0.9]
1107         tmp=f1.getArray().getValues();
1108         self.assertEqual(len(values1),len(tmp))
1109         for i in xrange(len(values1)):
1110             self.assertTrue(abs(values1[i]-tmp[i])<1.e-12);
1111             pass
1112         #
1113         f1=m.fillFromAnalytic(ON_NODES,1,"y+2*x");
1114         f1.checkCoherency();
1115         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1116         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1117         self.assertEqual(1,f1.getNumberOfComponents());
1118         self.assertEqual(9,f1.getNumberOfTuples());
1119         values2=[-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1]
1120         tmp=f1.getArray().getValues();
1121         self.assertEqual(len(values2),len(tmp))
1122         for i in xrange(len(values2)):
1123             self.assertTrue(abs(values2[i]-tmp[i])<1.e-12);
1124             pass
1125         f1=m.fillFromAnalytic(ON_NODES,1,"2.*x+y");
1126         f1.checkCoherency();
1127         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1128         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1129         self.assertEqual(1,f1.getNumberOfComponents());
1130         self.assertEqual(9,f1.getNumberOfTuples());
1131         tmp=f1.getArray().getValues();
1132         values2Bis=[-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1]
1133         self.assertEqual(len(values2Bis),len(tmp))
1134         for i in xrange(len(values2Bis)):
1135             self.assertTrue(abs(values2Bis[i]-tmp[i])<1.e-12);
1136             pass
1137         #
1138         f1=m.fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+2*(x+y)*JVec");
1139         f1.checkCoherency();
1140         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1141         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1142         self.assertEqual(2,f1.getNumberOfComponents());
1143         self.assertEqual(9,f1.getNumberOfTuples());
1144         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]
1145         tmp=f1.getArray().getValues();
1146         self.assertEqual(len(values3),len(tmp))
1147         for i in xrange(len(values3)):
1148             self.assertTrue(abs(values3[i]-tmp[i])<1.e-12);
1149             pass
1150         values4=f1.accumulate();
1151         self.assertTrue(abs(3.6-values4[0])<1.e-12);
1152         self.assertTrue(abs(7.2-values4[1])<1.e-12);
1153         values4=f1.integral(True);
1154         self.assertTrue(abs(0.5-values4[0])<1.e-12);
1155         self.assertTrue(abs(1.-values4[1])<1.e-12);
1156         pass
1157
1158     def testApplyFunc(self):
1159         m=MEDCouplingDataForTest.build2DTargetMesh_1();
1160         f1=m.fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+(2*(x+y))*JVec");
1161         f1.checkCoherency();
1162         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1163         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1164         self.assertEqual(2,f1.getNumberOfComponents());
1165         self.assertEqual(9,f1.getNumberOfTuples());
1166         f1.applyFunc(1,"x+y");
1167         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1168         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1169         self.assertEqual(1,f1.getNumberOfComponents());
1170         self.assertEqual(9,f1.getNumberOfTuples());
1171         values1=[-1.8,-0.3,1.2,-0.3,1.2,2.7,1.2,2.7,4.2]
1172         tmp=f1.getArray().getValues();
1173         self.assertEqual(len(values1),len(tmp))
1174         for i in xrange(len(tmp)):
1175             self.assertTrue(abs(tmp[i]-values1[i])<1.e-12)
1176             pass
1177         pass
1178
1179     def testApplyFunc2(self):
1180         m=MEDCouplingDataForTest.build2DTargetMesh_1();
1181         f1=m.fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+2*(x+y)*JVec");
1182         f1.checkCoherency();
1183         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1184         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1185         self.assertEqual(2,f1.getNumberOfComponents());
1186         self.assertEqual(9,f1.getNumberOfTuples());
1187         #
1188         f2=f1.clone(True);
1189         self.assertRaises(InterpKernelException, f2.applyFunc, 1, "a+b+c+d");
1190         self.assertRaises(InterpKernelException, f2.applyFunc, 1, "a/0");
1191         self.assertRaises(InterpKernelException, f2.applyFunc, "a/0");
1192         f2.applyFunc("abs(u)^2.4+2*u");
1193         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1194         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1195         self.assertEqual(2,f1.getNumberOfComponents());
1196         self.assertEqual(9,f1.getNumberOfTuples());
1197         values2=[-0.9065304805418678, -0.85105859001709905, -0.19601892829446504, -0.37898777756476987,
1198                  0.91090317490482353, 2.1853504664669781, -0.19601892829446504, -0.37898777756476987,
1199                  0.91090317490482353, 2.1853504664669781, 2.5765725275664879, 7.6987743736515295,
1200                  0.91090317490482353, 2.1853504664669781, 2.5765725275664879, 7.6987743736515295,
1201                  5.0423700574830965, 17.435300118916864]
1202         tmp=f2.getArray().getValues();
1203         self.assertEqual(len(tmp),len(values2))
1204         for i in xrange(len(tmp)):
1205             self.assertTrue(abs(tmp[i]-values2[i])<1.e-12)
1206             pass
1207         #
1208         f1.applyFunc(1,"x+y");
1209         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1210         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1211         self.assertEqual(1,f1.getNumberOfComponents());
1212         self.assertEqual(9,f1.getNumberOfTuples());
1213         values1=[-1.8,-0.3,1.2,-0.3,1.2,2.7,1.2,2.7,4.2]
1214         tmp=f1.getArray().getValues();
1215         self.assertEqual(len(tmp),len(values1))
1216         for i in xrange(len(tmp)):
1217             self.assertTrue(abs(tmp[i]-values1[i])<1.e-12)
1218             pass
1219         pass
1220
1221     def testOperationsOnFields(self):
1222         m=MEDCouplingDataForTest.build2DTargetMesh_1();
1223         f1=m.fillFromAnalytic(ON_NODES,1,"x+y");
1224         f2=m.fillFromAnalytic(ON_NODES,1,"x+y");
1225         f1.checkCoherency();
1226         f2.checkCoherency();
1227         f3=f1+f2;
1228         f3.checkCoherency();
1229         self.assertEqual(f3.getTypeOfField(),ON_NODES);
1230         self.assertEqual(f3.getTimeDiscretization(),ONE_TIME);
1231         values1=[-1.2,-0.2,0.8,-0.2,0.8,1.8,0.8,1.8,2.8]
1232         tmp=f3.getArray().getValues();
1233         self.assertEqual(len(values1),len(tmp))
1234         for i in xrange(len(tmp)):
1235             self.assertTrue(abs(tmp[i]-values1[i])<1.e-12)
1236             pass
1237         #
1238         f3=f1*f2;
1239         f3.checkCoherency();
1240         self.assertEqual(f3.getTypeOfField(),ON_NODES);
1241         self.assertEqual(f3.getTimeDiscretization(),ONE_TIME);
1242         values2=[0.36,0.01,0.16,0.01,0.16,0.81,0.16,0.81,1.96]
1243         tmp=f3.getArray().getValues();
1244         self.assertEqual(len(values2),len(tmp))
1245         for i in xrange(len(tmp)):
1246             self.assertTrue(abs(tmp[i]-values2[i])<1.e-12)
1247             pass
1248         #
1249         f3=f1+f2;
1250         f4=f1-f3;
1251         f4.checkCoherency();
1252         self.assertEqual(f4.getTypeOfField(),ON_NODES);
1253         self.assertEqual(f4.getTimeDiscretization(),ONE_TIME);
1254         values3=[0.6,0.1,-0.4,0.1,-0.4,-0.9,-0.4,-0.9,-1.4]
1255         tmp=f4.getArray().getValues();
1256         self.assertEqual(len(values3),len(tmp))
1257         for i in xrange(len(tmp)):
1258             self.assertTrue(abs(tmp[i]-values3[i])<1.e-12)
1259             pass
1260         #
1261         f3=f1+f2;
1262         f4=f3/f2;
1263         f4.checkCoherency();
1264         self.assertEqual(f4.getTypeOfField(),ON_NODES);
1265         self.assertEqual(f4.getTimeDiscretization(),ONE_TIME);
1266         tmp=f4.getArray().getValues();
1267         for i in xrange(len(tmp)):
1268             self.assertTrue(abs(tmp[i]-2.)<1.e-12)
1269             pass
1270         #
1271         f4=f2.buildNewTimeReprFromThis(NO_TIME,False);
1272         f4.checkCoherency();
1273         self.assertEqual(f4.getTypeOfField(),ON_NODES);
1274         self.assertEqual(f4.getTimeDiscretization(),NO_TIME);
1275         self.assertRaises(InterpKernelException,f1.__add__,f4);
1276         f5=f4.buildNewTimeReprFromThis(ONE_TIME,False);
1277         self.assertEqual(f5.getTypeOfField(),ON_NODES);
1278         self.assertEqual(f5.getTimeDiscretization(),ONE_TIME);
1279         f3=f1+f5;
1280         tmp=f3.getArray().getValues();
1281         values4=[-1.2,-0.2,0.8,-0.2,0.8,1.8,0.8,1.8,2.8]
1282         self.assertEqual(len(values3),len(tmp))
1283         for i in xrange(len(tmp)):
1284             self.assertTrue(abs(tmp[i]-values4[i])<1.e-12)
1285             pass
1286         #
1287         f4=f2.buildNewTimeReprFromThis(NO_TIME,True);
1288         f4.checkCoherency();
1289         self.assertEqual(f4.getTypeOfField(),ON_NODES);
1290         self.assertEqual(f4.getTimeDiscretization(),NO_TIME);
1291         self.assertRaises(InterpKernelException,f1.__add__,f4);
1292         f5=f4.buildNewTimeReprFromThis(ONE_TIME,True);
1293         self.assertEqual(f5.getTypeOfField(),ON_NODES);
1294         self.assertEqual(f5.getTimeDiscretization(),ONE_TIME);
1295         f3=f1+f5;
1296         tmp=f3.getArray().getValues();
1297         values5=[-1.2,-0.2,0.8,-0.2,0.8,1.8,0.8,1.8,2.8]
1298         self.assertEqual(len(values5),len(tmp))
1299         for i in xrange(len(tmp)):
1300             self.assertTrue(abs(tmp[i]-values5[i])<1.e-12)
1301             pass
1302         pass
1303
1304     def testOperationsOnFields2(self):
1305         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1306         m.setTime(3.4,5,6); m.setTimeUnit("us");
1307         f1=m.fillFromAnalytic(ON_NODES,1,"x+y+z");
1308         f2=m.fillFromAnalytic(ON_NODES,1,"a*a+b+c*c");
1309         f3=f1/f2;
1310         f3.checkCoherency();
1311         self.assertEqual(f3.getTypeOfField(),ON_NODES);
1312         self.assertEqual(f3.getTimeDiscretization(),ONE_TIME);
1313         expected1=[-2.4999999999999991, 1.2162162162162162, 0.77868852459016391,
1314                    0.7407407407407407, 1.129032258064516, 0.81632653061224492,
1315                    0.86538461538461531, 1.0919540229885056, 0.84302325581395343]
1316         self.assertEqual(1,f3.getNumberOfComponents());
1317         self.assertEqual(9,f3.getNumberOfTuples());
1318         val=f3.getArray().getValues();
1319         for i in xrange(9):
1320             self.assertTrue(abs(expected1[i]-val[i])<1.e-12);
1321         #
1322         f1=m.buildOrthogonalField();
1323         self.assertAlmostEqual(3.4,f1.getTime()[0],12) ; self.assertEqual(5,f1.getTime()[1]) ; self.assertEqual(6,f1.getTime()[2])
1324         self.assertEqual("us",f1.getTimeUnit())
1325         f2=m.fillFromAnalytic(ON_CELLS,1,"x");
1326         f3=f1*f2;
1327         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]
1328         val=f3.getArray().getValues();
1329         for i in xrange(15):
1330             self.assertTrue(abs(expected2[i]-val[i])<1.e-12);
1331             pass
1332         #
1333         f3=f2*f1;
1334         val=f3.getArray().getValues();
1335         for i in xrange(15):
1336             self.assertTrue(abs(expected2[i]-val[i])<1.e-12);
1337             pass
1338         pass
1339
1340     def testOperationsOnFields3(self):
1341         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1342         f1=m.fillFromAnalytic(ON_NODES,1,"x+y+z");
1343         f2=m.fillFromAnalytic(ON_NODES,1,"a*a+b+c*c");
1344         f1/=f2
1345         f1.checkCoherency();
1346         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1347         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1348         expected1=[-2.4999999999999991, 1.2162162162162162, 0.77868852459016391,
1349                    0.7407407407407407, 1.129032258064516, 0.81632653061224492,
1350                    0.86538461538461531, 1.0919540229885056, 0.84302325581395343]
1351         self.assertEqual(1,f1.getNumberOfComponents());
1352         self.assertEqual(9,f1.getNumberOfTuples());
1353         val=f1.getArray().getValues();
1354         for i in xrange(9):
1355             self.assertTrue(abs(expected1[i]-val[i])<1.e-12);
1356             pass
1357         #
1358         f1=m.buildOrthogonalField();
1359         f2=m.fillFromAnalytic(ON_CELLS,1,"x");
1360         f1*=f2
1361         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]
1362         val=f1.getArray().getValues();
1363         for i in xrange(15):
1364             self.assertTrue(abs(expected2[i]-val[i])<1.e-12);
1365             pass
1366         #
1367         f1=m.buildOrthogonalField();
1368         # to avoid valgrind leaks
1369         # self.assertRaises(InterpKernelException,f2.__imul__,f1);
1370         pass
1371
1372     def testOperationsOnFields4(self):
1373         m=MEDCouplingDataForTest.build2DTargetMesh_1();
1374         nbOfCells=m.getNumberOfCells();
1375         f1=MEDCouplingFieldDouble.New(ON_CELLS,CONST_ON_TIME_INTERVAL);
1376         f1.setMesh(m);
1377         array=DataArrayDouble.New();
1378         f1.setArray(array);
1379         self.assertRaises(InterpKernelException,f1.setEndArray,array);
1380         self.assertRaises(InterpKernelException,f1.getEndArray);
1381         arr1=[0.,10.,20.,1.,11.,21.,2.,12.,22.,3.,13.,23.,4.,14.,24.]
1382         arr2=[5.,15.,25.,6.,16.,26.,7.,17.,27.,8.,18.,28.,9.,19.,29.]
1383         array.setValues(arr1,nbOfCells,3);
1384         f1.setStartTime(2.,0,0);
1385         f1.setEndTime(3.,0,0);
1386         f1.checkCoherency();
1387         pos=[0.3,-0.2]
1388         res=f1.getValueOn(pos);
1389         self.assertTrue(abs(arr1[3]-res[0])<1.e-12);
1390         self.assertTrue(abs(arr1[4]-res[1])<1.e-12);
1391         self.assertTrue(abs(arr1[5]-res[2])<1.e-12);
1392         res=None
1393         res=f1.getValueOn(pos,2.2);
1394         self.assertTrue(abs(arr1[3]-res[0])<1.e-12);
1395         self.assertTrue(abs(arr1[4]-res[1])<1.e-12);
1396         self.assertTrue(abs(arr1[5]-res[2])<1.e-12);
1397         res=None
1398         self.assertRaises(InterpKernelException,f1.getValueOn,pos,3.2)
1399         f2=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
1400         f2.setMesh(m);
1401         f2.setArray(f1.getArray());
1402         f2.setStartTime(2.,3,0);
1403         f2.setEndTime(4.,13,0);
1404         self.assertRaises(InterpKernelException,f2.checkCoherency)
1405         array2=DataArrayDouble.New();
1406         array2.setValues(arr2,nbOfCells,3);
1407         f2.setEndArray(array2);
1408         f2.checkCoherency();
1409         #
1410         res=None
1411         res=f2.getValueOn(pos,3.21);
1412         self.assertTrue(abs(4.025-res[0])<1.e-12);
1413         self.assertTrue(abs(14.025-res[1])<1.e-12);
1414         self.assertTrue(abs(24.025-res[2])<1.e-12);
1415         f3=f2.clone(True);
1416         self.assertTrue(f2.isEqual(f3,1e-12,1e-12));
1417         f3.getEndArray().setIJ(0,0,5.001);
1418         self.assertTrue(not f2.isEqual(f3,1e-12,1e-12));
1419         self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1420         f3.setStartTime(2.1,3,0);
1421         self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1422         f3.setStartTime(2.,3,0);
1423         self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1424         f3.setStartTime(2.,4,0);
1425         self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1426         f3.setStartTime(2.,3,1);
1427         self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1428         f3.setStartTime(2.,3,0);
1429         self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1430         f3.setEndTime(4.1,13,0);
1431         self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1432         f3.setEndTime(4.,13,0);
1433         self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1434         f3.setEndTime(4.,14,0);
1435         self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1436         f3.setEndTime(4.,13,1);
1437         self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1438         f3.setEndTime(4.,13,0);
1439         self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1440         f4=f2+f2
1441         res=None
1442         res=f4.getValueOn(pos,3.21);
1443         self.assertTrue(abs(8.05-res[0])<1.e-12);
1444         self.assertTrue(abs(28.05-res[1])<1.e-12);
1445         self.assertTrue(abs(48.05-res[2])<1.e-12);
1446         f4+=f2;
1447         res=None
1448         res=f4.getValueOn(pos,3.21);
1449         self.assertTrue(abs(12.075-res[0])<1.e-12);
1450         self.assertTrue(abs(42.075-res[1])<1.e-12);
1451         self.assertTrue(abs(72.075-res[2])<1.e-12);
1452         pass
1453
1454     def testMergeNodesOnField(self):
1455         targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
1456         f1=targetMesh.fillFromAnalytic(ON_NODES,1,"x+y+z");
1457         f1.mergeNodes(1e-10);
1458         #
1459         targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
1460         f1=targetMesh.fillFromAnalytic(ON_NODES,1,"x+y+z");
1461         tmp=f1.getArray()
1462         tmp.setIJ(0,0,1000.);
1463         f1.mergeNodes(1e-10);
1464         #
1465         targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
1466         f1=targetMesh.fillFromAnalytic(ON_NODES,1,"x+y+z");
1467         tmp=f1.getArray()
1468         tmp.setIJ(1,0,1000.);
1469         self.assertRaises(InterpKernelException,f1.mergeNodes,1.e-10)
1470         pass
1471
1472     def testCheckConsecutiveCellTypes(self):
1473         sourceMesh=MEDCouplingDataForTest.build2DSourceMesh_1();
1474         targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1475         self.assertTrue(sourceMesh.checkConsecutiveCellTypes());
1476         order1=[NORM_TRI3,NORM_QUAD4]
1477         order2=[NORM_QUAD4,NORM_TRI3]
1478         self.assertTrue(not targetMesh.checkConsecutiveCellTypes());
1479         self.assertTrue(not targetMesh.checkConsecutiveCellTypesAndOrder(order1));
1480         self.assertTrue(not targetMesh.checkConsecutiveCellTypesAndOrder(order2));
1481         da=targetMesh.getRenumArrForConsecutiveCellTypesSpec(order1);
1482         self.assertEqual(5,da.getNumberOfTuples());
1483         self.assertEqual(1,da.getNumberOfComponents());
1484         expected1=[2,0,1,3,4]
1485         self.assertTrue(expected1==list(da.getValues()));
1486         da=targetMesh.getRenumArrForConsecutiveCellTypesSpec(order2);
1487         self.assertEqual(5,da.getNumberOfTuples());
1488         self.assertEqual(1,da.getNumberOfComponents());
1489         expected2=[0,3,4,1,2]
1490         self.assertTrue(expected2==list(da.getValues()));
1491         renumber1=[4,0,1,2,3]
1492         targetMesh.renumberCells(renumber1,False);
1493         self.assertTrue(targetMesh.checkConsecutiveCellTypes());
1494         self.assertTrue(targetMesh.checkConsecutiveCellTypesAndOrder(order1));
1495         self.assertTrue(not targetMesh.checkConsecutiveCellTypesAndOrder(order2));
1496         pass
1497
1498     def testRearrange2ConsecutiveCellTypes(self):
1499         m1_1=MEDCouplingDataForTest.build2DSourceMesh_1();
1500         m2_1=MEDCouplingDataForTest.build2DTargetMesh_1();
1501         arr1=m1_1.rearrange2ConsecutiveCellTypes();
1502         m1_2=MEDCouplingDataForTest.build2DSourceMesh_1();
1503         self.assertTrue(m1_2.isEqual(m1_1,1e-12));
1504         expected1=[0,1]
1505         self.assertEqual(2,arr1.getNumberOfTuples());
1506         self.assertEqual(1,arr1.getNumberOfComponents());
1507         self.assertEqual(expected1,arr1.getValues());
1508         expected2=[0,3,4,1,2]
1509         arr1=m2_1.rearrange2ConsecutiveCellTypes();
1510         self.assertEqual(5,arr1.getNumberOfTuples());
1511         self.assertEqual(1,arr1.getNumberOfComponents());
1512         self.assertEqual(expected2,list(arr1.getValues()));
1513         m2_2=MEDCouplingDataForTest.build2DTargetMesh_1();
1514         self.assertEqual(5,arr1.getNumberOfTuples());
1515         self.assertEqual(1,arr1.getNumberOfComponents());
1516         self.assertEqual(expected2,list(arr1.getValues()));
1517         self.assertTrue(not m2_2.isEqual(m2_1,1e-12));
1518         m2_2.renumberCells(expected2,False);
1519         self.assertTrue(m2_2.isEqual(m2_1,1e-12));
1520         pass
1521
1522     def testSplitByType(self):
1523         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1524         v=m1.splitByType();
1525         self.assertEqual(3,len(v));
1526         m2=MEDCouplingUMesh.MergeUMeshesOnSameCoords(v);
1527         m2.setName(m1.getName());
1528         self.assertTrue(m1.isEqual(m2,1.e-12));
1529         pass
1530
1531     def testFuseUMeshesOnSameCoords(self):
1532         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
1533         cells1=[2,3,4]
1534         m3=m2.buildPartOfMySelf(cells1,True);
1535         self.assertTrue(isinstance(m3,MEDCouplingUMesh))
1536         cells2=[1,2,4]
1537         m4=m2.buildPartOfMySelf(cells2,True);
1538         self.assertTrue(isinstance(m4,MEDCouplingUMesh))
1539         cells3=[1,2]
1540         m5=m2.buildPartOfMySelf(cells3,True);
1541         self.assertTrue(isinstance(m5,MEDCouplingUMesh))
1542         meshes=[m3,m4,m5]
1543         #
1544         m7,corr=MEDCouplingUMesh.FuseUMeshesOnSameCoords(meshes,0);
1545         self.assertEqual(4,m7.getNumberOfCells());
1546         self.assertEqual(3,len(corr));
1547         expectedVals1=[3,3,2]
1548         expectedVals2=[[0,1,2],[3,0,2],[3,0]]
1549         for i in xrange(3):
1550             arr=corr[i];
1551             self.assertEqual(1,arr.getNumberOfComponents());
1552             nbOfVals=expectedVals1[i];
1553             self.assertEqual(nbOfVals,arr.getNumberOfTuples());
1554             vals=arr.getValues();
1555             self.assertEqual(expectedVals2[i],list(vals));
1556             pass
1557         arr2,fidsOfGroups=DataArrayInt.MakePartition(corr,m7.getNumberOfCells());
1558         fidExp=[5,1,3,4]
1559         fidsGrp=[[1,3,5],[3,4,5],[4,5]]
1560         self.assertEqual(3,len(fidsOfGroups));
1561         self.assertEqual(1,arr2.getNumberOfComponents());
1562         self.assertEqual(4,arr2.getNumberOfTuples());
1563         self.assertEqual(fidExp,list(arr2.getValues()));
1564         for i in xrange(3):
1565             nbOfVals=expectedVals1[i];
1566             self.assertEqual(list(fidsOfGroups[i]),fidsGrp[i]);
1567             pass
1568         pass
1569
1570     def testFuseUMeshesOnSameCoords2(self):
1571         m1,m2=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
1572         part1=[2,3,6,4,10]
1573         m3=m1.buildPartOfMySelf(part1,True);
1574         part2=[5,6,4,7]
1575         m4=m1.buildPartOfMySelf(part2,True);
1576         meshes=[m1,m3,m3,m4]
1577         m5,corr=MEDCouplingUMesh.FuseUMeshesOnSameCoords(meshes,0);
1578         self.assertEqual(18,m5.getNumberOfCells());
1579         exp2=[
1580             [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17],
1581             [2,3,6,4,10],
1582             [2,3,6,4,10],
1583             [5,6,4,7]]
1584         i=0;
1585         for it in corr:
1586             self.assertEqual(exp2[i],list(it.getValues()));
1587             i+=1
1588             pass
1589         pass
1590
1591     def testBuildOrthogonalField(self):
1592         targetMesh=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1593         field=targetMesh.buildOrthogonalField();
1594         expected=[0.70710678118654746,0.,-0.70710678118654746]
1595         self.assertEqual(5,field.getNumberOfTuples());
1596         self.assertEqual(3,field.getNumberOfComponents());
1597         vals=field.getArray().getValues();
1598         for i in xrange(15):
1599             self.assertTrue(abs(expected[i%3]-vals[i])<1e-12);
1600         # testing
1601         targetCoords=[0.,0.,0.,0.5,0.,0.5,1.,0.,1.,0.,1.,0.]
1602         targetConn=[0,1,2,3]
1603         targetMesh=MEDCouplingUMesh.New();
1604         targetMesh.setMeshDimension(2);
1605         targetMesh.allocateCells(1);
1606         targetMesh.insertNextCell(NORM_QUAD4,targetConn[0:4])
1607         targetMesh.finishInsertingCells();
1608         myCoords=DataArrayDouble.New();
1609         myCoords.setValues(targetCoords,4,3);
1610         targetMesh.setCoords(myCoords);
1611         field=targetMesh.buildOrthogonalField();
1612         self.assertEqual(1,field.getNumberOfTuples());
1613         self.assertEqual(3,field.getNumberOfComponents());
1614         vals=field.getArray().getValues();
1615         self.assertTrue(abs(-0.70710678118654746-vals[0])<1e-12);
1616         self.assertTrue(abs(0.-vals[1])<1e-12);
1617         self.assertTrue(abs(0.70710678118654746-vals[2])<1e-12);
1618         pass
1619
1620     def testGetCellsContainingPoint(self):
1621         targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1622         pos=[0.,0.,0.4,0.4,0.,0.4,0.1,0.1,0.25,0.,0.65,0.]
1623         #2D basic
1624         t1,t2=targetMesh.getCellsContainingPoints(pos,6,1e-12);
1625         self.assertEqual(6,t1.getNumberOfTuples());
1626         self.assertEqual(1,t1.getNumberOfComponents());
1627         self.assertEqual(7,t2.getNumberOfTuples());
1628         self.assertEqual(1,t2.getNumberOfComponents());
1629         expectedValues1=[0,4,3,0,1,2]
1630         expectedValues2=[0,1,2,3,4,5,6]
1631         self.assertEqual(list(t1.getValues()),expectedValues1);
1632         self.assertEqual(list(t2.getValues()),expectedValues2);
1633         #2D with no help of bounding box.
1634         center=[0.2,0.2]
1635         MEDCouplingPointSet.Rotate2DAlg(center,0.78539816339744830962,6,pos);
1636         targetMesh.rotate(center,0.78539816339744830962);
1637         t1=None
1638         t2=None
1639         t1,t2=targetMesh.getCellsContainingPoints(pos,1e-12);
1640         self.assertEqual(6,t1.getNumberOfTuples());
1641         self.assertEqual(7,t2.getNumberOfTuples());
1642         self.assertEqual(list(t1.getValues()),expectedValues1);
1643         self.assertEqual(list(t2.getValues()),expectedValues2);
1644         t1,t2=targetMesh.getCellsContainingPoints(DataArrayDouble.New(pos,6,2),1e-12);
1645         self.assertEqual(6,t1.getNumberOfTuples());
1646         self.assertEqual(7,t2.getNumberOfTuples());
1647         self.assertEqual(list(t1.getValues()),expectedValues1);
1648         self.assertEqual(list(t2.getValues()),expectedValues2);
1649         self.assertRaises(InterpKernelException,targetMesh.getCellsContainingPoints,DataArrayDouble.New(pos,4,3),1e-12);
1650         #2D outside
1651         pos1bis=[-0.3303300858899107,-0.11819805153394641]
1652         self.assertEqual(-1,targetMesh.getCellContainingPoint(pos1bis,1e-12));
1653         #test limits 2D
1654         targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1655         pos2=[0.2,-0.05]
1656         t1=None
1657         t1=targetMesh.getCellsContainingPoint(pos2,1e-12)
1658         self.assertEqual(2,len(t1));
1659         expectedValues3=[0,1]
1660         self.assertEqual(list(t1.getValues()),expectedValues3);
1661         pos3=[0.2,0.2]
1662         t1=None
1663         t1=targetMesh.getCellsContainingPoint(pos3,1e-12);
1664         self.assertEqual(5,len(t1));
1665         expectedValues4=[0,1,2,3,4]
1666         self.assertEqual(list(t1.getValues()),expectedValues4);
1667         self.assertEqual(0,targetMesh.getCellContainingPoint(pos3,1e-12));
1668         #3D
1669         targetMesh=MEDCouplingDataForTest.build3DTargetMesh_1();
1670         pos4=[25.,25.,25.]
1671         self.assertEqual(0,targetMesh.getCellContainingPoint(pos4,1e-12));
1672         pos5=[50.,50.,50.]
1673         t1=None
1674         t1=targetMesh.getCellsContainingPoint(pos5,1e-12);
1675         self.assertEqual(8,len(t1));
1676         expectedValues5=[0,1,2,3,4,5,6,7]
1677         self.assertEqual(list(t1.getValues()),expectedValues5);
1678         pos6=[0., 50., 0.]
1679         t1=None
1680         t1=targetMesh.getCellsContainingPoint(pos6,1e-12);
1681         self.assertEqual(2,len(t1));
1682         expectedValues6=[0,2]
1683         self.assertEqual(list(t1.getValues()),expectedValues6);
1684         #3D outside
1685         pos7=[-1.0,-1.0,0.]
1686         self.assertEqual(-1,targetMesh.getCellContainingPoint(pos7,1e-12));
1687         #3D outside 2
1688         center2=[0.,0.,0.]
1689         vec2=[0.,-1.,0.]
1690         targetMesh.rotate(center2,vec2,0.78539816339744830962);
1691         pos8=[-25.,25.,12.]
1692         self.assertEqual(-1,targetMesh.getCellContainingPoint(pos8,1e-12));
1693         pass
1694
1695     def testGetValueOn1(self):
1696         targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1697         fieldOnCells=MEDCouplingFieldDouble.New(ON_CELLS);
1698         nbOfCells=targetMesh.getNumberOfCells();
1699         fieldOnCells.setMesh(targetMesh);
1700         array=DataArrayDouble.New();
1701         tmp=2*nbOfCells*[None]
1702         for i in xrange(nbOfCells):
1703             tmp[2*i]=7.+float(i);
1704             tmp[2*i+1]=17.+float(i)
1705             pass
1706         array.setValues(tmp,nbOfCells,2);
1707         fieldOnCells.setArray(array);
1708         #
1709         pos1=[0.25,0.]
1710         res=fieldOnCells.getValueOn(pos1);
1711         self.assertEqual(2,len(res))
1712         self.assertTrue(abs(8.-res[0])<1e-12);
1713         self.assertTrue(abs(18.-res[1])<1e-12);
1714         #
1715         #
1716         targetMesh=MEDCouplingDataForTest.build2DSourceMesh_1();
1717         fieldOnNodes=MEDCouplingFieldDouble.New(ON_NODES);
1718         nbOfNodes=targetMesh.getNumberOfNodes();
1719         fieldOnNodes.setMesh(targetMesh);
1720         array=DataArrayDouble.New();
1721         tmp=2*nbOfNodes*[None]
1722         for i in xrange(nbOfNodes):
1723             tmp[2*i]=17.+float(i);
1724             tmp[2*i+1]=27.+float(i)
1725             pass
1726         array.setValues(tmp,nbOfNodes,2);
1727         fieldOnNodes.setArray(array);
1728         #
1729         pos2=[-0.13333333333333333,-0.13333333333333333]
1730         res=None
1731         res=fieldOnNodes.getValueOn(pos2);
1732         self.assertEqual(2,len(res))
1733         self.assertTrue(abs(17.5-res[0])<1e-12);
1734         self.assertTrue(abs(27.5-res[1])<1e-12);
1735         pos3=[0.033333333333333326,0.36666666666666664]
1736         res=None
1737         res=fieldOnNodes.getValueOn(pos3);
1738         self.assertEqual(2,len(res))
1739         self.assertTrue(abs(18.666666666666667-res[0])<1e-12);
1740         self.assertTrue(abs(28.666666666666667-res[1])<1e-12);
1741         pass
1742
1743     def testCMesh0(self):
1744         mesh=MEDCouplingCMesh.New();
1745         meshEmpty=mesh.clone(True);
1746         self.assertTrue(meshEmpty.isEqual(mesh, 1e-12));
1747
1748         coordsX=DataArrayDouble.New();
1749         arrX=[ -1., 1., 2., 4. ]
1750         coordsX.setValues(arrX, 4, 1);
1751         coordsY=DataArrayDouble.New();
1752         arrY=[ -2., 2., 4., 8. ]
1753         coordsY.setValues(arrY, 4, 1);
1754         coordsZ=DataArrayDouble.New();
1755         arrZ=[ -3., 3., 6., 12. ]
1756         coordsZ.setValues(arrZ, 4, 1);
1757         mesh.setCoords(coordsX, coordsY, coordsZ);
1758         #
1759         fieldOnNodes=mesh.fillFromAnalytic(ON_NODES, 1, "x+y/2.+z/3.");
1760         self.assertEqual(1, fieldOnNodes.getNumberOfComponents());
1761         self.assertEqual(64, fieldOnNodes.getNumberOfTuples());
1762         expected1=[-3., -1., 0., 2., -1., 1., 2., 4., 0., 2., 3., 5., 2., 4., 5., 7., -1., 1., 2.,
1763                     4., 1., 3., 4., 6., 2., 4., 5., 7., 4., 6., 7., 9., 0., 2., 3., 5., 2., 4., 5.,
1764                     7., 3., 5., 6., 8., 5., 7., 8., 10., 2., 4., 5.,
1765                     7., 4., 6., 7., 9., 5., 7., 8., 10., 7., 9., 10., 12.];
1766
1767         val=fieldOnNodes.getArray().getValues();
1768         for i in xrange(64):
1769           self.assertAlmostEqual(expected1[i], val[i], 12)
1770         res=fieldOnNodes.getValueOnPos(1, 3, 2);
1771         self.assertAlmostEqual(7., res[0], 12);
1772         #
1773         fieldOnCells=mesh.fillFromAnalytic(ON_CELLS, 1, "x+y/2.+z/3.");
1774         self.assertEqual(1, fieldOnCells.getNumberOfComponents());
1775         self.assertEqual(27, fieldOnCells.getNumberOfTuples());
1776         val=fieldOnCells.getArray().getValues();
1777         expected2=[0, 1.5, 3, 1.5, 3, 4.5, 3, 4.5, 6, 1.5, 3, 4.5, 3, 4.5,
1778                     6, 4.5, 6, 7.5, 3, 4.5, 6, 4.5, 6, 7.5, 6, 7.5, 9];
1779         for i in xrange(27):
1780           self.assertAlmostEqual(expected2[i], val[i], 12);
1781         #res=fieldOnCells.getValueOnPos(1,2,1);
1782         #self.assertAlmostEqual(6.,res,12);
1783         #
1784         meshDeepCopy=mesh.deepCpy();
1785         meshClone=mesh.clone(False);
1786
1787         meshEmpty.copyTinyStringsFrom(mesh);
1788         #no data in meshEmpty, expected False
1789         self.assertTrue(not meshEmpty.isEqual(mesh, 1e-12));
1790
1791         self.assertTrue(meshDeepCopy.isEqual(mesh, 1e-12));
1792         meshDeepCopy.copyTinyStringsFrom(mesh);
1793         self.assertTrue(meshDeepCopy.isEqual(mesh, 1e-12));
1794         self.assertTrue(meshClone.isEqual(mesh, 1e-12));
1795
1796         self.assertEqual(CARTESIAN, mesh.getType());
1797         self.assertEqual(CARTESIAN, meshEmpty.getType());
1798         self.assertEqual(CARTESIAN, meshDeepCopy.getType());
1799         self.assertEqual(CARTESIAN, meshClone.getType());
1800         pass
1801
1802     def testCMesh1(self):
1803         mesh1=MEDCouplingCMesh.New();
1804         coordsX1=DataArrayDouble.New();
1805         arrX1=[ -1., 1., 2., 4. ]
1806         coordsX1.setValues(arrX1, 4, 1);
1807         coordsY1=DataArrayDouble.New();
1808         arrY1=[ -2., 2., 4., 8. ]
1809         coordsY1.setValues(arrY1, 4, 1);
1810         coordsZ1=DataArrayDouble.New();
1811         arrZ1=[ -3., 3., 6., 12. ]
1812         coordsZ1.setValues(arrZ1, 4, 1);
1813         mesh1.setCoords(coordsX1, coordsY1, coordsZ1);
1814
1815         mesh2=MEDCouplingCMesh.New();
1816         coordsX2=DataArrayDouble.New();
1817         arrX2=[ -1., 1., 2., 4. ]
1818         coordsX2.setValues(arrX2, 4, 1);
1819         coordsY2=DataArrayDouble.New();
1820         arrY2=[ -2., 2., 4., 8. ]
1821         coordsY2.setValues(arrY2, 4, 1);
1822         coordsZ2=DataArrayDouble.New();
1823         arrZ2=[ -3., 3., 6., 12.+1e-6 ]
1824         coordsZ2.setValues(arrZ2, 4, 1);
1825         mesh2.setCoords(coordsX2, coordsY2, coordsZ2);
1826
1827         mesh3=MEDCouplingCMesh.New();
1828         coordsX3=DataArrayDouble.New();
1829         arrX3=[-1.]
1830         coordsX3.setValues(arrX3, 1, 1);
1831         coordsY3=DataArrayDouble.New();
1832         arrY3=[-2.]
1833         coordsY3.setValues(arrY3, 1, 1);
1834         coordsZ3=DataArrayDouble.New();
1835         arrZ3=[-3.]
1836         coordsZ3.setValues(arrZ3, 1, 1);
1837         mesh3.setCoords(coordsX3, coordsY3, coordsZ3);
1838
1839         self.assertEqual(3, mesh1.getSpaceDimension());
1840         self.assertEqual(3, mesh1.getMeshDimension());
1841
1842         self.assertTrue(not mesh1.isEqual(mesh2, 1e-12));
1843         self.assertTrue(not mesh2.isEqual(mesh1, 1e-12));
1844         self.assertTrue(not mesh2.isEqualWithoutConsideringStr(mesh1, 1e-12));
1845         self.assertTrue(mesh1.isEqual(mesh2, 1e-5));
1846         self.assertTrue(not mesh1.isEqual(mesh2, 1e-7));
1847
1848         self.assertRaises(InterpKernelException, mesh3.checkCoherency1, 1e-12);
1849         mesh1.checkCoherency2(1e-12);
1850         self.assertEqual(NORM_HEXA8, mesh1.getTypeOfCell(1));
1851
1852         self.assertEqual(NORM_HEXA8, mesh1.getAllGeoTypes()[0]);
1853         self.assertEqual(27, mesh1.getNumberOfCellsWithType(NORM_HEXA8));
1854         self.assertRaises(InterpKernelException, mesh1.getNumberOfCellsWithType, NORM_QUAD4);
1855
1856         coo=mesh1.getCoordinatesOfNode(0);
1857         self.assertEqual(3, len(coo));
1858         self.assertAlmostEqual(-1., coo[0], 14);
1859         self.assertAlmostEqual(-2., coo[1], 14);
1860         self.assertAlmostEqual(-3., coo[2], 14);
1861         coo=mesh1.getCoordinatesOfNode(63);
1862         self.assertEqual(3, len(coo));
1863         self.assertAlmostEqual(4., coo[0], 14);
1864         self.assertAlmostEqual(8., coo[1], 14);
1865         self.assertAlmostEqual(12., coo[2], 14);
1866
1867         a=str(mesh1)
1868         repr=mesh1.simpleRepr();
1869         repr=mesh1.advancedRepr();
1870         self.assertTrue("Cartesian" in repr);
1871         self.assertTrue("Number of components : 1" in repr);
1872         self.assertTrue("Number of tuples : 4" in repr);
1873         self.assertTrue("Z Array :" in repr);
1874         pass
1875
1876     def testCMesh2(self):
1877         mesh1=MEDCouplingCMesh.New();
1878         coordsX1=DataArrayDouble.New();
1879         arrX1=[ -1., 1., 2., 4. ]
1880         coordsX1.setValues(arrX1, 4, 1);
1881         coordsY1=DataArrayDouble.New();
1882         arrY1=[ -2., 2., 4., 8. ]
1883         coordsY1.setValues(arrY1, 4, 1);
1884         coordsZ1=DataArrayDouble.New();
1885         arrZ1=[ -3., 3., 6., 12. ]
1886         coordsZ1.setValues(arrZ1, 4, 1);
1887         mesh1.setCoords(coordsX1, coordsY1, coordsZ1);
1888
1889         dis=mesh1.getDistributionOfTypes();
1890         self.assertEqual(1, len(dis));
1891         self.assertEqual(NORM_HEXA8, dis[0][0]);
1892         self.assertEqual(27, dis[0][1]);
1893         self.assertEqual(-1, dis[0][2]);
1894
1895         idsPerType=[]
1896         self.assertTrue(not mesh1.checkTypeConsistencyAndContig(dis, idsPerType));
1897         dis[0][0]=NORM_QUAD4;
1898         self.assertRaises(InterpKernelException, mesh1.checkTypeConsistencyAndContig, dis, idsPerType);
1899         dis[0][0]=NORM_HEXA8;
1900         dis[0][2]=0;
1901         ids=DataArrayInt.New();
1902         ids.alloc(10, 1);
1903         ids.fillWithValue(23);
1904         idsPerType=[ids];
1905         check=mesh1.checkTypeConsistencyAndContig(dis, idsPerType);
1906         self.assertTrue(check);
1907         self.assertTrue(check.isEqual(ids));
1908
1909         code, idsInPflPerType, pfls=mesh1.splitProfilePerType(ids);
1910         self.assertEqual(1, len(code));
1911         self.assertEqual(NORM_HEXA8, code[0][0]);
1912         self.assertEqual(10, code[0][1]);
1913         self.assertEqual(0, code[0][2]);
1914         self.assertEqual(1, len(idsInPflPerType));
1915         self.assertEqual(1, len(pfls));
1916         self.assertTrue(idsInPflPerType[0].isEqual(DataArrayInt([0,1,2,3,4,5,6,7,8,9])));
1917         self.assertTrue(pfls[0].isEqual(ids));
1918
1919         cells1=[0, 1, 25, 26]
1920         partMesh1=mesh1.buildPart(cells1)
1921         self.assertTrue(isinstance(partMesh1,MEDCouplingMesh))
1922         self.assertEqual(4, partMesh1.getNumberOfCellsWithType(NORM_HEXA8));
1923         self.assertEqual(64, mesh1.getNumberOfNodes());
1924         self.assertEqual(64, partMesh1.getNumberOfNodes());
1925
1926         cells2=[25, 26]
1927         partMesh2, arr1=mesh1.buildPartAndReduceNodes(cells2)
1928         self.assertTrue(isinstance(partMesh2,MEDCouplingCMesh))
1929         self.assertEqual(2,partMesh2.getNumberOfCellsWithType(NORM_HEXA8));
1930         self.assertEqual(12,partMesh2.getNumberOfNodes());
1931
1932         cells3=[2, 3]
1933         partMesh3, arr2=partMesh1.buildPartAndReduceNodes(cells3)
1934         self.assertTrue(isinstance(partMesh3,MEDCouplingUMesh))
1935         self.assertEqual(2, partMesh3.getNumberOfCellsWithType(NORM_HEXA8));
1936         self.assertEqual(12, partMesh3.getNumberOfNodes());
1937
1938         self.assertRaises(InterpKernelException, mesh1.simplexize, 0);
1939         self.assertRaises(InterpKernelException, mesh1.getMeasureFieldOnNode, True);
1940
1941         #double bbox1[6];
1942         #double bbox2[6];
1943         bbox1=mesh1.getBoundingBox(); #[(-1.0, 4.0), (-2.0, 8.0), (-3.0, 12.0)]
1944         bbox2=partMesh1.getBoundingBox();
1945         self.assertTrue(bbox1==bbox2);
1946         bbox1=partMesh3.getBoundingBox();
1947         bbox2=partMesh2.getBoundingBox();
1948         self.assertTrue(bbox1==bbox2);
1949
1950         self.assertRaises(InterpKernelException, mesh1.buildOrthogonalField);
1951         mesh2d=MEDCouplingCMesh.New();
1952         mesh2d.setCoords(coordsX1, coordsY1);
1953         f1=mesh2d.buildOrthogonalField();
1954
1955         pass
1956
1957     def testScale(self):
1958         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1959         pos=[0.2,0.2]
1960         mesh.scale(pos,0.5);
1961         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,
1962                    -0.05,0.45, 0.2,0.45, 0.45,0.45]
1963         val=mesh.getCoords().getValues();
1964         self.assertEqual(18,len(val))
1965         for i in xrange(18):
1966             self.assertTrue(abs(expected1[i]-val[i])<1e-12);
1967             pass
1968         pass
1969
1970     def testTryToShareSameCoords(self):
1971         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
1972         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
1973         self.assertTrue(m1.getCoords().getHiddenCppPointer()!=m2.getCoords().getHiddenCppPointer());
1974         m1.tryToShareSameCoords(m2,1e-12);
1975         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1976         m1.tryToShareSameCoords(m2,1e-12);
1977         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1978         m2.tryToShareSameCoords(m1,1e-12);
1979         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1980         #
1981         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
1982         m2=MEDCouplingDataForTest.build2DTargetMesh_2();
1983         self.assertTrue(m1.getCoords().getHiddenCppPointer()!=m2.getCoords().getHiddenCppPointer());
1984         m1.tryToShareSameCoords(m2,1e-12);
1985         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1986         m1.tryToShareSameCoords(m2,1e-12);
1987         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1988         m2.tryToShareSameCoords(m1,1e-12);
1989         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1990         #
1991         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
1992         m2=MEDCouplingDataForTest.build2DSourceMesh_1();
1993         self.assertTrue(m1.getCoords().getHiddenCppPointer()!=m2.getCoords().getHiddenCppPointer());
1994         self.assertRaises(InterpKernelException,m1.tryToShareSameCoords,m2,1e-12)
1995         pass
1996
1997     def testFindNodeOnPlane(self):
1998         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
1999         pt=[300.,300.,0.]
2000         v=[0.,0.,2.]
2001         n=mesh.findNodesOnPlane(pt,v,1e-12);
2002         self.assertEqual(9,len(n));
2003         m3dSurf=mesh.buildFacePartOfMySelfNode(n,True);
2004         self.assertTrue(isinstance(m3dSurf,MEDCouplingUMesh))
2005         me=MEDCouplingExtrudedMesh.New(mesh,m3dSurf,0);
2006         da=me.getMesh3DIds();
2007         self.assertEqual(8,me.getNumberOfCells());
2008         expected=[0,1,2,3,4,5,6,7]
2009         val=da.getValues();
2010         self.assertEqual(expected,list(val));
2011         #
2012         m3dSurf=mesh.buildFacePartOfMySelfNode(n,True);
2013         self.assertTrue(isinstance(m3dSurf,MEDCouplingUMesh))
2014         me=MEDCouplingExtrudedMesh.New(mesh,m3dSurf,0);
2015         da=me.getMesh3DIds();
2016         self.assertEqual(8,me.getNumberOfCells());
2017         expected=[0,1,2,3,4,5,6,7]
2018         val=da.getValues();
2019         self.assertEqual(expected,list(val));
2020         pass
2021
2022     def testRenumberCells(self):
2023         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2024         m2=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2025         self.assertTrue(m.isEqual(m2,0));
2026         arr=[12,3,25,2,26]
2027         m.renumberCells(arr,True);
2028         self.assertTrue(not m.isEqual(m2,0));
2029         self.assertEqual(NORM_QUAD4,m.getTypeOfCell(0));
2030         self.assertEqual(NORM_TRI3,m.getTypeOfCell(1));
2031         self.assertEqual(NORM_QUAD4,m.getTypeOfCell(2));
2032         self.assertEqual(NORM_TRI3,m.getTypeOfCell(3));
2033         self.assertEqual(NORM_QUAD4,m.getTypeOfCell(4));
2034         arr2=[5,-1,-5,4,8]
2035         m.renumberCells(arr2,True);
2036         self.assertTrue(m.isEqual(m2,0));
2037         pass
2038
2039     def testChangeSpaceDimension(self):
2040         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2041         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
2042         #
2043         self.assertEqual(3,m1.getSpaceDimension());
2044         m1.changeSpaceDimension(2);
2045         self.assertEqual(2,m1.getSpaceDimension());
2046         m1.setName(m2.getName());
2047         self.assertTrue(m1.isEqual(m2,1e-12));
2048         m1.changeSpaceDimension(3);
2049         self.assertEqual(3,m1.getSpaceDimension());
2050         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.]
2051         val=m1.getCoords().getValues();
2052         for i in xrange(27):
2053             self.assertTrue(abs(expected[i]-val[i])<1e-14);
2054             pass
2055         pass
2056
2057     def testGaussPointField1(self):
2058         _a=0.446948490915965;
2059         _b=0.091576213509771;
2060         _p1=0.11169079483905;
2061         _p2=0.0549758718227661;
2062         refCoo1=[ 0.,0., 1.,0., 0.,1. ]
2063         gsCoo1=[ 2*_b-1, 1-4*_b, 2*_b-1, 2.07*_b-1, 1-4*_b,
2064                  2*_b-1, 1-4*_a, 2*_a-1, 2*_a-1, 1-4*_a, 2*_a-1, 2*_a-1 ]
2065         wg1=[ 4*_p2, 4*_p2, 4*_p2, 4*_p1, 4*_p1, 4*_p1 ]
2066         _refCoo1=refCoo1
2067         _gsCoo1=gsCoo1
2068         _wg1=wg1
2069         #
2070         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2071         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,NO_TIME);
2072         f.setMesh(m);
2073         self.assertEqual(5,f.getNumberOfMeshPlacesExpected());
2074         self.assertEqual(0,f.getNbOfGaussLocalization());
2075         f.setGaussLocalizationOnType(NORM_TRI3,_refCoo1,_gsCoo1,_wg1);
2076         f.setGaussLocalizationOnType(NORM_TRI3,_refCoo1,_gsCoo1,_wg1); # not a bug only to check that it works well
2077         self.assertRaises(InterpKernelException,f.setGaussLocalizationOnType,NORM_QUAD4,_refCoo1,_gsCoo1,_wg1)
2078         self.assertEqual(1,f.getNbOfGaussLocalization());
2079         refCoo2=[ 0.,0., 1.,0., 1.,1., 0.,1. ]
2080         _refCoo2=refCoo2
2081         _gsCoo1=_gsCoo1[0:4]
2082         _wg1=_wg1[0:2]
2083         f.setGaussLocalizationOnType(NORM_QUAD4,_refCoo2,_gsCoo1,_wg1);
2084         self.assertEqual(2,f.getNbOfGaussLocalization());
2085         array=DataArrayDouble.New();
2086         ptr=18*2*[None]
2087         for i in xrange(18*2):
2088             ptr[i]=float(i+1)
2089         array.setValues(ptr,18,2);
2090         ptr=array.getPointer();
2091         f.setArray(array);
2092         f.setName("MyFirstFieldOnGaussPoint");
2093         f.checkCoherency();
2094         self.assertAlmostEqual(27.,f.getIJK(2,5,0),14);
2095         self.assertAlmostEqual(16.,f.getIJK(1,5,1),14);
2096         #
2097         f.clearGaussLocalizations();
2098         self.assertEqual(0,f.getNbOfGaussLocalization());
2099         self.assertRaises(InterpKernelException,f.checkCoherency);
2100         ids1=[0,1,3,4]
2101         self.assertRaises(InterpKernelException,f.setGaussLocalizationOnCells,ids1,_refCoo2,_gsCoo1,_wg1);
2102         self.assertEqual(0,f.getNbOfGaussLocalization());
2103         ids2=[0,4]
2104         f.setGaussLocalizationOnCells(ids2,_refCoo2,_gsCoo1,_wg1);
2105         self.assertEqual(1,f.getNbOfGaussLocalization());
2106         self.assertEqual(0,f.getGaussLocalizationIdOfOneCell(0));
2107         self.assertRaises(InterpKernelException,f.getGaussLocalizationIdOfOneCell,1);
2108         ids3=[1,2]
2109         f.setGaussLocalizationOnCells(ids3,_refCoo1,_gsCoo1,_wg1);
2110         self.assertEqual(2,f.getNbOfGaussLocalization());
2111         self.assertEqual(0,f.getGaussLocalizationIdOfOneCell(0));
2112         self.assertEqual(1,f.getGaussLocalizationIdOfOneCell(1));
2113         self.assertEqual(1,f.getGaussLocalizationIdOfOneCell(2));
2114         self.assertRaises(InterpKernelException,f.checkCoherency);#<- cell 3 has no localization
2115         ids4=[3]
2116         _gsCoo2=_gsCoo1;
2117         _wg2=_wg1;
2118         _gsCoo2[0]=0.8888777776666;
2119         _wg2[0]=0.1234567892377;
2120         f.setGaussLocalizationOnCells(ids4,_refCoo2,_gsCoo2,_wg2);
2121         self.assertEqual(3,f.getNbOfGaussLocalization());
2122         tmpIds=f.getCellIdsHavingGaussLocalization(0);
2123         self.assertEqual(ids2,list(tmpIds.getValues()));
2124         self.assertRaises(InterpKernelException,f.checkCoherency);#<- it's always not ok because undelying array not with the good size.
2125         array2=f.getArray().substr(0,10);
2126         f.setArray(array2);
2127         f.checkCoherency();#<- here it is OK
2128         f2=f.clone(True);
2129         self.assertTrue(f.isEqual(f2,1e-14,1e-14));
2130         gl1=f2.getGaussLocalization(0);
2131         tmp=gl1.getGaussCoord(1,1);
2132         self.assertAlmostEqual(2.07*_b-1,tmp,14);
2133         gl1.setGaussCoord(1,1,0.07);
2134         self.assertTrue(not f.isEqual(f2,1e-14,1e-14));
2135         gl1.setGaussCoord(1,1,tmp);
2136         self.assertTrue(f.isEqual(f2,1e-14,1e-14));
2137         f2.checkCoherency();
2138         pass
2139
2140     def testGaussPointNEField1(self):
2141         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2142         f=MEDCouplingFieldDouble.New(ON_GAUSS_NE,NO_TIME);
2143         f.setMesh(m);
2144         self.assertEqual(5,f.getNumberOfMeshPlacesExpected());
2145         f.setName("MyFirstFieldOnNE");
2146         f.setDescription("MyDescriptionNE");
2147         array=DataArrayDouble.New();
2148         tmp=18*2*[None]
2149         for i in xrange(18*2):
2150             tmp[i]=float(i+7)
2151             pass
2152         array.setValues(tmp,18,2);
2153         ptr=array.getPointer();
2154         f.setArray(array);
2155         #
2156         f.checkCoherency();
2157         f2=f.clone(True);
2158         self.assertTrue(f.isEqual(f2,1e-14,1e-14));
2159         self.assertAlmostEqual(21.,f.getIJK(2,0,0),14);
2160         self.assertAlmostEqual(18.,f.getIJK(1,1,1),14);
2161         pass
2162
2163     def testCellOrientation1(self):
2164         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2165         vec=[0.,0.,-1.]
2166         self.assertRaises(InterpKernelException,m.are2DCellsNotCorrectlyOriented,vec,False);
2167         m.changeSpaceDimension(3);
2168         res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2169         self.assertTrue(len(res1)==0);
2170         vec[2]=1.;
2171         res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2172         self.assertEqual(5,len(res1));
2173         #
2174         vec[2]=-1.;
2175         # connectivity inversion
2176         conn=m.getNodalConnectivity().getValues();
2177         tmp=conn[11];
2178         conn[11]=conn[12];
2179         conn[12]=tmp;
2180         m.getNodalConnectivity().setValues(conn,len(conn),1)
2181         res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2182         self.assertEqual(1,len(res1));
2183         self.assertEqual(2,res1.getValues()[0]);
2184         m.orientCorrectly2DCells(vec,False);
2185         res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2186         self.assertTrue(len(res1)==0);
2187         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
2188         m2.changeSpaceDimension(3);
2189         self.assertTrue(m.isEqual(m2,1e-12));
2190         pass
2191
2192     def testCellOrientation2(self):
2193         m2,m1=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
2194         res1=m2.arePolyhedronsNotCorrectlyOriented();
2195         self.assertEqual(6,len(res1));
2196         m2.orientCorrectlyPolyhedrons();
2197         res1=m2.arePolyhedronsNotCorrectlyOriented();
2198         self.assertTrue(len(res1)==0);
2199         m2.checkCoherency();
2200         self.assertEqual(18,m2.getNumberOfCells());
2201         cellIds2=[0,6,12]
2202         m2.convertToPolyTypes(cellIds2);
2203         m2.orientCorrectlyPolyhedrons();
2204         res1=m2.arePolyhedronsNotCorrectlyOriented();
2205         self.assertTrue(len(res1)==0);
2206         f2=m2.getMeasureField(False);
2207         f2Ptr=f2.getArray().getValues();
2208         #Test to check global reverse in MEDCouplingUMesh::tryToCorrectPolyhedronOrientation
2209         m3=MEDCouplingDataForTest.build2DTargetMesh_1();
2210         vec=[0.,0.,1.]
2211         m3.changeSpaceDimension(3);
2212         ids2=[0,1,2,3,4]
2213         m3.convertToPolyTypes(ids2);
2214         m3.orientCorrectly2DCells(vec,False);
2215         m4=MEDCouplingDataForTest.buildCU1DMesh_U();
2216         m4.changeSpaceDimension(3);
2217         center=[0.,0.,0.]
2218         vector=[0.,1.,0.]
2219         m4.rotate(center,vector,-pi/2.);
2220         m5=m3.buildExtrudedMesh(m4,0);
2221         res1=m5.arePolyhedronsNotCorrectlyOriented();
2222         self.assertEqual(15,len(res1));
2223         m5.orientCorrectlyPolyhedrons();
2224         res1=m5.arePolyhedronsNotCorrectlyOriented();
2225         self.assertTrue(len(res1)==0);
2226         f3=m5.getMeasureField(False);
2227         self.assertEqual(15,f3.getArray().getNumberOfTuples());
2228         self.assertEqual(1,f3.getNumberOfComponents());
2229         f3Ptr=f3.getArray().getValues();
2230         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];
2231         for i in xrange(15):
2232             self.assertTrue(abs(expected1[i]-f3Ptr[i])<1e-12);
2233             pass
2234         f4=m5.getBarycenterAndOwner();
2235         self.assertEqual(15,f4.getNumberOfTuples());
2236         self.assertEqual(3,f4.getNumberOfComponents());
2237         f4Ptr=f4.getValues();
2238         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];
2239         for i in xrange(45):
2240             self.assertTrue(abs(expected2[i]-f4Ptr[i])<1e-12);
2241             pass
2242         pass
2243
2244     def testCellOrientation3(self):
2245         from cmath import rect
2246
2247         c = [rect(1.0, i*pi/4.0) for i in range(8)]
2248         coords = [c[-1].real,c[-1].imag,  c[3].real,c[3].imag,
2249                    c[5].real,c[5].imag,  c[1].real,c[1].imag]
2250         connec = [0,1,2,3]
2251         baseMesh = MEDCouplingUMesh.New("circle", 2)
2252         baseMesh.allocateCells(1)
2253         meshCoords = DataArrayDouble.New(coords, 4, 2)
2254         baseMesh.setCoords(meshCoords)
2255         baseMesh.insertNextCell(NORM_QPOLYG, connec)  # a circle
2256         baseMesh.finishInsertingCells()
2257         baseMesh.changeSpaceDimension(3)
2258         Oz = [0.0, 0.0, -1.0]
2259         cell_lst = baseMesh.are2DCellsNotCorrectlyOriented(Oz, False)
2260         self.assertEqual(cell_lst.getNumberOfTuples(), 0)
2261         Oz[2] = 1.0
2262         cell_lst = baseMesh.are2DCellsNotCorrectlyOriented(Oz, False)
2263         self.assertEqual(cell_lst.getNumberOfTuples(), 1)
2264
2265     def testPolyhedronBarycenter(self):
2266         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];
2267         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];
2268         meshN=MEDCouplingUMesh.New();
2269         meshN.setName("ForBary");
2270         meshN.setMeshDimension(3);
2271         meshN.allocateCells(4);
2272         meshN.insertNextCell(NORM_POLYHED,29,connN[0:29])
2273         meshN.finishInsertingCells();
2274         myCoords=DataArrayDouble.New();
2275         myCoords.setValues(coords,9,3);
2276         meshN.setCoords(myCoords);
2277         meshN.checkCoherency();
2278         #
2279         res1=meshN.arePolyhedronsNotCorrectlyOriented();
2280         meshN.orientCorrectlyPolyhedrons();
2281         self.assertTrue(len(res1)==0);
2282         da=meshN.getBarycenterAndOwner();
2283         self.assertEqual(1,da.getNumberOfTuples());
2284         self.assertEqual(3,da.getNumberOfComponents());
2285         daPtr=da.getValues();
2286         ref=meshN.getCoords().getValues()[24:];
2287         for i in xrange(3):
2288             self.assertTrue(abs(ref[i]-daPtr[i])<1e-12);
2289             pass
2290         #
2291         center=[0.,0.,0.]
2292         vec=[0.,2.78,0.]
2293         da=meshN.getBarycenterAndOwner();
2294         daPtr=da.getValues();
2295         ref=meshN.getCoords().getValues()[24:];
2296         for i in xrange(3):
2297             self.assertTrue(abs(ref[i]-daPtr[i])<1e-12);
2298             pass
2299         #
2300         meshN.rotate(center,vec,pi/7.);
2301         meshN.translate(vec);
2302         da=meshN.getBarycenterAndOwner();
2303         daPtr=da.getValues();
2304         ref=meshN.getCoords().getValues()[24:];
2305         for i in xrange(3):
2306             self.assertTrue(abs(ref[i]-daPtr[i])<1e-12);
2307             pass
2308         #
2309         center2=[1.12,3.45,6.78]
2310         vec2=[4.5,9.3,2.8]
2311         meshN.rotate(center2,vec2,e);
2312         meshN.translate(vec2);
2313         da=meshN.getBarycenterAndOwner();
2314         daPtr=da.getValues();
2315         ref=meshN.getCoords().getValues()[24:];
2316         for i in xrange(3):
2317             self.assertTrue(abs(ref[i]-daPtr[i])<1e-10);
2318             pass
2319         pass
2320
2321     def testNormL12Integ1D(self):
2322         m1=MEDCouplingDataForTest.build1DTargetMesh_3();
2323         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2324         f1.setMesh(m1);
2325         array=DataArrayDouble.New();
2326         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]
2327         array.setValues(arr,m1.getNumberOfCells(),3);
2328         f1.setArray(array);
2329         #
2330         f3=m1.getBarycenterAndOwner();
2331         self.assertEqual(4,f3.getNumberOfTuples());
2332         self.assertEqual(1,f3.getNumberOfComponents());
2333         expected9=[0.75,5.105,0.8,5.155]
2334         ptr=f3.getValues();
2335         for i in xrange(4):
2336             self.assertTrue(abs(expected9[i]-ptr[i])<1e-12);
2337             pass
2338         #
2339         f2=m1.getMeasureField(False);
2340         self.assertEqual(4,f2.getArray().getNumberOfTuples());
2341         self.assertEqual(1,f2.getNumberOfComponents());
2342         expected1=[0.5,0.21,-0.6,-0.31]
2343         ptr=f2.getArray().getValues();
2344         for i in xrange(4):
2345             self.assertTrue(abs(expected1[i]-ptr[i])<1e-12);
2346             pass
2347         expected2=[0.5,0.21,0.6,0.31]
2348         f2=m1.getMeasureField(True);
2349         ptr=f2.getArray().getValues();
2350         for i in xrange(4):
2351             self.assertTrue(abs(expected2[i]-ptr[i])<1e-12);
2352             pass
2353         #integral
2354         self.assertTrue(4,f1.getNumberOfTuples())
2355         res=f1.integral(False);
2356         self.assertTrue(3,len(res))
2357         expected3=[0.9866,-0.3615,0.4217]
2358         for i in xrange(3):
2359             self.assertTrue(abs(expected3[i]-res[i])<1e-12);
2360             pass
2361         self.assertTrue(abs(expected3[0]-f1.integral(0,False))<1e-12);
2362         self.assertTrue(abs(expected3[1]-f1.integral(1,False))<1e-12);
2363         self.assertTrue(abs(expected3[2]-f1.integral(2,False))<1e-12);
2364         res=f1.integral(True);
2365         expected4=[-3.4152,8.7639,-14.6879]
2366         for i in xrange(3):
2367             self.assertTrue(abs(expected4[i]-res[i])<1e-12);
2368             pass
2369         #normL1
2370         res=f1.normL1();
2371         self.assertTrue(3,len(res))
2372         expected5=[6.979506172839505, 16.89018518518518, 27.02969135802469]
2373         for i in xrange(3):
2374             self.assertTrue(abs(expected5[i]-res[i])<1e-12);
2375             pass
2376         self.assertTrue(abs(expected5[0]-f1.normL1(0))<1e-12);
2377         self.assertTrue(abs(expected5[1]-f1.normL1(1))<1e-12);
2378         self.assertTrue(abs(expected5[2]-f1.normL1(2))<1e-12);
2379         #normL2
2380         res=f1.normL2();
2381         self.assertTrue(3,len(res))
2382         expected7=[7.090910979452395, 16.9275542960123, 27.053271464160858]
2383         for i in xrange(3):
2384             self.assertTrue(abs(expected7[i]-res[i])<1e-9);
2385             pass
2386         self.assertTrue(abs(expected7[0]-f1.normL2(0))<1e-9);
2387         self.assertTrue(abs(expected7[1]-f1.normL2(1))<1e-9);
2388         self.assertTrue(abs(expected7[2]-f1.normL2(2))<1e-9);
2389         #buildMeasureField
2390         f4=f1.buildMeasureField(False);
2391         self.assertTrue(abs(-0.2-f4.accumulate(0))<1e-12);
2392         f4=f1.buildMeasureField(True);
2393         self.assertTrue(abs(1.62-f4.accumulate(0))<1e-12);
2394         # Testing with 2D Curve
2395         m1=MEDCouplingDataForTest.build2DCurveTargetMesh_3();
2396         f2=m1.getMeasureField(False);
2397         self.assertEqual(4,f2.getArray().getNumberOfTuples());
2398         self.assertEqual(1,f2.getNumberOfComponents());
2399         ptr=f2.getArray().getValues();
2400         for i in xrange(4):
2401             self.assertTrue(abs(sqrt(2.)*expected2[i]-ptr[i])<1e-12);
2402             pass
2403         f2=m1.getMeasureField(True);
2404         self.assertEqual(4,f2.getArray().getNumberOfTuples());
2405         self.assertEqual(1,f2.getNumberOfComponents());
2406         ptr=f2.getArray().getValues();
2407         for i in xrange(4):
2408             self.assertTrue(abs(expected2[i]*sqrt(2.)-ptr[i])<1e-12);
2409             pass
2410         #bary
2411         f3=m1.getBarycenterAndOwner();
2412         self.assertEqual(4,f3.getNumberOfTuples());
2413         self.assertEqual(2,f3.getNumberOfComponents());
2414         expected10=[0.75,0.75,5.105,5.105,0.8,0.8,5.155,5.155]
2415         ptr=f3.getValues();
2416         for i in xrange(8):
2417             self.assertTrue(abs(expected10[i]-ptr[i])<1e-12);
2418             pass
2419         #
2420         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2421         f1.setMesh(m1);
2422         array=DataArrayDouble.New();
2423         array.setValues(arr,m1.getNumberOfCells(),3);
2424         f1.setArray(array);
2425         res=f1.integral(False);
2426         for i in xrange(3):
2427             self.assertTrue(abs(sqrt(2.)*expected4[i]-res[i])<1e-12);
2428             pass
2429         res=f1.integral(True);
2430         for i in xrange(3):
2431             self.assertTrue(abs(sqrt(2.)*expected4[i]-res[i])<1e-12);
2432             pass
2433         res=f1.normL1();
2434         for i in xrange(3):
2435             self.assertTrue(abs(expected5[i]-res[i])<1e-12);
2436             pass
2437         res=f1.normL2();
2438         for i in xrange(3):
2439             self.assertTrue(abs(expected7[i]-res[i])<1e-12);
2440             pass
2441         pass
2442
2443     def testAreaBary2D(self):
2444         m1=MEDCouplingDataForTest.build2DTargetMesh_3();
2445         f1=m1.getMeasureField(False);
2446         self.assertEqual(10,f1.getArray().getNumberOfTuples());
2447         self.assertEqual(1,f1.getNumberOfComponents());
2448         expected1=[-0.5,-1,-1.5,-0.5,-1,  0.5,1,1.5,0.5,1]
2449         ptr=f1.getArray().getValues();
2450         for i in xrange(10):
2451             self.assertTrue(abs(expected1[i]-ptr[i])<1e-12);
2452             pass
2453         f1=m1.getMeasureField(True);
2454         ptr=f1.getArray().getValues();
2455         for i in xrange(10):
2456             self.assertTrue(abs(abs(expected1[i])-ptr[i])<1e-12);
2457             pass
2458         f2=m1.getBarycenterAndOwner();
2459         self.assertEqual(10,f2.getNumberOfTuples());
2460         self.assertEqual(2,f2.getNumberOfComponents());
2461         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]
2462         ptr=f2.getValues();
2463         for i in xrange(20):
2464             self.assertTrue(abs(expected2[i]-ptr[i])<1e-12);
2465             pass
2466         m1.changeSpaceDimension(3);
2467         f1=m1.getMeasureField(False);
2468         self.assertEqual(10,f1.getArray().getNumberOfTuples());
2469         self.assertEqual(1,f1.getNumberOfComponents());
2470         ptr=f1.getArray().getValues();
2471         for i in xrange(10):
2472             self.assertTrue(abs(abs(expected1[i])-ptr[i])<1e-12);
2473             pass
2474         f2=m1.getBarycenterAndOwner();
2475         self.assertEqual(10,f2.getNumberOfTuples());
2476         self.assertEqual(3,f2.getNumberOfComponents());
2477         ptr=f2.getValues();
2478         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.]
2479         for i in xrange(30):
2480             self.assertTrue(abs(expected3[i]-ptr[i])<1e-12);
2481             pass
2482         pass
2483
2484     def testAreaBary3D(self):
2485         coords=[ 0.241310763507 , 0.0504777305619 , 0.0682283524903 , 0.252501053866 , -0.0625176732937 , 0.137272639894 ,
2486                  0.152262663601 , 0.241816569527 , 0.133812556197 , 0.18047750211 , -0.0789949051358 , 0.339098173401 ,
2487                  0.151741971857 , 0.238885278571 , 0.137715037333 , 0.242532155481 , -0.0928169086456 , 0.0678043417367 ,
2488                  0.240941965335 , -0.015461491464 , 0.0617186345825 , 0.24127650112 , 0.0499427876717 , 0.0679634099148 ,
2489                  -0.145828917428 , 0.206291632565 , 0.0310071927543 , 0.0125651775307 , 0.266262085828 , 0.105228430543 ,
2490                  -0.0994066533286 , 0.233224271238 , 0.0572213839567 , -0.0951345338317 , 0.234819509426 , 0.0592126284538 ,
2491                  0.136580574205 , -0.205486212579 , 0.0572866072014 , 0.0637270784978 , -0.168886355238 , 0.446614057077 ,
2492                  0.041337157151 , -0.213402568198 , 0.372407095999 , 0.0411601970268 , -0.202387875756 , 0.411334979491 ,
2493                  -0.108355701857 , 0.193636239335 , 0.204886756738 , 0.00639779029829 , 0.155296981517 , 0.252585892979 ,
2494                  0.0262473111702 , -0.112919732543 , 0.424286639249 ,-0.224103052733 , -0.139430015438 , -0.0122352295701 ,
2495                 -0.0312760589481 , -0.274272003594 , 0.0323959636568 , -0.166663422532 , -0.217754445175 , 0.00392109070364 ,
2496                  -0.30586619777 , -0.0475168041091 , -0.0144585228182 , -0.280881480586 , 0.135571293538 , 0.00623923647986 ,
2497                  -0.25548538234 , 0.156819217766 , 0.0645277879769 , -0.131567009284 , 0.184133752309 , 0.206021802753 ,
2498                  -0.196204010965 , 0.151602971681 , 0.212974777736 , -0.183713879463 , 0.0802946639531 , 0.260115662599 ,
2499                  -0.244241178767 , -0.0738873389604 , 0.144590565817 , -0.155804057829 , -0.164892720025 , 0.210613950558 ,
2500                  -0.170950800428 , -0.215099334026 , 0.00610122860092 , -0.30552634869 , -0.0490020791904 , -0.0132786533145 ,
2501                  0.271831011884 , 0.15105657296 , 0.0230534827908 , 0.281919192283 , 0.0898544306288 , -0.0625201489143 ,
2502                  0.260240727276 , -0.0120688706637 , -0.0532316588626 , 0.244947737722 , 0.0197984684293 , 0.0309341209233 ,
2503                  0.23439631578 , 0.229825279875 , 0.0508520585381 , 0.160921316875 , 0.265078502128 , 0.121716560626 ,
2504                  -0.315088694175 , 0.0747700471918 , -0.245836615071 , -0.327728781776 , 0.0857114674649 , -0.239431905957 ,
2505                  -0.308385460634 , 0.145142997084 , -0.149886828433 , 0.0488236045164 , 0.309462801914 , 0.0849169148265 ,
2506                 -0.0244964803395 , 0.33145611751 , -0.0476415818061 , 0.0060567994229 , 0.32418412014 , 0.0367779543812 ,
2507                  -0.0950221448063 , 0.236675326003 , 0.0572594453983 , 0.248723023186 , 0.0886648784791 , -0.176629430538 ,
2508                  0.116796984 , 0.256596599567 , -0.292863523603 , 0.118024552914 , 0.229154257843 , -0.34233232501 ,
2509                  0.217507892549 , -0.0417822335742 , -0.176771782888 , -0.224429321304 , 0.0125595300114 , -0.362064725588 ,
2510                  0.0937301100955 , -0.0500824832657 , -0.299713548444 , -0.244162220397 , 0.0383853931293 , -0.389856984411 ,
2511                  -0.0281989366102 , 0.097392811563 , -0.458244577284 , -0.385010847162 , 0.10122766194 , -0.140052859922 ,
2512                  -0.377936358012 , 0.110875172128 , -0.176207095463 , 0.244483045556 , -0.0991073977045 , 0.0575134372934 ,
2513                 0.262605120167 , -0.100243191645 , -0.0495620806935 , 0.240306880972 , -0.136153701579 , -0.114745281696 ,
2514                  0.215763176129 , -0.0836766059189 , -0.183249640616 , 0.237870396603 , -0.132449578286 , -0.121598854639 ,
2515                  -0.0637683083097 , -0.27921020214 , -0.149112321992 , -0.0856211014977 , -0.2973233473 , -0.0446878139589 ,
2516                  0.104675342288 , -0.0625908305324 , -0.290346256534 , 0.0248264249186 , -0.247797708548 , -0.165830884019 ,
2517                  0.0719302438309 , -0.178468260473 , -0.211432157345 , 0.142871843159 , -0.208769948542 , 0.0454101128246 ,
2518                  0.167803379307 , -0.207851396623 , -0.088802726124 , 0.12868717152 , -0.230920439715 , 0.00760508389036 ,
2519                  -0.0372812069535 , -0.286740286332 , 0.00963701291166 ]
2520
2521         connN = [ #polyhedron 0
2522             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
2523             , 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
2524             , 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
2525             , 22 , 19 , 21 , 30 , 31 , -1 , 22 , 31 , 28 , 27 , 26 , 24 , 23 , -1 , 31 , 30 , 29 , 28,
2526             # polyhedron 1
2527             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
2528             , 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
2529             , 33 , 34 , 48 , 45 , -1 , 35 , 34 , 48 , 50 , 49 , 38 , -1 , 41 , 43 , 42 , 46 , 36 , 37 , -1 , 38 , 39 , 51 , 49 , -1
2530             , 39 , 40 , 42 , 46 , 47 , 52 , 51 , -1 , 45 , 47 , 52 , 50 , 48 , -1 , 52 , 51 , 49 , 50,
2531             # polyhedron 2
2532             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
2533             , 23 , 53 , 54 , 40 , 8 , -1 , 53 , 22 , 23 , -1 , 39 , 54 , 40,
2534             # polyhedron 3
2535             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
2536             , 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
2537             , 55 , 5 , 12 , 65 , -1 , 66 , 67 , 65 , 55 , 56 , 57 , -1 , 63 , 66 , 57 , 59 , 64 , -1 , 64 , 62 , 58 , 59 , -1
2538             , 60 , 63 , 66 , 67 , 68 , 61 , -1 , 61 , 68 , 20 , 21 , -1 , 67 , 68 , 20 , 12 , 65]
2539
2540         barys = [ -0.0165220465527 , -0.0190922868195 , 0.158882733414 ,
2541                   0.0287618656076 , 0.135874379934 , -0.14601588119 ,
2542                   -0.147128055553 , 0.0465995097041 , -0.049391174453 ,
2543                   -0.00142506732317 , -0.0996953090351 , -0.115159183132 ]
2544         meshN=MEDCouplingUMesh.New();
2545         meshN.setName("ForBary");
2546         meshN.setMeshDimension(3);
2547         meshN.allocateCells(4);
2548         meshN.insertNextCell(NORM_POLYHED,113,connN);
2549         meshN.insertNextCell(NORM_POLYHED,99,connN[113:]);
2550         meshN.insertNextCell(NORM_POLYHED,43,connN[212:]);
2551         meshN.insertNextCell(NORM_POLYHED,92,connN[255:]);
2552         meshN.finishInsertingCells();
2553         myCoords=DataArrayDouble.New();
2554         myCoords.setValues(coords,69,3);
2555         meshN.setCoords(myCoords);
2556         meshN.checkCoherency();
2557         res1=meshN.arePolyhedronsNotCorrectlyOriented();
2558         meshN.orientCorrectlyPolyhedrons();
2559         res1=meshN.arePolyhedronsNotCorrectlyOriented();
2560         self.assertTrue(len(res1)==0);
2561         #
2562         da=meshN.getBarycenterAndOwner();
2563         self.assertEqual(4,da.getNumberOfTuples());
2564         self.assertEqual(3,da.getNumberOfComponents());
2565         daPtr=da.getValues();
2566         for i in xrange(12):
2567             self.assertTrue(abs(barys[i]-daPtr[i])<1e-12);
2568             pass
2569         pass
2570
2571     def testRenumberCellsForFields(self):
2572         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2573         f=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2574         f.setMesh(m);
2575         arr=DataArrayDouble.New();
2576         nbOfCells=m.getNumberOfCells();
2577         values1=[7.,107.,10007.,8.,108.,10008.,9.,109.,10009.,10.,110.,10010.,11.,111.,10011.]
2578         arr.setValues(values1,nbOfCells,3);
2579         f.setArray(arr);
2580         renumber1=[3,1,0,4,2]
2581         loc=[-0.05,-0.05, 0.55,-0.25, 0.55,0.15, -0.05,0.45, 0.45,0.45]
2582         for j in xrange(5):
2583             res=f.getValueOn(loc[2*j:2*j+2]);
2584             for i in xrange(3):
2585                 self.assertTrue(abs(values1[i+3*j]-res[i])<1e-12);
2586                 pass
2587             pass
2588         f.renumberCells(renumber1,False);
2589         ptr=f.getArray().getValues();
2590         expected1=[9.,109.,10009.,8.,108.,10008.,11.,111.,10011.,7.,107.,10007.,10.,110.,10010.]
2591         for i in xrange(15):
2592             self.assertTrue(abs(expected1[i]-ptr[i])<1e-12);
2593             pass
2594         #check that fields remains the same geometrically
2595         for j in xrange(5):
2596             res=f.getValueOn(loc[2*j:2*(j+1)]);
2597             for i in xrange(3):
2598                 self.assertTrue(abs(values1[i+3*j]-res[i])<1e-12);
2599                 pass
2600             pass
2601         #On gauss
2602         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,NO_TIME);
2603         f.setMesh(m);
2604         _a=0.446948490915965;
2605         _b=0.091576213509771;
2606         _p1=0.11169079483905;
2607         _p2=0.0549758718227661;
2608         refCoo1=[ 0.,0., 1.,0., 0.,1. ]
2609         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 ];
2610         wg1=[ 4*_p2, 4*_p2, 4*_p2, 4*_p1, 4*_p1, 4*_p1 ]
2611         _refCoo1=refCoo1[0:6];
2612         _gsCoo1=gsCoo1[0:12];
2613         _wg1=wg1[0:6];
2614         f.setGaussLocalizationOnType(NORM_TRI3,_refCoo1,_gsCoo1,_wg1);
2615         refCoo2=[ 0.,0., 1.,0., 1.,1., 0.,1. ]
2616         _refCoo2=refCoo2[0:8];
2617         _gsCoo1=_gsCoo1[0:4]
2618         _wg1=_wg1[0:2]
2619         f.setGaussLocalizationOnType(NORM_QUAD4,_refCoo2,_gsCoo1,_wg1);
2620         arr=DataArrayDouble.New();
2621         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.]
2622         arr.setValues(values2,18,2);
2623         f.setArray(arr);
2624         f.checkCoherency();
2625         fCpy=f.clone(True);
2626         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2627         f.renumberCells(renumber1,False);
2628         self.assertTrue(not f.isEqual(fCpy,1e-12,1e-12));
2629         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.]
2630         ptr=f.getArray().getValues();
2631         for i in xrange(36):
2632             self.assertTrue(abs(expected2[i]-ptr[i])<1e-12);
2633             pass
2634         renumber2=[2,1,4,0,3]
2635         f.renumberCells(renumber2,False);
2636         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2637         #GaussNE
2638         f=MEDCouplingFieldDouble.New(ON_GAUSS_NE,NO_TIME);
2639         f.setMesh(m);
2640         arr=DataArrayDouble.New();
2641         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.]
2642         arr.setValues(values3,18,2);
2643         f.setArray(arr);
2644         f.checkCoherency();
2645         fCpy=f.clone(True);
2646         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2647         f.renumberCells(renumber1,False);
2648         self.assertTrue(not f.isEqual(fCpy,1e-12,1e-12));
2649         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.]
2650         ptr=f.getArray().getValues();
2651         for i in xrange(36):
2652             self.assertTrue(abs(expected3[i]-ptr[i])<1e-12);
2653             pass
2654         f.renumberCells(renumber2,False);#perform reverse operation of renumbering to check that the resulting field is equal.
2655         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2656         #
2657         pass
2658
2659     def testRenumberNodesForFields(self):
2660         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2661         f=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
2662         f.setMesh(m);
2663         self.assertEqual(9,f.getNumberOfMeshPlacesExpected());
2664         arr=DataArrayDouble.New();
2665         nbOfNodes=m.getNumberOfNodes();
2666         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.]
2667         arr.setValues(values1,nbOfNodes,3);
2668         f.setArray(arr);
2669         f.checkCoherency();
2670         renumber1=[0,4,1,3,5,2,6,7,8]
2671         loc=[0.5432,-0.2432, 0.5478,0.1528]
2672         expected1=[9.0272, 109.0272, 10009.0272, 11.4124,111.4124,10011.4124]
2673         for j in xrange(2):
2674             res=f.getValueOn(loc[2*j:2*j+2]);
2675             for i in xrange(3):
2676                 self.assertTrue(abs(expected1[i+3*j]-res[i])<1e-12);
2677                 pass
2678             pass
2679         fCpy=f.clone(True);
2680         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2681         f.renumberNodes(renumber1);
2682         self.assertTrue(not f.isEqual(fCpy,1e-12,1e-12));
2683         for j in xrange(2):
2684             res=f.getValueOn(loc[2*j:2*j+2]);
2685             for i in xrange(3):
2686                 self.assertTrue(abs(expected1[i+3*j]-res[i])<1e-12);
2687                 pass
2688             pass
2689         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.]
2690         for i in xrange(27):
2691             self.assertTrue(abs(expected2[i]-f.getArray().getValues()[i])<1e-12);
2692             pass
2693         renumber2=[0,2,5,3,1,4,6,7,8]
2694         f.renumberNodes(renumber2);
2695         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2696         pass
2697
2698     def testConvertQuadraticCellsToLinear(self):
2699         mesh=MEDCouplingDataForTest.build2DTargetMesh_3();
2700         mesh.checkCoherency();
2701         types=mesh.getAllGeoTypes();
2702         types.sort()
2703         self.assertEqual(5,len(types));
2704         expected1=[NORM_POLYGON, NORM_TRI3, NORM_QUAD4, NORM_TRI6, NORM_QUAD8]
2705         expected1.sort()
2706         self.assertEqual(expected1,types);
2707         self.assertTrue(mesh.isPresenceOfQuadratic());
2708         self.assertEqual(62,mesh.getMeshLength());
2709         f1=mesh.getMeasureField(False);
2710         #
2711         mesh.convertQuadraticCellsToLinear();
2712         self.assertTrue(not mesh.isPresenceOfQuadratic());
2713         #
2714         mesh.checkCoherency();
2715         f2=mesh.getMeasureField(False);
2716         self.assertTrue(f1.getArray().isEqual(f2.getArray(),1e-12));
2717         self.assertEqual(48,mesh.getMeshLength());
2718         types2=mesh.getAllGeoTypes();
2719         types2.sort()
2720         self.assertEqual(3,len(types2));
2721         expected2=[NORM_POLYGON, NORM_TRI3, NORM_QUAD4]
2722         expected2.sort()
2723         self.assertEqual(expected2,types2);
2724         pass
2725
2726     def testCheckGeoEquivalWith(self):
2727         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2728         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2729         #First test mesh1
2730         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh1,0,1e-12);#deepEqual
2731         self.assertTrue(cellCor==None);
2732         self.assertTrue(nodeCor==None);
2733         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh1,1,1e-12);#fastEqual
2734         self.assertTrue(cellCor==None);
2735         self.assertTrue(nodeCor==None);
2736         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh1,10,1e-12);#deepEqual with geo permutations
2737         self.assertTrue(cellCor==None);
2738         self.assertTrue(nodeCor==None);
2739         #Second test mesh1 and mesh2 are 2 different meshes instance
2740         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,0,1e-12);#deepEqual
2741         self.assertTrue(cellCor==None);
2742         self.assertTrue(nodeCor==None);
2743         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,1,1e-12);#fastEqual
2744         self.assertTrue(cellCor==None);
2745         self.assertTrue(nodeCor==None);
2746         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);#deepEqual with geo permutations
2747         self.assertTrue(cellCor==None);
2748         self.assertTrue(nodeCor==None);
2749         #Third test : cell permutation by keeping the first the middle and the last as it is.
2750         renum=[0,2,1,3,4,5,6,8,7,9]
2751         mesh2.renumberCells(renum,False);
2752         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12);#deepEqual fails
2753         self.assertTrue(cellCor==None);
2754         self.assertTrue(nodeCor==None);
2755         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,1,1e-12);#fastEqual do not see anything
2756         self.assertTrue(cellCor==None);
2757         self.assertTrue(nodeCor==None);
2758         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);#deepEqual with geo permutations
2759         self.assertTrue(cellCor);
2760         self.assertEqual(10,cellCor.getNumberOfTuples());
2761         self.assertEqual(1,cellCor.getNumberOfComponents());
2762         self.assertEqual(renum,list(cellCor.getValues()))
2763         self.assertTrue(nodeCor==None);
2764         cellCor=0;
2765         self.assertTrue(nodeCor==None);
2766         a,b=mesh1.checkDeepEquivalWith(mesh2,0,1e-12);
2767         self.assertEqual(renum,list(a.getValues()))
2768         self.assertTrue(b==None);
2769         mesh2.setCoords(mesh1.getCoords())
2770         a=mesh1.checkDeepEquivalOnSameNodesWith(mesh2,0,1e-12);
2771         self.assertEqual(renum,list(a.getValues()))
2772         #4th test : cell and node permutation by keeping the first the middle and the last as it is.
2773         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2774         renum2=[0,2,1,3,4,5,6,8,7,9,10]
2775         mesh2.renumberCells(renum,False);
2776         mesh2.renumberNodes(renum2,11);
2777         cellCor=None
2778         nodeCor=None
2779         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12);#deepEqual fails
2780         self.assertTrue(cellCor==None);
2781         self.assertTrue(nodeCor==None);
2782         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,1,1e-12);#fastEqual do not see anything
2783         self.assertTrue(cellCor==None);
2784         self.assertTrue(nodeCor==None);
2785         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);#deepEqual with geo permutations
2786         self.assertTrue(cellCor);
2787         self.assertEqual(10,cellCor.getNumberOfTuples());
2788         self.assertEqual(1,cellCor.getNumberOfComponents());
2789         self.assertEqual(renum,list(cellCor.getValues()))
2790         self.assertTrue(nodeCor);
2791         self.assertEqual(11,nodeCor.getNumberOfTuples());
2792         self.assertEqual(1,nodeCor.getNumberOfComponents());
2793         self.assertEqual(renum2,list(nodeCor.getValues()))
2794         cellCor=0;
2795         nodeCor=0;
2796         #5th test : modification of the last cell to check fastCheck detection.
2797         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2798         renum3=[0,2,1,3,4,5,6,8,9,7]
2799         mesh2.renumberCells(renum3,False);
2800         mesh2.renumberNodes(renum2,11);
2801         cellCor=None
2802         nodeCor=None
2803         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12)
2804         self.assertTrue(cellCor==None);
2805         self.assertTrue(nodeCor==None);
2806         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,1,1e-12)
2807         self.assertTrue(cellCor==None);
2808         self.assertTrue(nodeCor==None);
2809         cellCor,nodeCor=mesh2.checkGeoEquivalWith(mesh1,10,1e-12);#deepEqual with geo permutations
2810         self.assertTrue(cellCor!=None);
2811         self.assertEqual(10,cellCor.getNumberOfTuples());
2812         self.assertEqual(1,cellCor.getNumberOfComponents());
2813         self.assertEqual(renum3,list(cellCor.getValues()))
2814         self.assertTrue(nodeCor!=None);
2815         self.assertEqual(11,nodeCor.getNumberOfTuples());
2816         self.assertEqual(1,nodeCor.getNumberOfComponents());
2817         self.assertEqual(renum2,list(nodeCor.getValues()));
2818         pass
2819
2820     def testCheckGeoEquivalWith2(self):
2821         mesh1=MEDCouplingDataForTest.build2DTargetMesh_4();
2822         mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
2823         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);
2824         self.assertEqual(None,cellCor);
2825         self.assertNotEqual(None,nodeCor);
2826         expected1=[0, 1, 3, 4, 5, 6, 7, 8, 9]
2827         for i in xrange(9):
2828             self.assertEqual(expected1[i],nodeCor.getIJ(i,0));
2829             pass
2830         pass
2831
2832     def testSwig2CheckDeepEquivalWith1(self):
2833         eps = 1.0e-8
2834         mcart = MEDCouplingCMesh()
2835         mcart.setCoordsAt(0, DataArrayDouble([0.0,1.5,2.0]))
2836         mcart.setCoordsAt(1, DataArrayDouble([1.0,2.5,3.0,4.0]))
2837         m = mcart.buildUnstructured()
2838         m2 = m[1:m.getNumberOfCells()]
2839         self.assertRaises(InterpKernelException, m.checkDeepEquivalWith, m2, 0, eps)
2840         self.assertRaises(InterpKernelException, m.checkDeepEquivalWith, m2, 1, eps)
2841         self.assertRaises(InterpKernelException, m.checkDeepEquivalWith, m2, 2, eps)
2842         pass
2843
2844     def testSwig2CheckDeepEquivalWith2(self):
2845         eps = 1.0e-8
2846         m = MEDCouplingUMesh("tst", 2)
2847         m.setCoords(DataArrayDouble([], 0,2))
2848         m.setConnectivity(DataArrayInt([]), DataArrayInt([0]))
2849         m2 = m.deepCpy()
2850         m.checkDeepEquivalWith(m2, 0, eps)  # Should not raise!
2851         pass
2852
2853     def testCopyTinyStringsFromOnFields(self):
2854         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2855         nbOfCells=m.getNumberOfCells();
2856         f=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
2857         f.setMesh(m);
2858         self.assertEqual(5,f.getNumberOfMeshPlacesExpected());
2859         f.setName("a");
2860         f.setDescription("b");
2861         a1=DataArrayDouble.New();
2862         a1.alloc(nbOfCells,2);
2863         a1.fillWithZero();
2864         a1.setInfoOnComponent(0,"c");
2865         a1.setInfoOnComponent(1,"d");
2866         a2=a1.deepCpy();
2867         a2.setInfoOnComponent(0,"e");
2868         a2.setInfoOnComponent(1,"f");
2869         f.setArray(a1);
2870         f.setEndArray(a2);
2871         f.setEndTime(3.,3,4);
2872         m.setName("g");
2873         m.getCoords().setInfoOnComponent(0,"h");
2874         m.getCoords().setInfoOnComponent(1,"i");
2875         m.getCoords().setInfoOnComponent(2,"j");
2876         #
2877         f.checkCoherency();
2878         f2=f.clone(True);
2879         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2880         f2.setName("smth");
2881         self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2882         f2.copyTinyStringsFrom(f);
2883         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2884         f2.setDescription("GGG");
2885         self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2886         f2.copyTinyStringsFrom(f);
2887         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2888         f2.getArray().setInfoOnComponent(0,"mmmm");
2889         self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2890         f2.copyTinyStringsFrom(f);
2891         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2892         f2.getEndArray().setInfoOnComponent(1,"mmmm");
2893         self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2894         f2.copyTinyStringsFrom(f);
2895         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2896         m2=m.clone(True);
2897         self.assertTrue(m2.isEqual(m,1e-12));
2898         m2.setName("123");
2899         self.assertTrue(not m2.isEqual(m,1e-12));
2900         m2.copyTinyStringsFrom(m);
2901         self.assertTrue(m2.isEqual(m,1e-12));
2902         m2.getCoords().setInfoOnComponent(1,"eee");
2903         self.assertTrue(not m2.isEqual(m,1e-12));
2904         m2.copyTinyStringsFrom(m);
2905         self.assertTrue(m2.isEqual(m,1e-12));
2906         pass
2907
2908     def testTryToShareSameCoordsPermute(self):
2909         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2910         m2=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2911         #self.assertTrue(m.getCoords()!=m2.getCoords());
2912         m.tryToShareSameCoordsPermute(m2,1e-12);
2913         #self.assertTrue(m.getCoords()==m2.getCoords());
2914         self.assertTrue(m2.isEqual(m,1e-12));
2915         renum1=[1,2,0,5,8,7,4,3,6]
2916         r1=DataArrayInt.New()
2917         r1.setValues(renum1,len(renum1),1)
2918         m.renumberNodes(r1,9);
2919         #self.assertTrue(m.getCoords()!=m2.getCoords());
2920         self.assertTrue(not m2.isEqual(m,1e-12));
2921         m.tryToShareSameCoordsPermute(m2,1e-12);
2922         #self.assertTrue(m.getCoords()==m2.getCoords());
2923         self.assertTrue(m2.isEqual(m,1e-12));
2924         pass
2925
2926     def testTryToShareSameCoordsPermute2(self):
2927         m1=MEDCouplingDataForTest.build2DTargetMesh_4();
2928         targetCoords=[-0.3,-0.3, 0.2,-0.3, -0.3,0.2, 0.2,0.2 ]
2929         targetConn=[0,2,3,1]
2930         m2=MEDCouplingUMesh.New();
2931         m2.setMeshDimension(2);
2932         m2.allocateCells(1);
2933         m2.insertNextCell(NORM_QUAD4,targetConn[0:4])
2934         m2.finishInsertingCells();
2935         myCoords=DataArrayDouble.New();
2936         myCoords.setValues(targetCoords,4,2);
2937         m2.setCoords(myCoords);
2938         m2.checkCoherency();
2939         m1.checkCoherency();
2940         #
2941         expected1=[0.25,0.125,0.125,0.25,0.25]
2942         f1=m1.getMeasureField(False);
2943         f2=m2.getMeasureField(False);
2944         self.assertEqual(5,f1.getArray().getNumberOfTuples());
2945         self.assertEqual(1,f2.getArray().getNumberOfTuples());
2946         for i in xrange(5):
2947             self.assertAlmostEqual(expected1[i],f1.getIJ(i,0),12);
2948             pass
2949         self.assertAlmostEqual(expected1[0],f2.getIJ(0,0),12);
2950         self.assertRaises(InterpKernelException,m1.tryToShareSameCoordsPermute,m2,1e-12);# <- here in this order the sharing is impossible.
2951         # Let's go for deeper test of tryToShareSameCoordsPermute
2952         m2.tryToShareSameCoordsPermute(m1,1e-12);
2953         f1=m1.getMeasureField(False);
2954         f2=m2.getMeasureField(False);
2955         self.assertEqual(5,f1.getArray().getNumberOfTuples());
2956         self.assertEqual(1,f2.getArray().getNumberOfTuples());
2957         for i in xrange(5):
2958             self.assertAlmostEqual(expected1[i],f1.getIJ(i,0),12);
2959             pass
2960         self.assertAlmostEqual(expected1[0],f2.getIJ(0,0),12);
2961         pass
2962
2963     def testChangeUnderlyingMesh1(self):
2964         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2965         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2966         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2967         f1.setMesh(mesh1);
2968         array=DataArrayDouble.New();
2969         arr=[7., 107., 8., 108., 9., 109., 10., 110., 11., 111., 12., 112., 13., 113., 14., 114., 15., 115., 16., 116.]
2970         array.setValues(arr,mesh1.getNumberOfCells(),2);
2971         f1.setArray(array);
2972         #
2973         renum=[0,2,1,3,4,5,6,8,7,9]
2974         mesh2.renumberCells(renum,False);
2975         #self.assertTrue(f1.getMesh()==mesh1);
2976         f1.changeUnderlyingMesh(mesh1,10,1e-12);# nothing done only to check that nothing done.
2977         #self.assertTrue(f1.getMesh()==mesh1);
2978         f1.changeUnderlyingMesh(mesh2,10,1e-12);
2979         #self.assertTrue(f1.getMesh()==mesh2);
2980         expected1=[7.,107.,9.,109.,8.,108.,10.,110.,11.,111.,12.,112.,13.,113.,15.,115.,14.,114.,16.,116.]
2981         for i in xrange(20):
2982             self.assertAlmostEqual(expected1[i],f1.getArray().getIJ(0,i),12);
2983             pass
2984         #
2985         f1=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
2986         f1.setMesh(mesh1);
2987         array=DataArrayDouble.New();
2988         arr2=[7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.,17.,117.]
2989         array.setValues(arr2,mesh1.getNumberOfNodes(),2);
2990         f1.setArray(array);
2991         #
2992         renum2=[0,2,10,3,4,5,6,8,7,9,1]
2993         mesh2.renumberNodes(renum2,11);
2994         #self.assertTrue(f1.getMesh()==mesh1);
2995         f1.changeUnderlyingMesh(mesh2,10,1e-12);
2996         #self.assertTrue(f1.getMesh()==mesh2);
2997         expected2=[7.,107.,17.,117.,8.,108.,10.,110.,11.,111.,12.,112.,13.,113.,15.,115.,14.,114.,16.,116.,9.,109.]
2998         for i in xrange(22):
2999             self.assertAlmostEqual(expected2[i],f1.getArray().getIJ(0,i),12);
3000             pass
3001         pass
3002
3003     def testGetMaxValue1(self):
3004         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
3005         nbOfCells=m.getNumberOfCells();
3006         f=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
3007         f.setMesh(m);
3008         a1=DataArrayDouble.New();
3009         val1=[3.,4.,5.,6.,7.]
3010         a1.setValues(val1,nbOfCells,1);
3011         a2=DataArrayDouble.New();
3012         val2=[0.,1.,2.,8.,7.]
3013         a2.setValues(val2,nbOfCells,1);
3014         f.setArray(a1);
3015         f.setEndArray(a2);
3016         f.setEndTime(3.,3,4);
3017         f.checkCoherency();
3018         #
3019         self.assertAlmostEqual(8.,f.getMaxValue(),14);
3020         self.assertAlmostEqual(0.,f.getMinValue(),14);
3021         self.assertAlmostEqual(5.,f.getAverageValue(),14);
3022         self.assertAlmostEqual(5.125,f.getWeightedAverageValue(0,True),14);
3023         a1.setIJ(0,2,9.5);
3024         self.assertAlmostEqual(9.5,f.getMaxValue(),14);
3025         self.assertAlmostEqual(0.,f.getMinValue(),14);
3026         a2.setIJ(0,0,9.);
3027         self.assertAlmostEqual(9.5,f.getMaxValue(),14);
3028         self.assertAlmostEqual(1.,f.getMinValue(),14);
3029         pass
3030
3031     def testSubstractInPlaceDM1(self):
3032         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
3033         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
3034         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3035         f1.setMesh(mesh1);
3036         array=DataArrayDouble.New();
3037         arr=[7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.]
3038         array.setValues(arr,mesh1.getNumberOfCells(),2);
3039         f1.setArray(array);
3040         #
3041         self.assertEqual(10,f1.getNumberOfTuples());
3042         self.assertEqual(2,f1.getNumberOfComponents());
3043         self.assertEqual(20,f1.getNumberOfValues());
3044         #
3045         renum=[0,2,3,1,4,5,6,8,7,9]
3046         mesh2.renumberCells(renum,False);
3047         #
3048         f2=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3049         f2.setMesh(mesh2);
3050         array=DataArrayDouble.New();
3051         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]
3052         array.setValues(arr2,mesh2.getNumberOfCells(),2);
3053         f2.setArray(array);
3054         #
3055         f1.substractInPlaceDM(f2,10,1e-12);
3056         f1.applyFunc(1,"abs(x+y+0.2)");
3057         self.assertAlmostEqual(0.,f1.getMaxValue(),13);
3058         pass
3059
3060     def testDotCrossProduct1(self):
3061         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
3062         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3063         f1.setTime(2.3,5,6);
3064         f1.setMesh(mesh1);
3065         array=DataArrayDouble.New();
3066         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.]
3067         array.setValues(arr1,mesh1.getNumberOfCells(),3);
3068         f1.setArray(array);
3069         f2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3070         f2.setTime(7.8,4,5);
3071         f2.setMesh(mesh1);
3072         array=DataArrayDouble.New();
3073         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.]
3074         array.setValues(arr2,mesh1.getNumberOfCells(),3);
3075         f2.setArray(array);
3076         #
3077         f3=f1.dot(f2);
3078         expected1=[842.,1820.,2816.,3830.,4862.,5912.,6980.,8066.,9170.,10292.]
3079         for i in xrange(10):
3080             self.assertAlmostEqual(expected1[i],f3.getIJ(i,0),9);
3081             pass
3082         #
3083         f4=f1.crossProduct(f2);
3084         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.]
3085         for i in xrange(30):
3086             self.assertAlmostEqual(expected2[i],f4.getIJ(0,i),9);
3087             pass
3088         pass
3089
3090     def testMinMaxFields1(self):
3091         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
3092         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3093         f1.setTime(2.3,5,6);
3094         f1.setMesh(mesh1);
3095         array=DataArrayDouble.New();
3096         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.]
3097         array.setValues(arr1,mesh1.getNumberOfCells(),3);
3098         f1.setArray(array);
3099         f2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3100         f2.setTime(7.8,4,5);
3101         f2.setMesh(mesh1);
3102         array=DataArrayDouble.New();
3103         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.]
3104         array.setValues(arr2,mesh1.getNumberOfCells(),3);
3105         f2.setArray(array);
3106         #
3107         f3=f1.max(f2);
3108         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.]
3109         for i in xrange(30):
3110             self.assertAlmostEqual(expected1[i],f3.getIJ(0,i),9);
3111             pass
3112         #
3113         f4=f1.min(f2);
3114         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.]
3115         for i in xrange(30):
3116             self.assertAlmostEqual(expected2[i],f4.getIJ(0,i),9);
3117             pass
3118         #
3119         pass
3120
3121     def testApplyLin1(self):
3122         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
3123         f1=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
3124         f1.setMesh(mesh1);
3125         array=DataArrayDouble.New();
3126         arr=[7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.]
3127         array.setValues(arr,mesh1.getNumberOfCells(),2);
3128         f1.setArray(array);
3129         #
3130         f1.applyLin(2.,3.,0);
3131         expected1=[17.,107.,19.,108.,21.,109.,23.,110.,25.,111.,27.,112.,29.,113.,31.,114.,33.,115.,35.,116.]
3132         for i in xrange(20):
3133             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),9);
3134             pass
3135         #
3136         arr2=[2.,102.,3.,103.,4.,104.,5.,105.,6.,106.,7.,107.,8.,108.,9.,109.,10.,110.,11.,111.]
3137         array=DataArrayDouble.New();
3138         array.setValues(arr2,mesh1.getNumberOfCells(),2);
3139         f1.setEndArray(array);
3140         #
3141         f1.applyLin(4.,5.,1);
3142         #
3143         expected2=[17.,433.,19.,437.,21.,441.,23.,445.,25.,449.,27.,453.,29.,457.,31.,461.,33.,465.,35.,469.]
3144         for i in xrange(20):
3145             self.assertAlmostEqual(expected2[i],f1.getIJ(0,i),9);
3146             pass
3147         expected3=[2.,413.,3.,417.,4.,421.,5.,425.,6.,429.,7.,433.,8.,437.,9.,441.,10.,445.,11.,449.]
3148         for i in xrange(20):
3149             self.assertAlmostEqual(expected3[i],f1.getEndArray().getIJ(0,i),9);
3150             pass
3151         #
3152         pass
3153
3154     def testGetIdsInRange1(self):
3155         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
3156         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3157         f1.setTime(2.3,5,6);
3158         f1.setMesh(mesh1);
3159         array=DataArrayDouble.New();
3160         arr1=[2.,8.,6.,5.,11.,7.,9.,3.,10.,4.]
3161         array.setValues(arr1,mesh1.getNumberOfCells(),1);
3162         f1.setArray(array);
3163         #
3164         f1.checkCoherency();
3165         da=f1.getIdsInRange(2.9,7.1);
3166         self.failUnlessEqual(5,da.getNbOfElems());
3167         expected1=[2,3,5,7,9]
3168         self.failUnlessEqual(expected1,list(da.getValues()));
3169         da=f1.getIdsInRange(8.,12.);
3170         self.failUnlessEqual(4,da.getNbOfElems());
3171         expected2=[1,4,6,8]
3172         self.failUnlessEqual(expected2,list(da.getValues()));
3173         #
3174         pass
3175
3176     def testBuildSubPart1(self):
3177         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3178         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3179         f1.setTime(2.3,5,6);
3180         f1.setMesh(mesh1);
3181         array=DataArrayDouble.New();
3182         arr1=[3.,103.,4.,104.,5.,105.,6.,106.,7.,107.]
3183         array.setValues(arr1,mesh1.getNumberOfCells(),2);
3184         f1.setArray(array);
3185         #
3186         part1=[2,1,4]
3187         f2=f1[part1];
3188         f2.zipCoords()
3189         self.failUnlessEqual(3,f2.getNumberOfTuples());
3190         self.failUnlessEqual(2,f2.getNumberOfComponents());
3191         expected1=[5.,105.,4.,104.,7.,107.]
3192         for i in xrange(6):
3193             self.assertAlmostEqual(f2.getIJ(0,i),expected1[i],12);
3194             pass
3195         self.failUnlessEqual(3,f2.getMesh().getNumberOfCells());
3196         self.failUnlessEqual(6,f2.getMesh().getNumberOfNodes());
3197         self.failUnlessEqual(2,f2.getMesh().getSpaceDimension());
3198         self.failUnlessEqual(2,f2.getMesh().getMeshDimension());
3199         m2C=f2.getMesh();
3200         self.failUnlessEqual(13,m2C.getMeshLength());
3201         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]
3202         for i in xrange(12):
3203             self.assertAlmostEqual(expected2[i],m2C.getCoords().getIJ(0,i),12);
3204             pass
3205         expected3=[3,2,3,1,3,0,2,1,4,4,5,3,2]
3206         self.failUnlessEqual(expected3,list(m2C.getNodalConnectivity().getValues()));
3207         expected4=[0,4,8,13]
3208         self.failUnlessEqual(expected4,list(m2C.getNodalConnectivityIndex().getValues()));
3209         # Test with field on nodes.
3210         f1=MEDCouplingFieldDouble.New(ON_NODES,ONE_TIME);
3211         f1.setTime(2.3,5,6);
3212         f1.setMesh(mesh1);
3213         array=DataArrayDouble.New();
3214         arr2=[3.,103.,4.,104.,5.,105.,6.,106.,7.,107.,8.,108.,9.,109.,10.,110.,11.,111.]
3215         array.setValues(arr2,mesh1.getNumberOfNodes(),2);
3216         f1.setArray(array);
3217         part2=[1,2]
3218         f2=f1.buildSubPart(part2);
3219         self.failUnlessEqual(4,f2.getNumberOfTuples());
3220         self.failUnlessEqual(2,f2.getNumberOfComponents());
3221         expected5=[4.,104.,5.,105.,7.,107.,8.,108.]
3222         for i in xrange(8):
3223             self.assertAlmostEqual(f2.getIJ(0,i),expected5[i],12);
3224             pass
3225         self.failUnlessEqual(2,f2.getMesh().getNumberOfCells());
3226         self.failUnlessEqual(4,f2.getMesh().getNumberOfNodes());
3227         self.failUnlessEqual(2,f2.getMesh().getSpaceDimension());
3228         self.failUnlessEqual(2,f2.getMesh().getMeshDimension());
3229         m2C=f2.getMesh();
3230         self.failUnlessEqual(8,m2C.getMeshLength());
3231         for i in xrange(8):#8 is not an error
3232             self.assertAlmostEqual(expected2[i],m2C.getCoords().getIJ(0,i),12);
3233             pass
3234         self.failUnlessEqual(expected3[:4],list(m2C.getNodalConnectivity().getValues())[4:]);
3235         self.failUnlessEqual(expected3[4:8],list(m2C.getNodalConnectivity().getValues())[:4]);
3236         self.failUnlessEqual(expected4[:3],list(m2C.getNodalConnectivityIndex().getValues()));
3237         #idem previous because nodes of cell#4 are not fully present in part3
3238         part3=[1,2]
3239         arrr=DataArrayInt.New();
3240         arrr.setValues(part3,2,1);
3241         f2=f1.buildSubPart(arrr);
3242         self.failUnlessEqual(4,f2.getNumberOfTuples());
3243         self.failUnlessEqual(2,f2.getNumberOfComponents());
3244         for i in xrange(8):
3245             self.assertAlmostEqual(f2.getIJ(0,i),expected5[i],12);
3246             pass
3247         self.failUnlessEqual(2,f2.getMesh().getNumberOfCells());
3248         self.failUnlessEqual(4,f2.getMesh().getNumberOfNodes());
3249         self.failUnlessEqual(2,f2.getMesh().getSpaceDimension());
3250         self.failUnlessEqual(2,f2.getMesh().getMeshDimension());
3251         m2C=f2.getMesh();
3252         self.failUnlessEqual(8,m2C.getMeshLength());
3253         for i in xrange(8):#8 is not an error
3254             self.assertAlmostEqual(expected2[i],m2C.getCoords().getIJ(0,i),12);
3255             pass
3256         self.failUnlessEqual(expected3[:4],list(m2C.getNodalConnectivity().getValues())[4:8]);
3257         self.failUnlessEqual(expected3[4:8],list(m2C.getNodalConnectivity().getValues())[:4]);
3258         self.failUnlessEqual(expected4[:3],list(m2C.getNodalConnectivityIndex().getValues()));
3259         #
3260         part4=[1,2,4]
3261         f2=f1.buildSubPart(part4);
3262         self.failUnlessEqual(6,f2.getNumberOfTuples());
3263         self.failUnlessEqual(2,f2.getNumberOfComponents());
3264         expected6=[4.,104.,5.,105.,7.,107.,8.,108.,10.,110.,11.,111.]
3265         for i in xrange(12):
3266             self.assertAlmostEqual(f2.getIJ(0,i),expected6[i],12);
3267             pass
3268         self.failUnlessEqual(3,f2.getMesh().getNumberOfCells());
3269         self.failUnlessEqual(6,f2.getMesh().getNumberOfNodes());
3270         self.failUnlessEqual(2,f2.getMesh().getSpaceDimension());
3271         self.failUnlessEqual(2,f2.getMesh().getMeshDimension());
3272         m2C=f2.getMesh();
3273         self.failUnlessEqual(13,m2C.getMeshLength());
3274         for i in xrange(12):
3275             self.assertAlmostEqual(expected2[i],m2C.getCoords().getIJ(0,i),12);
3276             pass
3277         self.failUnlessEqual(expected3[0:4],list(m2C.getNodalConnectivity().getValues())[4:8]);
3278         self.failUnlessEqual(expected3[4:8],list(m2C.getNodalConnectivity().getValues())[0:4]);
3279         self.failUnlessEqual(expected3[8:13],list(m2C.getNodalConnectivity().getValues())[8:13]);
3280         self.failUnlessEqual(expected4,list(m2C.getNodalConnectivityIndex().getValues()));
3281         pass
3282
3283     def testDoublyContractedProduct1(self):
3284         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3285         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3286         f1.setMesh(mesh1);
3287         array=DataArrayDouble.New();
3288         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]
3289         array.setValues(arr1,mesh1.getNumberOfCells(),6);
3290         f1.setArray(array);
3291         f1.checkCoherency();
3292         #
3293         f2=f1.doublyContractedProduct();
3294         f2.checkCoherency();
3295         self.assertEqual(1,f2.getNumberOfComponents());
3296         self.assertEqual(5,f2.getNumberOfTuples());
3297         for i in xrange(5):
3298             self.assertAlmostEqual(3906.56,f2.getIJ(i,0),9);
3299             pass
3300         #
3301         pass
3302
3303     def testDeterminant1(self):
3304         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3305         f1=MEDCouplingFieldDouble.New(ON_CELLS,CONST_ON_TIME_INTERVAL);
3306         f1.setTime(2.3,5,6);
3307         f1.setEndTime(3.8,7,3);
3308         f1.setMesh(mesh1);
3309         array=DataArrayDouble.New();
3310         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]
3311         array.setValues(arr1,mesh1.getNumberOfCells(),4);
3312         f1.setArray(array);
3313         #4 components
3314         f1.checkCoherency();
3315         f2=f1.determinant();
3316         f2.checkCoherency();
3317         self.assertEqual(CONST_ON_TIME_INTERVAL,f2.getTimeDiscretization());
3318         self.assertEqual(1,f2.getNumberOfComponents());
3319         self.assertEqual(5,f2.getNumberOfValues());
3320         for i in xrange(5):
3321             self.assertAlmostEqual(-2.42,f2.getIJ(i,0),13);
3322             pass
3323         #6 components multi arrays with end array not defined
3324         f1=MEDCouplingFieldDouble.New(ON_NODES,LINEAR_TIME);
3325         f1.setTime(2.3,5,6);
3326         f1.setEndTime(3.8,7,3);
3327         f1.setMesh(mesh1);
3328         array=DataArrayDouble.New();
3329         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,
3330               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]
3331         array.setValues(arr2,mesh1.getNumberOfNodes(),6);
3332         f1.setArray(array);
3333         self.assertRaises(InterpKernelException,f1.checkCoherency);#no end array specified !
3334         #
3335         f2=f1.determinant();
3336         self.assertEqual(LINEAR_TIME,f2.getTimeDiscretization());
3337         self.assertEqual(1,f2.getArray().getNumberOfComponents());
3338         self.assertEqual(9,f2.getNumberOfTuples());
3339         for i in xrange(9):
3340             self.assertAlmostEqual(137.335,f2.getIJ(i,0),10);
3341             pass
3342         #6 components multi arrays with end array defined
3343         array=DataArrayDouble.New();
3344         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,
3345               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]
3346         array.setValues(arr3,mesh1.getNumberOfNodes(),6);
3347         f1.setEndArray(array);
3348         f1.checkCoherency();
3349         f2=f1.determinant();
3350         f2.checkCoherency();
3351         self.assertEqual(LINEAR_TIME,f2.getTimeDiscretization());
3352         self.assertEqual(1,f2.getNumberOfComponents());
3353         self.assertEqual(9,f2.getNumberOfTuples());
3354         time2,it,order=f2.getTime()
3355         self.assertAlmostEqual(2.3,time2,12);
3356         self.assertEqual(5,it);
3357         self.assertEqual(6,order);
3358         time2,it,order=f2.getEndTime()
3359         self.assertAlmostEqual(3.8,time2,12);
3360         self.assertEqual(7,it);
3361         self.assertEqual(3,order);
3362         for i in xrange(9):
3363             self.assertAlmostEqual(137.335,f2.getIJ(i,0),10);
3364             self.assertAlmostEqual(1289.685,f2.getEndArray().getIJ(i,0),9);
3365             pass
3366         #9 components
3367         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3368         f1.setTime(7.8,10,2);
3369         f1.setMesh(mesh1);
3370         array=DataArrayDouble.New();
3371         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]
3372         array.setValues(arr4,mesh1.getNumberOfCells(),9);
3373         f1.setArray(array);
3374         #
3375         f1.checkCoherency();
3376         f2=f1.determinant();
3377         f2.checkCoherency();
3378         self.assertEqual(ONE_TIME,f2.getTimeDiscretization());
3379         self.assertEqual(1,f2.getNumberOfComponents());
3380         self.assertEqual(5,f2.getNumberOfTuples());
3381         time2,it,order=f2.getTime()
3382         self.assertAlmostEqual(7.8,time2,12);
3383         self.assertEqual(10,it);
3384         self.assertEqual(2,order);
3385         for i in xrange(5):
3386             self.assertAlmostEqual(3.267,f2.getIJ(i,0),13);
3387             pass
3388         pass
3389
3390     def testEigenValues1(self):
3391         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3392         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3393         f1.setMesh(mesh1);
3394         array=DataArrayDouble.New();
3395         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]
3396         array.setValues(arr1,mesh1.getNumberOfCells(),6);
3397         f1.setArray(array);
3398         f1.checkCoherency();
3399         #
3400         f2=f1.eigenValues();
3401         f2.checkCoherency();
3402         self.assertEqual(3,f2.getNumberOfComponents());
3403         self.assertEqual(5,f2.getNumberOfTuples());
3404         expected1=[13.638813677891717,-4.502313844635971,-2.2364998332557486]
3405         for i in xrange(5):
3406             self.assertAlmostEqual(expected1[0],f2.getIJ(i,0),13);
3407             self.assertAlmostEqual(expected1[1],f2.getIJ(i,1),13);
3408             self.assertAlmostEqual(expected1[2],f2.getIJ(i,2),13);
3409             pass
3410         pass
3411
3412     def testEigenVectors1(self):
3413         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3414         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3415         f1.setMesh(mesh1);
3416         array=DataArrayDouble.New();
3417         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]
3418         array.setValues(arr1,mesh1.getNumberOfCells(),6);
3419         f1.setArray(array);
3420         f1.checkCoherency();
3421         #
3422         f2=f1.eigenVectors();
3423         f2.checkCoherency();
3424         self.assertEqual(9,f2.getNumberOfComponents());
3425         self.assertEqual(5,f2.getNumberOfTuples());
3426         expected1=[0.5424262364180696, 0.5351201064614425, 0.6476266283176001,#eigenvect 0
3427                    0.7381111277307373, 0.06458838384003074, -0.6715804522117897,#eigenvect 1
3428                    -0.4012053603397987, 0.8423032781211455, -0.3599436712889738#eigenvect 2
3429                    ]
3430         for i in xrange(5):
3431             self.assertAlmostEqual(expected1[0],f2.getIJ(i,0),13);
3432             self.assertAlmostEqual(expected1[1],f2.getIJ(i,1),13);
3433             self.assertAlmostEqual(expected1[2],f2.getIJ(i,2),13);
3434             self.assertAlmostEqual(expected1[3],f2.getIJ(i,3),13);
3435             self.assertAlmostEqual(expected1[4],f2.getIJ(i,4),13);
3436             self.assertAlmostEqual(expected1[5],f2.getIJ(i,5),13);
3437             self.assertAlmostEqual(expected1[6],f2.getIJ(i,6),13);
3438             self.assertAlmostEqual(expected1[7],f2.getIJ(i,7),13);
3439             self.assertAlmostEqual(expected1[8],f2.getIJ(i,8),13);
3440             pass
3441         #
3442         pass
3443
3444     def testInverse1(self):
3445         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3446         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3447         f1.setMesh(mesh1);
3448         array=DataArrayDouble.New();
3449         arr1=[1.2,2.3,3.4,4.5,5.6,6.7,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]
3450         array.setValues(arr1,mesh1.getNumberOfCells(),9);
3451         f1.setArray(array);
3452         f1.checkCoherency();
3453         #
3454         f2=f1.inverse();
3455         f2.checkCoherency();
3456         self.assertEqual(9,f2.getNumberOfComponents());
3457         self.assertEqual(5,f2.getNumberOfTuples());
3458         expected1=[-2.6538108356290113, 2.855831037649208, -1.1111111111111067, 3.461891643709813, -4.775022956841121, 2.2222222222222143, -1.1111111111111054, 2.222222222222214, -1.1111111111111072]
3459         for i in xrange(5):
3460             self.assertAlmostEqual(expected1[0],f2.getIJ(i,0),13);
3461             self.assertAlmostEqual(expected1[1],f2.getIJ(i,1),13);
3462             self.assertAlmostEqual(expected1[2],f2.getIJ(i,2),13);
3463             self.assertAlmostEqual(expected1[3],f2.getIJ(i,3),13);
3464             self.assertAlmostEqual(expected1[4],f2.getIJ(i,4),13);
3465             self.assertAlmostEqual(expected1[5],f2.getIJ(i,5),13);
3466             self.assertAlmostEqual(expected1[6],f2.getIJ(i,6),13);
3467             self.assertAlmostEqual(expected1[7],f2.getIJ(i,7),13);
3468             self.assertAlmostEqual(expected1[8],f2.getIJ(i,8),13);
3469             pass
3470         #
3471         array=DataArrayDouble.New();
3472         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]
3473         array.setValues(arr3,mesh1.getNumberOfCells(),6);
3474         f1.setArray(array);
3475         f1.checkCoherency();
3476         #
3477         f2=f1.inverse();
3478         f2.checkCoherency();
3479         self.assertEqual(6,f2.getNumberOfComponents());
3480         self.assertEqual(5,f2.getNumberOfTuples());
3481         expected3=[-0.3617705098531818, -0.8678630828458127, -0.026843764174972983, 0.5539957431465833, 0.13133439560823013, -0.05301294502145887]
3482         for i in xrange(5):
3483             self.assertAlmostEqual(expected3[0],f2.getIJ(i,0),13);
3484             self.assertAlmostEqual(expected3[1],f2.getIJ(i,1),13);
3485             self.assertAlmostEqual(expected3[2],f2.getIJ(i,2),13);
3486             self.assertAlmostEqual(expected3[3],f2.getIJ(i,3),13);
3487             self.assertAlmostEqual(expected3[4],f2.getIJ(i,4),13);
3488             self.assertAlmostEqual(expected3[5],f2.getIJ(i,5),13);
3489             pass
3490         #
3491         array=DataArrayDouble.New();
3492         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]
3493         array.setValues(arr2,mesh1.getNumberOfCells(),4);
3494         f1.setArray(array);
3495         f1.checkCoherency();
3496         #
3497         f2=f1.inverse();
3498         f2.checkCoherency();
3499         self.assertEqual(4,f2.getNumberOfComponents());
3500         self.assertEqual(5,f2.getNumberOfTuples());
3501         expected2=[-1.8595041322314059, 0.9504132231404963, 1.404958677685951, -0.49586776859504156]
3502         for i in xrange(5):
3503             self.assertAlmostEqual(expected2[0],f2.getIJ(i,0),13);
3504             self.assertAlmostEqual(expected2[1],f2.getIJ(i,1),13);
3505             self.assertAlmostEqual(expected2[2],f2.getIJ(i,2),13);
3506             self.assertAlmostEqual(expected2[3],f2.getIJ(i,3),13);
3507             pass
3508         #
3509         pass
3510
3511     def testTrace1(self):
3512         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3513         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3514         f1.setMesh(mesh1);
3515         array=DataArrayDouble.New();
3516         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]
3517         array.setValues(arr1,mesh1.getNumberOfCells(),9);
3518         f1.setArray(array);
3519         f1.checkCoherency();
3520         #
3521         f2=f1.trace();
3522         f2.checkCoherency();
3523         self.assertEqual(1,f2.getNumberOfComponents());
3524         self.assertEqual(5,f2.getNumberOfTuples());
3525         for i in xrange(5):
3526             self.assertAlmostEqual(15.9,f2.getIJ(i,0),13);
3527             pass
3528         #
3529         array=DataArrayDouble.New();
3530         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]
3531         array.setValues(arr3,mesh1.getNumberOfCells(),6);
3532         f1.setArray(array);
3533         f1.checkCoherency();
3534         #
3535         f2=f1.trace();
3536         f2.checkCoherency();
3537         self.assertEqual(1,f2.getNumberOfComponents());
3538         self.assertEqual(5,f2.getNumberOfTuples());
3539         for i in xrange(5):
3540             self.assertAlmostEqual(25.8,f2.getIJ(i,0),13);
3541             pass
3542         #
3543         array=DataArrayDouble.New();
3544         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]
3545         array.setValues(arr2,mesh1.getNumberOfCells(),4);
3546         f1.setArray(array);
3547         f1.checkCoherency();
3548         #
3549         f2=f1.trace();
3550         f2.checkCoherency();
3551         self.assertEqual(1,f2.getNumberOfComponents());
3552         self.assertEqual(5,f2.getNumberOfTuples());
3553         for i in xrange(5):
3554             self.assertAlmostEqual(5.7,f2.getIJ(i,0),13);
3555             pass
3556         #
3557         pass
3558
3559     def testDeviator1(self):
3560         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3561         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3562         f1.setMesh(mesh1);
3563         array=DataArrayDouble.New();
3564         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]
3565         array.setValues(arr1,mesh1.getNumberOfCells(),6);
3566         f1.setArray(array);
3567         f1.checkCoherency();
3568         #
3569         f2=f1.deviator();
3570         f2.checkCoherency();
3571         self.assertEqual(6,f2.getNumberOfComponents());
3572         self.assertEqual(5,f2.getNumberOfTuples());
3573         expected1=[-1.1,0.,1.1,4.5,5.6,6.7]
3574         for i in xrange(5):
3575             self.assertAlmostEqual(expected1[0],f2.getIJ(i,0),13);
3576             self.assertAlmostEqual(expected1[1],f2.getIJ(i,1),13);
3577             self.assertAlmostEqual(expected1[2],f2.getIJ(i,2),13);
3578             self.assertAlmostEqual(expected1[3],f2.getIJ(i,3),13);
3579             self.assertAlmostEqual(expected1[4],f2.getIJ(i,4),13);
3580             self.assertAlmostEqual(expected1[5],f2.getIJ(i,5),13);
3581             pass
3582         #
3583         pass
3584
3585     def testMagnitude1(self):
3586         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3587         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3588         f1.setMesh(mesh1);
3589         array=DataArrayDouble.New();
3590         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]
3591         array.setValues(arr1,mesh1.getNumberOfCells(),5);
3592         f1.setArray(array);
3593         f1.checkCoherency();
3594         #
3595         f2=f1.magnitude();
3596         f2.checkCoherency();
3597         self.assertEqual(1,f2.getNumberOfComponents());
3598         self.assertEqual(5,f2.getNumberOfTuples());
3599         for i in xrange(5):
3600             self.assertAlmostEqual(8.3606219864313918,f2.getIJ(i,0),13);
3601             pass
3602         #
3603         pass
3604
3605     def testMaxPerTuple1(self):
3606         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3607         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3608         f1.setMesh(mesh1);
3609         array=DataArrayDouble.New();
3610         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]
3611         array.setValues(arr1,mesh1.getNumberOfCells(),5);
3612         f1.setArray(array);
3613         f1.checkCoherency();
3614         #
3615         f2=f1.maxPerTuple();
3616         f2.checkCoherency();
3617         self.assertEqual(1,f2.getNumberOfComponents());
3618         self.assertEqual(5,f2.getNumberOfTuples());
3619         for i in xrange(5):
3620             self.assertAlmostEqual(5.6,f2.getIJ(i,0),13);
3621             pass
3622         #
3623         d2,d2I=array.maxPerTupleWithCompoId()
3624         self.assertEqual(1,d2.getNumberOfComponents());
3625         self.assertEqual(5,d2.getNumberOfTuples());
3626         for i in xrange(5):
3627             self.assertAlmostEqual(5.6,d2.getIJ(i,0),13);
3628             pass
3629         self.assertTrue(d2I.isEqual(DataArrayInt([4,3,2,0,1])))
3630         pass
3631
3632     def testChangeNbOfComponents(self):
3633         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3634         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3635         f1.setMesh(mesh1);
3636         array=DataArrayDouble.New();
3637         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]
3638         array.setValues(arr1,mesh1.getNumberOfCells(),5);
3639         f1.setArray(array);
3640         f1.checkCoherency();
3641         #
3642         f1.changeNbOfComponents(3,7.77);
3643         f1.checkCoherency();
3644         self.assertEqual(3,f1.getNumberOfComponents());
3645         self.assertEqual(5,f1.getNumberOfTuples());
3646         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]
3647         for i in xrange(15):
3648             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),13);
3649             pass
3650         f1.changeNbOfComponents(4,7.77);
3651         f1.checkCoherency();
3652         self.assertEqual(4,f1.getNumberOfComponents());
3653         self.assertEqual(5,f1.getNumberOfTuples());
3654         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]
3655         for i in xrange(20):
3656             self.assertAlmostEqual(expected2[i],f1.getIJ(0,i),13);
3657             pass
3658         #
3659         pass
3660
3661     def testSortPerTuple1(self):
3662         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3663         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3664         f1.setMesh(mesh1);
3665         array=DataArrayDouble.New();
3666         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]
3667         array.setValues(arr1,mesh1.getNumberOfCells(),5);
3668         f1.setArray(array);
3669         f1.checkCoherency();
3670         #
3671         f1.sortPerTuple(True);
3672         f1.checkCoherency();
3673         self.assertEqual(5,f1.getNumberOfComponents());
3674         self.assertEqual(5,f1.getNumberOfTuples());
3675         for i in xrange(5):
3676             self.assertAlmostEqual(arr1[0],f1.getIJ(i,0),13);
3677             self.assertAlmostEqual(arr1[1],f1.getIJ(i,1),13);
3678             self.assertAlmostEqual(arr1[2],f1.getIJ(i,2),13);
3679             self.assertAlmostEqual(arr1[3],f1.getIJ(i,3),13);
3680             self.assertAlmostEqual(arr1[4],f1.getIJ(i,4),13);
3681             pass
3682         #
3683         f1.sortPerTuple(False);
3684         f1.checkCoherency();
3685         self.assertEqual(5,f1.getNumberOfComponents());
3686         self.assertEqual(5,f1.getNumberOfTuples());
3687         for i in xrange(5):
3688             self.assertAlmostEqual(arr1[4],f1.getIJ(i,0),13);
3689             self.assertAlmostEqual(arr1[3],f1.getIJ(i,1),13);
3690             self.assertAlmostEqual(arr1[2],f1.getIJ(i,2),13);
3691             self.assertAlmostEqual(arr1[1],f1.getIJ(i,3),13);
3692             self.assertAlmostEqual(arr1[0],f1.getIJ(i,4),13);
3693             pass
3694         #
3695         pass
3696
3697     def testIsEqualWithoutConsideringStr1(self):
3698         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3699         mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
3700         #
3701         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3702         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3703         mesh2.setName("rr");
3704         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
3705         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3706         da1,da2=mesh1.checkGeoEquivalWith(mesh2,2,1e-12);
3707         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12);
3708         mesh2.setName("");
3709         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3710         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3711         mesh2.getCoords().setInfoOnComponent(0,"tty");
3712         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
3713         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3714         mesh2.getCoords().setInfoOnComponent(0,"");
3715         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3716         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3717         mesh2.getCoords().setInfoOnComponent(1,"tty");
3718         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
3719         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3720         mesh2.getCoords().setInfoOnComponent(1,"");
3721         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3722         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3723         tmp=mesh2.getCoords().getIJ(0,3);
3724         mesh2.getCoords().setIJ(0,3,9999.);
3725         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
3726         self.assertTrue(not mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3727         mesh2.getCoords().setIJ(0,3,tmp);
3728         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3729         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3730         tmp2=mesh2.getNodalConnectivity().getIJ(0,4);
3731         mesh2.getNodalConnectivity().setIJ(0,4,0);
3732         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
3733         self.assertTrue(not mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3734         mesh2.getNodalConnectivity().setIJ(0,4,tmp2);
3735         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3736         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3737         #
3738         f1=mesh1.getMeasureField(True);
3739         f2=mesh2.getMeasureField(True);
3740         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
3741         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3742         f2.setName("ftest");
3743         self.assertTrue(not f1.isEqual(f2,1e-12,1e-12));
3744         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3745         f1.setName("ftest");
3746         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
3747         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3748         #
3749         f2.getArray().setInfoOnComponent(0,"eee");
3750         self.assertTrue(not f1.isEqual(f2,1e-12,1e-12));
3751         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3752         f2.getArray().setInfoOnComponent(0,"");
3753         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
3754         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3755         #
3756         f2.getArray().setIJ(1,0,0.123);
3757         self.assertTrue(not f1.isEqual(f2,1e-12,1e-12));
3758         self.assertTrue(not f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3759         f2.getArray().setIJ(1,0,0.125);
3760         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
3761         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3762         #
3763         pass
3764
3765     def testGetNodeIdsOfCell1(self):
3766         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3767         li=mesh1.getNodeIdsOfCell(1)
3768         expected1=[1, 4, 2]
3769         self.assertEqual(expected1,list(li))
3770         li=mesh1.getCoordinatesOfNode(4)
3771         self.assertEqual(2,len(li))
3772         self.assertAlmostEqual(0.2,li[0],13);
3773         self.assertAlmostEqual(0.2,li[1],13);
3774         li=mesh1.getCoords().getValuesAsTuple()
3775         self.assertEqual(9,len(li))
3776         li2=mesh1.getNodalConnectivityIndex().getValuesAsTuple()
3777         self.assertEqual(6,len(li2))
3778         pass
3779
3780     def testGetEdgeRatioField1(self):
3781         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
3782         m1.setTime(3.4,5,6); m1.setTimeUnit("us");
3783         f1=m1.getEdgeRatioField();
3784         self.assertAlmostEqual(3.4,f1.getTime()[0],12) ; self.assertEqual(5,f1.getTime()[1]) ; self.assertEqual(6,f1.getTime()[2])
3785         self.assertEqual("us",f1.getTimeUnit())
3786         self.assertEqual(m1.getNumberOfCells(),f1.getNumberOfTuples());
3787         self.assertEqual(5,f1.getNumberOfTuples());
3788         self.assertEqual(1,f1.getNumberOfComponents());
3789         expected1=[1.,1.4142135623730951, 1.4142135623730951,1.,1.]
3790         for i in xrange(5):
3791             self.assertAlmostEqual(expected1[i],f1.getIJ(i,0),14);
3792             pass
3793         #
3794         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
3795         f1=m1.getEdgeRatioField();
3796         self.assertEqual(m1.getNumberOfCells(),f1.getNumberOfTuples());
3797         self.assertEqual(5,f1.getNumberOfTuples());
3798         self.assertEqual(1,f1.getNumberOfComponents());
3799         expected2=[1.4142135623730951, 1.7320508075688772, 1.7320508075688772, 1.4142135623730951, 1.4142135623730951]
3800         for i in xrange(5):
3801             self.assertAlmostEqual(expected2[i],f1.getIJ(i,0),14);
3802             pass
3803         pass
3804
3805     def testFillFromAnalytic3(self):
3806         m=MEDCouplingDataForTest.build2DTargetMesh_1()
3807         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME)
3808         self.assertRaises(InterpKernelException,f1.fillFromAnalytic,1,"y+x");
3809         f1.setMesh(m)
3810         f1.setName("myField");
3811         f1.fillFromAnalytic(1,"y+x");
3812         f1.checkCoherency();
3813         self.assertEqual(f1.getName(),"myField");
3814         self.assertEqual(f1.getTypeOfField(),ON_CELLS);
3815         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
3816         self.assertEqual(1,f1.getNumberOfComponents());
3817         self.assertEqual(5,f1.getNumberOfTuples());
3818         values1=[-0.1,0.23333333333333336,0.56666666666666665,0.4,0.9]
3819         tmp=f1.getArray().getValues();
3820         self.assertEqual(len(values1),len(tmp))
3821         for i in xrange(len(values1)):
3822             self.assertTrue(abs(values1[i]-tmp[i])<1.e-12);
3823             pass
3824         #
3825         f1=MEDCouplingFieldDouble.New(ON_NODES,CONST_ON_TIME_INTERVAL)
3826         f1.setMesh(m)
3827         f1.fillFromAnalytic(1,"y+2*x");
3828         f1.setEndTime(1.2,3,4);
3829         f1.checkCoherency();
3830         self.assertEqual(f1.getTypeOfField(),ON_NODES);
3831         self.assertEqual(f1.getTimeDiscretization(),CONST_ON_TIME_INTERVAL);
3832         self.assertEqual(1,f1.getNumberOfComponents());
3833         self.assertEqual(9,f1.getNumberOfTuples());
3834         values2=[-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1]
3835         tmp=f1.getArray().getValues();
3836         self.assertEqual(len(values2),len(tmp))
3837         for i in xrange(len(values2)):
3838             self.assertTrue(abs(values2[i]-tmp[i])<1.e-12);
3839             pass
3840         f1=MEDCouplingFieldDouble.New(ON_NODES,LINEAR_TIME);
3841         f1.setMesh(m)
3842         f1.fillFromAnalytic(1,"2.*x+y");
3843         f1.setEndTime(1.2,3,4);
3844         f1.checkCoherency();
3845         self.assertEqual(f1.getTypeOfField(),ON_NODES);
3846         self.assertEqual(f1.getTimeDiscretization(),LINEAR_TIME);
3847         self.assertEqual(1,f1.getNumberOfComponents());
3848         self.assertEqual(9,f1.getNumberOfTuples());
3849         tmp=f1.getArray().getValues();
3850         values2Bis=[-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1]
3851         self.assertEqual(len(values2Bis),len(tmp))
3852         for i in xrange(len(values2Bis)):
3853             self.assertTrue(abs(values2Bis[i]-tmp[i])<1.e-12);
3854             pass
3855         tmp=f1.getEndArray().getValues();
3856         self.assertEqual(len(values2Bis),len(tmp))
3857         for i in xrange(len(values2Bis)):
3858             self.assertTrue(abs(values2Bis[i]-tmp[i])<1.e-12);
3859             pass
3860         #
3861         f1=MEDCouplingFieldDouble.New(ON_NODES,ONE_TIME);
3862         f1.setMesh(m)
3863         f1.fillFromAnalytic(2,"(x+y)*IVec+2*(x+y)*JVec");
3864         f1.checkCoherency();
3865         self.assertEqual(f1.getTypeOfField(),ON_NODES);
3866         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
3867         self.assertEqual(2,f1.getNumberOfComponents());
3868         self.assertEqual(9,f1.getNumberOfTuples());
3869         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]
3870         tmp=f1.getArray().getValues();
3871         self.assertEqual(len(values3),len(tmp))
3872         for i in xrange(len(values3)):
3873             self.assertTrue(abs(values3[i]-tmp[i])<1.e-12);
3874             pass
3875         values4=f1.accumulate();
3876         self.assertTrue(abs(3.6-values4[0])<1.e-12);
3877         self.assertTrue(abs(7.2-values4[1])<1.e-12);
3878         values4=f1.integral(True);
3879         self.assertTrue(abs(0.5-values4[0])<1.e-12);
3880         self.assertTrue(abs(1.-values4[1])<1.e-12);
3881         #
3882         f1=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
3883         f1.setMesh(m);
3884         self.assertRaises(InterpKernelException,f1.fillFromAnalytic,1,"1./(x-0.2)");
3885         pass
3886
3887     def testFieldDoubleOpEqual1(self):
3888         m=MEDCouplingDataForTest.build2DTargetMesh_1();
3889         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3890         self.assertRaises(InterpKernelException,f1.assign,0.07);
3891         f1.setMesh(m);
3892         f1.assign(0.07);
3893         f1.checkCoherency();
3894         self.assertEqual(1,f1.getNumberOfComponents());
3895         self.assertEqual(5,f1.getNumberOfTuples());
3896         for i in xrange(5):
3897             self.assertAlmostEqual(0.07,f1.getIJ(i,0),16);
3898             pass
3899         f1.assign(0.09);
3900         f1.checkCoherency();
3901         self.assertEqual(1,f1.getNumberOfComponents());
3902         self.assertEqual(5,f1.getNumberOfTuples());
3903         for i in xrange(5):
3904             self.assertAlmostEqual(0.09,f1.getIJ(i,0),16);
3905             pass
3906         #
3907         f1=MEDCouplingFieldDouble.New(ON_NODES,LINEAR_TIME);
3908         f1.setEndTime(4.5,2,3);
3909         f1.setMesh(m);
3910         f1.assign(0.08);
3911         f1.checkCoherency();
3912         self.assertEqual(1,f1.getNumberOfComponents());
3913         self.assertEqual(9,f1.getNumberOfTuples());
3914         for i in xrange(9):
3915             self.assertAlmostEqual(0.08,f1.getIJ(i,0),16);
3916             pass
3917         self.assertEqual(1,f1.getEndArray().getNumberOfComponents());
3918         self.assertEqual(9,f1.getEndArray().getNumberOfTuples());
3919         for i in xrange(9):
3920             self.assertAlmostEqual(0.08,f1.getEndArray().getIJ(i,0),16);
3921             pass
3922         pass
3923
3924     def testAreaBary3D2(self):
3925         coordsForHexa8=[-75.45749305371, 180.95495078401, 39.515472018008,
3926                         -9.755591679144, 23.394927935279, 5.108794294848,
3927                         14.337630157832, 61.705351002702, 160.42422501908,
3928                         -27.273893776752, 167.567731083961, 192.830034145464,
3929                         99.857193154796,264.499264735586,-8.287335493412,
3930                         144.939882761126,156.38626563134,-31.896173894226,
3931                         161.34096835726,182.4654895809,73.832387065572,
3932                         132.680430393685,255.37973247196,96.15235602819];
3933         volHexa8=3258520.29637466;
3934         baryHexa8=[43.925705821778, 155.31893955289, 65.874418109644]
3935
3936         coordsForPenta6=[-68.199829618726,178.938498373416,62.608505919588,
3937                          8.461744647847,76.653979804423,165.00018874933,
3938                          -27.273893776752,167.567731083961,192.830034145464,
3939                          106.586501038965,262.629609408327,13.124533008813,
3940                          155.465082847275,197.414118382622,78.408350795821,
3941                          132.680430393685,255.37973247196,96.15235602819];
3942         volPenta6=944849.868507338;
3943         baryPenta6=[39.631002313543,182.692711783428,106.98540473964]
3944
3945         coordsForPyra5=[132.680430393685,255.37973247196,96.15235602819,
3946                         -27.273893776752,167.567731083961,192.830034145464,
3947                         8.461744647847,76.653979804423,165.00018874933,
3948                         155.465082847275,197.414118382622,78.408350795821,
3949                         -68.199829618726,178.938498373416,62.608505919588];
3950         volPyra5=756943.92980254;
3951         baryPyra5=[29.204294116618,172.540129749156,118.01035951483]
3952         mesh=MEDCouplingUMesh.New("Bary3D2",3);
3953         coo=DataArrayDouble.New();
3954         tmp=coordsForHexa8+coordsForPenta6+coordsForPyra5
3955         coo.setValues(tmp,19,3);
3956         mesh.setCoords(coo);
3957         #
3958         tmpConn=[0,1,2,3,4,5,6,7]
3959         mesh.allocateCells(3);
3960         self.assertRaises(InterpKernelException,mesh.insertNextCell,NORM_HEXA8,9,tmpConn[0:8])
3961         mesh.insertNextCell(NORM_HEXA8,tmpConn[0:8])
3962         mesh.insertNextCell(NORM_PENTA6,6,[i+8 for i in tmpConn])
3963         mesh.insertNextCell(NORM_PYRA5,5,[i+14 for i in tmpConn])
3964         mesh.finishInsertingCells();
3965         mesh.checkCoherency();
3966         mesh.mergeNodes(1e-7)
3967         self.assertEqual(12,mesh.getNumberOfNodes());
3968         vols=mesh.getMeasureField(True);
3969         self.assertEqual(3,vols.getNumberOfTuples());
3970         self.assertEqual(1,vols.getNumberOfComponents());
3971         self.assertAlmostEqual(volHexa8,vols.getIJ(0,0),6);
3972         self.assertAlmostEqual(volPenta6,vols.getIJ(1,0),7);
3973         self.assertAlmostEqual(volPyra5,vols.getIJ(2,0),7);
3974         bary=mesh.getBarycenterAndOwner();
3975         self.assertEqual(3,bary.getNumberOfTuples());
3976         self.assertEqual(3,bary.getNumberOfComponents());
3977         self.assertAlmostEqual(baryHexa8[0],bary.getIJ(0,0),11);
3978         self.assertAlmostEqual(baryHexa8[1],bary.getIJ(0,1),11);
3979         self.assertAlmostEqual(baryHexa8[2],bary.getIJ(0,2),11);
3980         self.assertAlmostEqual(baryPenta6[0],bary.getIJ(1,0),11);
3981         self.assertAlmostEqual(baryPenta6[1],bary.getIJ(1,1),11);
3982         self.assertAlmostEqual(baryPenta6[2],bary.getIJ(1,2),11);
3983         self.assertAlmostEqual(baryPyra5[0],bary.getIJ(2,0),11);
3984         self.assertAlmostEqual(baryPyra5[1],bary.getIJ(2,1),11);
3985         self.assertAlmostEqual(baryPyra5[2],bary.getIJ(2,2),11);
3986         pass
3987
3988     def testGetMeasureFieldCMesh1(self):
3989         m=MEDCouplingCMesh.New();
3990         da=DataArrayDouble.New();
3991         discX=[2.3,3.4,5.8,10.2]
3992         discY=[12.3,23.4,45.8]
3993         discZ=[-0.7,1.2,1.25,2.13,2.67]
3994         da.setValues(discX,4,1);
3995         m.setCoordsAt(0,da);
3996         m.checkCoherency();
3997         self.assertEqual(4,m.getNumberOfNodes());
3998         self.assertEqual(3,m.getNumberOfCells());
3999         self.assertEqual(1,m.getSpaceDimension());
4000         f=m.getMeasureField(True);
4001         self.assertEqual(3,f.getNumberOfTuples());
4002         self.assertEqual(1,f.getNumberOfComponents());
4003         expected1=[1.1,2.4,4.4]
4004         for i in xrange(3):
4005             self.assertAlmostEqual(expected1[i],f.getIJ(i,0),12);
4006             pass
4007         coords=m.getCoordinatesAndOwner();
4008         self.assertEqual(4,coords.getNumberOfTuples());
4009         self.assertEqual(1,coords.getNumberOfComponents());
4010         for i in xrange(4):
4011             self.assertAlmostEqual(discX[i],coords.getIJ(i,0),12);
4012             pass
4013         coords=m.getBarycenterAndOwner();
4014         self.assertEqual(3,coords.getNumberOfTuples());
4015         self.assertEqual(1,coords.getNumberOfComponents());
4016         expected1_3=[2.85,4.6,8.]
4017         for i in xrange(3):
4018             self.assertAlmostEqual(expected1_3[i],coords.getIJ(i,0),12);
4019             pass
4020         #
4021         da=DataArrayDouble.New();
4022         da.setValues(discY,3,1);
4023         m.setCoordsAt(1,da);
4024         m.checkCoherency();
4025         self.assertEqual(12,m.getNumberOfNodes());
4026         self.assertEqual(6,m.getNumberOfCells());
4027         self.assertEqual(2,m.getSpaceDimension());
4028         f=m.getMeasureField(True);
4029         self.assertEqual(6,f.getNumberOfTuples());
4030         self.assertEqual(1,f.getNumberOfComponents());
4031         expected2=[12.21,26.64,48.84,24.64,53.76,98.56]
4032         for i in xrange(6):
4033             self.assertAlmostEqual(expected2[i],f.getIJ(i,0),12);
4034             pass
4035         coords=m.getCoordinatesAndOwner();
4036         self.assertEqual(12,coords.getNumberOfTuples());
4037         self.assertEqual(2,coords.getNumberOfComponents());
4038         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]
4039         for i in xrange(24):
4040             self.assertAlmostEqual(expected2_2[i],coords.getIJ(0,i),12);
4041             pass
4042         coords=m.getBarycenterAndOwner();
4043         self.assertEqual(6,coords.getNumberOfTuples());
4044         self.assertEqual(2,coords.getNumberOfComponents());
4045         expected2_3=[2.85,17.85,4.6,17.85,8.,17.85, 2.85,34.6,4.6,34.6,8.,34.6]
4046         for i in xrange(12):
4047             self.assertAlmostEqual(expected2_3[i],coords.getIJ(0,i),12);
4048             pass
4049         #
4050         da=DataArrayDouble.New();
4051         da.setValues(discZ,5,1);
4052         m.setCoordsAt(2,da);
4053         m.checkCoherency();
4054         self.assertEqual(60,m.getNumberOfNodes());
4055         self.assertEqual(24,m.getNumberOfCells());
4056         self.assertEqual(3,m.getSpaceDimension());
4057         f=m.getMeasureField(True);
4058         self.assertEqual(24,f.getNumberOfTuples());
4059         self.assertEqual(1,f.getNumberOfComponents());
4060         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]
4061         for i in xrange(24):
4062             self.assertAlmostEqual(expected3[i],f.getIJ(i,0),12);
4063             pass
4064         coords=m.getCoordinatesAndOwner();
4065         self.assertEqual(60,coords.getNumberOfTuples());
4066         self.assertEqual(3,coords.getNumberOfComponents());
4067         expected3_2=[
4068             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,
4069             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,
4070             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,
4071             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,
4072             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];
4073         for i in xrange(180):
4074             self.assertAlmostEqual(expected3_2[i],coords.getIJ(0,i),12);
4075             pass
4076         coords=m.getBarycenterAndOwner();
4077         self.assertEqual(24,coords.getNumberOfTuples());
4078         self.assertEqual(3,coords.getNumberOfComponents());
4079         expected3_3=[
4080             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,
4081             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,
4082             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,
4083             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];
4084         for i in xrange(72):
4085             self.assertAlmostEqual(expected3_3[i],coords.getIJ(0,i),12);
4086             pass
4087         pass
4088
4089     def testFieldDoubleZipCoords1(self):
4090         m=MEDCouplingDataForTest.build2DTargetMeshMergeNode_1();
4091         f=m.fillFromAnalytic(ON_NODES,2,"x*2.");
4092         f.getArray().setInfoOnComponent(0,"titi");
4093         f.getArray().setInfoOnComponent(1,"tutu");
4094         f.checkCoherency();
4095         self.assertEqual(18,f.getNumberOfTuples());
4096         self.assertEqual(2,f.getNumberOfComponents());
4097         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]
4098         for i in xrange(36):
4099             self.assertAlmostEqual(expected1[i],f.getIJ(0,i),12);
4100             pass
4101         self.assertTrue(f.zipCoords());
4102         f.checkCoherency();
4103         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]
4104         for i in xrange(30):
4105             self.assertAlmostEqual(expected2[i],f.getIJ(0,i),12);
4106             pass
4107         self.assertTrue(not f.zipCoords());
4108         f.checkCoherency();
4109         for i in xrange(30):
4110             self.assertAlmostEqual(expected2[i],f.getIJ(0,i),12);
4111             pass
4112         self.assertTrue(f.getArray().getInfoOnComponent(0)=="titi");
4113         self.assertTrue(f.getArray().getInfoOnComponent(1)=="tutu");
4114         pass
4115
4116     def testFieldDoubleZipConnectivity1(self):
4117         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
4118         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
4119         cells1=[2,3,4]
4120         m3_1=m2.buildPartOfMySelf(cells1,True);
4121         m3=m3_1;
4122         m4=MEDCouplingDataForTest.build2DSourceMesh_1();
4123         m5=MEDCouplingUMesh.MergeUMeshes(m1,m3);
4124         m6=MEDCouplingUMesh.MergeUMeshes(m5,m4);
4125         #
4126         self.assertEqual(10,m6.getNumberOfCells());
4127         self.assertEqual(22,m6.getNumberOfNodes());
4128         arr,areNodesMerged,newNbOfNodes=m6.mergeNodes(1e-13);
4129         self.assertEqual(9,m6.getNumberOfNodes());
4130         f=m6.fillFromAnalytic(ON_CELLS,2,"x");
4131         f2=m6.fillFromAnalytic(ON_NODES,2,"x");
4132         self.assertEqual(10,f.getNumberOfTuples());
4133         self.assertEqual(2,f.getNumberOfComponents());
4134         expected1=[-0.05, -0.05, 0.3666666666666667, 0.3666666666666667, 0.53333333333333321, 0.53333333333333321,
4135                    -0.05, -0.05, 0.45, 0.45, 0.53333333333333321, 0.53333333333333321, -0.05, -0.05, 0.45, 0.45,
4136                    0.36666666666666659, 0.36666666666666659, 0.033333333333333326, 0.033333333333333326];
4137         for i in xrange(20):
4138             self.assertAlmostEqual(expected1[i],f.getIJ(0,i),12);
4139             pass
4140         f.getArray().setInfoOnComponent(0,"titi");
4141         f.getArray().setInfoOnComponent(1,"tutu");
4142         f.checkCoherency();
4143         self.assertTrue(f.zipConnectivity(0));
4144         expected2=[-0.05, -0.05, 0.3666666666666667, 0.3666666666666667, 0.53333333333333321, 0.53333333333333321,
4145                    -0.05, -0.05, 0.45, 0.45, 0.36666666666666659, 0.36666666666666659, 0.033333333333333326, 0.033333333333333326];
4146         self.assertEqual(7,f.getNumberOfTuples());
4147         self.assertEqual(2,f.getNumberOfComponents());
4148         for i in xrange(14):
4149             self.assertAlmostEqual(expected2[i],f.getIJ(0,i),12);
4150             pass
4151         self.assertTrue(f.getArray().getInfoOnComponent(0)=="titi");
4152         self.assertTrue(f.getArray().getInfoOnComponent(1)=="tutu");
4153         self.assertTrue(not f.zipConnectivity(0));
4154         #
4155         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,
4156                    -0.3, -0.3, 0.2, 0.2, 0.7, 0.7];
4157         self.assertEqual(9,f2.getNumberOfTuples());
4158         self.assertEqual(2,f2.getNumberOfComponents());
4159         for i in xrange(18):
4160             self.assertAlmostEqual(expected3[i],f2.getIJ(0,i),12);
4161             pass
4162         self.assertTrue(f2.zipConnectivity(0));
4163         self.assertEqual(9,f2.getNumberOfTuples());
4164         self.assertEqual(2,f2.getNumberOfComponents());
4165         for i in xrange(18):
4166             self.assertAlmostEqual(expected3[i],f2.getIJ(0,i),12);
4167             pass
4168         pass
4169
4170     def testDaDoubleRenumber1(self):
4171         a=DataArrayDouble.New();
4172         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]
4173         a.setValues(arr1,7,2);
4174         a.setInfoOnComponent(0,"toto");
4175         a.setInfoOnComponent(1,"tata");
4176         #
4177         arr2=[3,1,0,6,5,4,2]
4178         b=a.renumber(arr2);
4179         self.assertEqual(7,b.getNumberOfTuples());
4180         self.assertEqual(2,b.getNumberOfComponents());
4181         self.assertTrue(b.getInfoOnComponent(0)=="toto");
4182         self.assertTrue(b.getInfoOnComponent(1)=="tata");
4183         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]
4184         for i in xrange(14):
4185             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
4186             pass
4187         #
4188         c=DataArrayInt.New();
4189         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4190         c.setValues(arr3,7,2);
4191         c.setInfoOnComponent(0,"toto");
4192         c.setInfoOnComponent(1,"tata");
4193         d=c.renumber(arr2);
4194         self.assertEqual(7,d.getNumberOfTuples());
4195         self.assertEqual(2,d.getNumberOfComponents());
4196         self.assertTrue(d.getInfoOnComponent(0)=="toto");
4197         self.assertTrue(d.getInfoOnComponent(1)=="tata");
4198         expected2=[3, 13, 2, 12, 7, 17, 1, 11, 6, 16, 5, 15, 4, 14]
4199         for i in xrange(14):
4200             self.assertEqual(expected2[i],d.getIJ(0,i));
4201             pass
4202         pass
4203
4204     def testDaDoubleRenumberAndReduce1(self):
4205         a=DataArrayDouble.New();
4206         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]
4207         a.setValues(arr1,7,2);
4208         a.setInfoOnComponent(0,"toto");
4209         a.setInfoOnComponent(1,"tata");
4210         #
4211         arr2=[2,-1,1,-1,0,4,3]
4212         b=a.renumberAndReduce(arr2,5);
4213         self.assertEqual(5,b.getNumberOfTuples());
4214         self.assertEqual(2,b.getNumberOfComponents());
4215         self.assertTrue(b.getInfoOnComponent(0)=="toto");
4216         self.assertTrue(b.getInfoOnComponent(1)=="tata");
4217         expected1=[5.1,15.1,3.1,13.1,1.1,11.1,7.1,17.1,6.1,16.1]
4218         for i in xrange(10):
4219             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
4220             pass
4221         #
4222         c=DataArrayInt.New();
4223         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4224         c.setValues(arr3,7,2);
4225         c.setInfoOnComponent(0,"toto");
4226         c.setInfoOnComponent(1,"tata");
4227         d=c.renumberAndReduce(arr2,5);
4228         self.assertEqual(5,d.getNumberOfTuples());
4229         self.assertEqual(2,d.getNumberOfComponents());
4230         self.assertTrue(d.getInfoOnComponent(0)=="toto");
4231         self.assertTrue(d.getInfoOnComponent(1)=="tata");
4232         expected2=[5,15,3,13,1,11,7,17,6,16]
4233         for i in xrange(10):
4234             self.assertEqual(expected2[i],d.getIJ(0,i));
4235             pass
4236         pass
4237
4238     def testDaDoubleRenumberInPlace1(self):
4239         a=DataArrayDouble.New();
4240         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]
4241         a.setValues(arr1,7,2);
4242         #
4243         arr2=[3,1,0,6,5,4,2]
4244         a.renumberInPlace(arr2);
4245         self.assertEqual(7,a.getNumberOfTuples());
4246         self.assertEqual(2,a.getNumberOfComponents());
4247         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]
4248         for i in xrange(14):
4249             self.assertAlmostEqual(expected1[i],a.getIJ(0,i),14);
4250             pass
4251         #
4252         c=DataArrayInt.New();
4253         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4254         c.setValues(arr3,7,2);
4255         c.renumberInPlace(arr2);
4256         self.assertEqual(7,c.getNumberOfTuples());
4257         self.assertEqual(2,c.getNumberOfComponents());
4258         expected2=[3, 13, 2, 12, 7, 17, 1, 11, 6, 16, 5, 15, 4, 14]
4259         for i in xrange(14):
4260             self.assertEqual(expected2[i],c.getIJ(0,i));
4261             pass
4262         pass
4263
4264     def testDaDoubleRenumberR1(self):
4265         a=DataArrayDouble.New();
4266         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]
4267         a.setValues(arr1,7,2);
4268         a.setInfoOnComponent(0,"toto");
4269         a.setInfoOnComponent(1,"tata");
4270         #
4271         arr2=[3,1,0,6,5,4,2]
4272         b=a.renumberR(arr2);
4273         self.assertEqual(7,b.getNumberOfTuples());
4274         self.assertEqual(2,b.getNumberOfComponents());
4275         self.assertTrue(b.getInfoOnComponent(0)=="toto");
4276         self.assertTrue(b.getInfoOnComponent(1)=="tata");
4277         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]
4278         for i in xrange(14):
4279             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
4280             pass
4281         #
4282         c=DataArrayInt.New();
4283         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4284         c.setValues(arr3,7,2);
4285         c.setInfoOnComponent(0,"toto");
4286         c.setInfoOnComponent(1,"tata");
4287         d=c.renumberR(arr2);
4288         self.assertEqual(7,d.getNumberOfTuples());
4289         self.assertEqual(2,d.getNumberOfComponents());
4290         self.assertTrue(d.getInfoOnComponent(0)=="toto");
4291         self.assertTrue(d.getInfoOnComponent(1)=="tata");
4292         expected2=[4, 14, 2, 12, 1, 11, 7, 17, 6, 16, 5, 15, 3, 13]
4293         for i in xrange(14):
4294             self.assertEqual(expected2[i],d.getIJ(0,i));
4295             pass
4296         pass
4297
4298     def testDaDoubleRenumberInPlaceR1(self):
4299         a=DataArrayDouble.New();
4300         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]
4301         a.setValues(arr1,7,2);
4302         #
4303         arr2=[3,1,0,6,5,4,2]
4304         a.renumberInPlaceR(arr2);
4305         self.assertEqual(7,a.getNumberOfTuples());
4306         self.assertEqual(2,a.getNumberOfComponents());
4307         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]
4308         for i in xrange(14):
4309             self.assertAlmostEqual(expected1[i],a.getIJ(0,i),14);
4310             pass
4311         #
4312         c=DataArrayInt.New();
4313         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4314         c.setValues(arr3,7,2);
4315         c.renumberInPlaceR(arr2);
4316         self.assertEqual(7,c.getNumberOfTuples());
4317         self.assertEqual(2,c.getNumberOfComponents());
4318         expected2=[4, 14, 2, 12, 1, 11, 7, 17, 6, 16, 5, 15, 3, 13]
4319         for i in xrange(14):
4320             self.assertEqual(expected2[i],c.getIJ(0,i));
4321             pass
4322         pass
4323
4324     def testDaDoubleSelectByTupleId1(self):
4325         a=DataArrayDouble.New();
4326         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]
4327         a.setValues(arr1,7,2);
4328         a.setInfoOnComponent(0,"toto");
4329         a.setInfoOnComponent(1,"tata");
4330         #
4331         arr2=[4,2,0,6,5]
4332         b=a.selectByTupleId(arr2);
4333         self.assertEqual(5,b.getNumberOfTuples());
4334         self.assertEqual(2,b.getNumberOfComponents());
4335         self.assertTrue(b.getInfoOnComponent(0)=="toto");
4336         self.assertTrue(b.getInfoOnComponent(1)=="tata");
4337         expected1=[5.1,15.1,3.1,13.1,1.1,11.1,7.1,17.1,6.1,16.1]
4338         for i in xrange(10):
4339             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
4340             pass
4341         #
4342         c=DataArrayInt.New();
4343         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4344         c.setValues(arr3,7,2);
4345         c.setInfoOnComponent(0,"toto");
4346         c.setInfoOnComponent(1,"tata");
4347         d=c.selectByTupleId(arr2);
4348         self.assertEqual(5,d.getNumberOfTuples());
4349         self.assertEqual(2,d.getNumberOfComponents());
4350         self.assertTrue(d.getInfoOnComponent(0)=="toto");
4351         self.assertTrue(d.getInfoOnComponent(1)=="tata");
4352         expected2=[5,15,3,13,1,11,7,17,6,16]
4353         for i in xrange(10):
4354             self.assertEqual(expected2[i],d.getIJ(0,i));
4355             pass
4356         pass
4357
4358     def testDaDoubleGetMinMaxValues1(self):
4359         a=DataArrayDouble.New();
4360         arr1=[2.34,4.56,-6.77,4.55,4.56,2.24,2.34,1.02,4.56]
4361         a.setValues(arr1,9,1);
4362         m,where=a.getMaxValue();
4363         self.assertEqual(1,where);
4364         self.assertAlmostEqual(4.56,m,12);
4365         m,ws=a.getMaxValue2();
4366         self.assertAlmostEqual(4.56,m,12);
4367         self.assertEqual(3,ws.getNumberOfTuples());
4368         self.assertEqual(1,ws.getNumberOfComponents());
4369         expected1=[1,4,8]
4370         for i in xrange(3):
4371             self.assertEqual(expected1[i],ws.getIJ(i,0));
4372             pass
4373         a=DataArrayDouble.New();
4374         arr2=[-2.34,-4.56,6.77,-4.55,-4.56,-2.24,-2.34,-1.02,-4.56]
4375         a.setValues(arr2,9,1);
4376         m,where=a.getMinValue();
4377         self.assertEqual(1,where);
4378         self.assertAlmostEqual(-4.56,m,12);
4379         m,ws=a.getMinValue2();
4380         self.assertAlmostEqual(-4.56,m,12);
4381         self.assertEqual(3,ws.getNumberOfTuples());
4382         self.assertEqual(1,ws.getNumberOfComponents());
4383         for i in xrange(3):
4384             self.assertEqual(expected1[i],ws.getIJ(i,0));
4385             pass
4386         pass
4387
4388     def testFieldDoubleGetMinMaxValues2(self):
4389         m2,m1=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
4390         self.assertEqual(18,m2.getNumberOfCells());
4391         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]
4392         f=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
4393         a=DataArrayDouble.New();
4394         a.setValues(arr1,18,1);
4395         f.setArray(a);
4396         f.setMesh(m2);
4397         #
4398         f.checkCoherency();
4399         m=f.getMaxValue();
4400         self.assertAlmostEqual(8.71,m,12);
4401         m,ws=f.getMaxValue2();
4402         self.assertAlmostEqual(8.71,m,12);
4403         self.assertEqual(4,ws.getNumberOfTuples());
4404         self.assertEqual(1,ws.getNumberOfComponents());
4405         expected1=[0,3,7,17]
4406         for i in xrange(4):
4407             self.assertEqual(expected1[i],ws.getIJ(i,0));
4408             pass
4409         #
4410         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]
4411         a.setValues(arr2,18,1);
4412         f.checkCoherency();
4413         m=f.getMinValue();
4414         self.assertAlmostEqual(-8.71,m,12);
4415         m,ws=f.getMinValue2();
4416         self.assertAlmostEqual(-8.71,m,12);
4417         self.assertEqual(4,ws.getNumberOfTuples());
4418         self.assertEqual(1,ws.getNumberOfComponents());
4419         for i in xrange(4):
4420             self.assertEqual(expected1[i],ws.getIJ(i,0));
4421             pass
4422         pass
4423
4424     def testBuildUnstructuredCMesh1(self):
4425         m=MEDCouplingCMesh.New();
4426         da=DataArrayDouble.New();
4427         discX=[2.3,3.4,5.8,10.2]
4428         discY=[12.3,23.4,45.8]
4429         discZ=[-0.7,1.2,1.25,2.13,2.67]
4430         da.setValues(discX,4,1);
4431         m.setCoordsAt(0,da);
4432         m.checkCoherency();
4433         self.assertEqual(0,m.getCellContainingPoint([2.4],1e-12));
4434         self.assertEqual(1,m.getCellContainingPoint([3.7],1e-12));
4435         self.assertEqual(2,m.getCellContainingPoint([5.9],1e-12));
4436         self.assertEqual(-1,m.getCellContainingPoint([10.3],1e-12));
4437         self.assertEqual(-1,m.getCellContainingPoint([1.3],1e-12));
4438         #
4439         m2=m.buildUnstructured();
4440         m2.checkCoherency();
4441         f1=m.getMeasureField(False);
4442         f2=m2.getMeasureField(False);
4443         self.assertTrue(isinstance(f1.getMesh(),MEDCouplingCMesh))
4444         self.assertEqual(f1.getNumberOfTuples(),3);
4445         self.assertEqual(f2.getNumberOfTuples(),3);
4446         self.assertEqual(1,m2.getMeshDimension());
4447         self.assertEqual(1,m2.getSpaceDimension());
4448         for i in xrange(3):
4449             self.assertAlmostEqual(f1.getIJ(i,0),f2.getIJ(i,0),10);
4450             pass
4451         da=DataArrayDouble.New();
4452         da.setValues(discY,3,1);
4453         m.setCoordsAt(1,da);
4454         #
4455         m2=m.buildUnstructured();
4456         m2.checkCoherency();
4457         f1=m.getMeasureField(False);
4458         f2=m2.getMeasureField(False);
4459         self.assertEqual(f1.getNumberOfTuples(),6);
4460         self.assertEqual(f2.getNumberOfTuples(),6);
4461         self.assertEqual(2,m2.getMeshDimension());
4462         self.assertEqual(2,m2.getSpaceDimension());
4463         for i in xrange(6):
4464             self.assertAlmostEqual(f1.getIJ(i,0),f2.getIJ(i,0),10);
4465             pass
4466         #
4467         da=DataArrayDouble.New();
4468         da.setValues(discZ,5,1);
4469         m.setCoordsAt(2,da);
4470         m2=m.buildUnstructured();
4471         m2.checkCoherency();
4472         f1=m.getMeasureField(False);
4473         f2=m2.getMeasureField(False);
4474         self.assertEqual(f1.getNumberOfTuples(),24);
4475         self.assertEqual(f2.getNumberOfTuples(),24);
4476         self.assertEqual(3,m2.getMeshDimension());
4477         self.assertEqual(3,m2.getSpaceDimension());
4478         for i in xrange(24):
4479             self.assertAlmostEqual(f1.getIJ(i,0),f2.getIJ(i,0),10);
4480             pass
4481         #
4482         pos1=[5.,30.,2.]
4483         self.assertEqual(16,m.getCellContainingPoint(pos1,1e-12));
4484         #
4485         elems=m2.getCellsInBoundingBox([3.5,6.,12.2,25.,0.,1.5],1e-7)
4486         self.assertEqual([1, 2, 4, 5, 7, 8, 10, 11, 13, 14, 16, 17],elems.getValues())
4487         #
4488         pt=[2.4,12.7,-3.4]
4489         m.scale(pt,3.7);
4490         m3=m.buildUnstructured();
4491         m2.scale(pt,3.7);
4492         self.assertTrue(m3.isEqual(m2,1e-12));
4493         pass
4494
4495     def testDataArrayIntInvertO2NNO21(self):
4496         arr1=[2,0,4,1,5,3]
4497         da=DataArrayInt.New();
4498         da.setValues(arr1,6,1);
4499         da2=da.invertArrayO2N2N2O(6);
4500         self.assertEqual(6,da2.getNumberOfTuples());
4501         self.assertEqual(1,da2.getNumberOfComponents());
4502         expected1=[1,3,0,5,2,4]
4503         for i in xrange(6):
4504             self.assertEqual(expected1[i],da2.getIJ(i,0));
4505             pass
4506         da3=da2.invertArrayN2O2O2N(6);
4507         for i in xrange(6):
4508             self.assertEqual(arr1[i],da3.getIJ(i,0));
4509             pass
4510         #
4511         arr2=[3,-1,5,4,-1,0,-1,1,2,-1]
4512         da=DataArrayInt.New();
4513         da.setValues(arr2,10,1);
4514         da2=da.invertArrayO2N2N2O(6);
4515         self.assertEqual(6,da2.getNumberOfTuples());
4516         self.assertEqual(1,da2.getNumberOfComponents());
4517         expected2=[5,7,8,0,3,2]
4518         for i in xrange(6):
4519             self.assertEqual(expected2[i],da2.getIJ(i,0));
4520             pass
4521         da3=da2.invertArrayN2O2O2N(10);
4522         for i in xrange(10):
4523             self.assertEqual(arr2[i],da3.getIJ(i,0));
4524             pass
4525         pass
4526
4527     def testKeepSetSelectedComponent1(self):
4528         arr1=[1.,2.,3.,4., 11.,12.,13.,14., 21.,22.,23.,24., 31.,32.,33.,34., 41.,42.,43.,44.]
4529         a1=DataArrayDouble.New();
4530         a1.setValues(arr1,5,4);
4531         expp=[21.,22.,23.,24.]
4532         self.assertEqual(4,len(a1.getTuple(2)));
4533         for i in xrange(4):
4534             self.assertAlmostEqual(expp[i],a1.getTuple(2)[i],12)
4535             pass
4536         a1.setInfoOnComponent(0,"aaaa");
4537         a1.setInfoOnComponent(1,"bbbb");
4538         a1.setInfoOnComponent(2,"cccc");
4539         a1.setInfoOnComponent(3,"dddd");
4540         arr2V=[1,2,1,2,0,0]
4541         a2=a1.keepSelectedComponents(arr2V);
4542         self.assertEqual(6,a2.getNumberOfComponents());
4543         self.assertEqual(5,a2.getNumberOfTuples());
4544         self.assertTrue(a2.getInfoOnComponent(0)=="bbbb");
4545         self.assertTrue(a2.getInfoOnComponent(1)=="cccc");
4546         self.assertTrue(a2.getInfoOnComponent(2)=="bbbb");
4547         self.assertTrue(a2.getInfoOnComponent(3)=="cccc");
4548         self.assertTrue(a2.getInfoOnComponent(4)=="aaaa");
4549         self.assertTrue(a2.getInfoOnComponent(5)=="aaaa");
4550         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.]
4551         for i in xrange(30):
4552             self.assertAlmostEqual(expected1[i],a2.getIJ(0,i),14);
4553             pass
4554         a3=a1.convertToIntArr();
4555         self.assertEqual([21,22,23,24],a3.getTuple(2))
4556         a4=a3.keepSelectedComponents(arr2V);
4557         self.assertEqual(6,a4.getNumberOfComponents());
4558         self.assertEqual(5,a4.getNumberOfTuples());
4559         self.assertTrue(a4.getInfoOnComponent(0)=="bbbb");
4560         self.assertTrue(a4.getInfoOnComponent(1)=="cccc");
4561         self.assertTrue(a4.getInfoOnComponent(2)=="bbbb");
4562         self.assertTrue(a4.getInfoOnComponent(3)=="cccc");
4563         self.assertTrue(a4.getInfoOnComponent(4)=="aaaa");
4564         self.assertTrue(a4.getInfoOnComponent(5)=="aaaa");
4565         for i in xrange(30):
4566             self.assertEqual(int(expected1[i]),a4.getIJ(0,i));
4567             pass
4568         # setSelectedComponents
4569         arr3V=[3,2]
4570         a5=a1.keepSelectedComponents(arr3V);
4571         a5.setInfoOnComponent(0,"eeee");
4572         a5.setInfoOnComponent(1,"ffff");
4573         arr4V=[1,2]
4574         a2.setSelectedComponents(a5,arr4V);
4575         self.assertEqual(6,a2.getNumberOfComponents());
4576         self.assertEqual(5,a2.getNumberOfTuples());
4577         self.assertTrue(a2.getInfoOnComponent(0)=="bbbb");
4578         self.assertTrue(a2.getInfoOnComponent(1)=="eeee");
4579         self.assertTrue(a2.getInfoOnComponent(2)=="ffff");
4580         self.assertTrue(a2.getInfoOnComponent(3)=="cccc");
4581         self.assertTrue(a2.getInfoOnComponent(4)=="aaaa");
4582         self.assertTrue(a2.getInfoOnComponent(5)=="aaaa");
4583         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.]
4584         for i in xrange(30):
4585             self.assertAlmostEqual(expected2[i],a2.getIJ(0,i),14);
4586             pass
4587         a6=a5.convertToIntArr();
4588         a6.setInfoOnComponent(0,"eeee");
4589         a6.setInfoOnComponent(1,"ffff");
4590         a4.setSelectedComponents(a6,arr4V);
4591         self.assertEqual(6,a4.getNumberOfComponents());
4592         self.assertEqual(5,a4.getNumberOfTuples());
4593         self.assertTrue(a4.getInfoOnComponent(0)=="bbbb");
4594         self.assertTrue(a4.getInfoOnComponent(1)=="eeee");
4595         self.assertTrue(a4.getInfoOnComponent(2)=="ffff");
4596         self.assertTrue(a4.getInfoOnComponent(3)=="cccc");
4597         self.assertTrue(a4.getInfoOnComponent(4)=="aaaa");
4598         self.assertTrue(a4.getInfoOnComponent(5)=="aaaa");
4599         for i in xrange(30):
4600             self.assertEqual(int(expected2[i]),a4.getIJ(0,i));
4601             pass
4602         # test of throw
4603         arr5V=[2,3,6]
4604         arr6V=[2,7,5]
4605         arr7V=[2,1,4,6]
4606         self.assertRaises(InterpKernelException,a2.keepSelectedComponents,arr5V);
4607         self.assertRaises(InterpKernelException,a2.keepSelectedComponents,arr6V);
4608         self.assertRaises(InterpKernelException,a2.setSelectedComponents,a1,arr7V);
4609         arr7V=arr7V[0:3]
4610         self.assertRaises(InterpKernelException,a2.setSelectedComponents,a1,arr7V);
4611         #
4612         pass
4613
4614     def testKeepSetSelectedComponent2(self):
4615         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
4616         arr1=[1.,2.,3.,4., 11.,12.,13.,14., 21.,22.,23.,24., 31.,32.,33.,34., 41.,42.,43.,44.]
4617         a1=DataArrayDouble.New();
4618         a1.setValues(arr1,5,4);
4619         a1.setInfoOnComponent(0,"aaaa");
4620         a1.setInfoOnComponent(1,"bbbb");
4621         a1.setInfoOnComponent(2,"cccc");
4622         a1.setInfoOnComponent(3,"dddd");
4623         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
4624         f1.setTime(2.3,4,5);
4625         f1.setMesh(m1);
4626         f1.setName("f1");
4627         f1.setArray(a1);
4628         f1.checkCoherency();
4629         #
4630         arr2V=[1,2,1,2,0,0]
4631         f2=f1.keepSelectedComponents(arr2V);
4632         self.assertTrue(f2.getTimeDiscretization()==ONE_TIME);
4633         t,dt,it=f2.getTime()
4634         self.assertAlmostEqual(2.3,t,13);
4635         self.assertEqual(4,dt);
4636         self.assertEqual(5,it);
4637         f2.checkCoherency();
4638         self.assertEqual(6,f2.getNumberOfComponents());
4639         self.assertEqual(5,f2.getNumberOfTuples());
4640         self.assertTrue(f2.getArray().getInfoOnComponent(0)=="bbbb");
4641         self.assertTrue(f2.getArray().getInfoOnComponent(1)=="cccc");
4642         self.assertTrue(f2.getArray().getInfoOnComponent(2)=="bbbb");
4643         self.assertTrue(f2.getArray().getInfoOnComponent(3)=="cccc");
4644         self.assertTrue(f2.getArray().getInfoOnComponent(4)=="aaaa");
4645         self.assertTrue(f2.getArray().getInfoOnComponent(5)=="aaaa");
4646         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.]
4647         for i in xrange(30):
4648             self.assertAlmostEqual(expected1[i],f2.getIJ(0,i),14);
4649             pass
4650         #setSelectedComponents
4651         arr3V=[3,2]
4652         f5=f1.keepSelectedComponents(arr3V);
4653         f5.setTime(6.7,8,9);
4654         f5.getArray().setInfoOnComponent(0,"eeee");
4655         f5.getArray().setInfoOnComponent(1,"ffff");
4656         f5.checkCoherency();
4657         arr4V=[1,2]
4658         f2.setSelectedComponents(f5,arr4V);
4659         self.assertEqual(6,f2.getNumberOfComponents());
4660         self.assertEqual(5,f2.getNumberOfTuples());
4661         f2.checkCoherency();
4662         t,dt,it=f2.getTime()
4663         self.assertAlmostEqual(2.3,t,13);
4664         self.assertEqual(4,dt);
4665         self.assertEqual(5,it);
4666         self.assertTrue(f2.getArray().getInfoOnComponent(0)=="bbbb");
4667         self.assertTrue(f2.getArray().getInfoOnComponent(1)=="eeee");
4668         self.assertTrue(f2.getArray().getInfoOnComponent(2)=="ffff");
4669         self.assertTrue(f2.getArray().getInfoOnComponent(3)=="cccc");
4670         self.assertTrue(f2.getArray().getInfoOnComponent(4)=="aaaa");
4671         self.assertTrue(f2.getArray().getInfoOnComponent(5)=="aaaa");
4672         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.]
4673         for i in xrange(30):
4674             self.assertAlmostEqual(expected2[i],f2.getIJ(0,i),14);
4675             pass
4676         #
4677         pass
4678
4679     def testElementaryDAThrowAndSpecialCases(self):
4680         da=DataArrayInt.New();
4681         self.assertRaises(InterpKernelException, da.checkAllocated);
4682         self.assertRaises(InterpKernelException, da.fillWithValue, 1);
4683         self.assertRaises(InterpKernelException, da.iota, 1);
4684         da.alloc(7,1);
4685         da.fillWithValue(11); #11,11,11,11...
4686         da.iota(10); #10,11,12,13...
4687
4688         db=DataArrayInt.New();
4689         db.alloc(7,2);
4690
4691         dbl2=DataArrayDouble.New();
4692         dbl2.alloc(7,2);
4693         self.assertRaises(InterpKernelException, dbl2.isUniform, 10., 1e-15);
4694         self.assertRaises(InterpKernelException, dbl2.sort);
4695         self.assertRaises(InterpKernelException, dbl2.iota, 10.);
4696
4697         dbl=DataArrayDouble.New();
4698         #DataArrayDouble not allocated yet
4699         self.assertRaises(InterpKernelException, dbl.iota, 10.);
4700         self.assertRaises(InterpKernelException, dbl.isUniform, 10., 1e-15);
4701         self.assertRaises(InterpKernelException, dbl.sort);
4702         self.assertRaises(InterpKernelException, dbl.fromNoInterlace);
4703         self.assertRaises(InterpKernelException, dbl.toNoInterlace);
4704
4705         dbl.alloc(7,1);
4706         dbl.iota(10.);
4707         self.assertTrue(not dbl.isUniform(10.,1e-15));
4708         dbl.sort();
4709         self.assertTrue(dbl.isMonotonic(True, .99));
4710         self.assertTrue(dbl.isMonotonic(True, -.99));
4711         self.assertTrue(not dbl.isMonotonic(True, 1.1));
4712         self.assertTrue(not dbl.isMonotonic(True, -1.1));
4713         dbl.reverse();
4714         self.assertTrue(dbl.isMonotonic(False, .99));
4715         self.assertTrue(not dbl.isMonotonic(False, 1.1));
4716         self.assertTrue(not dbl.isMonotonic(False, -1.1));
4717
4718         dc=DataArrayInt.New();
4719         dc.alloc(14,1);
4720
4721         dd=DataArrayDouble.New();
4722         self.assertRaises(InterpKernelException, dd.checkAllocated);
4723         self.assertRaises(InterpKernelException, dd.fillWithValue, 1.);
4724         self.assertRaises(InterpKernelException, dd.iota, 1.);
4725         self.assertTrue(not ((dd.repr().find("No data"))==-1));
4726
4727         dd.alloc(0,1); #Allocated but nbOfElements==0!
4728         self.assertTrue(not ((dd.repr().find("Number of tuples : 0"))==-1));
4729         self.assertTrue(not ((dd.repr().find("Empty Data"))==-1));
4730         dd.fillWithValue(11); #?!...ok
4731         dd.iota(10); #?!...ok
4732         self.assertTrue(dd.isMonotonic(True, 1.));  #nothing is monotonic
4733         self.assertTrue(dd.isMonotonic(False, 1.));
4734
4735         self.assertRaises(InterpKernelException, db.copyStringInfoFrom, da);
4736         self.assertRaises(InterpKernelException, db.copyStringInfoFrom, da);
4737         cIds=[2,2]
4738         self.assertRaises(InterpKernelException, da.copyPartOfStringInfoFrom, db, cIds);
4739         cIds[0]=1;
4740         cIds[0]=-1;
4741         self.assertRaises(InterpKernelException, da.copyPartOfStringInfoFrom, db, cIds);
4742
4743         info=["infoOfOneComponent"]*2;
4744         self.assertRaises(InterpKernelException, da.setInfoOnComponents, info);
4745         self.assertRaises(InterpKernelException, da.setInfoOnComponent, 1, info[0]);
4746         db.setInfoOnComponents(info);
4747
4748         self.assertRaises(InterpKernelException, da.getInfoOnComponent, -1);
4749         self.assertRaises(InterpKernelException, da.getInfoOnComponent, 2);
4750         self.assertTrue(db.getInfoOnComponent(1)==db.getInfoOnComponent(0));
4751         self.assertRaises(InterpKernelException, db.getVarOnComponent, -1);
4752         self.assertRaises(InterpKernelException, db.getVarOnComponent, 2);
4753         self.assertRaises(InterpKernelException, db.getUnitOnComponent, -1);
4754         self.assertRaises(InterpKernelException, db.getUnitOnComponent, 2);
4755
4756         self.assertTrue(da.GetVarNameFromInfo("varname unit ")=="varname unit ");
4757         self.assertTrue(da.GetVarNameFromInfo("varname]unit[")=="varname]unit[");
4758         self.assertTrue(da.GetVarNameFromInfo("[unit]")=="");
4759         self.assertTrue(da.GetVarNameFromInfo("varname [unit]")=="varname");
4760
4761         self.assertTrue(da.GetUnitFromInfo("varname unit ")=="");
4762         self.assertTrue(da.GetUnitFromInfo("varname]unit[")=="");
4763         self.assertTrue(da.GetUnitFromInfo("[unit]")=="unit");
4764         self.assertTrue(da.GetUnitFromInfo("varname [unit]")=="unit");
4765
4766         self.assertRaises(InterpKernelException, da.checkNbOfTuplesAndComp, db, "theMessageInThrow");
4767         self.assertRaises(InterpKernelException, da.checkNbOfTuplesAndComp, dc, "theMessageInThrow");
4768         self.assertRaises(InterpKernelException, db.checkNbOfTuplesAndComp, dc, "theMessageInThrow");
4769
4770         self.assertRaises(InterpKernelException, da.checkNbOfTuplesAndComp, 7, 2, "theMessageInThrow");
4771         da.checkNbOfTuplesAndComp(7,1,"theMessageInThrow");
4772
4773         self.assertRaises(InterpKernelException, db.checkNbOfElems, 7*2+1, "theMessageInThrow");
4774         db.checkNbOfElems(7*2,"theMessageInThrow");
4775
4776         self.assertRaises(InterpKernelException, db.GetNumberOfItemGivenBES, 10, 9, 1, "theMessageInThrow");
4777         self.assertRaises(InterpKernelException, db.GetNumberOfItemGivenBES, 0, 1, -1, "theMessageInThrow");
4778         self.assertEqual(10,db.GetNumberOfItemGivenBES(0,10,1,"theMessageInThrow"));
4779         self.assertEqual(5,db.GetNumberOfItemGivenBES(0,10,2,"theMessageInThrow"));
4780         self.assertEqual(6,db.GetNumberOfItemGivenBES(0,11,2,"theMessageInThrow"));
4781
4782         self.assertTrue(not ((da.repr().find("Number of components : 1"))==-1));
4783         self.assertTrue(not ((dd.repr().find("Number of components : 1"))==-1));
4784         self.assertTrue(not ((dbl.repr().find("Number of components : 1"))==-1));
4785
4786         self.assertTrue(not ((da.reprZip().find("Number of components : 1"))==-1));
4787         self.assertTrue(not ((dd.reprZip().find("Number of components : 1"))==-1));
4788         self.assertTrue(not ((dbl.reprZip().find("Number of components : 1"))==-1));
4789
4790         self.assertRaises(InterpKernelException, dbl.selectByTupleId2, 0, 1, -1);
4791         self.assertRaises(InterpKernelException, dbl.substr, -1, 1);
4792         self.assertRaises(InterpKernelException, dbl.substr, 8, 1);
4793         self.assertRaises(InterpKernelException, dbl.substr, 0, 8);
4794         self.assertRaises(InterpKernelException, dbl.meldWith, dd);
4795
4796         self.assertRaises(InterpKernelException, dbl.setPartOfValuesAdv, dbl2, da); #dbl dbl2 not have the same number of components
4797         self.assertRaises(InterpKernelException, dbl.setPartOfValuesAdv, dd, da);  #da tuple selector DataArrayInt instance not have exactly 2 components
4798
4799         dbl3=DataArrayDouble.New();
4800         dbl3.alloc(6,2);
4801         dbl3.fillWithValue(11.);
4802         #bad number of components
4803         self.assertRaises(InterpKernelException, dbl3.getMaxValue);
4804         self.assertRaises(InterpKernelException, dd.getMaxValue);
4805         self.assertRaises(InterpKernelException, dbl3.getMinValue);
4806         self.assertRaises(InterpKernelException, dd.getMinValue);
4807         self.assertRaises(InterpKernelException, dbl3.getAverageValue);
4808         self.assertRaises(InterpKernelException, dd.getAverageValue);
4809         self.assertRaises(InterpKernelException, dd.accumulate, 100);
4810         self.assertRaises(InterpKernelException, dbl.fromPolarToCart);
4811         self.assertRaises(InterpKernelException, dbl3.fromCylToCart);
4812         self.assertRaises(InterpKernelException, dbl3.fromSpherToCart);
4813         self.assertRaises(InterpKernelException, dbl3.doublyContractedProduct);
4814         self.assertRaises(InterpKernelException, dbl3.determinant);
4815         self.assertRaises(InterpKernelException, dbl3.eigenValues);
4816         self.assertRaises(InterpKernelException, dbl3.eigenVectors);
4817         self.assertRaises(InterpKernelException, dbl3.inverse);
4818         self.assertRaises(InterpKernelException, dbl3.trace);
4819         self.assertRaises(InterpKernelException, dbl3.deviator);
4820
4821         dbl3.setIJ(5,1,12.);
4822         self.assertTrue(dbl3.getMaxValueInArray()==12.);
4823         self.assertTrue(dbl3.getMinValueInArray()==11.);
4824
4825         db.fillWithValue(100); #bad Ids
4826         self.assertRaises(InterpKernelException, dbl3.setPartOfValuesAdv, dbl2, db);
4827         db.fillWithValue(-1); #bad Ids
4828         self.assertRaises(InterpKernelException, dbl3.setPartOfValuesAdv, dbl2, db);
4829         db.fillWithValue(6); #bad Ids for dbl3
4830         self.assertRaises(InterpKernelException, dbl3.setPartOfValuesAdv, dbl2, db);
4831
4832         dbl3.checkNoNullValues();
4833         dbl3.setIJ(5,0,0.);
4834         self.assertRaises(InterpKernelException, dbl3.checkNoNullValues);
4835         self.assertRaises(InterpKernelException, dbl3.applyInv, 1.);  #div by zero
4836         self.assertRaises(InterpKernelException, dbl2.getIdsInRange, 1., 2.);
4837         a=[]
4838         self.assertRaises(InterpKernelException, DataArrayDouble_Aggregate, a);
4839         self.assertRaises(InterpKernelException, DataArrayDouble_Meld, a);
4840
4841         a=[dbl2,dbl]; #Nb of components mismatch
4842         self.assertRaises(InterpKernelException, DataArrayDouble_Aggregate, a);
4843
4844         self.assertRaises(InterpKernelException, DataArrayDouble_Dot, dbl2, dbl);
4845
4846         self.assertRaises(InterpKernelException, DataArrayDouble_CrossProduct, dbl2, dbl); #Nb of components mismatch
4847         self.assertRaises(InterpKernelException, DataArrayDouble_CrossProduct, dbl2, dbl2); #Nb of components must be equal to 3
4848         dbl4=DataArrayDouble.New();
4849         dbl4.alloc(6,3);
4850         dbl5=DataArrayDouble.New();
4851         dbl5.alloc(7,3);
4852         self.assertRaises(InterpKernelException, DataArrayDouble_CrossProduct, dbl4, dbl5); #Nb of tuples mismatch
4853
4854         a[0]=dbl4; #Nb of tuple mismatch
4855         a[1]=dbl5; #Nb of tuple mismatch
4856         self.assertRaises(InterpKernelException, DataArrayDouble_Meld, a);
4857         self.assertRaises(InterpKernelException, DataArrayDouble_Dot, dbl4, dbl5);
4858         pass
4859
4860     def testDAIGetIdsEqual1(self):
4861         tab1=[5,-2,-4,-2,3,2,-2];
4862         da=DataArrayInt.New();
4863         da.setValues(tab1,7,1);
4864         da2=da.getIdsEqual(-2);
4865         self.assertEqual(3,da2.getNumberOfTuples());
4866         self.assertEqual(1,da2.getNumberOfComponents());
4867         expected1=[1,3,6];
4868         self.assertEqual(expected1,da2.getValues());
4869         pass
4870
4871     def testDAIGetIdsEqualList1(self):
4872         tab1=[5,-2,-4,-2,3,2,-2];
4873         da=DataArrayInt.New();
4874         da.setValues(tab1,7,1);
4875         da2=da.getIdsEqualList([3,-2,0]);
4876         self.assertEqual(4,da2.getNumberOfTuples());
4877         self.assertEqual(1,da2.getNumberOfComponents());
4878         expected1=[1,3,4,6];
4879         self.assertEqual(expected1,da2.getValues());
4880         pass
4881
4882     def testDAFromNoInterlace1(self):
4883         tab1=[1,11,21,31,41,2,12,22,32,42,3,13,23,33,43]
4884         da=DataArrayInt.New();
4885         da.setValues(tab1,5,3);
4886         da2=da.fromNoInterlace();
4887         expected1=[1,2,3,11,12,13,21,22,23,31,32,33,41,42,43]
4888         self.assertEqual(5,da2.getNumberOfTuples());
4889         self.assertEqual(3,da2.getNumberOfComponents());# it's not a bug. Avoid to have 1 million components !
4890         self.assertEqual(expected1,da2.getValues());
4891         da3=da.convertToDblArr();
4892         da4=da3.fromNoInterlace();
4893         self.assertEqual(5,da4.getNumberOfTuples());
4894         self.assertEqual(3,da4.getNumberOfComponents());# it's not a bug. Avoid to have 1 million components !
4895         for i in xrange(15):
4896             self.assertAlmostEqual(expected1[i],da4.getIJ(0,i),14);
4897             pass
4898         pass
4899
4900     def testDAToNoInterlace1(self):
4901         tab1=[1,2,3,11,12,13,21,22,23,31,32,33,41,42,43]
4902         da=DataArrayInt.New();
4903         da.setValues(tab1,5,3);
4904         da2=da.toNoInterlace();
4905         expected1=[1,11,21,31,41,2,12,22,32,42,3,13,23,33,43]
4906         self.assertEqual(5,da2.getNumberOfTuples());
4907         self.assertEqual(3,da2.getNumberOfComponents());# it's not a bug. Avoid to have 1 million components !
4908         self.assertEqual(expected1,da2.getValues());
4909         da3=da.convertToDblArr();
4910         da4=da3.toNoInterlace();
4911         self.assertEqual(5,da4.getNumberOfTuples());
4912         self.assertEqual(3,da4.getNumberOfComponents());# it's not a bug. Avoid to have 1 million components !
4913         for i in xrange(15):
4914             self.assertAlmostEqual(expected1[i],da4.getIJ(0,i),14);
4915             pass
4916         pass
4917
4918     def testDAIsUniform1(self):
4919         tab1=[1,1,1,1,1]
4920         da=DataArrayInt.New();
4921         da.setValues(tab1,5,1);
4922         self.assertTrue(da.isUniform(1));
4923         da.setIJ(2,0,2);
4924         self.assertTrue(not da.isUniform(1));
4925         da.setIJ(2,0,1);
4926         self.assertTrue(da.isUniform(1));
4927         da2=da.convertToDblArr();
4928         self.assertTrue(da2.isUniform(1.,1.e-12));
4929         da2.setIJ(1,0,1.+1.e-13);
4930         self.assertTrue(da2.isUniform(1.,1.e-12));
4931         da2.setIJ(1,0,1.+1.e-11);
4932         self.assertTrue(not da2.isUniform(1.,1.e-12));
4933         pass
4934
4935     def testDADFromPolarToCart1(self):
4936         tab1=[2.,0.2,2.5,0.7]
4937         da=DataArrayDouble.New();
4938         da.setValues(tab1,2,2);
4939         da2=da.fromPolarToCart();
4940         expected1=[1.9601331556824833,0.39733866159012243, 1.9121054682112213,1.6105442180942275]
4941         for i in xrange(4):
4942             self.assertAlmostEqual(expected1[i],da2.getIJ(0,i),13);
4943             pass
4944         pass
4945
4946     def testDADFromCylToCart1(self):
4947         tab1=[2.,0.2,4.,2.5,0.7,9.]
4948         da=DataArrayDouble.New();
4949         da.setValues(tab1,2,3);
4950         da2=da.fromCylToCart();
4951         expected1=[1.9601331556824833,0.39733866159012243,4., 1.9121054682112213,1.6105442180942275,9.]
4952         for i in xrange(6):
4953             self.assertAlmostEqual(expected1[i],da2.getIJ(0,i),13);
4954             pass
4955         pass
4956
4957     def testDADFromSpherToCart1(self):
4958         tab1=[2.,0.2,0.3,2.5,0.7,0.8]
4959         da=DataArrayDouble.New();
4960         da.setValues(tab1,2,3);
4961         da2=da.fromSpherToCart();
4962         expected1=[0.37959212195737485,0.11742160338765303,1.9601331556824833, 1.1220769624465328,1.1553337045129035,1.9121054682112213]
4963         for i in xrange(6):
4964             self.assertAlmostEqual(expected1[i],da2.getIJ(0,i),13);
4965             pass
4966         pass
4967
4968     def testUnPolyze1(self):
4969         elts=[0,1,2,3,4,5,6,7]
4970         eltsV=elts;
4971         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
4972         mesh.convertToPolyTypes(eltsV);
4973         mesh.unPolyze();
4974         mesh2=MEDCouplingDataForTest.build3DTargetMesh_1();
4975         mesh.checkCoherency();
4976         self.assertTrue(mesh.isEqual(mesh2,1e-12));
4977         mesh.convertToPolyTypes(eltsV);
4978         self.assertTrue(not mesh.isEqual(mesh2,1e-12));
4979         mesh.getNodalConnectivity().setIJ(0,6,10);
4980         mesh.getNodalConnectivity().setIJ(0,7,9);
4981         mesh.getNodalConnectivity().setIJ(0,8,12);
4982         mesh.getNodalConnectivity().setIJ(0,9,13);
4983         mesh.unPolyze();
4984         self.assertTrue(mesh.isEqual(mesh2,1e-12));
4985         mesh.convertToPolyTypes(eltsV);
4986         mesh.getNodalConnectivity().setIJ(0,6,12);
4987         mesh.getNodalConnectivity().setIJ(0,7,13);
4988         mesh.getNodalConnectivity().setIJ(0,8,10);
4989         mesh.getNodalConnectivity().setIJ(0,9,9);
4990         mesh.unPolyze();
4991         self.assertTrue(mesh.isEqual(mesh2,1e-12));
4992         mesh.convertToPolyTypes(eltsV);
4993         mesh.getNodalConnectivity().setIJ(0,6,12);
4994         mesh.getNodalConnectivity().setIJ(0,7,10);
4995         mesh.getNodalConnectivity().setIJ(0,8,13);
4996         mesh.getNodalConnectivity().setIJ(0,9,9);
4997         mesh.unPolyze();
4998         self.assertTrue(not mesh.isEqual(mesh2,1e-12));
4999         # Test for 2D mesh
5000         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
5001         mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
5002         eltsV=eltsV[:5];
5003         mesh.convertToPolyTypes(eltsV);
5004         self.assertTrue(not mesh.isEqual(mesh2,1e-12));
5005         mesh.unPolyze();
5006         self.assertTrue(mesh.isEqual(mesh2,1e-12));
5007         pass
5008
5009     def testConvertDegeneratedCells1(self):
5010         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
5011         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]
5012         mesh.allocateCells(4);
5013         mesh.insertNextCell(NORM_HEXA8,8,conn[0:8])
5014         mesh.insertNextCell(NORM_HEXA8,8,conn[8:16])
5015         mesh.insertNextCell(NORM_HEXA8,8,conn[16:24])
5016         mesh.insertNextCell(NORM_HEXA8,8,conn[24:32])
5017         mesh.finishInsertingCells();
5018         mesh.checkCoherency();
5019         self.assertEqual(4,mesh.getNumberOfCells());
5020         self.assertEqual(NORM_HEXA8,mesh.getTypeOfCell(0));
5021         self.assertEqual(NORM_HEXA8,mesh.getTypeOfCell(1));
5022         self.assertEqual(NORM_HEXA8,mesh.getTypeOfCell(2));
5023         self.assertEqual(NORM_HEXA8,mesh.getTypeOfCell(3));
5024         f1=mesh.getMeasureField(True);
5025         mesh.convertDegeneratedCells();
5026         mesh.checkCoherency();
5027         f2=mesh.getMeasureField(True);
5028         self.assertEqual(4,mesh.getNumberOfCells());
5029         self.assertEqual(NORM_PENTA6,mesh.getTypeOfCell(0));
5030         self.assertEqual(NORM_PYRA5,mesh.getTypeOfCell(1));
5031         self.assertEqual(NORM_TETRA4,mesh.getTypeOfCell(2));
5032         self.assertEqual(NORM_PYRA5,mesh.getTypeOfCell(3));
5033         for i in xrange(4):
5034             self.assertAlmostEqual(f1.getArray().getIJ(0,i),f2.getArray().getIJ(0,i),5);
5035             pass
5036         pass
5037
5038     def testGetNodeIdsNearPoints1(self):
5039         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
5040         coords=mesh.getCoords();
5041         tmp=DataArrayDouble.New();
5042         vals=[0.2,0.2,0.1,0.2,0.2,0.2]
5043         tmp.setValues(vals,3,2);
5044         tmp2=DataArrayDouble.Aggregate(coords,tmp);
5045         mesh.setCoords(tmp2);
5046         pts=[0.2,0.2,0.1,0.3,-0.3,0.7]
5047         c=mesh.getNodeIdsNearPoint(pts[:2],1e-7);
5048         self.assertEqual([4,9,11],c.getValues());
5049         c,cI=mesh.getNodeIdsNearPoints(pts,3,1e-7);
5050         self.assertEqual([0,3,3,4],cI.getValues());
5051         self.assertEqual([4,9,11,6],c.getValues());
5052         c,cI=mesh.getNodeIdsNearPoints(pts,1e-7);
5053         self.assertEqual([0,3,3,4],cI.getValues());
5054         self.assertEqual([4,9,11,6],c.getValues());
5055         c,cI=mesh.getNodeIdsNearPoints(DataArrayDouble.New(pts,3,2),1e-7);
5056         self.assertEqual([0,3,3,4],cI.getValues());
5057         self.assertEqual([4,9,11,6],c.getValues());
5058         self.assertRaises(InterpKernelException,mesh.getNodeIdsNearPoints,DataArrayDouble.New(pts,2,3),1e-7);
5059         pass
5060
5061     def testFieldCopyTinyAttrFrom1(self):
5062         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
5063         f1.setName("f1");
5064         f1.setTimeTolerance(1.e-5);
5065         f1.setDescription("f1Desc");
5066         f1.setTime(1.23,4,5);
5067         f2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
5068         f2.setName("f2");
5069         f2.setDescription("f2Desc");
5070         f2.setTime(6.78,9,10);
5071         f2.setTimeTolerance(4.556e-12);
5072         #
5073         f1.copyTinyAttrFrom(f2);
5074         self.assertAlmostEqual(4.556e-12,f1.getTimeTolerance(),24);
5075         t,dt,it=f1.getTime()
5076         self.assertAlmostEqual(6.78,t,12);
5077         self.assertEqual(9,dt);
5078         self.assertEqual(10,it);
5079         self.assertTrue(f1.getName()=="f1");#name unchanged
5080         self.assertTrue(f1.getDescription()=="f1Desc");#description unchanged
5081         #
5082         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
5083         f1.setName("f1");
5084         f1.setTimeTolerance(1.e-5);
5085         f1.setDescription("f1Desc");
5086         f2=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
5087         f2.setName("f2");
5088         f2.setDescription("f2Desc");
5089         f2.setTimeTolerance(4.556e-12);
5090         #
5091         f1.copyTinyAttrFrom(f2);
5092         self.assertAlmostEqual(4.556e-12,f1.getTimeTolerance(),24);
5093         self.assertTrue(f1.getName()=="f1");#name unchanged
5094         self.assertTrue(f1.getDescription()=="f1Desc");#description unchanged
5095         #
5096         f1=MEDCouplingFieldDouble.New(ON_CELLS,CONST_ON_TIME_INTERVAL);
5097         f1.setName("f1");
5098         f1.setTimeTolerance(1.e-5);
5099         f1.setDescription("f1Desc");
5100         f1.setTime(1.23,4,5);
5101         f1.setEndTime(5.43,2,1);
5102         f2=MEDCouplingFieldDouble.New(ON_CELLS,CONST_ON_TIME_INTERVAL);
5103         f2.setName("f2");
5104         f2.setDescription("f2Desc");
5105         f2.setTimeTolerance(4.556e-12);
5106         f2.setTime(6.78,9,10);
5107         f2.setEndTime(10.98,7,6);
5108         #
5109         f1.copyTinyAttrFrom(f2);
5110         self.assertAlmostEqual(4.556e-12,f1.getTimeTolerance(),24);
5111         self.assertTrue(f1.getName()=="f1");#name unchanged
5112         self.assertTrue(f1.getDescription()=="f1Desc");#description unchanged
5113         t,dt,it=f1.getTime()
5114         self.assertAlmostEqual(6.78,t,12);
5115         self.assertEqual(9,dt);
5116         self.assertEqual(10,it);
5117         t,dt,it=f1.getEndTime()
5118         self.assertAlmostEqual(10.98,t,12);
5119         self.assertEqual(7,dt);
5120         self.assertEqual(6,it);
5121         #
5122         f1=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
5123         f1.setName("f1");
5124         f1.setTimeTolerance(1.e-5);
5125         f1.setDescription("f1Desc");
5126         f1.setTime(1.23,4,5);
5127         f1.setEndTime(5.43,2,1);
5128         f2=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
5129         f2.setName("f2");
5130         f2.setDescription("f2Desc");
5131         f2.setTimeTolerance(4.556e-12);
5132         f2.setTime(6.78,9,10);
5133         f2.setEndTime(10.98,7,6);
5134         #
5135         f1.copyTinyAttrFrom(f2);
5136         self.assertAlmostEqual(4.556e-12,f1.getTimeTolerance(),24);
5137         self.assertTrue(f1.getName()=="f1");#name unchanged
5138         self.assertTrue(f1.getDescription()=="f1Desc");#description unchanged
5139         t,dt,it=f1.getTime()
5140         self.assertAlmostEqual(6.78,t,12);
5141         self.assertEqual(9,dt);
5142         self.assertEqual(10,it);
5143         t,dt,it=f1.getEndTime()
5144         self.assertAlmostEqual(10.98,t,12);
5145         self.assertEqual(7,dt);
5146         self.assertEqual(6,it);
5147         pass
5148
5149     def testExtrudedMesh5(self):
5150         coo1=[0.,1.,2.,3.5]
5151         a=DataArrayDouble.New();
5152         a.setValues(coo1,4,1);
5153         b=MEDCouplingCMesh.New();
5154         b.setCoordsAt(0,a);
5155         c=b.buildUnstructured();
5156         self.assertEqual(1,c.getSpaceDimension());
5157         c.changeSpaceDimension(2);
5158         #
5159         d=DataArrayDouble.New();
5160         d.alloc(13,1);
5161         d.iota();
5162         e=MEDCouplingCMesh.New();
5163         e.setCoordsAt(0,d);
5164         f=e.buildUnstructured();
5165         g=f.getCoords().applyFunc(2,"3.5*IVec+x/6*3.14159265359*JVec");
5166         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 !
5167         h=g.fromPolarToCart();
5168         f.setCoords(h);
5169         i=c.buildExtrudedMesh(f,1);
5170         self.assertEqual(52,i.getNumberOfNodes());
5171         tmp,tmp2,tmp3=i.mergeNodes(1e-9);
5172         self.assertTrue(tmp2);
5173         self.assertEqual(37,tmp3);
5174         i.convertDegeneratedCells();
5175         i.checkCoherency();
5176         self.assertEqual(36,i.getNumberOfCells());
5177         self.assertEqual(37,i.getNumberOfNodes());
5178         self.assertEqual(12,i.getNumberOfCellsWithType(NORM_TRI3));
5179         self.assertEqual(24,i.getNumberOfCellsWithType(NORM_QUAD4));
5180         expected1=[0.25,0.75,2.0625]
5181         j=i.getMeasureField(True);
5182         for ii in xrange(12):
5183             for k in xrange(3):
5184                 self.assertAlmostEqual(expected1[k],j.getIJ(0,ii*3+k),10);
5185                 pass
5186             pass
5187         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]
5188         m=i.getBarycenterAndOwner();
5189         for i in xrange(72):
5190             self.assertAlmostEqual(expected2[i],m.getIJ(0,i),10);
5191             pass
5192         #
5193         pass
5194
5195     def testExtrudedMesh6(self):
5196         coo1=[0.,1.,2.,3.5]
5197         a=DataArrayDouble.New();
5198         a.setValues(coo1,4,1);
5199         b=MEDCouplingCMesh.New();
5200         b.setCoordsAt(0,a);
5201         c=b.buildUnstructured();
5202         self.assertEqual(1,c.getSpaceDimension());
5203         c.changeSpaceDimension(2);
5204         #
5205         d=DataArrayDouble.New();
5206         d.alloc(5);
5207         d.iota();
5208         e=MEDCouplingCMesh.New();
5209         e.setCoordsAt(0,d);
5210         f=e.buildUnstructured();
5211         d2=f.getCoords().applyFunc("x*x/2");
5212         f.setCoords(d2);
5213         f.changeSpaceDimension(2);
5214         #
5215         center=[0.,0.]
5216         f.rotate(center,None,pi/3);
5217         g=c.buildExtrudedMesh(f,0);
5218         g.checkCoherency();
5219         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 ]
5220         f1=g.getMeasureField(True);
5221         for i in xrange(12):
5222             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),12);
5223             pass
5224         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]
5225         f2=g.getBarycenterAndOwner();
5226         for i in xrange(24):
5227             self.assertAlmostEqual(expected2[i],f2.getIJ(0,i),12);
5228             pass
5229         pass
5230
5231     def testExtrudedMesh7(self):
5232         coo1=[0.,1.,2.,3.5]
5233         a=DataArrayDouble.New();
5234         a.setValues(coo1,4,1);
5235         b=MEDCouplingCMesh.New();
5236         b.setCoordsAt(0,a);
5237         c=b.buildUnstructured();
5238         self.assertEqual(1,c.getSpaceDimension());
5239         c.changeSpaceDimension(2);
5240         #
5241         d=DataArrayDouble.New();
5242         d.alloc(13,1);
5243         d.iota();
5244         e=MEDCouplingCMesh.New();
5245         e.setCoordsAt(0,d);
5246         f=e.buildUnstructured();
5247         g=f.getCoords().applyFunc(2,"3.5*IVec+x/6*3.14159265359*JVec");
5248         h=g.fromPolarToCart();
5249         f.setCoords(h);
5250         i=c.buildExtrudedMesh(f,1);
5251         self.assertEqual(52,i.getNumberOfNodes());
5252         tmp,tmp2,tmp3=i.mergeNodes(1e-9);
5253         self.assertTrue(tmp2);
5254         self.assertEqual(37,tmp3);
5255         i.convertDegeneratedCells();
5256         vec1=[10.,0]
5257         i.translate(vec1);
5258         g2=h.applyFunc(3,"13.5/3.5*x*IVec+0*JVec+13.5/3.5*y*KVec");
5259         f.setCoords(g2);
5260         i.changeSpaceDimension(3);
5261         i3=i.buildExtrudedMesh(f,1);
5262         f2=i3.getMeasureField(True);
5263         tmp,tmp2,tmp3=i.mergeNodes(1e-9);
5264         self.assertTrue(tmp2);
5265         self.assertEqual(444,tmp3);
5266         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]
5267         for ii in xrange(12):
5268             for jj in xrange(36):
5269                 self.assertAlmostEqual(expected1[jj],f2.getIJ(0,ii*36+jj),9);
5270                 pass
5271         #
5272         pass
5273
5274     def testSimplexize1(self):
5275         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5276         m.convertToPolyTypes([3]);
5277         da=m.simplexize(0);
5278         self.assertEqual(7,da.getNumberOfTuples());
5279         self.assertEqual(1,da.getNumberOfComponents());
5280         expected2=[0,0,1,2,3,4,4]
5281         for i in xrange(7):
5282             self.assertEqual(expected2[i],da.getIJ(i,0));
5283             pass
5284         m.checkCoherency();
5285         self.assertEqual(7,m.getNumberOfCells());
5286         self.assertEqual(NORM_TRI3,m.getTypeOfCell(0));
5287         self.assertEqual(NORM_TRI3,m.getTypeOfCell(1));
5288         self.assertEqual(NORM_TRI3,m.getTypeOfCell(2));
5289         self.assertEqual(NORM_TRI3,m.getTypeOfCell(3));
5290         self.assertEqual(NORM_POLYGON,m.getTypeOfCell(4));
5291         self.assertEqual(NORM_TRI3,m.getTypeOfCell(5));
5292         self.assertEqual(NORM_TRI3,m.getTypeOfCell(6));
5293         expected1=[0.125,0.125,0.125,0.125,0.25,0.125,0.125]
5294         f=m.getMeasureField(False);
5295         for i in xrange(7):
5296             self.assertAlmostEqual(expected1[i]*sqrt(2.),f.getIJ(i,0),10);
5297             pass
5298         types=m.getAllGeoTypes();
5299         self.assertEqual([NORM_TRI3,NORM_POLYGON],types);
5300         #
5301         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5302         m.convertToPolyTypes([3]);
5303         da=m.simplexize(1);
5304         self.assertEqual(7,da.getNumberOfTuples());
5305         self.assertEqual(1,da.getNumberOfComponents());
5306         for i in xrange(7):
5307             self.assertEqual(expected2[i],da.getIJ(i,0));
5308             pass
5309         m.checkCoherency();
5310         types=m.getAllGeoTypes();
5311         self.assertEqual([NORM_TRI3,NORM_POLYGON],types);
5312         self.assertEqual(7,m.getNumberOfCells());
5313         self.assertEqual(NORM_TRI3,m.getTypeOfCell(0));
5314         self.assertEqual(NORM_TRI3,m.getTypeOfCell(1));
5315         self.assertEqual(NORM_TRI3,m.getTypeOfCell(2));
5316         self.assertEqual(NORM_TRI3,m.getTypeOfCell(3));
5317         self.assertEqual(NORM_POLYGON,m.getTypeOfCell(4));
5318         self.assertEqual(NORM_TRI3,m.getTypeOfCell(5));
5319         self.assertEqual(NORM_TRI3,m.getTypeOfCell(6));
5320         f=m.getMeasureField(False);
5321         for i in xrange(7):
5322             self.assertAlmostEqual(expected1[i]*sqrt(2.),f.getIJ(i,0),10);
5323             pass
5324         pass
5325
5326     def testSimplexize2(self):
5327         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5328         m.convertToPolyTypes([3]);
5329         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
5330         f1.setMesh(m);
5331         arr=DataArrayDouble.New();
5332         arr1=[10.,110.,20.,120.,30.,130.,40.,140.,50.,150.]
5333         arr.setValues(arr1,5,2);
5334         f1.setArray(arr);
5335         #
5336         f1.checkCoherency();
5337         self.assertTrue(f1.simplexize(0));
5338         f1.checkCoherency();
5339         expected1=[10.,110.,10.,110.,20.,120.,30.,130.,40.,140.,50.,150.,50.,150.]
5340         for i in xrange(14):
5341             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),10);
5342             pass
5343         self.assertTrue(not f1.simplexize(0));
5344         for i in xrange(14):
5345             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),10);
5346             pass
5347         #
5348         pass
5349
5350     def testDAMeld1(self):
5351         da1=DataArrayDouble.New();
5352         da1.alloc(7,2);
5353         da2=DataArrayDouble.New();
5354         da2.alloc(7,1);
5355         #
5356         da1.fillWithValue(7.);
5357         da2.iota(0.);
5358         da3=da2.applyFunc(3,"10*x*IVec+100*x*JVec+1000*x*KVec");
5359         #
5360         da1.setInfoOnComponent(0,"c0da1");
5361         da1.setInfoOnComponent(1,"c1da1");
5362         da3.setInfoOnComponent(0,"c0da3");
5363         da3.setInfoOnComponent(1,"c1da3");
5364         da3.setInfoOnComponent(2,"c2da3");
5365         #
5366         da1C=da1.deepCpy();
5367         da1.meldWith(da3);
5368         self.assertEqual(5,da1.getNumberOfComponents());
5369         self.assertEqual(7,da1.getNumberOfTuples());
5370         self.assertTrue(da1.getInfoOnComponent(0)=="c0da1");
5371         self.assertTrue(da1.getInfoOnComponent(1)=="c1da1");
5372         self.assertTrue(da1.getInfoOnComponent(2)=="c0da3");
5373         self.assertTrue(da1.getInfoOnComponent(3)=="c1da3");
5374         self.assertTrue(da1.getInfoOnComponent(4)=="c2da3");
5375         #
5376         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.]
5377         for i in xrange(35):
5378             self.assertAlmostEqual(expected1[i],da1.getIJ(0,i),10);
5379             pass
5380         #
5381         dai1=da1C.convertToIntArr();
5382         dai3=da3.convertToIntArr();
5383         dai1.meldWith(dai3);
5384         self.assertEqual(5,dai1.getNumberOfComponents());
5385         self.assertEqual(7,dai1.getNumberOfTuples());
5386         self.assertTrue(dai1.getInfoOnComponent(0)=="c0da1");
5387         self.assertTrue(dai1.getInfoOnComponent(1)=="c1da1");
5388         self.assertTrue(dai1.getInfoOnComponent(2)=="c0da3");
5389         self.assertTrue(dai1.getInfoOnComponent(3)=="c1da3");
5390         self.assertTrue(dai1.getInfoOnComponent(4)=="c2da3");
5391         for i in xrange(35):
5392             self.assertEqual(int(expected1[i]),dai1.getIJ(0,i));
5393             pass
5394         # test of static method DataArrayDouble::meld
5395         da4=DataArrayDouble.Meld(da1C,da3);
5396         tmp=DataArrayDouble.Meld([da1C,da3]);
5397         self.assertTrue(da4.isEqual(tmp,1e-10))
5398         self.assertEqual(5,da4.getNumberOfComponents());
5399         self.assertEqual(7,da4.getNumberOfTuples());
5400         self.assertTrue(da4.getInfoOnComponent(0)=="c0da1");
5401         self.assertTrue(da4.getInfoOnComponent(1)=="c1da1");
5402         self.assertTrue(da4.getInfoOnComponent(2)=="c0da3");
5403         self.assertTrue(da4.getInfoOnComponent(3)=="c1da3");
5404         self.assertTrue(da4.getInfoOnComponent(4)=="c2da3");
5405         for i in xrange(35):
5406             self.assertAlmostEqual(expected1[i],da4.getIJ(0,i),10);
5407             pass
5408         # test of static method DataArrayInt::meld
5409         dai1=da1C.convertToIntArr();
5410         dai4=DataArrayInt.Meld(dai1,dai3);
5411         tmp=DataArrayInt.Meld([dai1,dai3]);
5412         self.assertTrue(dai4.isEqual(tmp))
5413         self.assertEqual(5,dai4.getNumberOfComponents());
5414         self.assertEqual(7,dai4.getNumberOfTuples());
5415         self.assertTrue(dai4.getInfoOnComponent(0)=="c0da1");
5416         self.assertTrue(dai4.getInfoOnComponent(1)=="c1da1");
5417         self.assertTrue(dai4.getInfoOnComponent(2)=="c0da3");
5418         self.assertTrue(dai4.getInfoOnComponent(3)=="c1da3");
5419         self.assertTrue(dai4.getInfoOnComponent(4)=="c2da3");
5420         for i in xrange(35):
5421             self.assertEqual(int(expected1[i]),dai4.getIJ(0,i));
5422             pass
5423         pass
5424
5425     def testFieldMeld1(self):
5426         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5427         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
5428         f1.setMesh(m);
5429         da1=DataArrayDouble.New();
5430         arr1=[12.,23.,34.,45.,56.]
5431         da1.setValues(arr1,5,1);
5432         da1.setInfoOnComponent(0,"aaa");
5433         f1.setArray(da1);
5434         f1.setTime(3.4,2,1);
5435         f1.checkCoherency();
5436         #
5437         f2=f1.deepCpy();
5438         f2.setMesh(f1.getMesh());
5439         f2.checkCoherency();
5440         f2.changeNbOfComponents(2,5.);
5441         f2.assign(5.);
5442         f2.getArray().setInfoOnComponent(0,"bbb");
5443         f2.getArray().setInfoOnComponent(1,"ccc");
5444         f2.checkCoherency();
5445         #
5446         f3=MEDCouplingFieldDouble.MeldFields(f2,f1);
5447         f3.checkCoherency();
5448         self.assertEqual(5,f3.getNumberOfTuples());
5449         self.assertEqual(3,f3.getNumberOfComponents());
5450         self.assertTrue(f3.getArray().getInfoOnComponent(0)=="bbb");
5451         self.assertTrue(f3.getArray().getInfoOnComponent(1)=="ccc");
5452         self.assertTrue(f3.getArray().getInfoOnComponent(2)=="aaa");
5453         expected1=[5.,5.,12.,5.,5.,23.,5.,5.,34.,5.,5.,45.,5.,5.,56.]
5454         for i in xrange(15):
5455             self.assertAlmostEqual(expected1[i],f3.getIJ(0,i),12);
5456             pass
5457         time,dt,it=f3.getTime();
5458         self.assertAlmostEqual(3.4,time,14);
5459         self.assertEqual(2,dt);
5460         self.assertEqual(1,it);
5461         #
5462         f4=f2.buildNewTimeReprFromThis(NO_TIME,False);
5463         f5=f1.buildNewTimeReprFromThis(NO_TIME,False);
5464         f6=MEDCouplingFieldDouble.MeldFields(f4,f5);
5465         f6.checkCoherency();
5466         self.assertEqual(5,f6.getNumberOfTuples());
5467         self.assertEqual(3,f6.getNumberOfComponents());
5468         self.assertTrue(f6.getArray().getInfoOnComponent(0)=="bbb");
5469         self.assertTrue(f6.getArray().getInfoOnComponent(1)=="ccc");
5470         self.assertTrue(f6.getArray().getInfoOnComponent(2)=="aaa");
5471         for i in xrange(15):
5472             self.assertAlmostEqual(expected1[i],f6.getIJ(0,i),12);
5473             pass
5474         #
5475         pass
5476
5477     def testMergeNodes2(self):
5478         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5479         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
5480         vec=[0.002,0.]
5481         m2.translate(vec);
5482         #
5483         m3=MEDCouplingUMesh.MergeUMeshes([m1,m2]);
5484         da,b,newNbOfNodes=m3.mergeNodes2(0.01);
5485         self.assertEqual(9,m3.getNumberOfNodes());
5486         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]
5487         for i in xrange(18):
5488             self.assertAlmostEqual(expected1[i],m3.getCoords().getIJ(0,i),13);
5489             pass
5490         #
5491         pass
5492
5493     def testMergeField2(self):
5494         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5495         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
5496         f1.setMesh(m);
5497         arr=DataArrayDouble.New();
5498         arr.alloc(5,2);
5499         arr.fillWithValue(2.);
5500         f1.setArray(arr);
5501         f2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
5502         f2.setMesh(m);
5503         arr=DataArrayDouble.New();
5504         arr.alloc(5,2);
5505         arr.fillWithValue(5.);
5506         f2.setArray(arr);
5507         f3=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
5508         f3.setMesh(m);
5509         arr=DataArrayDouble.New();
5510         arr.alloc(5,2);
5511         arr.fillWithValue(7.);
5512         f3.setArray(arr);
5513         #
5514         f4=MEDCouplingFieldDouble.MergeFields([f1,f2,f3]);
5515         self.assertEqual(15,f4.getMesh().getNumberOfCells());
5516         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.]
5517         for i in xrange(30):
5518             self.assertAlmostEqual(expected1[i],f4.getIJ(0,i),13);
5519             pass
5520         #
5521         pass
5522
5523     def testDAIBuildComplement1(self):
5524         a=DataArrayInt.New();
5525         tab=[3,1,7,8]
5526         a.setValues(tab,4,1);
5527         b=a.buildComplement(12);
5528         self.assertEqual(8,b.getNumberOfTuples());
5529         self.assertEqual(1,b.getNumberOfComponents());
5530         expected1=[0,2,4,5,6,9,10,11]
5531         for i in xrange(8):
5532             self.assertEqual(expected1[i],b.getIJ(0,i));
5533             pass
5534         pass
5535
5536     def testDAIBuildUnion1(self):
5537         a=DataArrayInt.New();
5538         tab1=[3,1,7,8]
5539         a.setValues(tab1,4,1);
5540         c=DataArrayInt.New();
5541         tab2=[5,3,0,18,8]
5542         c.setValues(tab2,5,1);
5543         b=a.buildUnion(c);
5544         self.assertEqual(7,b.getNumberOfTuples());
5545         self.assertEqual(1,b.getNumberOfComponents());
5546         expected1=[0,1,3,5,7,8,18]
5547         for i in xrange(7):
5548             self.assertEqual(expected1[i],b.getIJ(0,i));
5549             pass
5550         b=DataArrayInt.BuildUnion([a,c]);
5551         self.assertEqual(7,b.getNumberOfTuples());
5552         self.assertEqual(1,b.getNumberOfComponents());
5553         expected1=[0,1,3,5,7,8,18]
5554         for i in xrange(7):
5555             self.assertEqual(expected1[i],b.getIJ(0,i));
5556             pass
5557         pass
5558
5559     def testDAIBuildIntersection1(self):
5560         a=DataArrayInt.New();
5561         tab1=[3,1,7,8]
5562         a.setValues(tab1,4,1);
5563         c=DataArrayInt.New();
5564         tab2=[5,3,0,18,8]
5565         c.setValues(tab2,5,1);
5566         b=a.buildIntersection(c);
5567         self.assertEqual(2,b.getNumberOfTuples());
5568         self.assertEqual(1,b.getNumberOfComponents());
5569         expected1=[3,8]
5570         for i in xrange(2):
5571             self.assertEqual(expected1[i],b.getIJ(0,i));
5572             pass
5573         b=DataArrayInt.BuildIntersection([a,c]);
5574         self.assertEqual(2,b.getNumberOfTuples());
5575         self.assertEqual(1,b.getNumberOfComponents());
5576         expected1=[3,8]
5577         for i in xrange(2):
5578             self.assertEqual(expected1[i],b.getIJ(0,i));
5579             pass
5580         pass
5581
5582     def testDAIDeltaShiftIndex1(self):
5583         a=DataArrayInt.New();
5584         tab=[1,3,6,7,7,9,15]
5585         a.setValues(tab,7,1);
5586         b=a.deltaShiftIndex();
5587         self.assertEqual(6,b.getNumberOfTuples());
5588         self.assertEqual(1,b.getNumberOfComponents());
5589         expected1=[2,3,1,0,2,6]
5590         for i in xrange(6):
5591             self.assertEqual(expected1[i],b.getIJ(0,i));
5592             pass
5593         pass
5594
5595     def testDaDoubleSelectByTupleIdSafe1(self):
5596         a=DataArrayDouble.New();
5597         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]
5598         a.setValues(arr1,7,2);
5599         a.setInfoOnComponent(0,"toto");
5600         a.setInfoOnComponent(1,"tata");
5601         #
5602         arr2=[4,2,0,6,5]
5603         b=a.selectByTupleIdSafe(arr2);
5604         self.assertEqual(5,b.getNumberOfTuples());
5605         self.assertEqual(2,b.getNumberOfComponents());
5606         self.assertTrue(b.getInfoOnComponent(0)=="toto");
5607         self.assertTrue(b.getInfoOnComponent(1)=="tata");
5608         expected1=[5.1,15.1,3.1,13.1,1.1,11.1,7.1,17.1,6.1,16.1]
5609         for i in xrange(10):
5610             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
5611             pass
5612         arr4=[4,-1,0,6,5]
5613         self.assertRaises(InterpKernelException,a.selectByTupleIdSafe,arr4);
5614         arr5=[4,2,0,6,7]
5615         self.assertRaises(InterpKernelException,a.selectByTupleIdSafe,arr5);
5616         #
5617         c=DataArrayInt.New();
5618         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
5619         c.setValues(arr3,7,2);
5620         c.setInfoOnComponent(0,"toto");
5621         c.setInfoOnComponent(1,"tata");
5622         d=c.selectByTupleIdSafe(arr2);
5623         self.assertEqual(5,d.getNumberOfTuples());
5624         self.assertEqual(2,d.getNumberOfComponents());
5625         self.assertTrue(d.getInfoOnComponent(0)=="toto");
5626         self.assertTrue(d.getInfoOnComponent(1)=="tata");
5627         expected2=[5,15,3,13,1,11,7,17,6,16]
5628         for i in xrange(10):
5629             self.assertEqual(expected2[i],d.getIJ(0,i));
5630             pass
5631         self.assertRaises(InterpKernelException,c.selectByTupleIdSafe,arr4);
5632         self.assertRaises(InterpKernelException,c.selectByTupleIdSafe,arr5);
5633         pass
5634
5635     def testAreCellsIncludedIn1(self):
5636         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5637         pt=[1,3]
5638         m2=m.buildPartOfMySelf(pt,True);
5639         ret,tmp=m.areCellsIncludedIn(m2,0)
5640         self.assertTrue(ret);
5641         self.assertEqual(2,tmp.getNumberOfTuples());
5642         self.assertEqual(1,tmp.getNumberOfComponents());
5643         self.assertEqual(pt[0],tmp.getIJ(0,0));
5644         self.assertEqual(pt[1],tmp.getIJ(0,1));
5645         ret,tmp=m2.areCellsIncludedIn(m,0)
5646         self.assertTrue(not ret);
5647         m3=MEDCouplingUMesh.MergeUMeshesOnSameCoords(m,m2)
5648         c,cI=m3.findCommonCells(2,m.getNumberOfCells())
5649         self.assertTrue(c.isEqual(DataArrayInt([1,5,3,6])))
5650         self.assertTrue(cI.isEqual(DataArrayInt([0,2,4])))
5651         pass
5652
5653     def testSwigErrorProtection1(self):
5654         m=MEDCouplingDataForTest.build3DTargetMesh_1();
5655         m.rotate([0.,0.,0.],[0.3,0.6,1.2],0.37)
5656         m.rotate([0.,0.,0.],[0.3,6,1.2],0.37)
5657         self.assertRaises(InterpKernelException,m.rotate,[0.,0.,0.],(0.3,6,"1.2"),0.37)
5658         self.assertRaises(InterpKernelException,m.rotate,[0.,"0.",0.],[0.3,0.6,1.2],0.37)
5659         self.assertRaises(InterpKernelException,m.rotate,[0.,0.,0.],[0.3,'0.6',1.2],0.37)
5660         m2=m.buildPartOfMySelf([2,5],True)
5661         m3=m.buildPartOfMySelf((2,5),True)
5662         self.assertTrue(m2.isEqual(m3,1e-12))
5663         self.assertRaises(InterpKernelException,m.buildPartOfMySelf,[2,5.],True)
5664         da1=m.getCoords().keepSelectedComponents([1])
5665         da2=m.getCoords().keepSelectedComponents((1,))
5666         self.assertTrue(da1.isEqual(da2,1e-12))
5667         self.assertRaises(InterpKernelException,m.getCoords().keepSelectedComponents,["1"])
5668         pass
5669
5670     def testDAIBuildSubstraction1(self):
5671         a=DataArrayInt.New()
5672         aa=[2,3,6,8,9]
5673         a.setValues(aa,5,1)
5674         b=DataArrayInt.New()
5675         bb=[1,3,5,9,11]
5676         b.setValues(bb,5,1)
5677         self.assertEqual([2,6,8],a.buildSubstraction(b).getValues())
5678         pass
5679
5680     def testBuildOrthogonalField2(self):
5681         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5682         d1=DataArrayInt.New();
5683         d2=DataArrayInt.New();
5684         d3=DataArrayInt.New();
5685         d4=DataArrayInt.New();
5686         m1=m.buildDescendingConnectivity(d1,d2,d3,d4);
5687         #
5688         f1=m1.buildOrthogonalField();
5689         da1=f1.getArray();
5690         self.assertEqual(2,da1.getNumberOfComponents());
5691         self.assertEqual(13,da1.getNumberOfTuples());
5692         #
5693         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.];
5694         for i in xrange(26):
5695             self.assertAlmostEqual(expected1[i],da1.getIJ(0,i),14);
5696             pass
5697         pass
5698
5699     def testSwigErrorProtection2(self):
5700         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5701         coo=m.getCoords()
5702         c=m.getNodalConnectivity()
5703         ci=m.getNodalConnectivityIndex()
5704         del m
5705         self.assertEqual(2,coo.getNumberOfComponents());
5706         self.assertEqual(6,ci.getNumberOfTuples());
5707         self.assertEqual(23,c.getNumberOfTuples());
5708         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5709         f=m.getMeasureField(True)
5710         c=f.getArray()
5711         del f
5712         self.assertEqual(1,c.getNumberOfComponents());
5713         m=MEDCouplingCMesh.New()
5714         x=DataArrayDouble.New()
5715         x.setValues([1.,2.,4.],3,1)
5716         m.setCoordsAt(0,x)
5717         del x
5718         xx=m.getCoordsAt(0)
5719         del m
5720         self.assertEqual(3,xx.getNumberOfTuples());
5721         #
5722         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5723         f=m.getMeasureField(True)
5724         m2=f.getMesh()
5725         del m
5726         del f
5727         self.assertEqual(5,m2.getNumberOfCells());
5728         pass
5729
5730     def testUMInsertNextCell1(self):
5731         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 ]
5732         targetConn=[0,3,4,1, 1,4,2, 4,5,2, 6,7,4,3, 7,8,5,4]
5733         targetMesh=MEDCouplingUMesh.New();
5734         targetMesh.allocateCells(5);
5735         self.assertRaises(InterpKernelException,targetMesh.insertNextCell,NORM_QUAD4,4,targetConn[0:4])
5736         targetMesh.setMeshDimension(2);
5737         targetMesh.insertNextCell(NORM_QUAD4,4,targetConn[0:4])
5738         self.assertRaises(InterpKernelException,targetMesh.insertNextCell,NORM_TETRA4,4,targetConn[0:4])
5739         self.assertRaises(InterpKernelException,targetMesh.insertNextCell,NORM_SEG2,2,targetConn[0:2])
5740         self.assertRaises(InterpKernelException,targetMesh.insertNextCell,NORM_POINT1,1,targetConn[0:1])
5741         targetMesh.insertNextCell(NORM_TRI3,3,targetConn[4:7])
5742         targetMesh.insertNextCell(NORM_TRI3,3,targetConn[7:10])
5743         targetMesh.insertNextCell(NORM_QUAD4,4,targetConn[10:14])
5744         targetMesh.insertNextCell(NORM_QUAD4,4,targetConn[14:18])
5745         targetMesh.finishInsertingCells();
5746         myCoords=DataArrayDouble.New();
5747         myCoords.setValues(targetCoords,9,2);
5748         targetMesh.setCoords(myCoords);
5749         targetMesh.checkCoherency();
5750         pass
5751
5752     def testFieldOperatorDivDiffComp1(self):
5753         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5754         m1,d0,d1,d2,d3=m.buildDescendingConnectivity();
5755         #
5756         f1=m1.buildOrthogonalField();
5757         arr1=[2.,3.,4.,5.,6.,7.,8.,9.,10.,11.,12.,13.,14.]
5758         arr=DataArrayDouble.New();
5759         arr.setValues(arr1,13,1);
5760         f2=MEDCouplingFieldDouble.New(ON_CELLS);
5761         f2.setArray(arr);
5762         f2.setMesh(m1);
5763         f2.checkCoherency();
5764         #
5765         f3=f1/f2;
5766         self.assertRaises(InterpKernelException,f2.__div__,f1)
5767         f3.checkCoherency();
5768         f1/=f2;
5769         #self.assertRaises(InterpKernelException,f2.__idiv__,f1) # mem leaks
5770         self.assertTrue(f1.isEqual(f3,1e-10,1e-10));
5771         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]
5772         for i in xrange(26):
5773             self.assertAlmostEqual(expected1[i],f3.getIJ(0,i),10);
5774             pass
5775         pass
5776
5777     def testDARearrange1(self):
5778         da1=DataArrayInt.New();
5779         da1.alloc(12,1);
5780         da1.iota(0);
5781         #
5782         self.assertEqual(12,da1.getNbOfElems());
5783         self.assertEqual(1,da1.getNumberOfComponents());
5784         self.assertEqual(12,da1.getNumberOfTuples());
5785         da1.rearrange(4);
5786         self.assertEqual(12,da1.getNbOfElems());
5787         self.assertEqual(4,da1.getNumberOfComponents());
5788         self.assertEqual(3,da1.getNumberOfTuples());
5789         for i in xrange(12):
5790             self.assertEqual(i,da1.getIJ(0,i));
5791         #
5792         da1.rearrange(6);
5793         self.assertEqual(12,da1.getNbOfElems());
5794         self.assertEqual(6,da1.getNumberOfComponents());
5795         self.assertEqual(2,da1.getNumberOfTuples());
5796         for i in xrange(12):
5797             self.assertEqual(i,da1.getIJ(0,i));
5798         #
5799         self.assertRaises(InterpKernelException,da1.rearrange,7);
5800         #
5801         da1.rearrange(12);
5802         self.assertEqual(12,da1.getNbOfElems());
5803         self.assertEqual(12,da1.getNumberOfComponents());
5804         self.assertEqual(1,da1.getNumberOfTuples());
5805         for i in xrange(12):
5806             self.assertEqual(i,da1.getIJ(0,i));
5807         #
5808         da1.rearrange(3);
5809         self.assertEqual(12,da1.getNbOfElems());
5810         self.assertEqual(3,da1.getNumberOfComponents());
5811         self.assertEqual(4,da1.getNumberOfTuples());
5812         for i in xrange(12):
5813             self.assertEqual(i,da1.getIJ(0,i));
5814         #double
5815         da2=da1.convertToDblArr();
5816         st=da2.getHiddenCppPointer()
5817         #
5818         self.assertEqual(12,da2.getNbOfElems());
5819         self.assertEqual(3,da2.getNumberOfComponents());
5820         self.assertEqual(4,da2.getNumberOfTuples());
5821         da2.rearrange(4);
5822         self.assertEqual(12,da2.getNbOfElems());
5823         self.assertEqual(4,da2.getNumberOfComponents());
5824         self.assertEqual(3,da2.getNumberOfTuples());
5825         for i in xrange(12):
5826             self.assertAlmostEqual(float(i),da2.getIJ(0,i),14);
5827         #
5828         da2.rearrange(6);
5829         self.assertEqual(12,da2.getNbOfElems());
5830         self.assertEqual(6,da2.getNumberOfComponents());
5831         self.assertEqual(2,da2.getNumberOfTuples());
5832         for i in xrange(12):
5833             self.assertAlmostEqual(float(i),da2.getIJ(0,i),14);
5834         #
5835         self.assertRaises(InterpKernelException,da2.rearrange,7);
5836         #
5837         da2.rearrange(1);
5838         self.assertEqual(st,da2.getHiddenCppPointer())
5839         self.assertEqual(12,da2.getNbOfElems());
5840         self.assertEqual(1,da2.getNumberOfComponents());
5841         self.assertEqual(12,da2.getNumberOfTuples());
5842         for i in xrange(12):
5843             self.assertAlmostEqual(float(i),da2.getIJ(0,i),14);
5844         #
5845         da2.rearrange(3);
5846         self.assertEqual(12,da2.getNbOfElems());
5847         self.assertEqual(3,da2.getNumberOfComponents());
5848         self.assertEqual(4,da2.getNumberOfTuples());
5849         for i in xrange(12):
5850             self.assertAlmostEqual(float(i),da2.getIJ(0,i),14);
5851         pass
5852
5853     def testDARearrange2(self):
5854         da1=DataArrayInt.New();
5855         arr=[1,2,3,2,2,3,5,1,5,5,2,2]
5856         da1.setValues(arr,4,3);
5857         s=da1.getDifferentValues();
5858         expected1=DataArrayInt([1,2,3,5])
5859         self.assertTrue(expected1.isEqual(s));
5860         pass
5861
5862     def testSwigErrorProtection3(self):
5863         da=DataArrayInt.New()
5864         da.setValues([1,2,3,4,0,0,0,0,0,0,0,0],4,3)
5865         self.assertEqual([1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0],da.getValues())
5866         self.assertEqual(3,da.getNumberOfComponents());
5867         self.assertEqual(4,da.getNumberOfTuples());
5868         da=DataArrayInt.New()
5869         da.setValues(((1,2,3),(4,4,3),(0,0,0),(0,0,0)),4,3)
5870         self.assertEqual([1, 2, 3, 4, 4, 3, 0, 0, 0, 0, 0, 0],da.getValues())
5871         self.assertEqual(3,da.getNumberOfComponents());
5872         self.assertEqual(4,da.getNumberOfTuples());
5873         da.setValues((10*[1]+290*[2])[:12],4,3)
5874         self.assertEqual(10*[1]+[2,2],da.getValues())
5875         self.assertEqual(3,da.getNumberOfComponents());
5876         self.assertEqual(4,da.getNumberOfTuples());
5877         #
5878         da=DataArrayDouble.New()
5879         da.setValues([1,2,3.,4,0,0,0,0,0,0,0,0],4,3)
5880         self.assertEqual([1., 2., 3., 4., 0., 0., 0., 0., 0., 0., 0., 0.],da.getValues())
5881         self.assertEqual(3,da.getNumberOfComponents());
5882         self.assertEqual(4,da.getNumberOfTuples());
5883         da=DataArrayDouble.New()
5884         da.setValues(((1,2,3),(4.,4,3),(0,0,0),(0,0,0)),4,3)
5885         self.assertEqual([1., 2., 3., 4., 4., 3., 0., 0., 0., 0., 0., 0.],da.getValues())
5886         self.assertEqual(3,da.getNumberOfComponents());
5887         self.assertEqual(4,da.getNumberOfTuples());
5888         da.setValues((10*[1]+290*[2])[:12],4,3)
5889         self.assertEqual(10*[1.]+[2.,2.],da.getValues())
5890         self.assertEqual(3,da.getNumberOfComponents());
5891         self.assertEqual(4,da.getNumberOfTuples());
5892         pass
5893
5894     def testDAIBuildPermutationArr1(self):
5895         a=DataArrayInt.New()
5896         a.setValues([4,5,6,7,8],5,1)
5897         b=DataArrayInt.New()
5898         b.setValues([5,4,8,6,7],5,1)
5899         c=a.buildPermutationArr(b)
5900         self.assertEqual([1,0,4,2,3],c.getValues())
5901         self.assertTrue(a.isEqualWithoutConsideringStrAndOrder(b))
5902         b.setIJ(0,0,9)
5903         self.assertTrue(not a.isEqualWithoutConsideringStrAndOrder(b))
5904         self.assertRaises(InterpKernelException,a.buildPermutationArr,b)
5905         a.setIJ(3,0,4)
5906         b.setIJ(0,0,5)
5907         b.setIJ(4,0,4)#a==[4,5,6,4,8] and b==[5,4,8,6,4]
5908         self.assertTrue(a.isEqualWithoutConsideringStrAndOrder(b))
5909         c=a.buildPermutationArr(b)
5910         self.assertEqual([1,3,4,2,3],c.getValues())
5911         d=b.convertToDblArr()
5912         expect3=[4,4,5,6,8]
5913         b.sort()
5914         self.assertEqual(expect3,b.getValues())
5915         d.sort()
5916         self.assertEqual(5,d.getNumberOfTuples());
5917         self.assertEqual(1,d.getNumberOfComponents());
5918         for i in xrange(5):
5919             self.assertAlmostEqual(float(expect3[i]),d.getIJ(i,0),14);
5920             pass
5921         pass
5922
5923     def testAreCellsIncludedIn2(self):
5924         myName="Vitoo";
5925         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5926         m2=m.buildPartOfMySelf([],True);
5927         self.assertEqual(0,m2.getNumberOfCells());
5928         self.assertEqual(3,m2.getSpaceDimension());
5929         self.assertEqual(2,m2.getMeshDimension());
5930         m2.setName(myName);
5931         test,tmp=m.areCellsIncludedIn(m2,0)
5932         self.assertTrue(test);
5933         self.assertEqual(myName,tmp.getName());
5934         self.assertEqual(0,tmp.getNumberOfTuples())
5935         self.assertEqual(1,tmp.getNumberOfComponents())
5936         pass
5937
5938     def testUMeshGetPartBarycenterAndOwner1(self):
5939         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5940         part1=[1,0,4];
5941         part=DataArrayInt.New();
5942         part.setValues(part1,3,1);
5943         b=m1.getPartBarycenterAndOwner(part);
5944         self.assertEqual(2,b.getNumberOfComponents());
5945         self.assertEqual(3,b.getNumberOfTuples());
5946         expected1=[0.36666666666666665,-0.13333333333333333,-0.05,-0.05,0.45,0.45];
5947         for i in xrange(6):
5948             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
5949             pass
5950         pass
5951
5952     def testUMeshGetPartMeasureField1(self):
5953         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5954         part1=[1,0,4];
5955         part=DataArrayInt.New();
5956         part.setValues(part1,3,1);
5957         b=m1.getPartMeasureField(True,part);
5958         self.assertEqual(1,b.getNumberOfComponents());
5959         self.assertEqual(3,b.getNumberOfTuples());
5960         expected1=[0.125,0.25,0.25];
5961         for i in xrange(3):
5962             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
5963             pass
5964         pass
5965
5966     def testUMeshBuildPartOrthogonalField1(self):
5967         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5968         m1.changeSpaceDimension(3);
5969         part1=[1,0,4];
5970         part=DataArrayInt.New();
5971         part.setValues(part1,3,1);
5972         b=m1.buildPartOrthogonalField(part);
5973         self.assertEqual(3,b.getArray().getNumberOfComponents());
5974         self.assertEqual(3,b.getArray().getNumberOfTuples());
5975         expected1=[0.,0.,-1.,0.,0.,-1.,0.,0.,-1.];
5976         for i in xrange(9):
5977             self.assertAlmostEqual(expected1[i],b.getArray().getIJ(0,i),14);
5978             pass
5979         pass
5980
5981     def testUMeshGetTypesOfPart1(self):
5982         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5983         part1=[0,3,4];
5984         p1=DataArrayInt.New()
5985         p1.setValues(part1,3,1)
5986         s=m1.getTypesOfPart(p1);
5987         self.assertEqual([NORM_QUAD4],s);
5988         part2=[2,2,2,1];
5989         p2=DataArrayInt.New()
5990         p2.setValues(part2,4,1)
5991         s=m1.getTypesOfPart(p2);
5992         self.assertEqual([NORM_TRI3],s);
5993         part3=[3,2,1];
5994         p3=DataArrayInt.New()
5995         p3.setValues(part3,3,1)
5996         s=m1.getTypesOfPart(p3);
5997         self.assertEqual(s,[NORM_TRI3,NORM_QUAD4]);
5998         pass
5999
6000     def testUMeshKeepCellIdsByType1(self):
6001         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
6002         part1=[0,3,4]
6003         p1=DataArrayInt.New()
6004         p1.setValues(part1,3,1)
6005         p1.setName("p1")
6006         a=m1.keepCellIdsByType(NORM_TRI3,p1);
6007         self.assertEqual("p1",a.getName())
6008         self.assertEqual(1,a.getNumberOfComponents());
6009         self.assertEqual(0,a.getNumberOfTuples());
6010         #
6011         part2=[3,2,0,2,4]
6012         p2=DataArrayInt.New()
6013         p2.setValues(part2,5,1)
6014         p2.setName("p2")
6015         a=m1.keepCellIdsByType(NORM_TRI3,p2);
6016         self.assertEqual("p2",a.getName())
6017         self.assertEqual(1,a.getNumberOfComponents());
6018         self.assertEqual(2,a.getNumberOfTuples());
6019         self.assertEqual(2,a.getIJ(0,0));
6020         self.assertEqual(2,a.getIJ(1,0));
6021         #
6022         a=m1.keepCellIdsByType(NORM_QUAD4,p2);
6023         self.assertEqual("p2",a.getName())
6024         self.assertEqual(1,a.getNumberOfComponents());
6025         self.assertEqual(3,a.getNumberOfTuples());
6026         self.assertEqual(3,a.getIJ(0,0));
6027         self.assertEqual(0,a.getIJ(1,0));
6028         self.assertEqual(4,a.getIJ(2,0));
6029         pass
6030
6031     def testSwigErrorDaIntSelectByTupleId1(self):
6032         a=DataArrayInt.New();
6033         arr1=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
6034         a.setValues(arr1,7,2);
6035         a.setInfoOnComponent(0,"toto");
6036         a.setInfoOnComponent(1,"tata");
6037         #
6038         arr2=[4,2,0,6,5]
6039         b=a.selectByTupleId(arr2);
6040         self.assertEqual(5,b.getNumberOfTuples());
6041         self.assertEqual(2,b.getNumberOfComponents());
6042         self.assertTrue(b.getInfoOnComponent(0)=="toto");
6043         self.assertTrue(b.getInfoOnComponent(1)=="tata");
6044         expected1=[5,15,3,13,1,11,7,17,6,16]
6045         self.assertEqual(expected1,b.getValues())
6046         #
6047         a2=DataArrayInt.New()
6048         a2.setValues(arr2,5,1)
6049         b=a.selectByTupleId(a2);
6050         self.assertEqual(5,b.getNumberOfTuples());
6051         self.assertEqual(2,b.getNumberOfComponents());
6052         self.assertTrue(b.getInfoOnComponent(0)=="toto");
6053         self.assertTrue(b.getInfoOnComponent(1)=="tata");
6054         expected1=[5,15,3,13,1,11,7,17,6,16]
6055         self.assertEqual(expected1,b.getValues())
6056         pass
6057
6058     def testSwigErrorRenum(self):
6059         da=DataArrayDouble.New()
6060         da.setValues([7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.],10,2)
6061         d=DataArrayInt.New()
6062         d.setValues([0,2,3,1,4,5,6,8,7,9],10,1)
6063         da.renumberInPlace(d)
6064         da.renumber(d)
6065         pass
6066
6067     def testSwigGetItem1(self):
6068         da=DataArrayInt.New()
6069         da.alloc(16,3)
6070         da.rearrange(1)
6071         da.iota(7)
6072         da.rearrange(3)
6073         da.setInfoOnComponent(0,"X [m]")
6074         da.setInfoOnComponent(1,"Y [m]")
6075         da.setInfoOnComponent(2,"Z [km]")
6076         da2=da[5:-1]
6077         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())
6078         da2=da[4]
6079         self.assertEqual([19, 20, 21],da2.getValues())
6080         try:
6081             da2=da[4:17]
6082         except InterpKernelException as e:
6083             self.assertTrue(True)
6084         else:
6085             self.assertTrue(False)
6086             pass
6087         da2=da[5:-2,2]
6088         self.assertEqual([24, 27, 30, 33, 36, 39, 42, 45, 48],da2.getValues())
6089         da2=da[5:8,:]
6090         self.assertEqual([22, 23, 24, 25, 26, 27, 28, 29, 30],da2.getValues())
6091         da2=da[:]
6092         self.assertTrue(da2.isEqual(da))
6093         da2=da[:,:]
6094         self.assertTrue(da2.isEqual(da))
6095         try:
6096             da2=da[:,:,:]
6097         except InterpKernelException as e:
6098             self.assertTrue(True)
6099         else:
6100             self.assertTrue(False)
6101             pass
6102         self.assertTrue(da[5:8,-2].isEqualWithoutConsideringStr(DataArrayInt([23,26,29])))
6103         da2=da[5:8,:-2]
6104         self.assertEqual([22, 25, 28],da2.getValues())
6105         try:
6106             da2=da[5:-18,2]
6107         except InterpKernelException as e:
6108             self.assertTrue(True)
6109         else:
6110             self.assertTrue(False)
6111             pass
6112         da2=da[5:5,2]
6113         self.assertEqual([],da2.getValues())
6114         pass
6115
6116     def testSwigGetItem2(self):
6117         da=DataArrayDouble.New()
6118         da.alloc(16,3)
6119         da.rearrange(1)
6120         da.iota(7)
6121         da.rearrange(3)
6122         da.setInfoOnComponent(0,"X [m]")
6123         da.setInfoOnComponent(1,"Y [m]")
6124         da.setInfoOnComponent(2,"Z [km]")
6125         da2=da[5:-1]
6126         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())
6127         da2=da[4]
6128         self.assertEqual([19., 20., 21],da2.getValues())
6129         try:
6130             da2=da[4:17]
6131         except InterpKernelException as e:
6132             self.assertTrue(True)
6133         else:
6134             self.assertTrue(False)
6135             pass
6136         da2=da[5:-2,2]
6137         self.assertEqual([24., 27., 30., 33., 36., 39., 42., 45., 48.],da2.getValues())
6138         da2=da[5:8,:]
6139         self.assertEqual([22., 23., 24., 25., 26., 27., 28., 29., 30.],da2.getValues())
6140         da2=da[:]
6141         self.assertTrue(da2.isEqual(da,1e-12))
6142         da2=da[:,:]
6143         self.assertTrue(da2.isEqual(da,1e-12))
6144         try:
6145             da2=da[:,:,:]
6146         except InterpKernelException as e:
6147             self.assertTrue(True)
6148         else:
6149             self.assertTrue(False)
6150             pass
6151         self.assertTrue(da[5:8,-2].isEqualWithoutConsideringStr(DataArrayDouble([23.,26.,29.]),1e-12))
6152         da2=da[5:8,:-2]
6153         self.assertEqual([22., 25., 28.],da2.getValues())
6154         try:
6155             da2=da[5:-18,2]
6156         except InterpKernelException as e:
6157             self.assertTrue(True)
6158         else:
6159             self.assertTrue(False)
6160             pass
6161         da2=da[5:5,2]
6162         self.assertEqual([],da2.getValues())
6163         pass
6164
6165     def testSwigSetItem1(self):
6166         da=DataArrayInt.New()
6167         da.alloc(20,1)
6168         da.iota(7)
6169         da.rearrange(5)
6170         da.setInfoOnComponent(0,"X [m]") ; da.setInfoOnComponent(1,"Y [km]") ; da.setInfoOnComponent(2,"Y [m]")
6171         da.setInfoOnComponent(3,"Z [W]") ; da.setInfoOnComponent(4,"ZZ [km]") ;
6172         da[:,2]=3
6173         self.assertEqual([7, 8, 3, 10, 11, 12, 13, 3, 15, 16, 17, 18, 3, 20, 21, 22, 23, 3, 25, 26],da.getValues())
6174         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6175         da[2]=3
6176         self.assertEqual([7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 3, 3, 3, 3, 3, 22, 23, 24, 25, 26],da.getValues())
6177         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6178         da[[0,3]]=-1
6179         self.assertEqual([-1, -1, -1, -1, -1, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, -1, -1, -1, -1, -1],da.getValues())
6180         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6181         da[:,[1,3,4]]=-3
6182         self.assertEqual([7, -3, 9, -3, -3, 12, -3, 14, -3, -3, 17, -3, 19, -3, -3, 22, -3, 24, -3, -3],da.getValues())
6183         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6184         da2=DataArrayInt.New() ; da2.setValues([0,2,3],3,1)
6185         da[da2]=-7
6186         self.assertEqual([-7, -7, -7, -7, -7, 12, 13, 14, 15, 16, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7],da.getValues())
6187         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6188         da[da2,-2:]=-7
6189         self.assertEqual([7, 8, 9, -7, -7, 12, 13, 14, 15, 16, 17, 18, 19, -7, -7, 22, 23, 24, -7, -7],da.getValues())
6190         # Let's test with DAI right hand side
6191         da1=DataArrayInt.New()
6192         da1.setValues([25,26,27,125,126,127],2,3)
6193         #
6194         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6195         da[-2:,1:4]=da1
6196         self.assertEqual([7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 25, 26, 27, 21, 22, 125, 126, 127, 26],da.getValues())
6197         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6198         da[1:,3]=[225,226,227]
6199         self.assertEqual([7, 8, 9, 10, 11, 12, 13, 14, 225, 16, 17, 18, 19, 226, 21, 22, 23, 24, 227, 26],da.getValues())
6200         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6201         da[1,2:]=[225,226,227]
6202         self.assertEqual([7, 8, 9, 10, 11, 12, 13, 225, 226, 227, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26],da.getValues())
6203         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6204         da[da2,-2:]=[88,99,1010,1111,1212,1313]
6205         self.assertEqual([7, 8, 9, 88, 99, 12, 13, 14, 15, 16, 17, 18, 19, 1010, 1111, 22, 23, 24, 1212, 1313],da.getValues())
6206         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6207         da3=DataArrayInt.New(); da3.setValues([88,99,1010,1111,1212,1313],3,2)
6208         da[da2,-2:]=da3
6209         self.assertEqual([7, 8, 9, 88, 99, 12, 13, 14, 15, 16, 17, 18, 19, 1010, 1111, 22, 23, 24, 1212, 1313],da.getValues())
6210         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6211         da[da2,[0,2]]=da3
6212         self.assertEqual([88, 8, 99, 10, 11, 12, 13, 14, 15, 16, 1010, 18, 1111, 20, 21, 1212, 23, 1313, 25, 26],da.getValues())
6213         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6214         da[da2,0:3:2]=da3
6215         self.assertEqual([88, 8, 99, 10, 11, 12, 13, 14, 15, 16, 1010, 18, 1111, 20, 21, 1212, 23, 1313, 25, 26],da.getValues())
6216         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6217         da[da2,0:3:2]=-8
6218         self.assertEqual([-8, 8, -8, 10, 11, 12, 13, 14, 15, 16, -8, 18, -8, 20, 21, -8, 23, -8, 25, 26],da.getValues())
6219         pass
6220
6221     def testSwigSetItem2(self):
6222         da=DataArrayDouble.New()
6223         da.alloc(20,1)
6224         da.iota(7)
6225         da.rearrange(5)
6226         da.setInfoOnComponent(0,"X [m]") ; da.setInfoOnComponent(1,"Y [km]") ; da.setInfoOnComponent(2,"Y [m]")
6227         da.setInfoOnComponent(3,"Z [W]") ; da.setInfoOnComponent(4,"ZZ [km]") ;
6228         da[:,2]=3.
6229         self.assertEqual([7., 8., 3., 10., 11., 12., 13., 3., 15., 16., 17., 18., 3., 20., 21., 22., 23., 3., 25., 26.],da.getValues())
6230         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6231         da[2]=3.
6232         self.assertEqual([7., 8., 9., 10., 11., 12., 13., 14., 15., 16., 3., 3., 3., 3., 3., 22., 23., 24., 25., 26.],da.getValues())
6233         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6234         da[[0,3]]=-1.
6235         self.assertEqual([-1., -1., -1., -1., -1., 12., 13., 14., 15., 16., 17., 18., 19., 20., 21., -1., -1., -1., -1., -1.],da.getValues())
6236         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6237         da[:,[1,3,4]]=-3.
6238         self.assertEqual([7., -3., 9., -3., -3., 12., -3., 14., -3., -3., 17., -3., 19., -3., -3., 22., -3., 24., -3., -3.],da.getValues())
6239         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6240         da2=DataArrayInt.New() ; da2.setValues([0,2,3],3,1)
6241         da[da2]=-7.
6242         self.assertEqual([-7., -7., -7., -7., -7., 12., 13., 14., 15., 16., -7., -7., -7., -7., -7., -7., -7., -7., -7., -7.],da.getValues())
6243         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6244         da[da2,-2:]=-7
6245         self.assertEqual([7., 8., 9., -7., -7., 12., 13., 14., 15., 16., 17., 18., 19., -7., -7., 22., 23., 24., -7., -7.],da.getValues())
6246         # Let's test with DAI right hand side
6247         da1=DataArrayDouble.New()
6248         da1.setValues([25,26,27,125,126,127],2,3)
6249         #
6250         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6251         da[-2:,1:4]=da1
6252         self.assertEqual([7., 8., 9., 10., 11., 12., 13., 14., 15., 16., 17., 25., 26., 27., 21., 22., 125., 126., 127., 26.],da.getValues())
6253         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6254         da[1:,3]=[225.,226.,227.]
6255         self.assertEqual([7., 8., 9., 10., 11., 12., 13., 14., 225., 16., 17., 18., 19., 226., 21., 22., 23., 24., 227., 26.],da.getValues())
6256         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6257         da[1,2:]=[225,226,227]
6258         self.assertEqual([7., 8., 9., 10., 11., 12., 13., 225., 226., 227., 17., 18., 19., 20., 21., 22., 23., 24., 25., 26.],da.getValues())
6259         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6260         da[da2,-2:]=[88,99,1010,1111,1212,1313]
6261         self.assertEqual([7., 8., 9., 88., 99., 12., 13., 14., 15., 16., 17., 18., 19., 1010., 1111., 22., 23., 24., 1212., 1313.],da.getValues())
6262         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6263         da3=DataArrayDouble.New(); da3.setValues([88,99,1010,1111,1212,1313],3,2)
6264         da[da2,-2:]=da3
6265         self.assertEqual([7., 8., 9., 88., 99., 12., 13., 14., 15., 16., 17., 18., 19., 1010., 1111., 22., 23., 24., 1212., 1313.],da.getValues())
6266         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6267         da[da2,[0,2]]=da3
6268         self.assertEqual([88., 8., 99., 10., 11., 12., 13., 14., 15., 16., 1010., 18., 1111., 20., 21., 1212., 23., 1313., 25., 26.],da.getValues())
6269         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6270         da[da2,0:3:2]=da3
6271         self.assertEqual([88., 8., 99., 10., 11., 12., 13., 14., 15., 16., 1010., 18., 1111., 20., 21., 1212., 23., 1313., 25., 26.],da.getValues())
6272         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6273         da[da2,0:3:2]=-8.
6274         self.assertEqual([-8., 8., -8., 10., 11., 12., 13., 14., 15., 16., -8., 18., -8., 20., 21., -8., 23., -8., 25., 26.],da.getValues())
6275         pass
6276
6277     def testSwigDADOp(self):
6278         da=DataArrayDouble.New()
6279         da.alloc(12,1)
6280         da.iota(7.)
6281         da1=DataArrayDouble.New()
6282         da1.alloc(12,1)
6283         da1.iota(8.)
6284         da2=da+da1
6285         self.assertEqual([15., 17., 19., 21., 23., 25., 27., 29., 31., 33., 35., 37.],da2.getValues())
6286         da2=da+3
6287         da3=3+da
6288         self.assertTrue(da2.isEqual(da3,1e-12))
6289         da2=da-1.
6290         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())
6291         da2=1-da
6292         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())
6293         da2=da*3
6294         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())
6295         da2=3.*da
6296         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())
6297         da2=da*da1
6298         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())
6299         da2=da/4.
6300         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())
6301         da3=4./da
6302         da4=da3*da2
6303         self.assertTrue(da4.isUniform(1.,1e-12))
6304         st1=da.getHiddenCppPointer()
6305         da+=1
6306         st2=da.getHiddenCppPointer()
6307         self.assertEqual(st1,st2)
6308         self.assertTrue(da.isEqual(da1,1e-12))
6309         da-=8
6310         st2=da.getHiddenCppPointer()
6311         self.assertEqual(st1,st2)
6312         self.assertEqual(range(12),da.getValues())
6313         da+=da1
6314         st2=da.getHiddenCppPointer()
6315         self.assertEqual(st1,st2)
6316         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())
6317         da*=0.5
6318         st2=da.getHiddenCppPointer()
6319         self.assertEqual(st1,st2)
6320         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())
6321         da*=da1
6322         st2=da.getHiddenCppPointer()
6323         self.assertEqual(st1,st2)
6324         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())
6325         da/=da1
6326         self.assertEqual(st1,st2)
6327         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())
6328         da/=2
6329         st2=da.getHiddenCppPointer()
6330         self.assertEqual(st1,st2)
6331         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())
6332         da.rearrange(3)
6333         da5=DataArrayDouble.New()
6334         da5.setValues([5.,4.,3.,2.],4,1)
6335         da*=da5 # it works with unmathing number of compo
6336         st2=da.getHiddenCppPointer()
6337         self.assertEqual(st1,st2)
6338         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())
6339         #
6340         da.alloc(30,1)
6341         da.iota(7.)
6342         da.rearrange(3)
6343         ids=DataArrayInt.New()
6344         ids.setValues([3,4,7],3,1)
6345         da[ids,:]=[5.,8.,9.]
6346         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())
6347         #
6348         da.rearrange(1) ; da.iota(7) ; da.rearrange(3)
6349         da[ids,[1,2]]=[5,8]
6350         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())
6351         pass
6352
6353     def testSwigDAIOp(self):
6354         da=DataArrayInt.New()
6355         da.alloc(12,1)
6356         da.iota(7)
6357         da1=DataArrayInt.New()
6358         da1.alloc(12,1)
6359         da1.iota(8)
6360         da2=da+da1
6361         self.assertEqual([15,17,19,21,23,25,27,29,31,33,35,37],da2.getValues())
6362         da2=da+3
6363         da3=3+da
6364         self.assertTrue(da2.isEqual(da3))
6365         da2=da-1
6366         self.assertEqual([6,7,8,9,10,11,12,13,14,15,16,17],da2.getValues())
6367         da2=1-da
6368         self.assertEqual([-6,-7,-8,-9,-10,-11,-12,-13,-14,-15,-16,-17],da2.getValues())
6369         da2=da*3
6370         self.assertEqual([21,24,27,30,33,36,39,42,45,48,51,54.0],da2.getValues())
6371         da2=3*da
6372         self.assertEqual([21,24,27,30,33,36,39,42,45,48,51,54.0],da2.getValues())
6373         da2=da*da1
6374         self.assertEqual([56,72,90,110,132,156,182,210,240,272,306,342.0],da2.getValues())
6375         da2=da/4
6376         self.assertEqual([1,2,2,2,2,3,3,3,3,4,4,4],da2.getValues())
6377         da3=4/da
6378         da4=da3*da2
6379         self.assertTrue(da4.isUniform(0))
6380         st1=da.getHiddenCppPointer()
6381         da+=1
6382         st2=da.getHiddenCppPointer()
6383         self.assertEqual(st1,st2)
6384         self.assertTrue(da.isEqual(da1))
6385         da-=8
6386         st2=da.getHiddenCppPointer()
6387         self.assertEqual(st1,st2)
6388         self.assertEqual(range(12),da.getValues())
6389         da+=da1
6390         st2=da.getHiddenCppPointer()
6391         self.assertEqual(st1,st2)
6392         self.assertEqual([8,10,12,14,16,18,20,22,24,26,28,30],da.getValues())
6393         da/=2
6394         st2=da.getHiddenCppPointer()
6395         self.assertEqual(st1,st2)
6396         self.assertEqual([4,5,6,7,8,9,10,11,12,13,14,15],da.getValues())
6397         da*=da1
6398         st2=da.getHiddenCppPointer()
6399         self.assertEqual(st1,st2)
6400         self.assertEqual([32,45,60,77,96,117,140,165,192,221,252,285],da.getValues())
6401         da/=da1
6402         self.assertEqual(st1,st2)
6403         self.assertEqual([4,5,6,7,8,9,10,11,12,13,14,15],da.getValues())
6404         da/=2
6405         st2=da.getHiddenCppPointer()
6406         self.assertEqual(st1,st2)
6407         self.assertEqual([2,2, 3,3, 4,4, 5,5, 6,6, 7,7],da.getValues())
6408         da.rearrange(3)
6409         da5=DataArrayInt.New()
6410         da5.setValues([5,4,3,2],4,1)
6411         da*=da5 # it works with unmathing number of compo
6412         st2=da.getHiddenCppPointer()
6413         self.assertEqual(st1,st2)
6414         self.assertEqual([10,10, 15,12,16,16,15,15, 18,12,14,14],da.getValues())
6415         da%=6
6416         st2=da.getHiddenCppPointer()
6417         self.assertEqual(st1,st2)
6418         self.assertEqual([4,4,3,0,4,4,3,3,0,0,2,2],da.getValues())
6419         #
6420         da.alloc(30,1)
6421         da.iota(7)
6422         da.rearrange(3)
6423         ids=DataArrayInt.New()
6424         ids.setValues([3,4,7],3,1)
6425         da[ids,:]=[5,8,9]
6426         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())
6427         #
6428         da.rearrange(1) ; da.iota(7) ; da.rearrange(3)
6429         da[ids,[1,2]]=[5,8]
6430         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())
6431         pass
6432
6433     def testSwigDAIOp2(self):
6434         da=DataArrayInt.New()
6435         st=da.getHiddenCppPointer()
6436         da.alloc(10,3)
6437         da.rearrange(1)
6438         da.iota(0)
6439         da.rearrange(3)
6440         da[:,1]+=4
6441         da[-2:,2]+=10
6442         da[-2:,2]+=10
6443         da[:,2]+=da[:,0]
6444         da[da[0],:]=7
6445         self.assertEqual(st,da.getHiddenCppPointer())
6446         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])
6447         pass
6448
6449     def testSwigDAIOp3(self):
6450         da=DataArrayInt.New()
6451         self.assertRaises(InterpKernelException,da.__len__)
6452         self.assertRaises(InterpKernelException,da.__int__)
6453         for elt in da:
6454             self.assertTrue(False)
6455             pass
6456         da.alloc(12,3)
6457         da.rearrange(1) ; da.fillWithZero()
6458         l1=list(da)
6459         self.assertEqual(36,len(da));
6460         da.rearrange(3)
6461         tmp=da[0]
6462         self.assertRaises(InterpKernelException,tmp.__int__)
6463         self.assertEqual(12,len(da));
6464         l=list(da)
6465         for elt in enumerate(l):
6466             elt[1][2]=elt[0]
6467             pass
6468         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]
6469         self.assertEqual(ref,da.getValues());
6470         da.rearrange(1)
6471         l=[int(elt) for elt in l1]
6472         self.assertEqual(ref,da.getValues());
6473         self.assertEqual(11,int(da[-1:]))
6474         pass
6475
6476     def testSwigDADOp3(self):
6477         da=DataArrayDouble.New()
6478         self.assertRaises(InterpKernelException,da.__len__)
6479         self.assertRaises(InterpKernelException,da.__float__)
6480         for elt in da:
6481             self.assertTrue(False)
6482             pass
6483         da.alloc(12,3)
6484         da.rearrange(1) ; da.fillWithZero()
6485         l1=list(da)
6486         self.assertEqual(36,len(da));
6487         da.rearrange(3)
6488         tmp=da[0]
6489         self.assertRaises(InterpKernelException,tmp.__float__)
6490         self.assertEqual(12,len(da));
6491         l=list(da)
6492         for elt in enumerate(l):
6493             elt[1][2]=elt[0]
6494             pass
6495         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.]
6496         self.assertEqual(ref,da.getValues());
6497         da.rearrange(1)
6498         l=[float(elt) for elt in l1]
6499         self.assertEqual(ref,da.getValues());
6500         self.assertEqual(11.,float(da[-1:]))
6501         pass
6502
6503     def testSwigDataArrayIntIterator1(self):
6504         da=DataArrayInt.New()
6505         da.alloc(12,1)
6506         da.iota(2)
6507         da.rearrange(3)
6508         # __getitem__ testing
6509         li=[]
6510         for it in da:
6511             li+=it[1:]
6512             pass
6513         self.assertEqual([3, 4, 6, 7, 9, 10, 12, 13],li)
6514         li=[]
6515         for it in da:
6516             li+=[it[-1]]
6517             pass
6518         self.assertEqual([4, 7, 10, 13],li)
6519         li=[]
6520         for it in da:
6521             li+=it[[2,1,0]]
6522             pass
6523         self.assertEqual([4, 3, 2, 7, 6, 5, 10, 9, 8, 13, 12, 11],li)
6524         # __setitem__ testing
6525         da3=da.deepCpy()
6526         da2=DataArrayInt.New()
6527         da2.alloc(12,1)
6528         da2.iota(2002)
6529         da2.rearrange(3)
6530         it2=da2.__iter__()
6531         i=0
6532         for it in da:
6533             pt=it2.next()
6534             it[:]=pt
6535             pass
6536         self.assertTrue(da.isEqual(da2))
6537         da=da3
6538         da3=da.deepCpy()
6539         #
6540         for it in da:
6541             it[:]=5
6542             pass
6543         da.rearrange(1)
6544         self.assertTrue(da.isUniform(5))
6545         da=da3
6546         da3=da.deepCpy()
6547         #
6548         for it in da:
6549             it[:]=[8,9,12]
6550             pass
6551         self.assertEqual([8, 9, 12, 8, 9, 12, 8, 9, 12, 8, 9, 12],da.getValues())
6552         da=da3
6553         da3=da.deepCpy()
6554         #
6555         for it in da:
6556             it[2]=[7]
6557             pass
6558         self.assertEqual([2, 3, 7, 5, 6, 7, 8, 9, 7, 11, 12, 7],da.getValues())
6559         pass
6560
6561     def testSwigDataArrayDoubleIterator1(self):
6562         da=DataArrayDouble.New()
6563         da.alloc(12,1)
6564         da.iota(2)
6565         da.rearrange(3)
6566         # __getitem__ testing
6567         li=[]
6568         for it in da:
6569             li+=it[1:]
6570             pass
6571         self.assertEqual([3, 4, 6, 7, 9, 10, 12, 13],li)
6572         li=[]
6573         for it in da:
6574             li+=[it[-1]]
6575             pass
6576         self.assertEqual([4, 7, 10, 13],li)
6577         li=[]
6578         for it in da:
6579             li+=it[[2,1,0]]
6580             pass
6581         self.assertEqual([4, 3, 2, 7, 6, 5, 10, 9, 8, 13, 12, 11],li)
6582         # __setitem__ testing
6583         da3=da.deepCpy()
6584         da2=DataArrayDouble.New()
6585         da2.alloc(12,1)
6586         da2.iota(2002)
6587         da2.rearrange(3)
6588         it2=da2.__iter__()
6589         i=0
6590         for it in da:
6591             pt=it2.next()
6592             it[:]=pt
6593             pass
6594         self.assertTrue(da.isEqual(da2,1e-12))
6595         da=da3
6596         da3=da.deepCpy()
6597         #
6598         for it in da:
6599             it[:]=5
6600             pass
6601         da.rearrange(1)
6602         self.assertTrue(da.isUniform(5,1e-12))
6603         da=da3
6604         da3=da.deepCpy()
6605         #
6606         for it in da:
6607             it[:]=[8,9,12]
6608             pass
6609         self.assertEqual([8, 9, 12, 8, 9, 12, 8, 9, 12, 8, 9, 12],da.getValues())
6610         da=da3
6611         da3=da.deepCpy()
6612         #
6613         for it in da:
6614             it[2]=[7]
6615             pass
6616         self.assertEqual([2, 3, 7, 5, 6, 7, 8, 9, 7, 11, 12, 7],da.getValues())
6617         pass
6618
6619     def testSwigUMeshIterator1(self):
6620         m=MEDCouplingDataForTest.build2DTargetMesh_1()
6621         li1=[]
6622         li2=[]
6623         for cell in m:
6624             li1+=cell.getAllConn()[1:]
6625             li2+=[cell.getType()]
6626             pass
6627         self.assertEqual(li1,[0, 3, 4, 1, 1, 4, 2, 4, 5, 2, 6, 7, 4, 3, 7, 8, 5, 4])
6628         self.assertEqual(li2,[4, 3, 3, 4, 4])
6629         pass
6630
6631     def testSwigUMeshIterator2(self):
6632         m=MEDCouplingDataForTest.build2DTargetMesh_1()
6633         self.assertRaises(InterpKernelException,m.cellsByType);
6634         m.rearrange2ConsecutiveCellTypes()
6635         li1=[]
6636         li2=[]
6637         li3=[]
6638         for cellsByType in m.cellsByType():
6639             li1.append(cellsByType.getType())
6640             li2.append(cellsByType.getNumberOfElems())
6641             temp=[]
6642             for cell in cellsByType:
6643                 t=[None,None]
6644                 t[0]=cell.getType()
6645                 t[1]=cell.getAllConn()[1:]
6646                 temp.append(t)
6647                 pass
6648             li3.append(temp)
6649             pass
6650         self.assertEqual(li1,[4, 3])
6651         self.assertEqual(li2,[3, 2])
6652         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)]]])
6653         pass
6654
6655     def testDAIAggregateMulti1(self):
6656         a=DataArrayInt.New()
6657         a.setValues(range(4),2,2)
6658         a.setName("aa")
6659         b=DataArrayInt.New()
6660         b.setValues(range(6),3,2)
6661         c=DataArrayInt.Aggregate([a,b])
6662         self.assertEqual(range(4)+range(6),c.getValues())
6663         self.assertEqual("aa",c.getName())
6664         self.assertEqual(5,c.getNumberOfTuples())
6665         self.assertEqual(2,c.getNumberOfComponents())
6666         pass
6667
6668     def testMergeUMeshes2(self):
6669         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6670         m2=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6671         m3=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6672         #
6673         vec1=[0,2,3]
6674         m2_2=m2.buildPartOfMySelf(vec1,False);
6675         vec2=[1,1]
6676         m3_2=m3.buildPartOfMySelf(vec2,False);
6677         #
6678         ms=[m1,m2_2,m3_2];
6679         #
6680         self.assertRaises(InterpKernelException,MEDCouplingUMesh.MergeUMeshes,ms+[None]);
6681         self.assertRaises(InterpKernelException,MEDCouplingUMesh.MergeUMeshes,ms+[3.4])
6682         m4=MEDCouplingUMesh.MergeUMeshes(ms);
6683         m4.checkCoherency();
6684         self.assertEqual(10,m4.getNumberOfCells());
6685         self.assertEqual(20,m4.getNumberOfNodes());
6686         self.assertEqual(45,m4.getMeshLength());
6687         m4bis=MEDCouplingMesh.MergeMeshes(ms);
6688         self.assertTrue(m4.isEqual(m4bis,1e-12))
6689         del m4bis
6690         #
6691         vec3=[0,1,2,3,4]
6692         m4_1=m4.buildPartOfMySelf(vec3,False);
6693         m4_1.setName(m1.getName());
6694         self.assertTrue(m4_1.isEqual(m1,1e-12));
6695         #
6696         vec4=[5,6,7]
6697         m4_2=m4.buildPartOfMySelf(vec4,False);
6698         cellCor,nodeCor=m4_2.checkGeoEquivalWith(m2_2,10,1e-12);
6699         #
6700         vec5=[8,9]
6701         m4_3=m4.buildPartOfMySelf(vec5,False);
6702         self.assertEqual(2,m4_3.getNumberOfCells());
6703         self.assertEqual(3,m4_3.getNumberOfNodes());
6704         m3_2.zipCoords();
6705         m4_3.setName(m3_2.getName());
6706         self.assertTrue(m4_3.isEqual(m3_2,1e-12));
6707         #
6708         pass
6709
6710     def testBuild0DMeshFromCoords1(self):
6711         sourceCoords=[-0.3,-0.3,0., 0.7,-0.3,0., -0.3,0.7,0., 0.7,0.7,0.]
6712         coo=DataArrayDouble.New();
6713         coo.setValues(sourceCoords,4,3);
6714         coo.setName("My0D");
6715         m=MEDCouplingUMesh.Build0DMeshFromCoords(coo);
6716         m.checkCoherency();
6717         self.assertEqual(4,m.getNumberOfNodes());
6718         self.assertEqual(4,m.getNumberOfCells());
6719         self.assertEqual(3,m.getSpaceDimension());
6720         self.assertEqual(0,m.getMeshDimension());
6721         types1=m.getAllGeoTypes();
6722         self.assertEqual([NORM_POINT1],types1);
6723         for i in xrange(4):
6724             conn=m.getNodeIdsOfCell(i);
6725             self.assertEqual([i],conn);
6726             self.assertTrue(NORM_POINT1==m.getTypeOfCell(i));
6727             pass
6728         self.assertEqual(m.getName(),"My0D");
6729         pass
6730
6731     def testDescriptionInMeshTimeUnit1(self):
6732         text1="totoTTEDD";
6733         m=MEDCouplingDataForTest.build2DTargetMesh_1();
6734         m.setDescription(text1);
6735         self.assertEqual(m.getDescription(),text1);
6736         m2=m.deepCpy();
6737         self.assertTrue(m.isEqual(m2,1e-12));
6738         self.assertEqual(m2.getDescription(),text1);
6739         m2.setDescription("ggg");
6740         self.assertTrue(not m.isEqual(m2,1e-12));
6741         #
6742         f=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
6743         f.setTimeUnit(text1);
6744         self.assertEqual(f.getTimeUnit(),text1);
6745         f2=f.deepCpy();
6746         self.assertEqual(f2.getTimeUnit(),text1);
6747         #
6748         pass
6749
6750     def testMultiFields1(self):
6751         mfs=MEDCouplingDataForTest.buildMultiFields_1();
6752         ms=mfs.getMeshes();
6753         dms,refs=mfs.getDifferentMeshes()
6754         das=mfs.getArrays();
6755         das2,refs2=mfs.getDifferentArrays()
6756         self.assertEqual(5,len(mfs.getFields()))
6757         self.assertEqual(1,len(mfs.getFields()[0].getArrays()));
6758         self.assertEqual(2,len(mfs.getFields()[1].getArrays()));
6759         self.assertEqual(1,len(mfs.getFields()[2].getArrays()));
6760         self.assertEqual(1,len(mfs.getFields()[3].getArrays()));
6761         self.assertEqual(1,len(mfs.getFields()[4].getArrays()));
6762         self.assertEqual(5,len(ms));
6763         self.assertEqual(2,len(dms));
6764         self.assertEqual(6,len(das));
6765         self.assertEqual(5,len(das2));
6766         mfs2=mfs.deepCpy();
6767         self.assertTrue(mfs.isEqual(mfs2,1e-12,1e-12))
6768         pass
6769
6770     def testFieldOverTime1(self):
6771         fs=MEDCouplingDataForTest.buildMultiFields_2();
6772         self.assertRaises(InterpKernelException,MEDCouplingFieldOverTime.New,fs);
6773         f4bis=fs[4].buildNewTimeReprFromThis(ONE_TIME,False);
6774         fs[4]=f4bis;
6775         self.assertRaises(InterpKernelException,MEDCouplingFieldOverTime.New,fs);
6776         f4bis.setTime(2.7,20,21);
6777         fot=MEDCouplingFieldOverTime.New(fs);
6778         dt=fot.getDefinitionTimeZone();
6779         hs=dt.getHotSpotsTime();
6780         self.assertEqual(6,len(hs));
6781         expected1=[0.2,0.7,1.2,1.35,1.7,2.7]
6782         for i in xrange(6):
6783             self.assertAlmostEqual(expected1[i],hs[i],12);
6784             pass
6785         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(0.2);
6786         self.assertEqual(0,meshId);
6787         self.assertEqual(0,arrId);
6788         self.assertEqual(0,arrIdInField);
6789         self.assertEqual(0,fieldId);
6790         #
6791         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(0.7);
6792         self.assertEqual(0,meshId);
6793         self.assertEqual(1,arrId);
6794         self.assertEqual(0,arrIdInField);
6795         self.assertEqual(1,fieldId);
6796         #
6797         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeLeft(1.2);#**** WARNING left here
6798         self.assertEqual(0,meshId);
6799         self.assertEqual(2,arrId);
6800         self.assertEqual(1,arrIdInField);
6801         self.assertEqual(1,fieldId);
6802         #
6803         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(1.2);#**** WARNING right again here
6804         self.assertEqual(1,meshId);
6805         self.assertEqual(3,arrId);
6806         self.assertEqual(0,arrIdInField);
6807         self.assertEqual(2,fieldId);
6808         #
6809         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(1.35);
6810         self.assertEqual(1,meshId);
6811         self.assertEqual(3,arrId);
6812         self.assertEqual(0,arrIdInField);
6813         self.assertEqual(2,fieldId);
6814         #
6815         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(1.7);
6816         self.assertEqual(0,meshId);
6817         self.assertEqual(3,arrId);
6818         self.assertEqual(0,arrIdInField);
6819         self.assertEqual(3,fieldId);
6820         #
6821         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(2.7);
6822         self.assertEqual(1,meshId);
6823         self.assertEqual(4,arrId);
6824         self.assertEqual(0,arrIdInField);
6825         self.assertEqual(4,fieldId);
6826         #
6827         dt2=MEDCouplingDefinitionTime();
6828         self.assertTrue(not dt2.isEqual(dt));
6829         dt2.assign(dt);
6830         dt2.assign(dt);#to check memory management
6831         self.assertTrue(dt2.isEqual(dt));
6832         #
6833         dt3=MEDCouplingDefinitionTime();
6834         #
6835         pass
6836
6837     def testDAICheckAndPreparePermutation1(self):
6838         vals1=[9,10,0,6,4,11,3,7];
6839         expect1=[5,6,0,3,2,7,1,4];
6840         vals2=[9,10,0,6,10,11,3,7];
6841         da=DataArrayInt.New();
6842         da.setValues(vals1,8,1);
6843         da2=da.checkAndPreparePermutation();
6844         self.assertEqual(8,da2.getNumberOfTuples());
6845         self.assertEqual(1,da2.getNumberOfComponents());
6846         for i in xrange(8):
6847             self.assertEqual(expect1[i],da2.getIJ(i,0));
6848             pass
6849         #
6850         da=DataArrayInt.New();
6851         da.alloc(8,1);
6852         da.iota(0);
6853         da2=da.checkAndPreparePermutation();
6854         self.assertEqual(8,da2.getNumberOfTuples());
6855         self.assertEqual(1,da2.getNumberOfComponents());
6856         self.assertTrue(da2.isIdentity());
6857         #
6858         da=DataArrayInt.New();
6859         da.alloc(8,1);
6860         da.setValues(vals2,8,1);
6861         self.assertRaises(InterpKernelException,da.checkAndPreparePermutation);
6862         pass
6863
6864     def testDAIChangeSurjectiveFormat1(self):
6865         vals1=[0,3,2,3,2,2,1,2]
6866         expected1=[0,1,2,6,8]
6867         expected2=[0,  6,  2,4,5,7,  1,3]
6868         da=DataArrayInt.New();
6869         da.setValues(vals1,8,1);
6870         #
6871         da2,da2I=da.changeSurjectiveFormat(4);
6872         self.assertEqual(5,da2I.getNumberOfTuples());
6873         self.assertEqual(8,da2.getNumberOfTuples());
6874         self.assertEqual(expected1,da2I.getValues());
6875         self.assertEqual(expected2,da2.getValues());
6876         #
6877         self.assertRaises(InterpKernelException,da.changeSurjectiveFormat,3);
6878         #
6879         pass
6880
6881     def testUMeshGetCellIdsLyingOnNodes1(self):
6882         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6883         nodeIds1=[1,2,3,4,6]
6884         nodeIds2=[6,7]
6885         da=m.getCellIdsLyingOnNodes(nodeIds1,True);
6886         self.assertEqual(1,da.getNumberOfTuples());
6887         self.assertEqual(1,da.getNumberOfComponents());
6888         self.assertEqual(1,da.getIJ(0,0));
6889         da2=DataArrayInt.New()
6890         da2.setValues(nodeIds2,2,1)
6891         da=m.getCellIdsLyingOnNodes(da2,False);
6892         self.assertEqual(2,da.getNumberOfTuples());
6893         self.assertEqual(1,da.getNumberOfComponents());
6894         self.assertEqual(3,da.getIJ(0,0));
6895         self.assertEqual(4,da.getIJ(1,0));
6896         pass
6897
6898     def testUMeshFindCellIdsOnBoundary1(self):
6899         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6900         da5=m.findCellIdsOnBoundary();
6901         self.assertEqual(5,da5.getNumberOfTuples());
6902         self.assertTrue(da5.isIdentity());
6903         pass
6904
6905     def testMeshSetTime1(self):
6906         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6907         m2=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6908         #
6909         self.assertTrue(m1.isEqual(m2,1e-12));
6910         m1.setTime(3.14,6,7);
6911         tmp3,tmp1,tmp2=m1.getTime();
6912         self.assertEqual(6,tmp1);
6913         self.assertEqual(7,tmp2);
6914         self.assertAlmostEqual(3.14,tmp3,12);
6915         self.assertTrue(not m1.isEqual(m2,1e-12));
6916         m2.setTime(3.14,6,7);
6917         self.assertTrue(m1.isEqual(m2,1e-12));
6918         m1.setTimeUnit("ms");
6919         self.assertTrue(m1.getTimeUnit()=="ms");
6920         m1.setTimeUnit("us");
6921         self.assertTrue(m1.getTimeUnit()=="us");
6922         self.assertTrue(not m1.isEqual(m2,1e-12));
6923         m2.setTimeUnit("us");
6924         self.assertTrue(m1.isEqual(m2,1e-12));
6925         m2.setTime(3.14,6,8);
6926         self.assertTrue(not m1.isEqual(m2,1e-12));
6927         m2.setTime(3.14,7,7);
6928         self.assertTrue(not m1.isEqual(m2,1e-12));
6929         m2.setTime(3.15,6,7);
6930         self.assertTrue(not m1.isEqual(m2,1e-12));
6931         #
6932         m1.setTime(10.34,55,12);
6933         m3=m1.deepCpy();
6934         self.assertTrue(m1.isEqual(m3,1e-12));
6935         tmp3,tmp1,tmp2=m3.getTime();
6936         self.assertEqual(55,tmp1);
6937         self.assertEqual(12,tmp2);
6938         self.assertAlmostEqual(10.34,tmp3,12);
6939         #
6940         # testing CMesh
6941         coo1=[0.,1.,2.,3.5]
6942         a=DataArrayDouble.New();
6943         a.setValues(coo1,4,1);
6944         b=MEDCouplingCMesh.New();
6945         b.setCoordsAt(0,a);
6946         #
6947         b.setTime(5.67,8,100);
6948         tmp3,tmp1,tmp2=b.getTime();
6949         self.assertEqual(8,tmp1);
6950         self.assertEqual(100,tmp2);
6951         self.assertAlmostEqual(5.67,tmp3,12);
6952         c=b.deepCpy();
6953         self.assertTrue(c.isEqual(b,1e-12));
6954         tmp3,tmp1,tmp2=c.getTime();
6955         self.assertEqual(8,tmp1);
6956         self.assertEqual(100,tmp2);
6957         self.assertAlmostEqual(5.67,tmp3,12);
6958         pass
6959
6960     def testApplyFuncTwo1(self):
6961         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6962         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
6963         f1.setMesh(m1);
6964         #
6965         vals=[1.,11.,21.,2.,12.,22.,3.,13.,23.,4.,14.,24.,5.,15.,25.]
6966         da=DataArrayDouble.New();
6967         da.setValues(vals,5,3);
6968         f1.setArray(da);
6969         #
6970         self.assertRaises(InterpKernelException,da.applyFunc2,1,"y+z");
6971         da.setInfoOnComponent(0,"x [m]");
6972         da.setInfoOnComponent(1,"y [mm]");
6973         da.setInfoOnComponent(2,"z [km]");
6974
6975         self.assertRaises(InterpKernelException, da.applyFunc2, 1, "x+y+zz+zzz");
6976         self.assertRaises(InterpKernelException, da.applyFunc2, 1, "toto(x+y)");
6977         self.assertRaises(InterpKernelException, da.applyFunc2, 1, "x/0");
6978
6979         da2=da.applyFunc2(1,"y+z");
6980         self.assertEqual(1,da2.getNumberOfComponents());
6981         self.assertEqual(5,da2.getNumberOfTuples());
6982         expected1=[32.,34.,36.,38.,40.]
6983         for i in xrange(5):
6984             self.assertAlmostEqual(expected1[i],da2.getIJ(0,i),12);
6985             pass
6986         da2=da.applyFunc(1,"y+z");
6987         expected2=[12.,14.,16.,18.,20.]
6988         for i in xrange(5):
6989             self.assertAlmostEqual(expected2[i],da2.getIJ(0,i),12);
6990             pass
6991         #
6992         self.assertEqual(3,f1.getNumberOfComponents());
6993         self.assertEqual(5,f1.getNumberOfTuples());
6994         f1.applyFunc2(1,"y+z");
6995         self.assertEqual(1,f1.getNumberOfComponents());
6996         self.assertEqual(5,f1.getNumberOfTuples());
6997         for i in xrange(5):
6998             self.assertAlmostEqual(expected1[i],f1.getArray().getIJ(0,i),12);
6999             pass
7000         #
7001         pass
7002
7003     def testApplyFuncThree1(self):
7004         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
7005         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
7006         f1.setMesh(m1);
7007         #
7008         vals=[1.,11.,21.,2.,12.,22.,3.,13.,23.,4.,14.,24.,5.,15.,25.]
7009         da=DataArrayDouble.New();
7010         da.setValues(vals,5,3);
7011         f1.setArray(da);
7012         #
7013         vs=3*[None];
7014         vs[0]="x"; vs[1]="Y"; vs[2]="z";
7015         self.assertRaises(InterpKernelException, da.applyFunc3, 1, vs, "y+z");
7016         self.assertRaises(InterpKernelException, da.applyFunc3, 1, vs, "x+Y+z+zz+zzz");
7017         self.assertRaises(InterpKernelException, da.applyFunc3, 1, vs, "x/0");
7018         vs[1]="y";
7019         da2=da.applyFunc3(1,vs,"y+z");
7020         expected1=[32.,34.,36.,38.,40.]
7021         for i in xrange(5):
7022             self.assertAlmostEqual(expected1[i],da2.getIJ(0,i),12);
7023             pass
7024         self.assertRaises(InterpKernelException, da.applyFunc3, 1, ["x","y","z","a"],"x+a")
7025         f1.setArray(da);
7026         self.assertEqual(3,f1.getNumberOfComponents());
7027         self.assertEqual(5,f1.getNumberOfTuples());
7028         f1.applyFunc3(1,vs,"y+z");
7029         self.assertEqual(1,f1.getNumberOfComponents());
7030         self.assertEqual(5,f1.getNumberOfTuples());
7031         for i in xrange(5):
7032             self.assertAlmostEqual(expected1[i],f1.getArray().getIJ(0,i),12);
7033             pass
7034         pass
7035
7036     def testFillFromAnalyticTwo1(self):
7037         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
7038         m1.setTime(3.4,5,6); m1.setTimeUnit("us");
7039         self.assertRaises(InterpKernelException,m1.fillFromAnalytic2,ON_NODES,1,"y+z");
7040         m1.getCoords().setInfoOnComponent(0,"x [m]");
7041         m1.getCoords().setInfoOnComponent(1,"y");
7042         m1.getCoords().setInfoOnComponent(2,"z");
7043         f1=m1.fillFromAnalytic2(ON_NODES,1,"y+z");
7044         self.assertAlmostEqual(3.4,f1.getTime()[0],12) ; self.assertEqual(5,f1.getTime()[1]) ; self.assertEqual(6,f1.getTime()[2])
7045         self.assertEqual("us",f1.getTimeUnit())
7046         self.assertEqual(1,f1.getNumberOfComponents());
7047         self.assertEqual(9,f1.getNumberOfTuples());
7048         expected1=[0.2, 0.7, 1.2, 0.7, 1.2, 1.7, 1.2, 1.7, 2.2]
7049         for i in xrange(9):
7050             self.assertAlmostEqual(expected1[i],f1.getArray().getIJ(0,i),12);
7051             pass
7052         pass
7053
7054     def testFillFromAnalyticThree1(self):
7055         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
7056         m1.setTime(3.4,5,6); m1.setTimeUnit("us");
7057         vs=3*[None];
7058         vs[0]="x"; vs[1]="Y"; vs[2]="z";
7059         self.assertRaises(InterpKernelException,m1.fillFromAnalytic3,ON_NODES,1,vs,"y+z");
7060         vs[1]="y";
7061         f1=m1.fillFromAnalytic3(ON_NODES,1,vs,"y+z");
7062         self.assertAlmostEqual(3.4,f1.getTime()[0],12) ; self.assertEqual(5,f1.getTime()[1]) ; self.assertEqual(6,f1.getTime()[2])
7063         self.assertEqual("us",f1.getTimeUnit())
7064         self.assertEqual(1,f1.getNumberOfComponents());
7065         self.assertEqual(9,f1.getNumberOfTuples());
7066         expected1=[0.2, 0.7, 1.2, 0.7, 1.2, 1.7, 1.2, 1.7, 2.2]
7067         for i in xrange(9):
7068             self.assertAlmostEqual(expected1[i],f1.getArray().getIJ(0,i),12);
7069             pass
7070         pass
7071
7072     def testDAUnitVar1(self):
7073         da=DataArrayDouble.New();
7074         da.alloc(1,3);
7075         da.setInfoOnComponent(0,"XPS [m]");
7076         st1=da.getVarOnComponent(0);
7077         self.assertTrue(st1=="XPS");
7078         st2=da.getUnitOnComponent(0);
7079         self.assertTrue(st2=="m");
7080         #
7081         da.setInfoOnComponent(0,"XPS         [m]");
7082         st1=da.getVarOnComponent(0);
7083         self.assertTrue(st1=="XPS");
7084         st2=da.getUnitOnComponent(0);
7085         self.assertTrue(st2=="m");
7086         #
7087         da.setInfoOnComponent(0,"XPP         [m]");
7088         st1=da.getVarOnComponent(0);
7089         self.assertTrue(st1=="XPP");
7090         st2=da.getUnitOnComponent(0);
7091         self.assertTrue(st2=="m");
7092         #
7093         da.setInfoOnComponent(0,"XPP kdep  kefer   [ m  ]");
7094         st1=da.getVarOnComponent(0);
7095         self.assertTrue(st1=="XPP kdep  kefer");
7096         st2=da.getUnitOnComponent(0);
7097         self.assertTrue(st2==" m  ");
7098         #
7099         da.setInfoOnComponent(0,"     XPP k[  dep  k]efer   [ m^ 2/s^3*kJ  ]");
7100         st1=da.getVarOnComponent(0);
7101         self.assertTrue(st1=="     XPP k[  dep  k]efer");
7102         st2=da.getUnitOnComponent(0);
7103         self.assertTrue(st2==" m^ 2/s^3*kJ  ");
7104         #
7105         da.setInfoOnComponent(0,"     XPP kefer   ");
7106         st1=da.getVarOnComponent(0);
7107         self.assertTrue(st1=="     XPP kefer   ");
7108         st2=da.getUnitOnComponent(0);
7109         self.assertTrue(st2=="");
7110         #
7111         da.setInfoOnComponent(0,"temperature( bof)");
7112         st1=da.getVarOnComponent(0);
7113         self.assertTrue(st1=="temperature( bof)");
7114         st2=da.getUnitOnComponent(0);
7115         self.assertTrue(st2=="");
7116         #
7117         da.setInfoOnComponent(0,"kkk [m]");
7118         da.setInfoOnComponent(1,"ppp   [m^2/kJ]");
7119         da.setInfoOnComponent(2,"abcde   [MW/s]");
7120         #
7121         vs=da.getVarsOnComponent();
7122         self.assertEqual(3,len(vs));
7123         self.assertTrue(vs[0]=="kkk");
7124         self.assertTrue(vs[1]=="ppp");
7125         self.assertTrue(vs[2]=="abcde");
7126         vs=da.getUnitsOnComponent();
7127         self.assertEqual(3,len(vs));
7128         self.assertTrue(vs[0]=="m");
7129         self.assertTrue(vs[1]=="m^2/kJ");
7130         self.assertTrue(vs[2]=="MW/s");
7131         pass
7132
7133     def testGaussCoordinates1(self):
7134         #Testing 1D cell types
7135         m1=MEDCouplingDataForTest.build1DMultiTypes_1();
7136         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,ONE_TIME);
7137         f.setMesh(m1);
7138         wg1=[0.3];
7139         gsCoo1=[0.2];
7140         refCoo1=[-1.0,1.0];
7141         f.setGaussLocalizationOnType(NORM_SEG2,refCoo1,gsCoo1,wg1);
7142         wg2=wg1;
7143         gsCoo2=[0.2];
7144         refCoo2=[-1.0,1.0,0.0];
7145         f.setGaussLocalizationOnType(NORM_SEG3,refCoo2,gsCoo2,wg2);
7146         #
7147         resToTest=f.getLocalizationOfDiscr();
7148         self.assertEqual(3,resToTest.getNumberOfComponents());
7149         self.assertEqual(2,resToTest.getNumberOfTuples());
7150         expected1=[0.6,0.6,0.6, 0.6,0.6,0.6]
7151         for i in xrange(6):
7152             self.assertAlmostEqual(expected1[i],resToTest.getIJ(0,i),14);
7153             pass
7154         #
7155         #Testing 2D cell types
7156         m2=MEDCouplingDataForTest.build2DMultiTypes_1();
7157         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,ONE_TIME);
7158         f.setMesh(m2);
7159         wg3=[0.3,0.3];
7160         tria3CooGauss=[ 0.1, 0.8, 0.2, 0.7 ]
7161         gsCoo3=tria3CooGauss
7162         tria3CooRef=[ 0.0, 0.0, 1.0 , 0.0, 0.0, 1.0 ]
7163         refCoo3=tria3CooRef;
7164         f.setGaussLocalizationOnType(NORM_TRI3,refCoo3,gsCoo3,wg3);
7165         wg4=[0.3,0.3,0.3];
7166         tria6CooGauss=[ 0.3, 0.2, 0.2, 0.1, 0.2, 0.4 ]
7167         gsCoo4=tria6CooGauss;
7168         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]
7169         refCoo4=tria6CooRef;
7170         f.setGaussLocalizationOnType(NORM_TRI6,refCoo4,gsCoo4,wg4);
7171         wg5=[0.3,0.3,0.3,0.3];
7172         quad4CooGauss=[ 0.3, 0.2, 0.2, 0.1, 0.2, 0.4, 0.15, 0.27 ]
7173         gsCoo5=quad4CooGauss;
7174         quad4CooRef=[-1.0, 1.0, -1.0, -1.0, 1.0, -1.0, 1.0, 1.0]
7175         refCoo5=quad4CooRef;
7176         f.setGaussLocalizationOnType(NORM_QUAD4,refCoo5,gsCoo5,wg5);
7177         wg6=[0.3,0.3,0.3,0.3];
7178         quad8CooGauss=[ 0.34, 0.16, 0.21, 0.3, 0.23, 0.4, 0.14, 0.37 ]
7179         gsCoo6=quad8CooGauss;
7180         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]
7181         refCoo6=quad8CooRef;
7182         f.setGaussLocalizationOnType(NORM_QUAD8,refCoo6,gsCoo6,wg6);
7183         #
7184         resToTest=f.getLocalizationOfDiscr();
7185         self.assertEqual(3,resToTest.getNumberOfComponents());
7186         self.assertEqual(13,resToTest.getNumberOfTuples());#2+3+4+4 gauss points for resp TRI3,TRI6,QUAD4,QUAD8
7187         expected2=[5.1,1.55,0.0, 4.7,1.65,0.0,
7188                    2.32,1.52,0.0, 1.6,1.32,0.0, 3.52,1.26,0.0,#TRI6
7189                    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
7190                    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
7191         for i in xrange(39):
7192             self.assertAlmostEqual(expected2[i],resToTest.getIJ(0,i),14);
7193             pass
7194         #
7195         #Testing 3D cell types
7196         m3=MEDCouplingDataForTest.build3DMultiTypes_1();
7197         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,ONE_TIME);
7198         f.setMesh(m3);
7199         #
7200         wg7=[0.3];
7201         tetra4CooGauss=[0.34, 0.16, 0.21]
7202         gsCoo7=tetra4CooGauss;
7203         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]
7204         refCoo7=tetra4CooRef;
7205         f.setGaussLocalizationOnType(NORM_TETRA4,refCoo7,gsCoo7,wg7);
7206         wg8=[0.3];
7207         tetra10CooGauss=[0.2, 0.3, 0.1]
7208         gsCoo8=tetra10CooGauss;
7209         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]
7210         refCoo8=tetra10CooRef;
7211         f.setGaussLocalizationOnType(NORM_TETRA10,refCoo8,gsCoo8,wg8);
7212         wg9=[0.3];
7213         pyra5CooGauss=[0.2, 0.3, 0.1]
7214         gsCoo9=pyra5CooGauss;
7215         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]
7216         refCoo9=pyra5CooRef;
7217         f.setGaussLocalizationOnType(NORM_PYRA5,refCoo9,gsCoo9,wg9);
7218         wg10=[0.3];
7219         pyra13CooGauss=[0.1, 0.2, 0.7]
7220         gsCoo10=pyra13CooGauss;
7221         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]
7222         refCoo10=pyra13CooRef;
7223         f.setGaussLocalizationOnType(NORM_PYRA13,refCoo10,gsCoo10,wg10);
7224         wg11=[0.3];
7225         penta6CooGauss=[0.2, 0.3, 0.1]
7226         gsCoo11=penta6CooGauss;
7227         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]
7228         refCoo11=penta6CooRef;
7229         f.setGaussLocalizationOnType(NORM_PENTA6,refCoo11,gsCoo11,wg11);
7230         wg12=[0.3];
7231         penta15CooGauss=[0.2, 0.3,0.15]
7232         gsCoo12=penta15CooGauss;
7233         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]
7234         refCoo12=penta15CooRef;
7235         f.setGaussLocalizationOnType(NORM_PENTA15,refCoo12,gsCoo12,wg12);
7236         wg13=[0.3];
7237         hexa8CooGauss=[0.2,0.3,0.15]
7238         gsCoo13=hexa8CooGauss;
7239         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]
7240         refCoo13=hexa8CooRef;
7241         f.setGaussLocalizationOnType(NORM_HEXA8,refCoo13,gsCoo13,wg13);
7242         wg14=[0.3];
7243         hexa20CooGauss=[0.11,0.3,0.55]
7244         gsCoo14=hexa20CooGauss;
7245         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]
7246         refCoo14=hexa20CooRef;
7247         f.setGaussLocalizationOnType(NORM_HEXA20,refCoo14,gsCoo14,wg14);
7248         #
7249         resToTest=f.getLocalizationOfDiscr();
7250         self.assertEqual(3,resToTest.getNumberOfComponents());
7251         self.assertEqual(8,resToTest.getNumberOfTuples());#2+3+4+4 gauss points for resp TRI3,TRI6,QUAD4,QUAD8
7252         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]
7253         for i in xrange(24):
7254             self.assertAlmostEqual(expected3[i],resToTest.getIJ(0,i),14);
7255             pass
7256         #
7257         pass
7258
7259     def testP2Localization1(self):
7260         m=MEDCouplingUMesh.New("testP2",2);
7261         coords=[0.,2.,3.5,0.,4.5,1.5,1.2,0.32,3.4,1.,2.1,2.4]
7262         conn=[0,1,2,3,4,5]
7263         coo=DataArrayDouble.New();
7264         coo.setValues(coords,6,2);
7265         m.setCoords(coo);
7266         m.allocateCells(1);
7267         m.insertNextCell(NORM_TRI6,6,conn[0:6])
7268         m.finishInsertingCells();
7269         #
7270         f=MEDCouplingFieldDouble.New(ON_NODES,ONE_TIME);
7271         f.setMesh(m);
7272         da=DataArrayDouble.New();
7273         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]
7274         da.setValues(vals1,6,3);
7275         f.setArray(da);
7276         #
7277         loc=[2.27,1.3]
7278         locs=f.getValueOnMulti(loc);
7279         expected1=[6.0921164547752236, 7.1921164547752232, 8.2921164547752255]
7280         for i in xrange(3):
7281             self.assertAlmostEqual(expected1[i],locs.getIJ(0,i),12);
7282             pass
7283         pass
7284
7285     def testP2Localization2(self):
7286         m=MEDCouplingUMesh.New("testP2_2",3);
7287         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]
7288         conn=[0,1,2,3,4,5,6,7,8,9]
7289         coo=DataArrayDouble.New();
7290         coo.setValues(coords,10,3);
7291         m.setCoords(coo);
7292         m.allocateCells(1);
7293         m.insertNextCell(NORM_TETRA10,10,conn[0:10])
7294         m.finishInsertingCells();
7295         #
7296         f=MEDCouplingFieldDouble.New(ON_NODES,ONE_TIME);
7297         f.setMesh(m);
7298         da=DataArrayDouble.New();
7299         vals1=[1.1,2.1,3.1,4.1,5.2,6.2,7.2,8.2,9.2,10.2]
7300         da.setValues(vals1,10,1);
7301         f.setArray(da);
7302         #
7303         loc=[0.64637931739890486, -0.16185896817550552, 0.22678966365273748]
7304         locs=f.getValueOnMulti(loc);
7305         expected1=[10.0844021968047]
7306         for i in xrange(1):
7307             self.assertAlmostEqual(expected1[i],locs.getIJ(0,i),12);
7308             pass
7309         pass
7310
7311     def testGetValueOn2(self):
7312         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7313         f=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
7314         f.setMesh(m);
7315         arr=DataArrayDouble.New();
7316         nbOfCells=m.getNumberOfCells();
7317         f.setArray(arr);
7318         values1=[7.,107.,10007.,8.,108.,10008.,9.,109.,10009.,10.,110.,10010.,11.,111.,10011.]
7319         arr.setValues(values1,nbOfCells,3);
7320         loc=[-0.05,-0.05, 0.55,-0.25, 0.55,0.15, -0.05,0.45, 0.45,0.45]
7321         f.checkCoherency();
7322         locs=f.getValueOnMulti(loc);
7323         self.assertEqual(5,locs.getNumberOfTuples());
7324         self.assertEqual(3,locs.getNumberOfComponents());
7325         for j in xrange(15):
7326             self.assertAlmostEqual(values1[j],locs.getIJ(0,j),12);
7327             pass
7328         # Testing ON_NODES
7329         f=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
7330         f.setMesh(m);
7331         arr=DataArrayDouble.New();
7332         nbOfNodes=m.getNumberOfNodes();
7333         f.setArray(arr);
7334         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.]
7335         arr.setValues(values2,nbOfNodes,3);
7336         loc2=[0.5432,-0.2432, 0.5478,0.1528, 0.5432,-0.2432, 0.5432,-0.2432]
7337         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]
7338         f.checkCoherency();
7339         loc3=DataArrayDouble.New()
7340         loc3.setValues(loc2,4,2);
7341         locs=f.getValueOnMulti(loc3);
7342         self.assertEqual(4,locs.getNumberOfTuples());
7343         self.assertEqual(3,locs.getNumberOfComponents());
7344         for i in xrange(12):
7345             self.assertAlmostEqual(expected2[i],locs.getIJ(0,i),12);
7346             pass
7347         #
7348         pass
7349
7350     def testDAIGetIdsNotEqual1(self):
7351         d=DataArrayInt.New();
7352         vals1=[2,3,5,6,8,5,5,6,1,-5]
7353         d.setValues(vals1,10,1);
7354         d2=d.getIdsNotEqual(5);
7355         self.assertEqual(7,d2.getNumberOfTuples());
7356         self.assertEqual(1,d2.getNumberOfComponents());
7357         expected1=[0,1,3,4,7,8,9]
7358         for i in xrange(7):
7359             self.assertEqual(expected1[i],d2.getIJ(0,i));
7360             pass
7361         d.rearrange(2);
7362         self.assertRaises(InterpKernelException,d.getIdsNotEqual,5);
7363         vals2=[-4,5,6]
7364         vals3=vals2;
7365         d.rearrange(1);
7366         d3=d.getIdsNotEqualList(vals3);
7367         self.assertEqual(5,d3.getNumberOfTuples());
7368         self.assertEqual(1,d3.getNumberOfComponents());
7369         expected2=[0,1,4,8,9]
7370         for i in xrange(5):
7371             self.assertEqual(expected2[i],d3.getIJ(0,i));
7372             pass
7373         pass
7374
7375     def testDAIComputeOffsets1(self):
7376         d=DataArrayInt.New();
7377         vals1=[3,5,1,2,0,8]
7378         expected1=[0,3,8,9,11,11]
7379         d.setValues(vals1,6,1);
7380         d.computeOffsets();
7381         self.assertEqual(6,d.getNumberOfTuples());
7382         self.assertEqual(1,d.getNumberOfComponents());
7383         for i in xrange(6):
7384             self.assertEqual(expected1[i],d.getIJ(0,i));
7385             pass
7386         pass
7387
7388     def testUMeshHexagonPrism1(self):
7389         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,
7390                 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];
7391         conn=[1,2,3,4,5,0,7,8,9,10,11,6]
7392         mesh=MEDCouplingUMesh.New("MyFirstHexagonalPrism",3);
7393         coo=DataArrayDouble.New();
7394         coo.setValues(coords,12,3);
7395         mesh.setCoords(coo);
7396         mesh.allocateCells(1);
7397         mesh.insertNextCell(NORM_HEXGP12,12,conn[0:12])
7398         mesh.finishInsertingCells();
7399         #
7400         mesh.checkCoherency();
7401         vols=mesh.getMeasureField(False);
7402         self.assertEqual(1,vols.getNumberOfTuples());
7403         self.assertEqual(1,vols.getNumberOfComponents());
7404         self.assertAlmostEqual(-5.196152422706632,vols.getIJ(0,0),12);
7405         bary=mesh.getBarycenterAndOwner();
7406         self.assertEqual(1,bary.getNumberOfTuples());
7407         self.assertEqual(3,bary.getNumberOfComponents());
7408         expected1=[0.,0.,1.]
7409         for i in xrange(3):
7410             self.assertAlmostEqual(expected1[i],bary.getIJ(0,i),12);
7411             pass
7412         d1=DataArrayInt.New();
7413         d2=DataArrayInt.New();
7414         d3=DataArrayInt.New();
7415         d4=DataArrayInt.New();
7416         m2=mesh.buildDescendingConnectivity(d1,d2,d3,d4);
7417         self.assertEqual(8,m2.getNumberOfCells());
7418         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]];
7419         expected2=[NORM_POLYGON, NORM_POLYGON, NORM_QUAD4, NORM_QUAD4, NORM_QUAD4, NORM_QUAD4, NORM_QUAD4, NORM_QUAD4];
7420         expected3=[6,6,4,4,4,4,4,4]
7421         for i in xrange(8):
7422             self.assertTrue(m2.getTypeOfCell(i)==expected2[i]);
7423             v=m2.getNodeIdsOfCell(i);
7424             self.assertTrue(len(v)==expected3[i]);
7425             self.assertEqual(expected4[i],v);
7426         #
7427         mesh.convertAllToPoly();
7428         self.assertTrue(NORM_POLYHED==mesh.getTypeOfCell(0));
7429         mesh.unPolyze();
7430         self.assertTrue(NORM_HEXGP12==mesh.getTypeOfCell(0));
7431         self.assertEqual(13,mesh.getMeshLength());
7432         #
7433         pass
7434
7435     def testDADCheckIsMonotonic(self):
7436         da=DataArrayDouble.New();
7437         da.setValues([-1.,1.01,2.03,6.],2,2);
7438         self.assertRaises(InterpKernelException,da.isMonotonic,True,1e-12);
7439         da.rearrange(1);
7440         self.assertTrue(da.isMonotonic(True,1e-12));
7441         da.checkMonotonic(True,1e-12);
7442         da.setIJ(2,0,6.1);
7443         self.assertTrue(not da.isMonotonic(True,1e-12));
7444         self.assertRaises(InterpKernelException,da.checkMonotonic,True,1e-12);
7445         da.setIJ(2,0,5.99);
7446         self.assertTrue(da.isMonotonic(True,1e-12));
7447         self.assertTrue(not da.isMonotonic(True,1e-1));
7448         pass
7449
7450     def testCheckCoherencyDeeper1(self):
7451         m=MEDCouplingDataForTest.build3DSourceMesh_1();
7452         m.checkCoherency();
7453         m.checkCoherency1();
7454         m.getNodalConnectivity().setIJ(8,0,-1);
7455         m.checkCoherency();
7456         self.assertRaises(InterpKernelException,m.checkCoherency1);
7457         m.getNodalConnectivity().setIJ(8,0,-6);
7458         m.checkCoherency();
7459         self.assertRaises(InterpKernelException,m.checkCoherency1);
7460         m.getNodalConnectivity().setIJ(8,0,9);#9>=NbOfNodes
7461         m.checkCoherency();
7462         self.assertRaises(InterpKernelException,m.checkCoherency1);
7463         m.getNodalConnectivity().setIJ(8,0,8);#OK
7464         m.checkCoherency();
7465         m.checkCoherency1();
7466         elts=[1,5]
7467         m.convertToPolyTypes(elts);
7468         m.checkCoherency();
7469         m.checkCoherency1();
7470         m.getNodalConnectivity().setIJ(2,0,9);#9>=NbOfNodes
7471         m.checkCoherency();
7472         self.assertRaises(InterpKernelException,m.checkCoherency1);
7473         m.getNodalConnectivity().setIJ(2,0,-3);
7474         m.checkCoherency();
7475         self.assertRaises(InterpKernelException,m.checkCoherency1);
7476         m.getNodalConnectivity().setIJ(2,0,-1);
7477         m.checkCoherency();
7478         self.assertRaises(InterpKernelException,m.checkCoherency1);#Throw because cell#0 is not a polyhedron
7479         m.getNodalConnectivity().setIJ(2,0,4);
7480         m.checkCoherency();
7481         m.checkCoherency1();
7482         m.getNodalConnectivity().setIJ(7,0,-1);
7483         m.checkCoherency();
7484         m.checkCoherency1();#OK because we are in polyhedron connec
7485         m.getNodalConnectivity().setIJ(36,0,14);
7486         m.checkCoherency();
7487         self.assertRaises(InterpKernelException,m.checkCoherency1);#Throw beacause now cell 5 is a TETRA4 (14) so mimatch of number index and static type.
7488         pass
7489
7490     def testUnPolyze2(self):
7491         m=MEDCouplingUMesh.New("jjj",3);
7492         coo=DataArrayDouble.New();
7493         coo.alloc(4,3);
7494         coo.rearrange(1);
7495         coo.iota(0);
7496         coo.rearrange(3);
7497         m.setCoords(coo);
7498         m.allocateCells(2);
7499         m.insertNextCell(NORM_TETRA4,4,[0,1,2,3]);
7500         m.insertNextCell(NORM_TETRA4,4,[0,1,2,3]);
7501         m.finishInsertingCells();
7502         m2=MEDCouplingUMesh.MergeUMeshesOnSameCoords(4*[m]);
7503         m2.convertToPolyTypes([2]);
7504         m2.unPolyze();
7505         self.assertEqual(NORM_TETRA4,m2.getTypeOfCell(2));
7506         self.assertEqual(40,m2.getMeshLength());
7507         temp2=m2.getNodeIdsOfCell(2);
7508         self.assertEqual(temp2,[0,1,2,3]);
7509         m2.checkCoherency1();
7510         m3=m2.deepCpy();
7511         m2.unPolyze();
7512         self.assertTrue(m3.isEqual(m2,1e-12));
7513         pass
7514
7515     def testDACpyFrom1(self):
7516         d=DataArrayDouble.New();
7517         d.alloc(12,1);
7518         d.iota(14.);
7519         d.rearrange(3);
7520         d.setName("Toto");
7521         d.setInfoOnComponent(0,"X [m]");
7522         d.setInfoOnComponent(1,"Y [m]");
7523         d.setInfoOnComponent(2,"Z [m]");
7524         #
7525         d1=DataArrayDouble.New();
7526         self.assertTrue(not d.isEqual(d1,1e-12));
7527         d1.cpyFrom(d);
7528         self.assertTrue(d.isEqual(d1,1e-12));
7529         d1.cpyFrom(d);
7530         self.assertTrue(d.isEqual(d1,1e-12));
7531         d1.rearrange(2);
7532         self.assertTrue(not d.isEqual(d1,1e-12));
7533         d1.cpyFrom(d);
7534         self.assertTrue(d.isEqual(d1,1e-12));
7535         #
7536         d2=d.convertToIntArr();
7537         d4=DataArrayInt.New();
7538         self.assertTrue(not d2.isEqual(d4));
7539         d4.cpyFrom(d2);
7540         self.assertTrue(d2.isEqual(d4));
7541         d4.cpyFrom(d2);
7542         self.assertTrue(d2.isEqual(d4));
7543         d4.rearrange(2);
7544         self.assertTrue(not d2.isEqual(d4));
7545         d4.cpyFrom(d2);
7546         self.assertTrue(d2.isEqual(d4));
7547         pass
7548
7549     def testDAITransformWithIndArr1(self):
7550         tab1=[17,18,22,19]
7551         tab2=[0,1,1,3,3,0,1,3,2,2,3,0]
7552         expected=[17,18,18,19,19,17,18,19,22,22,19,17]
7553         d=DataArrayInt.New();
7554         d.setValues(tab1,4,1);
7555         d1=DataArrayInt.New();
7556         d1.setValues(tab2,12,1);
7557         d2=d1[:]
7558         #
7559         d1.transformWithIndArr(d);
7560         self.assertEqual(12,d1.getNumberOfTuples());
7561         self.assertEqual(1,d1.getNumberOfComponents());
7562         for i in xrange(12):
7563             self.assertEqual(expected[i],d1.getIJ(i,0));
7564             pass
7565         #
7566         d1=d2
7567         d1.transformWithIndArr(tab1)
7568         self.assertEqual(12,d1.getNumberOfTuples());
7569         self.assertEqual(1,d1.getNumberOfComponents());
7570         for i in xrange(12):
7571             self.assertEqual(expected[i],d1.getIJ(i,0));
7572             pass
7573         pass
7574
7575     def testDAIBuildPermArrPerLevel1(self):
7576         arr=[2,0,1,1,0,1,2,0,1,1,0,0]
7577         expected1=[10,0,5,6,1,7,11,2,8,9,3,4]
7578         da=DataArrayInt.New();
7579         da.setValues(arr,12,1);
7580         da2=da.buildPermArrPerLevel();
7581         self.assertEqual(12,da2.getNumberOfTuples());
7582         self.assertEqual(1,da2.getNumberOfComponents());
7583         for i in xrange(12):
7584             self.assertEqual(expected1[i],da2.getIJ(i,0));
7585             pass
7586         pass
7587
7588     def testDAIOperations1(self):
7589         arr1=[-1,-2,4,7,3,2,6,6,4,3,0,1]
7590         da=DataArrayInt.New();
7591         da.setValues(arr1,4,3);
7592         da1=DataArrayInt.New();
7593         da1.alloc(12,1);
7594         da1.iota(2);
7595         self.assertRaises(InterpKernelException,DataArrayInt.Add,da,da1);#not same number of tuples/Components
7596         da1.rearrange(3);
7597         da2=DataArrayInt.Add(da,da1);
7598         self.assertEqual(4,da2.getNumberOfTuples());
7599         self.assertEqual(3,da2.getNumberOfComponents());
7600         expected1=[1,1,8,12,9,9,14,15,14,14,12,14]
7601         for i in xrange(12):
7602             self.assertEqual(expected1[i],da2.getIJ(0,i));
7603             pass
7604         da1.substractEqual(da);
7605         expected2=[3,5,0,-2,3,5,2,3,6,8,12,12]
7606         for i in xrange(12):
7607             self.assertEqual(expected2[i],da1.getIJ(0,i));
7608             pass
7609         da1.rearrange(1); da1.iota(2); da1.rearrange(3);
7610         da1.addEqual(da);
7611         for i in xrange(12):
7612             self.assertEqual(expected1[i],da1.getIJ(0,i));
7613             pass
7614         da1.rearrange(1); da1.iota(2); da1.rearrange(3);
7615         da2=DataArrayInt.Multiply(da,da1);
7616         self.assertEqual(4,da2.getNumberOfTuples());
7617         self.assertEqual(3,da2.getNumberOfComponents());
7618         expected3=[-2,-6,16,35,18,14,48,54,40,33,0,13]
7619         for i in xrange(12):
7620             self.assertEqual(expected3[i],da2.getIJ(0,i));
7621             pass
7622         da.divideEqual(da1);
7623         self.assertEqual(4,da.getNumberOfTuples());
7624         self.assertEqual(3,da.getNumberOfComponents());
7625         expected4=[0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0]
7626         for i in xrange(12):
7627             self.assertEqual(expected4[i],da.getIJ(0,i));
7628             pass
7629         da.setValues(arr1,4,3);
7630         da1.multiplyEqual(da);
7631         self.assertEqual(4,da1.getNumberOfTuples());
7632         self.assertEqual(3,da1.getNumberOfComponents());
7633         for i in xrange(12):
7634             self.assertEqual(expected3[i],da1.getIJ(0,i));
7635             pass
7636         da1.rearrange(1); da1.iota(2); da1.rearrange(3);
7637         da2=DataArrayInt.Divide(da,da1);
7638         self.assertEqual(4,da2.getNumberOfTuples());
7639         self.assertEqual(3,da2.getNumberOfComponents());
7640         for i in xrange(12):
7641             self.assertEqual(expected4[i],da2.getIJ(0,i));
7642             pass
7643         da1.applyInv(321);
7644         self.assertEqual(4,da1.getNumberOfTuples());
7645         self.assertEqual(3,da1.getNumberOfComponents());
7646         expected5=[160,107,80,64,53,45,40,35,32,29,26,24]
7647         for i in xrange(12):
7648             self.assertEqual(expected5[i],da1.getIJ(0,i));
7649             pass
7650         da1.applyDivideBy(2);
7651         self.assertEqual(4,da1.getNumberOfTuples());
7652         self.assertEqual(3,da1.getNumberOfComponents());
7653         expected6=[80,53,40,32,26,22,20,17,16,14,13,12]
7654         for i in xrange(12):
7655             self.assertEqual(expected6[i],da1.getIJ(0,i));
7656             pass
7657         expected7=[3,4,5,4,5,1,6,3,2,0,6,5]
7658         da1.applyModulus(7);
7659         for i in xrange(12):
7660             self.assertEqual(expected7[i],da1.getIJ(0,i));
7661             pass
7662         da1.applyLin(1,1);
7663         expected8=[3,3,3,3,3,1,3,3,0,0,3,3]
7664         da1.applyRModulus(3);
7665         for i in xrange(12):
7666             self.assertEqual(expected8[i],da1.getIJ(0,i));
7667             pass
7668         pass
7669
7670     def testEmulateMEDMEMBDC1(self):
7671         m,m1=MEDCouplingDataForTest.buildPointe_1();
7672         m2,da1,da2,da3,da4,da5,da0=m.emulateMEDMEMBDC(m1)
7673         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]
7674         expected1=[1,32,29,23,41,36]
7675         self.assertEqual(47,da0.getNumberOfTuples());
7676         self.assertEqual(1,da0.getNumberOfComponents());
7677         for i in xrange(47):
7678             self.assertEqual(expected0[i],da0.getIJ(0,i));
7679             pass
7680         self.assertEqual(6,da5.getNumberOfTuples());
7681         self.assertEqual(1,da5.getNumberOfComponents());
7682         for i in xrange(6):
7683             self.assertEqual(expected1[i],da5.getIJ(0,i));
7684             pass
7685         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]
7686         self.assertEqual(70,da1.getNumberOfTuples());
7687         self.assertEqual(1,da1.getNumberOfComponents());
7688         for i in xrange(70):
7689             self.assertEqual(expected2[i],da1.getIJ(0,i));
7690             pass
7691         expected3=[0,4,8,12,16,20,24,28,32,36,40,44,48,53,58,64,70]
7692         self.assertEqual(17,da2.getNumberOfTuples());
7693         self.assertEqual(1,da2.getNumberOfComponents());
7694         for i in xrange(17):
7695             self.assertEqual(expected3[i],da2.getIJ(0,i));
7696             pass
7697         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]
7698         #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];
7699         self.assertEqual(48,da4.getNumberOfTuples());
7700         self.assertEqual(1,da4.getNumberOfComponents());
7701         for i in xrange(48):
7702             self.assertEqual(expected4[i],da4.getIJ(0,i));
7703             pass
7704         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]
7705         self.assertEqual(70,da3.getNumberOfTuples());
7706         self.assertEqual(1,da3.getNumberOfComponents());
7707         for i in xrange(70):
7708             self.assertEqual(expected5[i],da3.getIJ(0,i));
7709             pass
7710         pass
7711
7712     def testGetLevArrPerCellTypes1(self):
7713         m,m1=MEDCouplingDataForTest.buildPointe_1();
7714         m1,d0,d1,d2,d3=m.buildDescendingConnectivity();
7715         order=[NORM_TRI3,NORM_QUAD4];
7716         da0,da1=m1.getLevArrPerCellTypes(order);
7717         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]
7718         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]
7719         self.assertEqual(47,da0.getNumberOfTuples());
7720         self.assertEqual(1,da0.getNumberOfComponents());
7721         for i in xrange(47):
7722             self.assertEqual(expected0[i],da0.getIJ(0,i));
7723             pass
7724         self.assertEqual(2,da1.getNumberOfTuples());
7725         self.assertEqual(1,da1.getNumberOfComponents());
7726         self.assertEqual(36,da1.getIJ(0,0));#36 TRI3
7727         self.assertEqual(11,da1.getIJ(1,0));#11 QUAD4
7728         #
7729         da2=da0.buildPermArrPerLevel();
7730         #
7731         self.assertEqual(47,da2.getNumberOfTuples());
7732         self.assertEqual(1,da2.getNumberOfComponents());
7733         for i in xrange(47):
7734             self.assertEqual(expected1[i],da2.getIJ(0,i));
7735             pass
7736         pass
7737
7738     def testSortCellsInMEDFileFrmt1(self):
7739         m,m1=MEDCouplingDataForTest.buildPointe_1();
7740         m2=m.deepCpy()
7741         da=DataArrayInt.New()
7742         da.setValues([0,1,2,14,3,12,4,5,15,6,7,8,9,10,11,13],16,1)
7743         daa=da.invertArrayN2O2O2N(16)
7744         m.renumberCells(daa,False)
7745         da2=m.sortCellsInMEDFileFrmt()
7746         self.assertEqual(da2.getValues(),[0,1,2,14,3,12,4,5,15,6,7,8,9,10,11,13])
7747         self.assertTrue(m.isEqual(m2,1e-12))
7748         self.assertTrue(da.isEqual(da2))
7749         pass
7750
7751     def testBuildPartAndReduceNodes1(self):
7752         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7753         arr=[1,0]
7754         m2,da=m.buildPartAndReduceNodes(arr);
7755         self.assertEqual(5,m2.getNumberOfNodes());
7756         self.assertEqual(2,m2.getNumberOfCells());
7757         f=m2.getMeasureField(True);
7758         self.assertAlmostEqual(0.125,f.getArray().getIJ(0,0),12);
7759         self.assertAlmostEqual(0.25,f.getArray().getIJ(1,0),12);
7760         #
7761         arr2=DataArrayInt.New()
7762         arr2.setValues(arr,2,1)
7763         m2,da=m.buildPartAndReduceNodes(arr2);
7764         self.assertEqual(5,m2.getNumberOfNodes());
7765         self.assertEqual(2,m2.getNumberOfCells());
7766         f=m2.getMeasureField(True);
7767         self.assertAlmostEqual(0.125,f.getArray().getIJ(0,0),12);
7768         self.assertAlmostEqual(0.25,f.getArray().getIJ(1,0),12);
7769         pass
7770
7771     def testDAITransformWithIndArrR1(self):
7772         tab1=[2,4,5,3,6,7]
7773         tab2=[-1,-1,0,1,2,3,4,5,-1,-1,-1,-1]
7774         expected=[0,3,1,2,4,5]
7775         d=DataArrayInt.New();
7776         d.setValues(tab1,6,1);
7777         d1=DataArrayInt.New();
7778         d1.setValues(tab2,12,1);
7779         d2=d1[:]
7780         #
7781         d3=d.transformWithIndArrR(d1);
7782         self.assertEqual(6,d3.getNumberOfTuples());
7783         self.assertEqual(1,d3.getNumberOfComponents());
7784         for i in xrange(6):
7785             self.assertEqual(expected[i],d3.getIJ(i,0));
7786             pass
7787         #
7788         d1=d2
7789         d3=d.transformWithIndArrR(tab2)
7790         self.assertEqual(6,d3.getNumberOfTuples());
7791         self.assertEqual(1,d3.getNumberOfComponents());
7792         for i in xrange(6):
7793             self.assertEqual(expected[i],d3.getIJ(i,0));
7794             pass
7795         pass
7796
7797     def testDAISplitByValueRange1(self):
7798         val1=[6,5,0,3,2,7,8,1,4]
7799         val2=[0,4,9]
7800         d=DataArrayInt.New();
7801         d.setValues(val1,9,1);
7802         e,f,g=d.splitByValueRange(val2);
7803         self.assertEqual(9,e.getNumberOfTuples());
7804         self.assertEqual(1,e.getNumberOfComponents());
7805         self.assertEqual(9,f.getNumberOfTuples());
7806         self.assertEqual(1,f.getNumberOfComponents());
7807         self.assertEqual(2,g.getNumberOfTuples());
7808         self.assertEqual(1,g.getNumberOfComponents());
7809         #
7810         expected1=[1,1,0,0,0,1,1,0,1]
7811         expected2=[2,1,0,3,2,3,4,1,0]
7812         for i in xrange(9):
7813             self.assertEqual(expected1[i],e.getIJ(i,0));
7814             self.assertEqual(expected2[i],f.getIJ(i,0));
7815             pass
7816         self.assertEqual(0,g.getIJ(0,0));
7817         self.assertEqual(1,g.getIJ(1,0));
7818         #
7819         d.setIJ(6,0,9);
7820         self.assertRaises(InterpKernelException,d.splitByValueRange,val2);
7821         pass
7822
7823     def testUMeshSplitProfilePerType1(self):
7824         val0=[2,0,1,3,4]
7825         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7826         m.renumberCells(val0,False);
7827         #
7828         val1=[0,2,3]
7829         d=DataArrayInt.New();
7830         d.setValues(val1,3,1);
7831         d.setName("sup")
7832         code,idsInPflPerType,pfls=m.splitProfilePerType(d);
7833         self.assertEqual(2,len(code));
7834         self.assertEqual(2,len(idsInPflPerType));
7835         expected1=[[3,1,0], [4,2,1]]
7836         self.assertEqual(expected1,code)
7837         self.assertEqual(2,len(idsInPflPerType));
7838         self.assertEqual(1,idsInPflPerType[0].getNumberOfTuples());
7839         self.assertEqual(0,idsInPflPerType[0].getIJ(0,0));
7840         self.assertEqual(2,idsInPflPerType[1].getNumberOfTuples());
7841         self.assertEqual(1,idsInPflPerType[1].getIJ(0,0));
7842         self.assertEqual(2,idsInPflPerType[1].getIJ(1,0));
7843         #
7844         self.assertEqual(2,len(pfls));
7845         self.assertEqual("sup",pfls[0].getName())
7846         self.assertEqual(1,pfls[0].getNumberOfTuples());
7847         self.assertEqual(0,pfls[0].getIJ(0,0));
7848         self.assertEqual("sup",pfls[1].getName())
7849         self.assertEqual(2,pfls[1].getNumberOfTuples());
7850         self.assertEqual(0,pfls[1].getIJ(0,0));
7851         self.assertEqual(1,pfls[1].getIJ(1,0));
7852         #
7853         val2=[0,2,3,4]
7854         d=DataArrayInt.New();
7855         d.setValues(val2,4,1);
7856         code,idsInPflPerType,pfls=m.splitProfilePerType(d);
7857         self.assertEqual(2,len(code));
7858         self.assertEqual(2,len(idsInPflPerType));
7859         expected2=[[3,1,0], [4,3,-1]]
7860         self.assertEqual(expected2,code);
7861         self.assertEqual(2,len(idsInPflPerType));
7862         self.assertEqual(1,idsInPflPerType[0].getNumberOfTuples());
7863         self.assertEqual(0,idsInPflPerType[0].getIJ(0,0));
7864         self.assertEqual(3,idsInPflPerType[1].getNumberOfTuples());
7865         self.assertEqual(1,idsInPflPerType[1].getIJ(0,0));
7866         self.assertEqual(2,idsInPflPerType[1].getIJ(1,0));
7867         self.assertEqual(3,idsInPflPerType[1].getIJ(2,0));
7868         #
7869         self.assertEqual(1,len(pfls));
7870         self.assertEqual(1,pfls[0].getNumberOfTuples());
7871         self.assertEqual(0,pfls[0].getIJ(0,0));
7872         #
7873         val3=[1,0,2]
7874         d=DataArrayInt.New();
7875         d.setValues(val3,3,1);
7876         code,idsInPflPerType,pfls=m.splitProfilePerType(d);
7877         self.assertEqual(2,len(code));
7878         self.assertEqual(2,len(idsInPflPerType));
7879         expected3=[[3,2,0], [4,1,1]]
7880         self.assertEqual(expected3,code);
7881         self.assertEqual(2,len(idsInPflPerType));
7882         self.assertEqual(2,idsInPflPerType[0].getNumberOfTuples());
7883         self.assertEqual(0,idsInPflPerType[0].getIJ(0,0));
7884         self.assertEqual(1,idsInPflPerType[0].getIJ(1,0));
7885         self.assertEqual(1,idsInPflPerType[1].getNumberOfTuples());
7886         self.assertEqual(2,idsInPflPerType[1].getIJ(0,0));
7887         #
7888         self.assertEqual(2,len(pfls));
7889         self.assertEqual(2,pfls[0].getNumberOfTuples());
7890         self.assertEqual(1,pfls[0].getIJ(0,0));
7891         self.assertEqual(0,pfls[0].getIJ(1,0));
7892         self.assertEqual(0,pfls[1].getIJ(0,0));
7893         #
7894         val4=[3,4]
7895         d=DataArrayInt.New();
7896         d.setValues(val4,2,1);
7897         code,idsInPflPerType,pfls=m.splitProfilePerType(d);
7898         self.assertEqual(1,len(code));
7899         self.assertEqual(1,len(idsInPflPerType));
7900         expected4=[[4,2,0]]
7901         self.assertEqual(expected4,code);
7902         self.assertEqual(1,len(idsInPflPerType));
7903         self.assertEqual(2,idsInPflPerType[0].getNumberOfTuples());
7904         self.assertEqual(0,idsInPflPerType[0].getIJ(0,0));
7905         self.assertEqual(1,idsInPflPerType[0].getIJ(1,0));
7906         #
7907         self.assertEqual(1,len(pfls));
7908         self.assertEqual(2,pfls[0].getNumberOfTuples());
7909         self.assertEqual(1,pfls[0].getIJ(0,0));
7910         self.assertEqual(2,pfls[0].getIJ(1,0));
7911         pass
7912
7913     def testDAIBuildExplicitArrByRanges1(self):
7914         d=DataArrayInt.New();
7915         vals1=[0,2,3]
7916         d.setValues(vals1,3,1);
7917         e=DataArrayInt.New();
7918         vals2=[0,3,6,10,14,20]
7919         e.setValues(vals2,6,1);
7920         #
7921         f=d.buildExplicitArrByRanges(e);
7922         self.assertEqual(11,f.getNumberOfTuples());
7923         self.assertEqual(1,f.getNumberOfComponents());
7924         expected1=[0,1,2,6,7,8,9,10,11,12,13]
7925         for i in xrange(11):
7926             self.assertEqual(expected1[i],f.getIJ(i,0));
7927             pass
7928         pass
7929
7930     def testDAIComputeOffsets2(self):
7931         d=DataArrayInt.New();
7932         vals1=[3,5,1,2,0,8]
7933         expected1=[0,3,8,9,11,11,19]
7934         d.setValues(vals1,6,1);
7935         d.computeOffsets2();
7936         self.assertEqual(7,d.getNumberOfTuples());
7937         self.assertEqual(1,d.getNumberOfComponents());
7938         for i in xrange(7):
7939             self.assertEqual(expected1[i],d.getIJ(0,i));
7940             pass
7941         pass
7942
7943     def testMergeField3(self):
7944         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7945         m.getCoords().setInfoOnComponent(0,"x [m]");
7946         m.getCoords().setInfoOnComponent(1,"z [km]");
7947         m.setName("m");
7948         m.setDescription("desc");
7949         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
7950         f1.setName("f1");
7951         f1.setMesh(m);
7952         arr=DataArrayDouble.New();
7953         arr.alloc(5,2);
7954         arr.setInfoOnComponent(0,"X [m]");
7955         arr.setInfoOnComponent(1,"YY [mm]");
7956         arr.fillWithValue(2.);
7957         f1.setArray(arr);
7958         #
7959         f2=MEDCouplingFieldDouble.MergeFields([f1]);
7960         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
7961         #
7962         pass
7963
7964     def testGetDistributionOfTypes1(self):
7965         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7966         tab1=[2,0,1,3,4]
7967         self.assertRaises(InterpKernelException,m.getDistributionOfTypes);
7968         m.renumberCells(tab1,False);
7969         code=m.getDistributionOfTypes();
7970         self.assertEqual(2,len(code));
7971         self.assertEqual(3,code[0][0]);
7972         self.assertEqual(2,code[0][1]);
7973         self.assertEqual(-1,code[0][2]);
7974         self.assertEqual(4,code[1][0]);
7975         self.assertEqual(3,code[1][1]);
7976         self.assertEqual(-1,code[1][2]);
7977         pass
7978
7979     def testNorm2_1(self):
7980         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7981         f=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
7982         f.setMesh(m);
7983         #
7984         d=DataArrayDouble.New();
7985         tab=[1.2,1.3,2.2,2.3,3.2,3.3,4.2,4.3,5.2,5.3]
7986         d.setValues(tab,5,2);
7987         f.setArray(d);
7988         f.checkCoherency();
7989         #
7990         self.assertAlmostEqual(11.209371079592289,f.norm2(),14);
7991         #
7992         pass
7993
7994     def testNormMax1(self):
7995         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7996         f=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
7997         f.setMesh(m);
7998         #
7999         d=DataArrayDouble.New();
8000         tab=[2.3,-1.2,6.3,-7.8,2.9,7.7,2.1,0.,3.6,-7.6]
8001         d.setValues(tab,5,2);
8002         f.setArray(d);
8003         f.checkCoherency();
8004         #
8005         self.assertAlmostEqual(7.8,f.normMax(),14);
8006         #
8007         pass
8008
8009     def testFindAndCorrectBadOriented3DExtrudedCells1(self):
8010         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];
8011         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]
8012         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]
8013         invalidCells=[2,3,6,7]
8014         m=MEDCouplingUMesh.New("Example",3);
8015         coo=DataArrayDouble.New();
8016         coo.setValues(coords,38,3);
8017         m.setCoords(coo);
8018         m.allocateCells(8);
8019         m.insertNextCell(NORM_PENTA6,6,conn[0:6])
8020         m.insertNextCell(NORM_PENTA6,6,conn[6:12])
8021         m.insertNextCell(NORM_PENTA6,6,conn[12:18])
8022         m.insertNextCell(NORM_PENTA6,6,conn[18:24])
8023         m.insertNextCell(NORM_HEXA8,8,conn[24:32])
8024         m.insertNextCell(NORM_HEXA8,8,conn[32:40])
8025         m.insertNextCell(NORM_HEXA8,8,conn[40:48])
8026         m.insertNextCell(NORM_HEXA8,8,conn[48:56])
8027         m.finishInsertingCells();
8028         #
8029         v=m.findAndCorrectBadOriented3DExtrudedCells();
8030         self.assertEqual(4,len(v));
8031         self.assertEqual(v.getValues(),invalidCells);
8032         self.assertEqual(connExp,m.getNodalConnectivity().getValues());
8033         self.assertTrue(m.findAndCorrectBadOriented3DExtrudedCells().empty())
8034         #
8035         pass
8036
8037     def testConvertExtrudedPolyhedra1(self):
8038         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]
8039         m=MEDCouplingUMesh.New("Example",3);
8040         coo=DataArrayDouble.New();
8041         coo.alloc(73,3);
8042         coo.rearrange(1); coo.iota(0); coo.rearrange(3);
8043         m.setCoords(coo);
8044         m.allocateCells(9);
8045         m.insertNextCell(NORM_TETRA4,4,conn[0:4])
8046         m.insertNextCell(NORM_HEXA8,8,conn[4:12])
8047         m.insertNextCell(NORM_TETRA4,4,conn[12:16])
8048         m.insertNextCell(NORM_POLYHED,6,conn[16:22])
8049         m.insertNextCell(NORM_PENTA6,6,conn[22:28])
8050         m.insertNextCell(NORM_POLYHED,10,conn[28:38])
8051         m.insertNextCell(NORM_HEXA8,8,conn[38:46])
8052         m.insertNextCell(NORM_HEXGP12,12,conn[46:58])
8053         m.insertNextCell(NORM_POLYHED,14,conn[58:72])
8054         m.finishInsertingCells();
8055         #
8056         m.convertExtrudedPolyhedra();
8057         da=m.getNodalConnectivity();
8058         dai=m.getNodalConnectivityIndex();
8059         self.assertEqual(10,dai.getNbOfElems());
8060         self.assertEqual(159,da.getNbOfElems());
8061         #
8062         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];
8063         expected2=[0,5,14,19,42,49,86,95,108,159]
8064         self.assertEqual(expected1,da.getValues());
8065         self.assertEqual(expected2,dai.getValues());
8066         m.checkCoherency2()
8067         pass
8068
8069     def testNonRegressionCopyTinyStrings(self):
8070         m=MEDCouplingDataForTest.build2DTargetMesh_1()
8071         f1=m.getMeasureField(True)
8072         f1.getArray().setInfoOnComponent(0,"P [N/m^2]")
8073         bary=m.getBarycenterAndOwner()
8074         f2=f1.buildNewTimeReprFromThis(NO_TIME,False)
8075         f2.setArray(bary)
8076         self.assertRaises(InterpKernelException,f1.copyTinyAttrFrom,f2)
8077         pass
8078
8079     def testDaDSetPartOfValuesAdv1(self):
8080         tab1=[3.,4.,5., 13.,14.,15., 23.,24.,25., 33.,34.,35., 43.,44.,45., 53.,54.,55.]
8081         tab2=[6.,7.,8., 16.,17.,18., 26.,27.,28.]
8082         tab3=[4,1, 2,2, 3,0]
8083         a=DataArrayDouble.New();
8084         a.setValues(tab1,6,3);
8085         b=DataArrayDouble.New();
8086         b.setValues(tab2,3,3);
8087         c=DataArrayInt.New();
8088         c.setValues(tab3,3,2);
8089         #
8090         a.setPartOfValuesAdv(b,c);
8091         expected1=[3.,4.,5., 13.,14.,15., 26.,27.,28., 6.,7.,8., 16.,17.,18., 53.,54.,55.]
8092         self.assertEqual(expected1,a.getValues());
8093         pass
8094
8095     def testUMeshBuildSetInstanceFromThis1(self):
8096         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
8097         m2=m.buildSetInstanceFromThis(3);
8098         self.assertTrue(m.isEqual(m2,1e-12));
8099         #
8100         m=MEDCouplingUMesh.New("toto",2);
8101         m2=m.buildSetInstanceFromThis(3);
8102         self.assertEqual(0,m2.getNumberOfNodes());
8103         self.assertEqual(0,m2.getNumberOfCells());
8104         pass
8105
8106     def testUMeshMergeMeshesCVW1(self):
8107         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
8108         m2=MEDCouplingUMesh.New("toto",2);
8109         m3=MEDCouplingUMesh.MergeUMeshes([m,m2]);
8110         m3.setName(m.getName());
8111         self.assertTrue(m.isEqual(m3,1e-12));
8112         pass
8113
8114     def testChangeUnderlyingMeshWithCMesh1(self):
8115         mesh=MEDCouplingCMesh.New();
8116         coordsX=DataArrayDouble.New();
8117         arrX=[ -1., 1., 2., 4. ]
8118         coordsX.setValues(arrX,4,1);
8119         coordsY=DataArrayDouble.New();
8120         arrY=[ -2., 2., 4., 8. ]
8121         coordsY.setValues(arrY,4,1);
8122         coordsZ=DataArrayDouble.New();
8123         arrZ=[ -3., 3., 6., 12. ]
8124         coordsZ.setValues(arrZ,4,1);
8125         mesh.setCoords(coordsX,coordsY,coordsZ);
8126         f=mesh.getMeasureField(True)
8127         mesh2=mesh.deepCpy()
8128         for myId in [0,1,2,10,11,12,20,21,22]:
8129             f=mesh.getMeasureField(True)
8130             f.changeUnderlyingMesh(mesh2,myId,1e-12);
8131             pass
8132         mesh2.setName("uuuu")
8133         for myId in [1,2,10,11,12,20,21,22]:
8134             f=mesh.getMeasureField(True)
8135             f.changeUnderlyingMesh(mesh2,myId,1e-12);
8136             pass
8137         pass
8138
8139     def testDADFindCommonTuples1(self):
8140         da=DataArrayDouble.New();
8141         # nbOftuples=1
8142         array1=[2.3,1.2,1.3,2.3,2.301,0.8]
8143         da.setValues(array1,6,1)
8144         c,cI=da.findCommonTuples(1e-2);
8145         expected1=[0,3,4]
8146         expected2=[0,3]
8147         self.assertEqual(3,c.getNbOfElems());
8148         self.assertEqual(2,cI.getNbOfElems());
8149         self.assertEqual(expected1,c.getValues())
8150         self.assertEqual(expected2,cI.getValues())
8151         c,cI=da.findCommonTuples(2e-1)
8152         expected3=[0,3,4,1,2]
8153         expected4=[0,3,5]
8154         self.assertEqual(5,c.getNbOfElems());
8155         self.assertEqual(3,cI.getNbOfElems());
8156         self.assertEqual(expected3,c.getValues())
8157         self.assertEqual(expected4,cI.getValues())
8158         # nbOftuples=2
8159         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]
8160         da.setValues(array2,6,2)
8161         c,cI=da.findCommonTuples(1e-2);
8162         self.assertEqual(3,c.getNbOfElems());
8163         self.assertEqual(2,cI.getNbOfElems());
8164         self.assertEqual(expected1,c.getValues())
8165         self.assertEqual(expected2,cI.getValues())
8166         c,cI=da.findCommonTuples(2e-1)
8167         self.assertEqual(5,c.getNbOfElems());
8168         self.assertEqual(3,cI.getNbOfElems());
8169         self.assertEqual(expected3,c.getValues())
8170         self.assertEqual(expected4,cI.getValues())
8171         # nbOftuples=3
8172         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]
8173         da.setValues(array3,6,3)
8174         c,cI=da.findCommonTuples(1e-2);
8175         self.assertEqual(3,c.getNbOfElems());
8176         self.assertEqual(2,cI.getNbOfElems());
8177         self.assertEqual(expected1,c.getValues())
8178         self.assertEqual(expected2,cI.getValues())
8179         c,cI=da.findCommonTuples(2e-1)
8180         self.assertEqual(5,c.getNbOfElems());
8181         self.assertEqual(3,cI.getNbOfElems());
8182         self.assertEqual(expected3,c.getValues())
8183         self.assertEqual(expected4,cI.getValues())
8184         # nbOftuples=1, no common groups
8185         array11=[2.3,1.2,1.3,2.4,2.5,0.8]
8186         da.setValues(array11,6,1)
8187         c,cI=da.findCommonTuples(1e-2);
8188         self.assertEqual(0,c.getNbOfElems());
8189         self.assertEqual(1,cI.getNbOfElems());
8190         self.assertEqual([0],cI.getValues())
8191
8192         array12=[0.]*(6*5)
8193         da.setValues(array12,6,5) #bad NumberOfComponents
8194         self.assertRaises(InterpKernelException, da.findCommonTuples, 1e-2);
8195         pass
8196
8197     def testDABack1(self):
8198         da=DataArrayDouble.New();
8199         array1=[2.3,1.2,1.3,2.3,2.301,0.8]
8200         da.setValues(array1,6,1);
8201         self.assertAlmostEqual(0.8,da.back(),14);
8202         da.rearrange(2);
8203         self.assertRaises(InterpKernelException,da.back);
8204         da.alloc(0,1);
8205         self.assertRaises(InterpKernelException,da.back);
8206         #
8207         da=DataArrayInt.New();
8208         array2=[4,7,8,2]
8209         da.setValues(array2,4,1);
8210         self.assertEqual(2,da.back());
8211         da.rearrange(2);
8212         self.assertRaises(InterpKernelException,da.back);
8213         da.alloc(0,1);
8214         self.assertRaises(InterpKernelException,da.back);
8215         pass
8216
8217     def testDADGetDifferentValues1(self):
8218         da=DataArrayDouble.New();
8219         array1=[2.3,1.2,1.3,2.3,2.301,0.8]
8220         da.setValues(array1,6,1)
8221         #
8222         expected1=[2.301,1.2,1.3,0.8]
8223         dv=da.getDifferentValues(1e-2);
8224         self.assertEqual(4,dv.getNbOfElems());
8225         for i in xrange(4):
8226             self.assertAlmostEqual(expected1[i],dv.getIJ(i,0),14);
8227             pass
8228         #
8229         dv=da.getDifferentValues(2e-1);
8230         expected2=[2.301,1.3,0.8]
8231         self.assertEqual(3,dv.getNbOfElems());
8232         for i in xrange(3):
8233             self.assertAlmostEqual(expected2[i],dv.getIJ(i,0),14);
8234             pass
8235         pass
8236
8237     def testDAIBuildOld2NewArrayFromSurjectiveFormat2(self):
8238         arr=[0,3, 5,7,9]
8239         arrI=[0,2,5]
8240         a=DataArrayInt.New();
8241         a.setValues(arr,5,1);
8242         b=DataArrayInt.New();
8243         b.setValues(arrI,3,1);
8244         ret,newNbTuple=DataArrayInt.BuildOld2NewArrayFromSurjectiveFormat2(10,a,b);
8245         expected=[0,1,2,0,3,4,5,4,6,4]
8246         self.assertEqual(10,ret.getNbOfElems());
8247         self.assertEqual(7,newNbTuple);
8248         self.assertEqual(1,ret.getNumberOfComponents());
8249         self.assertEqual(expected,ret.getValues());
8250         self.assertRaises(InterpKernelException,DataArrayInt.BuildOld2NewArrayFromSurjectiveFormat2,9,a,b);
8251         pass
8252
8253     def testDADIReverse1(self):
8254         arr=[0,3,5,7,9,2]
8255         a=DataArrayInt.New();
8256         a.setValues(arr,6,1);
8257         self.assertEqual(2,a.back());
8258         a.reverse();
8259         for i in xrange(6):
8260             self.assertEqual(arr[5-i],a.getIJ(i,0));
8261             pass
8262         a.setValues(arr[:-1],5,1);
8263         a.reverse();
8264         for i in xrange(5):
8265             self.assertEqual(arr[4-i],a.getIJ(i,0));
8266             pass
8267         #
8268         arr2=[0.,3.,5.,7.,9.,2.]
8269         b=DataArrayDouble.New();
8270         b.setValues(arr2,6,1);
8271         b.reverse();
8272         for i in xrange(6):
8273             self.assertAlmostEqual(arr2[5-i],b.getIJ(i,0),14);
8274             pass
8275         b.setValues(arr2[:5],5,1);
8276         self.assertAlmostEqual(9.,b.back(),14)
8277         b.reverse();
8278         for i in xrange(5):
8279             self.assertAlmostEqual(arr2[4-i],b.getIJ(i,0),14);
8280             pass
8281         pass
8282
8283     def testGetNodeIdsInUse1(self):
8284         m0=MEDCouplingDataForTest.build2DTargetMesh_1();
8285         CellIds=[1,2]
8286         m1=m0.buildPartOfMySelf(CellIds,True);
8287         arr,newNbOfNodes=m1.getNodeIdsInUse();
8288         expected=[-1,0,1,-1,2,3,-1,-1,-1]
8289         self.assertEqual(4,newNbOfNodes);
8290         self.assertEqual(9,arr.getNbOfElems());
8291         self.assertEqual(expected,arr.getValues());
8292         arr2=arr.invertArrayO2N2N2O(newNbOfNodes);
8293         self.assertEqual(4,arr2.getNbOfElems());
8294         expected2=[1,2,4,5]
8295         self.assertEqual(expected2,arr2.getValues());
8296         pass
8297
8298     def testBuildDescendingConnec2(self):
8299         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
8300         #
8301         mesh2,desc,descIndx,revDesc,revDescIndx=mesh.buildDescendingConnectivity2();
8302         mesh2.checkCoherency();
8303         self.assertEqual(1,mesh2.getMeshDimension());
8304         self.assertEqual(13,mesh2.getNumberOfCells());
8305         self.assertEqual(14,revDescIndx.getNbOfElems()); self.assertEqual(14,revDescIndx.getNumberOfTuples());
8306         self.assertEqual(6,descIndx.getNbOfElems()); self.assertEqual(6,descIndx.getNumberOfTuples());
8307         self.assertEqual(18,desc.getNbOfElems()); self.assertEqual(18,desc.getNumberOfTuples());
8308         self.assertEqual(18,revDesc.getNbOfElems()); self.assertEqual(18,revDesc.getNumberOfTuples());
8309         expected1=[1,2,3,4,-3,5,6, 7,8,-5,9,10,-2,11, 12,13,-7,-10]
8310         self.assertEqual(expected1,desc.getValues());
8311         expected2=[0,4,7,10,14,18]
8312         self.assertEqual(expected2,descIndx.getValues());
8313         expected3=[0,1,3,5,6,8,9,11,12,13,15,16,17,18]
8314         self.assertEqual(expected3,revDescIndx.getValues());
8315         expected4=[0, 0,3, 0,1, 0, 1,2, 1, 2,4, 2, 3, 3,4, 3, 4, 4]
8316         self.assertEqual(expected4,revDesc.getValues());
8317         conn=mesh2.getNodalConnectivity();
8318         connIndex=mesh2.getNodalConnectivityIndex();
8319         expected5=[0,3,6,9,12,15,18,21,24,27,30,33,36,39]
8320         self.assertEqual(expected5,connIndex.getValues());
8321         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]
8322         self.assertEqual(expected6,conn.getValues());
8323         pass
8324
8325     def testIntersect2DMeshesTmp1(self):
8326         m1c=MEDCouplingCMesh.New();
8327         coordsX=DataArrayDouble.New();
8328         arrX=[ -1., 1., 2., 4. ]
8329         coordsX.setValues(arrX,4,1);
8330         m1c.setCoordsAt(0,coordsX);
8331         coordsY=DataArrayDouble.New();
8332         arrY=[ -2., 2., 4., 8. ]
8333         coordsY.setValues(arrY,4,1);
8334         m1c.setCoordsAt(1,coordsY);
8335         m1=m1c.buildUnstructured()
8336         m1bis=m1.buildPartOfMySelf([3,4,5],False)
8337         m2=m1.deepCpy()
8338         m2=m2.buildPartOfMySelf([0,1,2],False)
8339         m2.translate([0.5,0.5])
8340         #
8341         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m1bis,m2,1e-10)
8342         expected1=[0,0,1,1,1,2,2,2]
8343         expected2=[0,-1,0,1,-1,1,2,-1]
8344         self.assertEqual(8,d1.getNumberOfTuples());
8345         self.assertEqual(8,d2.getNumberOfTuples());
8346         self.assertEqual(8,m3.getNumberOfCells());
8347         self.assertEqual(22,m3.getNumberOfNodes());
8348         self.assertEqual(2,m3.getSpaceDimension());
8349         self.assertEqual(expected1,d1.getValues());
8350         self.assertEqual(expected2,d2.getValues());
8351         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]
8352         expected4=[0,5,12,17,22,28,33,38,44]
8353         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]
8354         self.assertEqual(44,m3.getNodalConnectivity().getNumberOfTuples());
8355         self.assertEqual(9,m3.getNodalConnectivityIndex().getNumberOfTuples());
8356         self.assertEqual(expected3,m3.getNodalConnectivity().getValues());
8357         self.assertEqual(expected4,m3.getNodalConnectivityIndex().getValues());
8358         for i in xrange(44):
8359             self.assertAlmostEqual(expected5[i],m3.getCoords().getIJ(0,i),12);
8360             pass
8361         pass
8362
8363     def testFindNodesOnLine1(self):
8364         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
8365         pt=[-0.3,-0.3]
8366         pt2=[0.,0.,0.]
8367         pt3=[-0.3,0.,0.]
8368         vec=[0.,1.]
8369         vec2=[1.,0.,0.]
8370         vec3=[0.,1.,1.]
8371         expected1=[0,3,6]
8372         res=mesh.findNodesOnLine(pt,vec,1e-12);
8373         self.assertEqual(3,len(res));
8374         self.assertEqual(expected1,res.getValues());
8375         #
8376         mesh.changeSpaceDimension(3);
8377         mesh.rotate(pt2,vec2,pi/4.);
8378         res=mesh.findNodesOnLine(pt3,vec3,1e-12);
8379         self.assertEqual(3,len(res));
8380         self.assertEqual(expected1,res.getValues());
8381         pass
8382
8383     def testIntersect2DMeshesTmp2(self):
8384         m1c=MEDCouplingCMesh.New();
8385         coordsX1=DataArrayDouble.New();
8386         arrX1=[ 0., 1., 1.5, 2. ]
8387         coordsX1.setValues(arrX1,4,1);
8388         m1c.setCoordsAt(0,coordsX1);
8389         coordsY1=DataArrayDouble.New();
8390         arrY1=[ 0., 1.5, 3.]
8391         coordsY1.setValues(arrY1,3,1);
8392         m1c.setCoordsAt(1,coordsY1);
8393         m1=m1c.buildUnstructured();
8394         m2c=MEDCouplingCMesh.New();
8395         coordsX2=DataArrayDouble.New();
8396         arrX2=[ 0., 1., 2. ]
8397         coordsX2.setValues(arrX2,3,1);
8398         m2c.setCoordsAt(0,coordsX2);
8399         coordsY2=DataArrayDouble.New();
8400         arrY2=[ 0., 1., 3.]
8401         coordsY2.setValues(arrY2,3,1);
8402         m2c.setCoordsAt(1,coordsY2);
8403         m2=m2c.buildUnstructured();
8404         #
8405         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m1,m2,1e-10)
8406         #
8407         expected1=[0,0,1,1,2,2,3,4,5]
8408         expected2=[0,2,1,3,1,3,2,3,3]
8409         self.assertEqual(9,d1.getNumberOfTuples());
8410         self.assertEqual(9,d2.getNumberOfTuples());
8411         self.assertEqual(9,m3.getNumberOfCells());
8412         self.assertEqual(22,m3.getNumberOfNodes());
8413         self.assertEqual(2,m3.getSpaceDimension());
8414         self.assertEqual(expected1,d1.getValues());
8415         self.assertEqual(expected2,d2.getValues());
8416         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]
8417         expected4=[0,5,10,15,20,25,30,35,40,45]
8418         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]
8419         self.assertEqual(45,m3.getNodalConnectivity().getNumberOfTuples());
8420         self.assertEqual(10,m3.getNodalConnectivityIndex().getNumberOfTuples());
8421         self.assertEqual(expected3,m3.getNodalConnectivity().getValues());
8422         self.assertEqual(expected4,m3.getNodalConnectivityIndex().getValues());
8423         for i in xrange(44):
8424             self.assertAlmostEqual(expected5[i],m3.getCoords().getIJ(0,i),12);
8425             pass
8426         pass
8427
8428     def testBuildPartOfMySelfSafe1(self):
8429         mesh=MEDCouplingDataForTest.build2DTargetMesh_1()
8430         self.assertRaises(InterpKernelException,mesh.buildPartOfMySelf,[0,-1,4,2],True)
8431         self.assertRaises(InterpKernelException,mesh.buildPartOfMySelf,[0,4,5,4],True)
8432         pass
8433
8434     def testIntersect2DMeshesTmp3(self):
8435         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];
8436         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];
8437         m1=MEDCouplingUMesh.New();
8438         m1.setMeshDimension(2);
8439         m1.allocateCells(8);
8440         m1.insertNextCell(NORM_TRI6,6,m1Conn[0:6]);
8441         m1.insertNextCell(NORM_QUAD8,8,m1Conn[6:14]);
8442         m1.insertNextCell(NORM_TRI6,6,m1Conn[14:20]);
8443         m1.insertNextCell(NORM_QUAD8,8,m1Conn[20:28]);
8444         m1.insertNextCell(NORM_TRI6,6,m1Conn[28:34]);
8445         m1.insertNextCell(NORM_QUAD8,8,m1Conn[34:42]);
8446         m1.insertNextCell(NORM_TRI6,6,m1Conn[42:48]);
8447         m1.insertNextCell(NORM_QUAD8,8,m1Conn[48:56]);
8448         m1.finishInsertingCells();
8449         myCoords1=DataArrayDouble.New();
8450         myCoords1.setValues(m1Coords,25,2);
8451         m1.setCoords(myCoords1);
8452         #
8453         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.]
8454         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]
8455         m2=MEDCouplingUMesh.New();
8456         m2.setMeshDimension(2);
8457         m2.allocateCells(8);
8458         for i in xrange(8):
8459             m2.insertNextCell(NORM_QUAD4,4,m2Conn[4*i:4*(i+1)])
8460             pass
8461         m2.finishInsertingCells();
8462         myCoords2=DataArrayDouble.New();
8463         myCoords2.setValues(m2Coords,15,2);
8464         m2.setCoords(myCoords2);
8465         #
8466         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m1,m2,1e-10)
8467         m3.unPolyze()
8468         #
8469         expected1=[0,1,1,1,2,3,3,3,4,5,5,5,6,7,7,7]
8470         expected2=[0,0,1,-1,2,2,3,-1,4,4,5,-1,6,6,7,-1]
8471         self.assertEqual(16,d1.getNumberOfTuples());
8472         self.assertEqual(16,d2.getNumberOfTuples());
8473         self.assertEqual(16,m3.getNumberOfCells());
8474         self.assertEqual(104,m3.getNumberOfNodes());
8475         self.assertEqual(2,m3.getSpaceDimension());
8476         self.assertEqual(expected1,d1.getValues());
8477         self.assertEqual(expected2,d2.getValues());
8478         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]
8479         expected4=[0,7,16,25,34,41,50,59,68,75,84,93,102,109,118,127,136]
8480         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]
8481         self.assertEqual(136,m3.getNodalConnectivity().getNumberOfTuples());
8482         self.assertEqual(17,m3.getNodalConnectivityIndex().getNumberOfTuples());
8483         self.assertEqual(expected3,m3.getNodalConnectivity().getValues());
8484         self.assertEqual(expected4,m3.getNodalConnectivityIndex().getValues());
8485         for i in xrange(208):
8486             self.assertAlmostEqual(expected5[i],m3.getCoords().getIJ(0,i),12);
8487             pass
8488         pass
8489
8490     def testUMeshTessellate2D1(self):
8491         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];
8492         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];
8493         m1=MEDCouplingUMesh.New();
8494         m1.setMeshDimension(2);
8495         m1.allocateCells(8);
8496         m1.insertNextCell(NORM_TRI6,6,m1Conn[0:6]);
8497         m1.insertNextCell(NORM_QUAD8,8,m1Conn[6:14]);
8498         m1.insertNextCell(NORM_TRI6,6,m1Conn[14:20]);
8499         m1.insertNextCell(NORM_QUAD8,8,m1Conn[20:28]);
8500         m1.insertNextCell(NORM_TRI6,6,m1Conn[28:34]);
8501         m1.insertNextCell(NORM_QUAD8,8,m1Conn[34:42]);
8502         m1.insertNextCell(NORM_TRI6,6,m1Conn[42:48]);
8503         m1.insertNextCell(NORM_QUAD8,8,m1Conn[48:56]);
8504         m1.finishInsertingCells();
8505         myCoords1=DataArrayDouble.New();
8506         myCoords1.setValues(m1Coords,25,2);
8507         m1.setCoords(myCoords1);
8508         #
8509         m11=m1.deepCpy();
8510         m11.tessellate2D(1.);
8511         self.assertTrue(m11.getCoords().isEqual(m11.getCoords(),1e-12));
8512         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]
8513         expected2=[0,5,12,17,24,29,36,41,48]
8514         self.assertEqual(48,m11.getNodalConnectivity().getNumberOfTuples());
8515         self.assertEqual(9,m11.getNodalConnectivityIndex().getNumberOfTuples());
8516         self.assertEqual(expected1,m11.getNodalConnectivity().getValues());
8517         self.assertEqual(expected2,m11.getNodalConnectivityIndex().getValues());
8518         #
8519         m12=m1.deepCpy();
8520         m12.tessellate2D(0.5);
8521         self.assertEqual(41,m12.getNumberOfNodes());
8522         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]
8523         expected4=[0,6,15,21,30,36,45,51,60]
8524         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]
8525         for i in xrange(82):
8526             self.assertAlmostEqual(expected5[i],m12.getCoords().getIJ(0,i),12);
8527             pass
8528         self.assertEqual(60,m12.getNodalConnectivity().getNumberOfTuples());
8529         self.assertEqual(9,m12.getNodalConnectivityIndex().getNumberOfTuples());
8530         self.assertEqual(expected3,m12.getNodalConnectivity().getValues());
8531         self.assertEqual(expected4,m12.getNodalConnectivityIndex().getValues());
8532         pass
8533
8534     def testUMeshTessellate2DCurve1(self):
8535         # A quarter of circle:
8536         mcoords = [0.4,0.0,   0.0,-0.4,   0.283,-0.283]
8537         mconnec = [0,1,2]
8538
8539         m1 = MEDCouplingUMesh.New()
8540         m1.setMeshDimension(1)
8541         m1.allocateCells(1)
8542         m1.insertNextCell(NORM_SEG3, mconnec)
8543
8544         myCoords = DataArrayDouble.New(mcoords, 3, 2)
8545         m1.setCoords(myCoords)
8546
8547         m2 = m1.deepCpy()
8548         m2.tessellate2DCurve(0.1)
8549         # If the following raises, the test will fail automatically:
8550         m2.checkCoherency1(0.0) # eps param not used
8551
8552     def testIntersect2DMeshesTmp4(self):
8553         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];
8554         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];
8555         m1=MEDCouplingUMesh.New();
8556         m1.setMeshDimension(2);
8557         m1.allocateCells(8);
8558         m1.insertNextCell(NORM_TRI6,6,m1Conn[0:6]);
8559         m1.insertNextCell(NORM_QUAD8,8,m1Conn[6:14]);
8560         m1.insertNextCell(NORM_TRI6,6,m1Conn[14:20]);
8561         m1.insertNextCell(NORM_QUAD8,8,m1Conn[20:28]);
8562         m1.insertNextCell(NORM_TRI6,6,m1Conn[28:34]);
8563         m1.insertNextCell(NORM_QUAD8,8,m1Conn[34:42]);
8564         m1.insertNextCell(NORM_TRI6,6,m1Conn[42:48]);
8565         m1.insertNextCell(NORM_QUAD8,8,m1Conn[48:56]);
8566         m1.finishInsertingCells();
8567         myCoords1=DataArrayDouble.New();
8568         myCoords1.setValues(m1Coords,25,2);
8569         m1.setCoords(myCoords1);
8570         #
8571         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.]
8572         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]
8573         m2=MEDCouplingUMesh.New();
8574         m2.setMeshDimension(2);
8575         m2.allocateCells(8);
8576         for i in xrange(8):
8577             m2.insertNextCell(NORM_QUAD4,4,m2Conn[4*i:4*(i+1)])
8578             pass
8579         m2.finishInsertingCells();
8580         myCoords2=DataArrayDouble.New();
8581         myCoords2.setValues(m2Coords,15,2);
8582         m2.setCoords(myCoords2);
8583         #
8584         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m2,m1,1e-10)
8585         m3.unPolyze()
8586         #
8587         expected1=[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
8588         expected2=[0,1,1,-1,2,3,3,-1,4,5,5,-1,6,7,7,-1]
8589         self.assertEqual(16,d1.getNumberOfTuples());
8590         self.assertEqual(16,d2.getNumberOfTuples());
8591         self.assertEqual(16,m3.getNumberOfCells());
8592         self.assertEqual(104,m3.getNumberOfNodes());
8593         self.assertEqual(2,m3.getSpaceDimension());
8594         self.assertEqual(expected1,d1.getValues());
8595         self.assertEqual(expected2,d2.getValues());
8596         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]
8597         expected4=[0,7,16,25,34,41,50,59,68,75,84,93,102,109,118,127,136]
8598         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]
8599         self.assertEqual(136,m3.getNodalConnectivity().getNumberOfTuples());
8600         self.assertEqual(17,m3.getNodalConnectivityIndex().getNumberOfTuples());
8601         self.assertEqual(expected3,m3.getNodalConnectivity().getValues());
8602         self.assertEqual(expected4,m3.getNodalConnectivityIndex().getValues());
8603         for i in xrange(208):
8604             self.assertAlmostEqual(expected5[i],m3.getCoords().getIJ(0,i),12);
8605             pass
8606         pass
8607
8608     def testGetCellIdsCrossingPlane1(self):
8609         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
8610         vec=[-0.07,1.,0.07]
8611         origin=[1.524,1.4552,1.74768]
8612         ids1=mesh3D.getCellIdsCrossingPlane(origin,vec,1e-10)
8613         self.assertEqual([1,3,4,7,9,10,13,15,16],ids1.getValues())
8614         vec2=[0.,0.,1.]
8615         ids2=mesh3D.getCellIdsCrossingPlane(origin,vec2,1e-10)
8616         self.assertEqual([6,7,8,9,10,11],ids2.getValues())
8617         pass
8618
8619     def testBuildSlice3D1(self):
8620         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
8621         vec1=[-0.07,1.,0.07]
8622         origin1=[1.524,1.4552,1.74768]
8623         slice1,ids=mesh3D.buildSlice3D(origin1,vec1,1e-10);
8624         expected1=[1,3,4,7,9,10,13,15,16]
8625         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]
8626         expected3=[0,6,11,17,22,27,32,37,42,47]
8627         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.]
8628         self.assertEqual(2,slice1.getMeshDimension());
8629         self.assertEqual(3,slice1.getSpaceDimension());
8630         self.assertEqual(57,slice1.getNumberOfNodes());
8631         self.assertEqual(9,slice1.getNumberOfCells());
8632         self.assertEqual(9,ids.getNumberOfTuples());
8633         self.assertEqual(47,slice1.getNodalConnectivity().getNumberOfTuples());
8634         self.assertEqual(10,slice1.getNodalConnectivityIndex().getNumberOfTuples());
8635         self.assertEqual(expected1,ids.getValues());
8636         self.assertEqual(expected2,slice1.getNodalConnectivity().getValues());
8637         self.assertEqual(expected3,slice1.getNodalConnectivityIndex().getValues());
8638         for i in xrange(171):
8639             self.assertAlmostEqual(expected4[i],slice1.getCoords().getIJ(0,i),12);
8640             pass
8641         # 2nd slice based on already existing nodes of mesh3D.
8642         vec2=[0.,3.,1.]
8643         origin2=[2.5,1.,3.]
8644         slice1,ids=mesh3D.buildSlice3D(origin2,vec2,1e-10);
8645         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]
8646         expected6=[0,5,10,15,21,26,32,38,43,49]
8647         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]
8648         self.assertEqual(2,slice1.getMeshDimension());
8649         self.assertEqual(3,slice1.getSpaceDimension());
8650         self.assertEqual(60,slice1.getNumberOfNodes());
8651         self.assertEqual(9,slice1.getNumberOfCells());
8652         self.assertEqual(9,ids.getNumberOfTuples());
8653         self.assertEqual(49,slice1.getNodalConnectivity().getNumberOfTuples());
8654         self.assertEqual(10,slice1.getNodalConnectivityIndex().getNumberOfTuples());
8655         self.assertEqual(expected1,ids.getValues());
8656         self.assertEqual(expected5,slice1.getNodalConnectivity().getValues());
8657         self.assertEqual(expected6,slice1.getNodalConnectivityIndex().getValues());
8658         for i in xrange(180):
8659             self.assertAlmostEqual(expected7[i],slice1.getCoords().getIJ(0,i),12);
8660             pass
8661         # 3rd slice based on shared face of mesh3D.
8662         vec3=[0.,0.,1.]
8663         origin3=[2.5,1.,2.]
8664         slice1,ids=mesh3D.buildSlice3D(origin3,vec3,1e-10);
8665         expected8=[6,7,8,9,10,11,12,13,14,15,16,17]
8666         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]
8667         expected10=[0,5,12,17,22,29,34,39,46,51,56,63,68]
8668         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.]
8669         self.assertEqual(2,slice1.getMeshDimension());
8670         self.assertEqual(3,slice1.getSpaceDimension());
8671         self.assertEqual(45,slice1.getNumberOfNodes());
8672         self.assertEqual(12,slice1.getNumberOfCells());
8673         self.assertEqual(12,ids.getNumberOfTuples());
8674         self.assertEqual(68,slice1.getNodalConnectivity().getNumberOfTuples());
8675         self.assertEqual(13,slice1.getNodalConnectivityIndex().getNumberOfTuples());
8676         self.assertEqual(expected8,ids.getValues());
8677         self.assertEqual(expected9,slice1.getNodalConnectivity().getValues());
8678         self.assertEqual(expected10,slice1.getNodalConnectivityIndex().getValues());
8679         for i in xrange(135):
8680             self.assertAlmostEqual(expected11[i],slice1.getCoords().getIJ(0,i),12);
8681             pass
8682         pass
8683
8684     def testBuildSlice3DSurf1(self):
8685         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
8686         mesh2D=mesh3D.buildDescendingConnectivity()[0];
8687         vec1=[-0.07,1.,0.07]
8688         origin1=[1.524,1.4552,1.74768]
8689         slice1,ids=mesh2D.buildSlice3DSurf(origin1,vec1,1e-10);
8690         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]
8691         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]
8692         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];
8693         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.]
8694         self.assertEqual(1,slice1.getMeshDimension());
8695         self.assertEqual(3,slice1.getSpaceDimension());
8696         self.assertEqual(57,slice1.getNumberOfNodes());
8697         self.assertEqual(25,slice1.getNumberOfCells());
8698         self.assertEqual(25,ids.getNumberOfTuples());
8699         self.assertEqual(75,slice1.getNodalConnectivity().getNumberOfTuples());
8700         self.assertEqual(26,slice1.getNodalConnectivityIndex().getNumberOfTuples());
8701         self.assertEqual(expected1,ids.getValues());
8702         self.assertEqual(expected2,slice1.getNodalConnectivity().getValues());
8703         self.assertEqual(expected3,slice1.getNodalConnectivityIndex().getValues());
8704         for i in xrange(171):
8705             self.assertAlmostEqual(expected4[i],slice1.getCoords().getIJ(0,i),12);
8706             pass
8707         #
8708         vec2=[0.,0.,1.]
8709         origin2=[2.5,1.,2.]
8710         slice1,ids=mesh2D.buildSlice3DSurf(origin2,vec2,1e-10);
8711         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]
8712         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]
8713         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];
8714         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.]
8715         self.assertEqual(1,slice1.getMeshDimension());
8716         self.assertEqual(3,slice1.getSpaceDimension());
8717         self.assertEqual(45,slice1.getNumberOfNodes());
8718         self.assertEqual(68,slice1.getNumberOfCells());
8719         self.assertEqual(68,ids.getNumberOfTuples());
8720         self.assertEqual(204,slice1.getNodalConnectivity().getNumberOfTuples());
8721         self.assertEqual(69,slice1.getNodalConnectivityIndex().getNumberOfTuples());
8722         self.assertEqual(expected5,ids.getValues());
8723         self.assertEqual(expected6,slice1.getNodalConnectivity().getValues());
8724         self.assertEqual(expected7,slice1.getNodalConnectivityIndex().getValues());
8725         for i in xrange(135):
8726             self.assertAlmostEqual(expected8[i],slice1.getCoords().getIJ(0,i),12);
8727             pass
8728         pass
8729
8730     def testDataArrayDoubleAdvSetting1(self):
8731         data1=[1.,11.,2.,12.,3.,13.,4.,14.,5.,15.,6.,16.,7.,17.]
8732         data2=[8.,38.,9.,39.,0.,30.,11.,41.,12.,42.]
8733         compsCpp=["comp1","comp2"]
8734         da=DataArrayDouble.New();
8735         da.setInfoAndChangeNbOfCompo(compsCpp);
8736         da.setName("da");
8737         da.alloc(7,2);
8738         compsCpp=compsCpp[:-1]
8739         self.assertRaises(InterpKernelException,da.setInfoAndChangeNbOfCompo,compsCpp);
8740         da.setValues(data1,7,2)
8741         #
8742         p=[(0,3),(3,5),(5,7)]
8743         tmp=da.selectByTupleRanges(p);
8744         self.assertTrue(tmp.isEqual(da,1e-14));
8745         p=[(0,2),(3,4),(5,7)]
8746         tmp=da.selectByTupleRanges(p);
8747         expected1=[1.,11.,2.,12.,4.,14.,6.,16.,7.,17.]
8748         self.assertEqual(5,tmp.getNumberOfTuples());
8749         self.assertEqual(2,tmp.getNumberOfComponents());
8750         for i in xrange(10):
8751             self.assertAlmostEqual(expected1[i],tmp.getIJ(0,i),14);
8752             pass
8753         p=[(0,2),(0,2),(5,6)]
8754         tmp=da.selectByTupleRanges(p);
8755         expected2=[1.,11.,2.,12.,1.,11.,2.,12.,6.,16.]
8756         self.assertEqual(5,tmp.getNumberOfTuples());
8757         self.assertEqual(2,tmp.getNumberOfComponents());
8758         for i in xrange(10):
8759             self.assertAlmostEqual(expected2[i],tmp.getIJ(0,i),14);
8760             pass
8761         p=[(0,2),(-1,2),(5,6)]
8762         self.assertRaises(InterpKernelException,da.selectByTupleRanges,p);
8763         p=[(0,2),(0,2),(5,8)]
8764         self.assertRaises(InterpKernelException,da.selectByTupleRanges,p);
8765         #
8766         da2=DataArrayDouble.New();
8767         da2.setValues(data2,5,2);
8768         #
8769         dac=da.deepCpy();
8770         dac.setContigPartOfSelectedValues2(1,da2,2,4,1);
8771         expected3=[1.,11.,0.,30.,11.,41.,4.,14.,5.,15.,6.,16.,7.,17.]
8772         for i in xrange(14):
8773             self.assertAlmostEqual(expected3[i],dac.getIJ(0,i),14);
8774             pass
8775         #
8776         dac=da.deepCpy();
8777         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,3,da2,0,5,1);
8778         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,0,da2,4,6,1);
8779         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,3,da2,5,0,1);
8780         dac.setContigPartOfSelectedValues2(3,da2,1,5,1);
8781         expected4=[1.,11.,2.,12.,3.,13.,9.,39.,0.,30.,11.,41.,12.,42.]
8782         for i in xrange(14):
8783             self.assertAlmostEqual(expected4[i],dac.getIJ(0,i),14);
8784             pass
8785         #
8786         ids=DataArrayInt.New();
8787         ids.alloc(3,1);
8788         dac=da.deepCpy();
8789         ids.setIJ(0,0,2); ids.setIJ(1,0,0); ids.setIJ(2,0,4);
8790         dac.setContigPartOfSelectedValues(2,da2,ids);
8791         expected5=[1.,11.,2.,12.,0.,30.,8.,38.,12.,42.,6.,16.,7.,17.]
8792         for i in xrange(14):
8793             self.assertAlmostEqual(expected5[i],dac.getIJ(0,i),14);
8794             pass
8795         #
8796         dac=da.deepCpy();
8797         ids.setIJ(0,0,2); ids.setIJ(1,0,5); ids.setIJ(2,0,4);
8798         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,1,da2,ids);
8799         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,-1);
8800         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,1,da2,ids);
8801         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,1);
8802         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,5,da2,ids);
8803         #
8804         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,1);
8805         dac=da.deepCpy();
8806         dac.setContigPartOfSelectedValues(4,da2,ids);
8807         expected6=[1.,11.,2.,12.,3.,13.,4.,14.,0.,30.,0.,30.,9.,39.]
8808         for i in xrange(14):
8809             self.assertAlmostEqual(expected6[i],dac.getIJ(0,i),14);
8810             pass
8811         pass
8812
8813     def testDataArrayIntAdvSetting1(self):
8814         data1=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
8815         data2=[8,38,9,39,0,30,11,41,12,42]
8816         compsCpp=["comp1","comp2"]
8817         da=DataArrayInt.New();
8818         da.setInfoAndChangeNbOfCompo(compsCpp);
8819         da.setName("da");
8820         da.alloc(7,2);
8821         compsCpp=compsCpp[:-1]
8822         self.assertRaises(InterpKernelException,da.setInfoAndChangeNbOfCompo,compsCpp);
8823         da.setValues(data1,7,2)
8824         #
8825         p=[(0,3),(3,5),(5,7)]
8826         tmp=da.selectByTupleRanges(p);
8827         self.assertTrue(tmp.isEqual(da));
8828         p=[(0,2),(3,4),(5,7)]
8829         tmp=da.selectByTupleRanges(p);
8830         expected1=[1,11,2,12,4,14,6,16,7,17]
8831         self.assertEqual(5,tmp.getNumberOfTuples());
8832         self.assertEqual(2,tmp.getNumberOfComponents());
8833         for i in xrange(10):
8834             self.assertEqual(expected1[i],tmp.getIJ(0,i));
8835             pass
8836         p=[(0,2),(0,2),(5,6)]
8837         tmp=da.selectByTupleRanges(p);
8838         expected2=[1,11,2,12,1,11,2,12,6,16]
8839         self.assertEqual(5,tmp.getNumberOfTuples());
8840         self.assertEqual(2,tmp.getNumberOfComponents());
8841         for i in xrange(10):
8842             self.assertEqual(expected2[i],tmp.getIJ(0,i));
8843             pass
8844         p=[(0,2),(-1,2),(5,6)]
8845         self.assertRaises(InterpKernelException,da.selectByTupleRanges,p);
8846         p=[(0,2),(0,2),(5,8)]
8847         self.assertRaises(InterpKernelException,da.selectByTupleRanges,p);
8848         #
8849         da2=DataArrayInt.New();
8850         da2.setValues(data2,5,2);
8851         #
8852         dac=da.deepCpy();
8853         dac.setContigPartOfSelectedValues2(1,da2,2,4,1);
8854         expected3=[1,11,0,30,11,41,4,14,5,15,6,16,7,17]
8855         for i in xrange(14):
8856             self.assertEqual(expected3[i],dac.getIJ(0,i));
8857             pass
8858         #
8859         dac=da.deepCpy();
8860         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,3,da2,0,5,1);
8861         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,0,da2,4,6,1);
8862         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,3,da2,5,0,1);
8863         dac.setContigPartOfSelectedValues2(3,da2,1,5,1);
8864         expected4=[1,11,2,12,3,13,9,39,0,30,11,41,12,42]
8865         for i in xrange(14):
8866             self.assertEqual(expected4[i],dac.getIJ(0,i));
8867             pass
8868         #
8869         ids=DataArrayInt.New();
8870         ids.alloc(3,1);
8871         dac=da.deepCpy();
8872         ids.setIJ(0,0,2); ids.setIJ(1,0,0); ids.setIJ(2,0,4);
8873         dac.setContigPartOfSelectedValues(2,da2,ids);
8874         expected5=[1,11,2,12,0,30,8,38,12,42,6,16,7,17]
8875         for i in xrange(14):
8876             self.assertEqual(expected5[i],dac.getIJ(0,i));
8877             pass
8878         #
8879         dac=da.deepCpy();
8880         ids.setIJ(0,0,2); ids.setIJ(1,0,5); ids.setIJ(2,0,4);
8881         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,1,da2,ids);
8882         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,-1);
8883         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,1,da2,ids);
8884         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,1);
8885         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,5,da2,ids);
8886         #
8887         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,1);
8888         dac=da.deepCpy();
8889         dac.setContigPartOfSelectedValues(4,da2,ids);
8890         expected6=[1,11,2,12,3,13,4,14,0,30,0,30,9,39]
8891         for i in xrange(14):
8892             self.assertEqual(expected6[i],dac.getIJ(0,i));
8893             pass
8894         pass
8895
8896     def testBuildDescendingConnec2Of3DMesh1(self):
8897         mesh=MEDCouplingDataForTest.build3DSourceMesh_1();
8898         #
8899         mesh2,desc,descIndx,revDesc,revDescIndx=mesh.buildDescendingConnectivity2();
8900         mesh2.checkCoherency();
8901         self.assertEqual(2,mesh2.getMeshDimension());
8902         self.assertEqual(30,mesh2.getNumberOfCells());
8903         self.assertEqual(31,revDescIndx.getNbOfElems()); self.assertEqual(31,revDescIndx.getNumberOfTuples());
8904         self.assertEqual(13,descIndx.getNbOfElems()); self.assertEqual(13,descIndx.getNumberOfTuples());
8905         self.assertEqual(48,desc.getNbOfElems()); self.assertEqual(48,desc.getNumberOfTuples());
8906         self.assertEqual(48,revDesc.getNbOfElems()); self.assertEqual(48,revDesc.getNumberOfTuples());
8907         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]
8908         self.assertEqual(expected1,desc.getValues());
8909         expected2=[0,4,8,12,16,20,24,28,32,36,40,44,48]
8910         self.assertEqual(expected2,descIndx.getValues());
8911         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]
8912         self.assertEqual(expected3,revDescIndx.getValues());
8913         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]
8914         self.assertEqual(expected4,revDesc.getValues());
8915         conn=mesh2.getNodalConnectivity();
8916         connIndex=mesh2.getNodalConnectivityIndex();
8917         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]
8918         self.assertEqual(expected5,connIndex.getValues());
8919         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]
8920         self.assertEqual(expected6,conn.getValues());
8921         pass
8922
8923     def testAre2DCellsNotCorrectlyOriented1(self):
8924         m1Coords=[1.,1.,-1.,-1.,-1.,-1.,1.,-1.]
8925         m1Conn=[0,3,1,2]
8926         m1=MEDCouplingUMesh.New();
8927         m1.setMeshDimension(2);
8928         m1.allocateCells(1);
8929         m1.insertNextCell(NORM_QUAD4,4,m1Conn[0:4])
8930         m1.finishInsertingCells();
8931         myCoords1=DataArrayDouble.New();
8932         myCoords1.setValues(m1Coords,4,2);
8933         m1.setCoords(myCoords1);
8934         #
8935         vec1=[0.,0.,1.]
8936         for i in xrange(18):
8937             vec2=[3.*cos(pi/9.*i),3.*sin(pi/9.*i)];
8938             m1Cpy=m1.deepCpy();
8939             m1Cpy.translate(vec2);
8940             self.assertRaises(InterpKernelException,m1Cpy.are2DCellsNotCorrectlyOriented,vec1,False);
8941             m1Cpy.changeSpaceDimension(3);
8942             res=m1Cpy.are2DCellsNotCorrectlyOriented(vec1,False)
8943             self.assertEqual([0],res.getValues());
8944             pass
8945         pass
8946
8947     def testDataArrayAbs1(self):
8948         d1=DataArrayDouble.New();
8949         val1=[2.,-3.,-5.,6.,-7.,-8.,9.,10.,-11.,-12.,-13.,-15.]
8950         expected1=[2.,3.,5.,6.,7.,8.,9.,10.,11.,12.,13.,15.]
8951         d1.setValues(val1,6,2);
8952         d2=d1.convertToIntArr();
8953         #
8954         d1.abs();
8955         for i in xrange(12):
8956             self.assertAlmostEqual(expected1[i],d1.getIJ(0,i),14);
8957             pass
8958         #
8959         expected2=[2,3,5,6,7,8,9,10,11,12,13,15]
8960         d2.abs();
8961         for i in xrange(12):
8962             self.assertEqual(expected2[i],d2.getIJ(0,i));
8963             pass
8964         #
8965         pass
8966
8967     # test on 1D
8968     def testGetValueOn3(self):
8969         v=[0.,1.,1.5,2.]
8970         v2=[0.7,1.25,0.,2.,1.5]
8971         disp=[5.,50.,500.,6.,60.,600.,7.,70.,700.,8.,80.,800.]
8972         m=MEDCouplingUMesh.New("myMesh",1)
8973         nbNodes=len(v)
8974         nbCells=nbNodes-1
8975         m.allocateCells(nbCells)
8976         coords=DataArrayDouble.New() ; coords.setValues(v,nbNodes,1)
8977         m.setCoords(coords)
8978         m.insertNextCell(NORM_SEG2,2,[0,1])
8979         m.insertNextCell(NORM_SEG2,2,[2,1])
8980         m.insertNextCell(NORM_SEG2,2,[2,3])
8981         m.finishInsertingCells()
8982         f=MEDCouplingFieldDouble.New(ON_NODES)
8983         f.setMesh(m)
8984         array=DataArrayDouble.New(); array.setValues(disp,m.getNumberOfNodes(),3)
8985         f.setArray(array)
8986         arr1=f.getValueOnMulti(v2)
8987         self.assertEqual(5,arr1.getNumberOfTuples());
8988         self.assertEqual(3,arr1.getNumberOfComponents());
8989         expected1=[5.7,57.,570.,6.5,65.,650.,5.,50.,500.,8.,80.,800.,7.,70.,700.]
8990         for i in xrange(15):
8991             self.assertAlmostEqual(expected1[i],arr1.getIJ(0,i),14);
8992             pass
8993         pass
8994
8995     def testGetNodeIdsOfCell2(self):
8996         m1c=MEDCouplingCMesh.New();
8997         coordsX=DataArrayDouble.New();
8998         arrX=[ -1., 1., 2., 4., 4.5 ]
8999         coordsX.setValues(arrX,5,1);
9000         coordsY=DataArrayDouble.New();
9001         arrY=[ -2., 2., 4., 8.]
9002         coordsY.setValues(arrY,4,1);
9003         coordsZ=DataArrayDouble.New();
9004         arrZ=[ -2., 2., 4.]
9005         coordsZ.setValues(arrZ,3,1);
9006         # test in 1D
9007         m1c.setCoordsAt(0,coordsX);
9008         expected1=[[0,1],[1,2],[2,3],[3,4]]
9009         self.assertEqual(4,m1c.getNumberOfCells())
9010         for i in xrange(m1c.getNumberOfCells()):
9011             self.assertEqual(expected1[i],m1c.getNodeIdsOfCell(i))
9012             pass
9013         # test in 2D
9014         m1c.setCoordsAt(1,coordsY);
9015         self.assertEqual(12,m1c.getNumberOfCells())
9016         self.assertEqual(20,m1c.getNumberOfNodes())
9017         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]]
9018         for i in xrange(m1c.getNumberOfCells()):
9019             self.assertEqual(expected2[i],m1c.getNodeIdsOfCell(i))
9020             pass
9021         # test in 3D
9022         m1c.setCoordsAt(2,coordsZ);
9023         self.assertEqual(24,m1c.getNumberOfCells())
9024         self.assertEqual(60,m1c.getNumberOfNodes())
9025         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]]
9026         self.assertEqual(24,m1c.getNumberOfCells())
9027         for i in xrange(m1c.getNumberOfCells()):
9028             self.assertEqual(expected3[i],m1c.getNodeIdsOfCell(i))
9029             pass
9030         pass
9031
9032     def testSwigDADOp4(self):
9033         da=DataArrayDouble.New(range(6,30),12,2)
9034         self.assertEqual(12,da.getNumberOfTuples());
9035         self.assertEqual(2,da.getNumberOfComponents());
9036         for i in xrange(24):
9037             self.assertAlmostEqual(da.getIJ(0,i),float(i+6),13)
9038             pass
9039         # operator transpose
9040         da.transpose()
9041         self.assertEqual(2,da.getNumberOfTuples());
9042         self.assertEqual(12,da.getNumberOfComponents());
9043         for i in xrange(24):
9044             self.assertAlmostEqual(da.getIJ(0,i),float(i+6),13)
9045             pass
9046         da.transpose()
9047         # operator __neg__
9048         da2=DataArrayDouble.New(12,1)
9049         da2.iota(0.)
9050         dabis=-da
9051         for i in xrange(24):
9052             self.assertAlmostEqual(dabis.getIJ(0,i),-float(i+6),13)
9053             pass
9054         # operator+=
9055         da+=da2
9056         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.]
9057         for i in xrange(24):
9058             self.assertAlmostEqual(da.getIJ(0,i),expected1[i],13)
9059             pass
9060         da=-dabis
9061         da+=[100.,101.]
9062         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.]
9063         self.assertEqual(12,da.getNumberOfTuples());
9064         self.assertEqual(2,da.getNumberOfComponents());
9065         for i in xrange(24):
9066             self.assertAlmostEqual(da.getIJ(0,i),expected2[i],13)
9067             pass
9068         for pos,elt in enumerate(dabis):
9069             da[pos]+=elt
9070             pass
9071         self.assertEqual(12,da.getNumberOfTuples());
9072         self.assertEqual(2,da.getNumberOfComponents());
9073         for elt in da:
9074             li=elt[:]
9075             self.assertAlmostEqual(li[0],100.,13) ; self.assertAlmostEqual(li[1],101.,13)
9076             pass
9077         # operator-=
9078         da=DataArrayDouble.New(range(6,30),12,2)
9079         da2=DataArrayDouble.New(range(12),12,1)
9080         dabis=-da
9081         da-=da2
9082         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.]
9083         for i in xrange(24):
9084             self.assertAlmostEqual(da.getIJ(0,i),expected1[i],13)
9085             pass
9086         da=-dabis
9087         da-=[100.,101.]
9088         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.]
9089         self.assertEqual(12,da.getNumberOfTuples());
9090         self.assertEqual(2,da.getNumberOfComponents());
9091         for i in xrange(24):
9092             self.assertAlmostEqual(da.getIJ(0,i),expected2[i],13)
9093             pass
9094         for pos,elt in enumerate(dabis):
9095             da[pos]-=elt
9096             pass
9097         self.assertEqual(12,da.getNumberOfTuples());
9098         self.assertEqual(2,da.getNumberOfComponents());
9099         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.]
9100         for i in xrange(24):
9101             self.assertAlmostEqual(da.getIJ(0,i),expected3[i],13)
9102             pass
9103         # operator*=
9104         da=DataArrayDouble.New(range(6,30),12,2)
9105         da2=DataArrayDouble.New(range(12),12,1)
9106         dabis=-da
9107         da*=da2
9108         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.]
9109         for i in xrange(24):
9110             self.assertAlmostEqual(da.getIJ(0,i),expected1[i],13)
9111             pass
9112         da=-dabis
9113         da*=[100.,101.]
9114         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.]
9115         self.assertEqual(12,da.getNumberOfTuples());
9116         self.assertEqual(2,da.getNumberOfComponents());
9117         for i in xrange(24):
9118             self.assertAlmostEqual(da.getIJ(0,i),expected2[i],13)
9119             pass
9120         for pos,elt in enumerate(dabis):
9121             da[pos]*=elt
9122             pass
9123         self.assertEqual(12,da.getNumberOfTuples());
9124         self.assertEqual(2,da.getNumberOfComponents());
9125         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]
9126         for i in xrange(24):
9127             self.assertAlmostEqual(da.getIJ(0,i),expected3[i],13)
9128             pass
9129         # operator/=
9130         da=DataArrayDouble.New(range(6,30),12,2)
9131         da2=DataArrayDouble.New(range(1,13),12,1)
9132         dabis=-da
9133         da/=da2
9134         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]
9135         for i in xrange(24):
9136             self.assertAlmostEqual(da.getIJ(0,i),expected1[i],13)
9137             pass
9138         da=-dabis
9139         da/=[100.,101.]
9140         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]
9141         self.assertEqual(12,da.getNumberOfTuples());
9142         self.assertEqual(2,da.getNumberOfComponents());
9143         for i in xrange(24):
9144             self.assertAlmostEqual(da.getIJ(0,i),expected2[i],13)
9145             pass
9146         for pos,elt in enumerate(dabis):
9147             da[pos]/=elt
9148             pass
9149         self.assertEqual(12,da.getNumberOfTuples());
9150         self.assertEqual(2,da.getNumberOfComponents());
9151         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]
9152         for i in xrange(24):
9153             self.assertAlmostEqual(da.getIJ(0,i),expected3[i],13)
9154             pass
9155         pass
9156
9157     def testSwigDAIOp4(self):
9158         da=DataArrayInt.New(range(6,30),12,2)
9159         self.assertEqual(12,da.getNumberOfTuples());
9160         self.assertEqual(2,da.getNumberOfComponents());
9161         for i in xrange(24):
9162             self.assertEqual(da.getIJ(0,i),i+6)
9163             pass
9164         # operator transpose
9165         da.transpose()
9166         self.assertEqual(2,da.getNumberOfTuples());
9167         self.assertEqual(12,da.getNumberOfComponents());
9168         for i in xrange(24):
9169             self.assertEqual(da.getIJ(0,i),i+6)
9170             pass
9171         da.transpose()
9172         # operator __neg__
9173         da2=DataArrayInt.New(12,1)
9174         da2.iota(0)
9175         dabis=-da
9176         for i in xrange(24):
9177             self.assertEqual(dabis.getIJ(0,i),-(i+6))
9178             pass
9179         # operator+=
9180         da+=da2
9181         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]
9182         for i in xrange(24):
9183             self.assertEqual(da.getIJ(0,i),expected1[i])
9184             pass
9185         da=-dabis
9186         da+=[100,101]
9187         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]
9188         self.assertEqual(12,da.getNumberOfTuples());
9189         self.assertEqual(2,da.getNumberOfComponents());
9190         for i in xrange(24):
9191             self.assertEqual(da.getIJ(0,i),expected2[i])
9192             pass
9193         for pos,elt in enumerate(dabis):
9194             da[pos]+=elt
9195             pass
9196         self.assertEqual(12,da.getNumberOfTuples());
9197         self.assertEqual(2,da.getNumberOfComponents());
9198         for elt in da:
9199             li=elt[:]
9200             self.assertEqual(li[0],100) ; self.assertEqual(li[1],101)
9201             pass
9202         # operator-=
9203         da=DataArrayInt.New(range(6,30),12,2)
9204         da2=DataArrayInt.New(range(12),12,1)
9205         dabis=-da
9206         da-=da2
9207         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]
9208         for i in xrange(24):
9209             self.assertEqual(da.getIJ(0,i),expected1[i])
9210             pass
9211         da=-dabis
9212         da-=[100,101]
9213         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]
9214         self.assertEqual(12,da.getNumberOfTuples());
9215         self.assertEqual(2,da.getNumberOfComponents());
9216         for i in xrange(24):
9217             self.assertEqual(da.getIJ(0,i),expected2[i])
9218             pass
9219         for pos,elt in enumerate(dabis):
9220             da[pos]-=elt
9221             pass
9222         self.assertEqual(12,da.getNumberOfTuples());
9223         self.assertEqual(2,da.getNumberOfComponents());
9224         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]
9225         for i in xrange(24):
9226             self.assertEqual(da.getIJ(0,i),expected3[i])
9227             pass
9228         # operator*=
9229         da=DataArrayInt.New(range(6,30),12,2)
9230         da2=DataArrayInt.New(range(12),12,1)
9231         dabis=-da
9232         da*=da2
9233         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]
9234         for i in xrange(24):
9235             self.assertEqual(da.getIJ(0,i),expected1[i])
9236             pass
9237         da=-dabis
9238         da*=[100,101]
9239         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]
9240         self.assertEqual(12,da.getNumberOfTuples());
9241         self.assertEqual(2,da.getNumberOfComponents());
9242         for i in xrange(24):
9243             self.assertEqual(da.getIJ(0,i),expected2[i])
9244             pass
9245         for pos,elt in enumerate(dabis):
9246             da[pos]*=elt
9247             pass
9248         self.assertEqual(12,da.getNumberOfTuples());
9249         self.assertEqual(2,da.getNumberOfComponents());
9250         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]
9251         for i in xrange(24):
9252             self.assertEqual(da.getIJ(0,i),expected3[i])
9253             pass
9254         # operator/=
9255         da=DataArrayInt.New(range(6,30),12,2)
9256         da2=DataArrayInt.New(range(1,13),12,1)
9257         dabis=-da
9258         da/=da2
9259         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]
9260         for i in xrange(24):
9261             self.assertEqual(da.getIJ(0,i),expected1[i])
9262             pass
9263         da=-dabis
9264         da/=DataArrayInt.New([2,3],1,2)
9265         self.assertEqual(12,da.getNumberOfTuples());
9266         self.assertEqual(2,da.getNumberOfComponents());
9267         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]
9268         for i in xrange(24):
9269             self.assertEqual(da.getIJ(0,i),expected2[i])
9270             pass
9271         pass
9272
9273     def testSwigDADOp5(self):
9274         da=DataArrayDouble.New([5,6,7,8,9,6,7,-2,3,9,8,10])
9275         da.rearrange(3)
9276         da2=DataArrayDouble.New([5.,8.,10.,12])
9277         self.assertEqual(4,da2.getNumberOfTuples());
9278         self.assertEqual(1,da2.getNumberOfComponents());
9279         da3=da+da2
9280         self.assertEqual(4,da3.getNumberOfTuples());
9281         self.assertEqual(3,da3.getNumberOfComponents());
9282         expected1=[10.,11.,12.,16.,17.,14.,17.,8.,13.,21.,20.,22.]
9283         for i in xrange(12):
9284             self.assertAlmostEqual(da3.getIJ(0,i),expected1[i],13)
9285             pass
9286         da3=da2+da
9287         self.assertEqual(4,da3.getNumberOfTuples());
9288         self.assertEqual(3,da3.getNumberOfComponents());
9289         for i in xrange(12):
9290             self.assertAlmostEqual(da3.getIJ(0,i),expected1[i],13)
9291             pass
9292         # Test new API of classmethod DataArrayDouble.New
9293         vals=[5,6,7,8,9,6,7,-2,3,9,8,10]
9294         da=DataArrayDouble.New(vals)
9295         self.assertEqual(12,da.getNumberOfTuples());
9296         self.assertEqual(1,da.getNumberOfComponents());
9297         for i in xrange(12):
9298             self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
9299             pass
9300         da=DataArrayDouble.New(vals,12)
9301         self.assertEqual(12,da.getNumberOfTuples());
9302         self.assertEqual(1,da.getNumberOfComponents());
9303         for i in xrange(12):
9304             self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
9305             pass
9306         da=DataArrayDouble.New(vals,1,12)
9307         self.assertEqual(1,da.getNumberOfTuples());
9308         self.assertEqual(12,da.getNumberOfComponents());
9309         for i in xrange(12):
9310             self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
9311             pass
9312         da=DataArrayDouble.New(vals,6,2)
9313         self.assertEqual(6,da.getNumberOfTuples());
9314         self.assertEqual(2,da.getNumberOfComponents());
9315         for i in xrange(12):
9316             self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
9317             pass
9318         da=DataArrayDouble.New(vals,4,3)
9319         self.assertEqual(4,da.getNumberOfTuples());
9320         self.assertEqual(3,da.getNumberOfComponents());
9321         for i in xrange(12):
9322             self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
9323             pass
9324         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,11);
9325         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,13);
9326         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,5,2);
9327         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,7,2);
9328         pass
9329
9330     def testSwigDADOp6(self):
9331         da=DataArrayInt.New([5,6,7,8,9,6,7,-2,3,9,8,10])
9332         da.rearrange(3)
9333         da2=DataArrayInt.New([5,8,10,12])
9334         self.assertEqual(4,da2.getNumberOfTuples());
9335         self.assertEqual(1,da2.getNumberOfComponents());
9336         da3=da+da2
9337         self.assertEqual(4,da3.getNumberOfTuples());
9338         self.assertEqual(3,da3.getNumberOfComponents());
9339         expected1=[10,11,12,16,17,14,17,8,13,21,20,22]
9340         for i in xrange(12):
9341             self.assertEqual(da3.getIJ(0,i),expected1[i])
9342             pass
9343         da3=da2+da
9344         self.assertEqual(4,da3.getNumberOfTuples());
9345         self.assertEqual(3,da3.getNumberOfComponents());
9346         for i in xrange(12):
9347             self.assertEqual(da3.getIJ(0,i),expected1[i])
9348             pass
9349         da3=da+DataArrayInt.New(da2.getValues())
9350         # Test new API of classmethod DataArrayInt.New
9351         vals=[5,6,7,8,9,6,7,-2,3,9,8,10]
9352         da=DataArrayDouble.New(vals)
9353         self.assertEqual(12,da.getNumberOfTuples());
9354         self.assertEqual(1,da.getNumberOfComponents());
9355         for i in xrange(12):
9356             self.assertEqual(da.getIJ(0,i),vals[i])
9357             pass
9358         da=DataArrayDouble.New(vals,12)
9359         self.assertEqual(12,da.getNumberOfTuples());
9360         self.assertEqual(1,da.getNumberOfComponents());
9361         for i in xrange(12):
9362             self.assertEqual(da.getIJ(0,i),vals[i])
9363             pass
9364         da=DataArrayDouble.New(vals,1,12)
9365         self.assertEqual(1,da.getNumberOfTuples());
9366         self.assertEqual(12,da.getNumberOfComponents());
9367         for i in xrange(12):
9368             self.assertEqual(da.getIJ(0,i),vals[i])
9369             pass
9370         da=DataArrayDouble.New(vals,6,2)
9371         self.assertEqual(6,da.getNumberOfTuples());
9372         self.assertEqual(2,da.getNumberOfComponents());
9373         for i in xrange(12):
9374             self.assertEqual(da.getIJ(0,i),vals[i])
9375             pass
9376         da=DataArrayDouble.New(vals,4,3)
9377         self.assertEqual(4,da.getNumberOfTuples());
9378         self.assertEqual(3,da.getNumberOfComponents());
9379         for i in xrange(12):
9380             self.assertEqual(da.getIJ(0,i),vals[i])
9381             pass
9382         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,11);
9383         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,13);
9384         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,5,2);
9385         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,7,2);
9386         pass
9387
9388     def testSwigDADOp9(self):
9389         l1=[(1.,2.,3),(4.,5.,6.),(7.,8.,9.),[10.,11.,12.]]
9390         da1=DataArrayDouble(l1,4,3)
9391         self.assertEqual(4,da1.getNumberOfTuples());
9392         self.assertEqual(3,da1.getNumberOfComponents());
9393         da2=DataArrayDouble(12) ; da2.iota(1.) ; da2.rearrange(3)
9394         self.assertTrue(da2.isEqual(da1,1e-12))
9395         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,3,4);
9396         da3=DataArrayDouble(l1,4)
9397         self.assertTrue(da3.isEqual(da1,1e-12))
9398         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,3);
9399         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,5);
9400         l1=[(1.,2.,3),(4.,(5.),((6.))),(7.,8.,9.),[10.,11.,12.]]
9401         da1=DataArrayDouble(l1,4,3)
9402         self.assertEqual(4,da1.getNumberOfTuples());
9403         self.assertEqual(3,da1.getNumberOfComponents());
9404         da2=DataArrayDouble(12) ; da2.iota(1.) ; da2.rearrange(3)
9405         self.assertTrue(da2.isEqual(da1,1e-12))
9406         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,3,4);
9407         da3=DataArrayDouble(l1,4)
9408         self.assertTrue(da3.isEqual(da1,1e-12))
9409         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,3);
9410         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,5);
9411         #
9412         l1=[(1,2,3),(4,5,6),(7,8,9),[10,11,12]]
9413         da1=DataArrayInt(l1,4,3)
9414         self.assertEqual(4,da1.getNumberOfTuples());
9415         self.assertEqual(3,da1.getNumberOfComponents());
9416         da2=DataArrayInt(12) ; da2.iota(1) ; da2.rearrange(3)
9417         self.assertTrue(da2.isEqual(da1))
9418         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,3,4);
9419         da3=DataArrayInt(l1,4)
9420         self.assertTrue(da3.isEqual(da1))
9421         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,3);
9422         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,5);
9423         l1=[(1,[2],3),(4,[(5)],6),((([7])),8,9),[10,11,12]]
9424         da1=DataArrayInt(l1,4,3)
9425         self.assertEqual(4,da1.getNumberOfTuples());
9426         self.assertEqual(3,da1.getNumberOfComponents());
9427         da2=DataArrayInt(12) ; da2.iota(1) ; da2.rearrange(3)
9428         self.assertTrue(da2.isEqual(da1))
9429         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,3,4);
9430         da3=DataArrayInt(l1,4)
9431         self.assertTrue(da3.isEqual(da1))
9432         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,3);
9433         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,5);
9434         pass
9435
9436     def testRenumberNodesInConn1(self):
9437         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. ]
9438         mesh2DConn=[1,4,2, 4,5,2, 0,3,4,1, 6,7,4,3, 7,8,5,4]
9439         mesh2D=MEDCouplingUMesh.New("mesh",2);
9440         mesh2D.allocateCells(5);
9441         mesh2D.insertNextCell(NORM_TRI3,3,mesh2DConn[0:3])
9442         mesh2D.insertNextCell(NORM_TRI3,3,mesh2DConn[3:6])
9443         mesh2D.insertNextCell(NORM_QUAD4,4,mesh2DConn[6:10])
9444         mesh2D.insertNextCell(NORM_QUAD4,4,mesh2DConn[10:14])
9445         mesh2D.insertNextCell(NORM_QUAD4,4,mesh2DConn[14:18])
9446         mesh2D.finishInsertingCells();
9447         myCoords=DataArrayDouble.New(mesh2DCoords,9,3);
9448         mesh2D.setCoords(myCoords);
9449         mesh2D.checkCoherency();
9450         #
9451         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. ]
9452         mesh3DConn=[0,1,2,3,4,5,6,7]
9453         mesh3D=MEDCouplingUMesh.New("mesh",3);
9454         mesh3D.allocateCells(1);
9455         mesh3D.insertNextCell(NORM_HEXA8,8,mesh3DConn[:])
9456         mesh3D.finishInsertingCells();
9457         myCoords3D=DataArrayDouble.New(mesh3DCoords,8,3);
9458         mesh3D.setCoords(myCoords3D);
9459         mesh3D.checkCoherency();
9460         #
9461         mesh3D_2=mesh3D.deepCpy();
9462         mesh2D_2=mesh2D.deepCpy();
9463         mesh3D_4=mesh3D.deepCpy();
9464         mesh2D_4=mesh2D.deepCpy();
9465         oldNbOf3DNodes=mesh3D.getNumberOfNodes();
9466         renumNodes=DataArrayInt.New();
9467         renumNodes.alloc(mesh2D.getNumberOfNodes(),1);
9468         renumNodes.iota(oldNbOf3DNodes);
9469         coo=DataArrayDouble.Aggregate(mesh3D.getCoords(),mesh2D.getCoords());
9470         mesh3D.setCoords(coo);
9471         mesh2D.setCoords(coo);
9472         mesh2DCpy=mesh2D.deepCpy()
9473         mesh2D_3=mesh2D.deepCpy();
9474         mesh2D_3.shiftNodeNumbersInConn(oldNbOf3DNodes);
9475         mesh2D.renumberNodesInConn(renumNodes);
9476         mesh2DCpy.renumberNodesInConn(renumNodes.getValues());
9477         self.assertTrue(mesh2D.isEqual(mesh2DCpy,1e-12))
9478         self.assertTrue(mesh2D.isEqual(mesh2D_3,1e-12))
9479         #
9480         da1,da2=mesh3D.checkGeoEquivalWith(mesh3D_2,10,1e-12);
9481         self.assertTrue(da1==None);
9482         self.assertEqual(8,da2.getNumberOfTuples());
9483         self.assertEqual(1,da2.getNumberOfComponents());
9484         expected1=[8,11,12,9,4,5,6,7]
9485         for i in xrange(8):
9486             self.assertEqual(expected1[i],da2.getIJ(i,0));
9487             pass
9488         #
9489         da1,da2=mesh2D.checkGeoEquivalWith(mesh2D_2,10,1e-12);
9490         self.assertTrue(da1==None);
9491         self.assertEqual(9,da2.getNumberOfTuples());
9492         self.assertEqual(1,da2.getNumberOfComponents());
9493         for i in xrange(9):
9494             self.assertEqual(8+i,da2.getIJ(i,0));
9495             pass
9496         #
9497         mesh2D_5=mesh2D_4.deepCpy();
9498         mesh2D_5.translate([1.,0.,0.]);
9499         meshes=[mesh3D_4,mesh2D_4,mesh2D_5];
9500         MEDCouplingUMesh.PutUMeshesOnSameAggregatedCoords(meshes);
9501         self.assertTrue(mesh3D_4.getCoords().getHiddenCppPointer()==mesh2D_4.getCoords().getHiddenCppPointer());
9502         self.assertTrue(mesh2D_4.getCoords().getHiddenCppPointer()==mesh2D_5.getCoords().getHiddenCppPointer());
9503         mesh3D_4.checkCoherency(); mesh2D_4.checkCoherency(); mesh2D_5.checkCoherency();
9504         self.assertEqual(26,mesh3D_4.getNumberOfNodes());
9505         self.assertEqual(3,mesh3D_4.getSpaceDimension());
9506         self.assertEqual(9,mesh3D_4.getNodalConnectivity().getNumberOfTuples());
9507         self.assertEqual(23,mesh2D_4.getNodalConnectivity().getNumberOfTuples());
9508         self.assertEqual(23,mesh2D_5.getNodalConnectivity().getNumberOfTuples());
9509         expected2=[18,0,1,2,3,4,5,6,7]
9510         expected3=[3,9,12,10, 3,12,13,10, 4,8,11,12,9, 4,14,15,12,11, 4,15,16,13,12]
9511         expected4=[3,18,21,19, 3,21,22,19, 4,17,20,21,18, 4,23,24,21,20, 4,24,25,22,21]
9512         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]
9513         self.assertEqual(expected2,mesh3D_4.getNodalConnectivity().getValues());
9514         self.assertEqual(expected3,mesh2D_4.getNodalConnectivity().getValues());
9515         self.assertEqual(expected4,mesh2D_5.getNodalConnectivity().getValues());
9516         for i in xrange(78):
9517             self.assertAlmostEqual(expected5[i],mesh3D_4.getCoords().getIJ(0,i),12);
9518             pass
9519         #
9520         MEDCouplingUMesh.MergeNodesOnUMeshesSharingSameCoords(meshes,1e-12);
9521         mesh3D_4.checkCoherency(); mesh2D_4.checkCoherency(); mesh2D_5.checkCoherency();
9522         self.assertTrue(mesh3D_4.getCoords().getHiddenCppPointer()==mesh2D_4.getCoords().getHiddenCppPointer());
9523         self.assertTrue(mesh2D_4.getCoords().getHiddenCppPointer()==mesh2D_5.getCoords().getHiddenCppPointer());
9524         self.assertEqual(19,mesh3D_4.getNumberOfNodes());
9525         self.assertEqual(3,mesh3D_4.getSpaceDimension());
9526         self.assertEqual(9,mesh3D_4.getNodalConnectivity().getNumberOfTuples());
9527         self.assertEqual(23,mesh2D_4.getNodalConnectivity().getNumberOfTuples());
9528         self.assertEqual(23,mesh2D_5.getNodalConnectivity().getNumberOfTuples());
9529         expected6=[18,0,1,2,3,4,5,6,7]
9530         expected7=[3,3,2,8, 3,2,9,8, 4,0,1,2,3, 4,10,11,2,1, 4,11,12,9,2]
9531         expected8=[3,13,15,14, 3,15,16,14, 4,8,9,15,13, 4,12,17,15,9, 4,17,18,16,15]
9532         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.,
9533                     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.,
9534                     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.]
9535         self.assertEqual(expected6,mesh3D_4.getNodalConnectivity().getValues());
9536         self.assertEqual(expected7,mesh2D_4.getNodalConnectivity().getValues());
9537         self.assertEqual(expected8,mesh2D_5.getNodalConnectivity().getValues());
9538         for i in xrange(57):
9539             self.assertAlmostEqual(expected9[i],mesh3D_4.getCoords().getIJ(0,i),12);
9540             pass
9541         #
9542         pass
9543
9544     def testComputeNeighborsOfCells1(self):
9545         m=MEDCouplingDataForTest.build2DTargetMesh_1();
9546         d1,d2=m.computeNeighborsOfCells();
9547         self.assertEqual(6,d2.getNumberOfTuples());
9548         self.assertEqual(10,d1.getNumberOfTuples());
9549         expected1=[0,2,4,6,8,10]
9550         expected2=[3,1,0,2,4,1,4,0,2,3]
9551         self.assertEqual(expected1,d2.getValues());
9552         self.assertEqual(expected2,d1.getValues());
9553         pass
9554
9555     def testCheckButterflyCellsBug1(self):
9556         mesh2DCoords=[323.85,120.983748908684,317.5,131.982271536747,336.55,120.983748908686,330.2,131.982271536751,323.85,142.98079416481]
9557         mesh2DConn=[4,1,0,2,3]
9558         mesh2D=MEDCouplingUMesh.New("mesh",2);
9559         mesh2D.allocateCells(1);
9560         mesh2D.insertNextCell(NORM_POLYGON,5,mesh2DConn[0:5])
9561         mesh2D.finishInsertingCells();
9562         myCoords=DataArrayDouble.New(mesh2DCoords,5,2);
9563         mesh2D.setCoords(myCoords);
9564         mesh2D.checkCoherency();
9565         #
9566         v=mesh2D.checkButterflyCells();
9567         self.assertTrue(v.empty());
9568         pass
9569
9570     def testDataArrayIntRange1(self):
9571         d=DataArrayInt.Range(2,17,7);
9572         expected1=[2,9,16]
9573         self.assertEqual(3,d.getNumberOfTuples());
9574         self.assertEqual(1,d.getNumberOfComponents());
9575         self.assertEqual(expected1,d.getValues());
9576         #
9577         d=DataArrayInt.Range(2,23,7);
9578         self.assertEqual(3,d.getNumberOfTuples());
9579         self.assertEqual(1,d.getNumberOfComponents());
9580         self.assertEqual(expected1,d.getValues());
9581         #
9582         d=DataArrayInt.Range(2,24,7);
9583         expected2=[2,9,16,23]
9584         self.assertEqual(4,d.getNumberOfTuples());
9585         self.assertEqual(1,d.getNumberOfComponents());
9586         self.assertEqual(expected2,d.getValues());
9587         #
9588         d=DataArrayInt.Range(24,2,-7);
9589         expected3=[24,17,10,3]
9590         self.assertEqual(4,d.getNumberOfTuples());
9591         self.assertEqual(1,d.getNumberOfComponents());
9592         self.assertEqual(expected3,d.getValues());
9593         #
9594         d=DataArrayInt.Range(23,2,-7);
9595         expected4=[23,16,9]
9596         self.assertEqual(3,d.getNumberOfTuples());
9597         self.assertEqual(1,d.getNumberOfComponents());
9598         self.assertEqual(expected4,d.getValues());
9599         #
9600         d=DataArrayInt.Range(23,22,-7);
9601         self.assertEqual(1,d.getNumberOfTuples());
9602         self.assertEqual(1,d.getNumberOfComponents());
9603         self.assertEqual(23,d.getIJ(0,0));
9604         #
9605         d=DataArrayInt.Range(22,23,7);
9606         self.assertEqual(1,d.getNumberOfTuples());
9607         self.assertEqual(1,d.getNumberOfComponents());
9608         self.assertEqual(22,d.getIJ(0,0));
9609         #
9610         d=DataArrayInt.Range(22,22,7);
9611         self.assertEqual(0,d.getNumberOfTuples());
9612         self.assertEqual(1,d.getNumberOfComponents());
9613         #
9614         d=DataArrayInt.Range(22,22,-7);
9615         self.assertEqual(0,d.getNumberOfTuples());
9616         self.assertEqual(1,d.getNumberOfComponents());
9617         #
9618         self.assertRaises(InterpKernelException,DataArrayInt.Range,22,23,-7);
9619         self.assertRaises(InterpKernelException,DataArrayInt.Range,23,22,7);
9620         self.assertRaises(InterpKernelException,DataArrayInt.Range,23,22,0);
9621         self.assertRaises(InterpKernelException,DataArrayInt.Range,22,23,0);
9622         pass
9623
9624     def testSwigUMeshGetItem1(self):
9625         m=MEDCouplingDataForTest.build2DTargetMesh_1();
9626         subMesh=m.buildPartOfMySelf([1,3],True);
9627         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
9628         m1=m[[1,3]]
9629         self.assertTrue(isinstance(m1,MEDCouplingUMesh))
9630         m2=m[(1,3)]
9631         self.assertTrue(isinstance(m2,MEDCouplingUMesh))
9632         m3=m[1::2]
9633         self.assertTrue(isinstance(m3,MEDCouplingUMesh))
9634         m4=m[DataArrayInt.New([1,3])]
9635         m5_1=m[1]
9636         self.assertTrue(isinstance(m5_1,MEDCouplingUMesh))
9637         m5_2=m[3]
9638         self.assertTrue(isinstance(m5_2,MEDCouplingUMesh))
9639         m5=MEDCouplingUMesh.MergeUMeshesOnSameCoords([m5_1,m5_2]);
9640         m5.setName(subMesh.getName())
9641         self.assertTrue(isinstance(m4,MEDCouplingUMesh))
9642         self.assertTrue(subMesh.isEqual(m1,1e-12))
9643         self.assertTrue(subMesh.isEqual(m2,1e-12))
9644         self.assertTrue(subMesh.isEqual(m3,1e-12))
9645         self.assertTrue(subMesh.isEqual(m4,1e-12))
9646         self.assertTrue(subMesh.isEqual(m5,1e-12))
9647         self.assertRaises(InterpKernelException,m.buildPartOfMySelf,[1,5],True);
9648         pass
9649
9650     def testSwigGetItem3(self):
9651         da=DataArrayInt.New([4,5,6])
9652         self.assertEqual(5,da[1])
9653         self.assertEqual(6,da[-1])
9654         self.assertRaises(InterpKernelException,da.__getitem__,3)
9655         da=DataArrayInt.New([4,5,6,7,8,9],2,3)
9656         self.assertEqual(9,da[1,2])
9657         da=DataArrayDouble.New([4.1,5.2,6.3])
9658         self.assertAlmostEqual(5.2,da[1],12)
9659         self.assertAlmostEqual(6.3,da[-1],12)
9660         self.assertRaises(InterpKernelException,da.__getitem__,3)
9661         da=DataArrayDouble.New([4.12,5.12,6.12,7.12,8.12,9.12],2,3)
9662         self.assertAlmostEqual(9.12,da[1,2],12)
9663         pass
9664
9665     def testSwigDADISub1(self):
9666         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
9667         bary=mesh3D.getBarycenterAndOwner()
9668         bary=bary[:,:2]
9669         pts=bary.getDifferentValues(1e-12)
9670         expected=[[0,6,12],[1,7,13],[2,8,14],[3,9,15],[4,10,16],[5,11,17]]
9671         for pos,pt in enumerate(pts):
9672             bary2=bary[:,:2]
9673             bary2[:]-=pt
9674             norm=bary2.magnitude()
9675             self.assertEqual(expected[pos],norm.getIdsInRange(-1.,1e-5).getValues())
9676             pass
9677         expected2=[[3.,54.],[-141.,180.],[21.,54.],[39.,72.],[-15.,90.],[21.,90.]]
9678         for pos,pt in enumerate(pts):
9679             bary2=bary[:,:2]
9680             bary2[:]+=pt
9681             self.assertAlmostEqual(expected2[pos][0],bary2.accumulate()[0],12);
9682             self.assertAlmostEqual(expected2[pos][1],bary2.accumulate()[1],12);
9683             pass
9684         expected3=[[-3.,22.5],[45.,337.5],[-9., 22.5],[-15.,67.5],[3.,112.5],[-9.,112.5]]
9685         for pos,pt in enumerate(pts):
9686             bary2=bary[:,:2]
9687             bary2[:]*=pt
9688             self.assertAlmostEqual(expected3[pos][0],bary2.accumulate()[0],12);
9689             self.assertAlmostEqual(expected3[pos][1],bary2.accumulate()[1],12);
9690             pass
9691         expected4=[[-12.,90.],[0.8,6.],[-4,90.],[-2.4,30.],[12.,18],[-4,18.]]
9692         for pos,pt in enumerate(pts):
9693             bary2=bary[:,:2]
9694             bary2[:]/=pt
9695             self.assertAlmostEqual(expected4[pos][0],bary2.accumulate()[0],12);
9696             self.assertAlmostEqual(expected4[pos][1],bary2.accumulate()[1],12);
9697             pass
9698         #
9699         d=DataArrayInt.New([1,2,0,1,0,2],3,2)
9700         e=DataArrayInt.New([1,11,101,2,12,102,3,13,103,4,14,104],4,3)
9701         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]]
9702         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]]
9703         for pos,tup in enumerate(d):
9704             f=e[:]
9705             self.assertTrue(isinstance(f,DataArrayInt))
9706             f[tup]=77
9707             self.assertEqual(expected5[pos],f.getValues())
9708             self.assertEqual(6*[77],f[tup].getValues())
9709             f=e[:]
9710             f[:,tup]=77
9711             self.assertEqual(expected6[pos],f.getValues())
9712             self.assertEqual(8*[77],f[:,tup].getValues())
9713             pass
9714         #
9715         e=e.convertToDblArr()
9716         for pos,tup in enumerate(d):
9717             f=e[:]
9718             self.assertTrue(isinstance(f,DataArrayDouble))
9719             f[tup]=77.
9720             self.assertEqual(expected5[pos],f.convertToIntArr().getValues())
9721             self.assertEqual(6*[77],f[tup].convertToIntArr().getValues())
9722             f=e[:]
9723             f[:,tup]=77.
9724             self.assertEqual(expected6[pos],f.convertToIntArr().getValues())
9725             self.assertEqual(8*[77],f[:,tup].convertToIntArr().getValues())
9726             pass
9727         pass
9728
9729     def testDataArrayDoubleGetMinMaxPerComponent1(self):
9730         values1=[1.,2.,3.,-0.9,2.1,3.,1.3,1.7,3.,1.,1.8,3.]
9731         d1=DataArrayDouble.New();
9732         self.assertRaises(InterpKernelException,d1.getMinMaxPerComponent)
9733         d1=DataArrayDouble.New(values1,4,3);
9734         res=d1.getMinMaxPerComponent();
9735         self.assertTrue(isinstance(res,list))
9736         self.assertEqual(3,len(res))
9737         for i in xrange(3):
9738             self.assertTrue(isinstance(res[i],tuple))
9739             self.assertEqual(2,len(res[i]))
9740             pass
9741         expected1=[-0.9,1.3,1.7,2.1,3.,3.]
9742         for i in xrange(6):
9743             self.assertAlmostEqual(expected1[i],res[i/2][i%2],14)
9744             pass
9745         #
9746         d1.rearrange(2);
9747         res=d1.getMinMaxPerComponent();
9748         self.assertTrue(isinstance(res,list))
9749         self.assertEqual(2,len(res))
9750         for i in xrange(2):
9751             self.assertTrue(isinstance(res[i],tuple))
9752             self.assertEqual(2,len(res[i]))
9753             pass
9754         expected2=[1.,3.,-0.9,3.]
9755         for i in xrange(4):
9756             self.assertAlmostEqual(expected2[i],res[i/2][i%2],14)
9757             pass
9758         #
9759         d1.rearrange(1);
9760         res=d1.getMinMaxPerComponent();
9761         self.assertTrue(isinstance(res,list))
9762         self.assertEqual(1,len(res))
9763         for i in xrange(1):
9764             self.assertTrue(isinstance(res[i],tuple))
9765             self.assertEqual(2,len(res[i]))
9766             pass
9767         expected3=[-0.9,3.]
9768         for i in xrange(2):
9769             self.assertAlmostEqual(expected3[i],res[i/2][i%2],14)
9770             pass
9771         pass
9772
9773     def testDataArrayIntGetHashCode1(self):
9774         d1=DataArrayInt.New(range(3545))
9775         d2=DataArrayInt.New(range(3545))
9776         self.assertEqual(d2.getHashCode(),d1.getHashCode())
9777         self.assertEqual(232341068,d1.getHashCode())
9778         d1[886]=6
9779         self.assertEqual(232340188,d1.getHashCode())
9780         pass
9781
9782     def testZipConnectivityPol1(self):
9783         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
9784         cells1=[2,3,4]
9785         m2_1=m1.buildPartOfMySelf(cells1,True);
9786         m2=m2_1
9787         self.assertTrue(isinstance(m2,MEDCouplingUMesh))
9788         # no permutation policy 0
9789         isOk,arr=m1.areCellsIncludedIn(m2,0)
9790         self.assertTrue(isOk);
9791         self.assertEqual(3,arr.getNumberOfTuples());
9792         self.assertEqual(1,arr.getNumberOfComponents());
9793         self.assertEqual(cells1,arr.getValues())
9794         # no permutation policy 1
9795         isOk,arr=m1.areCellsIncludedIn(m2,1)
9796         self.assertTrue(isOk);
9797         self.assertEqual(3,arr.getNumberOfTuples());
9798         self.assertEqual(1,arr.getNumberOfComponents());
9799         self.assertEqual(cells1,arr.getValues())
9800         # no permutation policy 2
9801         isOk,arr=m1.areCellsIncludedIn(m2,2)
9802         self.assertTrue(isOk);
9803         self.assertEqual(3,arr.getNumberOfTuples());
9804         self.assertEqual(1,arr.getNumberOfComponents());
9805         self.assertEqual(cells1,arr.getValues())
9806         # some modification into m2
9807         modif1=[2,4,5]
9808         m2.getNodalConnectivity()[1:4]=modif1
9809         #policy 0 fails because cell0 in m2 has same orientation be not same connectivity
9810         expected1=[5,3,4]
9811         isOk,arr=m1.areCellsIncludedIn(m2,0)
9812         self.assertTrue(not isOk);
9813         self.assertEqual(3,arr.getNumberOfTuples());
9814         self.assertEqual(1,arr.getNumberOfComponents());
9815         self.assertEqual(expected1,arr.getValues())
9816         #policy 1 succeeds because cell0 in m2 has not exactly the same conn
9817         isOk,arr=m1.areCellsIncludedIn(m2,1)
9818         self.assertTrue(isOk);
9819         self.assertEqual(3,arr.getNumberOfTuples());
9820         self.assertEqual(1,arr.getNumberOfComponents());
9821         self.assertEqual(cells1,arr.getValues())
9822         #policy 2 succeeds because cell0 in m2 has same nodes in connectivity
9823         isOk,arr=m1.areCellsIncludedIn(m2,2)
9824         self.assertTrue(isOk);
9825         self.assertEqual(3,arr.getNumberOfTuples());
9826         self.assertEqual(1,arr.getNumberOfComponents());
9827         self.assertEqual(cells1,arr.getValues())
9828         #some new modification into m2
9829         modif2=[2,5,4]
9830         m2.getNodalConnectivity()[1:4]=modif2
9831         #policy 0 fails because cell0 in m2 has not exactly the same conn
9832         isOk,arr=m1.areCellsIncludedIn(m2,0)
9833         self.assertTrue(not isOk);
9834         self.assertEqual(3,arr.getNumberOfTuples());
9835         self.assertEqual(1,arr.getNumberOfComponents());
9836         self.assertEqual(expected1,arr.getValues())
9837         #policy 1 fails too because cell0 in m2 has not same orientation
9838         isOk,arr=m1.areCellsIncludedIn(m2,1)
9839         self.assertTrue(not isOk);
9840         self.assertEqual(3,arr.getNumberOfTuples());
9841         self.assertEqual(1,arr.getNumberOfComponents());
9842         self.assertEqual(expected1,arr.getValues())
9843         #policy 2 succeeds because cell0 in m2 has same nodes in connectivity
9844         isOk,arr=m1.areCellsIncludedIn(m2,2)
9845         self.assertTrue(isOk);
9846         self.assertEqual(3,arr.getNumberOfTuples());
9847         self.assertEqual(1,arr.getNumberOfComponents());
9848         self.assertEqual(cells1,arr.getValues())
9849         # Now 1D
9850         cells2=[3,2]
9851         m1=MEDCouplingDataForTest.build1DSourceMesh_2();
9852         m2_1=m1.buildPartOfMySelf(cells2,True);
9853         m2=m2_1
9854         self.assertTrue(isinstance(m2,MEDCouplingUMesh))
9855         # no permutation policy 0
9856         isOk,arr=m1.areCellsIncludedIn(m2,0)
9857         self.assertTrue(isOk);
9858         self.assertEqual(2,arr.getNumberOfTuples());
9859         self.assertEqual(1,arr.getNumberOfComponents());
9860         self.assertEqual(cells2,arr.getValues())
9861         # no permutation policy 1
9862         isOk,arr=m1.areCellsIncludedIn(m2,1)
9863         self.assertTrue(isOk);
9864         self.assertEqual(2,arr.getNumberOfTuples());
9865         self.assertEqual(1,arr.getNumberOfComponents());
9866         self.assertEqual(cells2,arr.getValues())
9867         # no permutation policy 2
9868         isOk,arr=m1.areCellsIncludedIn(m2,2)
9869         self.assertTrue(isOk);
9870         self.assertEqual(2,arr.getNumberOfTuples());
9871         self.assertEqual(1,arr.getNumberOfComponents());
9872         self.assertEqual(cells2,arr.getValues())
9873         # some modification into m2
9874         modif3=[4,3]
9875         m2.getNodalConnectivity()[1:3]=modif3
9876         #policy 0 fails because cell0 in m2 has not exactly the same conn
9877         expected2=[4,2]
9878         isOk,arr=m1.areCellsIncludedIn(m2,0)
9879         self.assertTrue(not isOk);
9880         self.assertEqual(2,arr.getNumberOfTuples());
9881         self.assertEqual(1,arr.getNumberOfComponents());
9882         self.assertEqual(expected2,arr.getValues())
9883         #policy 1 fails too because cell0 in m2 has not same orientation
9884         isOk,arr=m1.areCellsIncludedIn(m2,1)
9885         self.assertTrue(not isOk);
9886         self.assertEqual(2,arr.getNumberOfTuples());
9887         self.assertEqual(1,arr.getNumberOfComponents());
9888         self.assertEqual(expected2,arr.getValues())
9889         #policy 2 succeeds because cell0 in m2 has same nodes in connectivity
9890         isOk,arr=m1.areCellsIncludedIn(m2,2)
9891         self.assertTrue(isOk);
9892         self.assertEqual(2,arr.getNumberOfTuples());
9893         self.assertEqual(1,arr.getNumberOfComponents());
9894         self.assertEqual(cells2,arr.getValues())
9895         pass
9896
9897     def toSeeIfDaIIopsAreOK(self,d):
9898         d+=5
9899         d*=6
9900         d/=3
9901         d-=2
9902         d%=7
9903         pass
9904
9905     def testSwigDAIOp5(self):
9906         d=DataArrayInt.New([4,5,6,10,3,-1],2,3)
9907         self.toSeeIfDaIIopsAreOK(d)
9908         dExp=DataArrayInt.New([2,4,6,0,0,6],2,3)
9909         self.assertTrue(d.isEqual(dExp));
9910         pass
9911
9912     def toSeeIfDaDIopsAreOK(self,d):
9913         d+=5
9914         d*=6
9915         d/=3
9916         d-=2
9917         pass
9918
9919     def testSwigDADOp7(self):
9920         d=DataArrayDouble.New([4.,5.,6.,10.,3.,-1.],2,3)
9921         self.toSeeIfDaDIopsAreOK(d)
9922         dExp=DataArrayDouble.New([16.,18.,20.,28.,14.,6.],2,3)
9923         self.assertTrue(d.isEqual(dExp,1e-14));
9924         pass
9925
9926     def testConvexEnvelop2D1(self):
9927         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]
9928         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]
9929         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]
9930         #
9931         m=MEDCouplingUMesh.New("convexhull",2);
9932         m.allocateCells(331);
9933         for i in xrange(331):
9934             m.insertNextCell(NORM_POLYGON,conn[connI[i]:connI[i+1]]);
9935             pass
9936         m.finishInsertingCells();
9937         coordsDa=DataArrayDouble.New(coords,331,2);
9938         m.setCoords(coordsDa);
9939         m.checkCoherency();
9940         #
9941         da=m.convexEnvelop2D();
9942         m.checkCoherency()
9943         self.assertEqual(coordsDa.getHiddenCppPointer(),m.getCoords().getHiddenCppPointer())
9944         daC=da.buildComplement(m.getNumberOfCells());
9945         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]);
9946         self.assertTrue(expected2.isEqual(daC));
9947         #
9948         vals=m.getMeasureField(ON_CELLS).getArray()
9949         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]
9950         vals-=DataArrayDouble.New(ref)
9951         vals.abs()
9952         theTest=vals.getIdsInRange(-1.,1e-7)
9953         self.assertTrue(theTest.isIdentity())
9954         self.assertEqual(331,len(theTest))
9955         pass
9956
9957     def testSwigDAIOp8(self):
9958         da=DataArrayInt.New([7,5,6,7,8,9,9,10,12,13,47,15])
9959         self.assertTrue(7 in da)
9960         self.assertTrue(47 in da)
9961         self.assertTrue(15 in da)
9962         self.assertEqual(0,da.index(7))
9963         self.assertEqual(10,da.index(47))
9964         self.assertTrue(14 not in da)
9965         self.assertEqual(5,da.search([9,9]))
9966         self.assertEqual(-1,da.search([5,8]))
9967         da.rearrange(2)
9968         self.assertTrue([47,16] not in da)
9969         self.assertTrue([5,6] not in da)
9970         self.assertTrue([6,7] in da)
9971         self.assertEqual(4,da.index([12,13]))
9972         pass
9973
9974     def testDataArraySort1(self):
9975         arr=DataArrayInt.New();
9976         self.assertRaises(InterpKernelException,arr.sort,True)
9977         self.assertRaises(InterpKernelException,arr.sort,False)
9978         values=[2,1,6,5,4,7]
9979         arr.alloc(3,2);
9980         self.assertRaises(InterpKernelException,arr.sort,True)
9981         self.assertRaises(InterpKernelException,arr.sort,False)
9982         arr.rearrange(1);
9983         arr.setValues(values,6,1)
9984         arr1=arr.deepCpy();
9985         arr2=arr.deepCpy();
9986         arr1.sort(True);
9987         expected1=[1,2,4,5,6,7]
9988         self.assertEqual(6,arr1.getNumberOfTuples());
9989         self.assertEqual(1,arr1.getNumberOfComponents());
9990         self.assertEqual(expected1,arr1.getValues());
9991         arr2.sort(False);
9992         expected2=[7,6,5,4,2,1]
9993         self.assertEqual(6,arr2.getNumberOfTuples());
9994         self.assertEqual(1,arr2.getNumberOfComponents());
9995         self.assertTrue(expected2,arr2.getValues());
9996         #
9997         ard=DataArrayDouble.New();
9998         self.assertRaises(InterpKernelException,ard.sort,True)
9999         self.assertRaises(InterpKernelException,ard.sort,False)
10000         valuesD=[2.,1.,6.,5.,4.,7.]
10001         ard.alloc(3,2);
10002         self.assertRaises(InterpKernelException,ard.sort,True)
10003         self.assertRaises(InterpKernelException,ard.sort,False)
10004         ard.rearrange(1);
10005         ard.setValues(valuesD,6,1)
10006         ard1=ard.deepCpy();
10007         ard2=ard.deepCpy();
10008         ard1.sort(True);
10009         expected3=[1.,2.,4.,5.,6.,7.]
10010         self.assertEqual(6,ard1.getNumberOfTuples());
10011         self.assertEqual(1,ard1.getNumberOfComponents());
10012         for i in xrange(6):
10013             self.assertAlmostEqual(expected3[i],ard1.getIJ(i,0),12)
10014             pass
10015         ard2.sort(False);
10016         expected4=[7.,6.,5.,4.,2.,1.]
10017         self.assertEqual(6,ard2.getNumberOfTuples());
10018         self.assertEqual(1,ard2.getNumberOfComponents());
10019         for i in xrange(6):
10020             self.assertAlmostEqual(expected4[i],ard2.getIJ(i,0),12)
10021             pass
10022         pass
10023
10024     def testPartitionBySpreadZone1(self):
10025         m=MEDCouplingDataForTest.build2DTargetMesh_1();
10026         m4=MEDCouplingUMesh.MergeUMeshes([m,m[-3:],m[0:2]]);
10027         m4.renumberCells([5,2,9,6,4,7,0,1,3,8]);
10028         #
10029         v2=m4.partitionBySpreadZone();
10030         self.assertTrue(3,len(v2));
10031         self.assertTrue(v2[0].isEqual(DataArrayInt.New([0,1,7])))
10032         self.assertTrue(v2[1].isEqual(DataArrayInt.New([2,4,5,6,9])))
10033         self.assertTrue(v2[2].isEqual(DataArrayInt.New([3,8])))
10034         #
10035         m5=m4.buildSpreadZonesWithPoly();
10036         self.assertEqual(3,m5.getNumberOfCells());
10037         self.assertTrue(m5.getCoords().getHiddenCppPointer()==m4.getCoords().getHiddenCppPointer());
10038         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())
10039         self.assertEqual([0,8,17,23],m5.getNodalConnectivityIndex().getValues())
10040         #
10041         pass
10042
10043     def testGiveCellsWithType1(self):
10044         expected0=[1,2]
10045         expected1=[0,3,4]
10046         m=MEDCouplingDataForTest.build2DTargetMesh_1();
10047         da=m.giveCellsWithType(NORM_TRI3);
10048         self.assertEqual(2,da.getNumberOfTuples());
10049         self.assertEqual(1,da.getNumberOfComponents());
10050         self.assertEqual(expected0,da.getValues())
10051         #
10052         da=m.giveCellsWithType(NORM_QUAD4);
10053         self.assertEqual(3,da.getNumberOfTuples());
10054         self.assertEqual(1,da.getNumberOfComponents());
10055         self.assertEqual(expected1,da.getValues())
10056         #
10057         da=m.giveCellsWithType(NORM_TRI6);
10058         self.assertEqual(0,da.getNumberOfTuples());
10059         self.assertEqual(1,da.getNumberOfComponents());
10060         #
10061         self.assertRaises(InterpKernelException,m.giveCellsWithType,NORM_SEG2)
10062         self.assertRaises(InterpKernelException,m.giveCellsWithType,NORM_HEXA8)
10063         pass
10064
10065     def testSwigDAOp1(self):
10066         d=DataArrayDouble.New(5,2)
10067         d.rearrange(1) ; d.iota(2.) ; d.rearrange(2)
10068         d.setInfoOnComponents(["X [m]","Y [m]"])
10069         d.setName("AName")
10070         #
10071         d1=d+[8,9]
10072         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))
10073         d1bis=DataArrayDouble.New([8,9],1,2)+d
10074         self.assertTrue(d1bis.isEqual(d1,1e-12))
10075         d1ter=[8,9]+d
10076         self.assertTrue(d1ter.isEqual(d1,1e-12))
10077         #
10078         d2=d1-[8,9]
10079         self.assertTrue(d2.isEqual(d,1e-12))
10080         self.assertRaises(InterpKernelException,d1.__rsub__,[8,9])#[8,9]-d1
10081         #
10082         d3=d*[8,9]
10083         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))
10084         d3bis=DataArrayDouble.New([8,9],1,2)*d
10085         self.assertTrue(d3bis.isEqual(d3,1e-12))
10086         d3ter=[8,9]*d
10087         self.assertTrue(d3ter.isEqual(d3,1e-12))
10088         #
10089         d4=d3/[8,9]
10090         self.assertTrue(d4.isEqual(d,1e-12))
10091         #
10092         d=DataArrayInt.New(5,2)
10093         d.rearrange(1) ; d.iota(2) ; d.rearrange(2)
10094         d.setInfoOnComponents(["X [m]","Y [m]"])
10095         d.setName("AName")
10096         #
10097         d1=d+[8,9]
10098         self.assertEqual(d1.getValues(),[10,12,12,14,14,16,16,18,18,20])
10099         d1bis=DataArrayInt.New([8,9],1,2)+d
10100         self.assertTrue(d1bis.isEqual(d1))
10101         d1ter=[8,9]+d
10102         self.assertTrue(d1ter.isEqual(d1))
10103         #
10104         d2=d1-[8,9]
10105         self.assertTrue(d2.isEqual(d))
10106         self.assertRaises(InterpKernelException,d1.__rsub__,[8,9])
10107         #
10108         d3=d*[8,9]
10109         self.assertEqual(d3.getValues(),[16,27,32,45,48,63,64,81,80,99])
10110         d3bis=DataArrayInt.New([8,9],1,2)*d
10111         self.assertTrue(d3bis.isEqual(d3))
10112         d3ter=[8,9]*d
10113         self.assertTrue(d3ter.isEqual(d3))
10114         #
10115         d4=d3/[8,9]
10116         self.assertTrue(d4.isEqual(d))
10117         #
10118         d5=d%[4,5]
10119         self.assertEqual(d5.getValues(),[2,3,0,0,2,2,0,4,2,1])
10120         pass
10121
10122     def testSwigSelectTupleId2DAIBug1(self):
10123         da=DataArrayInt.New([0,1,2,3,12,13,4,5,6,7,14,15,8,9,10,11,16,17])
10124         self.assertEqual([2,6,10],da[2::6].getValues())
10125         self.assertEqual([0,4,8],da[::6].getValues())
10126         self.assertEqual([5,9],da[7::6].getValues())
10127         self.assertEqual([5],da[7:-5:6].getValues())
10128         pass
10129
10130     def testSwigCpp5Safe1(self):
10131         m=MEDCouplingUMesh.New("toto",2)
10132         coords=DataArrayDouble.New([0.,0.,1.,0.,1.,1.,0.,1.],4,2)
10133         m.setCoords(coords)
10134         vecs=DataArrayDouble.New([2.,3.,4.,5.,6.,7.],3,2)
10135         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]]
10136         for pos,vec in enumerate(vecs):
10137             m2=m.deepCpy()
10138             m2.translate(vec)
10139             self.assertTrue(m2.getCoords().isEqual(DataArrayDouble.New(expected1[pos],4,2),1e-12))
10140             pass
10141         for pos,vec in enumerate(vecs):
10142             m2=m.deepCpy()
10143             m2.translate(vec.buildDADouble())
10144             self.assertTrue(m2.getCoords().isEqual(DataArrayDouble.New(expected1[pos],4,2),1e-12))
10145             pass
10146         pass
10147
10148     def testSwigBugNonRegressionZipDA(self):
10149         angles=map(lambda x:pi/3*x,xrange(6))
10150         radius=3
10151         #
10152         dad=DataArrayDouble.New(6, 2)
10153         dad[:,0]=radius
10154         dad[:,1]=angles
10155         #
10156         dad2=dad.fromPolarToCart()
10157         dads=[dad2.deepCpy() for elt in 7*[None]]
10158         #
10159         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.)]]
10160         for d,t in zip(dads,translationToPerform):
10161             d+=t
10162             pass
10163         for elt in dads:
10164             self.assertTrue(not dad2.isEqual(elt,1e-12))
10165             pass
10166         for d,t in zip(dads,translationToPerform):
10167             d-=t
10168             pass
10169         for elt in dads:
10170             self.assertTrue(dad2.isEqual(elt,1e-12))
10171             pass
10172         pass
10173
10174     def testBuildSlice3D2(self):
10175         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
10176         vec1=[-0.07,1.,0.07]
10177         origin1=[1.524,1.4552,1.74768]
10178         slice1,ids=mesh3D.buildSlice3D(origin1,vec1,1e-10);
10179         f=MEDCouplingFieldDouble(ON_CELLS,ONE_TIME)
10180         f.setTime(4.5,6,7) ; f.setMesh(mesh3D)
10181         arr=DataArrayDouble(mesh3D.getNumberOfCells(),2)
10182         arr.rearrange(1) ; arr.iota(2.) ; arr.rearrange(2)
10183         f.setArray(arr)
10184         f.checkCoherency()
10185         expected1=DataArrayInt([1,3,4,7,9,10,13,15,16])
10186         self.assertTrue(expected1.isEqual(ids))
10187         arr2=arr[expected1]
10188         #
10189         f2=f.extractSlice3D(origin1,vec1,1e-10)
10190         self.assertTrue(f2.getArray().isEqual(arr2,1e-12));
10191         self.assertTrue(slice1.isEqual(f2.getMesh(),1e-12))
10192         self.assertEqual(6,f2.getTime()[1]) ; self.assertEqual(7,f2.getTime()[2])
10193         self.assertAlmostEqual(4.5,f2.getTime()[0],12);
10194         pass
10195
10196     def testComputeTupleIdsToSelectFromCellIds1(self):
10197         m=MEDCouplingDataForTest.build2DTargetMesh_3()
10198         f=MEDCouplingFieldDouble.New(ON_GAUSS_NE,NO_TIME);
10199         f.setMesh(m);
10200         arr=DataArrayDouble(52,2) ; arr.rearrange(1) ; arr.iota(7.) ; arr.rearrange(2)
10201         f.setArray(arr)
10202         #
10203         f2=f.buildSubPart([1,5,9])
10204         f2.checkCoherency()
10205         cI=m.computeNbOfNodesPerCell()
10206         cI.computeOffsets2()
10207         sel=DataArrayInt([1,5,9])
10208         res=sel.buildExplicitArrByRanges(cI)
10209         arr2=arr[res]
10210         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))
10211         self.assertTrue(arr2.isEqual(f2.getArray(),1e-12))
10212         pass
10213
10214     def testComputeSkin1(self):
10215         arrX=DataArrayDouble([2.,3.4,5.6,7.7,8.0]) ; arrY=DataArrayDouble([2.,3.4,5.6,7.7,9.0,14.2])
10216         cmesh=MEDCouplingCMesh() ; cmesh.setCoordsAt(0,arrX) ; cmesh.setCoordsAt(1,arrY)
10217         umesh=cmesh.buildUnstructured()
10218         #
10219         skin=umesh.computeSkin()
10220         self.assertEqual(18,skin.getNumberOfCells())
10221         self.assertEqual(1,skin.getMeshDimension())
10222         self.assertTrue(skin.getCoords().getHiddenCppPointer()==umesh.getCoords().getHiddenCppPointer())
10223         self.assertEqual([0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48,51,54],skin.getNodalConnectivityIndex().getValues())
10224         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())
10225         ids=skin.computeFetchedNodeIds()
10226         self.assertEqual([0,1,2,3,4,5,9,10,14,15,19,20,24,25,26,27,28,29],ids.getValues())
10227         part=umesh.buildFacePartOfMySelfNode(ids,True)
10228         part.setName(skin.getName());
10229         self.assertTrue(part.isEqual(skin,1e-12))
10230         part2=part[1::2]
10231         part[::2]=part2
10232         self.assertTrue(not part.isEqual(skin,1e-12))
10233         trad=part.zipConnectivityTraducer(0)
10234         self.assertEqual(9,part.getNumberOfCells())
10235         self.assertEqual([0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8],trad.getValues())
10236         pass
10237
10238     def testUMeshSetPartOfMySelf2(self):
10239         # resize with explicit ids list
10240         m=MEDCouplingDataForTest.build2DTargetMesh_1()
10241         self.assertEqual([3,4],m.getAllGeoTypes())
10242         part=m[[0,3,4]]
10243         part.simplexize(0)
10244         part2=part[[1,2,5]]
10245         m[[0,3,4]]=part2
10246         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())
10247         self.assertEqual([0,4,8,12,16,20],m.getNodalConnectivityIndex().getValues())
10248         self.assertEqual([3],m.getAllGeoTypes())
10249         # no resize with explicit ids list
10250         m=MEDCouplingDataForTest.build2DTargetMesh_1()
10251         part=m[[0,3]]
10252         part.convertAllToPoly()
10253         m[[3,4]]=part
10254         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())
10255         self.assertEqual([0,5,9,13,18,23],m.getNodalConnectivityIndex().getValues())
10256         self.assertEqual([3,4,5],m.getAllGeoTypes())
10257         # resize with range ids
10258         m=MEDCouplingDataForTest.build2DTargetMesh_1()
10259         part=m[3:]
10260         m[1:3]=part
10261         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())
10262         self.assertEqual([0,5,10,15,20,25],m.getNodalConnectivityIndex().getValues())
10263         self.assertEqual([4],m.getAllGeoTypes())
10264         # no resize with range ids
10265         m=MEDCouplingDataForTest.build2DTargetMesh_1()
10266         part=m[0::3]
10267         part.convertAllToPoly()
10268         m[3:]=part
10269         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())
10270         self.assertEqual([0,5,9,13,18,23],m.getNodalConnectivityIndex().getValues())
10271         self.assertEqual([3,4,5],m.getAllGeoTypes())
10272         # no resize with range ids negative direction
10273         m=MEDCouplingDataForTest.build2DTargetMesh_1()
10274         part=m[3::-3]
10275         part.convertAllToPoly()
10276         m[:-3:-1]=part
10277         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())
10278         self.assertEqual([0,5,9,13,18,23],m.getNodalConnectivityIndex().getValues())
10279         self.assertEqual([3,4,5],m.getAllGeoTypes())
10280         pass
10281
10282     def testUnPolyze3(self):
10283         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]
10284         conn=[1,2,5,4,-1,4,3,0,1,-1,2,0,3,5,-1,0,2,1,-1,4,5,3]
10285         m=MEDCouplingUMesh.New("a mesh",3);
10286         m.allocateCells(1);
10287         m.insertNextCell(NORM_POLYHED,22,conn[0:22])
10288         m.finishInsertingCells();
10289         coords=DataArrayDouble(coord,6,3);
10290         m.setCoords(coords);
10291         m.checkCoherency();
10292         #
10293         vol=m.getMeasureField(ON_CELLS);
10294         self.assertEqual(1,vol.getArray().getNumberOfTuples());
10295         self.assertAlmostEqual(0.5,vol.getArray().getIJ(0,0),12)
10296         #
10297         m.unPolyze();
10298         #
10299         self.assertEqual([NORM_PENTA6],m.getAllGeoTypes())
10300         self.assertTrue(DataArrayInt([0,7]).isEqual(m.getNodalConnectivityIndex()))
10301         self.assertTrue(DataArrayInt([16,0,2,1,3,5,4]).isEqual(m.getNodalConnectivity()))
10302         #
10303         vol=m.getMeasureField(ON_CELLS);
10304         self.assertEqual(1,vol.getArray().getNumberOfTuples());
10305         self.assertAlmostEqual(0.5,vol.getArray().getIJ(0,0),12)
10306         pass
10307
10308     def testKrSpatialDiscretization1(self):
10309         srcPointCoordsX=[0.8401877171547095, 0.7830992237586059, 0.9116473579367843, 0.335222755714889, 0.2777747108031878, 0.4773970518621602, 0.3647844727918433, 0.9522297251747128, 0.6357117279599009, 0.1416025553558034]
10310         srcFieldValsOnPoints=[2.129892434968836, 2.295320474540621, 1.931948594981134, 2.728013590937196, 2.715603240418478, 2.661778472822935, 2.695696990104364, 1.893710234970982, 2.529628016549284, 2.728432341300668]
10311         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]
10312         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]
10313         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])
10314         #
10315         nbOfInputPoints=10;
10316         f=MEDCouplingFieldDouble.New(ON_NODES_KR,ONE_TIME);
10317         srcArrX=DataArrayDouble.New(srcPointCoordsX,nbOfInputPoints,1);
10318         cmesh=MEDCouplingCMesh.New("aMesh");
10319         cmesh.setCoordsAt(0,srcArrX);
10320         umesh=cmesh.buildUnstructured();
10321         f.setMesh(umesh);
10322         srcVals=DataArrayDouble.New(srcFieldValsOnPoints,nbOfInputPoints,1);
10323         f.setArray(srcVals);
10324         f.checkCoherency();
10325         #
10326         res0=f.getValueOn(targetPointCoordsX[:1]);
10327         self.assertAlmostEqual(targetFieldValsExpected[0],res0[0],10)
10328         #
10329         valuesToTest=f.getValueOnMulti(targetPointCoordsX);
10330         self.assertEqual(40,valuesToTest.getNumberOfTuples());
10331         self.assertEqual(1,valuesToTest.getNumberOfComponents());
10332         for i in xrange(40):
10333             self.assertAlmostEqual(targetFieldValsExpected[i],valuesToTest.getIJ(i,0),10)
10334             pass
10335         fd=f.getDiscretization()
10336         del f
10337         self.assertTrue(isinstance(fd,MEDCouplingFieldDiscretizationKriging))
10338         coeffs,isDrift=fd.computeVectorOfCoefficients(umesh,srcVals)
10339         self.assertEqual(2,isDrift)
10340         self.assertTrue(coeffsExpected.isEqual(coeffs,1e-8))
10341         #
10342         pass
10343
10344     def testDuplicateEachTupleNTimes1(self):
10345         d=DataArrayDouble.New([9.,8.,7.,6.],4,1) ; d.setInfoOnComponents(["mass [kg]"]) ; d.setName("aname")
10346         d2=d.duplicateEachTupleNTimes(3)
10347         self.assertTrue(d2.isEqualWithoutConsideringStr(DataArrayDouble.New([9.,9.,9.,8.,8.,8.,7.,7.,7.,6.,6.,6.],4*3,1),1e-14))
10348         self.assertEqual("aname",d2.getName())
10349         self.assertEqual(["mass [kg]"],d2.getInfoOnComponents())
10350         #
10351         d=DataArrayInt.New([9,8,7,6],4,1) ; d.setInfoOnComponents(["mass [kg]"]) ; d.setName("aname")
10352         d2=d.duplicateEachTupleNTimes(3)
10353         self.assertTrue(d2.isEqualWithoutConsideringStr(DataArrayInt.New([9,9,9,8,8,8,7,7,7,6,6,6],4*3,1)))
10354         self.assertEqual("aname",d2.getName())
10355         self.assertEqual(["mass [kg]"],d2.getInfoOnComponents())
10356         pass
10357
10358     def testSwigComputeTupleIdsNearTuples1(self):
10359         da=DataArrayDouble([5.,6.,-5.,-6.,5.,-6.,-5.,6.,5.,6.],5,2)
10360         arr,arrI=da.computeTupleIdsNearTuples(DataArrayDouble([5.,-6.,5.,6.,-5.,-6.],3,2),1e-10)
10361         self.assertEqual([2,0,4,1],arr.getValues())
10362         self.assertEqual([0,1,3,4],arrI.getValues())
10363         arr,arrI=da.computeTupleIdsNearTuples([5.,-6.,5.,6.,-5.,-6.],1e-10)
10364         self.assertEqual([2,0,4,1],arr.getValues())
10365         self.assertEqual([0,1,3,4],arrI.getValues())
10366         expected0=[[2],[0,4],[1]]
10367         expected1=[[0,1],[0,2],[0,1]]
10368         for pos,it in enumerate(DataArrayDouble([5.,-6.,5.,6.,-5.,-6.],3,2)):
10369             arr,arrI=da.computeTupleIdsNearTuples(it,1e-10)
10370             self.assertEqual(expected0[pos],arr.getValues())
10371             self.assertEqual(expected1[pos],arrI.getValues())
10372             pass
10373         pass
10374
10375     def testSwigDataTupleIOp1(self):
10376         d=DataArrayDouble(10,1)
10377         d.iota(7.)
10378         for elt in d:
10379             elt+=2.
10380             pass
10381         toTest=DataArrayDouble([9.0,10.0,11.0,12.0,13.0,14.0,15.0,16.0,17.0,18.0])
10382         self.assertTrue(toTest.isEqual(d,1e-12))
10383         for elt in d:
10384             elt-=2.
10385             pass
10386         toTest=DataArrayDouble([7.0,8.0,9.0,10.0,11.0,12.0,13.0,14.0,15.0,16.0])
10387         self.assertTrue(toTest.isEqual(d,1e-12))
10388         for elt in d:
10389             elt*=2.
10390             pass
10391         toTest=DataArrayDouble([14.0,16.0,18.0,20.0,22.0,24.0,26.0,28.0,30.0,32.0])
10392         self.assertTrue(toTest.isEqual(d,1e-12))
10393         for elt in d:
10394             elt/=2.
10395             pass
10396         toTest=DataArrayDouble([7.0,8.0,9.0,10.0,11.0,12.0,13.0,14.0,15.0,16.0])
10397         self.assertTrue(toTest.isEqual(d,1e-12))
10398         #
10399         d=DataArrayInt(10,1)
10400         d.iota(7)
10401         for elt in d:
10402             elt+=2
10403             pass
10404         self.assertEqual(d.getValues(),[9,10,11,12,13,14,15,16,17,18])
10405         for elt in d:
10406             elt-=2
10407             pass
10408         self.assertEqual(d.getValues(),[7,8,9,10,11,12,13,14,15,16])
10409         for elt in d:
10410             elt*=2
10411             pass
10412         self.assertEqual(d.getValues(),[14,16,18,20,22,24,26,28,30,32])
10413         for elt in d:
10414             elt/=2
10415             pass
10416         self.assertEqual(d.getValues(),[7,8,9,10,11,12,13,14,15,16])
10417         for elt in d:
10418             elt%=3
10419             pass
10420         self.assertEqual(d.getValues(),[1,2,0,1,2,0,1,2,0,1])
10421         pass
10422
10423     def testIntersect2DMeshesTmp5(self):
10424         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)
10425         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)
10426         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)
10427         #
10428         m1=MEDCouplingUMesh.New("Fix",2);
10429         m1.setCoords(coords);
10430         m1.setConnectivity(conn,connI,True);
10431         #
10432         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)
10433         # connectivity
10434         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);
10435         conn.setName("");
10436         connI=DataArrayInt([0,9,18,27,36,45,54,63,72],9)
10437         m2=MEDCouplingUMesh.New("Mobile",2);
10438         m2.setCoords(coords);
10439         m2.setConnectivity(conn,connI,True);
10440         #
10441         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m1,m2,1e-10);
10442         self.assertEqual(105,m3.getNumberOfCells());
10443         self.assertEqual(105,d1.getNumberOfTuples());
10444         self.assertEqual(105,d2.getNumberOfTuples());
10445         self.assertEqual(704,m3.getNumberOfNodes());
10446         #
10447         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]
10448         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]
10449         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]
10450         f3=m3.getMeasureField(ON_CELLS).getArray().getValues();
10451         for i in xrange(105):
10452             self.assertAlmostEqual(areaExpected[i],f3[i],10)
10453             pass
10454         self.assertEqual(expected1,d1.getValues())
10455         self.assertEqual(expected2,d2.getValues())
10456         pass
10457
10458     def testSwig2Intersect2DMeshesQuadra1(self):
10459         import cmath
10460         def createDiagCircle(lX, lY, R, cells=[0,1]):
10461             """ A circle in a square box, cut along the diagonal.
10462             """
10463             c = []
10464             for i in range(8):
10465               c.append(cmath.rect(R, i*pi/4))
10466
10467             coords = [0.0,0.0,          c[3].real,c[3].imag,       -lX/2.0, lY/2.0,
10468                       0.0, lY/2.0,      lX/2.0,lY/2.0,             lX/2.0,0.0,
10469                       #   6                  7                              8
10470                       lX/2.0,-lY/2.0,   c[7].real,c[7].imag,       c[1].real,c[1].imag,
10471                       #   9                  10                            11
10472                       c[5].real,c[5].imag,   -lX/2.0,-lY/2.0,      0.0, -lY/2.0,
10473                       #   12                  13                            14
10474                       -lX/2.0,0.0,         0.0,0.0,                  0.0, 0.0]
10475             # Points 13 (reps. 14) are average of points (6,7) (resp (1,2))
10476             coords[13*2]   = 0.5*(coords[6*2]+coords[7*2])
10477             coords[13*2+1] = 0.5*(coords[6*2+1]+coords[7*2+1])
10478             coords[14*2]   = 0.5*(coords[1*2]+coords[2*2])
10479             coords[14*2+1] = 0.5*(coords[1*2+1]+coords[2*2+1])
10480             connec  = [1,7,8,0]      # half circle up right
10481             connec3 = [6,7,1,2,4,13,8,14,3,5]
10482
10483             baseMesh = MEDCouplingUMesh.New("box_circle", 2)
10484             baseMesh.allocateCells(2)
10485             meshCoords = DataArrayDouble.New(coords, len(coords)/2, 2)
10486             meshCoords.setInfoOnComponents(["X [au]", "Y [au]"])
10487             baseMesh.setCoords(meshCoords)
10488
10489             if 0 in cells:
10490               baseMesh.insertNextCell(NORM_QPOLYG, connec)
10491             if 1 in cells:
10492               baseMesh.insertNextCell(NORM_QPOLYG, connec3)
10493             baseMesh.finishInsertingCells()
10494             baseMesh.checkCoherency()
10495             return baseMesh
10496
10497         eps = 1.0e-7
10498         m1 = createDiagCircle(1.0, 1.0, 0.5*0.90, cells=[0,1])
10499         m2 = createDiagCircle(1.0, 1.0, 0.5*0.95, cells=[0])
10500         m3, _, _= MEDCouplingUMesh.Intersect2DMeshes(m1, m2, eps)
10501         m3.mergeNodes(eps)
10502         m3.convertDegeneratedCells()
10503         m3.zipCoords()
10504         m4 = m3.deepCpy()
10505         m5, _, _ = MEDCouplingUMesh.Intersect2DMeshes(m3, m4, eps)
10506         m5.mergeNodes(eps)
10507         # Check coordinates:
10508         self.assertTrue(m3.getCoords().isEqual(m5.getCoords(), eps))
10509
10510     def testIntersect2DMeshesTmp7(self):
10511         eps = 1.0e-8
10512         coords = [-0.5,-0.5,   -0.5, 0.5, 0.5, 0.5,    0.5,-0.5]
10513         connec = range(4)
10514         m1 = MEDCouplingUMesh.New("box", 2)
10515         m1.allocateCells(1)
10516         meshCoords = DataArrayDouble.New(coords, len(coords)/2, 2)
10517         m1.setCoords(meshCoords)
10518         m1.insertNextCell(NORM_POLYGON, connec)
10519         m1.finishInsertingCells()
10520
10521         m2 = MEDCouplingDataForTest.buildCircle(0.25, 0.2, 0.4)
10522         # Was looping indefinitly:
10523         m_intersec, resToM1, resToM2 = MEDCouplingUMesh.Intersect2DMeshes(m1, m2, eps)
10524         m_intersec.zipCoords()
10525         coo_tgt = DataArrayDouble([-0.5, -0.5, -0.5, 0.5, 0.5, 0.5, 0.5, -0.5, -0.03284271247461901, 0.4828427124746191,
10526           -0.014575131106459124, 0.5000000000000001, 0.5, -0.11224989991991996, 0.24271243444677046, 0.5, 0.5, 0.19387505004004,
10527           -0.04799910280454185, -0.06682678787499614, -0.023843325638122054, 0.4915644577163915, 0.5, -0.30612494995996, 0.0, -0.5,
10528           -0.5, 0.0, -0.25728756555322957, 0.5, -0.023843325638122026, 0.49156445771639157, -0.04799910280454181, -0.06682678787499613], 17 ,2)
10529         conn_tgt = [32, 5, 2, 6, 4, 7, 8, 9, 10, 32, 6, 3, 0, 1, 5, 4, 11, 12, 13, 14, 15, 16]
10530         connI_tgt = [0, 9, 22]
10531         res1_tgt  = [0, 0]
10532         res2_tgt = [0, -1]
10533         self.assert_(coo_tgt.isEqualWithoutConsideringStr(m_intersec.getCoords(), 1e-12))
10534         self.assertEqual(conn_tgt, m_intersec.getNodalConnectivity().getValues())
10535         self.assertEqual(connI_tgt, m_intersec.getNodalConnectivityIndex().getValues())
10536         self.assertEqual(res1_tgt, resToM1.getValues())
10537         self.assertEqual(res2_tgt, resToM2.getValues())
10538
10539     def testDAIBuildUnique1(self):
10540         d=DataArrayInt([1,2,2,3,3,3,3,4,5,5,7,7,7,19])
10541         e=d.buildUnique()
10542         self.assertTrue(e.isEqual(DataArrayInt([1,2,3,4,5,7,19])))
10543         pass
10544
10545     def testDAIPartitionByDifferentValues1(self):
10546         d=DataArrayInt([1,0,1,2,0,2,2,-3,2])
10547         expected=[[-3,[7]],[0,[1,4]],[1,[0,2]],[2,[3,5,6,8]]]
10548         for i,elt in enumerate(zip(*d.partitionByDifferentValues())):
10549             self.assertEqual(expected[i][0],elt[1])
10550             self.assertEqual(expected[i][1],elt[0].getValues())
10551             pass
10552         pass
10553
10554     def testFieldGaussMultiDiscPerType1(self):
10555         coords=DataArrayDouble([0.,0.,0.,1.,1.,1.,1.,0.,0.,0.5,0.5,1.,1.,0.5,0.5,0.],8,2)
10556         mQ8=MEDCouplingUMesh("",2) ; mQ8.setCoords(coords)
10557         mQ8.allocateCells(1)
10558         mQ8.insertNextCell(NORM_QUAD8,range(8))
10559         mQ8.finishInsertingCells()
10560         mQ4=MEDCouplingUMesh("",2) ; mQ4.setCoords(coords)
10561         mQ4.allocateCells(1)
10562         mQ4.insertNextCell(NORM_QUAD4,range(4))
10563         mQ4.finishInsertingCells()
10564         mT3=MEDCouplingUMesh("",2) ; mT3.setCoords(coords)
10565         mT3.allocateCells(1)
10566         mT3.insertNextCell(NORM_TRI3,range(3))
10567         mT3.finishInsertingCells()
10568
10569         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.]]
10570         ms=2*[mQ4]+7*[mQ8]+11*[mT3]
10571         ms[:]=(elt.deepCpy() for elt in ms)
10572         for m,t in zip(ms,tr):
10573             d=m.getCoords() ; d+= t
10574             pass
10575         m=MEDCouplingUMesh.MergeUMeshes(ms)
10576         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,NO_TIME)
10577         f.setMesh(m)
10578         # throw because cell 0,1 are QUAD4 and cell 3 is QUAD8
10579         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])
10580         f.setGaussLocalizationOnCells([0,1],[0.,0.,1.,0.,1.,1.,0.,1.],[0.3,0.3,0.7,0.7],[0.8,0.2])
10581         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])
10582         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])
10583         f.setGaussLocalizationOnCells([9,10,11,12,13],[0.,0.,1.,0.,1.,1.],[0.4,0.4],[1.])
10584         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])
10585         self.assertEqual(46,f.getNumberOfTuplesExpected())
10586         vals=DataArrayDouble.New(46*3,1) ; vals.iota(7.7) ; vals.rearrange(3)
10587         f.setArray(vals)
10588         f.checkCoherency()
10589         #f.getLocalizationOfDiscr()
10590         self.assertRaises(InterpKernelException,f.getGaussLocalizationIdOfOneType,NORM_QUAD8) #throw because several loc
10591         self.assertEqual([1,2],f.getGaussLocalizationIdsOfOneType(NORM_QUAD8))
10592         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())
10593         fc=f[[1,2,3,8]]
10594         fc.checkCoherency()
10595         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))
10596         fc.renumberCells([3,2,0,1])
10597         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))
10598         fc.getArray()
10599         pass
10600
10601     def testSwigRotate(self):
10602         d=DataArrayDouble([1.,2.,3.,4.,6.,5.],2,3)
10603         MEDCouplingPointSet.Rotate3DAlg([0.,0.,0.],[0.,1.,0.],1.5707963267948966,d)
10604         self.assertTrue(d.isEqual(DataArrayDouble([3.,2.,-1.,5.,6.,-4.],2,3),1e-12))
10605         d=DataArrayDouble([1.,2.,3.,4.,6.,5.],3,2)
10606         MEDCouplingPointSet.Rotate2DAlg([0.,0.],1.5707963267948966,d)
10607         self.assertTrue(d.isEqual(DataArrayDouble([-2.,1.,-4.,3.,-5.,6.],3,2),1e-12))
10608         pass
10609
10610     def testSwigCMeshProtection(self):
10611         cm=MEDCouplingCMesh()
10612         self.assertRaises(InterpKernelException,cm.setCoordsAt,0,DataArrayDouble([4.,4.5,6.,7.],2,2))
10613         self.assertRaises(InterpKernelException,cm.setCoords,DataArrayDouble([4.,4.5,6.,7.],2,2))
10614         pass
10615
10616     def testSwigCellsInBoundingBox1(self):
10617         m3D=MEDCouplingDataForTest.build3DExtrudedUMesh_1()[0]
10618         self.assertTrue(m3D.getCellsInBoundingBox([(0,3),(0,3),(0,1)],-1e-12).isEqual(DataArrayInt([0,1,2,3,4,5])))
10619         self.assertRaises(InterpKernelException,m3D.getCellsInBoundingBox,[(0,3,0),(3,0,1)],-1e-12)
10620         pass
10621
10622     def testDAICheckMonotonic1(self):
10623         data1=[-1,0,2,2,4,5]
10624         data2=[6,2,0,-8,-9,-56]
10625         data3=[-1,0,3,2,4,6]
10626         data4=[7,5,2,3,0,-6]
10627         d=DataArrayInt.New(data1);
10628         self.assertTrue(d.isMonotonic(True));
10629         self.assertTrue(not d.isMonotonic(False));
10630         d.checkMonotonic(True);
10631         self.assertRaises(InterpKernelException,d.checkMonotonic,False)
10632         d=DataArrayInt.New(data2);
10633         self.assertTrue(d.isMonotonic(False));
10634         self.assertTrue(not d.isMonotonic(True));
10635         d.checkMonotonic(False);
10636         self.assertRaises(InterpKernelException,d.checkMonotonic,True)
10637         d=DataArrayInt.New(data3);
10638         self.assertTrue(not d.isMonotonic(False));
10639         self.assertTrue(not d.isMonotonic(True));
10640         self.assertRaises(InterpKernelException,d.checkMonotonic,True)
10641         self.assertRaises(InterpKernelException,d.checkMonotonic,False)
10642         d=DataArrayInt.New(data4);
10643         self.assertTrue(not d.isMonotonic(False));
10644         self.assertTrue(not d.isMonotonic(True));
10645         self.assertRaises(InterpKernelException,d.checkMonotonic,True)
10646         self.assertRaises(InterpKernelException,d.checkMonotonic,False)
10647         d=DataArrayInt.New(0,1)
10648         self.assertTrue(d.isMonotonic(True));
10649         self.assertTrue(d.isMonotonic(False));
10650         d.checkMonotonic(True);
10651         d.checkMonotonic(False);
10652         d=DataArrayInt.New(data4,3,2);#throw because nbComp!=1
10653         self.assertRaises(InterpKernelException,d.isMonotonic,True)
10654         self.assertRaises(InterpKernelException,d.isMonotonic,False)
10655         self.assertRaises(InterpKernelException,d.checkMonotonic,True)
10656         self.assertRaises(InterpKernelException,d.checkMonotonic,False)
10657         pass
10658
10659     def testSwigDASetItemOnEmpty1(self):
10660         d=DataArrayInt(0,1)
10661         isThrow=False
10662         try:
10663             d[0:1000:2]=4
10664         except InterpKernelException as e:
10665             isThrow=True
10666             pass
10667         self.assertTrue(isThrow)
10668         d[:]=4
10669         d[::2]=5
10670         #
10671         d=DataArrayDouble(0,1)
10672         isThrow=False
10673         try:
10674             d[0:1000:2]=4
10675         except InterpKernelException as e:
10676             isThrow=True
10677             pass
10678         self.assertTrue(isThrow)
10679         d[:]=4
10680         d[::2]=5
10681         d=DataArrayInt([],0,1)
10682         d2=DataArrayInt(0)
10683         self.assertTrue(d2.isEqual(d))
10684         d=DataArrayDouble([],0,1)
10685         d2=DataArrayDouble(0)
10686         self.assertTrue(d2.isEqual(d,1e-12))
10687         pass
10688
10689     def testSwigDAITransformWithIndArr1(self):
10690         arr=DataArrayInt([0,4,5,1])
10691         d=DataArrayInt([7,8,9,10])
10692         self.assertRaises(InterpKernelException,arr.transformWithIndArr,d)
10693         pass
10694
10695     def testIntersect2DMeshesTmp6(self):
10696         # coordinates
10697         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);
10698         # connectivity
10699         conn=DataArrayInt.New([8,0,3,5,1,4,6,7,2])
10700         connI=DataArrayInt.New([0,9]);
10701         m1=MEDCouplingUMesh.New("Fixe",2);
10702         m1.setCoords(coords);
10703         m1.setConnectivity(conn,connI,True);
10704         #
10705         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);
10706         # connectivity
10707         conn=DataArrayInt.New([8,0,1,2,3,4,5,6,7,8,3,2,8,9,6,10,11,12]);
10708         connI=DataArrayInt.New([0,9,18]);
10709         #
10710         m2=MEDCouplingUMesh.New("Mobile",2);
10711         m2.setCoords(coords);
10712         m2.setConnectivity(conn,connI,True);
10713         #
10714         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m1,m2,1e-10);
10715         self.assertTrue(d1.isEqual(DataArrayInt([0,0,0,0])));
10716         self.assertTrue(d2.isEqual(DataArrayInt([0,1,-1,-1])));
10717         self.assertEqual(4,m3.getNumberOfCells());
10718         self.assertEqual(4,d1.getNumberOfTuples());
10719         self.assertEqual(4,d2.getNumberOfTuples());
10720         self.assertEqual(43,m3.getNumberOfNodes());
10721         dI,areMerged,newNbOfNodes=m3.mergeNodes(1e-12)
10722         self.assertEqual(35,m3.getNumberOfNodes());
10723         m3.zipCoords();
10724         self.assertEqual(23,m3.getNumberOfNodes());
10725         #
10726         f=m3.getMeasureField(True);
10727         valuesExpected=DataArrayDouble([1.6603638692585716,5.747555728471923,129.68907101754394,7.4162714498559694])
10728         self.assertTrue(f.getArray().isEqual(valuesExpected,1e-12))
10729         pass
10730
10731     def testDAPushBack(self):
10732         d=DataArrayDouble(0,1)
10733         for i in xrange(8):
10734             d.pushBackSilent(i)
10735             pass
10736         self.assertEqual(d.getNumberOfTuples(),8)
10737         self.assertEqual(d.getNbOfElemAllocated(),8)
10738         d.pushBackSilent(4.44)
10739         self.assertEqual(d.getNumberOfTuples(),9)
10740         self.assertEqual(d.getNbOfElemAllocated(),16)
10741         self.assertTrue(d.isEqual(DataArrayDouble([0.,1.,2.,3.,4.,5.,6.,7.,4.44]),1e-12))
10742         e=d.deepCpy()
10743         self.assertEqual(e.getNumberOfTuples(),9)
10744         self.assertEqual(e.getNbOfElemAllocated(),9)
10745         self.assertTrue(e.isEqual(DataArrayDouble([0.,1.,2.,3.,4.,5.,6.,7.,4.44]),1e-12))
10746         self.assertAlmostEqual(d.popBackSilent(),4.44,12)
10747         self.assertEqual(d.getNumberOfTuples(),8)
10748         self.assertEqual(d.getNbOfElemAllocated(),16)
10749         self.assertTrue(d.isEqual(DataArrayDouble([0.,1.,2.,3.,4.,5.,6.,7.]),1e-12))
10750         f=DataArrayDouble()
10751         f.reserve(1000)
10752         f.pushBackSilent(4.)
10753         self.assertTrue(f.isEqual(DataArrayDouble([4.]),1e-12))
10754         self.assertEqual(f.getNumberOfTuples(),1)
10755         self.assertEqual(f.getNbOfElemAllocated(),1000)
10756         ff=f[:]
10757         self.assertTrue(ff.isEqual(DataArrayDouble([4.]),1e-12))
10758         self.assertEqual(ff.getNumberOfTuples(),1)
10759         self.assertEqual(ff.getNbOfElemAllocated(),1)
10760         d=DataArrayDouble()
10761         d.pushBackSilent(4.44)
10762         d.pushBackSilent(5.55)
10763         d.pushBackSilent(6.66)
10764         self.assertTrue(d.isEqual(DataArrayDouble([4.44,5.55,6.66]),1e-12))
10765         #
10766         d=DataArrayInt(0,1)
10767         for i in xrange(8):
10768             d.pushBackSilent(i)
10769             pass
10770         self.assertEqual(d.getNumberOfTuples(),8)
10771         self.assertEqual(d.getNbOfElemAllocated(),8)
10772         d.pushBackSilent(444)
10773         self.assertEqual(d.getNumberOfTuples(),9)
10774         self.assertEqual(d.getNbOfElemAllocated(),16)
10775         self.assertTrue(d.isEqual(DataArrayInt([0,1,2,3,4,5,6,7,444])))
10776         e=d.deepCpy()
10777         self.assertEqual(e.getNumberOfTuples(),9)
10778         self.assertEqual(e.getNbOfElemAllocated(),9)
10779         self.assertTrue(e.isEqual(DataArrayInt([0,1,2,3,4,5,6,7,444])))
10780         self.assertEqual(d.popBackSilent(),444)
10781         self.assertEqual(d.getNumberOfTuples(),8)
10782         self.assertEqual(d.getNbOfElemAllocated(),16)
10783         self.assertTrue(d.isEqual(DataArrayInt([0,1,2,3,4,5,6,7])))
10784         f=DataArrayInt()
10785         f.reserve(1000)
10786         f.pushBackSilent(4)
10787         self.assertTrue(f.isEqual(DataArrayInt([4])))
10788         self.assertEqual(f.getNumberOfTuples(),1)
10789         self.assertEqual(f.getNbOfElemAllocated(),1000)
10790         ff=f[:]
10791         self.assertTrue(ff.isEqual(DataArrayInt([4])))
10792         self.assertEqual(ff.getNumberOfTuples(),1)
10793         self.assertEqual(ff.getNbOfElemAllocated(),1)
10794         d=DataArrayInt()
10795         d.pushBackSilent(444)
10796         d.pushBackSilent(555)
10797         d.pushBackSilent(666)
10798         self.assertTrue(d.isEqual(DataArrayInt([444,555,666])))
10799         #
10800         d=DataArrayInt()
10801         d.alloc(10,1)
10802         d.setInfoOnComponent(0,"ABC")
10803         d.setName("dEf")
10804         d.iota(7)
10805         e=DataArrayInt([7,8,9,10,11,12,13,14,15,16]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
10806         self.assertEqual(10,d.getNbOfElemAllocated())
10807         d.pushBackSilent(55)
10808         e=DataArrayInt([7,8,9,10,11,12,13,14,15,16,55]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
10809         self.assertEqual(20,d.getNbOfElemAllocated())
10810         d.reserve(4)
10811         e=DataArrayInt([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
10812         self.assertEqual(4,d.getNbOfElemAllocated())
10813         d.pushBackSilent(5)
10814         e=DataArrayInt([7,8,9,10,5]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
10815         self.assertEqual(8,d.getNbOfElemAllocated())
10816         self.assertEqual(5,d.popBackSilent())
10817         e=DataArrayInt([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
10818         self.assertEqual(8,d.getNbOfElemAllocated())
10819         self.assertRaises(OverflowError,d.reserve,-1)
10820         e=DataArrayInt([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
10821         self.assertEqual(8,d.getNbOfElemAllocated())
10822         d.reserve(0)
10823         e=DataArrayInt([]) ; e.setInfoOnComponent(0,"ABC") ; e.setName("dEf") ; self.assertTrue(d.isEqual(e))
10824         self.assertEqual(0,d.getNbOfElemAllocated())
10825         #
10826         d=DataArrayDouble()
10827         d.alloc(10,1)
10828         d.setInfoOnComponent(0,"ABC")
10829         d.setName("dEf")
10830         d.iota(7)
10831         e=DataArrayDouble([7,8,9,10,11,12,13,14,15,16]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
10832         self.assertEqual(10,d.getNbOfElemAllocated())
10833         d.pushBackSilent(55)
10834         e=DataArrayDouble([7,8,9,10,11,12,13,14,15,16,55]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
10835         self.assertEqual(20,d.getNbOfElemAllocated())
10836         d.reserve(4)
10837         e=DataArrayDouble([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
10838         self.assertEqual(4,d.getNbOfElemAllocated())
10839         d.pushBackSilent(5)
10840         e=DataArrayDouble([7,8,9,10,5]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
10841         self.assertEqual(8,d.getNbOfElemAllocated())
10842         self.assertEqual(5.,d.popBackSilent())
10843         e=DataArrayDouble([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
10844         self.assertEqual(8,d.getNbOfElemAllocated())
10845         self.assertRaises(OverflowError,d.reserve,-1)
10846         e=DataArrayDouble([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
10847         self.assertEqual(8,d.getNbOfElemAllocated())
10848         d.reserve(0)
10849         e=DataArrayDouble([]) ; e.setInfoOnComponent(0,"ABC") ; e.setName("dEf") ; self.assertTrue(d.isEqual(e,1e-14))
10850         self.assertEqual(0,d.getNbOfElemAllocated())
10851         pass
10852
10853     def testDAIBuildSubstractionOptimized1(self):
10854         da1=DataArrayInt.New([1,3,5,6,7,9,13])
10855         da2=DataArrayInt.New([3,5,9])
10856         da3=DataArrayInt.New([1,3,5])
10857         da4=DataArrayInt.New([1,3,5,6,7,9,13])
10858         #
10859         a=da1.buildSubstractionOptimized(da2);
10860         self.assertTrue(a.isEqual(DataArrayInt([1,6,7,13])));
10861         #
10862         a=da1.buildSubstractionOptimized(da3);
10863         self.assertTrue(a.isEqual(DataArrayInt([6,7,9,13])));
10864         #
10865         a=da1.buildSubstractionOptimized(da4);
10866         self.assertTrue(a.isEqual(DataArrayInt([])));
10867         pass
10868
10869     def testDAIIsStrictlyMonotonic1(self):
10870         da1=DataArrayInt.New([1,3,5,6,7,9,13])
10871         self.assertTrue(da1.isStrictlyMonotonic(True));
10872         da1.checkStrictlyMonotonic(True);
10873         self.assertTrue(da1.isMonotonic(True));
10874         da1.checkMonotonic(True);
10875         self.assertTrue(not da1.isStrictlyMonotonic(False));
10876         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,False)
10877         self.assertTrue(not da1.isMonotonic(False));
10878         self.assertRaises(InterpKernelException,da1.checkMonotonic,False)
10879         #
10880         da1=DataArrayInt.New([1,3,5,6,6,9,13])
10881         self.assertTrue(not da1.isStrictlyMonotonic(True));
10882         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,True)
10883         self.assertTrue(da1.isMonotonic(True));
10884         da1.checkMonotonic(True);
10885         self.assertTrue(not da1.isStrictlyMonotonic(False));
10886         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,False)
10887         self.assertTrue(not da1.isMonotonic(False));
10888         self.assertRaises(InterpKernelException,da1.checkMonotonic,False)
10889         #
10890         da1=DataArrayInt.New([1,3,5,6,5,9,13])
10891         self.assertTrue(not da1.isStrictlyMonotonic(True));
10892         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,True)
10893         self.assertTrue(not da1.isMonotonic(True));
10894         self.assertRaises(InterpKernelException,da1.checkMonotonic,True)
10895         self.assertTrue(not da1.isStrictlyMonotonic(False));
10896         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,False)
10897         self.assertTrue(not da1.isMonotonic(False));
10898         self.assertRaises(InterpKernelException,da1.checkMonotonic,False)
10899         #
10900         da1=DataArrayInt.New([13,9,7,6,5,3,1])
10901         self.assertTrue(not da1.isStrictlyMonotonic(True));
10902         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,True)
10903         self.assertTrue(not da1.isMonotonic(True));
10904         self.assertRaises(InterpKernelException,da1.checkMonotonic,True)
10905         self.assertTrue(da1.isStrictlyMonotonic(False));
10906         da1.checkStrictlyMonotonic(False);
10907         self.assertTrue(da1.isMonotonic(False));
10908         da1.checkMonotonic(False);
10909         #
10910         da1=DataArrayInt.New([13,9,6,6,5,3,1])
10911         self.assertTrue(not da1.isStrictlyMonotonic(True));
10912         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,True)
10913         self.assertTrue(not da1.isMonotonic(True));
10914         self.assertRaises(InterpKernelException,da1.checkMonotonic,True)
10915         self.assertTrue(not da1.isStrictlyMonotonic(False));
10916         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,False)
10917         self.assertTrue(da1.isMonotonic(False));
10918         da1.checkMonotonic(False);
10919         #
10920         da1=DataArrayInt.New([13,9,5,6,5,3,1])
10921         self.assertTrue(not da1.isStrictlyMonotonic(True));
10922         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,True)
10923         self.assertTrue(not da1.isMonotonic(True));
10924         self.assertRaises(InterpKernelException,da1.checkMonotonic,True)
10925         self.assertTrue(not da1.isStrictlyMonotonic(False));
10926         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,False)
10927         self.assertTrue(not da1.isMonotonic(False));
10928         self.assertRaises(InterpKernelException,da1.checkMonotonic,False)
10929         #
10930         da1=DataArrayInt.New([])
10931         self.assertTrue(da1.isStrictlyMonotonic(True));
10932         da1.checkStrictlyMonotonic(True);
10933         self.assertTrue(da1.isMonotonic(True));
10934         da1.checkMonotonic(True);
10935         self.assertTrue(da1.isStrictlyMonotonic(False));
10936         da1.checkStrictlyMonotonic(False);
10937         self.assertTrue(da1.isMonotonic(False));
10938         da1.checkMonotonic(False);
10939         #
10940         da1=DataArrayInt.New([13])
10941         self.assertTrue(da1.isStrictlyMonotonic(True));
10942         da1.checkStrictlyMonotonic(True);
10943         self.assertTrue(da1.isMonotonic(True));
10944         da1.checkMonotonic(True);
10945         self.assertTrue(da1.isStrictlyMonotonic(False));
10946         da1.checkStrictlyMonotonic(False);
10947         self.assertTrue(da1.isMonotonic(False));
10948         da1.checkMonotonic(False);
10949         pass
10950
10951     def testFindAndCorrectBadOriented3DCells1(self):
10952         nbOfDisc=20
10953         vects=([0,0,-1],[0.3,0.7,0.2],[-0.3,0.7,0.2],[-0.3,-0.7,0.2])
10954         #
10955         m0=MEDCouplingUMesh("m",3) ; m0.allocateCells(0); m0.insertNextCell(NORM_TETRA4,[0,1,2,3]); #Well oriented
10956         m1=MEDCouplingUMesh("m",3) ; m1.allocateCells(0); m1.insertNextCell(NORM_PYRA5,[0,1,2,3,4]); #Well oriented
10957         m2=MEDCouplingUMesh("m",3) ; m2.allocateCells(0); m2.insertNextCell(NORM_PENTA6,[0,1,2,3,4,5]); #Well oriented
10958         m3=MEDCouplingUMesh("m",3) ; m3.allocateCells(0); m3.insertNextCell(NORM_HEXA8,[0,1,2,3,4,5,6,7]); #Well oriented
10959         m4=MEDCouplingUMesh("m",3) ; m4.allocateCells(0)
10960         self.assertRaises(InterpKernelException,m4.insertNextCell,NORM_HEXGP12,[0,1,2,3,4,5,6,7,8,9,10,11,12]);
10961         m4.insertNextCell(NORM_HEXGP12,[0,1,2,3,4,5,6,7,8,9,10,11]); #Well oriented
10962         c0=DataArrayDouble([0.,0.,0.,0.,1.,0.,1.,0.,0.,0.,0.,1.],4,3) ; m0.setCoords(c0)
10963         c1=DataArrayDouble([0.,0.,0.,0.,1.,0.,1.,1.,0.,1.,0.,0.,0.,0.,1.],5,3) ; m1.setCoords(c1)
10964         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)
10965         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)
10966         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)
10967         m=MEDCouplingMesh.MergeMeshes([m0,m1,m2,m3,m4])
10968         expected1=DataArrayDouble([0.16666666666666666,0.3333333333333333,0.5,1.,1.])
10969         for v in vects:
10970             for i in xrange(nbOfDisc):
10971                 mm=m.deepCpy()
10972                 mm.rotate([0.,0.,0.],[0.3,0.7,0.2],float(i)/float(nbOfDisc)*2*pi)
10973                 mm2=mm.deepCpy()
10974                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
10975                 self.assertTrue(mm.findAndCorrectBadOriented3DCells().empty())
10976                 self.assertTrue(mm.isEqual(mm2,1e-14))
10977                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
10978                 mm.convertAllToPoly()
10979                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
10980                 pass
10981             pass
10982         #
10983         mOK=m.deepCpy()
10984         m0=MEDCouplingUMesh("m",3) ; m0.allocateCells(0); m0.insertNextCell(NORM_TETRA4,[0,2,1,3]); #Not well oriented
10985         m1=MEDCouplingUMesh("m",3) ; m1.allocateCells(0); m1.insertNextCell(NORM_PYRA5,[0,1,2,3,4]); #Well oriented
10986         m2=MEDCouplingUMesh("m",3) ; m2.allocateCells(0); m2.insertNextCell(NORM_PENTA6,[0,1,2,3,4,5]); #Well oriented
10987         m3=MEDCouplingUMesh("m",3) ; m3.allocateCells(0); m3.insertNextCell(NORM_HEXA8,[0,3,2,1,4,7,6,5]); #Not well oriented
10988         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
10989         m0.setCoords(c0) ; m1.setCoords(c1) ; m2.setCoords(c2) ; m3.setCoords(c3) ; m4.setCoords(c4)
10990         m=MEDCouplingMesh.MergeMeshes([m0,m1,m2,m3,m4])
10991         expected2=DataArrayDouble([-0.16666666666666666,0.3333333333333333,0.5,-1.,-1.])
10992         for v in vects:
10993             for i in xrange(nbOfDisc):
10994                 mm=m.deepCpy()
10995                 mm.rotate([0.,0.,0.],[0.3,0.7,0.2],float(i)/float(nbOfDisc)*2*pi)
10996                 mm2=mm.deepCpy() ; mm3=mm.deepCpy() ; mm3.convertAllToPoly()
10997                 self.assertTrue(mm3.getMeasureField(False).getArray().isEqual(expected2,1e-14))
10998                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected2,1e-14))
10999                 self.assertTrue(mm.findAndCorrectBadOriented3DCells().isEqual(DataArrayInt([0,3,4])))
11000                 mOK.setCoords(mm.getCoords())
11001                 self.assertTrue(mm.isEqual(mOK,1e-14))
11002                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
11003                 mmm=mm.deepCpy()
11004                 self.assertTrue(mmm.findAndCorrectBadOriented3DCells().empty())
11005                 mm.convertAllToPoly()
11006                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
11007                 pass
11008             pass
11009         #
11010         m0=MEDCouplingUMesh("m",3) ; m0.allocateCells(0); m0.insertNextCell(NORM_TETRA4,[0,1,2,3]); #Well oriented
11011         m1=MEDCouplingUMesh("m",3) ; m1.allocateCells(0); m1.insertNextCell(NORM_PYRA5,[0,3,2,1,4]); #Not well oriented
11012         m2=MEDCouplingUMesh("m",3) ; m2.allocateCells(0); m2.insertNextCell(NORM_PENTA6,[0,2,1,3,5,4]); #Not well oriented
11013         m3=MEDCouplingUMesh("m",3) ; m3.allocateCells(0); m3.insertNextCell(NORM_HEXA8,[0,1,2,3,4,5,6,7]); #Well oriented
11014         m4=MEDCouplingUMesh("m",3) ; m4.allocateCells(0); m4.insertNextCell(NORM_HEXGP12,range(12)); #Well oriented
11015         m0.setCoords(c0) ; m1.setCoords(c1) ; m2.setCoords(c2) ; m3.setCoords(c3) ; m4.setCoords(c4)
11016         m=MEDCouplingMesh.MergeMeshes([m0,m1,m2,m3,m4])
11017         expected3=DataArrayDouble([0.16666666666666666,-0.3333333333333333,-0.5,1.,1.])
11018         for v in vects:
11019             for i in xrange(nbOfDisc):
11020                 mm=m.deepCpy()
11021                 mm.rotate([0.,0.,0.],[0.3,0.7,0.2],float(i)/float(nbOfDisc)*2*pi)
11022                 mm2=mm.deepCpy() ; mm3=mm.deepCpy() ; mm3.convertAllToPoly()
11023                 self.assertTrue(mm3.getMeasureField(False).getArray().isEqual(expected3,1e-14))
11024                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected3,1e-14))
11025                 self.assertTrue(mm.findAndCorrectBadOriented3DCells().isEqual(DataArrayInt([1,2])))
11026                 mOK.setCoords(mm.getCoords())
11027                 self.assertTrue(mm.isEqual(mOK,1e-14))
11028                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
11029                 mmm=mm.deepCpy()
11030                 self.assertTrue(mmm.findAndCorrectBadOriented3DCells().empty())
11031                 mm.convertAllToPoly()
11032                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
11033                 pass
11034             pass
11035         pass
11036
11037     def testSwig2CellOrientation1(self):
11038         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)
11039         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]]
11040         for i in xrange(256):
11041             mesh=MEDCouplingUMesh("FluidMesh_1",3);
11042             mesh.allocateCells(0)
11043             conn2=[elt[:] for elt in conn]
11044             code=bin(i)[2:] ; code='0'*(8-len(code))+code
11045             for face,rev in zip(conn2,code):
11046                 if bool(int(rev)):
11047                     face.reverse()
11048                     pass
11049                 pass
11050             conn3=[elt+[-1] for elt in conn2]
11051             conn3=sum(conn3,[])[:-1]
11052             mesh.insertNextCell(NORM_POLYHED,conn3)
11053             mesh.setCoords(coords)
11054             mesh.orientCorrectlyPolyhedrons()
11055             self.assertTrue(mesh.getBarycenterAndOwner().isEqual(DataArrayDouble([-0.10803,0.,0.3385],1,3),1e-12))
11056             pass
11057         pass
11058
11059     def testSwig2CheckConsecutiveCellTypesForMEDFileFrmt1(self):
11060         m1=MEDCouplingUMesh("",2) ; m1.allocateCells(0)
11061         m1.insertNextCell(NORM_QUAD4,[0,1,2,3])
11062         m1.insertNextCell(NORM_TRI3,[0,1,2])
11063         d=DataArrayDouble(4,3) ; d[:]=0.
11064         m1.setCoords(d)
11065         self.assertTrue(m1.checkConsecutiveCellTypes())
11066         self.assertTrue(not m1.checkConsecutiveCellTypesForMEDFileFrmt())
11067         m1.renumberCells([1,0])
11068         self.assertTrue(m1.checkConsecutiveCellTypes())
11069         self.assertTrue(m1.checkConsecutiveCellTypesForMEDFileFrmt())
11070         pass
11071
11072     def testSwig2DAAccumulate1(self):
11073         d=DataArrayInt(10) ; d.iota(0)
11074         self.assertEqual([45],d.accumulate())
11075         self.assertEqual(45,d.accumulate(0))
11076         d=DataArrayInt(30) ; d.iota(0) ; d.rearrange(3)
11077         self.assertEqual([135,145,155],d.accumulate())
11078         self.assertEqual(135,d.accumulate(0))
11079         self.assertEqual(145,d.accumulate(1))
11080         self.assertEqual(155,d.accumulate(2))
11081         d=DataArrayDouble(10) ; d.iota(0.)
11082         self.assertEqual([45.],d.accumulate())
11083         self.assertEqual(45.,d.accumulate(0))
11084         d=DataArrayDouble(30) ; d.iota(0) ; d.rearrange(3)
11085         self.assertEqual([135.,145.,155.],d.accumulate())
11086         self.assertEqual(135.,d.accumulate(0))
11087         self.assertEqual(145.,d.accumulate(1))
11088         self.assertEqual(155.,d.accumulate(2))
11089         pass
11090
11091     def testSwig2UMeshDistanceToMesh1(self):
11092         m=MEDCouplingUMesh("toto",2)
11093         coords=DataArrayDouble([2.3,3.4,5.6,6.5,-4.3,3.2,-9.8,7.6,-5.4],3,3)
11094         m.setCoords(coords)
11095         m.allocateCells(0)
11096         m.insertNextCell(NORM_TRI3,[0,1,2])
11097         a,b=m.distanceToPoint([-0.335,2.27,1.21])
11098         self.assertEqual(0,b)
11099         self.assertAlmostEqual(0.022360988100374124,a,14);
11100         a,b=m.distanceToPoint(DataArrayDouble([-0.335,2.27,1.21],1,3))
11101         self.assertEqual(0,b)
11102         self.assertAlmostEqual(0.022360988100374124,a,14);
11103         a,b=coords.distanceToTuple([-0.335,2.27,1.21])
11104         self.assertAlmostEqual(5.243302871282566,a,14)
11105         self.assertEqual(0,b)
11106         #
11107         m=MEDCouplingUMesh("toto",2)
11108         coords=DataArrayDouble([0.,0.,0., 8.,0.,0., 8.,8.,0., 0.,8.,0.],4,3)
11109         m.setCoords(coords)
11110         m.allocateCells(0)
11111         m.insertNextCell(NORM_QUAD4,[0,1,2,3])
11112         m.checkCoherency2()
11113         self.assertEqual([4,0,1,2,3],m.getNodalConnectivity().getValues())
11114         a,b=m.distanceToPoint([5.,2.,0.1])
11115         self.assertAlmostEqual(0.1,a,14) ; self.assertEqual(0,b)
11116         a,b=m.distanceToPoint([5.,-2.,4.])
11117         self.assertAlmostEqual(sqrt(2*2+4*4),a,14) ; self.assertEqual(0,b)
11118         m.allocateCells(0)
11119         m.insertNextCell(NORM_POLYGON,[0,1,2,3])
11120         m.checkCoherency2()
11121         self.assertEqual([5,0,1,2,3],m.getNodalConnectivity().getValues())
11122         a,b=m.distanceToPoint([11.,3.,4.])
11123         self.assertAlmostEqual(sqrt(3*3+4*4),a,14) ; self.assertEqual(0,b)
11124         a,b=m.distanceToPoint([4.,12.,5.])
11125         self.assertAlmostEqual(sqrt(4*4+5*5),a,14) ; self.assertEqual(0,b)
11126         d=DataArrayDouble([-1.2,3.,2.],1,3)
11127         for elt in d:
11128             a,b=m.distanceToPoint(d)
11129             self.assertAlmostEqual(sqrt(1.2*1.2+2*2),a,14) ; self.assertEqual(0,b)
11130             pass
11131         #
11132         m=MEDCouplingUMesh("toto",1)
11133         coords=DataArrayDouble([0.,0.,4.,0.,0.,4.],3,2) ; m.setCoords(coords)
11134         m.allocateCells(0) ; m.insertNextCell(NORM_SEG2,[0,1]) ; m.insertNextCell(NORM_SEG2,[1,2])
11135         a,b=m.distanceToPoint([-0.1,4.1])
11136         self.assertAlmostEqual(0.14142135623730925,a,14)  # b==1 self.assertEqual(2,c)
11137         a,b=m.distanceToPoint([0.,3.9])
11138         self.assertAlmostEqual(0.07071067811865482,a,14) ; self.assertEqual(1,b) # self.assertEqual(2,c)
11139         pass
11140
11141     def testSwig2NonRegressionPartitionBySpreadZone1(self):
11142         m=MEDCouplingCMesh()
11143         arr=DataArrayDouble(6) ; arr.iota(0.)
11144         m.setCoords(arr,arr,arr)
11145         m=m.buildUnstructured()
11146         mPart=m[50,80,85,87,92,122]
11147         zones=mPart.partitionBySpreadZone()
11148         self.assertEqual(4,len(zones))
11149         self.assertTrue(zones[0].isEqual(DataArrayInt([0])))
11150         self.assertTrue(zones[1].isEqual(DataArrayInt([1,2])))
11151         self.assertTrue(zones[2].isEqual(DataArrayInt([3,4])))
11152         self.assertTrue(zones[3].isEqual(DataArrayInt([5])))
11153         #
11154         n,ni=m.computeNeighborsOfCells()
11155         a,b=MEDCouplingUMesh.ComputeSpreadZoneGraduallyFromSeed(0,n,ni)
11156         self.assertEqual(13,b) ; self.assertEqual(125,len(a)) ; self.assertTrue(a.isIdentity())
11157         a,b=MEDCouplingUMesh.ComputeSpreadZoneGraduallyFromSeed([1],n,ni)
11158         self.assertEqual(12,b) ; self.assertEqual(125,len(a)) ; self.assertTrue(a.isIdentity())
11159         a,b=MEDCouplingUMesh.ComputeSpreadZoneGraduallyFromSeed((2,),n,ni)
11160         self.assertEqual(11,b) ; self.assertEqual(125,len(a)) ; self.assertTrue(a.isIdentity())
11161         a,b=MEDCouplingUMesh.ComputeSpreadZoneGraduallyFromSeed(DataArrayInt([3]),n,ni)
11162         self.assertEqual(12,b) ; self.assertEqual(125,len(a)) ; self.assertTrue(a.isIdentity())
11163         pass
11164
11165     def testSwigUMeshInsertNextCell1(self):
11166         m=MEDCouplingUMesh("toto",2)
11167         #
11168         coords=DataArrayDouble([0.,0.,1.,1.,1.,0.]) ; m.setCoords(coords)
11169         da=DataArrayInt([0,1,2])
11170         m.allocateCells(0)
11171         for i in xrange(5):
11172             m.insertNextCell(NORM_TRI3,da)
11173             pass
11174         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])))
11175         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4,8,12,16,20])))
11176         #
11177         da=DataArrayInt([0,1,2,3])
11178         m.allocateCells(0)
11179         for i in xrange(5):
11180             m.insertNextCell(NORM_TRI3,3,da)
11181             pass
11182         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])))
11183         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4,8,12,16,20])))
11184         #
11185         da=DataArrayInt([0,1])
11186         m.allocateCells(0)
11187         self.assertRaises(InterpKernelException,m.insertNextCell,NORM_TRI3,3,da)
11188         #
11189         da=DataArrayInt([0,1,2,0,1,3,0,1,4,0,1,5,0,1,6],5,3)
11190         m.allocateCells(0)
11191         for t in da:
11192             m.insertNextCell(NORM_TRI3,t)
11193             pass
11194         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])))
11195         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4,8,12,16,20])))
11196         self.assertRaises(InterpKernelException,m.insertNextCell,NORM_TRI3,None)
11197         pass
11198
11199     def testSwigCurveLinearMesh1(self):
11200         m=MEDCouplingCurveLinearMesh("toto")
11201         m.setNodeGridStructure([2,3])
11202         coords=DataArrayDouble([0.,0., 2.,0., 0.,1., 1.9,1.1, 0.3,1.9, 2.2,2.1],6,2)
11203         m.setCoords(coords)
11204         m.checkCoherency()
11205         m0=m.deepCpy()
11206         self.assertTrue(m0.isEqual(m,1e-12))
11207         m.getCoords().setInfoOnComponents(["X [m]","Y [m]"])
11208         self.assertTrue(not m0.isEqual(m,1e-12))
11209         m0=m.deepCpy()
11210         self.assertTrue(m0.isEqual(m,1e-12))
11211         self.assertEqual(m.getNodeGridStructure(),(2,3))
11212         pass
11213
11214     def testSimplexize3(self):
11215         m=MEDCouplingUMesh("toto",3)
11216         m.allocateCells(0)
11217         m.insertNextCell(NORM_TETRA4,[0,1,2,3])
11218         self.assertEqual([NORM_TETRA4],m.getAllGeoTypesSorted())
11219         m.insertNextCell(NORM_HEXA8,[4,5,6,7,8,9,10,11])
11220         self.assertEqual([NORM_TETRA4,NORM_HEXA8],m.getAllGeoTypesSorted())
11221         m.insertNextCell(NORM_HEXA8,[12,13,14,15,16,17,18,19])
11222         self.assertEqual([NORM_TETRA4,NORM_HEXA8],m.getAllGeoTypesSorted())
11223         m.insertNextCell(NORM_TETRA4,[20,21,22,23])
11224         self.assertEqual([NORM_TETRA4,NORM_HEXA8,NORM_TETRA4],m.getAllGeoTypesSorted())
11225         c1=DataArrayDouble([0.,0.,0.,0.,1.,0.,1.,0.,0.,0.,0.,1.],4,3)
11226         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.]
11227         c3=c2+[2.,0.,0.]
11228         c4=c1+[6.,0.,0.]
11229         c=DataArrayDouble.Aggregate([c1,c2,c3,c4])
11230         m.setCoords(c)
11231         m.checkCoherency2()
11232         #
11233         m1=m.deepCpy()
11234         d1=m1.simplexize(PLANAR_FACE_5)
11235         m1.checkCoherency2()
11236         vol1=m1.getMeasureField(ON_CELLS).getArray()
11237         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))
11238         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])
11239         self.assertEqual(m1.getNodalConnectivityIndex().getValues(),[0,5,10,15,20,25,30,35,40,45,50,55,60])
11240         self.assertTrue(d1.isEqual(DataArrayInt([0,1,1,1,1,1,2,2,2,2,2,3])))
11241         #
11242         m2=m.deepCpy()
11243         d2=m2.simplexize(PLANAR_FACE_6)
11244         m2.checkCoherency2()
11245         vol2=m2.getMeasureField(ON_CELLS).getArray()
11246         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))
11247         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])
11248         self.assertEqual(m2.getNodalConnectivityIndex().getValues(),[0,5,10,15,20,25,30,35,40,45,50,55,60,65,70])
11249         self.assertTrue(d2.isEqual(DataArrayInt([0,1,1,1,1,1,1,2,2,2,2,2,2,3])))
11250         pass
11251
11252     def testSwig2CurveLinearMesh2(self):
11253         c=MEDCouplingCMesh()
11254         #2D
11255         arr1=DataArrayDouble([0,1,3,7])
11256         arr2=DataArrayDouble([0,1,1.5])
11257         c.setCoords(arr1,arr2)
11258         u=c.buildUnstructured()
11259         coo=u.getCoords()
11260         cl=MEDCouplingCurveLinearMesh()
11261         cl.setCoords(coo)
11262         cl.setNodeGridStructure([4,3])
11263         cl.checkCoherency2()
11264         li1=[1.,2.,4.,0.5,1.,2.]
11265         self.assertTrue(cl.getMeasureField(False).getArray().isEqual(DataArrayDouble(li1),1e-14))
11266         self.assertTrue(u.getMeasureField(False).getArray().isEqual(DataArrayDouble(li1),1e-14))
11267         li1_1=[0.5,0.5,2.,0.5,5.,0.5,0.5,1.25,2.,1.25,5.,1.25]
11268         self.assertTrue(cl.getBarycenterAndOwner().isEqual(DataArrayDouble(li1_1,6,2),1e-14))
11269         self.assertTrue(u.getBarycenterAndOwner().isEqual(DataArrayDouble(li1_1,6,2),1e-14))
11270         #3D
11271         c.setCoords(arr1,arr2,arr2)
11272         u=c.buildUnstructured()
11273         coo=u.getCoords()
11274         cl=MEDCouplingCurveLinearMesh()
11275         cl.setCoords(coo)
11276         cl.setNodeGridStructure([4,3,3])
11277         cl.checkCoherency2()
11278         li2=[1.,2.,4.,0.5, 1.,2.,0.5,1.,2.,0.25,0.5,1.]
11279         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]
11280         self.assertTrue(cl.getMeasureField(False).getArray().isEqual(DataArrayDouble(li2),1e-14))
11281         self.assertTrue(u.getMeasureField(False).getArray().isEqual(DataArrayDouble(li2),1e-14))
11282         self.assertTrue(cl.getBarycenterAndOwner().isEqual(DataArrayDouble(li2_1,12,3),1e-14))
11283         self.assertTrue(u.getBarycenterAndOwner().isEqual(DataArrayDouble(li2_1,12,3),1e-14))
11284         #1D spaceDim 1
11285         coo=DataArrayDouble(5) ; coo.iota(0.)
11286         coo=coo*coo
11287         cl.setCoords(coo)
11288         cl.setNodeGridStructure([5])
11289         cl.checkCoherency2()
11290         li3=[1.,3.,5.,7.]
11291         li3_1=[0.5,2.5,6.5,12.5]
11292         self.assertTrue(cl.getMeasureField(False).getArray().isEqual(DataArrayDouble(li3),1e-14))
11293         self.assertTrue(cl.buildUnstructured().getMeasureField(False).getArray().isEqual(DataArrayDouble(li3),1e-14))
11294         self.assertTrue(cl.getBarycenterAndOwner().isEqual(DataArrayDouble(li3_1),1e-14))
11295         self.assertTrue(cl.buildUnstructured().getBarycenterAndOwner().isEqual(DataArrayDouble(li3_1),1e-14))
11296         #1D spaceDim 2
11297         coo=DataArrayDouble.Meld(coo,coo)
11298         cl.setCoords(coo)
11299         cl.checkCoherency2()
11300         li4=[sqrt(2.)*elt for elt in [1.,3.,5.,7.]]
11301         li4_1=[0.5,0.5,2.5,2.5,6.5,6.5,12.5,12.5]
11302         self.assertEqual(2,cl.getSpaceDimension())
11303         self.assertEqual(1,cl.getMeshDimension())
11304         self.assertEqual(4,cl.getNumberOfCells())
11305         self.assertEqual(5,cl.getNumberOfNodes())
11306         self.assertTrue(cl.getMeasureField(False).getArray().isEqual(DataArrayDouble(li4),1e-14))
11307         self.assertTrue(cl.buildUnstructured().getMeasureField(False).getArray().isEqual(DataArrayDouble(li4),1e-14))
11308         self.assertTrue(cl.getBarycenterAndOwner().isEqual(DataArrayDouble(li4_1,4,2),1e-14))
11309         self.assertTrue(cl.buildUnstructured().getBarycenterAndOwner().isEqual(DataArrayDouble(li4_1,4,2),1e-14))
11310         pass
11311
11312     def testSwig2CurveLinearMeshNonRegression1(self):
11313         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)
11314         m=MEDCouplingCurveLinearMesh("toto")
11315         m.setCoords(coords)
11316         m.setNodeGridStructure([3,3,3])
11317         #
11318         vol=m.getMeasureField(False).getArray()
11319         self.assertTrue(vol.isEqual(DataArrayDouble([0.11450000709295281, 0.10583334351579375,0.11149999939029423,0.08866666863113633, 0.1404166805123294,0.1250000135352219,0.1270833433481557,0.13258334288001067]),1e-12))
11320         self.assertTrue(vol.isEqual(m.buildUnstructured().getMeasureField(False).getArray(),1e-12))
11321         #
11322         self.assertTrue(m.getBarycenterAndOwner().isEqual(m.buildUnstructured().getBarycenterAndOwner(),1e-12))
11323         pass
11324
11325     def testSwig2NonRegressionDASetSelectedComponents1(self):
11326         da=DataArrayDouble.New([1.,2.,3.,4.,5.,6.],3,2)
11327         dv=DataArrayDouble.New();
11328         dv.alloc(4,4)
11329         dv.fillWithZero()
11330         # da has less tuples than dv
11331         dv.setSelectedComponents(da,[1,0])
11332         #
11333         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))
11334         #
11335         da=DataArrayInt.New([1,2,3,4,5,6],3,2)
11336         dv=DataArrayInt.New();
11337         dv.alloc(4,4)
11338         dv.fillWithZero()
11339         # da has less tuples than dv
11340         dv.setSelectedComponents(da,[1,0])
11341         #
11342         self.assertTrue(dv.isEqual(DataArrayInt([2,1,0,0,4,3,0,0,6,5,0,0,0,0,0,0],4,4)))
11343         pass
11344
11345     def testSwigSetItem3(self):
11346         # 1-2
11347         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11348         d[3]=[1,2]
11349         self.assertTrue(d.isEqual(DataArrayDouble([0,0,0,0,0,0,1,2,0,0,0,0],6,2),1e-14))
11350         # 2-2 false
11351         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11352         d[[5,3,2]]=[1,2]
11353         self.assertTrue(d.isEqual(DataArrayDouble([0,0,0,0,1,2,1,2,0,0,1,2],6,2),1e-14))
11354         # 3-2 false
11355         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11356         d[:]=[1,2]
11357         self.assertTrue(d.isEqual(DataArrayDouble([1,2,1,2,1,2,1,2,1,2,1,2],6,2),1e-14))
11358         # 4-2 false
11359         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11360         d[DataArrayInt([0,3,4])]=[1,2]
11361         self.assertTrue(d.isEqual(DataArrayDouble([1,2,0,0,0,0,1,2,1,2,0,0],6,2),1e-14))
11362         # 5-2
11363         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11364         d[5,1]=[7]
11365         self.assertTrue(d.isEqual(DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,7],6,2),1e-14))
11366         # 6-2 false
11367         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11368         d[[3,5],1]=[7]
11369         self.assertTrue(d.isEqual(DataArrayDouble([0,0,0,0,0,0,0,7,0,0,0,7],6,2),1e-14))
11370         # 7-2 false
11371         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11372         d[:-1:2,1]=[7]
11373         self.assertTrue(d.isEqual(DataArrayDouble([0,7,0,0,0,7,0,0,0,7,0,0],6,2),1e-14))
11374         # 8-2 false
11375         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11376         d[DataArrayInt([0,3,4]),1]=[7]
11377         self.assertTrue(d.isEqual(DataArrayDouble([0,7,0,0,0,0,0,7,0,7,0,0],6,2),1e-14))
11378         # 9-2
11379         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11380         d[3,[1,0]]=[7,8]
11381         self.assertTrue(d.isEqual(DataArrayDouble([0,0,0,0,0,0,8,7,0,0,0,0],6,2),1e-14))
11382         # 10-2 false
11383         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11384         d[[1,3,4],[1,0]]=[7,8]
11385         self.assertTrue(d.isEqual(DataArrayDouble([0,0,8,7,0,0,8,7,8,7,0,0],6,2),1e-14))
11386         # 11-2 false
11387         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11388         d[1::2,[1,0]]=[7,8]
11389         self.assertTrue(d.isEqual(DataArrayDouble([0,0,8,7,0,0,8,7,0,0,8,7],6,2),1e-14))
11390         # 12-2 false
11391         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11392         d[DataArrayInt([1,4]),[1,0]]=[7,8]
11393         self.assertTrue(d.isEqual(DataArrayDouble([0,0,8,7,0,0,0,0,8,7,0,0],6,2),1e-14))
11394         # 13-2
11395         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11396         d[1,:-1]=[9]
11397         self.assertTrue(d.isEqual(DataArrayDouble([0,0,9,0,0,0,0,0,0,0,0,0],6,2),1e-14))
11398         # 14-2 false
11399         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11400         d[[1,4,5],:]=[7,8]
11401         self.assertTrue(d.isEqual(DataArrayDouble([0,0,7,8,0,0,0,0,7,8,7,8],6,2),1e-14))
11402         # 15-2 false
11403         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11404         d[1::2,:]=[3,9]
11405         self.assertTrue(d.isEqual(DataArrayDouble([0,0,3,9,0,0,3,9,0,0,3,9],6,2),1e-14))
11406         # 1-2
11407         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11408         d[3]=[1,2]
11409         self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,0,0,1,2,0,0,0,0],6,2)))
11410         # 2-2 false
11411         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11412         d[[5,3,2]]=[1,2]
11413         self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,1,2,1,2,0,0,1,2],6,2)))
11414         # 3-2 false
11415         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11416         d[:]=[1,2]
11417         self.assertTrue(d.isEqual(DataArrayInt([1,2,1,2,1,2,1,2,1,2,1,2],6,2)))
11418         # 4-2 false
11419         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11420         d[DataArrayInt([0,3,4])]=[1,2]
11421         self.assertTrue(d.isEqual(DataArrayInt([1,2,0,0,0,0,1,2,1,2,0,0],6,2)))
11422         # 5-2
11423         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11424         d[5,1]=[7]
11425         self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,7],6,2)))
11426         # 6-2 false
11427         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11428         d[[3,5],1]=[7]
11429         self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,0,0,0,7,0,0,0,7],6,2)))
11430         # 7-2 false
11431         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11432         d[:-1:2,1]=[7]
11433         self.assertTrue(d.isEqual(DataArrayInt([0,7,0,0,0,7,0,0,0,7,0,0],6,2)))
11434         # 8-2 false
11435         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11436         d[DataArrayInt([0,3,4]),1]=[7]
11437         self.assertTrue(d.isEqual(DataArrayInt([0,7,0,0,0,0,0,7,0,7,0,0],6,2)))
11438         # 9-2
11439         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11440         d[3,[1,0]]=[7,8]
11441         self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,0,0,8,7,0,0,0,0],6,2)))
11442         # 10-2 false
11443         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11444         d[[1,3,4],[1,0]]=[7,8]
11445         self.assertTrue(d.isEqual(DataArrayInt([0,0,8,7,0,0,8,7,8,7,0,0],6,2)))
11446         # 11-2 false
11447         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11448         d[1::2,[1,0]]=[7,8]
11449         self.assertTrue(d.isEqual(DataArrayInt([0,0,8,7,0,0,8,7,0,0,8,7],6,2)))
11450         # 12-2 false
11451         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11452         d[DataArrayInt([1,4]),[1,0]]=[7,8]
11453         self.assertTrue(d.isEqual(DataArrayInt([0,0,8,7,0,0,0,0,8,7,0,0],6,2)))
11454         # 13-2
11455         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11456         d[1,:-1]=[9]
11457         self.assertTrue(d.isEqual(DataArrayInt([0,0,9,0,0,0,0,0,0,0,0,0],6,2)))
11458         # 14-2 false
11459         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11460         d[[1,4,5],:]=[7,8]
11461         self.assertTrue(d.isEqual(DataArrayInt([0,0,7,8,0,0,0,0,7,8,7,8],6,2)))
11462         # 15-2 false
11463         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11464         d[1::2,:]=[3,9]
11465         self.assertTrue(d.isEqual(DataArrayInt([0,0,3,9,0,0,3,9,0,0,3,9],6,2)))
11466         pass
11467
11468     def testSwig2ConvertLinearCellsToQuadratic1(self):
11469         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)
11470         # 2D
11471         m2D=MEDCouplingDataForTest.build2DTargetMesh_1()
11472         m2D.convertLinearCellsToQuadratic(0)
11473         m2D.checkCoherency1()
11474         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])
11475         self.assertEqual(m2D.getNodalConnectivityIndex().getValues(),[0,9,16,23,32,41])
11476         self.assertTrue(m2D.getCoords().isEqual(coordsExp,1e-14))
11477         # 1D
11478         m1D=MEDCouplingDataForTest.build2DTargetMesh_1().buildDescendingConnectivity()[0]
11479         m1D.convertLinearCellsToQuadratic(0)
11480         m1D.checkCoherency1()
11481         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])
11482         self.assertEqual(m1D.getNodalConnectivityIndex().getValues(),[0,4,8,12,16,20,24,28,32,36,40,44,48,52])
11483         self.assertTrue(m1D.getCoords().isEqual(coordsExp,1e-14))
11484         # 3D
11485         m2D=MEDCouplingDataForTest.build2DTargetMesh_1()
11486         m2D.changeSpaceDimension(3)
11487         arr=DataArrayDouble(4);  arr.iota(0) ; z=MEDCouplingCMesh() ; z.setCoords(arr)
11488         m1D=z.buildUnstructured() ; m1D.setCoords(arr.changeNbOfComponents(3,0.))
11489         m1D.getCoords()[:]=m1D.getCoords()[:,[1,2,0]]
11490         cooTmp=m2D.getCoords()[:]
11491         m3D=m2D.buildExtrudedMesh(m1D,0)
11492         m3D.convertLinearCellsToQuadratic(0)
11493         m3D.checkCoherency1()
11494         # check of new m3D content
11495         coordsExp2=[coordsExp.changeNbOfComponents(3,i) for i in xrange(4)]
11496         coordsExp3=[DataArrayDouble.Meld(cooTmp[:,[0,1]],cooTmp[:,2]+(0.5+float(i))) for i in xrange(3)]
11497         coordsExp4=DataArrayDouble.Aggregate([coordsExp2[0],coordsExp3[0],coordsExp2[1],coordsExp3[1],coordsExp2[2],coordsExp3[2],coordsExp2[3]])
11498         c=DataArrayDouble.Aggregate(m3D.getCoords(),coordsExp4)
11499         self.assertEqual(len(coordsExp4),115)
11500         self.assertEqual(len(m3D.getCoords()),115)
11501         a,b=c.findCommonTuples(1e-14)
11502         self.assertEqual(len(b),len(coordsExp4)+1)
11503         e,f=DataArrayInt.BuildOld2NewArrayFromSurjectiveFormat2(2*115,a,b)
11504         self.assertEqual(f,115)
11505         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])))
11506         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()))
11507         self.assertTrue(DataArrayInt([0,21,37,53,74,95,116,132,148,169,190,211,227,243,264,285]).isEqual(m3D.getNodalConnectivityIndex()))
11508         # testing explode3DMeshTo1D
11509         m3DSlice0=m3D[:5]
11510         m3DSlice0.zipCoords()
11511         a,b,c,d,e=m3DSlice0.explode3DMeshTo1D()
11512         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])))
11513         self.assertTrue(c.isEqual(DataArrayInt([0,12,21,30,42,54])))
11514         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])))
11515         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])))
11516         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])))
11517         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])))
11518         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))
11519         pass
11520
11521     def testSwig2DataArrayPushBackValsSilent1(self):
11522         d=DataArrayDouble()
11523         d.pushBackValsSilent([4,5,6])
11524         self.assertTrue(d.isEqual(DataArrayDouble([4.,5.,6.]),1e-14))
11525         e=DataArrayDouble([1,2,3],1,3)
11526         for t in e: d.pushBackValsSilent(t)
11527         self.assertTrue(d.isEqual(DataArrayDouble([4.,5.,6.,1.,2.,3.]),1e-14))
11528         d.pushBackValsSilent(DataArrayDouble([9,10.]))
11529         self.assertTrue(d.isEqual(DataArrayDouble([4.,5.,6.,1.,2.,3.,9.,10.]),1e-14))
11530         d.pushBackValsSilent(DataArrayDouble(0,1))
11531         self.assertTrue(d.isEqual(DataArrayDouble([4.,5.,6.,1.,2.,3.,9.,10.]),1e-14))
11532         e=DataArrayDouble([1,2,3],3,1)
11533         for t in e: d.pushBackValsSilent(t)
11534         self.assertTrue(d.isEqual(DataArrayDouble([4.,5.,6.,1.,2.,3.,9.,10.,1.,2.,3.]),1e-14))
11535         d.pushBackValsSilent(77)
11536         self.assertTrue(d.isEqual(DataArrayDouble([4.,5.,6.,1.,2.,3.,9.,10.,1.,2.,3.,77.]),1e-14))
11537         #
11538         d=DataArrayInt()
11539         d.pushBackValsSilent([4,5,6])
11540         self.assertTrue(d.isEqual(DataArrayInt([4,5,6])))
11541         e=DataArrayInt([1,2,3],1,3)
11542         for t in e: d.pushBackValsSilent(t)
11543         self.assertTrue(d.isEqual(DataArrayInt([4,5,6,1,2,3])))
11544         d.pushBackValsSilent(DataArrayInt([9,10]))
11545         self.assertTrue(d.isEqual(DataArrayInt([4,5,6,1,2,3,9,10])))
11546         d.pushBackValsSilent(DataArrayInt(0,1))
11547         self.assertTrue(d.isEqual(DataArrayInt([4,5,6,1,2,3,9,10])))
11548         e=DataArrayInt([1,2,3],3,1)
11549         for t in e: d.pushBackValsSilent(t)
11550         self.assertTrue(d.isEqual(DataArrayInt([4,5,6,1,2,3,9,10,1,2,3])))
11551         d.pushBackValsSilent(77)
11552         self.assertTrue(d.isEqual(DataArrayInt([4,5,6,1,2,3,9,10,1,2,3,77])))
11553         pass
11554
11555     def testSwig2ConvertLinearCellsToQuadratic2(self):
11556         m2D=MEDCouplingDataForTest.build2DTargetMesh_1()
11557         ret=m2D.convertLinearCellsToQuadratic(1)
11558         self.assertTrue(ret.isIdentity())
11559         self.assertEqual(5,len(ret))
11560         m2D.checkCoherency1()
11561         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)
11562         self.assertTrue(m2D.getCoords().isEqual(coordsExp,1e-14))
11563         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])))
11564         self.assertTrue(m2D.getNodalConnectivityIndex().isEqual(DataArrayInt([0,10,18,26,36,46])))
11565         #
11566         m2D=MEDCouplingDataForTest.build2DTargetMesh_1()[(0,3)] ; m2D.zipCoords()
11567         m2D.changeSpaceDimension(3)
11568         arr=DataArrayDouble(3);  arr.iota(0) ; z=MEDCouplingCMesh() ; z.setCoords(arr)
11569         m1D=z.buildUnstructured() ; m1D.setCoords(arr.changeNbOfComponents(3,0.))
11570         m1D.getCoords()[:]=m1D.getCoords()[:,[1,2,0]]
11571         cooTmp=m2D.getCoords()[:]
11572         m3D=m2D.buildExtrudedMesh(m1D,0)
11573         ret=m3D.convertLinearCellsToQuadratic(1)
11574         self.assertTrue(ret.isIdentity())
11575         self.assertEqual(4,len(ret))
11576         m3D.checkCoherency1()
11577         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)
11578         self.assertTrue(m3D.getCoords().isEqual(coordsExp2,1e-14))
11579         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])))
11580         self.assertTrue(m3D.getNodalConnectivityIndex().isEqual(DataArrayInt([0,28,56,84,112])))
11581         pass
11582
11583     def testSwig2GaussNEIntegral1(self):
11584         m2D=MEDCouplingDataForTest.build2DTargetMesh_1()
11585         m0=m2D[0] ; m0.zipCoords()
11586         m1=m2D[[1,2]] ; m1.zipCoords()
11587         m2=m2D[[3,4]] ; m2.zipCoords()
11588         m0.convertLinearCellsToQuadratic(1)
11589         m1.convertLinearCellsToQuadratic(0)
11590         m2.convertLinearCellsToQuadratic(1)
11591         m=MEDCouplingUMesh.MergeUMeshes([m0,m1,m2])
11592         m.mergeNodes(1e-12)
11593         f=MEDCouplingFieldDouble(ON_GAUSS_NE)
11594         f.setMesh(m)
11595         arr=DataArrayDouble([1.1,2.2,3.3,4.4,5.5,6.6,7.7,8.8,9.9,
11596                              11.1,12.2,13.3,14.4,15.5,16.6,
11597                              21.1,22.2,23.3,24.4,25.5,26.6,
11598                              31.1,32.2,33.3,34.4,35.5,36.6,37.7,38.8,39.9,
11599                              41.1,42.2,43.3,44.4,45.5,46.6,47.7,48.8,49.9])
11600         arr2=DataArrayDouble(len(arr),2)
11601         arr2[:,0]=arr ; arr2[:,1]=arr+100
11602         f.setArray(arr2)
11603         f.checkCoherency()
11604         res=f.integral(False)
11605         # a=25./81 ; b=40./81 ; c=64./81
11606         # p1=0.11169079483905 ; p2=0.0549758718227661
11607         # 1st compo
11608         # 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
11609         # c1=(p2*(11.1+12.2+13.3)+p1*(14.4+15.5+16.6))*0.125/0.4999999999854482 ; c1=1.8014347172346943
11610         # c2=(p2*(21.1+22.2+23.3)+p1*(24.4+25.5+26.6))*0.125/0.4999999999854482 ; c2=3.0514347172346943
11611         # 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
11612         # 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
11613         # c0+c1+c2+c3+c4=27.104258323358287
11614         integExp0=27.104258323358287
11615         self.assertAlmostEqual(res[0],integExp0,13)
11616         # 2nd compo
11617         # 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
11618         # c1=(p2*(111.1+112.2+113.3)+p1*(114.4+115.5+116.6))*0.125/0.4999999999854482 ; c1=14.301434717234699
11619         # c2=(p2*(121.1+122.2+123.3)+p1*(124.4+125.5+126.6))*0.125/0.4999999999854482 ; c2=15.5514347172347
11620         # 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
11621         # 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
11622         # c0+c1+c2+c3+c4=127.10425832335835
11623         integExp1=127.10425832335835
11624         self.assertAlmostEqual(res[1],integExp1,12)
11625         meas=f.getDiscretization().getMeasureField(f.getMesh(),False)
11626         intPerTuple=meas*f
11627         res2=intPerTuple.accumulate()
11628         self.assertAlmostEqual(res2[0],integExp0,13)
11629         self.assertAlmostEqual(res2[1],integExp1,12)
11630         #
11631         meas2=f.buildMeasureField(False)
11632         intPerTuple=meas2*f
11633         res3=intPerTuple.accumulate()
11634         self.assertAlmostEqual(res3[0],integExp0,13)
11635         self.assertAlmostEqual(res3[1],integExp1,12)
11636         #
11637         res4=f.getWeightedAverageValue(False) # res4==res2 because sum of area of mesh is equal to 1
11638         self.assertAlmostEqual(res4[0],integExp0,13)
11639         self.assertAlmostEqual(res4[1],integExp1,12)
11640         #
11641         m.scale([0,0],2.)
11642         #
11643         res5=f.getWeightedAverageValue() # res4==res4 because weighted average is not sensitive to the scaling
11644         self.assertAlmostEqual(res5[0],integExp0,13)
11645         self.assertAlmostEqual(res5[1],integExp1,12)
11646         meas3=f.buildMeasureField(False)
11647         delta=4*meas2.getArray()-meas3.getArray()
11648         delta.abs()
11649         self.assertTrue(delta.isUniform(0.,1e-16))
11650         res6=f.integral(False)
11651         self.assertAlmostEqual(res6[0],4.*integExp0,12)
11652         self.assertAlmostEqual(res6[1],4.*integExp1,11)
11653         pass
11654
11655     def testSwig2SlowDADFindClosestTupleId(self):
11656         nbPts=[10,]
11657         for nbPt in nbPts:
11658             d=DataArrayDouble(nbPt) ; d.iota() ; d*=1./(nbPt-1)
11659             c=MEDCouplingCMesh() ; c.setCoords(d,d) ; m=c.buildUnstructured() ; pts=m.getCoords() ; del m
11660             #
11661             d0=DataArrayDouble((nbPt-1)*(nbPt-1)) ; d0.iota() ; d0*=(3./((nbPt-1)*(nbPt-1))) ; d0=d0.applyFunc("exp(x)-1")
11662             d1=DataArrayDouble((nbPt-1)*(nbPt-1)) ; d1.iota()
11663             d2=DataArrayDouble.Meld(d0,d1) ; d2=d2.fromPolarToCart() ; d2+=[0.32,0.73]
11664             ids=pts.findClosestTupleId(d2)
11665             #print "Start of costly computation"
11666             idsExpected=DataArrayInt(len(d2))
11667             tmp=1e300
11668             for i,elt in enumerate(d2):
11669                 l,m=(pts-elt).magnitude().getMinValue()
11670                 idsExpected.setIJSilent(i,0,m)
11671                 if l<tmp:
11672                     tmp=l ; tmp1=m ; tmp2=i
11673                     pass
11674                 pass
11675             #print "End of costly computation"
11676             self.assertTrue(idsExpected.isEqual(ids))
11677             a,b,c=pts.minimalDistanceTo(d2)
11678             self.assertEqual(tmp,a)
11679             self.assertEqual(tmp1,b)
11680             self.assertEqual(tmp2,c)
11681             #
11682             l=[d2[:,i] for i in [0,1]]
11683             for elt in l: elt.reverse()
11684             d2i=DataArrayDouble.Meld(l)
11685             ids1=pts.findClosestTupleId(d2i)
11686             idsExpectedI=idsExpected.deepCpy() ; idsExpectedI.reverse()
11687             self.assertTrue(idsExpectedI.isEqual(ids1))
11688             #
11689             l=[pts[:,i] for i in [0,1]]
11690             for elt in l: elt.reverse()
11691             ptsi=DataArrayDouble.Meld(l)
11692             ids2=ptsi.findClosestTupleId(d2)
11693             idsExpected2=nbPt*nbPt-1-ids
11694             self.assertTrue(idsExpected2.isEqual(ids2))
11695             #
11696             ids3=ptsi.findClosestTupleId(d2i)
11697             idsExpected3=idsExpected2.deepCpy() ; idsExpected3.reverse()
11698             self.assertTrue(idsExpected3.isEqual(ids3))
11699             pass
11700
11701     def testSwig2DataArrayAsciiChar1(self):
11702         alpha=DataArrayInt(26) ; alpha.iota(ord("A"))
11703         d=DataArrayAsciiChar(alpha.getValues(),2,13)
11704         d.setInfoOnComponents(["c%i"%(v) for v in xrange(13)])
11705         self.assertEqual('ABCDEFGHIJKLM',d.getTuple(0))
11706         self.assertEqual('NOPQRSTUVWXYZ',d.getTuple(1))
11707         self.assertEqual(2,d.getNumberOfTuples())
11708         self.assertEqual(26,d.getNbOfElems())
11709         self.assertEqual(13,d.getNumberOfComponents())
11710         dd=d.deepCpy()
11711         self.assertTrue(d.isEqual(dd))
11712         dd.setIJ(0,3,'d')
11713         self.assertTrue(not d.isEqual(dd))
11714         d.setIJ(0,3,ord('d'))
11715         self.assertTrue(d.isEqual(dd))
11716         d.rearrange(1)
11717         d.reserve(20)
11718         self.assertEqual(20,d.getNumberOfTuples())
11719         self.assertEqual(20,d.getNbOfElems())
11720         self.assertEqual(1,d.getNumberOfComponents())
11721         #
11722         d0=DataArrayAsciiChar([ord('a')],1,1)
11723         self.assertEqual('a',d0.asciiCharValue())
11724         self.assertTrue(not d0.empty())
11725         d0=DataArrayAsciiChar(0,3)
11726         self.assertTrue(d0.empty())
11727         d.pushBackSilent("U") ; d.pushBackSilent("V") ; d.pushBackSilent("W")
11728         self.assertEqual("W",d.popBackSilent())
11729         d.rearrange(2)
11730         self.assertEqual(['AB','Cd','EF','GH','IJ','KL','MN','OP','QR','ST','UV'],d.toStrList())
11731         d.fillWithZero()
11732         self.assertEqual(11*[''],d.toStrList())
11733         d.fillWithValue('T')
11734         self.assertEqual(11*["TT"],d.toStrList())
11735         d.rearrange(1)
11736         self.assertTrue(d.isUniform("T"))
11737         d.rearrange(2)
11738         #
11739         dd.rearrange(2)
11740         dd2=dd.deepCpy()
11741         dd.renumberInPlace([3,1,2,4,0,11,10,9,8,7,5,12,6])
11742         self.assertEqual(dd.toStrList(),['IJ','Cd','EF','AB','GH','UV','YZ','ST','QR','OP','MN','KL','WX'])
11743         dd.renumberInPlaceR([3,1,2,4,0,11,10,9,8,7,5,12,6])
11744         self.assertEqual(['AB','Cd','EF','GH','IJ','KL','MN','OP','QR','ST','UV','WX','YZ'],dd.toStrList())
11745         e=dd.renumber([3,1,2,4,0,11,10,9,8,7,5,12,6])
11746         self.assertEqual(e.toStrList(),['IJ','Cd','EF','AB','GH','UV','YZ','ST','QR','OP','MN','KL','WX'])
11747         e=dd.renumberR([3,1,2,4,0,11,10,9,8,7,5,12,6])
11748         self.assertEqual(e.toStrList(),['GH','Cd','EF','IJ','AB','WX','UV','ST','QR','OP','KL','YZ','MN'])
11749         e=dd.renumberAndReduce([1,1,1,1,1,1,1,2,0,0,0,0,0],3)
11750         self.assertEqual(['YZ','MN','OP'],e.toStrList())
11751         self.assertEqual(['GH','IJ'],dd.selectByTupleIdSafe([3,4]).toStrList())
11752         self.assertEqual(['AB','GH','MN','ST','YZ'],dd.selectByTupleId2(0,13,3).toStrList())
11753         dd3=dd.changeNbOfComponents(3,"G")
11754         self.assertEqual(['ABG','CdG','EFG','GHG','IJG','KLG','MNG','OPG','QRG','STG','UVG','WXG','YZG'],dd3.toStrList())
11755         dd3.rearrange(1) ; self.assertEqual("G",dd3.back()) ; dd3.rearrange(3)
11756         self.assertTrue(dd3.changeNbOfComponents(2,"\0").isEqual(dd))
11757         self.assertEqual(len(dd),13)
11758         d=DataArrayAsciiChar(13,2) ; d.fillWithValue('Y')
11759         dd3.meldWith(d)
11760         self.assertEqual(['ABGYY','CdGYY','EFGYY','GHGYY','IJGYY','KLGYY','MNGYY','OPGYY','QRGYY','STGYY','UVGYY','WXGYY','YZGYY'],dd3.toStrList())
11761         self.assertEqual("d",dd3.getIJ(0,6))
11762         self.assertRaises(InterpKernelException,dd3.getIJSafe,0,6)
11763         self.assertEqual("d",dd3.getIJSafe(1,1))
11764         dd3.rearrange(1)
11765         e=dd3.getIdsEqual("Y")
11766         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])))
11767         e=dd3.getIdsNotEqual("Y")
11768         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])))
11769         self.assertEqual(("d",6),dd3.getMaxValue())
11770         self.assertEqual(("A",0),dd3.getMinValue())
11771         self.assertEqual(26,dd3.search("LGYYM"))
11772         self.assertEqual(-1,dd3.search("LGYYN"))
11773         dd3.rearrange(5)
11774         self.assertEqual(7,dd3.locateTuple("OPGYY"))
11775         self.assertTrue("OPGYY" in dd3)
11776         self.assertEqual(7,dd3.index("OPGYY"))
11777         self.assertEqual(-1,dd3.locateTuple("OPGYP"))
11778         dd3.rearrange(1)
11779         self.assertEqual(2,dd3.locateValue("OPGYY"))
11780         self.assertTrue(dd3.presenceOfValue("OPGYY"))
11781         self.assertTrue("O" in dd3)
11782         self.assertTrue(not dd3.presenceOfValue("z"))
11783         self.assertTrue("z" not in dd3)
11784         dd3.rearrange(5)
11785         l=list(dd3)
11786         self.assertEqual([e.buildDAAsciiChar().toStrList()[0] for e in list(dd3)],dd3.toStrList())
11787         dd3.reAlloc(5)
11788         dd4=DataArrayChar.Aggregate(dd3,dd3)
11789         self.assertEqual(['ABGYY','CdGYY','EFGYY','GHGYY','IJGYY','ABGYY','CdGYY','EFGYY','GHGYY','IJGYY'],dd4.toStrList())
11790         dd5=DataArrayChar.Aggregate([dd4,dd3,dd4])
11791         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())
11792         # getitem,__iter__,__setitem__
11793         a=list(dd3)
11794         self.assertEqual("ABGYY",str(a[0]))
11795         dd4=dd3[::2]
11796         self.assertEqual(['ABGYY','EFGYY','IJGYY'],dd4.toStrList())
11797         dd4=dd3[(3,2,1)]
11798         self.assertEqual(['GHGYY','EFGYY','CdGYY'],dd4.toStrList())
11799         dd4=dd3[:]
11800         dd4[::2]=["12","345","67890"]
11801         self.assertEqual(['12   ','CdGYY','345  ','GHGYY','67890'],dd4.toStrList())
11802         dd4=dd3[:]
11803         dd4[[1,2]]=" "
11804         self.assertEqual(['ABGYY','     ','     ','GHGYY','IJGYY'],dd4.toStrList())
11805         dd4=dd3[:]
11806         dd4[4]='12345'
11807         self.assertEqual(['ABGYY','CdGYY','EFGYY','GHGYY','12345'],dd4.toStrList())
11808         dd4[0]=dd4[1]
11809         self.assertEqual(['CdGYY','CdGYY','EFGYY','GHGYY','12345'],dd4.toStrList())
11810         dd4=DataArrayAsciiChar(["abc","de","fghi"])
11811         self.assertEqual(['abc ','de  ','fghi'],dd4.toStrList())
11812         dd4=DataArrayAsciiChar(["abc","de","fghi"],"t")
11813         self.assertEqual(['abct','dett','fghi'],dd4.toStrList())
11814         pass
11815
11816     def testSwig2GaussNELocalizationOfDiscValues(self):
11817         m=MEDCouplingDataForTest.build2DTargetMesh_3()[[0,1,3,4,5,6,8,9]] # suppression of polygons
11818         f=MEDCouplingFieldDouble(ON_GAUSS_NE)
11819         f.setMesh(m)
11820         loc=f.getLocalizationOfDiscr()
11821         self.assertEqual(42,len(loc))
11822         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))
11823         m.changeSpaceDimension(3)
11824         m.getCoords()[:,2]=7.
11825         loc=f.getLocalizationOfDiscr()
11826         self.assertEqual(42,len(loc))
11827         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))
11828         pass
11829
11830     def testSwig2GaussMeasureAndIntegral(self):
11831         ft=MEDCouplingDataForTest.buildFieldOnGauss_1()
11832         mea=ft.buildMeasureField(False)
11833         mea.checkCoherency()
11834         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))
11835         f=MEDCouplingFieldDouble(ft)
11836         arr=DataArrayDouble(126,2)
11837         arr[:,0]=range(126)
11838         arr[:,1]=range(126)
11839         arr[:,1]+=1000
11840         f.setArray(arr)
11841         f.checkCoherency()
11842         self.assertTrue(DataArrayDouble(f.integral(False)).isEqual(DataArrayDouble([-211.66121638700983,-4863.9563007698835]),1e-11))
11843         self.assertTrue(DataArrayDouble(f.getWeightedAverageValue()).isEqual(DataArrayDouble([45.4960858131136,1045.496085813114]),1e-11))
11844         self.assertTrue(DataArrayDouble(f.normL1()).isEqual(DataArrayDouble([45.49608581311362,1045.496085813114]),1e-11))
11845         self.assertTrue(DataArrayDouble(f.normL2()).isEqual(DataArrayDouble([58.16846378340898,1046.1241521947334]),1e-11))
11846         pass
11847
11848     def testSwig2FieldDiscretizationComputeMeshRestrictionFromTupleIds1(self):
11849         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1()
11850         f=MEDCouplingFieldDouble(ON_GAUSS_NE)
11851         f.setMesh(m)
11852         a,b=f.getDiscretization().computeMeshRestrictionFromTupleIds(f.getMesh(),[3,4,5,6,8,9,10,14,15,16,17])
11853         self.assertTrue(a.isEqual(DataArrayInt([1,4])))
11854         self.assertTrue(b.isEqual(DataArrayInt([4,5,6,14,15,16,17])))
11855         a,b=f.getDiscretization().computeMeshRestrictionFromTupleIds(f.getMesh(),DataArrayInt([0,1,2,3,5,7,8,9,10,11,12,18]))
11856         self.assertTrue(a.isEqual(DataArrayInt([0,2])))
11857         self.assertTrue(b.isEqual(DataArrayInt([0,1,2,3,7,8,9])))
11858         #
11859         f=MEDCouplingFieldDouble(ON_CELLS)
11860         f.setMesh(m)
11861         a,b=f.getDiscretization().computeMeshRestrictionFromTupleIds(f.getMesh(),[3,4])
11862         self.assertTrue(a.isEqual(DataArrayInt([3,4])))
11863         self.assertTrue(b.isEqual(DataArrayInt([3,4])))
11864         #
11865         f=MEDCouplingFieldDouble(ON_NODES)
11866         f.setMesh(m)
11867         a,b=f.getDiscretization().computeMeshRestrictionFromTupleIds(f.getMesh(),[1,2,3,4])
11868         self.assertTrue(a.isEqual(DataArrayInt([1])))
11869         self.assertTrue(b.isEqual(DataArrayInt([1,2,4])))
11870         #
11871         f=MEDCouplingDataForTest.buildFieldOnGauss_1()
11872         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])
11873         self.assertTrue(a.isEqual(DataArrayInt([0,11,12,18,35])))
11874         self.assertTrue(b.isEqual(DataArrayInt([0,11,12,13,14,15,36,37,38,117,118,119,120,121,122,123,124,125])))
11875         #
11876         d=DataArrayInt([0,3,7,9,15,18])
11877         e=DataArrayInt([0,1,2,3,7,8,15,16,17])
11878         a,b=d.searchRangesInListOfIds(e)
11879         self.assertTrue(a.isEqual(DataArrayInt([0,2,4])))
11880         self.assertTrue(b.isEqual(DataArrayInt([0,1,2,7,8,15,16,17])))
11881         pass
11882
11883     def testSwig2BigMem(self):
11884         if MEDCouplingSizeOfVoidStar()==64:
11885             d=DataArrayAsciiChar(223456789,16)
11886             self.assertTrue(d.getNumberOfTuples(),223456789)
11887             self.assertTrue(d.getNumberOfComponents(),16)
11888             d.setIJ(223456788,5,"r")
11889             self.assertTrue(d.getIJ(223456788,5),'r')
11890             d[223456787]="1234567890123456"
11891             self.assertTrue(d[223456787],'1234567890123456')
11892             self.assertRaises(InterpKernelException,d.rearrange,1)# fails because it would lead to nb of tuples > 2147483647
11893             pass
11894         pass
11895
11896     def testSwig2DAReverseMultiCompo1(self):
11897         d=DataArrayDouble(6,2)
11898         d[:,0]=range(6)
11899         d[:,1]=range(10,16)
11900         d.reverse()
11901         self.assertTrue(d.isEqual(DataArrayDouble([5.,15.,4.,14.,3.,13.,2.,12.,1.,11.,0.,10.],6,2),1e-14))
11902         d=DataArrayDouble(7,2)
11903         d[:,0]=range(7)
11904         d[:,1]=range(10,17)
11905         d.reverse()
11906         self.assertTrue(d.isEqual(DataArrayDouble([6.,16.,5.,15.,4.,14.,3.,13.,2.,12.,1.,11.,0.,10.],7,2),1e-14))
11907         #
11908         d=DataArrayInt(6,2)
11909         d[:,0]=range(6)
11910         d[:,1]=range(10,16)
11911         d.reverse()
11912         self.assertTrue(d.isEqual(DataArrayInt([5,15,4,14,3,13,2,12,1,11,0,10],6,2)))
11913         d=DataArrayInt(7,2)
11914         d[:,0]=range(7)
11915         d[:,1]=range(10,17)
11916         d.reverse()
11917         self.assertTrue(d.isEqual(DataArrayInt([6,16,5,15,4,14,3,13,2,12,1,11,0,10],7,2)))
11918         pass
11919
11920     def testSwigDAPow1(self):
11921         d=DataArrayInt(10)
11922         d.iota(0)
11923         d1=d.deepCpy()
11924         d.setIJ(2,0,-2)
11925         self.assertTrue((d**2).isEqual(DataArrayInt([0,1,4,9,16,25,36,49,64,81])))
11926         self.assertTrue((d**3).isEqual(DataArrayInt([0,1,-8,27,64,125,216,343,512,729])))
11927         for elt in [d]:
11928             elt**=2
11929             pass
11930         self.assertTrue(d.isEqual(DataArrayInt([0,1,4,9,16,25,36,49,64,81])))
11931         self.assertTrue((d1[:4]**d1[:4]).isEqual(DataArrayInt([1,1,4,27])))
11932         self.assertTrue((3**d1[:4]).isEqual(DataArrayInt([1,3,9,27])))
11933         d2=d1[:4]
11934         d2**=d2
11935         self.assertTrue(d2.isEqual(DataArrayInt([1,1,4,27])))
11936         self.assertRaises(InterpKernelException,d2.__pow__,-1)#non supporting negative pow in DataArrayInt.__pow__
11937         self.assertRaises(InterpKernelException,d2.__ipow__,-1)#non supporting negative pow in DataArrayInt.__pow__
11938         #
11939         d=DataArrayDouble(10)
11940         d.iota(0)
11941         d1=d.deepCpy()
11942         d.setIJ(2,0,-2.)
11943         self.assertTrue((d**2).isEqual(DataArrayDouble([0,1,4,9,16,25,36,49,64,81]),1e-12))
11944         self.assertTrue((d**3).isEqual(DataArrayDouble([0,1,-8,27,64,125,216,343,512,729]),1e-12))
11945         self.assertRaises(InterpKernelException,d.__pow__,3.1)#3.1 is double not integer -> not supporting negative values in d
11946         for elt in [d]:
11947             elt**=2
11948             pass
11949         self.assertTrue(d.isEqual(DataArrayDouble([0,1,4,9,16,25,36,49,64,81]),1e-12))
11950         self.assertTrue((d1[:4]**d1[:4]).isEqual(DataArrayDouble([1,1,4,27]),1e-12))
11951         self.assertTrue((3**d1[:4]).isEqual(DataArrayDouble([1,3,9,27]),1e-12))
11952         d2=d1[:4]
11953         d2**=d2
11954         self.assertTrue(d2.isEqual(DataArrayDouble([1,1,4,27]),1e-12))
11955         d2**=-0.5
11956         self.assertTrue(d2.isEqual(DataArrayDouble([1,1,1./2,1./sqrt(27.)]),1e-14))
11957         d3=-1./d1[1:5]
11958         self.assertTrue((3**d3).isEqual(DataArrayDouble([0.3333333333333333,0.5773502691896257,0.6933612743506348,0.7598356856515925]),1e-14))
11959         d4=d3.deepCpy() ; d4.abs()
11960         self.assertTrue((d4**d3).isEqual(DataArrayDouble([1.,sqrt(2.),1.4422495703074083,sqrt(2.)]),1e-14))
11961         d4**=d3
11962         self.assertTrue(d4.isEqual(DataArrayDouble([1.,sqrt(2.),1.4422495703074083,sqrt(2.)]),1e-14))
11963         pass
11964
11965     def testSwig2Baryenter3DForCellsWithVolumeZero1(self):
11966         coo=DataArrayDouble([0.,0.,0.,1.,0.,0.,0.,1.,0.],3,3)
11967         m2=MEDCouplingUMesh("mesh",2)
11968         m2.allocateCells(0)
11969         m2.insertNextCell(NORM_POLYGON,[0,1,2])
11970         m2.setCoords(coo)
11971         m2.checkCoherency1()
11972         #
11973         coo2=DataArrayDouble([0.,0.,0.,0.,0.,0.,0.,0.,2.],3,3)
11974         m1=MEDCouplingUMesh("mesh",1)
11975         m1.allocateCells(0)
11976         m1.insertNextCell(NORM_SEG2,[0,1])
11977         m1.insertNextCell(NORM_SEG2,[1,2])
11978         m1.setCoords(coo2)
11979         m1.checkCoherency1()
11980         #
11981         m3=m2.buildExtrudedMesh(m1,0)
11982         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
11983         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))
11984         m4,a,b,c,d=m3.buildDescendingConnectivity()
11985         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))
11986         pass
11987
11988     def testSwigRepr1(self):
11989         d=DataArrayDouble()
11990         self.assertTrue(len(d.__repr__())<120)
11991         d.alloc(1000,0) ; self.assertTrue(len(d.__repr__())<100)
11992         for i in xrange(100):
11993             d.alloc(i,1) ; d.iota(1.1234567890123456) ; d*=1e123
11994             self.assertTrue(len(d.__repr__())<500)
11995             pass
11996         for i in xrange(50):
11997             d.alloc(i,2) ; d.rearrange(1) ; d.iota(1.1234567890123456) ; d.rearrange(2) ; d*=1e123
11998             self.assertTrue(len(d.__repr__())<500)
11999             pass
12000         d.alloc(4000,1) ; d.iota() ; self.assertTrue(len(d.__repr__())<500)
12001         for i in xrange(2,4):
12002             d.alloc(362880,1) ; d.iota() ; d.rearrange(i) ; self.assertTrue(len(d.__repr__())<500)
12003             pass
12004         d.alloc(0,9)
12005         self.assertTrue(len(d.__repr__())<120)
12006         #
12007         d=DataArrayInt()
12008         self.assertTrue(len(d.__repr__())<100)
12009         d.alloc(1000,0) ; self.assertTrue(len(d.__repr__())<100)
12010         for i in xrange(100):
12011             d.alloc(i,1) ; d.iota(123456789)
12012             self.assertTrue(len(d.__repr__())<500)
12013             pass
12014         for i in xrange(50):
12015             d.alloc(i,2) ; d.rearrange(1) ; d.iota(123456789) ; d.rearrange(2)
12016             self.assertTrue(len(d.__repr__())<500)
12017             pass
12018         d.alloc(4000,1) ; d.iota() ; self.assertTrue(len(d.__repr__())<500)
12019         for i in xrange(2,10):
12020             d.alloc(362880,1) ; d.iota() ; d.rearrange(i) ; self.assertTrue(len(d.__repr__())<500)
12021             pass
12022         d.alloc(0,9)
12023         self.assertTrue(len(d.__repr__())<100)
12024         #
12025         d=DataArrayAsciiChar()
12026         d.alloc(1000,0) ; self.assertTrue(len(d.__repr__())<100)
12027         d.alloc(2,16) ; d[:]='1234567890ABCDEF'
12028         self.assertTrue(len(d.__repr__())<500)
12029         d.alloc(2000,16) ; d[:]='1234567890ABCDEF'
12030         self.assertTrue(len(d.__repr__())<500)
12031         d.alloc(0,16) ; d[:]='1234567890ABCDEF'
12032         self.assertTrue(len(d.__repr__())<120)
12033         #
12034         d=DataArrayByte()
12035         self.assertTrue(len(d.__repr__())<100)
12036         d.alloc(1000,0) ; self.assertTrue(len(d.__repr__())<100)
12037         d.alloc(0,16) ; self.assertTrue(len(d.__repr__())<100)
12038         d.alloc(5,1) ; d.fillWithValue(127)
12039         self.assertTrue(len(d.__repr__())<200)
12040         d.alloc(1000,1) ; d.fillWithValue(127)
12041         self.assertTrue(len(d.__repr__())<500)
12042         d.alloc(1000,3) ; d.fillWithValue(127)
12043         self.assertTrue(len(d.__repr__())<500)
12044         pass
12045
12046     def testSwig2MeshComputeIsoBarycenterOfNodesPerCell1(self):
12047         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)
12048         m=MEDCouplingUMesh.New("toto",3)
12049         m.allocateCells(0)
12050         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])
12051         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])
12052         m.setCoords(coo)
12053         m.checkCoherency1()
12054         #
12055         dReference=DataArrayDouble([(34.900130952189848,0.,200),(17.450065476094931,30.2244,200.)])
12056         self.assertTrue(m.computeIsoBarycenterOfNodesPerCell().isEqual(dReference,1e-12))
12057         m.getNodalConnectivity().setIJ(87,0,24)
12058         self.assertRaises(InterpKernelException,m.computeIsoBarycenterOfNodesPerCell)
12059         m.getNodalConnectivity().setIJ(87,0,-2)
12060         self.assertRaises(InterpKernelException,m.computeIsoBarycenterOfNodesPerCell)
12061         m.getNodalConnectivity().setIJ(87,0,21)# put again 21 as at the beginning
12062         #
12063         self.assertTrue(m.unPolyze())
12064         self.assertEqual([NORM_HEXGP12],m.getAllGeoTypes())
12065         self.assertTrue(m.computeIsoBarycenterOfNodesPerCell().isEqual(dReference,1e-12))
12066         m.getNodalConnectivity().setIJ(25,0,24)
12067         self.assertRaises(InterpKernelException,m.computeIsoBarycenterOfNodesPerCell)
12068         m.getNodalConnectivity().setIJ(25,0,-1)
12069         self.assertRaises(InterpKernelException,m.computeIsoBarycenterOfNodesPerCell)
12070         pass
12071
12072     def testSwig2NonRegressionBugDescHexa20(self):
12073         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)
12074         m=MEDCouplingUMesh('mesh',3)
12075         m.allocateCells(0)
12076         m.insertNextCell(NORM_HEXA20,[0,3,5,1,12,18,16,14,7,4,6,2,19,17,15,13,8,11,10,9])
12077         m.setCoords(coo)
12078         m.checkCoherency1()
12079         #
12080         a,b,c,d,e=m.buildDescendingConnectivity()
12081         m2=MEDCouplingUMesh('mesh',2)
12082         m2.allocateCells(0)
12083         m2.setCoords(coo)
12084         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]]
12085         for i in xrange(6):
12086             m2.insertNextCell(NORM_QUAD8,conn2[i])
12087             pass
12088         self.assertTrue(m2.isEqual(a,1e-12))
12089         self.assertTrue(b.isEqual(DataArrayInt([0,1,2,3,4,5])))
12090         self.assertTrue(c.isEqual(DataArrayInt([0,6])))
12091         self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,0,0])))
12092         self.assertTrue(e.isEqual(DataArrayInt([0,1,2,3,4,5,6])))
12093         #
12094         m.convertQuadraticCellsToLinear() ; m.zipCoords()
12095         m.convertLinearCellsToQuadratic(1)
12096         #
12097         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)
12098         m3=MEDCouplingUMesh("mesh",3)
12099         m3.allocateCells(1)
12100         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])
12101         m3.setCoords(coo2)
12102         self.assertTrue(m3.isEqual(m,1e-12))
12103         #
12104         a,b,c,d,e=m.buildDescendingConnectivity()
12105         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]]
12106         m4=MEDCouplingUMesh("mesh",2)
12107         m4.allocateCells(0)
12108         for i in xrange(6):
12109             m4.insertNextCell(NORM_QUAD9,conn4[i])
12110             pass
12111         m4.setCoords(coo2)
12112         self.assertTrue(m4.isEqual(a,1e-12))
12113         self.assertTrue(b.isEqual(DataArrayInt([0,1,2,3,4,5])))
12114         self.assertTrue(c.isEqual(DataArrayInt([0,6])))
12115         self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,0,0])))
12116         self.assertTrue(e.isEqual(DataArrayInt([0,1,2,3,4,5,6])))
12117         pass
12118
12119     def testSwigAdvGauss(self):
12120         f=MEDCouplingFieldTemplate(ON_GAUSS_PT)
12121         f.setDiscretization(None)
12122         f.__repr__() ; f.__str__()
12123         #
12124         f=MEDCouplingFieldTemplate(ON_GAUSS_PT)
12125         d=f.getDiscretization()
12126         i=DataArrayInt() ; i.alloc(10,1) ; i.iota(1)
12127         d.setArrayOfDiscIds(i)
12128         f.__repr__() ; f.__str__()
12129         i2=d.getArrayOfDiscIds()
12130         self.assertEqual(i.__repr__(),i2.__repr__())
12131         #
12132         f=MEDCouplingFieldDouble(ON_GAUSS_PT)
12133         f.setDiscretization(None)
12134         f.__repr__() ; f.__str__()
12135         #
12136         f=MEDCouplingFieldDouble(ON_GAUSS_PT)
12137         d=f.getDiscretization()
12138         i=DataArrayInt() ; i.alloc(10,1) ; i.iota(1)
12139         d.setArrayOfDiscIds(i)
12140         f.__repr__() ; f.__str__()
12141         #
12142         gl=MEDCouplingGaussLocalization(NORM_SEG2,[0,1],[0.5],[1.])
12143         gl.setWeights([3.])
12144         gl.__repr__() ; gl.__str__()
12145         gl=MEDCouplingGaussLocalization(NORM_ERROR)
12146         gl.setWeights([3.])
12147         gl.__repr__() ; gl.__str__()
12148         pass
12149
12150     def testSwig2NonRegressionBugSubstractInPlaceDM(self):
12151         m0=MEDCouplingCMesh()
12152         arr=DataArrayDouble(5,1) ; arr.iota(0.)
12153         m0.setCoords(arr,arr)
12154         m0=m0.buildUnstructured()
12155         m00=m0[::2] ; m00.simplexize(0) ; m01=m0[1::2]
12156         m0=MEDCouplingUMesh.MergeUMeshes([m00,m01])
12157         m0.getCoords()[:]*=1/4.
12158         m0.setName("mesh")
12159         #
12160         NodeField=MEDCouplingFieldDouble(ON_NODES,ONE_TIME) ; NodeField.setTime(5.6,5,6) ; NodeField.setMesh(m0)
12161         NodeField.setName("NodeField")
12162         NodeField.fillFromAnalytic(1,"exp(-((x-1)*(x-1)+(y-1)*(y-1)))") ; NodeField.getArray().setInfoOnComponent(0,"powernode [W]")
12163         proc0=m0.getCellsInBoundingBox([(0.,0.4),(0.,0.4)],1e-10)
12164         proc1=proc0.buildComplement(m0.getNumberOfCells())
12165         #
12166         NodeField0=NodeField[proc0] ; NodeField0.getMesh().setName(m0.getName())
12167         NodeField1=NodeField[proc1] ; NodeField1.getMesh().setName(m0.getName())
12168         #
12169         NodeField_read=MEDCouplingFieldDouble.MergeFields([NodeField0,NodeField1])
12170         NodeField_read.mergeNodes(1e-10)
12171         NodeFieldCpy=NodeField.deepCpy()
12172         NodeFieldCpy.mergeNodes(1e-10)
12173         NodeField.checkCoherency()
12174         self.assertTrue(not NodeField.getArray().isUniform(0.,1e-12))
12175         NodeField.substractInPlaceDM(NodeField_read,10,1e-12)
12176         self.assertTrue(NodeField.getArray().isUniform(0.,1e-12))
12177         pass
12178
12179     def testSwigFieldOperationOpen1(self):
12180         ## MEDCouplingFieldDouble.__add__
12181         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12182         f=MEDCouplingFieldDouble(ON_CELLS)
12183         f.setMesh(m)
12184         arr=DataArrayDouble(5,2)
12185         arr[:,0]=range(5) ; arr[:,1]=2*arr[:,0]
12186         f2=f.clone(True)
12187         self.assertRaises(InterpKernelException,f.__add__,2)
12188         self.assertRaises(InterpKernelException,f.__add__,range(5))
12189         self.assertRaises(InterpKernelException,f.__add__,arr)
12190         self.assertRaises(InterpKernelException,f.__add__,f2)
12191         f.setArray(DataArrayDouble())
12192         self.assertRaises(InterpKernelException,f.__add__,2)
12193         self.assertRaises(InterpKernelException,f.__add__,range(5))
12194         self.assertRaises(InterpKernelException,f.__add__,arr)
12195         self.assertRaises(InterpKernelException,f.__add__,f2)
12196         self.assertRaises(InterpKernelException,f.__getitem__,(slice(None),0))
12197         f.getArray().alloc(5,2)
12198         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
12199         ff=f+2
12200         ff.checkCoherency()
12201         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(2,9),(3,10),(4,11),(5,12),(6,13)]),1e-12))
12202         ff=f+arr
12203         ff.checkCoherency()
12204         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,7),(2,10),(4,13),(6,16),(8,19)]),1e-12))
12205         self.assertRaises(InterpKernelException,f.__add__,f2)
12206         f2.setArray(arr)
12207         ff=f+f2
12208         ff.checkCoherency()
12209         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,7),(2,10),(4,13),(6,16),(8,19)]),1e-12))
12210         ff=f+[5,8]
12211         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(5,15),(6,16),(7,17),(8,18),(9,19)]),1e-12))
12212         ### MEDCouplingFieldDouble.__sub__
12213         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12214         f=MEDCouplingFieldDouble(ON_CELLS)
12215         f.setMesh(m)
12216         arr=DataArrayDouble(5,2)
12217         arr[:,0]=range(5) ; arr[:,1]=2*arr[:,0]
12218         f2=f.clone(True)
12219         self.assertRaises(InterpKernelException,f.__sub__,2)
12220         self.assertRaises(InterpKernelException,f.__sub__,range(5))
12221         self.assertRaises(InterpKernelException,f.__sub__,arr)
12222         self.assertRaises(InterpKernelException,f.__sub__,f2)
12223         f.setArray(DataArrayDouble())
12224         self.assertRaises(InterpKernelException,f.__sub__,2)
12225         self.assertRaises(InterpKernelException,f.__sub__,range(5))
12226         self.assertRaises(InterpKernelException,f.__sub__,arr)
12227         self.assertRaises(InterpKernelException,f.__sub__,f2)
12228         self.assertRaises(InterpKernelException,f.__getitem__,(slice(None),0))
12229         f.getArray().alloc(5,2)
12230         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
12231         ff=f-2
12232         ff.checkCoherency()
12233         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(-2,5),(-1,6),(0,7),(1,8),(2,9)]),1e-12))
12234         ff=f-arr
12235         ff.checkCoherency()
12236         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,7),(0,6),(0,5),(0,4),(0,3)]),1e-12))
12237         self.assertRaises(InterpKernelException,f.__sub__,f2)
12238         f2.setArray(arr)
12239         ff=f-f2
12240         ff.checkCoherency()
12241         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,7),(0,6),(0,5),(0,4),(0,3)]),1e-12))
12242         ff=f-[5,8]
12243         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(-5,-1),(-4,0),(-3,1),(-2,2),(-1,3)]),1e-12))
12244         ### MEDCouplingFieldDouble.__mul__
12245         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12246         f=MEDCouplingFieldDouble(ON_CELLS)
12247         f.setMesh(m)
12248         arr=DataArrayDouble(5,2)
12249         arr[:,0]=range(5) ; arr[:,1]=2*arr[:,0]
12250         f2=f.clone(True)
12251         self.assertRaises(InterpKernelException,f.__mul__,2)
12252         self.assertRaises(InterpKernelException,f.__mul__,range(5))
12253         self.assertRaises(InterpKernelException,f.__mul__,arr)
12254         self.assertRaises(InterpKernelException,f.__mul__,f2)
12255         f.setArray(DataArrayDouble())
12256         self.assertRaises(InterpKernelException,f.__mul__,2)
12257         self.assertRaises(InterpKernelException,f.__mul__,range(5))
12258         self.assertRaises(InterpKernelException,f.__mul__,arr)
12259         self.assertRaises(InterpKernelException,f.__mul__,f2)
12260         self.assertRaises(InterpKernelException,f.__getitem__,(slice(None),0))
12261         f.getArray().alloc(5,2)
12262         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
12263         ff=f*2
12264         ff.checkCoherency()
12265         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,14),(2,16),(4,18),(6,20),(8,22)]),1e-12))
12266         ff=f*arr
12267         ff.checkCoherency()
12268         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,0),(1,16),(4,36),(9,60),(16,88)]),1e-12))
12269         self.assertRaises(InterpKernelException,f.__mul__,f2)
12270         f2.setArray(arr)
12271         ff=f*f2
12272         ff.checkCoherency()
12273         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,0),(1,16),(4,36),(9,60),(16,88)]),1e-12))
12274         ff=f*[5,8]
12275         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,56),(5,64),(10,72),(15,80),(20,88)]),1e-12))
12276         ### MEDCouplingFieldDouble.__div__
12277         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12278         f=MEDCouplingFieldDouble(ON_CELLS)
12279         f.setMesh(m)
12280         arr=DataArrayDouble(5,2)
12281         arr[:,0]=range(1,6) ; arr[:,1]=2*arr[:,0]
12282         f2=f.clone(True)
12283         self.assertRaises(InterpKernelException,f.__div__,2)
12284         self.assertRaises(InterpKernelException,f.__div__,range(5))
12285         self.assertRaises(InterpKernelException,f.__div__,arr)
12286         self.assertRaises(InterpKernelException,f.__div__,f2)
12287         f.setArray(DataArrayDouble())
12288         self.assertRaises(InterpKernelException,f.__div__,2)
12289         self.assertRaises(InterpKernelException,f.__div__,range(5))
12290         self.assertRaises(InterpKernelException,f.__div__,arr)
12291         self.assertRaises(InterpKernelException,f.__div__,f2)
12292         self.assertRaises(InterpKernelException,f.__getitem__,(slice(None),0))
12293         f.getArray().alloc(5,2)
12294         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
12295         self.assertRaises(InterpKernelException,f.__div__,0)
12296         ff=f/2
12297         ff.checkCoherency()
12298         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,3.5),(0.5,4),(1,4.5),(1.5,5),(2,5.5)]),1e-12))
12299         ff=f/arr
12300         ff.checkCoherency()
12301         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))
12302         self.assertRaises(InterpKernelException,f.__div__,f2)
12303         f2.setArray(arr)
12304         ff=f/f2
12305         ff.checkCoherency()
12306         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))
12307         ff=f/[5,8]
12308         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))
12309         ### MEDCouplingFieldDouble.__pow__
12310         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12311         f=MEDCouplingFieldDouble(ON_CELLS)
12312         f.setMesh(m)
12313         arr=DataArrayDouble(5)
12314         arr[:]=[1,1,3,2,0]
12315         f2=f.clone(True)
12316         self.assertRaises(InterpKernelException,f.__div__,2)
12317         self.assertRaises(InterpKernelException,f.__div__,range(5))
12318         self.assertRaises(InterpKernelException,f.__div__,arr)
12319         self.assertRaises(InterpKernelException,f.__div__,f2)
12320         f.setArray(DataArrayDouble())
12321         self.assertRaises(InterpKernelException,f.__div__,2)
12322         self.assertRaises(InterpKernelException,f.__div__,range(5))
12323         self.assertRaises(InterpKernelException,f.__div__,arr)
12324         self.assertRaises(InterpKernelException,f.__div__,f2)
12325         self.assertRaises(InterpKernelException,f.__getitem__,(slice(None),0))
12326         f.getArray().alloc(5,1)
12327         f.getArray()[:]=range(2,7)
12328         ff=f**2
12329         ff.checkCoherency()
12330         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([4,9,16,25,36]),1e-12))
12331         ff=f**arr
12332         ff.checkCoherency()
12333         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([2,3,64,25,1]),1e-12))
12334         f2.setArray(arr)
12335         ff=f**f2
12336         ff.checkCoherency()
12337         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([2,3,64,25,1]),1e-12))
12338         ## MEDCouplingFieldDouble.__iadd__
12339         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12340         f=MEDCouplingFieldDouble(ON_CELLS)
12341         f.setMesh(m)
12342         arr=DataArrayDouble(5,2)
12343         arr[:,0]=range(5) ; arr[:,1]=2*arr[:,0]
12344         f2=f.clone(True)
12345         self.assertRaises(InterpKernelException,f.__iadd__,2)
12346         self.assertRaises(InterpKernelException,f.__iadd__,range(5))
12347         self.assertRaises(InterpKernelException,f.__iadd__,arr)
12348         self.assertRaises(InterpKernelException,f.__iadd__,f2)
12349         f.setArray(DataArrayDouble())
12350         self.assertRaises(InterpKernelException,f.__iadd__,2)
12351         self.assertRaises(InterpKernelException,f.__iadd__,range(5))
12352         self.assertRaises(InterpKernelException,f.__iadd__,arr)
12353         self.assertRaises(InterpKernelException,f.__iadd__,f2)
12354         f.getArray().alloc(5,2)
12355         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
12356         f.checkCoherency()
12357         f+=2
12358         f.checkCoherency()
12359         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(2,9),(3,10),(4,11),(5,12),(6,13)]),1e-12))
12360         f+=arr
12361         f.checkCoherency()
12362         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(2,9),(4,12),(6,15),(8,18),(10,21)]),1e-12))
12363         f2.setArray(arr)
12364         f+=f2
12365         f.checkCoherency()
12366         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(2,9),(5,14),(8,19),(11,24),(14,29)]),1e-12))
12367         f+=[0.1,0.2]
12368         f.checkCoherency()
12369         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))
12370         ## MEDCouplingFieldDouble.__isub__
12371         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12372         f=MEDCouplingFieldDouble(ON_CELLS)
12373         f.setMesh(m)
12374         arr=DataArrayDouble(5,2)
12375         arr[:,0]=range(5) ; arr[:,1]=2*arr[:,0]
12376         f2=f.clone(True)
12377         self.assertRaises(InterpKernelException,f.__isub__,2)
12378         self.assertRaises(InterpKernelException,f.__isub__,range(5))
12379         self.assertRaises(InterpKernelException,f.__isub__,arr)
12380         self.assertRaises(InterpKernelException,f.__isub__,f2)
12381         f.setArray(DataArrayDouble())
12382         self.assertRaises(InterpKernelException,f.__isub__,2)
12383         self.assertRaises(InterpKernelException,f.__isub__,range(5))
12384         self.assertRaises(InterpKernelException,f.__isub__,arr)
12385         self.assertRaises(InterpKernelException,f.__isub__,f2)
12386         f.getArray().alloc(5,2)
12387         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
12388         f.checkCoherency()
12389         f-=2
12390         f.checkCoherency()
12391         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(-2,5),(-1,6),(0,7),(1,8),(2,9)]),1e-12))
12392         f-=arr
12393         f.checkCoherency()
12394         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(-2,5),(-2,4),(-2,3),(-2,2),(-2,1)]),1e-12))
12395         f2.setArray(arr)
12396         f-=f2
12397         f.checkCoherency()
12398         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(-2,5),(-3,2),(-4,-1),(-5,-4),(-6,-7)]),1e-12))
12399         f-=[0.1,0.2]
12400         f.checkCoherency()
12401         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))
12402         ## MEDCouplingFieldDouble.__imul__
12403         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12404         f=MEDCouplingFieldDouble(ON_CELLS)
12405         f.setMesh(m)
12406         arr=DataArrayDouble(5,2)
12407         arr[:,0]=range(5) ; arr[:,1]=2*arr[:,0]
12408         f2=f.clone(True)
12409         self.assertRaises(InterpKernelException,f.__imul__,2)
12410         self.assertRaises(InterpKernelException,f.__imul__,range(5))
12411         self.assertRaises(InterpKernelException,f.__imul__,arr)
12412         self.assertRaises(InterpKernelException,f.__imul__,f2)
12413         f.setArray(DataArrayDouble())
12414         self.assertRaises(InterpKernelException,f.__imul__,2)
12415         self.assertRaises(InterpKernelException,f.__imul__,range(5))
12416         self.assertRaises(InterpKernelException,f.__imul__,arr)
12417         self.assertRaises(InterpKernelException,f.__imul__,f2)
12418         f.getArray().alloc(5,2)
12419         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
12420         f.checkCoherency()
12421         f*=2
12422         f.checkCoherency()
12423         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(0,14),(2,16),(4,18),(6,20),(8,22)]),1e-12))
12424         f*=arr
12425         f.checkCoherency()
12426         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(0,0),(2,32),(8,72),(18,120),(32,176)]),1e-12))
12427         f2.setArray(arr)
12428         f*=f2
12429         f.checkCoherency()
12430         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(0,0),(2,64),(16,288),(54,720),(128,1408)]),1e-12))
12431         f*=[0.1,0.2]
12432         f.checkCoherency()
12433         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))
12434         ## MEDCouplingFieldDouble.__idiv__
12435         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12436         f=MEDCouplingFieldDouble(ON_CELLS)
12437         f.setMesh(m)
12438         arr=DataArrayDouble(5,2)
12439         arr[:,0]=range(1,6) ; arr[:,1]=2*arr[:,0]
12440         f2=f.clone(True)
12441         self.assertRaises(InterpKernelException,f.__idiv__,2)
12442         self.assertRaises(InterpKernelException,f.__idiv__,range(5))
12443         self.assertRaises(InterpKernelException,f.__idiv__,arr)
12444         self.assertRaises(InterpKernelException,f.__idiv__,f2)
12445         f.setArray(DataArrayDouble())
12446         self.assertRaises(InterpKernelException,f.__idiv__,2)
12447         self.assertRaises(InterpKernelException,f.__idiv__,range(5))
12448         self.assertRaises(InterpKernelException,f.__idiv__,arr)
12449         self.assertRaises(InterpKernelException,f.__idiv__,f2)
12450         f.getArray().alloc(5,2)
12451         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
12452         f.checkCoherency()
12453         f/=2
12454         f.checkCoherency()
12455         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(0,3.5),(0.5,4),(1,4.5),(1.5,5),(2,5.5)]),1e-12))
12456         f/=arr
12457         f.checkCoherency()
12458         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))
12459         f2.setArray(arr)
12460         f/=f2
12461         f.checkCoherency()
12462         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))
12463         f/=[0.1,0.2]
12464         f.checkCoherency()
12465         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))
12466         ## MEDCouplingFieldDouble.__ipow__
12467         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12468         f=MEDCouplingFieldDouble(ON_CELLS)
12469         f.setMesh(m)
12470         arr=DataArrayDouble(5,2)
12471         arr[:,0]=range(1,6) ; arr[:,1]=2*arr[:,0]
12472         f2=f.clone(True)
12473         self.assertRaises(InterpKernelException,f.__ipow__,2)
12474         self.assertRaises(InterpKernelException,f.__ipow__,range(5))
12475         self.assertRaises(InterpKernelException,f.__ipow__,arr)
12476         self.assertRaises(InterpKernelException,f.__ipow__,f2)
12477         f.setArray(DataArrayDouble())
12478         self.assertRaises(InterpKernelException,f.__ipow__,2)
12479         self.assertRaises(InterpKernelException,f.__ipow__,range(5))
12480         self.assertRaises(InterpKernelException,f.__ipow__,arr)
12481         self.assertRaises(InterpKernelException,f.__ipow__,f2)
12482         f.getArray().alloc(5,2)
12483         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
12484         f.checkCoherency()
12485         f**=2
12486         f.checkCoherency()
12487         self.assertTrue(f.getArray().isEqual(DataArrayDouble([(0,49),(1,64),(4,81),(9,100),(16,121)]),1e-12))
12488          ## MEDCouplingFieldDouble.__radd__
12489         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12490         f=MEDCouplingFieldDouble(ON_CELLS)
12491         f.setMesh(m)
12492         arr=DataArrayDouble(5,2)
12493         arr[:,0]=range(5) ; arr[:,1]=2*arr[:,0]
12494         f2=f.clone(True)
12495         self.assertRaises(InterpKernelException,f.__radd__,2)
12496         self.assertRaises(InterpKernelException,f.__radd__,range(5))
12497         self.assertRaises(InterpKernelException,f.__radd__,arr)
12498         self.assertRaises(InterpKernelException,f.__radd__,f2)
12499         f.setArray(DataArrayDouble())
12500         self.assertRaises(InterpKernelException,f.__radd__,2)
12501         self.assertRaises(InterpKernelException,f.__radd__,range(5))
12502         self.assertRaises(InterpKernelException,f.__radd__,arr)
12503         self.assertRaises(InterpKernelException,f.__radd__,f2)
12504         self.assertRaises(InterpKernelException,f.__getitem__,(slice(None),0))
12505         f.getArray().alloc(5,2)
12506         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
12507         ff=2+f
12508         ff.checkCoherency()
12509         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(2,9),(3,10),(4,11),(5,12),(6,13)]),1e-12))
12510         ff=arr+f
12511         ff.checkCoherency()
12512         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,7),(2,10),(4,13),(6,16),(8,19)]),1e-12))
12513         self.assertRaises(InterpKernelException,f.__radd__,f2)
12514         ff=[5,8]+f
12515         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(5,15),(6,16),(7,17),(8,18),(9,19)]),1e-12))
12516         ### MEDCouplingFieldDouble.__rsub__
12517         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12518         f=MEDCouplingFieldDouble(ON_CELLS)
12519         f.setMesh(m)
12520         arr=DataArrayDouble(5,2)
12521         arr[:,0]=range(5) ; arr[:,1]=2*arr[:,0]
12522         f2=f.clone(True)
12523         self.assertRaises(InterpKernelException,f.__rsub__,2)
12524         self.assertRaises(InterpKernelException,f.__rsub__,range(5))
12525         self.assertRaises(InterpKernelException,f.__rsub__,arr)
12526         self.assertRaises(InterpKernelException,f.__rsub__,f2)
12527         f.setArray(DataArrayDouble())
12528         self.assertRaises(InterpKernelException,f.__rsub__,2)
12529         self.assertRaises(InterpKernelException,f.__rsub__,range(5))
12530         self.assertRaises(InterpKernelException,f.__rsub__,arr)
12531         self.assertRaises(InterpKernelException,f.__rsub__,f2)
12532         self.assertRaises(InterpKernelException,f.__getitem__,(slice(None),0))
12533         f.getArray().alloc(5,2)
12534         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
12535         ff=2-f
12536         ff.checkCoherency()
12537         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(2,-5),(1,-6),(0,-7),(-1,-8),(-2,-9)]),1e-12))
12538         ff=arr-f
12539         ff.checkCoherency()
12540         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,-7),(0,-6),(0,-5),(0,-4),(0,-3)]),1e-12))
12541         self.assertRaises(InterpKernelException,f.__rsub__,f2)
12542         ### MEDCouplingFieldDouble.__rmul__
12543         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12544         f=MEDCouplingFieldDouble(ON_CELLS)
12545         f.setMesh(m)
12546         arr=DataArrayDouble(5,2)
12547         arr[:,0]=range(5) ; arr[:,1]=2*arr[:,0]
12548         f2=f.clone(True)
12549         self.assertRaises(InterpKernelException,f.__rmul__,2)
12550         self.assertRaises(InterpKernelException,f.__rmul__,range(5))
12551         self.assertRaises(InterpKernelException,f.__rmul__,arr)
12552         self.assertRaises(InterpKernelException,f.__rmul__,f2)
12553         f.setArray(DataArrayDouble())
12554         self.assertRaises(InterpKernelException,f.__rmul__,2)
12555         self.assertRaises(InterpKernelException,f.__rmul__,range(5))
12556         self.assertRaises(InterpKernelException,f.__rmul__,arr)
12557         self.assertRaises(InterpKernelException,f.__rmul__,f2)
12558         self.assertRaises(InterpKernelException,f.__getitem__,(slice(None),0))
12559         f.getArray().alloc(5,2)
12560         f.getArray()[:,0]=range(5) ; f.getArray()[:,1]=f.getArray()[:,0]+7
12561         ff=2*f
12562         ff.checkCoherency()
12563         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,14),(2,16),(4,18),(6,20),(8,22)]),1e-12))
12564         ff=arr*f
12565         ff.checkCoherency()
12566         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,0),(1,16),(4,36),(9,60),(16,88)]),1e-12))
12567         self.assertRaises(InterpKernelException,f.__rmul__,f2)
12568         ff=f*[5,8]
12569         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(0,56),(5,64),(10,72),(15,80),(20,88)]),1e-12))
12570         ### MEDCouplingFieldDouble.__rdiv__
12571         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12572         f=MEDCouplingFieldDouble(ON_CELLS)
12573         f.setMesh(m)
12574         arr=DataArrayDouble(5,2)
12575         arr[:,0]=range(1,6) ; arr[:,1]=2*arr[:,0]
12576         f2=f.clone(True)
12577         self.assertRaises(InterpKernelException,f.__rdiv__,2)
12578         self.assertRaises(InterpKernelException,f.__rdiv__,range(5))
12579         self.assertRaises(InterpKernelException,f.__rdiv__,arr)
12580         self.assertRaises(InterpKernelException,f.__rdiv__,f2)
12581         f.setArray(DataArrayDouble())
12582         self.assertRaises(InterpKernelException,f.__rdiv__,2)
12583         self.assertRaises(InterpKernelException,f.__rdiv__,range(5))
12584         self.assertRaises(InterpKernelException,f.__rdiv__,arr)
12585         self.assertRaises(InterpKernelException,f.__rdiv__,f2)
12586         self.assertRaises(InterpKernelException,f.__getitem__,(slice(None),0))
12587         f.getArray().alloc(5,2)
12588         f.getArray()[:,0]=range(1,6) ; f.getArray()[:,1]=f.getArray()[:,0]+7
12589         ff=2/f
12590         ff.checkCoherency()
12591         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))
12592         ff=arr/f
12593         ff.checkCoherency()
12594         self.assertTrue(ff.getArray().isEqual(DataArrayDouble([(1,0.25),(1,0.44444444444444442),(1,0.59999999999999998),(1,0.72727272727272729),(1,0.83333333333333337)]),1e-12))
12595         self.assertRaises(InterpKernelException,f.__rdiv__,f2)
12596         pass
12597
12598     def testSwig2FieldDoubleBuildSubPartRange1(self):
12599         #ON_CELLS
12600         m=MEDCouplingDataForTest.build2DTargetMesh_1()
12601         f=MEDCouplingFieldDouble(ON_CELLS)
12602         f.setMesh(m)
12603         arr=DataArrayDouble(5,2) ; arr[:,0]=range(7,12) ; arr[:,1]=100+arr[:,0]
12604         f.setArray(arr)
12605         f.checkCoherency()
12606         ff=f[1:-1:2]
12607         ff.checkCoherency()
12608         self.assertTrue((m.buildPartOfMySelf([1,3],True)).isEqual(ff.getMesh(),1e-12))
12609         self.assertTrue(9,ff.getMesh().getNumberOfNodes())
12610         self.assertTrue(2,ff.getMesh().getNumberOfCells())
12611         self.assertTrue(ff.getArray().isEqual(arr[[1,3]],1e-12))
12612         #
12613         a,b=f.buildSubMeshDataRange(2,5,1)
12614         self.assertTrue(m.buildPartOfMySelf([2,3,4],True).isEqual(a,1e-12))
12615         self.assertEqual(b,slice(2,5,1))
12616         ff=f[2:]
12617         ff.checkCoherency()
12618         self.assertTrue((m.buildPartOfMySelf([2,3,4],True)).isEqual(ff.getMesh(),1e-12))
12619         self.assertTrue(9,ff.getMesh().getNumberOfNodes())
12620         self.assertTrue(3,ff.getMesh().getNumberOfCells())
12621         self.assertTrue(ff.getArray().isEqual(arr[[2,3,4]],1e-12))
12622         #
12623         ff=f[-2:0:-1]
12624         ff.checkCoherency()
12625         self.assertTrue((m.buildPartOfMySelf([3,2,1],True)).isEqual(ff.getMesh(),1e-12))
12626         self.assertTrue(9,ff.getMesh().getNumberOfNodes())
12627         self.assertTrue(3,ff.getMesh().getNumberOfCells())
12628         self.assertTrue(ff.getArray().isEqual(arr[[3,2,1]],1e-12))
12629         self.assertTrue(f[-2:0:-1,1].getArray().isEqual(arr[[3,2,1],1],1e-12))
12630         #ON_NODES
12631         f=MEDCouplingFieldDouble(ON_NODES)
12632         f.setMesh(m)
12633         arr=DataArrayDouble(9,2) ; arr[:,0]=range(7,16) ; arr[:,1]=100+arr[:,0]
12634         f.setArray(arr)
12635         f.checkCoherency()
12636         ff=f[1:-1:2]
12637         ff.checkCoherency()
12638         self.assertTrue((m.buildPartOfMySelf([1,3],False)).isEqual(ff.getMesh(),1e-12))
12639         self.assertTrue(6,ff.getMesh().getNumberOfNodes())
12640         self.assertTrue(2,ff.getMesh().getNumberOfCells())
12641         self.assertTrue(ff.getArray().isEqual(arr[[1,2,3,4,6,7]],1e-12))
12642         #
12643         m2=m.buildPartRange(2,5,1)
12644         self.assertTrue(m.buildPartOfMySelf([2,3,4],True).isEqual(m2,1e-12))
12645         m2,b=m.buildPartRangeAndReduceNodes(2,5,1)
12646         self.assertTrue(m.buildPartOfMySelf([2,3,4],False).isEqual(m2,1e-12))
12647         self.assertTrue(b.isEqual(DataArrayInt([-1,-1,0,1,2,3,4,5,6])))
12648         a,b=f.buildSubMeshDataRange(2,5,1)
12649         self.assertTrue(m.buildPartOfMySelf([2,3,4],False).isEqual(a,1e-12))
12650         self.assertTrue(b.isEqual(DataArrayInt([2,3,4,5,6,7,8])))
12651         ff=f[2:]
12652         ff.checkCoherency()
12653         self.assertTrue((m.buildPartOfMySelf([2,3,4],False)).isEqual(ff.getMesh(),1e-12))
12654         self.assertTrue(7,ff.getMesh().getNumberOfNodes())
12655         self.assertTrue(3,ff.getMesh().getNumberOfCells())
12656         self.assertTrue(ff.getArray().isEqual(arr[[2,3,4,5,6,7,8]],1e-12))
12657         #
12658         ff=f[-2:0:-1]
12659         ff.checkCoherency()
12660         self.assertTrue((m.buildPartOfMySelf([3,2,1],False)).isEqual(ff.getMesh(),1e-12))
12661         self.assertTrue(7,ff.getMesh().getNumberOfNodes())
12662         self.assertTrue(3,ff.getMesh().getNumberOfCells())
12663         self.assertTrue(ff.getArray().isEqual(arr[[1,2,3,4,5,6,7]],1e-12))
12664         self.assertTrue(f[-2:0:-1,1].getArray().isEqual(arr[[1,2,3,4,5,6,7],1],1e-12))
12665         #ON_GAUSS_NE
12666         f=MEDCouplingFieldDouble(ON_GAUSS_NE)
12667         f.setMesh(m)
12668         arr=DataArrayDouble(18,2) ; arr[:,0]=range(7,25) ; arr[:,1]=100+arr[:,0]
12669         f.setArray(arr)
12670         f.checkCoherency()
12671         ff=f[1:-1:2]
12672         ff.checkCoherency()
12673         self.assertTrue((m.buildPartOfMySelf([1,3],True)).isEqual(ff.getMesh(),1e-12))
12674         self.assertTrue(9,ff.getMesh().getNumberOfNodes())
12675         self.assertTrue(2,ff.getMesh().getNumberOfCells())
12676         self.assertTrue(ff.getArray().isEqual(arr[[4,5,6,10,11,12,13]],1e-12))
12677         #
12678         a,b=f.buildSubMeshDataRange(2,5,1)
12679         self.assertTrue(m.buildPartOfMySelf([2,3,4],True).isEqual(a,1e-12))
12680         self.assertEqual(b,slice(7,18,1))
12681         ff=f[2:]
12682         ff.checkCoherency()
12683         self.assertTrue((m.buildPartOfMySelf([2,3,4],True)).isEqual(ff.getMesh(),1e-12))
12684         self.assertTrue(9,ff.getMesh().getNumberOfNodes())
12685         self.assertTrue(3,ff.getMesh().getNumberOfCells())
12686         self.assertTrue(ff.getArray().isEqual(arr[[7,8,9,10,11,12,13,14,15,16,17]],1e-12))
12687         #
12688         ff=f[-2:0:-1]
12689         ff.checkCoherency()
12690         self.assertTrue((m.buildPartOfMySelf([3,2,1],True)).isEqual(ff.getMesh(),1e-12))
12691         self.assertTrue(9,ff.getMesh().getNumberOfNodes())
12692         self.assertTrue(3,ff.getMesh().getNumberOfCells())
12693         self.assertTrue(ff.getArray().isEqual(arr[[10,11,12,13,7,8,9,4,5,6]],1e-12))
12694         self.assertTrue(f[-2:0:-1,1].getArray().isEqual(arr[[10,11,12,13,7,8,9,4,5,6],1],1e-12))
12695         #ON_GAUSS_PT
12696         f=MEDCouplingFieldDouble(ON_GAUSS_PT)
12697         f.setMesh(m)
12698         f.setGaussLocalizationOnCells([0,4],[0,0,1,0,1,1,1,0],[1.1,1.1,2.2,2.2],[0.2,0.8]);
12699         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]);
12700         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]);
12701         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]);
12702         arr=DataArrayDouble(16,2) ; arr[:,0]=range(7,23) ; arr[:,1]=100+arr[:,0]
12703         f.setArray(arr)
12704         f.checkCoherency()
12705         ff=f[1:-1:2]
12706         ff.checkCoherency()
12707         self.assertTrue((m.buildPartOfMySelf([1,3],True)).isEqual(ff.getMesh(),1e-12))
12708         self.assertTrue(9,ff.getMesh().getNumberOfNodes())
12709         self.assertTrue(2,ff.getMesh().getNumberOfCells())
12710         self.assertTrue(ff.getArray().isEqual(arr[[2,3,4,5,11,12,13]],1e-12))
12711         #
12712         a,b=f.buildSubMeshDataRange(2,5,1)
12713         self.assertTrue(m.buildPartOfMySelf([2,3,4],True).isEqual(a,1e-12))
12714         self.assertEqual(b,slice(6,16,1))
12715         ff=f[2:]
12716         ff.checkCoherency()
12717         self.assertTrue((m.buildPartOfMySelf([2,3,4],True)).isEqual(ff.getMesh(),1e-12))
12718         self.assertTrue(9,ff.getMesh().getNumberOfNodes())
12719         self.assertTrue(3,ff.getMesh().getNumberOfCells())
12720         self.assertTrue(ff.getArray().isEqual(arr[[6,7,8,9,10,11,12,13,14,15]],1e-12))
12721         #
12722         ff=f[-2:0:-1]
12723         ff.checkCoherency()
12724         self.assertTrue((m.buildPartOfMySelf([3,2,1],True)).isEqual(ff.getMesh(),1e-12))
12725         self.assertTrue(9,ff.getMesh().getNumberOfNodes())
12726         self.assertTrue(3,ff.getMesh().getNumberOfCells())
12727         self.assertTrue(ff.getArray().isEqual(arr[[11,12,13,6,7,8,9,10,2,3,4,5]],1e-12))
12728         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))
12729         pass
12730
12731     def testSwig2FieldDoubleApplyFuncBug1(self):
12732         f=MEDCouplingFieldDouble(ON_CELLS)
12733         f.setMesh(MEDCouplingDataForTest.build2DTargetMesh_1())
12734         f.applyFunc(3,700.)
12735         f.checkCoherency()
12736         self.assertEqual(3,f.getArray().getNumberOfComponents())
12737         f.getArray().rearrange(1)
12738         self.assertTrue(f.getArray().isUniform(700.,1e-10))
12739         f.getArray().rearrange(3)
12740         f.checkCoherency()
12741         f.applyFunc(4,800.)
12742         f.checkCoherency()
12743         self.assertEqual(4,f.getArray().getNumberOfComponents())
12744         f.getArray().rearrange(1)
12745         self.assertTrue(f.getArray().isUniform(800.,1e-10))
12746         f.getArray().rearrange(4)
12747         f.checkCoherency()
12748         pass
12749
12750     def testSwig2ComputeTupleIdsNearTupleBug1(self):
12751         coords=[1.1,0.0, 1.1,0.0 ];
12752         coordsArr=DataArrayDouble(coords,2,2);
12753         mesh=MEDCouplingUMesh();
12754         mesh.setCoords(coordsArr);
12755         points=[1.1, 0.002]
12756         c,cI=mesh.getNodeIdsNearPoints(points,0.00185);
12757         self.assertTrue(c.isEqual(DataArrayInt([])))
12758         self.assertTrue(cI.isEqual(DataArrayInt([0,0])))
12759         c,cI=mesh.getNodeIdsNearPoints(points,0.00200000000000001);
12760         self.assertTrue(c.isEqual(DataArrayInt([0,1])))
12761         self.assertTrue(cI.isEqual(DataArrayInt([0,2])))
12762         pass
12763
12764     def testSwig2NonRegressionBugChangeUnderlyingWithZeroCells(self):
12765         coords1=[0.,1.,2.,3.]
12766         coords2=[2.,1.,0.,3.] #0 <==> #2
12767         # mesh 1
12768         mesh1=MEDCouplingUMesh.New();
12769         coordsArr=DataArrayDouble.New(coords1,4,1);
12770         mesh1.setCoords(coordsArr);
12771         mesh1.setMeshDimension(0);
12772         mesh1.allocateCells(0);
12773         mesh1.finishInsertingCells();
12774         # mesh 2
12775         mesh2=mesh1.deepCpy();
12776         coordsArr=DataArrayDouble.New(coords2,4,1);
12777         mesh2.setCoords(coordsArr);
12778         field = mesh1.fillFromAnalytic(ON_NODES,1,"x")
12779         field.checkCoherency()
12780         levOfCheck = 10
12781         field.changeUnderlyingMesh( mesh2, levOfCheck, 1e-13, 0 )
12782         self.assertTrue( field.getArray().getValues() == coords2 )
12783         pass
12784
12785     def testSwig2UMeshDistanceToMesh2(self):
12786         sz=5
12787         m=MEDCouplingCMesh()
12788         arr=DataArrayDouble(sz+1) ; arr.iota() ; arr/=sz
12789         m.setCoords(arr,arr,arr)
12790         m=m.buildUnstructured()
12791         m1=m.computeSkin()
12792         m1.zipCoords()
12793         c=m1.getCoords()[:]
12794         d=2*(c-[0.5,0.5,0.5])+[0.5,0.5,0.5]
12795         time_deb = datetime.now()
12796         #print "go.."
12797         a,b=m1.distanceToPoints(d)
12798         #print 'time spent in distanceToPoints %s ' %str(datetime.now() - time_deb)
12799         time_deb = datetime.now()
12800         a1=DataArrayDouble(len(d))
12801         b1=DataArrayInt(len(d))
12802         m1s=[m1[i] for i in xrange(m1.getNumberOfCells())]
12803         for j,pt in enumerate(d):
12804             eter=1e308
12805             fter=-1
12806             for i,miter in enumerate(m1s):
12807                 e,f=miter.distanceToPoint(pt)
12808                 self.assertEqual(0,f)
12809                 if e<eter:
12810                     eter=e ; fter=i
12811                     pass
12812                 pass
12813             a1[j]=eter
12814             b1[j]=fter
12815             pass
12816         #print 'time spent in naive distanceToPoints  %s ' %str(datetime.now() - time_deb)
12817         self.assertTrue(a.isEqual(a1,1e-12))
12818         self.assertTrue(b.isEqual(b1))
12819         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))
12820         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])))
12821         pass
12822
12823     def testSwig2NonRegressionBugDistance1(self):
12824         pt=DataArrayDouble([(8.8452994616207476,3.1547005383792515,3.1547005383792515)])
12825         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)])
12826         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])
12827         m=MEDCouplingUMesh("mesh",2)
12828         m.setCoords(coo)
12829         m.allocateCells()
12830         for i in xrange(24):
12831             m.insertNextCell(NORM_QUAD4,conn[4*i:4*i+4])
12832             pass
12833         m.checkCoherency2()
12834         m0=m[3] ; m0.zipCoords()
12835         expectedDist=0.8452994616207476
12836         a,b=m0.distanceToPoint(pt)
12837         self.assertAlmostEqual(expectedDist,a,14)
12838         self.assertEqual(0,b)
12839         #
12840         a,b=m.distanceToPoint(pt)
12841         self.assertAlmostEqual(expectedDist,a,14)
12842         self.assertEqual(3,b)
12843         #
12844         fd=MEDCouplingFieldDiscretization.New(ON_CELLS)
12845         self.assertEqual(24,fd.getNumberOfTuples(m))
12846         fd=MEDCouplingFieldDiscretization.New(ON_NODES)
12847         self.assertEqual(26,fd.getNumberOfTuples(m))
12848         pass
12849
12850     def testSwig2AreaBarySeg3Quad8Tri6QPolyg(self):
12851         #QUAD8 representing a circle of center zeBary and radius zeRadius
12852         zeBary=[5,6]
12853         zeRadius=3
12854         d=DataArrayDouble(8,2)
12855         d[:,0]=zeRadius
12856         d[:,1]=[87,-100,-170,110,5,-130,175,95] # angle in degree
12857         d[:,1]*=pi/180. # angle in radian
12858         d=d.fromPolarToCart()
12859         d+=zeBary
12860         m=MEDCouplingUMesh("quad8",2) ; m.allocateCells() ; m.insertNextCell(NORM_QUAD8,range(8)) ; m.setCoords(d)
12861         self.assertTrue(m.getBarycenterAndOwner().isEqual(DataArrayDouble(zeBary,1,2),1e-13))
12862         self.assertAlmostEqual(float(m.getMeasureField(False).getArray()),pi*zeRadius*zeRadius,12)
12863         tri32D=m.buildDescendingConnectivity()[0][0] ; tri32D.zipCoords()
12864         # spaceDim=3 QUAD8 becomes QUAD4 ... for the moment
12865         m.setCoords(m.getCoords().changeNbOfComponents(3,0.))
12866         m2=m.deepCpy()
12867         m2.convertQuadraticCellsToLinear()
12868         self.assertAlmostEqual(float(m.getMeasureField(False).getArray()),float(m2.getMeasureField(False).getArray()),12)
12869         self.assertTrue(m.getBarycenterAndOwner().isEqual(m2.getBarycenterAndOwner(),1e-13))
12870         #TRI6 representing a circle of center zeBary and radius zeRadius
12871         zeBary=[5,6]
12872         zeRadius=3
12873         d=DataArrayDouble(6,2)
12874         d[:,0]=zeRadius
12875         d[:,1]=[87,-100,110,5,175,95] # angle in degree
12876         d[:,1]*=pi/180. # angle in radian
12877         d=d.fromPolarToCart()
12878         d+=zeBary
12879         m=MEDCouplingUMesh("tri6",2) ; m.allocateCells() ; m.insertNextCell(NORM_TRI6,range(6)) ; m.setCoords(d)
12880         self.assertTrue(m.getBarycenterAndOwner().isEqual(DataArrayDouble(zeBary,1,2),1e-13))
12881         self.assertAlmostEqual(float(m.getMeasureField(False).getArray()),pi*zeRadius*zeRadius,12)
12882         # spaceDim=3 TRI6 becomes TRI3 ... for the moment
12883         m.setCoords(m.getCoords().changeNbOfComponents(3,0.))
12884         m2=m.deepCpy()
12885         m2.convertQuadraticCellsToLinear()
12886         self.assertAlmostEqual(float(m.getMeasureField(False).getArray()),float(m2.getMeasureField(False).getArray()),12)
12887         self.assertTrue(m.getBarycenterAndOwner().isEqual(m2.getBarycenterAndOwner(),1e-13))
12888         # QPOLYG representing a circle of center zeBary and radius zeRadius
12889         zeBary=[5,6]
12890         zeRadius=3
12891         d=DataArrayDouble(10,2)
12892         d[:,0]=zeRadius
12893         d[:,1]=[87,-80,-100,-170,110,5,-90,-130,175,95] # angle in degree
12894         d[:,1]*=pi/180. # angle in radian
12895         d=d.fromPolarToCart()
12896         d+=zeBary
12897         m=MEDCouplingUMesh("qpolyg",2) ; m.allocateCells() ; m.insertNextCell(NORM_QPOLYG,range(10)) ; m.setCoords(d)
12898         self.assertTrue(m.getBarycenterAndOwner().isEqual(DataArrayDouble(zeBary,1,2),1e-13))
12899         self.assertAlmostEqual(float(m.getMeasureField(False).getArray()),pi*zeRadius*zeRadius,12)
12900         # spaceDim=3 QPOLYG becomes POLYG ... for the moment
12901         m.setCoords(m.getCoords().changeNbOfComponents(3,0.))
12902         m2=m.deepCpy()
12903         m2.convertQuadraticCellsToLinear() ; m2.checkCoherency2()
12904         self.assertTrue(m2.getAllGeoTypes()==[NORM_POLYGON] and m2.getNodalConnectivity().getValues()==[5,0,1,2,3,4])
12905         self.assertAlmostEqual(float(m.getMeasureField(False).getArray()),float(m2.getMeasureField(False).getArray()),12)
12906         self.assertTrue(m.getBarycenterAndOwner().isEqual(m2.getBarycenterAndOwner(),1e-13))
12907         # TRI3
12908         self.assertAlmostEqual(float(tri32D.getMeasureField(False).getArray()),(87+100)*pi/180*zeRadius,13)
12909         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)
12910         self.assertTrue(tri32D.getBarycenterAndOwner().isEqual(exp,1e-12))
12911         # spaceDim=3 TRI3 becomes TRI2 ... for the moment
12912         tri32D.changeSpaceDimension(3)
12913         tri2=tri32D.deepCpy() ; tri2.convertQuadraticCellsToLinear()
12914         self.assertAlmostEqual(float(tri32D.getMeasureField(False).getArray()),float(tri2.getMeasureField(False).getArray()),13)
12915         self.assertTrue(tri32D.getBarycenterAndOwner().isEqual(tri2.getBarycenterAndOwner(),1e-12))
12916         tri32D.changeSpaceDimension(1)
12917         self.assertAlmostEqual(float(tri32D.getMeasureField(False).getArray()),-0.67795240172962323,12)
12918         pass
12919
12920     # this bug 5/6/2013 is swig specific
12921     def testSwigNonRegressionBugRotate3D1(self):
12922         m=MEDCouplingUMesh.New()
12923         dataArray=DataArrayDouble.New(100,3)
12924         dataArray[:]=0.
12925         dataArray[0]=[0.,1,3]
12926         m.setCoords(dataArray[0])
12927         m1=m.deepCpy()
12928         m.rotate([0.,0.,3.],[1.,0.,0.],0.5*pi)
12929         self.assertTrue(m.getCoords().isEqual(DataArrayDouble([0.,0.,4.],1,3),1e-15))
12930         #
12931         d1=DataArrayDouble([0.,0.,3.],1,3) ; d2=DataArrayDouble([1.,0.,0.],1,3)
12932         pts=[[0.,0.,3.],[(0.,0.,3.)],DataArrayDouble([0.,0.,3.],1,3),list(d1)[0]]
12933         vec=[[1.,0.,0.],[(1.,0.,0.)],DataArrayDouble([1.,0.,0.],1,3),list(d2)[0]]
12934         for p in pts:
12935             for v in vec:
12936                 m2=m1.deepCpy()
12937                 m2.rotate(p,v,0.5*pi)
12938                 self.assertTrue(m2.getCoords().isEqual(DataArrayDouble([0.,0.,4.],1,3),1e-15))
12939                 pass
12940         pass
12941
12942     def testSwig2DataArrayCount1(self):
12943         d=DataArrayInt([])
12944         self.assertEqual(0,d.getNumberOfTuples())
12945         self.assertEqual(1,d.getNumberOfComponents())
12946         self.assertEqual(0,d.count(0))
12947         self.assertEqual(0,d.count(1))
12948         self.assertEqual(0,d.count(-1))
12949         d=DataArrayInt([2,1,-2,-3,2,0,0,7,2,-2,3,0])
12950         self.assertEqual(12,d.getNumberOfTuples())
12951         self.assertEqual(1,d.getNumberOfComponents())
12952         self.assertEqual(3,d.count(0))
12953         self.assertEqual(1,d.count(1))
12954         self.assertEqual(0,d.count(-1))
12955         self.assertEqual(2,d.count(-2))
12956         self.assertEqual(3,d.count(2))
12957         e=d.getDifferentValues()
12958         f=DataArrayInt()
12959         for it in e:
12960             f.pushBackSilent(d.count(int(it)))
12961             pass
12962         self.assertEqual(12,f.accumulate()[0])
12963         #
12964         eps=1e-12
12965         d=DataArrayDouble([])
12966         self.assertEqual(0,d.getNumberOfTuples())
12967         self.assertEqual(1,d.getNumberOfComponents())
12968         self.assertEqual(0,d.count(0,eps))
12969         self.assertEqual(0,d.count(1,eps))
12970         self.assertEqual(0,d.count(-1,eps))
12971         d=DataArrayDouble([2,1,-2,-3,2,0,eps/10,7,2+eps/10,-2,3,0])
12972         self.assertEqual(12,d.getNumberOfTuples())
12973         self.assertEqual(1,d.getNumberOfComponents())
12974         self.assertEqual(3,d.count(0,eps))
12975         self.assertEqual(1,d.count(1,eps))
12976         self.assertEqual(0,d.count(-1,eps))
12977         self.assertEqual(2,d.count(-2,eps))
12978         self.assertEqual(3,d.count(2,eps))
12979         self.assertEqual(3,d.count(2,eps))
12980         self.assertEqual(2,d.count(2,eps/100))
12981         e=d.getDifferentValues(eps)
12982         f=DataArrayInt()
12983         for it in e:
12984             f.pushBackSilent(d.count(float(it),eps))
12985             pass
12986         self.assertEqual(12,f.accumulate()[0])
12987         pass
12988
12989     def testSwig2DataArrayGetSlice1(self):
12990         s=slice(2,18,1)
12991         self.assertEqual(DataArray.GetNumberOfItemGivenBESRelative(s),16)
12992         self.assertEqual(DataArray.GetNumberOfItemGivenBES(s),16)
12993         self.assertEqual(DataArray.GetSlice(s,0,4),slice(2,6,1))
12994         self.assertEqual(DataArray.GetSlice(s,1,4),slice(6,10,1))
12995         self.assertEqual(DataArray.GetSlice(s,2,4),slice(10,14,1))
12996         self.assertEqual(DataArray.GetSlice(s,3,4),slice(14,18,1))
12997         #
12998         s=slice(2,18,2)
12999         self.assertEqual(DataArray.GetNumberOfItemGivenBESRelative(s),8)
13000         self.assertEqual(DataArray.GetNumberOfItemGivenBES(s),8)
13001         self.assertEqual(DataArray.GetSlice(s,0,4),slice(2,6,2))
13002         self.assertEqual(DataArray.GetSlice(s,1,4),slice(6,10,2))
13003         self.assertEqual(DataArray.GetSlice(s,2,4),slice(10,14,2))
13004         self.assertEqual(DataArray.GetSlice(s,3,4),slice(14,18,2))
13005         #
13006         s=slice(1,18,1)
13007         self.assertEqual(DataArray.GetSlice(s,0,4),slice(1,5,1))
13008         self.assertEqual(DataArray.GetSlice(s,1,4),slice(5,9,1))
13009         self.assertEqual(DataArray.GetSlice(s,2,4),slice(9,13,1))
13010         self.assertEqual(DataArray.GetSlice(s,3,4),slice(13,18,1))# 18 not 17
13011         #
13012         s=slice(1,18,2)
13013         self.assertEqual(DataArray.GetNumberOfItemGivenBESRelative(s),9)
13014         self.assertEqual(DataArray.GetNumberOfItemGivenBES(s),9)
13015         self.assertEqual(DataArray.GetSlice(s,0,4),slice(1,5,2))
13016         self.assertEqual(DataArray.GetSlice(s,1,4),slice(5,9,2))
13017         self.assertEqual(DataArray.GetSlice(s,2,4),slice(9,13,2))
13018         self.assertEqual(DataArray.GetSlice(s,3,4),slice(13,18,2))# 18 not 17
13019         #
13020         s=slice(18,2,-1)
13021         self.assertEqual(DataArray.GetSlice(s,0,4),slice(18,14,-1))
13022         self.assertEqual(DataArray.GetSlice(s,1,4),slice(14,10,-1))
13023         self.assertEqual(DataArray.GetSlice(s,2,4),slice(10,6,-1))
13024         self.assertEqual(DataArray.GetSlice(s,3,4),slice(6,2,-1))
13025         #
13026         s=slice(18,2,-2)
13027         self.assertEqual(DataArray.GetSlice(s,0,4),slice(18,14,-2))
13028         self.assertEqual(DataArray.GetSlice(s,1,4),slice(14,10,-2))
13029         self.assertEqual(DataArray.GetSlice(s,2,4),slice(10,6,-2))
13030         self.assertEqual(DataArray.GetSlice(s,3,4),slice(6,2,-2))
13031         #
13032         s=slice(18,1,-1)
13033         self.assertEqual(DataArray.GetSlice(s,0,4),slice(18,14,-1))
13034         self.assertEqual(DataArray.GetSlice(s,1,4),slice(14,10,-1))
13035         self.assertEqual(DataArray.GetSlice(s,2,4),slice(10,6,-1))
13036         self.assertEqual(DataArray.GetSlice(s,3,4),slice(6,1,-1))# 1 not 2
13037         #
13038         s=slice(18,1,-2)
13039         self.assertEqual(DataArray.GetNumberOfItemGivenBESRelative(s),9)
13040         self.assertRaises(InterpKernelException,DataArray.GetNumberOfItemGivenBES,s)
13041         self.assertEqual(sum([DataArray.GetNumberOfItemGivenBESRelative(DataArray.GetSlice(s,i,4)) for i in xrange(4)]),DataArray.GetNumberOfItemGivenBESRelative(s))
13042         self.assertEqual(DataArray.GetSlice(s,0,4),slice(18,14,-2))
13043         self.assertEqual(DataArray.GetSlice(s,1,4),slice(14,10,-2))
13044         self.assertEqual(DataArray.GetSlice(s,2,4),slice(10,6,-2))
13045         self.assertEqual(DataArray.GetSlice(s,3,4),slice(6,1,-2))# 1 not 2
13046         self.assertRaises(InterpKernelException,DataArray.GetSlice,slice(0,None,2),0,4)
13047         #
13048         d=DataArrayInt.Range(0,18,1)
13049         s=slice(2,None,1)
13050         self.assertEqual(d.getNumberOfItemGivenBES(s),16)
13051         self.assertEqual(d.getNumberOfItemGivenBESRelative(s),16)
13052         self.assertEqual(d.getSlice(s,0,4),slice(2,6,1))
13053         self.assertEqual(d.getSlice(s,1,4),slice(6,10,1))
13054         self.assertEqual(d.getSlice(s,2,4),slice(10,14,1))
13055         self.assertEqual(d.getSlice(s,3,4),slice(14,18,1))
13056         #
13057         d=DataArrayInt.Range(0,18,1)
13058         s=slice(2,-2,1)
13059         self.assertEqual(d.getSlice(s,0,4),slice(2,5,1))
13060         self.assertEqual(d.getSlice(s,1,4),slice(5,8,1))
13061         self.assertEqual(d.getSlice(s,2,4),slice(8,11,1))
13062         self.assertEqual(d.getSlice(s,3,4),slice(11,16,1))
13063         #
13064         d=DataArrayInt.Range(0,18,1)
13065         s=slice(None,None,1)
13066         self.assertEqual(d.getSlice(s,0,4),slice(0,4,1))
13067         self.assertEqual(d.getSlice(s,1,4),slice(4,8,1))
13068         self.assertEqual(d.getSlice(s,2,4),slice(8,12,1))
13069         self.assertEqual(d.getSlice(s,3,4),slice(12,18,1))
13070         #
13071         d=DataArrayInt.Range(0,18,1)
13072         s=slice(None,2,-2)
13073         self.assertRaises(InterpKernelException,d.getNumberOfItemGivenBES,s)
13074         self.assertEqual(d.getNumberOfItemGivenBESRelative(s),8)
13075         self.assertEqual(d.getSlice(s,0,4),slice(17,13,-2))
13076         self.assertEqual(d.getSlice(s,1,4),slice(13,9,-2))
13077         self.assertEqual(d.getSlice(s,2,4),slice(9,5,-2))
13078         self.assertEqual(d.getSlice(s,3,4),slice(5,2,-2))
13079         pass
13080
13081     def testSwig2AccumulatePerChunk1(self):
13082         arr=DataArrayDouble(11) ; arr.iota()
13083         m=MEDCouplingCMesh() ; m.setCoords(arr,arr)
13084         m=m.buildUnstructured()
13085         m0=m[::2] ; ids0=m0.simplexize(0) ; m1=m[1::2]
13086         m=MEDCouplingUMesh.MergeUMeshesOnSameCoords(m0,m1) ; m.setName("mesh")
13087         m.checkConsecutiveCellTypesForMEDFileFrmt()
13088         #
13089         formula="7-sqrt((x-5.)*(x-5.)+(y-5.)*(y-5.))"
13090         f=MEDCouplingFieldDouble(ON_CELLS,ONE_TIME) ; f.setMesh(m)
13091         f.fillFromAnalytic(1,formula)
13092         f.setName("Field1") ; f.setTime(1.1,1,-1)
13093         f.checkCoherency()
13094         #
13095         arr=f.getArray()
13096         arr2=DataArrayDouble(len(arr),2) ; arr2[:,0]=arr
13097         arr2=DataArrayDouble(len(arr),2) ; arr2[:,0]=arr ; arr2[:,1]=2*arr
13098         f.setArray(arr2)
13099         f.checkCoherency()
13100         # here the compact code to obviously put field on cell to nodes
13101         rn,rni=f.getMesh().getReverseNodalConnectivity()
13102         arr2=f.getArray()[rn]
13103         arr4=arr2.accumulatePerChunck(rni)
13104         nbOfCellsSharingNodes=rni.deltaShiftIndex()
13105         arr4/=nbOfCellsSharingNodes.convertToDblArr()
13106         #
13107         maxNbCSN=nbOfCellsSharingNodes.getMaxValue()[0]
13108         arr3=DataArrayDouble(f.getMesh().getNumberOfNodes(),f.getArray().getNumberOfComponents()) ; arr3[:]=0.
13109         for i in xrange(1,maxNbCSN+1):
13110             ids=nbOfCellsSharingNodes.getIdsEqual(i)
13111             if len(ids)==0:
13112                 continue
13113             for j in range(i):
13114                 rni2=rni[ids] ; rni2+=j
13115                 arr3[ids]+=arr2[rni2]
13116                 pass
13117             arr3[ids]/=i
13118             pass
13119         fNode=MEDCouplingFieldDouble(ON_NODES,ONE_TIME) ; fNode.setMesh(m)
13120         fNode.setName("Field1Node") ; fNode.setTime(1.1,1,-1)
13121         fNode.setArray(arr3) ; fNode.checkCoherency()
13122         self.assertTrue(arr3.isEqual(arr4,1e-12))
13123         #
13124         d=DataArrayInt.Range(0,20,1)
13125         self.assertTrue(d.accumulatePerChunck([2,4,12]).isEqual(DataArrayInt([5,60])))
13126         #
13127         a=DataArrayDouble(12) ; a.iota() ; a.rearrange(3)
13128         b=DataArrayDouble(12) ; b.iota(20) ; b.rearrange(3)
13129         ids=DataArrayInt([])
13130         self.assertEqual(len(a[ids]),0)
13131         self.assertEqual(len(b[ids]),0)
13132         a2=a.deepCpy() ;  a2[ids]+=b[ids] ; self.assertTrue(a2.isEqual(a,1e-15))
13133         a2=a.deepCpy() ;  a2[ids]*=b[ids] ; self.assertTrue(a2.isEqual(a,1e-15))
13134         a2=a.deepCpy() ;  a2[ids]/=b[ids] ; self.assertTrue(a2.isEqual(a,1e-15))
13135         a2=a.deepCpy() ;  a2[ids]-=b[ids] ; self.assertTrue(a2.isEqual(a,1e-15))
13136         pass
13137
13138     def testSwig2CheckAndPreparePermutation1(self):
13139         a=DataArrayInt([10003,9999999,5,67])
13140         self.assertTrue(a.checkAndPreparePermutation().isEqual(DataArrayInt([2,3,0,1])))
13141         a=DataArrayInt([10003,-9999999,5,67])
13142         self.assertTrue(a.checkAndPreparePermutation().isEqual(DataArrayInt([3,0,1,2])))
13143         a=DataArrayInt([])
13144         self.assertTrue(a.checkAndPreparePermutation().isEqual(DataArrayInt([])))
13145         a=DataArrayInt([])
13146         a.iota();
13147         self.assertTrue(a.isEqual(DataArrayInt([])))
13148         pass
13149
13150     def testSwig21SGTUMesh1(self):
13151         m=MEDCoupling1GTUMesh.New("m",NORM_PENTA6)
13152         m.__repr__() ; m.__str__()
13153         self.assertTrue(isinstance(m,MEDCoupling1SGTUMesh))
13154         m.setCoords(DataArrayDouble(20,3))
13155         m.allocateCells()
13156         m.__repr__() ; m.__str__()
13157         m.insertNextCell([0,1,2,5,7,2])
13158         self.assertEqual(1,m.getNumberOfCells())
13159         self.assertTrue(DataArrayInt([6]).isEqual(m.computeNbOfNodesPerCell()))
13160         self.assertTrue(DataArrayInt([5]).isEqual(m.computeNbOfFacesPerCell()))
13161         m.__repr__() ; m.__str__()
13162         m.checkCoherency()
13163         m.checkCoherency2()
13164         #
13165         cm=MEDCouplingCMesh() ; cm.setName("m")
13166         arr0=DataArrayDouble(6) ; arr0.iota()
13167         arr1=DataArrayDouble([0,1])
13168         cm.setCoords(arr0,arr1,arr1) ; um=cm.buildUnstructured()
13169         #
13170         m=MEDCoupling1SGTUMesh("m",NORM_QUAD4)
13171         mem_m=m.getHeapMemorySize()
13172         m.allocateCells(5)
13173         self.assertIn(m.getHeapMemorySize()-mem_m,xrange(5*4*4,5*4*4+32))
13174         self.assertEqual(m.getNodalConnectivity().getNbOfElemAllocated(),20)
13175         m.setCoords(um.getCoords())
13176         m.insertNextCell([1,0,6,7])
13177         self.assertEqual(1,m.getNumberOfCells())
13178         m.insertNextCell([2,1,7,8])
13179         m.insertNextCell([3,2,8,9])
13180         m.insertNextCell([4,3,9,10])
13181         m.insertNextCell([5,4,10,11])
13182         self.assertEqual(5,m.getNumberOfCells())
13183         self.assertRaises(InterpKernelException,m.insertNextCell,[0,6,7])
13184         self.assertRaises(InterpKernelException,m.insertNextCell,[0,6,7,1,2])
13185         self.assertEqual(m.getNodalConnectivity().getNbOfElemAllocated(),20)
13186         f=m.getMeasureField(ON_CELLS)
13187         self.assertEqual(f.getMesh().getHiddenCppPointer(),m.getHiddenCppPointer())
13188         self.assertTrue(f.getArray().isUniform(1,1e-14))
13189         self.assertEqual(m.getType(),10)
13190         self.assertEqual(m.getCellModelEnum(),NORM_QUAD4)
13191         mo=MEDCoupling1SGTUMesh("m",NORM_QUAD4) ; mo.setCoords(m.getCoords())
13192         mo.setNodalConnectivity(DataArrayInt([1,0,6,7,2,1,7,8,3,2,8,9,4,3,9,10,5,4,10,11]))
13193         self.assertTrue(m.isEqual(mo,1e-12))
13194         #
13195         mo2=MEDCoupling1SGTUMesh.Merge1SGTUMeshesOnSameCoords([m[[0,1]],m[[2]],m[[3,4]]])
13196         mo2.setName(m.getName())
13197         self.assertTrue(m.isEqual(mo2,1e-12))
13198         #
13199         mp0=m[[0]] ; mp0.zipCoords() ; mp1=m[2] ; mp1.zipCoords() ; mp2=m[4] ; mp2.zipCoords()
13200         mo3=MEDCoupling1SGTUMesh.Merge1SGTUMeshes([mp0,mp1,mp2])
13201         self.assertTrue(isinstance(mo3,MEDCoupling1SGTUMesh))
13202         mo3.setName(m.getName())
13203         m_ref=m[(0,2,4)] ; m_ref.zipCoords()
13204         m_ref.tryToShareSameCoordsPermute(mo3,1e-12)
13205         self.assertTrue(m_ref.isEqual(mo3,1e-12))
13206         #
13207         m1=um.buildDescendingConnectivity()[0]
13208         ids=m1.getCellIdsFullyIncludedInNodeIds(DataArrayInt.Range(0,12,1))
13209         m1=m1[ids]
13210         m1c=m1.convertIntoSingleGeoTypeMesh()
13211         self.assertTrue(isinstance(m1c,MEDCoupling1SGTUMesh))
13212         self.assertEqual(m1c.getCoords().getHiddenCppPointer(),m.getCoords().getHiddenCppPointer())
13213         m1c.checkCoherency2()
13214         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])))
13215         self.assertEqual(20,m1c.getNodalConnectivityLength())
13216         self.assertTrue(m.isEqual(m1c,1e-12))
13217         m.getNodalConnectivity().setIJ(1,0,1)
13218         self.assertTrue(not m.isEqual(m1c,1e-12))
13219         m.getNodalConnectivity().setIJ(1,0,0)
13220         self.assertTrue(m.isEqual(m1c,1e-12))
13221         m1c.setCoords(m.getCoords().deepCpy())
13222         self.assertTrue(m.isEqual(m1c,1e-12))
13223         m1c.getCoords().setIJ(0,1,0.1)
13224         self.assertTrue(not m.isEqual(m1c,1e-12))
13225         m1c.getCoords().setIJ(0,1,0)
13226         self.assertTrue(m.isEqual(m1c,1e-12))
13227         m1c.getCoords().setInfoOnComponent(1,"X")
13228         self.assertTrue(not m.isEqual(m1c,1e-12) and m.isEqualWithoutConsideringStr(m1c,1e-12))
13229         m.getCoords().setInfoOnComponent(1,"X")
13230         self.assertTrue(m.isEqual(m1c,1e-12) and m.isEqualWithoutConsideringStr(m1c,1e-12))
13231         m.setName("m2")
13232         self.assertTrue(not m.isEqual(m1c,1e-12) and m.isEqualWithoutConsideringStr(m1c,1e-12))
13233         #
13234         m.checkCoherency() ; m.checkCoherency1() ; m.checkCoherency2()
13235         self.assertEqual(m.getMeshDimension(),2)
13236         self.assertTrue(m.giveCellsWithType(NORM_QUAD4).isEqual(DataArrayInt([0,1,2,3,4])))
13237         self.assertTrue(m.giveCellsWithType(NORM_TRI3).isEqual(DataArrayInt([])))
13238         self.assertEqual(m.getNumberOfCellsWithType(NORM_QUAD4),5)
13239         self.assertEqual(m.getNumberOfCellsWithType(NORM_TRI3),0)
13240         self.assertEqual(m.getTypeOfCell(3),NORM_QUAD4)
13241         self.assertRaises(InterpKernelException,m.getTypeOfCell,5)
13242         self.assertEqual(m.getAllGeoTypes(),[NORM_QUAD4])
13243         self.assertEqual(m.getDistributionOfTypes(),[[NORM_QUAD4,5,-1]])
13244         ##
13245         pfl1=DataArrayInt([1,3,4])
13246         a,b,c=m.splitProfilePerType(pfl1)
13247         d,e,f=m.buildUnstructured().splitProfilePerType(pfl1)
13248         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())
13249         self.assertTrue(a==d and len(b)==1 and b[0].isEqual(e[0]) and len(c)==1 and c[0].isEqual(f[0]))
13250         #
13251         pfl2=DataArrayInt([0,1,2,3])
13252         a,b,c=m.splitProfilePerType(pfl2)
13253         d,e,f=m.buildUnstructured().splitProfilePerType(pfl2)
13254         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())
13255         self.assertTrue(a==d and len(b)==1 and b[0].isEqual(e[0]) and len(c)==1 and c[0].isEqual(f[0]))
13256         #
13257         pfl3=DataArrayInt([0,1,2,3,4])
13258         a,b,c=m.splitProfilePerType(pfl3)
13259         d,e,f=m.buildUnstructured().splitProfilePerType(pfl3)
13260         self.assertTrue(a==[[4,5,-1]] and len(b)==1 and b[0].isEqual(DataArrayInt([0,1,2,3,4])) and c==[])
13261         self.assertTrue(a==d and len(b)==1 and b[0].isEqual(e[0]) and c==[])
13262         #
13263         invalidPfl=DataArrayInt([1,2,3,4,5])
13264         self.assertRaises(InterpKernelException,m.splitProfilePerType,invalidPfl)
13265         self.assertRaises(InterpKernelException,m.buildUnstructured().splitProfilePerType,invalidPfl)
13266         ##
13267         pfl1=DataArrayInt([1,2,3])
13268         a=m.checkTypeConsistencyAndContig([NORM_QUAD4,3,0],[pfl1])
13269         b=m.buildUnstructured().checkTypeConsistencyAndContig([NORM_QUAD4,3,0],[pfl1])
13270         self.assertTrue(a.isEqual(b) and pfl1.getHiddenCppPointer(),a.getHiddenCppPointer())
13271         #
13272         pfl2=DataArrayInt([0,1,2,3])
13273         a=m.checkTypeConsistencyAndContig([NORM_QUAD4,4,0],[pfl2])
13274         b=m.buildUnstructured().checkTypeConsistencyAndContig([NORM_QUAD4,4,0],[pfl2])
13275         self.assertTrue(a.isEqual(b) and pfl2.getHiddenCppPointer()==a.getHiddenCppPointer())
13276         #
13277         pfl3=DataArrayInt([0,1,2,3,4])
13278         a=m.checkTypeConsistencyAndContig([NORM_QUAD4,4,0],[pfl3])
13279         b=m.buildUnstructured().checkTypeConsistencyAndContig([NORM_QUAD4,5,0],[pfl3])
13280         self.assertTrue(a.isEqual(b) and pfl3.getHiddenCppPointer()==a.getHiddenCppPointer())
13281         #
13282         invalidPfl=DataArrayInt([1,2,3,4,5])
13283         self.assertRaises(InterpKernelException,m.checkTypeConsistencyAndContig,[NORM_QUAD4,5,0],[invalidPfl])
13284         self.assertRaises(InterpKernelException,m.buildUnstructured().checkTypeConsistencyAndContig,[NORM_QUAD4,5,0],[invalidPfl])
13285         ##
13286         self.assertTrue(DataArrayInt([4,4,4,4,4]).isEqual(m.computeNbOfNodesPerCell()))
13287         ##
13288         self.assertEqual(m.getNodeIdsOfCell(1),[2,1,7,8])
13289         ##
13290         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))
13291         ##
13292         ref=m.getCoords().getHiddenCppPointer()
13293         mcpy=m.deepCpy() ; mcpy.insertNextCell([1,0,6,7])
13294         c=m.getNodalConnectivity().deepCpy()
13295         o2n=DataArrayInt([2,0,1,4,3])
13296         m.renumberCells(o2n,False)
13297         c.rearrange(4) ; c.renumberInPlace(o2n) ; c.rearrange(1)
13298         self.assertTrue(c.isEqual(m.getNodalConnectivity()))
13299         self.assertEqual(ref,m.getCoords().getHiddenCppPointer())
13300         m2=mcpy.mergeMyselfWith(m)
13301         self.assertTrue(isinstance(m2,MEDCoupling1SGTUMesh))
13302         self.assertEqual(11,m2.getNumberOfCells())
13303         self.assertEqual(48,m2.getNumberOfNodes())
13304         self.assertTrue(m2.getCoords().isEqual(DataArrayDouble.Aggregate([m.getCoords(),m.getCoords()]),1e-12))
13305         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])))
13306         ##
13307         mu=m.buildUnstructured()
13308         mu.checkCoherency2()
13309         self.assertEqual(mu.getCoords().getHiddenCppPointer(),m.getCoords().getHiddenCppPointer())
13310         self.assertEqual(2,mu.getMeshDimension())
13311         self.assertEqual([NORM_QUAD4],mu.getAllGeoTypes())
13312         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])))
13313         self.assertTrue(mu.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5,10,15,20,25])))
13314         ##
13315         for typ in [0,1]:
13316             mcpy2=m.deepCpy() ; umcpy2=mcpy2.buildUnstructured()
13317             ids=mcpy2.simplexize(typ) ; ids2=umcpy2.simplexize(typ)
13318             self.assertTrue(ids.isEqual(ids2))
13319             mcpy3=umcpy2.convertIntoSingleGeoTypeMesh()
13320             self.assertTrue(mcpy2.isEqual(mcpy3,1e-14))
13321             pass
13322         um1=um.convertIntoSingleGeoTypeMesh()
13323         self.assertEqual(8,um1.getNumberOfNodesPerCell())
13324         for typ in [PLANAR_FACE_5,PLANAR_FACE_6]:
13325             mcpy2=um1.deepCpy() ; umcpy2=mcpy2.buildUnstructured()
13326             ids=mcpy2.simplexize(typ) ; ids2=umcpy2.simplexize(typ)
13327             self.assertTrue(ids.isEqual(ids2))
13328             mcpy3=umcpy2.convertIntoSingleGeoTypeMesh()
13329             self.assertTrue(mcpy2.isEqual(mcpy3,1e-14))
13330             pass
13331         ##
13332         self.assertRaises(InterpKernelException,mcpy.mergeMyselfWithOnSameCoords,m)
13333         mcpy.tryToShareSameCoords(m,1e-14)
13334         m3=mcpy.mergeMyselfWithOnSameCoords(m)
13335         self.assertTrue(isinstance(m3,MEDCoupling1SGTUMesh))
13336         self.assertEqual(11,m3.getNumberOfCells())
13337         self.assertEqual(24,m3.getNumberOfNodes())
13338         self.assertEqual(m3.getCoords().getHiddenCppPointer(),mcpy.getCoords().getHiddenCppPointer())
13339         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])))
13340         ##
13341         ref=mcpy.getCoords().deepCpy()
13342         c3=mcpy.getNodalConnectivity()[:]
13343         mcpy.getNodalConnectivity().setIJ(int(c3.getIdsEqual(11)),0,24)
13344         c2=DataArrayDouble.Aggregate([mcpy.getCoords(),mcpy.getCoords()[11:]])
13345         mcpy.setCoords(c2)
13346         mcpy.checkCoherency2()
13347         a,b=mcpy.getNodeIdsInUse()
13348         self.assertEqual(12,b)
13349         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])))
13350         ids=mcpy.zipCoordsTraducer()
13351         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])))
13352         self.assertTrue(mcpy.getCoords().isEqual(ref[:12],1e-12))
13353         self.assertTrue(mcpy.getNodalConnectivity().isEqual(c3))
13354         mcpy.checkCoherency2()
13355         ##
13356         m4=mcpy[DataArrayInt([0,3,4])]
13357         m5=mcpy.buildPartOfMySelfKeepCoords(DataArrayInt([0,3,4]))
13358         self.assertTrue(isinstance(m4,MEDCoupling1SGTUMesh))
13359         self.assertTrue(m4.isEqual(m5,-1e-14))# < 0 not a bug it proves that coordinates pointer are equal
13360         self.assertTrue(m4.getNodalConnectivity().isEqual(DataArrayInt([1,0,6,7,4,3,9,10,5,4,10,11])))
13361         m6=mcpy[::2]
13362         self.assertTrue(isinstance(m6,MEDCoupling1SGTUMesh))
13363         self.assertTrue(m6.getNodalConnectivity().isEqual(DataArrayInt([1,0,6,7,3,2,8,9,5,4,10,11])))
13364         ##
13365         mcpy.setCoords(DataArrayDouble.Aggregate([mcpy.getCoords(),mcpy.getCoords()]))
13366         mcpy.checkCoherency2()
13367         ##
13368         mcppy=mcpy.deepCpyConnectivityOnly()
13369         self.assertTrue(mcppy.isEqual(mcpy,1e-12))
13370         self.assertTrue(mcppy.getCoords().getHiddenCppPointer()==mcpy.getCoords().getHiddenCppPointer())
13371         self.assertTrue(mcppy.getNodalConnectivity().isEqual(mcpy.getNodalConnectivity()))
13372         self.assertTrue(mcppy.getNodalConnectivity().getHiddenCppPointer()!=mcpy.getNodalConnectivity().getHiddenCppPointer())
13373         ##
13374         a,b=mcpy.getReverseNodalConnectivity()
13375         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])))
13376         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])))
13377         self.assertTrue(mcpy.fillCellIdsToKeepFromNodeIds([0,1,6,7],False).isEqual(DataArrayInt([0,1,5])))
13378         self.assertTrue(mcpy.fillCellIdsToKeepFromNodeIds([0,1,6,7],True).isEqual(DataArrayInt([0,5])))
13379         self.assertTrue(mcpy.getCellsInBoundingBox([(0,1),(0,1),(0,1)],1e-12).isEqual(DataArrayInt([0,1,5])))
13380         f=mcpy.buildOrthogonalField()
13381         self.assertEqual(f.getMesh().getHiddenCppPointer(),mcpy.getHiddenCppPointer())
13382         self.assertTrue(f.getArray().isEqual(DataArrayDouble(6*[(0,0,-1)]),1e-12))
13383         mcpy.changeSpaceDimension(2)
13384         self.assertEqual(1,mcpy.getCellContainingPoint([1.5,0.5],1e-12))
13385         ##
13386         self.assertTrue(mcpy.fillCellIdsToKeepFromNodeIds(DataArrayInt([6,7]),False).isEqual(DataArrayInt([0,1,5])))
13387         ##
13388         mcpy2=mcpy.deepCpy()
13389         self.assertEqual([None,None],mcpy.checkGeoEquivalWith(mcpy2,1,1e-12))#fast equal
13390         mcpy.checkFastEquivalWith(mcpy2,1e-12)
13391         mcpy2.renumberCells([0,2,4,3,1,5])
13392         mcpy.checkFastEquivalWith(mcpy2,1e-12)
13393         self.assertEqual([None,None],mcpy.checkGeoEquivalWith(mcpy2,1,1e-12))#fast equal
13394         mcpy2.renumberCells([0,2,4,3,1,5])
13395         mcpy2.renumberCells([1,3,5,0,2,4])
13396         self.assertRaises(InterpKernelException,mcpy.checkFastEquivalWith,mcpy2,1e-12)
13397         self.assertRaises(InterpKernelException,mcpy.checkGeoEquivalWith,mcpy2,1,1e-12)#fast equal
13398         pass
13399
13400     def testSwig21DGTUMesh1(self):
13401         a0=DataArrayInt([0,2,3,5,6,8])
13402         a1=DataArrayInt([0,4,7,11,14,18,21,25])
13403         a2=DataArrayInt([0,1,4,5])
13404         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])))
13405         self.assertEqual(a1[3:].front(),11)
13406         self.assertEqual(a1[4:].convertToDblArr().front(),14.)
13407         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])
13408         d,e=MEDCouplingUMesh.ExtractFromIndexedArrays2(1,5,2,a1c,a1)
13409         self.assertTrue(d.isEqual(DataArrayInt([8,11,0,1,5,2])))
13410         self.assertTrue(e.isEqual(DataArrayInt([0,3,6])))
13411         #
13412         m=MEDCouplingDataForTest.build2DTargetMesh_1()[0,3,4]
13413         ref=DataArrayInt([0,3,4,1,6,7,4,3,7,8,5,4])
13414         self.assertTrue(m.convertNodalConnectivityToStaticGeoTypeMesh().isEqual(ref))
13415         d,e=m.convertNodalConnectivityToDynamicGeoTypeMesh()
13416         self.assertTrue(d.isEqual(ref))
13417         self.assertTrue(e.isEqual(DataArrayInt.Range(0,13,4)))
13418         self.assertTrue(m.fillCellIdsToKeepFromNodeIds(DataArrayInt([6,7]),False).isEqual(DataArrayInt([1,2])))
13419         #
13420         m=MEDCoupling1GTUMesh.New("m",NORM_POLYHED)
13421         self.assertTrue(isinstance(m,MEDCoupling1DGTUMesh))
13422         m.__repr__() ; m.__str__()
13423         m.setCoords(DataArrayDouble(20,3))
13424         m.allocateCells()
13425         m.__repr__() ; m.__str__()
13426         m.insertNextCell([0,1,2,5,7,2,-1,1,3])
13427         self.assertEqual(1,m.getNumberOfCells())
13428         self.assertTrue(DataArrayInt([8]).isEqual(m.computeNbOfNodesPerCell()))
13429         self.assertTrue(DataArrayInt([2]).isEqual(m.computeNbOfFacesPerCell()))
13430         m.__repr__() ; m.__str__()
13431         m.checkCoherency()
13432         m.checkCoherency2()
13433         #
13434         cm=MEDCouplingCMesh() ; cm.setName("m")
13435         arr0=DataArrayDouble(6) ; arr0.iota()
13436         arr1=DataArrayDouble([0,1])
13437         cm.setCoords(arr0,arr1,arr1) ; um=cm.buildUnstructured() ; um.convertAllToPoly()
13438         um2=um.deepCpyConnectivityOnly()
13439         self.assertTrue(um2.isEqual(um,1e-12))
13440         self.assertEqual(um2.getCoords().getHiddenCppPointer(),um.getCoords().getHiddenCppPointer())
13441         self.assertTrue(um2.getNodalConnectivity().isEqual(um.getNodalConnectivity()))
13442         self.assertTrue(um2.getNodalConnectivity().getHiddenCppPointer()!=um.getNodalConnectivity().getHiddenCppPointer())
13443         self.assertTrue(um2.getNodalConnectivityIndex().isEqual(um.getNodalConnectivityIndex()))
13444         self.assertTrue(um2.getNodalConnectivityIndex().getHiddenCppPointer()!=um.getNodalConnectivityIndex().getHiddenCppPointer())
13445         #
13446         self.assertRaises(InterpKernelException,MEDCoupling1SGTUMesh.New,"m",NORM_POLYHED)
13447         m=MEDCoupling1DGTUMesh("m",NORM_POLYHED)
13448         m.allocateCells(5)
13449         self.assertEqual(15,m.getNodalConnectivity().getNbOfElemAllocated())
13450         self.assertEqual(6,m.getNodalConnectivityIndex().getNbOfElemAllocated())
13451         m.setCoords(um.getCoords())
13452         m.insertNextCell([1,0,6,7,-1,7,6,1])
13453         self.assertEqual(1,m.getNumberOfCells())
13454         m.insertNextCell([2,1,7,8,-1,2,1,-1,8,-1,7])
13455         m.insertNextCell([3,2,8,9])
13456         m.insertNextCell([4,3,9,10,-1,5,3,9])
13457         m.insertNextCell([5,4,10,11,-1,11,10,-1,5])
13458         m.checkCoherency()
13459         m.checkCoherency2()
13460         self.assertEqual(5,m.getNumberOfCells())
13461         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,8,19,23,31,40])))
13462         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])))
13463         #
13464         m4=m.deepCpy()
13465         self.assertTrue(m.isEqual(m4,1e-12))
13466         m4.getNodalConnectivity().setIJ(2,0,5)
13467         self.assertTrue(not m.isEqual(m4,1e-12))
13468         m4.getNodalConnectivity().setIJ(2,0,6)
13469         self.assertTrue(m.isEqual(m4,1e-12))
13470         m4.getNodalConnectivityIndex().setIJ(2,0,21)
13471         self.assertTrue(not m.isEqual(m4,1e-12))
13472         m4.getNodalConnectivityIndex().setIJ(2,0,19)
13473         self.assertTrue(m.isEqual(m4,1e-12))
13474         m4.getCoords().setIJ(10,1,1.1)
13475         self.assertTrue(not m.isEqual(m4,1e-12))
13476         m4.getCoords().setIJ(10,1,1.)
13477         self.assertTrue(m.isEqual(m4,1e-12))
13478         m4.getNodalConnectivity().pushBackSilent(7)
13479         self.assertTrue(not m.isEqual(m4,1e-12))
13480         self.assertEqual(7,m4.getNodalConnectivity().popBackSilent())
13481         self.assertTrue(m.isEqual(m4,1e-12))
13482         m4.setName("m4")
13483         self.assertTrue(not m.isEqual(m4,1e-12))
13484         m4.setName("m")
13485         self.assertTrue(m.isEqual(m4,1e-12))
13486         #
13487         self.assertEqual(6,m.getNodalConnectivityIndex().getNbOfElemAllocated())
13488         self.assertEqual(60,m.getNodalConnectivity().getNbOfElemAllocated())
13489         self.assertTrue(m.computeNbOfNodesPerCell().isEqual(DataArrayInt([7,8,4,7,7])))
13490         self.assertTrue(m.computeNbOfFacesPerCell().isEqual(DataArrayInt([2,4,1,2,3])))
13491         self.assertEqual(m.getNodeIdsOfCell(1),[2,1,7,8,-1,2,1,-1,8,-1,7])
13492         f=m.computeIsoBarycenterOfNodesPerCell()
13493         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))
13494         mu0=m.buildUnstructured()
13495         o2n=[1,2,0,4,3]
13496         m2=m.deepCpy()
13497         m3=m.deepCpyConnectivityOnly()
13498         self.assertTrue(m3.isEqual(m,1e-12))
13499         self.assertEqual(m3.getCoords().getHiddenCppPointer(),m.getCoords().getHiddenCppPointer())
13500         self.assertTrue(m3.getNodalConnectivity().getHiddenCppPointer()!=m.getNodalConnectivity().getHiddenCppPointer())
13501         self.assertTrue(m3.getNodalConnectivity().isEqual(m.getNodalConnectivity()))
13502         self.assertTrue(m3.getNodalConnectivityIndex().getHiddenCppPointer()!=m.getNodalConnectivityIndex().getHiddenCppPointer())
13503         self.assertTrue(m3.getNodalConnectivityIndex().isEqual(m.getNodalConnectivityIndex()))
13504         m.renumberCells(o2n)
13505         mu0.renumberCells(o2n)
13506         self.assertTrue(mu0.isEqual(m.buildUnstructured(),1e-12))
13507         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4,12,23,32,40])))
13508         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])))
13509         #
13510         mcpy0=m.buildUnstructured()
13511         self.assertTrue(isinstance(mcpy0,MEDCouplingUMesh))
13512         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])))
13513         self.assertTrue(mcpy0.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5,14,26,36,45])))
13514         self.assertEqual(mcpy0.getAllGeoTypes(),[NORM_POLYHED])
13515         mcpy0.checkCoherency()
13516         mcpy0.checkCoherency2()
13517         mcpy1=mcpy0.convertIntoSingleGeoTypeMesh()
13518         self.assertTrue(mcpy1.isEqual(m,1e-12))
13519         #
13520         m_mrg=MEDCoupling1DGTUMesh.Merge1DGTUMeshes([m2,m,m2])
13521         self.assertTrue(m_mrg.getNodalConnectivityIndex().isEqual(DataArrayInt([0,8,19,23,31,40,44,52,63,72,80,88,99,103,111,120])))
13522         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])))
13523         m_mrg2=MEDCoupling1DGTUMesh.Merge1DGTUMeshesOnSameCoords([m3,m,m3])
13524         self.assertTrue(m_mrg2.getNodalConnectivityIndex().isEqual(DataArrayInt([0,8,19,23,31,40,44,52,63,72,80,88,99,103,111,120])))
13525         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])))
13526         a,b=m_mrg2.getReverseNodalConnectivity()
13527         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])))
13528         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])))
13529         self.assertTrue(m_mrg2.fillCellIdsToKeepFromNodeIds([7],False).isEqual(DataArrayInt([0,1,6,7,10,11])))
13530         self.assertTrue(m_mrg2.fillCellIdsToKeepFromNodeIds([0,1,6,7],True).isEqual(DataArrayInt([0,6,10])))
13531         #
13532         self.assertTrue(m_mrg2.isPacked())
13533         self.assertEqual(120,m_mrg2.getNodalConnectivityIndex().popBackSilent())
13534         self.assertEqual(m_mrg2.getNumberOfCells(),14)
13535         m_mrg2.checkCoherency2()
13536         self.assertTrue(not m_mrg2.isPacked())
13537         m_mrg4,b=m_mrg2.copyWithNodalConnectivityPacked()
13538         self.assertTrue(not b)
13539         m_mrg4.checkCoherency2()
13540         self.assertEqual(m_mrg4.getNumberOfCells(),14)
13541         self.assertTrue(m_mrg4.getNodalConnectivityIndex().isEqual(m_mrg2.getNodalConnectivityIndex()))
13542         self.assertEqual(len(m_mrg4.getNodalConnectivity()),111)
13543         self.assertEqual(len(m_mrg2.getNodalConnectivity()),120)
13544         self.assertTrue(m_mrg4.getNodalConnectivity().isEqual(m_mrg2.getNodalConnectivity()[:111]))
13545         #
13546         m0=m_mrg2[:5]
13547         m1=m_mrg2[[5,6,7,8,9]]
13548         m2=m_mrg2[10:]
13549         self.assertTrue(m1.isEqualWithoutConsideringStr(m,1e-12))
13550         a,b=m.checkGeoEquivalWith(m0,12,1e-12)
13551         self.assertTrue(a.isEqual(DataArrayInt(o2n)))
13552         self.assertTrue(b is None)
13553         pass
13554
13555     def testSwig2DADAreIncludedInMe1(self):
13556         a=DataArrayDouble(30) ; a.iota() ; a.rearrange(3)
13557         p=DataArrayInt([5,2,1,9])
13558         b,c=a.areIncludedInMe(a[p],1e-12)
13559         self.assertTrue(b)
13560         self.assertTrue(c.isEqual(p))
13561         d=a[p]
13562         d.setIJ(3,1,28.1)
13563         b,c=a.areIncludedInMe(d,1e-12)
13564         self.assertTrue(not b)
13565         self.assertTrue(c.isEqual(DataArrayInt([5,2,1,10])))
13566         pass
13567
13568     def testSwig2DADesallocate1(self):
13569         d=DataArrayDouble([(1,2),(6,7),(6,8)]) ; d.setInfoOnComponents(["aa","bbb"])
13570         self.assertTrue(d.isAllocated())
13571         d.checkAllocated()
13572         self.assertEqual(d.getInfoOnComponents(),["aa","bbb"])
13573         ref=d.getHeapMemorySize()
13574         d.desallocate()
13575         self.assertEqual(ref-d.getHeapMemorySize(),6*8)
13576         self.assertTrue(not d.isAllocated())
13577         self.assertEqual(d.getInfoOnComponents(),["aa","bbb"])
13578         self.assertRaises(InterpKernelException,d.checkAllocated)
13579         #
13580         d=DataArrayInt([(1,2),(6,7),(6,8)]) ; d.setInfoOnComponents(["aa","bbb"])
13581         self.assertTrue(d.isAllocated())
13582         d.checkAllocated()
13583         self.assertEqual(d.getInfoOnComponents(),["aa","bbb"])
13584         ref=d.getHeapMemorySize()
13585         d.desallocate()
13586         self.assertEqual(ref-d.getHeapMemorySize(),6*4)
13587         self.assertTrue(not d.isAllocated())
13588         self.assertEqual(d.getInfoOnComponents(),["aa","bbb"])
13589         self.assertRaises(InterpKernelException,d.checkAllocated)
13590         pass
13591
13592     def testSwig2IsPartStructured1(self):
13593         #dim 1
13594         d10=DataArrayInt([2,3,4,5,6,7,8,9,10,11])
13595         a,b=MEDCouplingStructuredMesh.IsPartStructured(d10,[13])
13596         self.assertTrue(a) ; self.assertEqual(b,[(2,12)])
13597         d11=DataArrayInt([2,3,4,5,6,7,8,10,9,11])
13598         a,b=MEDCouplingStructuredMesh.IsPartStructured(d11,[13])
13599         self.assertTrue(not a)
13600         self.assertRaises(InterpKernelException,MEDCouplingStructuredMesh.IsPartStructured,d10,[11])
13601         #dim 2
13602         st=[10,4]
13603         d20=DataArrayInt([1,2,3,4,11,12,13,14,21,22,23,24])
13604         a,b=MEDCouplingStructuredMesh.IsPartStructured(d20,st)
13605         self.assertTrue(a) ; self.assertEqual(b,[(1,5),(0,3)])
13606         self.assertEqual(12,MEDCouplingStructuredMesh.DeduceNumberOfGivenRangeInCompactFrmt(b))
13607         self.assertEqual(0,MEDCouplingStructuredMesh.DeduceNumberOfGivenRangeInCompactFrmt([(1,5),(1,3),(2,2)]))
13608         self.assertEqual(0,MEDCouplingStructuredMesh.DeduceNumberOfGivenRangeInCompactFrmt([(5,5),(3,3),(2,2)]))
13609         self.assertEqual(36,MEDCouplingStructuredMesh.DeduceNumberOfGivenStructure([3,2,6]))
13610         self.assertEqual(126,MEDCouplingStructuredMesh.DeduceNumberOfGivenStructure((3,7,6)))
13611         d20=DataArrayInt([1,2,3,4,12,11,13,14,21,22,23,24])
13612         a,b=MEDCouplingStructuredMesh.IsPartStructured(d20,st)
13613         self.assertTrue(not a)
13614         d20=DataArrayInt([1,2,3,4,11,12,13,15,21,22,23,24])
13615         a,b=MEDCouplingStructuredMesh.IsPartStructured(d20,st)
13616         self.assertTrue(not a)
13617         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])
13618         a,b=MEDCouplingStructuredMesh.IsPartStructured(d21,st)
13619         self.assertTrue(a) ; self.assertEqual(b,[(0,10),(0,4)])
13620         d22=DataArrayInt([1,2,3,4,11,12,13,14,21,22,23,24,31,32,33,34,41,42,43,44])
13621         self.assertRaises(InterpKernelException,MEDCouplingStructuredMesh.IsPartStructured,d22,st)
13622         a,b=MEDCouplingStructuredMesh.IsPartStructured(d22,[10,5])
13623         self.assertTrue(a) ; self.assertEqual(b,[(1,5),(0,5)])
13624         #dim 3
13625         d30=DataArrayInt([11,12,13,14,21,22,23,24,51,52,53,54,61,62,63,64])
13626         a,b=MEDCouplingStructuredMesh.IsPartStructured(d30,[10,4,2])
13627         self.assertTrue(a) ; self.assertEqual(b,[(1,5),(1,3),(0,2)])
13628         d31=DataArrayInt([11,12,13,14,21,22,24,23,51,52,53,54,61,62,63,64])
13629         a,b=MEDCouplingStructuredMesh.IsPartStructured(d31,[10,4,2])
13630         self.assertTrue(not a)
13631         self.assertRaises(InterpKernelException,MEDCouplingStructuredMesh.IsPartStructured,d30,[10,4,1])
13632         pass
13633
13634     def testSwig2PartStructured1(self):
13635         c=MEDCouplingCMesh() ; c.setName("toto")
13636         arr0=DataArrayDouble(10); arr0.iota()
13637         arr1=DataArrayDouble(4) ; arr1.iota(3)
13638         c.setCoords(arr0,arr1)
13639         self.assertEqual(c.getNodeGridStructure(),(10,4))
13640         self.assertEqual(c.getCellGridStructure(),(9,3))
13641         d20=DataArrayInt([1,2,3,4,10,11,12,13,19,20,21,22])
13642         self.assertEqual(27,c.getNumberOfCells())
13643         self.assertEqual(40,c.getNumberOfNodes())
13644         self.assertEqual(2,c.getMeshDimension())
13645         c.checkCoherency()
13646         #
13647         arr2=MEDCouplingStructuredMesh.BuildExplicitIdsFrom([9,3],[(1,5),(0,3)])
13648         self.assertTrue(arr2.isEqual(DataArrayInt([1,2,3,4,10,11,12,13,19,20,21,22])))
13649         # CMesh
13650         c2=c.buildStructuredSubPart([(1,5),(0,3)])
13651         c2.checkCoherency()
13652         self.assertTrue(isinstance(c2,MEDCouplingCMesh))
13653         self.assertEqual(12,c2.getNumberOfCells())
13654         self.assertEqual(20,c2.getNumberOfNodes())
13655         self.assertEqual(2,c2.getMeshDimension())
13656         self.assertEqual("toto",c2.getName())
13657         self.assertTrue(c2.getCoordsAt(0).isEqual(DataArrayDouble([1.,2.,3.,4.,5.]),1e-12))
13658         self.assertTrue(c2.getCoordsAt(1).isEqual(DataArrayDouble([3.,4.,5.,6.]),1e-12))
13659         #
13660         a,b=c.buildPartAndReduceNodes(d20)
13661         a.checkCoherency()
13662         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])
13663         self.assertTrue(exp2.isEqual(b))
13664         self.assertTrue(isinstance(a,MEDCouplingCMesh))
13665         self.assertTrue(a.buildUnstructured().isEqual(c.buildUnstructured().buildPartAndReduceNodes(d20)[0],1e-12))
13666         # CurveLinearMesh
13667         c2=MEDCouplingCurveLinearMesh() ; c2.setName("toto")
13668         c2.setCoords(c.buildUnstructured().getCoords())
13669         c2.setNodeGridStructure([10,4])
13670         c2.checkCoherency()
13671         a,b=c2.buildPartAndReduceNodes(d20)
13672         a.checkCoherency()
13673         self.assertTrue(exp2.isEqual(b))
13674         self.assertTrue(isinstance(a,MEDCouplingCurveLinearMesh))
13675         self.assertTrue(a.buildUnstructured().isEqual(c2.buildUnstructured().buildPartAndReduceNodes(d20)[0],1e-12))
13676         pass
13677
13678     def testSwig2FindPermutationFromFirstToSecond1(self):
13679         ids1=DataArrayInt([3,1,103,4,6,10,-7,205])
13680         ids2=DataArrayInt([-7,1,205,10,6,3,103,4])
13681         ids3=DataArrayInt.FindPermutationFromFirstToSecond(ids1,ids2)
13682         self.assertTrue(ids3.isEqual(DataArrayInt([5,1,6,7,4,3,0,2])))
13683         ids2ToTest=ids1.renumber(ids3)
13684         self.assertTrue(ids2ToTest.isEqual(ids2))
13685         self.assertRaises(InterpKernelException,DataArrayInt.FindPermutationFromFirstToSecond,DataArrayInt([3,1,103]),DataArrayInt([1,103]))
13686         self.assertRaises(InterpKernelException,DataArrayInt.FindPermutationFromFirstToSecond,DataArrayInt([3,1,103]),DataArrayInt([1,103,2]))
13687         self.assertRaises(InterpKernelException,DataArrayInt.FindPermutationFromFirstToSecond,DataArrayInt([3,1,103]),DataArrayInt([1,103,1]))
13688         self.assertTrue(DataArrayInt.FindPermutationFromFirstToSecond(DataArrayInt([]),DataArrayInt([])).empty())
13689         pass
13690
13691     def testSwig2BugStructuredMeshGetNodeIdsOfCell1(self):
13692         m=MEDCouplingCMesh("mesh")
13693         coordsX=DataArrayDouble([0,1.1,2.2,3.3,4.4]) ; coordsX.setInfoOnComponents(["XX [m]"])
13694         coordsY=DataArrayDouble([0,1.7,3.4]) ; coordsY.setInfoOnComponents(["YYY [km]"])
13695         m.setCoords(coordsX,coordsY)
13696         self.assertEqual([2,3,8,7],m.getNodeIdsOfCell(2))
13697         self.assertEqual([3,4,9,8],m.getNodeIdsOfCell(3))
13698         self.assertEqual([7,8,13,12],m.getNodeIdsOfCell(6))
13699         self.assertEqual([8,9,14,13],m.getNodeIdsOfCell(7))
13700         pass
13701
13702     def testSwig2ThrowOnDAIInvertN2O2ON2(self):
13703         p1=DataArrayInt([3,5,8])
13704         p2=DataArrayInt([0,3,4,5,6,7,8,9,10])
13705         p1.transformWithIndArr(p2.invertArrayN2O2O2N(11))
13706         self.assertTrue(p1.isEqual(DataArrayInt([1,3,6])))
13707         self.assertTrue(p2.invertArrayN2O2O2N(11).isEqual(DataArrayInt([0,-1,-1,1,2,3,4,5,6,7,8])))
13708         self.assertRaises(InterpKernelException,p2.invertArrayN2O2O2N,10)
13709         pass
13710
13711     def testSwig2ComputeEffectiveNbOfNodesPerCell1(self):
13712         coords=DataArrayDouble([ 0.241310763507 , 0.0504777305619 , 0.0682283524903 , 0.252501053866 , -0.0625176732937 , 0.137272639894 ,
13713                  0.152262663601 , 0.241816569527 , 0.133812556197 , 0.18047750211 , -0.0789949051358 , 0.339098173401 ,
13714                  0.151741971857 , 0.238885278571 , 0.137715037333 , 0.242532155481 , -0.0928169086456 , 0.0678043417367 ,
13715                  0.240941965335 , -0.015461491464 , 0.0617186345825 , 0.24127650112 , 0.0499427876717 , 0.0679634099148 ,
13716                  -0.145828917428 , 0.206291632565 , 0.0310071927543 , 0.0125651775307 , 0.266262085828 , 0.105228430543 ,
13717                  -0.0994066533286 , 0.233224271238 , 0.0572213839567 , -0.0951345338317 , 0.234819509426 , 0.0592126284538 ,
13718                  0.136580574205 , -0.205486212579 , 0.0572866072014 , 0.0637270784978 , -0.168886355238 , 0.446614057077 ,
13719                  0.041337157151 , -0.213402568198 , 0.372407095999 , 0.0411601970268 , -0.202387875756 , 0.411334979491 ,
13720                  -0.108355701857 , 0.193636239335 , 0.204886756738 , 0.00639779029829 , 0.155296981517 , 0.252585892979 ,
13721                  0.0262473111702 , -0.112919732543 , 0.424286639249 ,-0.224103052733 , -0.139430015438 , -0.0122352295701 ,
13722                 -0.0312760589481 , -0.274272003594 , 0.0323959636568 , -0.166663422532 , -0.217754445175 , 0.00392109070364 ,
13723                  -0.30586619777 , -0.0475168041091 , -0.0144585228182 , -0.280881480586 , 0.135571293538 , 0.00623923647986 ,
13724                  -0.25548538234 , 0.156819217766 , 0.0645277879769 , -0.131567009284 , 0.184133752309 , 0.206021802753 ,
13725                  -0.196204010965 , 0.151602971681 , 0.212974777736 , -0.183713879463 , 0.0802946639531 , 0.260115662599 ,
13726                  -0.244241178767 , -0.0738873389604 , 0.144590565817 , -0.155804057829 , -0.164892720025 , 0.210613950558 ,
13727                  -0.170950800428 , -0.215099334026 , 0.00610122860092 , -0.30552634869 , -0.0490020791904 , -0.0132786533145 ,
13728                  0.271831011884 , 0.15105657296 , 0.0230534827908 , 0.281919192283 , 0.0898544306288 , -0.0625201489143 ,
13729                  0.260240727276 , -0.0120688706637 , -0.0532316588626 , 0.244947737722 , 0.0197984684293 , 0.0309341209233 ,
13730                  0.23439631578 , 0.229825279875 , 0.0508520585381 , 0.160921316875 , 0.265078502128 , 0.121716560626 ,
13731                  -0.315088694175 , 0.0747700471918 , -0.245836615071 , -0.327728781776 , 0.0857114674649 , -0.239431905957 ,
13732                  -0.308385460634 , 0.145142997084 , -0.149886828433 , 0.0488236045164 , 0.309462801914 , 0.0849169148265 ,
13733                 -0.0244964803395 , 0.33145611751 , -0.0476415818061 , 0.0060567994229 , 0.32418412014 , 0.0367779543812 ,
13734                  -0.0950221448063 , 0.236675326003 , 0.0572594453983 , 0.248723023186 , 0.0886648784791 , -0.176629430538 ,
13735                  0.116796984 , 0.256596599567 , -0.292863523603 , 0.118024552914 , 0.229154257843 , -0.34233232501 ,
13736                  0.217507892549 , -0.0417822335742 , -0.176771782888 , -0.224429321304 , 0.0125595300114 , -0.362064725588 ,
13737                  0.0937301100955 , -0.0500824832657 , -0.299713548444 , -0.244162220397 , 0.0383853931293 , -0.389856984411 ,
13738                  -0.0281989366102 , 0.097392811563 , -0.458244577284 , -0.385010847162 , 0.10122766194 , -0.140052859922 ,
13739                  -0.377936358012 , 0.110875172128 , -0.176207095463 , 0.244483045556 , -0.0991073977045 , 0.0575134372934 ,
13740                 0.262605120167 , -0.100243191645 , -0.0495620806935 , 0.240306880972 , -0.136153701579 , -0.114745281696 ,
13741                  0.215763176129 , -0.0836766059189 , -0.183249640616 , 0.237870396603 , -0.132449578286 , -0.121598854639 ,
13742                  -0.0637683083097 , -0.27921020214 , -0.149112321992 , -0.0856211014977 , -0.2973233473 , -0.0446878139589 ,
13743                  0.104675342288 , -0.0625908305324 , -0.290346256534 , 0.0248264249186 , -0.247797708548 , -0.165830884019 ,
13744                  0.0719302438309 , -0.178468260473 , -0.211432157345 , 0.142871843159 , -0.208769948542 , 0.0454101128246 ,
13745                  0.167803379307 , -0.207851396623 , -0.088802726124 , 0.12868717152 , -0.230920439715 , 0.00760508389036 ,
13746                  -0.0372812069535 , -0.286740286332 , 0.00963701291166 ], 69, 3)
13747         connN = [ #polyhedron 0
13748             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
13749             , 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
13750             , 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
13751             , 22 , 19 , 21 , 30 , 31 , -1 , 22 , 31 , 28 , 27 , 26 , 24 , 23 , -1 , 31 , 30 , 29 , 28,
13752             # polyhedron 1
13753             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
13754             , 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
13755             , 33 , 34 , 48 , 45 , -1 , 35 , 34 , 48 , 50 , 49 , 38 , -1 , 41 , 43 , 42 , 46 , 36 , 37 , -1 , 38 , 39 , 51 , 49 , -1
13756             , 39 , 40 , 42 , 46 , 47 , 52 , 51 , -1 , 45 , 47 , 52 , 50 , 48 , -1 , 52 , 51 , 49 , 50,
13757             # polyhedron 2
13758             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
13759             , 23 , 53 , 54 , 40 , 8 , -1 , 53 , 22 , 23 , -1 , 39 , 54 , 40,
13760             # polyhedron 3
13761             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
13762             , 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
13763             , 55 , 5 , 12 , 65 , -1 , 66 , 67 , 65 , 55 , 56 , 57 , -1 , 63 , 66 , 57 , 59 , 64 , -1 , 64 , 62 , 58 , 59 , -1
13764             , 60 , 63 , 66 , 67 , 68 , 61 , -1 , 61 , 68 , 20 , 21 , -1 , 67 , 68 , 20 , 12 , 65]
13765         meshN=MEDCouplingUMesh.New()
13766         meshN.setName("ForBary")
13767         meshN.setMeshDimension(3) ; meshN.setCoords(coords)
13768         meshN.allocateCells(4)
13769         meshN.insertNextCell(NORM_POLYHED,113,connN);
13770         meshN.insertNextCell(NORM_POLYHED,99,connN[113:])
13771         meshN.insertNextCell(NORM_POLYHED,43,connN[212:])
13772         meshN.insertNextCell(NORM_POLYHED,92,connN[255:])
13773         d=meshN.computeEffectiveNbOfNodesPerCell()
13774         e=meshN.computeNbOfNodesPerCell()
13775         self.assertTrue(d.isEqual(DataArrayInt([32,28,12,26])))
13776         self.assertTrue(e.isEqual(DataArrayInt([96,84,36,78])))
13777         m0=MEDCoupling1DGTUMesh(meshN)
13778         c=MEDCouplingCMesh()
13779         arr=DataArrayDouble(3) ; arr.iota(10)
13780         c.setCoords(arr,arr,arr)
13781         m10=c.buildUnstructured()
13782         m11=c.build1SGTUnstructured()
13783         m12=MEDCoupling1SGTUMesh.New(m10)
13784         self.assertTrue(m12.isEqual(m11,1e-12))
13785         m12.setCoords(m0.getCoords()) # m12 is not OK geometrically but the aim of the test is only connectivity values
13786         m3=MEDCoupling1GTUMesh.AggregateOnSameCoordsToUMesh([m12,m0])
13787         m3.checkCoherency()
13788         self.assertEqual(m3.getCoords().getHiddenCppPointer(),m12.getCoords().getHiddenCppPointer())
13789         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])))
13790         self.assertTrue(m3.getNodalConnectivityIndex().isEqual(DataArrayInt([0,9,18,27,36,45,54,63,72,186,286,330,423])))
13791         pass
13792
13793     def testSwig2Tetrahedrize1(self):
13794         d=DataArrayInt([0,3,6,10,14,20])
13795         d2=d.buildExplicitArrOfSliceOnScaledArr(slice(0,5,2))
13796         self.assertTrue(d2.isEqual(DataArrayInt([0,0,0, 2,2,2,2, 4,4,4,4,4,4])))
13797         m=MEDCouplingUMesh("Penta6",3)
13798         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"])
13799         m.allocateCells()
13800         m.insertNextCell(NORM_PENTA6,[1,2,0,4,5,3])
13801         st=m.getCoords().getHiddenCppPointer()
13802         c,a,b=m.tetrahedrize(PLANAR_FACE_5)
13803         c.checkCoherency2()
13804         self.assertTrue(a.isEqual(DataArrayInt([0,0,0])))
13805         self.assertEqual(0,b)
13806         self.assertEqual(m.getCoords().getHiddenCppPointer(),c.getCoords().getHiddenCppPointer())
13807         self.assertTrue(c.getNodalConnectivity().isEqual(DataArrayInt([1,2,0,4,4,3,5,0,5,0,2,4])))
13808         del m,c
13809         #
13810         m2=MEDCouplingUMesh("octa12",3)
13811         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)
13812         m2.setCoords(coords)
13813         m2.allocateCells()
13814         m2.insertNextCell(NORM_HEXGP12,[3,2,1,0,5,4,9,8,7,6,11,10])
13815         c,a,b=m2.tetrahedrize(PLANAR_FACE_5)
13816         c.checkCoherency2()
13817         self.assertTrue(a.isEqual(DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0])))
13818         self.assertEqual(0,b)
13819         self.assertEqual(c.getCoords().getHiddenCppPointer(),coords.getHiddenCppPointer())
13820         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])))
13821         del m2,coords,c
13822         #
13823         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"])
13824         m3=MEDCouplingUMesh("hexa8",3)
13825         m3.setCoords(coords)
13826         m3.allocateCells(0)
13827         m3.insertNextCell(NORM_HEXA8,[3,2,1,0,7,6,5,4])
13828         st=m3.getCoords().getHiddenCppPointer()
13829         c,a,b=m3.tetrahedrize(PLANAR_FACE_5)
13830         c.checkCoherency2()
13831         a.isEqual(DataArrayInt([0,0,0,0,0]))
13832         self.assertEqual(0,b)
13833         self.assertEqual(m3.getCoords().getHiddenCppPointer(),coords.getHiddenCppPointer())
13834         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])))
13835         #
13836         m4=MEDCouplingUMesh("hexa8",3)
13837         m4.setCoords(coords)
13838         m4.allocateCells(0)
13839         m4.insertNextCell(NORM_HEXA8,[3,2,1,0,7,6,5,4])
13840         c,a,b=m4.tetrahedrize(PLANAR_FACE_6)
13841         c.checkCoherency2()
13842         a.isEqual(DataArrayInt([0,0,0,0,0,0]))
13843         self.assertEqual(0,b)
13844         self.assertEqual(c.getCoords().getHiddenCppPointer(),coords.getHiddenCppPointer())
13845         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])))
13846         #
13847         m4=MEDCouplingUMesh("hexa8",3)
13848         m4.setCoords(coords)
13849         m4.allocateCells(0)
13850         m4.insertNextCell(NORM_HEXA8,[3,2,1,0,7,6,5,4])
13851         st=m4.getCoords().getHiddenCppPointer()
13852         c,a,b=m4.tetrahedrize(GENERAL_24)
13853         c.checkCoherency2()
13854         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]))
13855         self.assertEqual(7,b)
13856         self.assertTrue(c.getCoords().getHiddenCppPointer()!=coords.getHiddenCppPointer())
13857         self.assertTrue(c.getCoords()[:8].isEqual(coords,0))
13858         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])))
13859         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)
13860         m4CoordsExp.setInfoOnComponents(["X","YY","ZZZ"])
13861         self.assertTrue(c.getCoords().isEqual(m4CoordsExp,1e-12))
13862         self.assertAlmostEqual(2.,c.getMeasureField(False).accumulate()[0],12)
13863         #
13864         m6=MEDCouplingUMesh("hexa8",3)
13865         m6.setCoords(coords)
13866         m6.allocateCells(0)
13867         m6.insertNextCell(NORM_HEXA8,[3,2,1,0,7,6,5,4])
13868         st=m6.getCoords().getHiddenCppPointer()
13869         c,a,b=m6.tetrahedrize(GENERAL_48)
13870         c.checkCoherency2()
13871         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]))
13872         self.assertEqual(19,b)
13873         self.assertTrue(c.getCoords().getHiddenCppPointer()!=coords.getHiddenCppPointer())
13874         self.assertTrue(c.getCoords()[:8].isEqual(coords,0))
13875         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])))
13876         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)
13877         m6CoordsExp.setInfoOnComponents(["X","YY","ZZZ"])
13878         self.assertTrue(c.getCoords().isEqual(m6CoordsExp,1e-12))
13879         self.assertAlmostEqual(2.,c.getMeasureField(False).accumulate()[0],12)
13880         #
13881         m7=MEDCouplingUMesh("polyhed",3)
13882         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"])
13883         m7.setCoords(coords)
13884         m7.allocateCells()
13885         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])
13886         c,a,b=m7.tetrahedrize(PLANAR_FACE_5)
13887         c.checkCoherency2()
13888         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])))
13889         self.assertEqual(9,b)
13890         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])))
13891         self.assertAlmostEqual(5.196152422706635,c.getMeasureField(False).accumulate()[0],12)
13892         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)
13893         m7CoordsExp.setInfoOnComponents(["X","YY","ZZZ"])
13894         self.assertTrue(c.getCoords().isEqual(m7CoordsExp,1e-12))
13895         del m7,coords,c
13896         #
13897         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"])
13898         m8=MEDCouplingUMesh("pyra5",3)
13899         m8.setCoords(coords)
13900         m8.allocateCells(0)
13901         m8.insertNextCell(NORM_PYRA5,[3,2,1,0,7])
13902         st=m8.getCoords().getHiddenCppPointer()
13903         c,a,b=m8.tetrahedrize(PLANAR_FACE_5)
13904         self.assertEqual(m8.getCoords().getHiddenCppPointer(),coords.getHiddenCppPointer())
13905         c.checkCoherency2()
13906         self.assertTrue(a.isEqual(DataArrayInt([0,0])))
13907         self.assertEqual(0,b)
13908         self.assertTrue(c.getNodalConnectivity().isEqual(DataArrayInt([3,2,1,7,3,1,0,7])))
13909         self.assertAlmostEqual(0.6666666666666667,c.getMeasureField(False).accumulate()[0],12)
13910         pass
13911
13912     def testDualMesh3D1(self):
13913         arr=DataArrayDouble(2) ; arr.iota()
13914         c=MEDCouplingCMesh() ; c.setCoords(arr,arr,arr)
13915         m=c.buildUnstructured()
13916         t=m.tetrahedrize(PLANAR_FACE_5)[0]
13917         d=t.computeDualMesh()
13918         self.assertTrue(d.getNodalConnectivityIndex().isEqual(DataArrayInt([0,29,118,207,236,325,354,383,472])))
13919         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])))
13920         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))
13921         self.assertAlmostEqual(1.,d.getMeasureField(False).accumulate()[0],1e-13)
13922         pass
13923
13924     def testDualMesh2D1(self):
13925         arr=DataArrayDouble(5) ; arr.iota()
13926         c=MEDCouplingCMesh() ; c.setCoords(arr,arr)
13927         m=c.buildUnstructured()
13928         m.simplexize(0)
13929         t=MEDCoupling1SGTUMesh(m)
13930         d=t.computeDualMesh()
13931         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])))
13932         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])))
13933         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))
13934         self.assertAlmostEqual(16.,d.getMeasureField(False).accumulate()[0],1e-13)
13935         pass
13936
13937     def testSwig2LoadBalanceBBox1(self):
13938         arr=DataArrayDouble(5) ; arr.iota()
13939         t=MEDCouplingCMesh() ; t.setCoords(arr,arr)
13940         arr=DataArrayDouble(16) ; arr.iota() ; arr*=2./15
13941         s=MEDCouplingCMesh() ; s.setCoords(arr,arr[:]) ; s.translate([2.,1.])
13942         #
13943         s1=s.build1SGTUnstructured()
13944         t1=t.build1SGTUnstructured()
13945         w=MEDCouplingPointSet.ComputeNbOfInteractionsWithSrcCells(s1,t1,1e-12)
13946         wExp=DataArrayInt([0,0,0,0,0,0,64,64,0,0,64,64,0,0,0,0])
13947         self.assertTrue(w.isEqual(wExp))
13948         slcs=w.splitInBalancedSlices(4)
13949         self.assertEqual(len(slcs),4)
13950         self.assertEqual(slcs,[slice(0,7,1),slice(7,8,1),slice(8,11,1),slice(11,16,1)])
13951         bbs=s1.getBoundingBoxForBBTree()
13952         bbt=t1.getBoundingBoxForBBTree()
13953         self.assertTrue(bbt.computeNbOfInteractionsWith(bbs,1e-12).isEqual(wExp))
13954         pass
13955
13956     def testKrSpatialDiscretization2(self):
13957         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)
13958         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)
13959         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)
13960         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])
13961         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])
13962         #
13963         nbOfInputPoints=100;
13964         f=MEDCouplingFieldDouble.New(ON_NODES_KR,ONE_TIME);
13965         mesh=MEDCoupling1SGTUMesh.New("aMesh",NORM_POINT1);
13966         mesh.setCoords(srcPointCoordsXY);
13967         f.setMesh(mesh);
13968         f.setArray(srcFieldValsOnPoints);
13969         f.checkCoherency();
13970         #
13971         res0=f.getValueOn([-0.5,-0.5]);
13972         self.assertAlmostEqual(targetFieldValsExpected.getIJ(0,0),res0[0],10)
13973         #
13974         valuesToTest=f.getValueOnMulti(targetPointCoordsXY);
13975         self.assertEqual(196,valuesToTest.getNumberOfTuples());
13976         self.assertEqual(1,valuesToTest.getNumberOfComponents());
13977         for i in xrange(40):
13978             self.assertAlmostEqual(targetFieldValsExpected[i],valuesToTest.getIJ(i,0),10)
13979             pass
13980         fd=f.getDiscretization()
13981         del f
13982         self.assertTrue(isinstance(fd,MEDCouplingFieldDiscretizationKriging))
13983         coeffs,isDrift=fd.computeVectorOfCoefficients(mesh,srcFieldValsOnPoints)
13984         self.assertEqual(3,isDrift)
13985         self.assertTrue(coeffsExpected.isEqual(coeffs,1e-8))
13986         # testing matrix
13987         pts3=[-0.5,-0.5,-0.5,-0.35,-0.35,-0.2]
13988         mesh.setCoords(srcPointCoordsXY[:4])
13989         m,nbCols=fd.computeEvaluationMatrixOnGivenPts(mesh,pts3)
13990         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))
13991         if MEDCouplingHasNumPyBindings():
13992             import numpy as np
13993             m0=m.toNumPyArray() ; m0=m0.reshape(3,nbCols) ; m0=np.matrix(m0)
13994             srcFieldValsOnPoints2=DataArrayDouble(4,2) ; srcFieldValsOnPoints2[:,0]=srcFieldValsOnPoints[:4] ; srcFieldValsOnPoints2[:,1]=2*srcFieldValsOnPoints[:4]
13995             n0=srcFieldValsOnPoints2.toNumPyArray() ; n0=n0.reshape(4,2) ; n0=np.matrix(n0)
13996             #
13997             f=MEDCouplingFieldDouble.New(ON_NODES_KR,ONE_TIME) ;  f.setMesh(mesh) ; f.setArray(srcFieldValsOnPoints2) ; f.checkCoherency()
13998             self.assertTrue(DataArrayDouble(np.array((m0*n0))).isEqual(f.getValueOnMulti(pts3),1e-14))
13999             pass
14000         #
14001         pass
14002
14003     # test the when input slice is all the same object is return by MEDCouplingMesh.buildPartRange
14004     def testSwig2MeshPartSlice1(self):
14005         a=DataArrayDouble(4) ; a.iota()
14006         c=MEDCouplingCMesh() ; c.setCoords(a,a) ; m=c.buildUnstructured()
14007         fc0=c.getMeasureField(False) ; fc1=fc0[:] ; fc2=fc0*fc1 ; fc2.setName(fc0.getName())
14008         self.assertEqual(fc0.getMesh().getHiddenCppPointer(),fc1.getMesh().getHiddenCppPointer())
14009         self.assertEqual(fc2.getMesh().getHiddenCppPointer(),fc1.getMesh().getHiddenCppPointer())
14010         self.assertTrue(fc2.isEqual(fc1,1e-12,1e-12))
14011         #
14012         fm0=m.getMeasureField(False) ; fm1=fm0[:] ; fm2=fm0*fm1 ; fm2.setName(fm0.getName())
14013         self.assertEqual(fm0.getMesh().getHiddenCppPointer(),fm1.getMesh().getHiddenCppPointer())
14014         self.assertEqual(fm2.getMesh().getHiddenCppPointer(),fm1.getMesh().getHiddenCppPointer())
14015         self.assertTrue(fm2.isEqual(fm1,1e-12,1e-12))
14016         pass
14017
14018     # test the correct behaviour when attempting to aggregate two fields whose mesh is null
14019     def testSwig2MergeFieldsOnFieldsHavingNoMesh(self):
14020         a=DataArrayDouble(4) ; a.iota() ; a*=1.5
14021         c=MEDCouplingCMesh() ; c.setCoords(a,a) ; f1=c.getMeasureField(False)
14022         f1.setMesh(None) ; f2=f1.deepCpy() ; f2*=2
14023         f3=MEDCouplingFieldDouble.MergeFields(f1,f2)
14024         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])
14025         self.assertTrue(f3.getArray().isEqual(daExp,1e-12))
14026         self.assertEqual(f3.getTypeOfField(),ON_CELLS)
14027         self.assertEqual(f3.getMesh(),None)
14028         f4=MEDCouplingFieldDouble.MergeFields([f1,f2])
14029         self.assertTrue(f4.getArray().isEqual(daExp,1e-12))
14030         self.assertEqual(f4.getTypeOfField(),ON_CELLS)
14031         self.assertEqual(f4.getMesh(),None)
14032         pass
14033
14034     # test a simple node to cell convertion of a field
14035     def testSwig2NodeToCellDiscretization1(self):
14036         f=MEDCouplingFieldDouble(ON_NODES) ; f.setTime(1.1,2,3)
14037         a1=DataArrayDouble(4) ; a1.iota()
14038         a2=DataArrayDouble(3) ; a2.iota()
14039         m=MEDCouplingCMesh() ; m.setCoords(a1,a2)
14040         f.setMesh(m)
14041         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]"])
14042         f.setArray(arr) ; f.setName("toto")
14043         #
14044         f2=f.nodeToCellDiscretization()
14045         self.assertEqual(ON_CELLS,f2.getTypeOfField())
14046         self.assertEqual("toto",f2.getName())
14047         self.assertEqual([1.1,2,3],f2.getTime())
14048         self.assertEqual(["aa [km]","bbb [kJ]"],f2.getArray().getInfoOnComponents())
14049         self.assertEqual(6,f2.getArray().getNumberOfTuples())
14050         self.assertEqual(f.getMesh().getHiddenCppPointer(),f2.getMesh().getHiddenCppPointer())
14051         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]"])
14052         self.assertTrue(f2.getArray().isEqual(exp,1e-13))
14053         pass
14054
14055     def testSwig2NonRegressionBugIntersectMeshes1(self):
14056         src=MEDCouplingUMesh("src",2)
14057         src.setCoords(DataArrayDouble([-2.5,-3,-2.5,3,2.5,3],3,2))
14058         src.allocateCells()
14059         src.insertNextCell(NORM_TRI3,[0,1,2])
14060         #
14061         trg=MEDCouplingUMesh("trg",2)
14062         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))
14063         trg.allocateCells()
14064         trg.insertNextCell(NORM_QPOLYG,[2,1,0,5,3,7,8,6,4,9])
14065         #
14066         a,b,c=MEDCouplingUMesh.Intersect2DMeshes(src,trg,1.0e-8)
14067         a.mergeNodes(1e-8)
14068         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))
14069         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])))
14070         self.assertTrue(a.getNodalConnectivityIndex().isEqual(DataArrayInt([0,9,20])))
14071         self.assertTrue(b.isEqual(DataArrayInt([0,0])))
14072         self.assertTrue(c.isEqual(DataArrayInt([0,-1])))
14073         pass
14074
14075     def testSwig2MeshOrientCorrectly2DCells1(self):
14076         m=MEDCouplingUMesh("mesh",2)
14077         coo=DataArrayDouble([1.,0.,0.5,-0.1,0.,1.,0.,0.,0.07,0.5,0.59,0.5],6,2)
14078         m.setCoords(coo)
14079         m.allocateCells()
14080         m.insertNextCell(NORM_TRI6,[3,0,2,1,5,4])
14081         m.insertNextCell(NORM_QPOLYG,[3,0,2,1,5,4])
14082         self.assertTrue(DataArrayDouble([-0.58093333350930543,-0.58093333350930543]).isEqual(m.getMeasureField(False).getArray(),1e-12))
14083         m.changeSpaceDimension(3)
14084         m.orientCorrectly2DCells([0.,0.,-1.],False)
14085         #
14086         m.checkCoherency()
14087         self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([6,3,2,0,4,5,1, 32,3,2,0,4,5,1])))
14088         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,7,14])))
14089         m.changeSpaceDimension(2)
14090         self.assertTrue(DataArrayDouble([0.58093333350930543,0.58093333350930543]).isEqual(m.getMeasureField(False).getArray(),1e-12))
14091         pass
14092
14093     def testSwig2Hexa8HavingFacesWarped1(self):
14094         """ 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
14095         intersected with src the sum of intersection volume is greater than the volume of the trg cell.
14096         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
14097         GENERAL_24).
14098         """
14099         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)
14100         src=MEDCouplingUMesh("TBmesh3D",3) ; src.setCoords(srcCoo)
14101         src.allocateCells()
14102         src.insertNextCell(NORM_HEXA8,[0,1,4,3,8,9,12,11])
14103         src.insertNextCell(NORM_HEXA8,[1,2,5,4,9,10,13,12])
14104         src.insertNextCell(NORM_HEXA8,[4,5,7,6,12,13,15,14])
14105         src.insertNextCell(NORM_HEXA8,[8,9,12,11,16,17,20,19])
14106         src.insertNextCell(NORM_HEXA8,[9,10,13,12,17,18,21,20])
14107         src.checkCoherency2()
14108         # trg is useless here but I keep it in case of MEDCouplingRemapper were expected to do something about warped NORM_HEXA8
14109         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)
14110         trg=MEDCouplingUMesh("MESH",3) ; trg.setCoords(trgCoo)
14111         trg.allocateCells()
14112         trg.insertNextCell(NORM_HEXA8,[0,1,3,2,4,5,7,6])
14113         #
14114         srcFace=src.buildDescendingConnectivity()[0]
14115         conn=MEDCoupling1SGTUMesh(srcFace).getNodalConnectivity() ; conn.rearrange(4)
14116         eqFaces=srcFace.computePlaneEquationOf3DFaces()
14117         nodeIdInCell=3
14118         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
14119         lambd=-e/(eqFaces[:,:3]**2).sumPerTuple()
14120         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
14121         shouldBeZero=(pts*eqFaces[:,:-1]).sumPerTuple()+eqFaces[:,3]# this line is useless only to be sure that pts are on the plane.
14122         check=(pts-srcFace.getCoords()[conn[:,nodeIdInCell]]).magnitude() # check contains the distance of the last point to its plane
14123         idsToTest=check.getIdsNotInRange(0.,1e-10)
14124         self.assertTrue(idsToTest.isEqual(DataArrayInt([17,18,19,20,22,23,24])))
14125         idsToTest2=idsToTest.getIdsNotInRange(18,22)
14126         self.assertTrue(idsToTest2.isEqual(DataArrayInt([0,4,5,6])))
14127         idsToTest2.rearrange(2)
14128         self.assertTrue(idsToTest2.sumPerTuple().isEqual(DataArrayInt([4,11])))
14129         pass
14130
14131     def testSwig2SortHexa8EachOther1(self):
14132         """
14133         testing MEDCoupling1SGTUMesh.sortHexa8EachOther method
14134         """
14135         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)])
14136         m1=MEDCouplingUMesh("m1",3) ; m1.setCoords(coords1)
14137         m1.allocateCells() ; m1.insertNextCell(NORM_HEXA8,[7,1,3,0,6,4,2,5])
14138         m1.checkCoherency()
14139         #
14140         m2=m1.deepCpy() ; m2.setName("m2")
14141         #
14142         trs=[[0.,0.,-1.],[0.,0.,1.],[1.,0.,0.],[0.,-1.,0.],[-1.,0.,0.],[0.,1.,0.]]
14143         for i,t in enumerate(trs):
14144             for j in xrange(64):
14145                 j2=(j//16) ; j1=((j%16)//4) ; j0=(j%4)
14146                 m11=m1.deepCpy()
14147                 m11.rotate([0.,0.,0.],[0.,0.,1.],float(j0)*pi/2)
14148                 m11.rotate([0.,0.,0.],[0.,1.,0.],float(j1)*pi/2)
14149                 m11.rotate([0.,0.,0.],[1.,0.,0.],float(j2)*pi/2)
14150                 m11.translate(t)
14151                 #
14152                 m=MEDCouplingUMesh.MergeUMeshes(m2,m11)
14153                 m.mergeNodes(1e-12)
14154                 self.assertEqual(12,m.getNumberOfNodes())
14155                 m=MEDCoupling1SGTUMesh(m)
14156                 m.sortHexa8EachOther()
14157                 tmp0=m.buildUnstructured().tetrahedrize(PLANAR_FACE_6)[0].buildUnstructured()
14158                 self.assertEqual(20,tmp0.computeSkin().getNumberOfCells())
14159                 pass
14160             pass
14161         pass
14162
14163     def testSwig2normMinComputeAbs1(self):
14164         d=DataArrayDouble([4,-5,2,6.1,-7.33,1,-1,3e2,0.07,-0.009,-6,-1e30],4,3)
14165         d.setInfoOnComponents(["XX [m]","YYY [km]","ABSJJ [MW]"])
14166         d0=d.computeAbs()
14167         dExp=d.deepCpy() ; dExp.abs()
14168         self.assertTrue(dExp.isEqual(d0,1e-12))
14169         e=d0-DataArrayDouble([4,5,2,6.1,7.33,1,1,3e2,0.07,0.009,6,1e30],4,3)
14170         self.assertAlmostEqual(0.,e.normMin(),13)
14171         self.assertAlmostEqual(0.009,d.normMin(),13)
14172         #
14173         di=DataArrayInt([3,-12,5,6,14,16,-23,100,23,-1,0,-6],4,3)
14174         di.setInfoOnComponents(["XX [m]","YYY [km]","ABSJJ [MW]"])
14175         d0i=di.computeAbs()
14176         diExp=di.deepCpy() ; diExp.abs()
14177         self.assertTrue(diExp.isEqual(d0i))
14178         self.assertEqual([3,12,5,6,14,16,23,100,23,1,0,6],d0i.getValues())
14179         pass
14180
14181     def testSwig2GetCellsContainingPointsForNonConvexPolygon1(self):
14182         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)
14183         m=MEDCouplingUMesh("Intersect2D",2) ; m.setCoords(coo) ; m.allocateCells()
14184         m.insertNextCell(NORM_POLYGON,[6,3,4,5])
14185         m.insertNextCell(NORM_POLYGON,[4,0,1,2,6,5])
14186         m.checkCoherency2()
14187         #
14188         self.assertTrue(m.getCellsContainingPoint((0.4,-0.4),1e-12).isEqual(DataArrayInt([0])))
14189         self.assertTrue(m.getCellsContainingPoint((-0.4,-0.4),1e-12).isEqual(DataArrayInt([1])))
14190         self.assertTrue(m.getCellsContainingPoint((0.,-0.4),1e-12).isEqual(DataArrayInt([0,1])))
14191         pass
14192
14193     def testSwig2GetCellsContainingPointsForNonConvexPolygon2(self):
14194         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)
14195         m=MEDCouplingUMesh("mesh",2) ; m.setCoords(coo) ; m.allocateCells()
14196         m.insertNextCell(NORM_QPOLYG,[8,5,4,9])
14197         m.insertNextCell(NORM_QPOLYG,[5,8,4,10])
14198         m.insertNextCell(NORM_QPOLYG,[16,8,5,15,21,9,22,17])
14199         m.insertNextCell(NORM_QPOLYG,[15,1,2,3,16,20,6,7,19,17])
14200         m.insertNextCell(NORM_QPOLYG,[15,5,8,16,22,10,21,18])
14201         m.insertNextCell(NORM_QPOLYG,[16,3,0,1,15,19,11,12,20,18])
14202         m.checkCoherency2()
14203         self.assertTrue(m.getCellsContainingPoint([0.,0.27],1e-12).isEqual(DataArrayInt([2])))
14204         pass
14205
14206     def testSwig2DAIGetIdsEqualTuple1(self):
14207         da=DataArrayInt([0,7,1,2,4,1,2,1,1,2,0,1,2,1,5,1,1,2],9,2)
14208         self.assertTrue(da.getIdsEqualTuple([1,2]).isEqual(DataArrayInt([1,4,8])))
14209         self.assertTrue(da.getIdsEqualTuple((1,2)).isEqual(DataArrayInt([1,4,8])))
14210         self.assertTrue(da.getIdsEqualTuple(DataArrayInt([1,2])).isEqual(DataArrayInt([1,4,8])))
14211         da.rearrange(3)
14212         self.assertRaises(InterpKernelException,da.getIdsEqualTuple,[1,2])# mismatch nb of compo (3) and nb of elts in input tuple (2)
14213         self.assertTrue(da.getIdsEqualTuple([2,0,1]).isEqual(DataArrayInt([3])))
14214         self.assertTrue(da.getIdsEqualTuple([2,0,7]).isEqual(DataArrayInt([])))
14215         da.rearrange(1)
14216         self.assertTrue(da.getIdsEqualTuple(2).isEqual(DataArrayInt([3,6,9,12,17])))
14217         self.assertTrue(da.getIdsEqualTuple(2).isEqual(da.getIdsEqual(2)))
14218         pass
14219
14220     def testSwig2GaussNEStaticInfo1(self):
14221         self.assertTrue(DataArrayDouble(MEDCouplingFieldDiscretizationGaussNE.GetWeightArrayFromGeometricType(NORM_TRI3)).isEqual(DataArrayDouble([0.16666666666666666,0.16666666666666666,0.16666666666666666]),1e-12))
14222         self.assertTrue(DataArrayDouble(MEDCouplingFieldDiscretizationGaussNE.GetRefCoordsFromGeometricType(NORM_TRI3)).isEqual(DataArrayDouble([0.,0.,1.,0.,0.,1.]),1e-12))
14223         self.assertTrue(DataArrayDouble(MEDCouplingFieldDiscretizationGaussNE.GetLocsFromGeometricType(NORM_TRI3)).isEqual(DataArrayDouble([0.16666666666666666,0.16666666666666666,0.6666666666666667,0.16666666666666666,0.16666666666666666,0.6666666666666667]),1e-12))
14224         pass
14225
14226     def testSwigReverseNodalConnOnStructuredMesh(self):
14227         # 1D - standard
14228         c=MEDCouplingCMesh() ; arr=DataArrayDouble(10) ; arr.iota()
14229         c.setCoordsAt(0,arr)
14230         rn,rni=c.getReverseNodalConnectivity()
14231         rn2,rni2=c.buildUnstructured().getReverseNodalConnectivity()
14232         self.assertTrue(rn.isEqual(DataArrayInt([0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8])))
14233         self.assertTrue(rni.isEqual(DataArrayInt([0,1,3,5,7,9,11,13,15,17,18])))
14234         self.assertTrue(rn.isEqual(rn2)) ; self.assertTrue(rni.isEqual(rni2))
14235         # 1D - limit
14236         c=MEDCouplingCMesh() ; arr=DataArrayDouble(1) ; arr.iota()
14237         c.setCoordsAt(0,arr)
14238         rn,rni=c.getReverseNodalConnectivity()
14239         rn2,rni2=c.buildUnstructured().getReverseNodalConnectivity()
14240         self.assertTrue(rn.isEqual(DataArrayInt([0])))
14241         self.assertTrue(rni.isEqual(DataArrayInt([0,1])))
14242         self.assertTrue(rn.isEqual(rn2)) ; self.assertTrue(rni.isEqual(rni2))
14243         # 1D - limit
14244         c=MEDCouplingCMesh() ; arr=DataArrayDouble(0) ; arr.iota()
14245         c.setCoordsAt(0,arr)
14246         rn,rni=c.getReverseNodalConnectivity()
14247         rn.isEqual(DataArrayInt([]))
14248         rni.isEqual(DataArrayInt([0]))
14249         # 2D - standard
14250         c=MEDCouplingCMesh() ; arr=DataArrayDouble(5) ; arr.iota() ; arr2=DataArrayDouble(4) ; arr.iota()
14251         c.setCoords(arr,arr2)
14252         rn,rni=c.getReverseNodalConnectivity()
14253         rn2,rni2=c.buildUnstructured().getReverseNodalConnectivity()
14254         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])))
14255         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])))
14256         self.assertTrue(rn.isEqual(rn2)) ; self.assertTrue(rni.isEqual(rni2))
14257         # 2D - limit
14258         c=MEDCouplingCMesh() ; arr=DataArrayDouble(10) ; arr.iota() ; arr2=DataArrayDouble(1) ; arr.iota()
14259         c.setCoords(arr,arr2)
14260         rn,rni=c.getReverseNodalConnectivity()
14261         self.assertTrue(rn.isEqual(DataArrayInt([0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8])))
14262         self.assertTrue(rni.isEqual(DataArrayInt([0,1,3,5,7,9,11,13,15,17,18])))
14263         # 2D - limit
14264         c=MEDCouplingCMesh() ; arr=DataArrayDouble(10) ; arr.iota() ; arr2=DataArrayDouble(1) ; arr.iota()
14265         c.setCoords(arr2,arr)
14266         rn,rni=c.getReverseNodalConnectivity()
14267         self.assertTrue(rn.isEqual(DataArrayInt([0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8])))
14268         self.assertTrue(rni.isEqual(DataArrayInt([0,1,3,5,7,9,11,13,15,17,18])))
14269         # 3D - standard
14270         c=MEDCouplingCMesh() ; arr0=DataArrayDouble(5) ; arr0.iota() ; arr1=DataArrayDouble(3) ; arr1.iota() ; arr2=DataArrayDouble(4) ; arr2.iota()
14271         c.setCoords(arr0,arr1,arr2)
14272         rn,rni=c.getReverseNodalConnectivity()
14273         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])))
14274         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])))
14275         rn2,rni2=c.buildUnstructured().getReverseNodalConnectivity()
14276         self.assertTrue(rn.isEqual(rn2)) ; self.assertTrue(rni.isEqual(rni2))
14277         pass
14278
14279     def testSwig2CellToNodeDiscretization1(self):
14280         m=MEDCouplingCMesh() ; arr0=DataArrayDouble(5) ; arr0.iota() ; arr1=DataArrayDouble(4) ; arr1.iota() ; m.setCoords(arr0,arr1)
14281         f=MEDCouplingFieldDouble(ON_CELLS) ; f.setMesh(m) ; f.setTime(1.1,5,6)
14282         arr=DataArrayDouble(12) ; arr.iota()
14283         arr=DataArrayDouble.Meld(arr,arr+100.) ; arr.setInfoOnComponents(["aaa","bbb"])
14284         f.setArray(arr)
14285         f.checkCoherency()
14286         #
14287         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.])
14288         ref=DataArrayDouble.Meld(ref,ref+100.) ; ref.setInfoOnComponents(["aaa","bbb"])
14289         f2=f.cellToNodeDiscretization()
14290         f2.checkCoherency()
14291         self.assertEqual(f2.getTime()[1:],[5,6])
14292         self.assertAlmostEqual(f2.getTime()[0],1.1,15)
14293         self.assertEqual(f2.getMesh().getHiddenCppPointer(),m.getHiddenCppPointer())
14294         self.assertTrue(f2.getArray().isEqual(ref,1e-12))
14295         rn,rni=m.getReverseNodalConnectivity()
14296         rni2=(rni.deltaShiftIndex()).convertToDblArr()
14297         arr2=(f.getArray()[rn]).accumulatePerChunck(rni)/rni2
14298         self.assertTrue(f2.getArray().isEqual(arr2,1e-12))
14299         del f2
14300         #
14301         u=m.buildUnstructured() ; f.setMesh(u) ; del m
14302         f3=f.cellToNodeDiscretization()
14303         f3.checkCoherency()
14304         self.assertEqual(f3.getTime()[1:],[5,6])
14305         self.assertAlmostEqual(f3.getTime()[0],1.1,15)
14306         self.assertEqual(f3.getMesh().getHiddenCppPointer(),u.getHiddenCppPointer())
14307         self.assertTrue(f3.getArray().isEqual(ref,1e-12))
14308         pass
14309
14310     def testSwig2GetMeshSpaceDimensionCMesh1(self):
14311         c=MEDCouplingCMesh()
14312         arr0=DataArrayDouble([0,1,2])
14313         arr1=DataArrayDouble([0])
14314         c.setCoords(arr0,arr0,arr0)
14315         self.assertEqual(c.getMeshDimension(),3)
14316         self.assertEqual(c.getSpaceDimension(),3)
14317         #
14318         c.setCoords(arr0,arr0,arr1)
14319         self.assertEqual(c.getMeshDimension(),2)
14320         self.assertEqual(c.getSpaceDimension(),3)
14321         #
14322         c.setCoords(arr0,arr0)
14323         self.assertEqual(c.getMeshDimension(),2)
14324         self.assertEqual(c.getSpaceDimension(),2)
14325         #
14326         c.setCoords(arr0,arr1)
14327         self.assertEqual(c.getMeshDimension(),1)
14328         self.assertEqual(c.getSpaceDimension(),2)
14329         #
14330         c.setCoords(arr0)
14331         self.assertEqual(c.getMeshDimension(),1)
14332         self.assertEqual(c.getSpaceDimension(),1)
14333         #
14334         c.setCoords(arr1)
14335         self.assertEqual(c.getMeshDimension(),0)
14336         self.assertEqual(c.getSpaceDimension(),1)
14337         pass
14338
14339     def testSwig2BuildSpreadZonesWithPolyOnQPolyg1(self):
14340         nx=6
14341         ny=6
14342         m=MEDCouplingCMesh()
14343         arr1=DataArrayDouble(nx) ; arr1.iota()
14344         arr2=DataArrayDouble(ny) ; arr2.iota()
14345         m.setCoords(arr1,arr2)
14346         m=m.buildUnstructured()
14347         da=DataArrayInt.Range(nx-1,(nx-1)*(ny-1),nx)
14348         m2=m[da] ; m2.simplexize(0)
14349         dan=da.buildComplement(m.getNumberOfCells())
14350         m1=m[dan]
14351         m=MEDCouplingUMesh.MergeUMeshesOnSameCoords(m1,m2)
14352         #
14353         m.convertLinearCellsToQuadratic()
14354         m1=m[::2] ; m2=m[1::2] ; m2.convertAllToPoly()
14355         m=MEDCouplingUMesh.MergeUMeshesOnSameCoords(m1,m2)
14356         p=m.buildSpreadZonesWithPoly()
14357         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])))
14358         self.assertTrue(p.getNodalConnectivityIndex().isEqual(DataArrayInt([0,41])))
14359         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))
14360         pass
14361
14362     def testSwig2Conformize2D1(self):
14363         eps = 1.0e-8
14364         coo = [0.,-0.5,0.,0.,0.5,0.,0.5,-0.5,0.25,
14365                -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]
14366         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]
14367         connI = [0,5,12,17,24]
14368         m = MEDCouplingUMesh("box",2)
14369         cooArr = DataArrayDouble(coo,len(coo)/2,2)
14370         m.setCoords(cooArr)
14371         m.setConnectivity(DataArrayInt(conn),DataArrayInt(connI))
14372         m.mergeNodes(eps)
14373         m.checkCoherency()
14374         self.assertTrue(m.conformize2D(eps).isEqual(DataArrayInt([3])))
14375         self.assertEqual(m.getCoords().getHiddenCppPointer(),cooArr.getHiddenCppPointer()) # check that coordinates remain the same here
14376         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])))
14377         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5,12,17,25])))
14378         pass
14379
14380     def testSwig2Conformize2D2(self):
14381         eps = 1.0e-8
14382         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)
14383         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])
14384         m=MEDCoupling1SGTUMesh("mesh",NORM_QUAD4)
14385         m.setCoords(coo)
14386         m.setNodalConnectivity(conn)
14387         m=m.buildUnstructured()
14388         self.assertTrue(m.conformize2D(eps).isEqual(DataArrayInt([0,1,2,5])))
14389         self.assertEqual(m.getCoords().getHiddenCppPointer(),coo.getHiddenCppPointer()) # check that coordinates remain the same here
14390         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])))
14391         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,6,12,21,26,31,37,42])))
14392         pass
14393
14394     def testSwigSplit2DCells1(self):
14395         coo=DataArrayDouble([[0,0],[1,0],[1,1],[0,1],[0.5,0],[1,0.5],[0.5,1],[0.,0.5]])
14396         m=MEDCouplingUMesh("mesh",2)
14397         m.setCoords(coo)
14398         m.allocateCells()
14399         m.insertNextCell(NORM_QUAD8,[0,1,2,3,4,5,6,7])
14400         _,d,di,_,_=m.buildDescendingConnectivity()
14401         subb=DataArrayInt([5])
14402         subbi=DataArrayInt([0,0,1,1,1])
14403         mid=DataArrayInt([-1,-1])
14404         midi=DataArrayInt([0,0,2,2,2])
14405         self.assertEqual(2,m.split2DCells(d,di,subb,subbi,mid,midi))
14406         self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([32,0,1,5,2,3,4,8,9,6,7])))
14407         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,11])))
14408         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))
14409         pass
14410
14411     def testSwig2Conformize2D3(self):
14412         eps = 1.0e-8
14413         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)
14414         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])
14415         m=MEDCoupling1SGTUMesh("mesh",NORM_QUAD4)
14416         m.setCoords(coo)
14417         m.setNodalConnectivity(conn)
14418         m=m.buildUnstructured()
14419         m.convertLinearCellsToQuadratic()
14420         self.assertTrue(m.conformize2D(eps).isEqual(DataArrayInt([0,1,2,5])))
14421         self.assertTrue(m.getCoords().getHiddenCppPointer()!=coo.getHiddenCppPointer()) # coordinates are not the same here contrary to testSwig2Conformize2D2 ...
14422         self.assertTrue(m.getCoords()[:18].isEqual(coo,1e-12)) # but the 18 first nodes are the same
14423         pass
14424
14425     def testSwig2Conformize2D4(self):
14426         eps = 1.0e-8
14427         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)
14428         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])
14429         m=MEDCoupling1SGTUMesh("mesh",NORM_QUAD4)
14430         m.setCoords(coo)
14431         m.setNodalConnectivity(conn)
14432         m=m.buildUnstructured()
14433         m.convertLinearCellsToQuadratic()
14434         self.assertEqual(42,m.getNumberOfNodes())
14435         oldCoo=m.getCoords().deepCpy()
14436         m.conformize2D(eps)
14437         self.assertTrue(m.getCoords()[:42].isEqual(oldCoo,1e-12))
14438         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])))
14439         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,11,22,39,48,57,68,77])))
14440         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))
14441         pass
14442
14443     def testSwig2Conformize2D5(self):
14444         eps=1e-8
14445         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]])
14446         m=MEDCouplingUMesh("mesh",2)
14447         m.allocateCells()
14448         m.setCoords(coo)
14449         m.insertNextCell(NORM_TRI6,[1,2,0,5,4,3])
14450         m.insertNextCell(NORM_TRI6,[8,6,0,12,7,13])
14451         m.insertNextCell(NORM_TRI6,[11,9,10,16,14,15])
14452         self.assertTrue(m.conformize2D(eps).isEqual(DataArrayInt([0])))
14453         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))
14454         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])))
14455         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,13,20,27])))
14456         pass
14457
14458     def testSwigExtendedSlice1(self):
14459         d=DataArrayInt([5,6,7])
14460         self.assertTrue(d[2:].isEqual(DataArrayInt([7])))
14461         self.assertTrue(d[3:].isEqual(DataArrayInt([])))
14462         try:
14463             d[4:]
14464         except InterpKernelException as e:
14465             self.assertTrue(True)
14466         else:
14467             self.assertTrue(False)
14468             pass
14469         d=DataArrayInt([5,6,7,8])
14470         self.assertEqual(d[-1],8)
14471         self.assertEqual(d[-4],5)
14472         try:
14473             d[-5]
14474         except InterpKernelException as e:
14475             self.assertTrue(True)
14476         else:
14477             self.assertTrue(False)
14478             pass
14479         self.assertTrue(d[2::-1].isEqual(DataArrayInt([7,6,5])))
14480         self.assertTrue(d[0::-1].isEqual(DataArrayInt([5])))
14481         self.assertTrue(d[-1::-1].isEqual(DataArrayInt([8,7,6,5])))
14482         self.assertTrue(d[-3::-1].isEqual(DataArrayInt([6,5])))
14483         self.assertTrue(d[-5::-1].isEqual(DataArrayInt([])))
14484         try:
14485             d[-6::-1]
14486         except InterpKernelException as e:
14487             self.assertTrue(True)
14488         else:
14489             self.assertTrue(False)
14490             pass
14491         d=DataArrayInt([])
14492         self.assertTrue(d[0:].isEqual(DataArrayInt([])))
14493         #
14494         d=DataArrayDouble([5,6,7])
14495         self.assertTrue(d[2:].isEqual(DataArrayDouble([7]),1e-12))
14496         self.assertTrue(d[3:].isEqual(DataArrayDouble([]),1e-12))
14497         try:
14498             d[4:]
14499         except InterpKernelException as e:
14500             self.assertTrue(True)
14501         else:
14502             self.assertTrue(False)
14503             pass
14504         d=DataArrayDouble([5,6,7,8])
14505         self.assertAlmostEqual(d[-1],8.,12)
14506         self.assertAlmostEqual(d[-4],5.,12)
14507         try:
14508             d[-5]
14509         except InterpKernelException as e:
14510             self.assertTrue(True)
14511         else:
14512             self.assertTrue(False)
14513             pass
14514         self.assertTrue(d[2::-1].isEqual(DataArrayDouble([7,6,5]),1e-12))
14515         self.assertTrue(d[0::-1].isEqual(DataArrayDouble([5]),1e-12))
14516         self.assertTrue(d[-1::-1].isEqual(DataArrayDouble([8,7,6,5]),1e-12))
14517         self.assertTrue(d[-3::-1].isEqual(DataArrayDouble([6,5]),1e-12))
14518         self.assertTrue(d[-5::-1].isEqual(DataArrayDouble([]),1e-12))
14519         try:
14520             d[-6::-1]
14521         except InterpKernelException as e:
14522             self.assertTrue(True)
14523         else:
14524             self.assertTrue(False)
14525             pass
14526         d=DataArrayDouble([])
14527         self.assertTrue(d[0:].isEqual(DataArrayDouble([]),1e-12))
14528         pass
14529
14530     def testSwig2Hexa27GP1(self):
14531         """ This test focused on shape functions of hexa27.
14532         """
14533         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.]])
14534         m=MEDCouplingUMesh("mesh",3) ; m.setCoords(coo)
14535         m.allocateCells()
14536         # the cell description is exactly those described in the description of HEXA27 in MED file 3.0.7 documentation
14537         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])
14538         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.]
14539         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]
14540         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]
14541         fGauss=MEDCouplingFieldDouble(ON_GAUSS_PT) ; fGauss.setName("fGauss")
14542         fGauss.setMesh(m)
14543         fGauss.setGaussLocalizationOnType(NORM_HEXA27,refCoo,gCoords,weights)
14544         arr=DataArrayDouble(fGauss.getNumberOfTuplesExpected()) ; arr.iota()
14545         fGauss.setArray(arr)
14546         arrOfDisc=fGauss.getLocalizationOfDiscr()
14547         # the test is here
14548         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))
14549         #
14550         weights=27*[1]
14551         gCoords=refCoo
14552         fGauss.setGaussLocalizationOnType(NORM_HEXA27,refCoo,gCoords,weights)
14553         arrOfDisc2=fGauss.getLocalizationOfDiscr()
14554         self.assertTrue(arrOfDisc2.isEqual(coo,1e-12))
14555         pass
14556
14557     def testSwig2Pyra13GP1(self):
14558         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.]])
14559         m=MEDCouplingUMesh("mesh",3) ; m.setCoords(coo)
14560         m.allocateCells()
14561         # the cell description is exactly those described in the description of PYRA13 in MED file 3.0.7 documentation
14562         m.insertNextCell(NORM_PYRA13,[0,1,2,3,4,5,6,7,8,9,10,11,12])
14563         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]
14564         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]
14565         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]
14566         fGauss=MEDCouplingFieldDouble(ON_GAUSS_PT) ; fGauss.setName("fGauss")
14567         fGauss.setMesh(m)
14568         fGauss.setGaussLocalizationOnType(NORM_PYRA13,refCoords,gaussCoords,weights)
14569         arr=DataArrayDouble(fGauss.getNumberOfTuplesExpected()) ; arr.iota()
14570         fGauss.setArray(arr)
14571         arrOfDisc=fGauss.getLocalizationOfDiscr()
14572         # the test is here
14573         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))
14574         #
14575         weights=13*[1]
14576         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. !
14577         fGauss.setGaussLocalizationOnType(NORM_PYRA13,refCoords,gaussCoords,weights)
14578         arrOfDisc2=fGauss.getLocalizationOfDiscr()
14579         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. !
14580         pass
14581
14582     def testSwig2Tri7GP1(self):
14583         coo=DataArrayDouble([[0,0],[0,2],[2,0],[0,1],[1,1],[1,0],[0.6666666666666667,0.6666666666666667]])
14584         m=MEDCouplingUMesh("mesh",2) ; m.setCoords(coo)
14585         m.allocateCells()
14586         # the cell description is exactly those described in the description of TRI7 in MED file 3.0.7 documentation
14587         m.insertNextCell(NORM_TRI7,range(7))
14588         refCoords=[0.,0.,1.,0.,0.,1.,0.5,0.,0.5,0.5,0.,0.5,0.3333333333333333,0.3333333333333333]
14589         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]
14590         weights=[0.062969590272413,0.062969590272413,0.062969590272413,0.066197076394253,0.066197076394253,0.066197076394253,0.1125]
14591         fGauss=MEDCouplingFieldDouble(ON_GAUSS_PT) ; fGauss.setName("fGauss")
14592         fGauss.setMesh(m)
14593         fGauss.setGaussLocalizationOnType(NORM_TRI7,refCoords,gaussCoords,weights)
14594         arr=DataArrayDouble(fGauss.getNumberOfTuplesExpected()) ; arr.iota()
14595         fGauss.setArray(arr)
14596         arrOfDisc=fGauss.getLocalizationOfDiscr()
14597         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))
14598         #
14599         weights=7*[1]
14600         gaussCoords=refCoords
14601         fGauss.setGaussLocalizationOnType(NORM_TRI7,refCoords,gaussCoords,weights)
14602         arrOfDisc2=fGauss.getLocalizationOfDiscr()
14603         self.assertTrue(arrOfDisc2.isEqual(coo,1e-12))
14604         pass
14605
14606     def testSwig2StructuredDesc1(self):
14607         c=MEDCouplingCMesh()
14608         arr0=DataArrayDouble(3) ; arr0.iota()
14609         arr1=DataArrayDouble(4) ; arr1.iota()
14610         arr2=DataArrayDouble(5) ; arr2.iota()
14611         c.setCoords(arr0,arr1,arr2)
14612         #
14613         self.assertEqual(98,c.getNumberOfCellsOfSubLevelMesh())
14614         m=c.build1SGTSubLevelMesh()
14615         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])))
14616         self.assertEqual(NORM_QUAD4,m.getCellModelEnum())
14617         #
14618         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])))
14619         pass
14620
14621     def testSwig2Colinearize2D1(self):
14622         coo=DataArrayDouble([-5.,0.,-1.,0.,4.,3.,7.,0.,1.,6.,1.,0.,-3.,0.,6.,1.,5.,0.,3.,0.],10,2)
14623         #
14624         m=MEDCouplingUMesh("mesh",2) ; m.setCoords(coo) ; m.allocateCells()
14625         m.insertNextCell(NORM_POLYGON,[5,9,8,3,7,2,4,0,6,1])
14626         refPtr=m.getCoords().getHiddenCppPointer()
14627         self.assertTrue(m.colinearize2D(1e-12).isEqual(DataArrayInt([0])))
14628         self.assertEqual(refPtr,m.getCoords().getHiddenCppPointer())
14629         self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([5,0,3,4])))
14630         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4])))
14631         self.assertTrue(m.colinearize2D(1e-12).isEqual(DataArrayInt([])))
14632         self.assertEqual(refPtr,m.getCoords().getHiddenCppPointer())
14633         self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([5,0,3,4])))
14634         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4])))
14635         #
14636         m=MEDCouplingUMesh("mesh",2) ; m.setCoords(coo) ; m.allocateCells()
14637         m.insertNextCell(NORM_POLYGON,[8,3,7,2,4,0,6,1,5,9])
14638         refPtr=m.getCoords().getHiddenCppPointer()
14639         self.assertTrue(m.colinearize2D(1e-12).isEqual(DataArrayInt([0])))
14640         self.assertEqual(refPtr,m.getCoords().getHiddenCppPointer())
14641         self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([5,0,3,4])))
14642         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4])))
14643         #
14644         m=MEDCouplingUMesh("mesh",2) ; m.setCoords(coo) ; m.allocateCells()
14645         m.insertNextCell(NORM_POLYGON,[3,7,2,4,0,6,1,5,9,8])
14646         refPtr=m.getCoords().getHiddenCppPointer()
14647         self.assertTrue(m.colinearize2D(1e-12).isEqual(DataArrayInt([0])))
14648         self.assertEqual(refPtr,m.getCoords().getHiddenCppPointer())
14649         self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([5,3,4,0])))
14650         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4])))
14651         #
14652         m=MEDCouplingUMesh("mesh",2) ; m.setCoords(coo) ; m.allocateCells()
14653         m.insertNextCell(NORM_POLYGON,[4,0,6,1,5,9,8,3,7,2,])
14654         refPtr=m.getCoords().getHiddenCppPointer()
14655         self.assertTrue(m.colinearize2D(1e-12).isEqual(DataArrayInt([0])))
14656         self.assertEqual(refPtr,m.getCoords().getHiddenCppPointer())
14657         self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([5,4,0,3])))
14658         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4])))
14659         ## false quadratic
14660         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)])
14661         coo2.setInfoOnComponents(["aa","bbbb"])
14662         m=MEDCouplingUMesh("mesh",2) ; m.setCoords(coo2) ; m.allocateCells()
14663         m.insertNextCell(NORM_QPOLYG,[5,9,8,3,7,2,4,0,6,1,10,11,12,13,14,15,16,17,18,19])
14664         refPtr=m.getCoords().getHiddenCppPointer()
14665         self.assertTrue(m.colinearize2D(1e-12).isEqual(DataArrayInt([0])))
14666         self.assertNotEqual(refPtr,m.getCoords().getHiddenCppPointer())#not same coordinates here
14667         self.assertEqual(["aa","bbbb"],m.getCoords().getInfoOnComponents())
14668         refPtr=m.getCoords().getHiddenCppPointer()
14669         self.assertTrue(coo2.isEqual(m.getCoords()[:20],1e-12))
14670         self.assertTrue(m.getCoords()[20:].isEqualWithoutConsideringStr(DataArrayDouble([(1.,0.),(4.,3.)]),1e-12))
14671         self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([32,0,3,4,20,21,16])))
14672         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,7])))
14673         self.assertTrue(m.colinearize2D(1e-12).isEqual(DataArrayInt([])))
14674         self.assertEqual(refPtr,m.getCoords().getHiddenCppPointer())
14675         self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([32,0,3,4,20,21,16])))
14676         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,7])))
14677         # mix of quadratic and linear inside a QPOLYG cell
14678         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)])
14679         m=MEDCouplingUMesh("mesh",2) ; m.setCoords(coo2) ; m.allocateCells()
14680         m.insertNextCell(NORM_QPOLYG,[5,9,8,3,7,2,4,0,6,1,10,11,12,13,14,15,16,17,18,19])
14681         refPtr=m.getCoords().getHiddenCppPointer()
14682         self.assertTrue(m.colinearize2D(1e-12).isEqual(DataArrayInt([0])))
14683         self.assertNotEqual(refPtr,m.getCoords().getHiddenCppPointer())#not same coordinates here
14684         self.assertTrue(coo2.isEqual(m.getCoords()[:20],1e-12))
14685         self.assertTrue(m.getCoords()[20:].isEqual(DataArrayDouble([(1.,0.),(7.,6.)]),1e-12))
14686         self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([32,0,3,4,20,21,16])))
14687         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,7])))
14688         pass
14689
14690     def testSwig2BoundingBoxForBBTree1(self):
14691         """ 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 !
14692         """
14693         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)
14694         m=MEDCouplingUMesh("mesh",2) ; m.setCoords(coo)
14695         m.allocateCells()
14696         m.insertNextCell(NORM_QPOLYG,[0,1,2,3,11,5,7,9,12,13,14,17,4,6,8,16])
14697         m.insertNextCell(NORM_QPOLYG,[3,0,9,11,15,16,10,17])
14698         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))
14699         pass
14700
14701     def testSwig2CartBuildUnstructuredOnExoticCases1(self):
14702         """ Test focusing on traduction from cartesian to unstructured mesh when spaceDim greater than meshDim.
14703         """
14704         #
14705         m=MEDCouplingCMesh()
14706         arrX=DataArrayDouble(3) ; arrX.iota()
14707         arrY=DataArrayDouble(4) ; arrY.iota()
14708         arrZ=DataArrayDouble(1) ; arrZ.iota()
14709         m.setCoords(arrX,arrY,arrZ)
14710         self.assertEqual(2,m.getMeshDimension())
14711         self.assertEqual(3,m.getSpaceDimension())
14712         mu=m.buildUnstructured()
14713         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])))
14714         self.assertTrue(mu.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5,10,15,20,25,30])))
14715         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)])
14716         self.assertTrue(mu.getCoords().isEqual(coo0,1e-12))
14717         #
14718         m=MEDCouplingCMesh()
14719         arrX=DataArrayDouble(3) ; arrX.iota()
14720         arrY=DataArrayDouble(1) ; arrY.iota()
14721         arrZ=DataArrayDouble(4) ; arrZ.iota()
14722         m.setCoords(arrX,arrY,arrZ)
14723         self.assertEqual(2,m.getMeshDimension())
14724         self.assertEqual(3,m.getSpaceDimension())
14725         mu=m.buildUnstructured()
14726         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])))
14727         self.assertTrue(mu.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5,10,15,20,25,30])))
14728         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)])
14729         self.assertTrue(mu.getCoords().isEqual(coo1,1e-12))
14730         #
14731         m=MEDCouplingCMesh()
14732         arrX=DataArrayDouble(1) ; arrX.iota() ; arrX+=9
14733         arrY=DataArrayDouble(3) ; arrY.iota()
14734         arrZ=DataArrayDouble(4) ; arrZ.iota()
14735         m.setCoords(arrX,arrY,arrZ)
14736         self.assertEqual(2,m.getMeshDimension())
14737         self.assertEqual(3,m.getSpaceDimension())
14738         mu=m.buildUnstructured()
14739         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])))
14740         self.assertTrue(mu.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5,10,15,20,25,30])))
14741         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)])
14742         self.assertTrue(mu.getCoords().isEqual(coo2,1e-12))
14743         #
14744         m=MEDCouplingCMesh()
14745         arrX=DataArrayDouble(3) ; arrX.iota()
14746         arrY=DataArrayDouble(1) ; arrY.iota(7)
14747         arrZ=DataArrayDouble(1) ; arrZ.iota(8)
14748         m.setCoords(arrX,arrY,arrZ)
14749         self.assertEqual(1,m.getMeshDimension())
14750         self.assertEqual(3,m.getSpaceDimension())
14751         mu=m.buildUnstructured()
14752         self.assertTrue(mu.getNodalConnectivity().isEqual(DataArrayInt([1,0,1,1,1,2])))
14753         self.assertTrue(mu.getNodalConnectivityIndex().isEqual(DataArrayInt([0,3,6])))
14754         coo3=DataArrayDouble([(0,7,8),(1,7,8),(2,7,8)])
14755         self.assertTrue(mu.getCoords().isEqual(coo3,1e-12))
14756         #
14757         m=MEDCouplingCMesh()
14758         arrX=DataArrayDouble(1) ; arrX.iota(7)
14759         arrY=DataArrayDouble(1) ; arrY.iota(8)
14760         arrZ=DataArrayDouble(3) ; arrZ.iota()
14761         m.setCoords(arrX,arrY,arrZ)
14762         self.assertEqual(1,m.getMeshDimension())
14763         self.assertEqual(3,m.getSpaceDimension())
14764         mu=m.buildUnstructured()
14765         self.assertTrue(mu.getNodalConnectivity().isEqual(DataArrayInt([1,0,1,1,1,2])))
14766         self.assertTrue(mu.getNodalConnectivityIndex().isEqual(DataArrayInt([0,3,6])))
14767         coo4=DataArrayDouble([(7,8,0),(7,8,1),(7,8,2)])
14768         self.assertTrue(mu.getCoords().isEqual(coo4,1e-12))
14769         #
14770         m=MEDCouplingCMesh()
14771         arrX=DataArrayDouble(3) ; arrX.iota()
14772         arrY=DataArrayDouble(1) ; arrY.iota(7)
14773         m.setCoords(arrX,arrY)
14774         self.assertEqual(1,m.getMeshDimension())
14775         self.assertEqual(2,m.getSpaceDimension())
14776         mu=m.buildUnstructured()
14777         self.assertTrue(mu.getNodalConnectivity().isEqual(DataArrayInt([1,0,1,1,1,2])))
14778         self.assertTrue(mu.getNodalConnectivityIndex().isEqual(DataArrayInt([0,3,6])))
14779         coo5=DataArrayDouble([(0,7),(1,7),(2,7)])
14780         self.assertTrue(mu.getCoords().isEqual(coo5,1e-12))
14781         #
14782         m=MEDCouplingCMesh()
14783         arrX=DataArrayDouble(1) ; arrX.iota(7)
14784         arrY=DataArrayDouble(3) ; arrY.iota()
14785         m.setCoords(arrX,arrY)
14786         self.assertEqual(1,m.getMeshDimension())
14787         self.assertEqual(2,m.getSpaceDimension())
14788         mu=m.buildUnstructured()
14789         self.assertTrue(mu.getNodalConnectivity().isEqual(DataArrayInt([1,0,1,1,1,2])))
14790         self.assertTrue(mu.getNodalConnectivityIndex().isEqual(DataArrayInt([0,3,6])))
14791         coo6=DataArrayDouble([(7,0),(7,1),(7,2)])
14792         self.assertTrue(mu.getCoords().isEqual(coo6,1e-12))
14793         pass
14794
14795     def testSwig2Colinearize2D2(self):
14796         """ simple non regression test but that has revealed a bug"""
14797         coo=DataArrayDouble([(0,0),(0,0.5),(0,1),(1,1),(1,0),(0.5,0)])
14798         m=MEDCouplingUMesh("mesh",2) ; m.setCoords(coo)
14799         m.allocateCells() ; m.insertNextCell(NORM_POLYGON,[0,1,2,3,4,5])
14800         m.checkCoherency2()
14801         refPtr=m.getCoords().getHiddenCppPointer()
14802         #
14803         m.colinearize2D(1e-12)
14804         m.checkCoherency2()
14805         self.assertEqual(refPtr,m.getCoords().getHiddenCppPointer())
14806         self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([NORM_POLYGON,0,2,3,4])))
14807         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5])))
14808         pass
14809
14810     def testSwig2Colinearize2D3(self):
14811         """ colinearize was too agressive, potentially producing cells with one edge """
14812         # Flat polygon  with 3 edges - nothing should happen (min number of edges for a linear polyg)
14813         coo = DataArrayDouble([0.0,0.0,  2.0,0.0,   1.5,0.0,  1.0,0.0,  0.5,0.0], 5,2)
14814         m = MEDCouplingUMesh("m", 2)
14815         c, cI = [DataArrayInt(l) for l in [[NORM_POLYGON, 0,1,2], [0,4]] ]
14816         m.setCoords(coo); m.setConnectivity(c, cI)
14817         m.colinearize2D(1e-10)
14818         m.checkCoherency2()
14819         self.assertEqual(c.getValues(), m.getNodalConnectivity().getValues())
14820         self.assertEqual(cI.getValues(), m.getNodalConnectivityIndex().getValues())
14821
14822         # Flat quad polygon, 2 edges - nothing should happen (min number of edges for a quad polyg)
14823         m = MEDCouplingUMesh("m", 2)
14824         c, cI = [DataArrayInt(l) for l in [[NORM_QPOLYG, 0,1,  2,3], [0,5]] ]
14825         m.setCoords(coo); m.setConnectivity(c, cI)
14826         m.colinearize2D(1e-10)
14827         m.checkCoherency2()
14828         self.assertEqual(c.getValues(), m.getNodalConnectivity().getValues())
14829         self.assertEqual(cI.getValues(), m.getNodalConnectivityIndex().getValues())
14830
14831         # Flat polygon, 4 edges - one reduction should happen
14832         m = MEDCouplingUMesh("m", 2)
14833         c, cI = [DataArrayInt(l) for l in [[NORM_POLYGON, 0,1,2,3], [0,5]] ]
14834         m.setCoords(coo); m.setConnectivity(c, cI)
14835         m.colinearize2D(1e-10)
14836         m.checkCoherency2()
14837         self.assertEqual([NORM_POLYGON, 3,1,2], m.getNodalConnectivity().getValues())
14838         self.assertEqual([0,4], m.getNodalConnectivityIndex().getValues())
14839
14840         # Flat quad polygon, 3 edges - one reduction expected
14841         m = MEDCouplingUMesh("m", 2)
14842         c, cI = [DataArrayInt(l) for l in [[NORM_QPOLYG, 0,1,3,  3,2,4], [0,7]] ]
14843         m.setCoords(coo); m.setConnectivity(c, cI)
14844         m.colinearize2D(1e-10)
14845         m.checkCoherency2()
14846         self.assertEqual([NORM_QPOLYG, 3,1, 5,2], m.getNodalConnectivity().getValues())
14847         self.assertTrue( m.getCoords()[5].isEqual( DataArrayDouble([(1.5,0.0)]), 1.0e-12 ) )
14848         self.assertEqual([0,5], m.getNodalConnectivityIndex().getValues())
14849
14850         # Now an actual (neutronic) case: circle made of 4 SEG3. Should be reduced to 2 SEG3
14851         m = MEDCouplingDataForTest.buildCircle2(0.0, 0.0, 1.0)
14852         c, cI = [DataArrayInt(l) for l in [[NORM_QPOLYG, 7,5,3,1,  6,4,2,0], [0,9]] ]
14853         m.colinearize2D(1e-10)
14854         m.checkCoherency2()
14855         self.assertEqual([NORM_QPOLYG, 3,5,  8,4], m.getNodalConnectivity().getValues())
14856         self.assertTrue( m.getCoords()[8].isEqual( DataArrayDouble([(1.0,0.0)]), 1.0e-12 ) )
14857         self.assertEqual([0,5], m.getNodalConnectivityIndex().getValues())
14858
14859     def testSwig2CheckAndPreparePermutation2(self):
14860         a=DataArrayInt([10003,9999999,5,67])
14861         self.assertTrue(DataArrayInt.CheckAndPreparePermutation(a).isEqual(DataArrayInt([2,3,0,1])))
14862         a=DataArrayInt([10003,-9999999,5,67])
14863         self.assertTrue(DataArrayInt.CheckAndPreparePermutation(a).isEqual(DataArrayInt([3,0,1,2])))
14864         a=DataArrayInt([])
14865         self.assertTrue(DataArrayInt.checkAndPreparePermutation(a).isEqual(DataArrayInt([])))
14866         pass
14867
14868     def testSwig2ComputeNeighborsOfNodes1(self):
14869         arrX=DataArrayDouble(3) ; arrX.iota()
14870         arrY=DataArrayDouble(4) ; arrY.iota()
14871         arrZ=DataArrayDouble(5) ; arrZ.iota()
14872         m=MEDCouplingCMesh() ; m.setCoords(arrX,arrY,arrZ) ; m=m.buildUnstructured()
14873         # 3D
14874         a,b=m.computeNeighborsOfNodes()
14875         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])))
14876         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])))
14877         # 2D
14878         m=MEDCouplingCMesh() ; m.setCoords(arrX,arrY) ; m=m.buildUnstructured()
14879         a,b=m.computeNeighborsOfNodes()
14880         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])))
14881         self.assertTrue(b.isEqual(DataArrayInt([0,2,5,7,10,14,17,20,24,27,29,32,34])))
14882         # 1D
14883         m=m.buildDescendingConnectivity()[0]
14884         a,b=m.computeNeighborsOfNodes()
14885         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])))
14886         self.assertTrue(b.isEqual(DataArrayInt([0,2,5,7,10,14,17,20,24,27,29,32,34])))
14887         pass
14888
14889     def testSwigBugOnUnpackingTuplesInDataArray1(self):
14890         inp=DataArrayDouble([(1,2,3),(4,5,6),(7,8,9),(10,11,12)])
14891         it=inp.__iter__()
14892         r=it.next()
14893         self.assertRaises(StopIteration,r.__getitem__,4)
14894         self.assertEqual(len(r),3)
14895         a,b,c=r
14896         r=it.next()
14897         self.assertEqual(len(r),3)
14898         d,e,f=r
14899         r=it.next()
14900         self.assertEqual(len(r),3)
14901         g,h,i=r
14902         r=it.next()
14903         self.assertEqual(len(r),3)
14904         j,k,l=r
14905         self.assertTrue(inp.isEqual(DataArrayDouble([a,b,c,d,e,f,g,h,i,j,k,l],4,3),1e-12))
14906         ########
14907         inp=DataArrayInt([(1,2,3),(4,5,6),(7,8,9),(10,11,12)])
14908         it=inp.__iter__()
14909         r=it.next()
14910         self.assertRaises(StopIteration,r.__getitem__,4)
14911         self.assertEqual(len(r),3)
14912         a,b,c=r
14913         r=it.next()
14914         self.assertEqual(len(r),3)
14915         d,e,f=r
14916         r=it.next()
14917         self.assertEqual(len(r),3)
14918         g,h,i=r
14919         r=it.next()
14920         self.assertEqual(len(r),3)
14921         j,k,l=r
14922         self.assertTrue(inp.isEqual(DataArrayInt([a,b,c,d,e,f,g,h,i,j,k,l],4,3)))
14923         pass
14924
14925     def testSwig2IMesh1(self):
14926         """ 1st test of image grid mesh.
14927         """
14928         m=MEDCouplingIMesh()
14929         self.assertEqual(m.getSpaceDimension(),-1)
14930         self.assertEqual(1,len(m.__repr__().split("\n")))
14931         self.assertEqual(6,len(m.__str__().split("\n")))
14932         self.assertRaises(InterpKernelException,m.getNodeStruct)
14933         self.assertRaises(InterpKernelException,m.getOrigin)
14934         self.assertRaises(InterpKernelException,m.getDXYZ)
14935         m.setSpaceDimension(3)
14936         self.assertEqual(9,len(m.__str__().split("\n")))
14937         self.assertEqual(4,len(m.__repr__().split("\n")))
14938         self.assertEqual((0,0,0),m.getNodeStruct())
14939         self.assertEqual((0.,0.,0.),m.getOrigin())
14940         self.assertEqual((0.,0.,0.),m.getDXYZ())
14941         self.assertRaises(InterpKernelException,m.setNodeStruct,[3,4])
14942         m.setNodeStruct([3,4,2])
14943         self.assertEqual((3,4,2),m.getNodeStruct())
14944         m.setOrigin(DataArrayDouble([1.5,2.5,3.5]))
14945         self.assertEqual((1.5,2.5,3.5),m.getOrigin())
14946         m.setDXYZ((0.5,1.,0.25))
14947         self.assertEqual((0.5,1.,0.25),m.getDXYZ())
14948         for it in DataArrayDouble([(1.5,2.5,3.5)]):
14949             m2=MEDCouplingIMesh("",3,DataArrayInt([3,4,2]),it,DataArrayDouble((0.5,1.,0.25)))
14950             pass
14951         self.assertEqual(3,m.getSpaceDimension())
14952         self.assertEqual((3,4,2),m2.getNodeStruct())
14953         self.assertEqual((1.5,2.5,3.5),m2.getOrigin())
14954         self.assertEqual((0.5,1.,0.25),m2.getDXYZ())
14955         self.assertEqual(24,m2.getNumberOfNodes())
14956         self.assertEqual(6,m2.getNumberOfCells())
14957         self.assertTrue(m.isEqual(m2,1e-12)) ; self.assertTrue(m.isEqualWithoutConsideringStr(m2,1e-12))
14958         m2.setAxisUnit("m")
14959         self.assertTrue(not m.isEqual(m2,1e-12)) ; self.assertTrue(m.isEqualWithoutConsideringStr(m2,1e-12))
14960         m.setAxisUnit("m")
14961         self.assertTrue(m.isEqual(m2,1e-12)) ; self.assertTrue(m.isEqualWithoutConsideringStr(m2,1e-12))
14962         m.setName("mesh")
14963         self.assertTrue(not m.isEqual(m2,1e-12)) ; self.assertTrue(m.isEqualWithoutConsideringStr(m2,1e-12))
14964         m2.setName("mesh")
14965         self.assertTrue(m.isEqual(m2,1e-12)) ; self.assertTrue(m.isEqualWithoutConsideringStr(m2,1e-12))
14966         m2.setTime(1.1,0,3)
14967         self.assertTrue(not m.isEqual(m2,1e-12))
14968         m.setTime(1.1,0,3)
14969         self.assertTrue(m.isEqual(m2,1e-12))
14970         m.setTimeUnit("ms")
14971         self.assertTrue(not m.isEqual(m2,1e-12)) ; self.assertTrue(m.isEqualWithoutConsideringStr(m2,1e-12))
14972         m2.setTimeUnit("ms")
14973         self.assertTrue(m.isEqual(m2,1e-12)) ; self.assertTrue(m.isEqualWithoutConsideringStr(m2,1e-12))
14974         #
14975         m2.setNodeStruct([3,2,4])
14976         self.assertTrue(not m.isEqual(m2,1e-12))
14977         m.setNodeStruct([3,2,4])
14978         self.assertTrue(m.isEqual(m2,1e-12))
14979         m.setOrigin(DataArrayDouble([1.5,3.5,2.5]))
14980         self.assertTrue(not m.isEqual(m2,1e-12))
14981         m2.setOrigin([1.5,3.5,2.5])
14982         self.assertTrue(m.isEqual(m2,1e-12))
14983         m.setDXYZ((0.5,0.25,1.))
14984         self.assertTrue(not m.isEqual(m2,1e-12))
14985         m2.setDXYZ(DataArrayDouble((0.5,0.25,1.)))
14986         self.assertTrue(m.isEqual(m2,1e-12))
14987         m2bis=m2.deepCpy()
14988         self.assertTrue(m2bis.isEqual(m2,1e-12))
14989         #
14990         self.assertEqual(6,m2bis.getNumberOfCells())#3,2,4
14991         m2bis.refineWithFactor([3,3,3])
14992         self.assertEqual(162,m2bis.getNumberOfCells())
14993         self.assertEqual((7,4,10),m2bis.getNodeStruct())
14994         self.assertEqual((1.5,3.5,2.5),m2bis.getOrigin())
14995         self.assertTrue(DataArrayDouble([0.16666666666666666,0.08333333333333333,0.3333333333333333]).isEqual(DataArrayDouble(m2bis.getDXYZ()),1e-12))
14996         #
14997         self.assertEqual(3,m.getMeshDimension())
14998         self.assertAlmostEqual(0.125,m.getMeasureOfAnyCell(),16);
14999         mu=MEDCoupling1SGTUMesh(m.buildUnstructured())
15000         mu.checkCoherency2()
15001         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]"])
15002         self.assertTrue(isinstance(mu,MEDCoupling1SGTUMesh))
15003         self.assertEqual(NORM_HEXA8,mu.getCellModelEnum())
15004         self.assertTrue(mu.getCoords().isEqual(cooExp,1e-12))
15005         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])))
15006         bary=m.getBarycenterAndOwner()
15007         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]"])
15008         self.assertTrue(bary.isEqual(baryExp,1e-12))
15009         #
15010         c=m.convertToCartesian()
15011         c.checkCoherency()
15012         self.assertEqual([1.1,0,3],c.getTime())
15013         self.assertEqual("ms",c.getTimeUnit())
15014         self.assertEqual(3,c.getMeshDimension())
15015         self.assertEqual(3,c.getSpaceDimension())
15016         arrX=DataArrayDouble([1.5,2.,2.5]) ; arrX.setInfoOnComponents(["X [m]"])
15017         self.assertTrue(c.getCoordsAt(0).isEqual(arrX,1e-12))
15018         arrY=DataArrayDouble([3.5,3.75]) ; arrY.setInfoOnComponents(["Y [m]"])
15019         self.assertTrue(c.getCoordsAt(1).isEqual(arrY,1e-12))
15020         arrZ=DataArrayDouble([2.5,3.5,4.5,5.5]) ; arrZ.setInfoOnComponents(["Z [m]"])
15021         self.assertTrue(c.getCoordsAt(2).isEqual(arrZ,1e-12))
15022         self.assertTrue(c.buildUnstructured().isEqual(m.buildUnstructured(),1e-12))
15023         #
15024         a,b=m.getCellsContainingPoints(baryExp,1e-12)
15025         self.assertTrue(a.isEqual(DataArrayInt([0,1,2,3,4,5])))
15026         self.assertTrue(b.isEqual(DataArrayInt([0,1,2,3,4,5,6])))
15027         for a,b in enumerate(baryExp):
15028             self.assertEqual(a,m.getCellContainingPoint(b,1e-12))
15029             pass
15030         #
15031         m.translate([1.,2.,4.])
15032         self.assertEqual((3,2,4),m.getNodeStruct())
15033         self.assertEqual((2.5,5.5,6.5),m.getOrigin())
15034         self.assertEqual((0.5,0.25,1.),m.getDXYZ())
15035         m.scale([0.,1.,3.],2.)
15036         self.assertAlmostEqual(1.,m.getMeasureOfAnyCell(),16);
15037         self.assertEqual((3,2,4),m.getNodeStruct())
15038         self.assertEqual((5.,10.,10.),m.getOrigin())
15039         self.assertEqual((1.,0.5,2.),m.getDXYZ())
15040         #
15041         f=m.getMeasureField(False)
15042         f2=MEDCouplingFieldDouble(ON_CELLS) ; f2.setTime(1.1,0,3) ; f2.setMesh(m) ; arr=DataArrayDouble(6) ; arr[:]=1. ; f2.setArray(arr) ; f2.setTimeUnit("ms")
15043         f2.setName("MeasureOfMesh_mesh")
15044         self.assertTrue(f.isEqual(f2,1e-12,1e-12))
15045         #
15046         m3=m.buildStructuredSubPart([(1,2),(0,1),(1,3)])
15047         self.assertEqual((2,2,3),m3.getNodeStruct())
15048         self.assertEqual((6.,10.,12.),m3.getOrigin())
15049         self.assertEqual((1.,0.5,2.),m3.getDXYZ())
15050         # now playing with 3D surf
15051         m4=MEDCouplingIMesh("",3,DataArrayInt([3,1,4]),DataArrayDouble([1.5,2.5,3.5]),DataArrayDouble((0.5,1.,0.25))) ; m4.setAxisUnit("km")
15052         self.assertEqual([(1.5,2.5),(2.5,3.5),(3.5,4.25)],m4.getBoundingBox())
15053         self.assertEqual(3,m4.getSpaceDimension())
15054         self.assertEqual(2,m4.getMeshDimension())
15055         self.assertEqual(12,m4.getNumberOfNodes())
15056         self.assertEqual(6,m4.getNumberOfCells())
15057         mu=MEDCoupling1SGTUMesh(m4.buildUnstructured())
15058         mu.checkCoherency2()
15059         self.assertTrue(isinstance(mu,MEDCoupling1SGTUMesh))
15060         self.assertEqual(NORM_QUAD4,mu.getCellModelEnum())
15061         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]"])
15062         self.assertTrue(mu.getCoords().isEqual(coordsExp,1e-12))
15063         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])))
15064         pass
15065
15066     def testSwig1GetValuesAsTuple1(self):
15067         d=DataArrayDouble()
15068         self.assertEqual(d.getValues(),[])
15069         self.assertEqual(d.getValuesAsTuple(),[])
15070         d=DataArrayDouble(24) ; d.iota() ; d.rearrange(3)
15071         self.assertEqual(d.getValues(),[0.,1.,2.,3.,4.,5.,6.,7.,8.,9.,10.,11.,12.,13.,14.,15.,16.,17.,18.,19.,20.,21.,22.,23.])
15072         self.assertEqual(d.getValuesAsTuple(),[(0.,1.,2.0),(3.,4.,5.0),(6.,7.,8.0),(9.,10.,11.0),(12.,13.,14.0),(15.,16.,17.0),(18.,19.,20.0),(21.,22.,23.)])
15073         d=DataArrayInt()
15074         self.assertEqual(d.getValues(),[])
15075         self.assertEqual(d.getValuesAsTuple(),[])
15076         d=DataArrayInt(24) ; d.iota() ; d.rearrange(3)
15077         self.assertEqual(d.getValues(),[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23])
15078         self.assertEqual(d.getValuesAsTuple(),[(0,1,2),(3,4,5),(6,7,8),(9,10,11),(12,13,14),(15,16,17),(18,19,20),(21,22,23)])
15079         pass
15080
15081     def testSwig2AMR1(self):
15082         self.assertEqual((1,3,12),MEDCouplingStructuredMesh.GetSplitVectFromStruct([3,4,5]))
15083         self.assertEqual((3,2),MEDCouplingStructuredMesh.GetDimensionsFromCompactFrmt([(1,4),(2,4)]))
15084         #
15085         amr=MEDCouplingCartesianAMRMesh("",2,[3,3],[0,0],[1,1])
15086         self.assertEqual(4,amr.getNumberOfCellsAtCurrentLevel())
15087         self.assertEqual(4,amr.getNumberOfCellsRecursiveWithOverlap())
15088         self.assertEqual(4,amr.getNumberOfCellsRecursiveWithoutOverlap())
15089         self.assertEqual(0,amr.getNumberOfPatches())
15090         self.assertEqual(1,amr.getMaxNumberOfLevelsRelativeToThis())
15091         self.assertEqual(2,amr.getSpaceDimension())
15092         amr.addPatch([(1,2),(0,1)],[4,4])
15093         self.assertEqual(4,amr.getNumberOfCellsAtCurrentLevel())
15094         self.assertEqual(20,amr.getNumberOfCellsRecursiveWithOverlap())
15095         self.assertEqual(19,amr.getNumberOfCellsRecursiveWithoutOverlap())
15096         self.assertEqual(1,amr.getNumberOfPatches())
15097         self.assertEqual(2,amr.getMaxNumberOfLevelsRelativeToThis())
15098         self.assertEqual(2,amr.getSpaceDimension())
15099         amr[0].addPatch([(2,3),(1,3)],[3,2])
15100         self.assertEqual(amr[0].getBLTRRange(),[(1,2),(0,1)])
15101         self.assertEqual(4,amr.getNumberOfCellsAtCurrentLevel())
15102         self.assertEqual(32,amr.getNumberOfCellsRecursiveWithOverlap())
15103         self.assertEqual(29,amr.getNumberOfCellsRecursiveWithoutOverlap())
15104         self.assertEqual(1,amr.getNumberOfPatches())
15105         self.assertEqual(3,amr.getMaxNumberOfLevelsRelativeToThis())
15106         self.assertEqual(2,amr.getSpaceDimension())
15107         amr[0].addPatch([(0,2),(3,4)],[3,2])
15108         self.assertEqual(16,amr[0].getMesh().getNumberOfCellsAtCurrentLevel())
15109         self.assertEqual(44,amr.getNumberOfCellsRecursiveWithOverlap())
15110         self.assertEqual(39,amr.getNumberOfCellsRecursiveWithoutOverlap())
15111         self.assertEqual(2,amr[0].getMesh().getNumberOfPatches())
15112         self.assertEqual(3,amr.getMaxNumberOfLevelsRelativeToThis())
15113         self.assertEqual(2,amr.getSpaceDimension())
15114         del amr[0][1]
15115         self.assertEqual(amr[0].getBLTRRange(),[(1,2),(0,1)])
15116         self.assertEqual(4,amr.getNumberOfCellsAtCurrentLevel())
15117         self.assertEqual(32,amr.getNumberOfCellsRecursiveWithOverlap())
15118         self.assertEqual(29,amr.getNumberOfCellsRecursiveWithoutOverlap())
15119         self.assertEqual(1,amr.getNumberOfPatches())
15120         self.assertEqual(3,amr.getMaxNumberOfLevelsRelativeToThis())
15121         self.assertEqual(2,amr.getSpaceDimension())
15122         pass
15123
15124     def testSwig2NonRegressionTestPAL1164(self):
15125         """ Test PAL1164 Protection of applyLin against error in compoId ( #CEA22584 ) """
15126         xarr=DataArrayDouble(3,1)
15127         xarr.iota(0.)
15128         cmesh=MEDCouplingCMesh()
15129         cmesh.setCoords(xarr,xarr,xarr)
15130         mesh=cmesh.buildUnstructured()
15131         f=mesh.fillFromAnalytic(ON_CELLS,1,"(x-5.)*(x-5.)+(y-5.)*(y-5.)+(z-5.)*(z-5.)")
15132         f.setName("MyField")
15133         self.assertTrue(f.getArray().isEqual(DataArrayDouble([60.75,52.75,52.75,44.75,52.75,44.75,44.75,36.75]),1e-12))
15134         self.assertRaises(InterpKernelException,f.applyLin,2.,0.,1)# compoId 1 whereas f has only one component !
15135         self.assertTrue(f.getArray().isEqual(DataArrayDouble([60.75,52.75,52.75,44.75,52.75,44.75,44.75,36.75]),1e-12))
15136         f.applyLin(2.,0.,0)# here it is OK !
15137         self.assertTrue(f.getArray().isEqual(DataArrayDouble([121.5,105.5,105.5,89.5,105.5,89.5,89.5,73.5]),1e-12))
15138         f.applyLin(2.,0.)
15139         self.assertTrue(f.getArray().isEqual(DataArrayDouble([243.,211.,211.,179.,211.,179.,179.,147.]),1e-12))
15140         pass
15141
15142     def testSwig2StructurizeMe1(self):
15143         arrx=DataArrayDouble(3) ; arrx.iota() ; arrx*=2.
15144         arry=DataArrayDouble(4) ; arry.iota() ; arry+=3.
15145         arrz=DataArrayDouble(5) ; arrz.iota() ; arrz*=0.5 ; arrz+=2.
15146         c=MEDCouplingCMesh() ; c.setCoords(arrx,arry,arrz)
15147         c.setName("mesh") ; c.setDescription("mesh descr") ; c.setTimeUnit("us") ; c.setTime(1.2,3,4)
15148         u=c.buildUnstructured()
15149         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])
15150         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])
15151         u.renumberCells(cp)
15152         u.renumberNodes(np,len(np))
15153         u=MEDCoupling1SGTUMesh(u)
15154         #
15155         e,d,f=u.structurizeMe()
15156         self.assertTrue(c.isEqual(e,1e-12))
15157         self.assertTrue(d.isEqual(cp))
15158         self.assertTrue(f.isEqual(np))
15159         pass
15160
15161     def testSwig2DenseMatrix1(self):
15162         m0=DenseMatrix(DataArrayDouble([2,3,4,5,1,6]),2,3)
15163         self.assertEqual(m0.getNumberOfRows(),2)
15164         self.assertEqual(m0.getNumberOfCols(),3)
15165         self.assertEqual(m0.getNbOfElems(),6)
15166         ref=m0.getData().getHiddenCppPointer()
15167         m00=m0.deepCpy()
15168         self.assertTrue(m0.isEqual(m00,1e-12))
15169         m00.getData().setIJ(0,0,2.1)
15170         self.assertTrue(not m0.isEqual(m00,1e-12))
15171         m00.getData().setIJ(0,0,2.)
15172         self.assertTrue(m0.isEqual(m00,1e-12))
15173         self.assertTrue(m0.getData().isEqual(DataArrayDouble([2,3,4,5,1,6]),1e-12))
15174         #
15175         m000=m0*DataArrayDouble([5,9,3])
15176         self.assertTrue(m000.getData().isEqual(DataArrayDouble([49.,52.]),1e-12))
15177         #
15178         m0.reShape(3,2)
15179         self.assertTrue(not m0.isEqual(m00,1e-12))
15180         self.assertEqual(m0.getNumberOfRows(),3)
15181         self.assertEqual(m0.getNumberOfCols(),2)
15182         self.assertEqual(ref,m0.getData().getHiddenCppPointer())
15183         self.assertTrue(m0.getData().isEqual(DataArrayDouble([2,3,4,5,1,6]),1e-12))
15184         m0.reShape(2,3)
15185         self.assertTrue(m0.isEqual(m00,1e-12))
15186         self.assertEqual(ref,m0.getData().getHiddenCppPointer())
15187         self.assertEqual(m0.getNumberOfRows(),2)
15188         self.assertEqual(m0.getNumberOfCols(),3)
15189         self.assertTrue(m0.getData().isEqual(DataArrayDouble([2,3,4,5,1,6]),1e-12))
15190         #m0np=m0.getData().toNumPyArray() ; m0np=matrix(m0np.reshape(m0.getNumberOfRows(),m0.getNumberOfCols()))
15191         m1=m0.deepCpy()
15192         self.assertEqual(m1.getNumberOfRows(),2)
15193         self.assertEqual(m1.getNumberOfCols(),3)
15194         self.assertTrue(m1.getData().isEqual(DataArrayDouble([2,3,4,5,1,6]),1e-12))
15195         m11=m0.deepCpy() ; m11+=m1
15196         self.assertEqual(m11.getNumberOfRows(),2)
15197         self.assertEqual(m11.getNumberOfCols(),3)
15198         self.assertTrue(m11.getData().isEqual(DataArrayDouble([4,6,8,10,2,12]),1e-12))
15199         m11=m11+m1
15200         self.assertEqual(m11.getNumberOfRows(),2)
15201         self.assertEqual(m11.getNumberOfCols(),3)
15202         self.assertTrue(m11.getData().isEqual(DataArrayDouble([6,9,12,15,3,18]),1e-12))
15203         m11=m11-m1
15204         self.assertEqual(m11.getNumberOfRows(),2)
15205         self.assertEqual(m11.getNumberOfCols(),3)
15206         self.assertTrue(m11.getData().isEqual(DataArrayDouble([4,6,8,10,2,12]),1e-12))
15207         m11-=m1
15208         self.assertEqual(m1.getNumberOfRows(),2)
15209         self.assertEqual(m1.getNumberOfCols(),3)
15210         self.assertTrue(m1.getData().isEqual(DataArrayDouble([2,3,4,5,1,6]),1e-12))
15211         m1.transpose()
15212         self.assertEqual(m1.getNumberOfRows(),3)
15213         self.assertEqual(m1.getNumberOfCols(),2)
15214         self.assertTrue(m1.getData().isEqual(DataArrayDouble([2,5,3,1,4,6]),1e-12))
15215         #m1np=m0np.transpose()
15216         m2=m0*m1
15217         self.assertEqual(m2.getNumberOfRows(),2)
15218         self.assertEqual(m2.getNumberOfCols(),2)
15219         self.assertTrue(m2.getData().isEqual(DataArrayDouble([29,37,37,62]),1e-12))
15220         pass
15221
15222     def testSwig2AMR2(self):
15223         """ 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."""
15224         coarse=DataArrayDouble(35) ; coarse.iota(0) #X=5,Y=7
15225         fine=DataArrayDouble(3*2*4*4) ; fine.iota(0) #X=3,Y=2 refined by 4
15226         MEDCouplingIMesh.CondenseFineToCoarse([5,7],fine,[(1,4),(2,4)],[4,4],coarse)
15227         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))
15228         # 3D
15229         coarse=DataArrayDouble(175) ; coarse.iota(0) #X=5,Y=7,Z=5
15230         fine=DataArrayDouble(3*2*3*4*4*4) ; fine.iota(0) #X=3,Y=2,Z=3 refined by 4
15231         MEDCouplingIMesh.CondenseFineToCoarse([5,7,5],fine,[(1,4),(2,4),(1,4)],[4,4,4],coarse)
15232         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))
15233         # 1D
15234         coarse=DataArrayDouble(5) ; coarse.iota(0) #X=5
15235         fine=DataArrayDouble(3*4) ; fine.iota(0) #X=3 refined by 4
15236         MEDCouplingIMesh.CondenseFineToCoarse([5],fine,[(1,4)],[4],coarse)
15237         self.assertTrue(coarse.isEqual(DataArrayDouble([0,6,22,38,4]),1e-12))
15238         pass
15239
15240     def testSwig2AMR3(self):
15241         """ Test spread of coarse IMesh instance into a fine one, with a factor."""
15242         coarse=DataArrayDouble(35) ; coarse.iota(0) #X=5,Y=7
15243         fine=DataArrayDouble(3*2*4*4) ; fine.iota(0) #X=3,Y=2 refined by 4
15244         MEDCouplingIMesh.SpreadCoarseToFine(coarse,[5,7],fine,[(1,4),(2,4)],[4,4])
15245         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))
15246         # 3D
15247         coarse=DataArrayDouble(175) ; coarse.iota(0) #X=5,Y=7,Z=5
15248         fine=DataArrayDouble(3*2*3*4*4*4) ; fine.iota(0) #X=3,Y=2,Z=3 refined by 4
15249         MEDCouplingIMesh.SpreadCoarseToFine(coarse,[5,7,5],fine,[(1,4),(2,4),(1,4)],[4,4,4])
15250         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))
15251         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()
15252         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()
15253         # 1D
15254         coarse=DataArrayDouble(5) ; coarse.iota(0) #X=5
15255         fine=DataArrayDouble(3*4) ; fine.iota(0) #X=3 refined by 4
15256         MEDCouplingIMesh.SpreadCoarseToFine(coarse,[5],fine,[(1,4)],[4])
15257         self.assertTrue(fine.isEqual(DataArrayDouble([1.,1.,1.,1.,2.,2.,2.,2.,3.,3.,3.,3.]),1e-12))
15258         pass
15259
15260     def testSwig2AMR4(self):
15261         """This test focuses on MEDCouplingCartesianAMRMesh.createPatchesFromCriterion method. To test it a field containing 0 everywhere except in the annulus (centered on the center of the mesh) value is 1."""
15262         im=MEDCouplingIMesh("mesh",2,[51,51],[0.,0.],[0.04,0.04])
15263         b=im.getBarycenterAndOwner() ; b-=[1.,1.] ; b=b.magnitude()
15264         ids=b.getIdsInRange(0.4,0.7)
15265         f=MEDCouplingFieldDouble(ON_CELLS) ; f.setMesh(im) ; f.setName("toto") ; arr=DataArrayDouble(im.getNumberOfCells()) ; arr[:]=0. ; arr[ids]=1. ; f.setArray(arr)
15266         # f.write("test.vti")
15267         amr=MEDCouplingCartesianAMRMesh(MEDCouplingIMesh("mesh",2,[51,51],[0.,0.],[0.04,0.04]))
15268         arr2=DataArrayByte(im.getNumberOfCells()) ; arr2[:]=0 ; arr2[ids]=1
15269         bso=BoxSplittingOptions() ; bso.setEfficiencyGoal(0.5); bso.setEfficiencyThreshold(0.8) ; bso.setMaximumNbOfCellsInPatch(3000) ; bso.setMinimumPatchLength(6) ; bso.setMaximumPatchLength(11)
15270         amr.createPatchesFromCriterion(bso,arr2,[2,2])
15271         m=amr.getImageMesh() ; m=m.buildUnstructured() ; m.changeSpaceDimension(3,1.)
15272         self.assertEqual(12,amr.getNumberOfPatches())
15273         exp0=[[(9,19),(9,19)],[(9,19),(31,41)],[(31,41),(9,19)],[(8,17),(19,25)],[(8,17),(25,31)],[(19,25),(8,17)],[(25,31),(8,17)],[(19,25),(33,42)],[(25,31),(33,42)],[(31,41),(31,41)],[(33,42),(19,25)],[(33,42),(25,31)]]
15274         for i,bltr in enumerate(exp0):
15275             self.assertEqual(amr[i].getBLTRRange(),bltr)
15276             pass
15277         self.assertAlmostEqual(0.666666666667,amr[3].getMesh().getImageMesh().computeSquareness(),12)
15278         #
15279         self.assertEqual(MEDCouplingStructuredMesh.ChangeReferenceToGlobalOfCompactFrmt([(8,32),(4,17)],[(0,24),(2,12)]),[(8,32),(6,16)])
15280         self.assertEqual(MEDCouplingStructuredMesh.ChangeReferenceFromGlobalOfCompactFrmt([(8,32),(4,17)],[(8,32),(6,16)]),[(0,24),(2,12)])
15281         self.assertTrue(amr.getImageMesh().isEqual(im,1e-12))
15282         m=amr.getImageMesh().asSingleCell().build1SGTUnstructured()
15283         self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([1,0,2,3])))
15284         self.assertTrue(m.getCoords().isEqualWithoutConsideringStr(DataArrayDouble([(0,0),(2,0),(0,2),(2,2)]),1e-12))
15285         pass
15286
15287     def testSwig2AMR5(self):
15288         """ Idem testAMR3, test spread of coarse IMesh instance into a fine one, with a factor, but here ghost is used !"""
15289         # 1D
15290         coarse=DataArrayDouble(5+2) ; coarse.iota(-1) #X=5 with ghostLev=1
15291         fine=DataArrayDouble(3*4+2) ; fine.iota(1000) #X=3 refined by 4 with ghostLev=1
15292         MEDCouplingIMesh.SpreadCoarseToFineGhost(coarse,[5],fine,[(1,4)],[4],1)
15293         self.assertTrue(fine.isEqual(DataArrayDouble([0,1,1,1,1,2,2,2,2,3,3,3,3,4]),1e-12))
15294         coarse.iota(-1000)
15295         MEDCouplingIMesh.CondenseFineToCoarseGhost([5],fine,[(1,4)],[4],coarse,1)
15296         self.assertTrue(coarse.isEqual(DataArrayDouble([-1000.,-999.,4.,8.,12.,-995.,-994.]),1e-12))
15297         # 2D
15298         coarse=DataArrayDouble((5+2*1)*(7+2*1)) ; coarse.iota(0) #X=5,Y=7 with ghostLev=1
15299         fine=DataArrayDouble((3*4+2*1)*(2*4+2*1)) ; fine.iota(1000) #X=3,Y=2 refined by 4
15300         MEDCouplingIMesh.SpreadCoarseToFineGhost(coarse,[5,7],fine,[(1,4),(2,4)],[4,4],1)
15301         self.assertTrue(fine.isEqual(DataArrayDouble([15.,16.,16.,16.,16.,17.,17.,17.,17.,18.,18.,18.,18.,19.,22.,23.,23.,23.,23.,24.,24.,24.,24.,25.,25.,25.,25.,26.,22.,23.,23.,23.,23.,24.,24.,24.,24.,25.,25.,25.,25.,26.,22.,23.,23.,23.,23.,24.,24.,24.,24.,25.,25.,25.,25.,26.,22.,23.,23.,23.,23.,24.,24.,24.,24.,25.,25.,25.,25.,26.,29.,30.,30.,30.,30.,31.,31.,31.,31.,32.,32.,32.,32.,33.,29.,30.,30.,30.,30.,31.,31.,31.,31.,32.,32.,32.,32.,33.,29.,30.,30.,30.,30.,31.,31.,31.,31.,32.,32.,32.,32.,33.,29.,30.,30.,30.,30.,31.,31.,31.,31.,32.,32.,32.,32.,33.,36.,37.,37.,37.,37.,38.,38.,38.,38.,39.,39.,39.,39.,40.]),1e-12))
15302         f=MEDCouplingFieldDouble(ON_CELLS) ; f.setMesh(MEDCouplingIMesh("",2,DataArrayInt([8,10]),[0.,0.],DataArrayDouble((1.,1.)))) ; f.setArray(coarse) ; f.setName("tutu") ; f.checkCoherency()
15303         coarse.iota(-1000)
15304         fine2=DataArrayDouble.Meld(fine,3*fine) ; coarse2=DataArrayDouble.Meld(coarse,3*coarse)
15305         MEDCouplingIMesh.CondenseFineToCoarseGhost([5,7],fine,[(1,4),(2,4)],[4,4],coarse,1)
15306         MEDCouplingIMesh.CondenseFineToCoarseGhost([5,7],fine2,[(1,4),(2,4)],[4,4],coarse2,1)
15307         f=MEDCouplingFieldDouble(ON_CELLS) ; f.setMesh(MEDCouplingIMesh("",2,DataArrayInt([8,10]),[0.,0.],DataArrayDouble((1.,1.)))) ; f.setArray(coarse) ; f.setName("tutu") ; f.checkCoherency()
15308         coarseExp=DataArrayDouble([-1000.,-999.,-998.,-997.,-996.,-995.,-994.,-993.,-992.,-991.,-990.,-989.,-988.,-987.,-986.,-985.,-984.,-983.,-982.,-981.,-980.,-979.,-978.,368.,384.,400.,-974.,-973.,-972.,-971.,480.,496.,512.,-967.,-966.,-965.,-964.,-963.,-962.,-961.,-960.,-959.,-958.,-957.,-956.,-955.,-954.,-953.,-952.,-951.,-950.,-949.,-948.,-947.,-946.,-945.,-944.,-943.,-942.,-941.,-940.,-939.,-938.])
15309         self.assertTrue(coarse.isEqual(coarseExp,1e-12))
15310         self.assertTrue(coarse2[:,0].isEqual(coarseExp,1e-12))
15311         self.assertTrue(coarse2[:,1].isEqual(3*coarseExp,1e-12))
15312         pass
15313
15314     def testSwig2AMR6(self):
15315         """ Idem testSwig2AMR5, except that only 2D is considered here, and fine to fine is considered here. At the end of the test some checks about typing with AMR structs."""
15316         amr=MEDCouplingCartesianAMRMesh("",2,[6,6],[0,0],[1,1])
15317         da=DataArrayDouble((5+2)*(5+2)) ; da.iota() ; da+=0.9
15318         amr.addPatch([(1,4),(2,4)],[4,4])
15319         amr.addPatch([(0,1),(0,1)],[4,4])
15320         amr.addPatch([(4,5),(3,4)],[4,4])
15321         amr.addPatch([(4,5),(1,3)],[4,4])
15322         amr.addPatch([(0,1),(1,4)],[4,4])
15323         da0=DataArrayDouble((3*4+2)*(2*4+2)) ; da0.iota() ; da0[:]+=0.2
15324         da1=DataArrayDouble((1*4+2)*(1*4+2)) ; da1.iota() ; da1[:]+=0.4
15325         da2=DataArrayDouble((1*4+2)*(1*4+2)) ; da2.iota() ; da2[:]+=0.6
15326         da3=DataArrayDouble((1*4+2)*(2*4+2)) ; da3.iota() ; da3[:]+=0.7
15327         da4=DataArrayDouble((1*4+2)*(3*4+2)) ; da4.iota() ; da4[:]+=0.8
15328         self.assertEqual(5,amr.getNumberOfPatches())
15329         l=[da0,da1,da2,da3,da4]
15330         lCpy=[elt.deepCpy() for elt in l]
15331         l2=[DataArrayDouble.Meld(elt,3*elt) for elt in l]
15332         amr.fillCellFieldOnPatchGhostAdv(0,da,1,l,False)
15333         amr.fillCellFieldOnPatchGhostAdv(0,DataArrayDouble.Meld(da,3*da),1,l2,False)
15334         amr.fillCellFieldOnPatchOnlyOnGhostZone(0,da,lCpy[0],1)
15335         #
15336         f=MEDCouplingFieldDouble(ON_CELLS) ; f.setMesh(amr.getImageMesh().buildWithGhost(1)) ; f.setArray(da) ; f.setName("all")
15337         f0=MEDCouplingFieldDouble(ON_CELLS) ; f0.setMesh(amr[0].getMesh().getImageMesh().buildWithGhost(1)) ; f0.setArray(da0) ; f0.setName("p0") ; f0.checkCoherency()
15338         f1=MEDCouplingFieldDouble(ON_CELLS) ; f1.setMesh(amr[1].getMesh().getImageMesh().buildWithGhost(1)) ; f1.setArray(da1) ; f1.setName("p1") ; f1.checkCoherency()
15339         f2=MEDCouplingFieldDouble(ON_CELLS) ; f2.setMesh(amr[2].getMesh().getImageMesh().buildWithGhost(1)) ; f2.setArray(da2) ; f2.setName("p2") ; f2.checkCoherency()
15340         f3=MEDCouplingFieldDouble(ON_CELLS) ; f3.setMesh(amr[3].getMesh().getImageMesh().buildWithGhost(1)) ; f3.setArray(da3) ; f3.setName("p3") ; f3.checkCoherency()
15341         f4=MEDCouplingFieldDouble(ON_CELLS) ; f4.setMesh(amr[4].getMesh().getImageMesh().buildWithGhost(1)) ; f4.setArray(da4) ; f4.setName("p4") ; f4.checkCoherency()
15342         #
15343         da0Exp=DataArrayDouble([28.8,16.9,16.9,16.9,16.9,17.9,17.9,17.9,17.9,18.9,18.9,18.9,18.9,25.7,34.8,23.9,23.9,23.9,23.9,24.9,24.9,24.9,24.9,25.9,25.9,25.9,25.9,31.7,40.8,23.9,23.9,23.9,23.9,24.9,24.9,24.9,24.9,25.9,25.9,25.9,25.9,37.7,46.8,23.9,23.9,23.9,23.9,24.9,24.9,24.9,24.9,25.9,25.9,25.9,25.9,43.7,52.8,23.9,23.9,23.9,23.9,24.9,24.9,24.9,24.9,25.9,25.9,25.9,25.9,49.7,58.8,30.9,30.9,30.9,30.9,31.9,31.9,31.9,31.9,32.9,32.9,32.9,32.9,7.6,64.8,30.9,30.9,30.9,30.9,31.9,31.9,31.9,31.9,32.9,32.9,32.9,32.9,13.6,70.8,30.9,30.9,30.9,30.9,31.9,31.9,31.9,31.9,32.9,32.9,32.9,32.9,19.6,76.8,30.9,30.9,30.9,30.9,31.9,31.9,31.9,31.9,32.9,32.9,32.9,32.9,25.6,36.9,37.9,37.9,37.9,37.9,38.9,38.9,38.9,38.9,39.9,39.9,39.9,39.9,40.9])
15344         da0Exp2=DataArrayDouble([15.9,16.9,16.9,16.9,16.9,17.9,17.9,17.9,17.9,18.9,18.9,18.9,18.9,19.9,22.9,15.2,16.2,17.2,18.2,19.2,20.2,21.2,22.2,23.2,24.2,25.2,26.2,26.9,22.9,29.2,30.2,31.2,32.2,33.2,34.2,35.2,36.2,37.2,38.2,39.2,40.2,26.9,22.9,43.2,44.2,45.2,46.2,47.2,48.2,49.2,50.2,51.2,52.2,53.2,54.2,26.9,22.9,57.2,58.2,59.2,60.2,61.2,62.2,63.2,64.2,65.2,66.2,67.2,68.2,26.9,29.9,71.2,72.2,73.2,74.2,75.2,76.2,77.2,78.2,79.2,80.2,81.2,82.2,33.9,29.9,85.2,86.2,87.2,88.2,89.2,90.2,91.2,92.2,93.2,94.2,95.2,96.2,33.9,29.9,99.2,100.2,101.2,102.2,103.2,104.2,105.2,106.2,107.2,108.2,109.2,110.2,33.9,29.9,113.2,114.2,115.2,116.2,117.2,118.2,119.2,120.2,121.2,122.2,123.2,124.2,33.9,36.9,37.9,37.9,37.9,37.9,38.9,38.9,38.9,38.9,39.9,39.9,39.9,39.9,40.9])
15345         self.assertTrue(da0.isEqual(da0Exp,1e-12))
15346         self.assertTrue(l2[0][:,0].isEqual(da0Exp,1e-12))
15347         self.assertTrue(l2[0][:,1].isEqual(3*da0Exp,1e-12))
15348         self.assertTrue(lCpy[0].isEqual(da0Exp2,1e-12))
15349         #
15350         g0=amr.retrieveGridsAt(0)
15351         self.assertEqual(1,len(g0))
15352         self.assertTrue(isinstance(g0[0],MEDCouplingCartesianAMRPatchGF))
15353         g1=amr.retrieveGridsAt(1)
15354         self.assertEqual(5,len(g1))
15355         for i in xrange(5):
15356             self.assertTrue(isinstance(g1[i],MEDCouplingCartesianAMRPatch))
15357             pass
15358         pass
15359
15360     def testSwig2AMR7(self):
15361         """Idem testSwig2AMR6 except that we are in 1D"""
15362         amr=MEDCouplingCartesianAMRMesh("",1,[6],[0],[1])
15363         da=DataArrayDouble(5+2) ; da.iota() ; da+=0.9
15364         amr.addPatch([(1,4)],[4])
15365         amr.addPatch([(0,1)],[4])
15366         da0=DataArrayDouble(3*4+2) ; da0.iota() ; da0[:]+=0.2
15367         da1=DataArrayDouble(1*4+2) ; da1.iota() ; da1[:]+=0.4
15368         self.assertEqual(2,amr.getNumberOfPatches())
15369         l=[da0,da1]
15370         lCpy=[elt.deepCpy() for elt in l]
15371         l2=[DataArrayDouble.Meld(elt,3*elt) for elt in l]
15372         amr.fillCellFieldOnPatchGhostAdv(0,da,1,l,False)
15373         amr.fillCellFieldOnPatchGhostAdv(0,DataArrayDouble.Meld(da,3*da),1,l2,False)
15374         amr.fillCellFieldOnPatchOnlyOnGhostZone(0,da,lCpy[0],1)
15375         #
15376         f=MEDCouplingFieldDouble(ON_CELLS) ; f.setMesh(amr.getImageMesh().buildWithGhost(1)) ; f.setArray(da) ; f.setName("all")
15377         f0=MEDCouplingFieldDouble(ON_CELLS) ; f0.setMesh(amr[0].getMesh().getImageMesh().buildWithGhost(1)) ; f0.setArray(da0) ; f0.setName("p0") ; f0.checkCoherency()
15378         f1=MEDCouplingFieldDouble(ON_CELLS) ; f1.setMesh(amr[1].getMesh().getImageMesh().buildWithGhost(1)) ; f1.setArray(da1) ; f1.setName("p1") ; f1.checkCoherency()
15379         #
15380         da0Exp=DataArrayDouble([4.4,2.9,2.9,2.9,2.9,3.9,3.9,3.9,3.9,4.9,4.9,4.9,4.9,5.9])
15381         da0Exp2=DataArrayDouble([1.9,1.2,2.2,3.2,4.2,5.2,6.2,7.2,8.2,9.2,10.2,11.2,12.2,5.9])
15382         self.assertTrue(da0.isEqual(da0Exp,1e-12))
15383         self.assertTrue(l2[0][:,0].isEqual(da0Exp,1e-12))
15384         self.assertTrue(l2[0][:,1].isEqual(3*da0Exp,1e-12))
15385         self.assertTrue(lCpy[0].isEqual(da0Exp2,1e-12))
15386         pass
15387
15388     def testSwig2AMR8(self):
15389         """This test checks 'basic' operations for ghost update."""
15390         ghostSz=1
15391         amr=MEDCouplingCartesianAMRMesh("",2,[6,7],[0,0],[1,1])
15392         amr.addPatch([(1,4),(2,4)],[4,4])
15393         amr.addPatch([(4,5),(3,5)],[4,4])
15394         amr.addPatch([(0,1),(4,6)],[4,4])
15395         amr[0].addPatch([(10,12),(5,8)],[2,2])
15396         amr[1].addPatch([(0,1),(0,5)],[2,2])
15397         amr[2].addPatch([(3,4),(0,3)],[2,2])
15398         m=amr.buildMeshFromPatchEnvelop()
15399         self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([1,0,2,3,5,4,6,7,9,8,10,11])))
15400         self.assertTrue(m.getCoords().isEqualWithoutConsideringStr(DataArrayDouble([1.,2.,4.,2.,1.,4.,4.,4.,4.,3.,5.,3.,4.,5.,5.,5.,0.,4.,1.,4.,0.,6.,1.,6.],12,2),1e-12))
15401         self.assertEqual(3,amr.getMaxNumberOfLevelsRelativeToThis())
15402         att=MEDCouplingAMRAttribute(amr,[("Field",["X"])],ghostSz)
15403         att.alloc()
15404         d=att.getFieldOn(amr,"Field")
15405         self.assertEqual(56,d.getNumberOfTuples())
15406         self.assertEqual(1,d.getNumberOfComponents())
15407         d.iota() ; d+=0.1
15408         d0=att.getFieldOn(amr[0].getMesh(),"Field")
15409         self.assertEqual(140,d0.getNumberOfTuples())
15410         self.assertEqual(1,d0.getNumberOfComponents())
15411         d0.iota() ; d0+=0.2
15412         d1=att.getFieldOn(amr[1].getMesh(),"Field")
15413         self.assertEqual(60,d1.getNumberOfTuples())
15414         self.assertEqual(1,d1.getNumberOfComponents())
15415         d1.iota() ; d1+=0.3
15416         d2=att.getFieldOn(amr[2].getMesh(),"Field")
15417         self.assertEqual(60,d2.getNumberOfTuples())
15418         self.assertEqual(1,d2.getNumberOfComponents())
15419         d2.iota() ; d2+=0.4
15420         d00=att.getFieldOn(amr[0][0].getMesh(),"Field")
15421         self.assertEqual(48,d00.getNumberOfTuples())
15422         self.assertEqual(1,d00.getNumberOfComponents())
15423         d00.iota() ; d00+=0.5
15424         d10=att.getFieldOn(amr[1][0].getMesh(),"Field")
15425         self.assertEqual(48,d10.getNumberOfTuples())
15426         self.assertEqual(1,d10.getNumberOfComponents())
15427         d10.iota() ; d10+=0.6
15428         d20=att.getFieldOn(amr[2][0].getMesh(),"Field")
15429         self.assertEqual(32,d20.getNumberOfTuples())
15430         self.assertEqual(1,d20.getNumberOfComponents())
15431         d20.iota() ; d20+=0.7
15432         f=att.buildCellFieldOnRecurseWithoutOverlapWithoutGhost(amr,"Field")
15433         arrExp=DataArrayDouble([8.1,9.1,10.1,11.1,12.1,15.1,16.1,17.1,18.1,19.1,22.1,26.1,29.1,37.1,38.1,39.1,44.1,45.1,46.1,47.1,15.2,16.2,17.2,18.2,19.2,20.2,21.2,22.2,23.2,24.2,25.2,26.2,29.2,30.2,31.2,32.2,33.2,34.2,35.2,36.2,37.2,38.2,39.2,40.2,43.2,44.2,45.2,46.2,47.2,48.2,49.2,50.2,51.2,52.2,53.2,54.2,57.2,58.2,59.2,60.2,61.2,62.2,63.2,64.2,65.2,66.2,67.2,68.2,71.2,72.2,73.2,74.2,75.2,76.2,77.2,78.2,79.2,80.2,81.2,82.2,85.2,86.2,87.2,88.2,89.2,90.2,91.2,92.2,93.2,94.2,99.2,100.2,101.2,102.2,103.2,104.2,105.2,106.2,107.2,108.2,113.2,114.2,115.2,116.2,117.2,118.2,119.2,120.2,121.2,122.2,7.5,8.5,9.5,10.5,13.5,14.5,15.5,16.5,19.5,20.5,21.5,22.5,25.5,26.5,27.5,28.5,31.5,32.5,33.5,34.5,37.5,38.5,39.5,40.5,8.3,9.3,10.3,14.3,15.3,16.3,20.3,21.3,22.3,26.3,27.3,28.3,32.3,33.3,34.3,37.3,38.3,39.3,40.3,43.3,44.3,45.3,46.3,49.3,50.3,51.3,52.3,5.6,6.6,9.6,10.6,13.6,14.6,17.6,18.6,21.6,22.6,25.6,26.6,29.6,30.6,33.6,34.6,37.6,38.6,41.6,42.6,7.4,8.4,9.4,13.4,14.4,15.4,19.4,20.4,21.4,25.4,26.4,27.4,28.4,31.4,32.4,33.4,34.4,37.4,38.4,39.4,40.4,43.4,44.4,45.4,46.4,49.4,50.4,51.4,52.4,5.7,6.7,9.7,10.7,13.7,14.7,17.7,18.7,21.7,22.7,25.7,26.7])
15434         arrExp.setName("Field") ; arrExp.setInfoOnComponents(["X"])
15435         self.assertTrue(f.getArray().isEqual(arrExp,1e-12))
15436         m=MEDCoupling1SGTUMesh(f.getMesh())
15437         self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([1,0,6,7,2,1,7,8,3,2,8,9,4,3,9,10,5,4,10,11,7,6,12,13,8,7,13,14,9,8,14,15,10,9,15,16,11,10,16,17,13,12,18,19,17,16,20,21,19,18,22,23,24,23,27,28,25,24,28,29,26,25,29,30,28,27,32,33,29,28,33,34,30,29,34,35,31,30,35,36,38,37,50,51,39,38,51,52,40,39,52,53,41,40,53,54,42,41,54,55,43,42,55,56,44,43,56,57,45,44,57,58,46,45,58,59,47,46,59,60,48,47,60,61,49,48,61,62,51,50,63,64,52,51,64,65,53,52,65,66,54,53,66,67,55,54,67,68,56,55,68,69,57,56,69,70,58,57,70,71,59,58,71,72,60,59,72,73,61,60,73,74,62,61,74,75,64,63,76,77,65,64,77,78,66,65,78,79,67,66,79,80,68,67,80,81,69,68,81,82,70,69,82,83,71,70,83,84,72,71,84,85,73,72,85,86,74,73,86,87,75,74,87,88,77,76,89,90,78,77,90,91,79,78,91,92,80,79,92,93,81,80,93,94,82,81,94,95,83,82,95,96,84,83,96,97,85,84,97,98,86,85,98,99,87,86,99,100,88,87,100,101,90,89,102,103,91,90,103,104,92,91,104,105,93,92,105,106,94,93,106,107,95,94,107,108,96,95,108,109,97,96,109,110,98,97,110,111,99,98,111,112,100,99,112,113,101,100,113,114,103,102,115,116,104,103,116,117,105,104,117,118,106,105,118,119,107,106,119,120,108,107,120,121,109,108,121,122,110,109,122,123,111,110,123,124,112,111,124,125,116,115,126,127,117,116,127,128,118,117,128,129,119,118,129,130,120,119,130,131,121,120,131,132,122,121,132,133,123,122,133,134,124,123,134,135,125,124,135,136,127,126,137,138,128,127,138,139,129,128,139,140,130,129,140,141,131,130,141,142,132,131,142,143,133,132,143,144,134,133,144,145,135,134,145,146,136,135,146,147,149,148,153,154,150,149,154,155,151,150,155,156,152,151,156,157,154,153,158,159,155,154,159,160,156,155,160,161,157,156,161,162,159,158,163,164,160,159,164,165,161,160,165,166,162,161,166,167,164,163,168,169,165,164,169,170,166,165,170,171,167,166,171,172,169,168,173,174,170,169,174,175,171,170,175,176,172,171,176,177,174,173,178,179,175,174,179,180,176,175,180,181,177,176,181,182,184,183,187,188,185,184,188,189,186,185,189,190,188,187,191,192,189,188,192,193,190,189,193,194,192,191,195,196,193,192,196,197,194,193,197,198,196,195,199,200,197,196,200,201,198,197,201,202,200,199,204,205,201,200,205,206,202,201,206,207,204,203,208,209,205,204,209,210,206,205,210,211,207,206,211,212,209,208,213,214,210,209,214,215,211,210,215,216,212,211,216,217,214,213,218,219,215,214,219,220,216,215,220,221,217,216,221,222,224,223,226,227,225,224,227,228,227,226,229,230,228,227,230,231,230,229,232,233,231,230,233,234,233,232,235,236,234,233,236,237,236,235,238,239,237,236,239,240,239,238,241,242,240,239,242,243,242,241,244,245,243,242,245,246,245,244,247,248,246,245,248,249,248,247,250,251,249,248,251,252,251,250,253,254,252,251,254,255,257,256,260,261,258,257,261,262,259,258,262,263,261,260,264,265,262,261,265,266,263,262,266,267,265,264,268,269,266,265,269,270,267,266,270,271,269,268,273,274,270,269,274,275,271,270,275,276,272,271,276,277,274,273,278,279,275,274,279,280,276,275,280,281,277,276,281,282,279,278,283,284,280,279,284,285,281,280,285,286,282,281,286,287,284,283,288,289,285,284,289,290,286,285,290,291,287,286,291,292,289,288,293,294,290,289,294,295,291,290,295,296,292,291,296,297,299,298,301,302,300,299,302,303,302,301,304,305,303,302,305,306,305,304,307,308,306,305,308,309,308,307,310,311,309,308,311,312,311,310,313,314,312,311,314,315,314,313,316,317,315,314,317,318])))
15438         self.assertTrue(m.getCoords().isEqualWithoutConsideringStr(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.,4.,3.,5.,3.,0.,4.,1.,4.,2.,4.,3.,4.,4.,4.,1.,5.,2.,5.,3.,5.,4.,5.,5.,5.,1.,6.,2.,6.,3.,6.,4.,6.,5.,6.,1.,2.,1.25,2.,1.5,2.,1.75,2.,2.,2.,2.25,2.,2.5,2.,2.75,2.,3.,2.,3.25,2.,3.5,2.,3.75,2.,4.,2.,1.,2.25,1.25,2.25,1.5,2.25,1.75,2.25,2.,2.25,2.25,2.25,2.5,2.25,2.75,2.25,3.,2.25,3.25,2.25,3.5,2.25,3.75,2.25,4.,2.25,1.,2.5,1.25,2.5,1.5,2.5,1.75,2.5,2.,2.5,2.25,2.5,2.5,2.5,2.75,2.5,3.,2.5,3.25,2.5,3.5,2.5,3.75,2.5,4.,2.5,1.,2.75,1.25,2.75,1.5,2.75,1.75,2.75,2.,2.75,2.25,2.75,2.5,2.75,2.75,2.75,3.,2.75,3.25,2.75,3.5,2.75,3.75,2.75,4.,2.75,1.,3.,1.25,3.,1.5,3.,1.75,3.,2.,3.,2.25,3.,2.5,3.,2.75,3.,3.,3.,3.25,3.,3.5,3.,3.75,3.,4.,3.,1.,3.25,1.25,3.25,1.5,3.25,1.75,3.25,2.,3.25,2.25,3.25,2.5,3.25,2.75,3.25,3.,3.25,3.25,3.25,3.5,3.25,3.75,3.25,4.,3.25,1.,3.5,1.25,3.5,1.5,3.5,1.75,3.5,2.,3.5,2.25,3.5,2.5,3.5,2.75,3.5,3.,3.5,3.25,3.5,3.5,3.5,1.,3.75,1.25,3.75,1.5,3.75,1.75,3.75,2.,3.75,2.25,3.75,2.5,3.75,2.75,3.75,3.,3.75,3.25,3.75,3.5,3.75,1.,4.,1.25,4.,1.5,4.,1.75,4.,2.,4.,2.25,4.,2.5,4.,2.75,4.,3.,4.,3.25,4.,3.5,4.,3.5,3.25,3.625,3.25,3.75,3.25,3.875,3.25,4.,3.25,3.5,3.375,3.625,3.375,3.75,3.375,3.875,3.375,4.,3.375,3.5,3.5,3.625,3.5,3.75,3.5,3.875,3.5,4.,3.5,3.5,3.625,3.625,3.625,3.75,3.625,3.875,3.625,4.,3.625,3.5,3.75,3.625,3.75,3.75,3.75,3.875,3.75,4.,3.75,3.5,3.875,3.625,3.875,3.75,3.875,3.875,3.875,4.,3.875,3.5,4.,3.625,4.,3.75,4.,3.875,4.,4.,4.,4.25,3.,4.5,3.,4.75,3.,5.,3.,4.25,3.25,4.5,3.25,4.75,3.25,5.,3.25,4.25,3.5,4.5,3.5,4.75,3.5,5.,3.5,4.25,3.75,4.5,3.75,4.75,3.75,5.,3.75,4.25,4.,4.5,4.,4.75,4.,5.,4.,4.,4.25,4.25,4.25,4.5,4.25,4.75,4.25,5.,4.25,4.,4.5,4.25,4.5,4.5,4.5,4.75,4.5,5.,4.5,4.,4.75,4.25,4.75,4.5,4.75,4.75,4.75,5.,4.75,4.,5.,4.25,5.,4.5,5.,4.75,5.,5.,5.,4.,3.,4.125,3.,4.25,3.,4.,3.125,4.125,3.125,4.25,3.125,4.,3.25,4.125,3.25,4.25,3.25,4.,3.375,4.125,3.375,4.25,3.375,4.,3.5,4.125,3.5,4.25,3.5,4.,3.625,4.125,3.625,4.25,3.625,4.,3.75,4.125,3.75,4.25,3.75,4.,3.875,4.125,3.875,4.25,3.875,4.,4.,4.125,4.,4.25,4.,4.,4.125,4.125,4.125,4.25,4.125,4.,4.25,4.125,4.25,4.25,4.25,0.,4.,0.25,4.,0.5,4.,0.75,4.,0.,4.25,0.25,4.25,0.5,4.25,0.75,4.25,0.,4.5,0.25,4.5,0.5,4.5,0.75,4.5,0.,4.75,0.25,4.75,0.5,4.75,0.75,4.75,1.,4.75,0.,5.,0.25,5.,0.5,5.,0.75,5.,1.,5.,0.,5.25,0.25,5.25,0.5,5.25,0.75,5.25,1.,5.25,0.,5.5,0.25,5.5,0.5,5.5,0.75,5.5,1.,5.5,0.,5.75,0.25,5.75,0.5,5.75,0.75,5.75,1.,5.75,0.,6.,0.25,6.,0.5,6.,0.75,6.,1.,6.,0.75,4.,0.875,4.,1.,4.,0.75,4.125,0.875,4.125,1.,4.125,0.75,4.25,0.875,4.25,1.,4.25,0.75,4.375,0.875,4.375,1.,4.375,0.75,4.5,0.875,4.5,1.,4.5,0.75,4.625,0.875,4.625,1.,4.625,0.75,4.75,0.875,4.75,1.,4.75],319,2),1e-12))
15439         # the test is here ! To be called after iteration with no remesh
15440         att.synchronizeAllGhostZones()
15441         f=att.buildCellFieldOnWithGhost(amr,"Field") ; f.checkCoherency()
15442         ftmp=att.buildCellFieldOnWithoutGhost(amr,"Field") ; ftmp.checkCoherency() ; self.assertTrue(ftmp.getArray().isEqualWithoutConsideringStr(DataArrayDouble([8.1,9.1,10.1,11.1,12.1,15.1,16.1,17.1,18.1,19.1,22.1,23.1,24.1,25.1,26.1,29.1,30.1,31.1,32.1,33.1,36.1,37.1,38.1,39.1,40.1,43.1,44.1,45.1,46.1,47.1]),1e-12))
15443         f0=att.buildCellFieldOnWithGhost(amr[0].getMesh(),"Field")
15444         f1=att.buildCellFieldOnWithGhost(amr[1].getMesh(),"Field")
15445         f2=att.buildCellFieldOnWithGhost(amr[2].getMesh(),"Field")
15446         f00=att.buildCellFieldOnWithGhost(amr[0][0].getMesh(),"Field")
15447         f10=att.buildCellFieldOnWithGhost(amr[1][0].getMesh(),"Field")
15448         f20=att.buildCellFieldOnWithGhost(amr[2][0].getMesh(),"Field")
15449         self.assertTrue(f.getArray().isEqualWithoutConsideringStr(DataArrayDouble([0.1,1.1,2.1,3.1,4.1,5.1,6.1,7.1,8.1,9.1,10.1,11.1,12.1,13.1,14.1,15.1,16.1,17.1,18.1,19.1,20.1,21.1,22.1,23.1,24.1,25.1,26.1,27.1,28.1,29.1,30.1,31.1,32.1,33.1,34.1,35.1,36.1,37.1,38.1,39.1,40.1,41.1,42.1,43.1,44.1,45.1,46.1,47.1,48.1,49.1,50.1,51.1,52.1,53.1,54.1,55.1]),1e-12))
15450         self.assertTrue(f0.getArray().isEqualWithoutConsideringStr(DataArrayDouble([15.1,16.1,16.1,16.1,16.1,17.1,17.1,17.1,17.1,18.1,18.1,18.1,18.1,19.1,22.1,15.2,16.2,17.2,18.2,19.2,20.2,21.2,22.2,23.2,24.2,25.2,26.2,26.1,22.1,29.2,30.2,31.2,32.2,33.2,34.2,35.2,36.2,37.2,38.2,39.2,40.2,26.1,22.1,43.2,44.2,45.2,46.2,47.2,48.2,49.2,50.2,51.2,52.2,53.2,54.2,26.1,22.1,57.2,58.2,59.2,60.2,61.2,62.2,63.2,64.2,65.2,66.2,67.2,68.2,26.1,29.1,71.2,72.2,73.2,74.2,75.2,76.2,77.2,78.2,79.2,80.2,81.2,82.2,7.3,29.1,85.2,86.2,87.2,88.2,89.2,90.2,91.2,92.2,93.2,94.2,95.2,96.2,13.3,29.1,99.2,100.2,101.2,102.2,103.2,104.2,105.2,106.2,107.2,108.2,109.2,110.2,19.3,29.1,113.2,114.2,115.2,116.2,117.2,118.2,119.2,120.2,121.2,122.2,123.2,124.2,25.3,10.4,37.1,37.1,37.1,37.1,38.1,38.1,38.1,38.1,39.1,39.1,39.1,39.1,31.3]),1e-12))
15451         self.assertTrue(f1.getArray().isEqualWithoutConsideringStr(DataArrayDouble([68.2,26.1,26.1,26.1,26.1,27.1,82.2,7.3,8.3,9.3,10.3,34.1,96.2,13.3,14.3,15.3,16.3,34.1,110.2,19.3,20.3,21.3,22.3,34.1,124.2,25.3,26.3,27.3,28.3,34.1,39.1,31.3,32.3,33.3,34.3,41.1,39.1,37.3,38.3,39.3,40.3,41.1,39.1,43.3,44.3,45.3,46.3,41.1,39.1,49.3,50.3,51.3,52.3,41.1,46.1,47.1,47.1,47.1,47.1,48.1]),1e-12))
15452         self.assertTrue(f2.getArray().isEqualWithoutConsideringStr(DataArrayDouble([28.1,29.1,29.1,29.1,29.1,113.2,35.1,7.4,8.4,9.4,10.4,37.1,35.1,13.4,14.4,15.4,16.4,37.1,35.1,19.4,20.4,21.4,22.4,37.1,35.1,25.4,26.4,27.4,28.4,37.1,42.1,31.4,32.4,33.4,34.4,44.1,42.1,37.4,38.4,39.4,40.4,44.1,42.1,43.4,44.4,45.4,46.4,44.1,42.1,49.4,50.4,51.4,52.4,44.1,49.1,50.1,50.1,50.1,50.1,51.1]),1e-12))
15453         self.assertTrue(f00.getArray().isEqualWithoutConsideringStr(DataArrayDouble([80.2,81.2,81.2,82.2,82.2,9.6,94.2,7.5,8.5,9.5,10.5,13.6,94.2,13.5,14.5,15.5,16.5,17.6,108.2,19.5,20.5,21.5,22.5,21.6,108.2,25.5,26.5,27.5,28.5,25.6,122.2,31.5,32.5,33.5,34.5,29.6,122.2,37.5,38.5,39.5,40.5,33.6,39.1,39.1,39.1,39.1,39.1,37.6]),1e-12))
15454         self.assertTrue(f10.getArray().isEqualWithoutConsideringStr(DataArrayDouble([68.2,26.1,26.1,26.1,82.2,5.6,6.6,8.3,82.2,9.6,10.6,8.3,10.5,13.6,14.6,14.3,16.5,17.6,18.6,14.3,22.5,21.6,22.6,20.3,28.5,25.6,26.6,20.3,34.5,29.6,30.6,26.3,40.5,33.6,34.6,26.3,39.1,37.6,38.6,32.3,39.1,41.6,42.6,32.3,39.1,37.3,37.3,38.3]),1e-12))
15455         self.assertTrue(f20.getArray().isEqualWithoutConsideringStr(DataArrayDouble([29.1,29.1,29.1,113.2,9.4,5.7,6.7,37.1,9.4,9.7,10.7,37.1,15.4,13.7,14.7,37.1,15.4,17.7,18.7,37.1,21.4,21.7,22.7,37.1,21.4,25.7,26.7,37.1,27.4,28.4,28.4,37.1]),1e-12))
15456         pass
15457
15458     def testSwig2AMR9(self):
15459         """ Equivalent to testSwig2AMR8 except that here the ghost level is 2 !"""
15460         ghostSz=2
15461         amr=MEDCouplingCartesianAMRMesh("",2,[6,7],[0,0],[1,1])
15462         amr.addPatch([(1,4),(2,4)],[4,4])
15463         amr.addPatch([(4,5),(3,5)],[4,4])
15464         amr.addPatch([(0,1),(4,6)],[4,4])
15465         amr[0].addPatch([(10,12),(5,8)],[2,2])
15466         amr[1].addPatch([(0,1),(0,5)],[2,2])
15467         amr[2].addPatch([(3,4),(0,3)],[2,2])
15468         self.assertEqual(3,amr.getMaxNumberOfLevelsRelativeToThis())
15469         att=MEDCouplingAMRAttribute(amr,[("Field",["X"])],ghostSz)
15470         att.alloc()
15471         d=att.getFieldOn(amr,"Field")
15472         self.assertEqual(90,d.getNumberOfTuples())
15473         self.assertEqual(1,d.getNumberOfComponents())
15474         d.iota() ; d+=0.1
15475         d0=att.getFieldOn(amr[0].getMesh(),"Field")
15476         self.assertEqual(192,d0.getNumberOfTuples())
15477         self.assertEqual(1,d0.getNumberOfComponents())
15478         d0.iota() ; d0+=0.2
15479         d1=att.getFieldOn(amr[1].getMesh(),"Field")
15480         self.assertEqual(96,d1.getNumberOfTuples())
15481         self.assertEqual(1,d1.getNumberOfComponents())
15482         d1.iota() ; d1+=0.3
15483         d2=att.getFieldOn(amr[2].getMesh(),"Field")
15484         self.assertEqual(96,d2.getNumberOfTuples())
15485         self.assertEqual(1,d2.getNumberOfComponents())
15486         d2.iota() ; d2+=0.4
15487         d00=att.getFieldOn(amr[0][0].getMesh(),"Field")
15488         self.assertEqual(80,d00.getNumberOfTuples())
15489         self.assertEqual(1,d00.getNumberOfComponents())
15490         d00.iota() ; d00+=0.5
15491         d10=att.getFieldOn(amr[1][0].getMesh(),"Field")
15492         self.assertEqual(84,d10.getNumberOfTuples())
15493         self.assertEqual(1,d10.getNumberOfComponents())
15494         d10.iota() ; d10+=0.6
15495         d20=att.getFieldOn(amr[2][0].getMesh(),"Field")
15496         self.assertEqual(60,d20.getNumberOfTuples())
15497         self.assertEqual(1,d20.getNumberOfComponents())
15498         d20.iota() ; d20+=0.7
15499         # the test is here ! To be called after iteration with no remesh
15500         att.synchronizeAllGhostZones()
15501         f=att.buildCellFieldOnWithGhost(amr,"Field")
15502         f0=att.buildCellFieldOnWithGhost(amr[0].getMesh(),"Field")
15503         f1=att.buildCellFieldOnWithGhost(amr[1].getMesh(),"Field")
15504         f2=att.buildCellFieldOnWithGhost(amr[2].getMesh(),"Field")
15505         f00=att.buildCellFieldOnWithGhost(amr[0][0].getMesh(),"Field")
15506         f10=att.buildCellFieldOnWithGhost(amr[1][0].getMesh(),"Field")
15507         f20=att.buildCellFieldOnWithGhost(amr[2][0].getMesh(),"Field")
15508         self.assertTrue(f0.getArray().isEqualWithoutConsideringStr(DataArrayDouble([29.1,29.1,30.1,30.1,30.1,30.1,31.1,31.1,31.1,31.1,32.1,32.1,32.1,32.1,33.1,33.1,29.1,29.1,30.1,30.1,30.1,30.1,31.1,31.1,31.1,31.1,32.1,32.1,32.1,32.1,33.1,33.1,38.1,38.1,34.2,35.2,36.2,37.2,38.2,39.2,40.2,41.2,42.2,43.2,44.2,45.2,42.1,42.1,38.1,38.1,50.2,51.2,52.2,53.2,54.2,55.2,56.2,57.2,58.2,59.2,60.2,61.2,42.1,42.1,38.1,38.1,66.2,67.2,68.2,69.2,70.2,71.2,72.2,73.2,74.2,75.2,76.2,77.2,42.1,42.1,38.1,38.1,82.2,83.2,84.2,85.2,86.2,87.2,88.2,89.2,90.2,91.2,92.2,93.2,42.1,42.1,47.1,47.1,98.2,99.2,100.2,101.2,102.2,103.2,104.2,105.2,106.2,107.2,108.2,109.2,18.3,19.3,47.1,47.1,114.2,115.2,116.2,117.2,118.2,119.2,120.2,121.2,122.2,123.2,124.2,125.2,26.3,27.3,47.1,47.1,130.2,131.2,132.2,133.2,134.2,135.2,136.2,137.2,138.2,139.2,140.2,141.2,34.3,35.3,47.1,47.1,146.2,147.2,148.2,149.2,150.2,151.2,152.2,153.2,154.2,155.2,156.2,157.2,42.3,43.3,20.4,21.4,57.1,57.1,57.1,57.1,58.1,58.1,58.1,58.1,59.1,59.1,59.1,59.1,50.3,51.3,28.4,29.4,57.1,57.1,57.1,57.1,58.1,58.1,58.1,58.1,59.1,59.1,59.1,59.1,58.3,59.3]),1e-12))
15509         self.assertTrue(f1.getArray().isEqualWithoutConsideringStr(DataArrayDouble([76.2,77.2,42.1,42.1,42.1,42.1,43.1,43.1,92.2,93.2,42.1,42.1,42.1,42.1,43.1,43.1,108.2,109.2,18.3,19.3,20.3,21.3,52.1,52.1,124.2,125.2,26.3,27.3,28.3,29.3,52.1,52.1,140.2,141.2,34.3,35.3,36.3,37.3,52.1,52.1,156.2,157.2,42.3,43.3,44.3,45.3,52.1,52.1,59.1,59.1,50.3,51.3,52.3,53.3,61.1,61.1,59.1,59.1,58.3,59.3,60.3,61.3,61.1,61.1,59.1,59.1,66.3,67.3,68.3,69.3,61.1,61.1,59.1,59.1,74.3,75.3,76.3,77.3,61.1,61.1,68.1,68.1,69.1,69.1,69.1,69.1,70.1,70.1,68.1,68.1,69.1,69.1,69.1,69.1,70.1,70.1]),1e-12))
15510         self.assertTrue(f2.getArray().isEqualWithoutConsideringStr(DataArrayDouble([46.1,46.1,47.1,47.1,47.1,47.1,130.2,131.2,46.1,46.1,47.1,47.1,47.1,47.1,146.2,147.2,55.1,55.1,18.4,19.4,20.4,21.4,57.1,57.1,55.1,55.1,26.4,27.4,28.4,29.4,57.1,57.1,55.1,55.1,34.4,35.4,36.4,37.4,57.1,57.1,55.1,55.1,42.4,43.4,44.4,45.4,57.1,57.1,64.1,64.1,50.4,51.4,52.4,53.4,66.1,66.1,64.1,64.1,58.4,59.4,60.4,61.4,66.1,66.1,64.1,64.1,66.4,67.4,68.4,69.4,66.1,66.1,64.1,64.1,74.4,75.4,76.4,77.4,66.1,66.1,73.1,73.1,74.1,74.1,74.1,74.1,75.1,75.1,73.1,73.1,74.1,74.1,74.1,74.1,75.1,75.1]),1e-12))
15511         self.assertTrue(f00.getArray().isEqualWithoutConsideringStr(DataArrayDouble([107.2,107.2,108.2,108.2,109.2,109.2,14.6,15.6,107.2,107.2,108.2,108.2,109.2,109.2,20.6,21.6,123.2,123.2,18.5,19.5,20.5,21.5,26.6,27.6,123.2,123.2,26.5,27.5,28.5,29.5,32.6,33.6,139.2,139.2,34.5,35.5,36.5,37.5,38.6,39.6,139.2,139.2,42.5,43.5,44.5,45.5,44.6,45.6,155.2,155.2,50.5,51.5,52.5,53.5,50.6,51.6,155.2,155.2,58.5,59.5,60.5,61.5,56.6,57.6,59.1,59.1,59.1,59.1,59.1,59.1,62.6,63.6,59.1,59.1,59.1,59.1,59.1,59.1,68.6,69.6]),1e-12))
15512         self.assertTrue(f10.getArray().isEqualWithoutConsideringStr(DataArrayDouble([93.2,93.2,42.1,42.1,42.1,42.1,93.2,93.2,42.1,42.1,42.1,42.1,109.2,109.2,14.6,15.6,19.3,19.3,109.2,109.2,20.6,21.6,19.3,19.3,20.5,21.5,26.6,27.6,27.3,27.3,28.5,29.5,32.6,33.6,27.3,27.3,36.5,37.5,38.6,39.6,35.3,35.3,44.5,45.5,44.6,45.6,35.3,35.3,52.5,53.5,50.6,51.6,43.3,43.3,60.5,61.5,56.6,57.6,43.3,43.3,59.1,59.1,62.6,63.6,51.3,51.3,59.1,59.1,68.6,69.6,51.3,51.3,59.1,59.1,58.3,58.3,59.3,59.3,59.1,59.1,58.3,58.3,59.3,59.3]),1e-12))
15513         self.assertTrue(f20.getArray().isEqualWithoutConsideringStr(DataArrayDouble([47.1,47.1,47.1,47.1,146.2,146.2,47.1,47.1,47.1,47.1,146.2,146.2,20.4,20.4,14.7,15.7,57.1,57.1,20.4,20.4,20.7,21.7,57.1,57.1,28.4,28.4,26.7,27.7,57.1,57.1,28.4,28.4,32.7,33.7,57.1,57.1,36.4,36.4,38.7,39.7,57.1,57.1,36.4,36.4,44.7,45.7,57.1,57.1,44.4,44.4,45.4,45.4,57.1,57.1,44.4,44.4,45.4,45.4,57.1,57.1]),1e-12))
15514         self.assertTrue(MEDCouplingStructuredMesh.ComputeCornersGhost([3],1).isEqual(DataArrayInt([0,4])))
15515         self.assertTrue(MEDCouplingStructuredMesh.ComputeCornersGhost([3],2).isEqual(DataArrayInt([0,1,5,6])))
15516         self.assertTrue(MEDCouplingStructuredMesh.ComputeCornersGhost([5,6],1).isEqual(DataArrayInt([0,6,49,55])))
15517         self.assertTrue(MEDCouplingStructuredMesh.ComputeCornersGhost([5,6],2).isEqual(DataArrayInt([0,8,10,16,73,79,81,89])))
15518         self.assertTrue(MEDCouplingStructuredMesh.ComputeCornersGhost([5,6,3],1).isEqual(DataArrayInt([0,6,49,55,224,230,273,279])))
15519         self.assertTrue(MEDCouplingStructuredMesh.ComputeCornersGhost([5,6,3],2).isEqual(DataArrayInt([0,8,81,89,100,106,163,169,460,466,523,529,540,548,621,629])))
15520         pass
15521
15522     def testSwig2AMR10(self):
15523         """ This test, focuses on basic operations of coarse to fine and fine to coarse and ghost zone update with a ghost size set to 2 and dimension equal to 2."""
15524         szGhost=2
15525         amr=MEDCouplingCartesianAMRMesh("",2,[11,11],[0,0],[0.1,0.1])
15526         amr.addPatch([(3,8),(0,3)],[2,2])
15527         amr[0].addPatch([(0,10),(3,6)],[3,3])
15528         amr[0].addPatch([(2,6),(0,3)],[3,3])
15529         amr[0].addPatch([(6,10),(2,3)],[3,3])
15530         amr.addPatch([(3,8),(3,6)],[2,2])
15531         amr[1].addPatch([(0,4),(0,6)],[3,3])
15532         amr[1].addPatch([(7,10),(0,4)],[3,3])
15533         amr[1].addPatch([(4,7),(0,3)],[3,3])
15534         amr[1].addPatch([(4,7),(3,6)],[3,3])
15535         amr.addPatch([(0,3),(6,10)],[2,2])
15536         self.assertEqual(([(30,39),(27,36)],[6,6]),amr[1][3].getMesh().positionRelativeToGodFather())
15537         self.assertEqual(([(6,16),(6,12)],[2,2]),amr[1].getMesh().positionRelativeToGodFather())
15538         self.assertTrue(not MEDCouplingStructuredMesh.AreRangesIntersect([(30,39),(27,36)],[(6,16),(6,12)]))
15539         self.assertTrue(MEDCouplingStructuredMesh.AreRangesIntersect([(30,39),(27,36)],[(28,32),(35,37)]))
15540         da=DataArrayDouble([0.,1.,2.,3.,4.,5.,6.,7.,8.,9.,10.,11.])
15541         MEDCouplingStructuredMesh.AssignPartOfFieldOfDoubleUsing([3,4],da,[(1,3),(2,3)],DataArrayDouble([7.7,8.8]))
15542         self.assertTrue(da.isEqual(DataArrayDouble([0.,1.,2.,3.,4.,5.,6.,7.7,8.8,9.,10.,11.]),1e-12))
15543         att=MEDCouplingAMRAttribute(amr,[("YY",1)],szGhost)
15544         att.spillNatures([ConservativeVolumic])
15545         att.alloc()
15546         yy=att.getFieldOn(amr,"YY") ; yy.iota(0.01)
15547         yy=att.getFieldOn(amr[0].getMesh(),"YY") ; yy.iota(0.02)
15548         yy=att.getFieldOn(amr[1].getMesh(),"YY") ; yy.iota(0.03)
15549         yy=att.getFieldOn(amr[0][0].getMesh(),"YY") ; yy.iota(0.04)
15550         yy=att.getFieldOn(amr[0][1].getMesh(),"YY") ; yy.iota(0.05)
15551         yy=att.getFieldOn(amr[0][2].getMesh(),"YY") ; yy.iota(0.06)
15552         yy=att.getFieldOn(amr[1][0].getMesh(),"YY") ; yy.iota(0.07)
15553         yy=att.getFieldOn(amr[1][1].getMesh(),"YY") ; yy.iota(0.08)
15554         yy=att.getFieldOn(amr[1][2].getMesh(),"YY") ; yy.iota(0.09)
15555         yy=att.getFieldOn(amr[1][3].getMesh(),"YY") ; yy.iota(0.10)
15556         yy=att.getFieldOn(amr[2].getMesh(),"YY") ; yy.iota(0.11)
15557         att2=att.deepCpy() ; att3=att2.deepCpy() ; att4=att3.deepCpy() ; att5=att4.deepCpy() ; att6=att5.deepCpy()
15558         ###
15559         att.synchronizeFineToCoarseBetween(2,1)
15560         ###
15561         for pos in [(),(0,0),(0,1),(0,2),(1,0),(1,1),(1,2),(1,3)]:
15562             self.assertTrue(att.getFieldOn(att.getMyGodFather().getMeshAtPosition(pos),"YY").isEqual(att2.getFieldOn(att2.getMyGodFather().getMeshAtPosition(pos),"YY"),1e-12))
15563             pass
15564         for pos in [(0,),(1,)]:
15565             self.assertTrue(not att.getFieldOn(att.getMyGodFather().getMeshAtPosition(pos),"YY").isEqual(att2.getFieldOn(att2.getMyGodFather().getMeshAtPosition(pos),"YY"),1e-12))
15566             pass
15567         self.assertTrue(att.getFieldOn(amr[0].getMesh(),"YY").isEqualWithoutConsideringStr(DataArrayDouble([0.02,1.02,2.02,3.02,4.02,5.02,6.02,7.02,8.02,9.02,10.02,11.02,12.02,13.02,14.02,15.02,16.02,17.02,18.02,19.02,20.02,21.02,22.02,23.02,24.02,25.02,26.02,27.02,28.02,29.02,30.02,31.02,51.05,54.05,57.05,60.05,36.02,37.02,38.02,39.02,40.02,41.02,42.02,43.02,44.02,45.02,99.05,102.05,105.05,108.05,50.02,51.02,52.02,53.02,54.02,55.02,56.02,57.02,58.02,59.02,147.05,150.05,153.05,156.05,51.06,54.06,57.06,60.06,68.02,69.02,70.02,71.02,105.04,108.04,111.04,114.04,117.04,120.04,123.04,126.04,129.04,132.04,82.02,83.02,84.02,85.02,207.04,210.04,213.04,216.04,219.04,222.04,225.04,228.04,231.04,234.04,96.02,97.02,98.02,99.02,309.04,312.04,315.04,318.04,321.04,324.04,327.04,330.04,333.04,336.04,110.02,111.02,112.02,113.02,114.02,115.02,116.02,117.02,118.02,119.02,120.02,121.02,122.02,123.02,124.02,125.02,126.02,127.02,128.02,129.02,130.02,131.02,132.02,133.02,134.02,135.02,136.02,137.02,138.02,139.02]),1e-12))
15568         self.assertTrue(att.getFieldOn(amr[1].getMesh(),"YY").isEqualWithoutConsideringStr(DataArrayDouble([0.03,1.03,2.03,3.03,4.03,5.03,6.03,7.03,8.03,9.03,10.03,11.03,12.03,13.03,14.03,15.03,16.03,17.03,18.03,19.03,20.03,21.03,22.03,23.03,24.03,25.03,26.03,27.03,28.03,29.03,51.07,54.07,57.07,60.07,42.09,45.09,48.09,42.08,45.08,48.08,40.03,41.03,42.03,43.03,99.07,102.07,105.07,108.07,81.09,84.09,87.09,81.08,84.08,87.08,54.03,55.03,56.03,57.03,147.07,150.07,153.07,156.07,120.09,123.09,126.09,120.08,123.08,126.08,68.03,69.03,70.03,71.03,195.07,198.07,201.07,204.07,42.1,45.1,48.1,159.08,162.08,165.08,82.03,83.03,84.03,85.03,243.07,246.07,249.07,252.07,81.1,84.1,87.1,93.03,94.03,95.03,96.03,97.03,98.03,99.03,291.07,294.07,297.07,300.07,120.1,123.1,126.1,107.03,108.03,109.03,110.03,111.03,112.03,113.03,114.03,115.03,116.03,117.03,118.03,119.03,120.03,121.03,122.03,123.03,124.03,125.03,126.03,127.03,128.03,129.03,130.03,131.03,132.03,133.03,134.03,135.03,136.03,137.03,138.03,139.03]),1e-12))
15569         del att
15570         ####
15571         att2.synchronizeAllGhostZonesOfDirectChidrenOf(att2.getMyGodFather())
15572         ### Only the 3 (0) (1) and (2) are modified (0,0), (0,1), (0,2), (1,0), (1,1), (1,2), (1,3) are not modified.
15573         exp2=DataArrayDouble([0.11,1.11,2.11,3.11,4.11,5.11,6.11,7.11,86.03,87.03,10.11,11.11,12.11,13.11,14.11,15.11,16.11,17.11,100.03,101.03,20.11,21.11,22.11,23.11,24.11,25.11,26.11,27.11,28.11,29.11,30.11,31.11,32.11,33.11,34.11,35.11,36.11,37.11,38.11,39.11,40.11,41.11,42.11,43.11,44.11,45.11,46.11,47.11,48.11,49.11,50.11,51.11,52.11,53.11,54.11,55.11,56.11,57.11,58.11,59.11,60.11,61.11,62.11,63.11,64.11,65.11,66.11,67.11,68.11,69.11,70.11,71.11,72.11,73.11,74.11,75.11,76.11,77.11,78.11,79.11,80.11,81.11,82.11,83.11,84.11,85.11,86.11,87.11,88.11,89.11,90.11,91.11,92.11,93.11,94.11,95.11,96.11,97.11,98.11,99.11,100.11,101.11,102.11,103.11,104.11,105.11,106.11,107.11,108.11,109.11,110.11,111.11,112.11,113.11,114.11,115.11,116.11,117.11,118.11,119.11])
15574         self.assertTrue(att2.getFieldOn(att2.getMyGodFather().getMeshAtPosition((2,)),"YY").isEqualWithoutConsideringStr(exp2,1e-12))
15575         exp3=DataArrayDouble([0.03,1.03,86.02,87.02,88.02,89.02,90.02,91.02,92.02,93.02,94.02,95.02,12.03,13.03,14.03,15.03,100.02,101.02,102.02,103.02,104.02,105.02,106.02,107.02,108.02,109.02,26.03,27.03,28.03,29.03,30.03,31.03,32.03,33.03,34.03,35.03,36.03,37.03,38.03,39.03,40.03,41.03,42.03,43.03,44.03,45.03,46.03,47.03,48.03,49.03,50.03,51.03,52.03,53.03,54.03,55.03,56.03,57.03,58.03,59.03,60.03,61.03,62.03,63.03,64.03,65.03,66.03,67.03,68.03,69.03,70.03,71.03,72.03,73.03,74.03,75.03,76.03,77.03,78.03,79.03,80.03,81.03,82.03,83.03,84.03,85.03,86.03,87.03,88.03,89.03,90.03,91.03,92.03,93.03,94.03,95.03,96.03,97.03,98.03,99.03,100.03,101.03,102.03,103.03,104.03,105.03,106.03,107.03,108.03,109.03,110.03,111.03,26.11,27.11,114.03,115.03,116.03,117.03,118.03,119.03,120.03,121.03,122.03,123.03,124.03,125.03,36.11,37.11,128.03,129.03,130.03,131.03,132.03,133.03,134.03,135.03,136.03,137.03,138.03,139.03])
15576         self.assertTrue(att2.getFieldOn(att2.getMyGodFather().getMeshAtPosition((1,)),"YY").isEqualWithoutConsideringStr(exp3,1e-12))
15577         exp4=DataArrayDouble([0.02,1.02,2.02,3.02,4.02,5.02,6.02,7.02,8.02,9.02,10.02,11.02,12.02,13.02,14.02,15.02,16.02,17.02,18.02,19.02,20.02,21.02,22.02,23.02,24.02,25.02,26.02,27.02,28.02,29.02,30.02,31.02,32.02,33.02,34.02,35.02,36.02,37.02,38.02,39.02,40.02,41.02,42.02,43.02,44.02,45.02,46.02,47.02,48.02,49.02,50.02,51.02,52.02,53.02,54.02,55.02,56.02,57.02,58.02,59.02,60.02,61.02,62.02,63.02,64.02,65.02,66.02,67.02,68.02,69.02,70.02,71.02,72.02,73.02,74.02,75.02,76.02,77.02,78.02,79.02,80.02,81.02,82.02,83.02,84.02,85.02,86.02,87.02,88.02,89.02,90.02,91.02,92.02,93.02,94.02,95.02,96.02,97.02,98.02,99.02,100.02,101.02,102.02,103.02,104.02,105.02,106.02,107.02,108.02,109.02,110.02,111.02,112.02,113.02,30.03,31.03,32.03,33.03,34.03,35.03,36.03,37.03,38.03,39.03,124.02,125.02,126.02,127.02,44.03,45.03,46.03,47.03,48.03,49.03,50.03,51.03,52.03,53.03,138.02,139.02])
15578         self.assertTrue(att2.getFieldOn(att2.getMyGodFather().getMeshAtPosition((0,)),"YY").isEqualWithoutConsideringStr(exp4,1e-12))
15579         for pos,iot in [((),0.01),((0,0),0.04),((0,1),0.05),((0,2),0.06),((1,0),0.07),((1,1),0.08),((1,2),0.09),((1,3),0.10)]:
15580             vals=att2.getFieldOn(att2.getMyGodFather().getMeshAtPosition(pos),"YY")
15581             l=vals.getNumberOfTuples()
15582             exps=DataArrayDouble(l) ; exps.iota(iot)
15583             self.assertTrue(vals.isEqualWithoutConsideringStr(exps,1e-12))
15584             pass
15585         del att2
15586         ###
15587         att3.synchronizeCoarseToFineBetween(1,2)
15588         ###
15589         for pos in [(),(0,),(1,),(2,)]:
15590             self.assertTrue(att3.getFieldOn(att3.getMyGodFather().getMeshAtPosition(pos),"YY").isEqual(att4.getFieldOn(att4.getMyGodFather().getMeshAtPosition(pos),"YY"),1e-12))
15591             pass
15592         exp5=DataArrayDouble([57.02,57.02,58.02,58.02,58.02,59.02,59.02,59.02,60.02,60.02,60.02,61.02,61.02,61.02,62.02,62.02,62.02,63.02,63.02,63.02,64.02,64.02,64.02,65.02,65.02,65.02,66.02,66.02,66.02,67.02,67.02,67.02,68.02,68.02,57.02,57.02,58.02,58.02,58.02,59.02,59.02,59.02,60.02,60.02,60.02,61.02,61.02,61.02,62.02,62.02,62.02,63.02,63.02,63.02,64.02,64.02,64.02,65.02,65.02,65.02,66.02,66.02,66.02,67.02,67.02,67.02,68.02,68.02,71.02,71.02,72.02,72.02,72.02,73.02,73.02,73.02,74.02,74.02,74.02,75.02,75.02,75.02,76.02,76.02,76.02,77.02,77.02,77.02,78.02,78.02,78.02,79.02,79.02,79.02,80.02,80.02,80.02,81.02,81.02,81.02,82.02,82.02,71.02,71.02,72.02,72.02,72.02,73.02,73.02,73.02,74.02,74.02,74.02,75.02,75.02,75.02,76.02,76.02,76.02,77.02,77.02,77.02,78.02,78.02,78.02,79.02,79.02,79.02,80.02,80.02,80.02,81.02,81.02,81.02,82.02,82.02,71.02,71.02,72.02,72.02,72.02,73.02,73.02,73.02,74.02,74.02,74.02,75.02,75.02,75.02,76.02,76.02,76.02,77.02,77.02,77.02,78.02,78.02,78.02,79.02,79.02,79.02,80.02,80.02,80.02,81.02,81.02,81.02,82.02,82.02,85.02,85.02,86.02,86.02,86.02,87.02,87.02,87.02,88.02,88.02,88.02,89.02,89.02,89.02,90.02,90.02,90.02,91.02,91.02,91.02,92.02,92.02,92.02,93.02,93.02,93.02,94.02,94.02,94.02,95.02,95.02,95.02,96.02,96.02,85.02,85.02,86.02,86.02,86.02,87.02,87.02,87.02,88.02,88.02,88.02,89.02,89.02,89.02,90.02,90.02,90.02,91.02,91.02,91.02,92.02,92.02,92.02,93.02,93.02,93.02,94.02,94.02,94.02,95.02,95.02,95.02,96.02,96.02,85.02,85.02,86.02,86.02,86.02,87.02,87.02,87.02,88.02,88.02,88.02,89.02,89.02,89.02,90.02,90.02,90.02,91.02,91.02,91.02,92.02,92.02,92.02,93.02,93.02,93.02,94.02,94.02,94.02,95.02,95.02,95.02,96.02,96.02,99.02,99.02,100.02,100.02,100.02,101.02,101.02,101.02,102.02,102.02,102.02,103.02,103.02,103.02,104.02,104.02,104.02,105.02,105.02,105.02,106.02,106.02,106.02,107.02,107.02,107.02,108.02,108.02,108.02,109.02,109.02,109.02,110.02,110.02,99.02,99.02,100.02,100.02,100.02,101.02,101.02,101.02,102.02,102.02,102.02,103.02,103.02,103.02,104.02,104.02,104.02,105.02,105.02,105.02,106.02,106.02,106.02,107.02,107.02,107.02,108.02,108.02,108.02,109.02,109.02,109.02,110.02,110.02,99.02,99.02,100.02,100.02,100.02,101.02,101.02,101.02,102.02,102.02,102.02,103.02,103.02,103.02,104.02,104.02,104.02,105.02,105.02,105.02,106.02,106.02,106.02,107.02,107.02,107.02,108.02,108.02,108.02,109.02,109.02,109.02,110.02,110.02,113.02,113.02,114.02,114.02,114.02,115.02,115.02,115.02,116.02,116.02,116.02,117.02,117.02,117.02,118.02,118.02,118.02,119.02,119.02,119.02,120.02,120.02,120.02,121.02,121.02,121.02,122.02,122.02,122.02,123.02,123.02,123.02,124.02,124.02,113.02,113.02,114.02,114.02,114.02,115.02,115.02,115.02,116.02,116.02,116.02,117.02,117.02,117.02,118.02,118.02,118.02,119.02,119.02,119.02,120.02,120.02,120.02,121.02,121.02,121.02,122.02,122.02,122.02,123.02,123.02,123.02,124.02,124.02])
15593         self.assertTrue(att3.getFieldOn(att3.getMyGodFather().getMeshAtPosition((0,0)),"YY").isEqualWithoutConsideringStr(exp5,1e-12))
15594         exp6=DataArrayDouble([17.02,17.02,18.02,18.02,18.02,19.02,19.02,19.02,20.02,20.02,20.02,21.02,21.02,21.02,22.02,22.02,17.02,17.02,18.02,18.02,18.02,19.02,19.02,19.02,20.02,20.02,20.02,21.02,21.02,21.02,22.02,22.02,31.02,31.02,32.02,32.02,32.02,33.02,33.02,33.02,34.02,34.02,34.02,35.02,35.02,35.02,36.02,36.02,31.02,31.02,32.02,32.02,32.02,33.02,33.02,33.02,34.02,34.02,34.02,35.02,35.02,35.02,36.02,36.02,31.02,31.02,32.02,32.02,32.02,33.02,33.02,33.02,34.02,34.02,34.02,35.02,35.02,35.02,36.02,36.02,45.02,45.02,46.02,46.02,46.02,47.02,47.02,47.02,48.02,48.02,48.02,49.02,49.02,49.02,50.02,50.02,45.02,45.02,46.02,46.02,46.02,47.02,47.02,47.02,48.02,48.02,48.02,49.02,49.02,49.02,50.02,50.02,45.02,45.02,46.02,46.02,46.02,47.02,47.02,47.02,48.02,48.02,48.02,49.02,49.02,49.02,50.02,50.02,59.02,59.02,60.02,60.02,60.02,61.02,61.02,61.02,62.02,62.02,62.02,63.02,63.02,63.02,64.02,64.02,59.02,59.02,60.02,60.02,60.02,61.02,61.02,61.02,62.02,62.02,62.02,63.02,63.02,63.02,64.02,64.02,59.02,59.02,60.02,60.02,60.02,61.02,61.02,61.02,62.02,62.02,62.02,63.02,63.02,63.02,64.02,64.02,73.02,73.02,74.02,74.02,74.02,75.02,75.02,75.02,76.02,76.02,76.02,77.02,77.02,77.02,78.02,78.02,73.02,73.02,74.02,74.02,74.02,75.02,75.02,75.02,76.02,76.02,76.02,77.02,77.02,77.02,78.02,78.02])
15595         self.assertTrue(att3.getFieldOn(att3.getMyGodFather().getMeshAtPosition((0,1)),"YY").isEqualWithoutConsideringStr(exp6,1e-12))
15596         exp7=DataArrayDouble([49.02,49.02,50.02,50.02,50.02,51.02,51.02,51.02,52.02,52.02,52.02,53.02,53.02,53.02,54.02,54.02,49.02,49.02,50.02,50.02,50.02,51.02,51.02,51.02,52.02,52.02,52.02,53.02,53.02,53.02,54.02,54.02,63.02,63.02,64.02,64.02,64.02,65.02,65.02,65.02,66.02,66.02,66.02,67.02,67.02,67.02,68.02,68.02,63.02,63.02,64.02,64.02,64.02,65.02,65.02,65.02,66.02,66.02,66.02,67.02,67.02,67.02,68.02,68.02,63.02,63.02,64.02,64.02,64.02,65.02,65.02,65.02,66.02,66.02,66.02,67.02,67.02,67.02,68.02,68.02,77.02,77.02,78.02,78.02,78.02,79.02,79.02,79.02,80.02,80.02,80.02,81.02,81.02,81.02,82.02,82.02,77.02,77.02,78.02,78.02,78.02,79.02,79.02,79.02,80.02,80.02,80.02,81.02,81.02,81.02,82.02,82.02])
15597         self.assertTrue(att3.getFieldOn(att3.getMyGodFather().getMeshAtPosition((0,2)),"YY").isEqualWithoutConsideringStr(exp7,1e-12))
15598         exp8=DataArrayDouble([15.03,15.03,16.03,16.03,16.03,17.03,17.03,17.03,18.03,18.03,18.03,19.03,19.03,19.03,20.03,20.03,15.03,15.03,16.03,16.03,16.03,17.03,17.03,17.03,18.03,18.03,18.03,19.03,19.03,19.03,20.03,20.03,29.03,29.03,30.03,30.03,30.03,31.03,31.03,31.03,32.03,32.03,32.03,33.03,33.03,33.03,34.03,34.03,29.03,29.03,30.03,30.03,30.03,31.03,31.03,31.03,32.03,32.03,32.03,33.03,33.03,33.03,34.03,34.03,29.03,29.03,30.03,30.03,30.03,31.03,31.03,31.03,32.03,32.03,32.03,33.03,33.03,33.03,34.03,34.03,43.03,43.03,44.03,44.03,44.03,45.03,45.03,45.03,46.03,46.03,46.03,47.03,47.03,47.03,48.03,48.03,43.03,43.03,44.03,44.03,44.03,45.03,45.03,45.03,46.03,46.03,46.03,47.03,47.03,47.03,48.03,48.03,43.03,43.03,44.03,44.03,44.03,45.03,45.03,45.03,46.03,46.03,46.03,47.03,47.03,47.03,48.03,48.03,57.03,57.03,58.03,58.03,58.03,59.03,59.03,59.03,60.03,60.03,60.03,61.03,61.03,61.03,62.03,62.03,57.03,57.03,58.03,58.03,58.03,59.03,59.03,59.03,60.03,60.03,60.03,61.03,61.03,61.03,62.03,62.03,57.03,57.03,58.03,58.03,58.03,59.03,59.03,59.03,60.03,60.03,60.03,61.03,61.03,61.03,62.03,62.03,71.03,71.03,72.03,72.03,72.03,73.03,73.03,73.03,74.03,74.03,74.03,75.03,75.03,75.03,76.03,76.03,71.03,71.03,72.03,72.03,72.03,73.03,73.03,73.03,74.03,74.03,74.03,75.03,75.03,75.03,76.03,76.03,71.03,71.03,72.03,72.03,72.03,73.03,73.03,73.03,74.03,74.03,74.03,75.03,75.03,75.03,76.03,76.03,85.03,85.03,86.03,86.03,86.03,87.03,87.03,87.03,88.03,88.03,88.03,89.03,89.03,89.03,90.03,90.03,85.03,85.03,86.03,86.03,86.03,87.03,87.03,87.03,88.03,88.03,88.03,89.03,89.03,89.03,90.03,90.03,85.03,85.03,86.03,86.03,86.03,87.03,87.03,87.03,88.03,88.03,88.03,89.03,89.03,89.03,90.03,90.03,99.03,99.03,100.03,100.03,100.03,101.03,101.03,101.03,102.03,102.03,102.03,103.03,103.03,103.03,104.03,104.03,99.03,99.03,100.03,100.03,100.03,101.03,101.03,101.03,102.03,102.03,102.03,103.03,103.03,103.03,104.03,104.03,99.03,99.03,100.03,100.03,100.03,101.03,101.03,101.03,102.03,102.03,102.03,103.03,103.03,103.03,104.03,104.03,113.03,113.03,114.03,114.03,114.03,115.03,115.03,115.03,116.03,116.03,116.03,117.03,117.03,117.03,118.03,118.03,113.03,113.03,114.03,114.03,114.03,115.03,115.03,115.03,116.03,116.03,116.03,117.03,117.03,117.03,118.03,118.03])
15599         self.assertTrue(att3.getFieldOn(att3.getMyGodFather().getMeshAtPosition((1,0)),"YY").isEqualWithoutConsideringStr(exp8,1e-12))
15600         exp9=DataArrayDouble([22.03,22.03,23.03,23.03,23.03,24.03,24.03,24.03,25.03,25.03,25.03,26.03,26.03,22.03,22.03,23.03,23.03,23.03,24.03,24.03,24.03,25.03,25.03,25.03,26.03,26.03,36.03,36.03,37.03,37.03,37.03,38.03,38.03,38.03,39.03,39.03,39.03,40.03,40.03,36.03,36.03,37.03,37.03,37.03,38.03,38.03,38.03,39.03,39.03,39.03,40.03,40.03,36.03,36.03,37.03,37.03,37.03,38.03,38.03,38.03,39.03,39.03,39.03,40.03,40.03,50.03,50.03,51.03,51.03,51.03,52.03,52.03,52.03,53.03,53.03,53.03,54.03,54.03,50.03,50.03,51.03,51.03,51.03,52.03,52.03,52.03,53.03,53.03,53.03,54.03,54.03,50.03,50.03,51.03,51.03,51.03,52.03,52.03,52.03,53.03,53.03,53.03,54.03,54.03,64.03,64.03,65.03,65.03,65.03,66.03,66.03,66.03,67.03,67.03,67.03,68.03,68.03,64.03,64.03,65.03,65.03,65.03,66.03,66.03,66.03,67.03,67.03,67.03,68.03,68.03,64.03,64.03,65.03,65.03,65.03,66.03,66.03,66.03,67.03,67.03,67.03,68.03,68.03,78.03,78.03,79.03,79.03,79.03,80.03,80.03,80.03,81.03,81.03,81.03,82.03,82.03,78.03,78.03,79.03,79.03,79.03,80.03,80.03,80.03,81.03,81.03,81.03,82.03,82.03,78.03,78.03,79.03,79.03,79.03,80.03,80.03,80.03,81.03,81.03,81.03,82.03,82.03,92.03,92.03,93.03,93.03,93.03,94.03,94.03,94.03,95.03,95.03,95.03,96.03,96.03,92.03,92.03,93.03,93.03,93.03,94.03,94.03,94.03,95.03,95.03,95.03,96.03,96.03])
15601         self.assertTrue(att3.getFieldOn(att3.getMyGodFather().getMeshAtPosition((1,1)),"YY").isEqualWithoutConsideringStr(exp9,1e-12))
15602         exp10=DataArrayDouble([19.03,19.03,20.03,20.03,20.03,21.03,21.03,21.03,22.03,22.03,22.03,23.03,23.03,19.03,19.03,20.03,20.03,20.03,21.03,21.03,21.03,22.03,22.03,22.03,23.03,23.03,33.03,33.03,34.03,34.03,34.03,35.03,35.03,35.03,36.03,36.03,36.03,37.03,37.03,33.03,33.03,34.03,34.03,34.03,35.03,35.03,35.03,36.03,36.03,36.03,37.03,37.03,33.03,33.03,34.03,34.03,34.03,35.03,35.03,35.03,36.03,36.03,36.03,37.03,37.03,47.03,47.03,48.03,48.03,48.03,49.03,49.03,49.03,50.03,50.03,50.03,51.03,51.03,47.03,47.03,48.03,48.03,48.03,49.03,49.03,49.03,50.03,50.03,50.03,51.03,51.03,47.03,47.03,48.03,48.03,48.03,49.03,49.03,49.03,50.03,50.03,50.03,51.03,51.03,61.03,61.03,62.03,62.03,62.03,63.03,63.03,63.03,64.03,64.03,64.03,65.03,65.03,61.03,61.03,62.03,62.03,62.03,63.03,63.03,63.03,64.03,64.03,64.03,65.03,65.03,61.03,61.03,62.03,62.03,62.03,63.03,63.03,63.03,64.03,64.03,64.03,65.03,65.03,75.03,75.03,76.03,76.03,76.03,77.03,77.03,77.03,78.03,78.03,78.03,79.03,79.03,75.03,75.03,76.03,76.03,76.03,77.03,77.03,77.03,78.03,78.03,78.03,79.03,79.03])
15603         self.assertTrue(att3.getFieldOn(att3.getMyGodFather().getMeshAtPosition((1,2)),"YY").isEqualWithoutConsideringStr(exp10,1e-12))
15604         exp11=DataArrayDouble([61.03,61.03,62.03,62.03,62.03,63.03,63.03,63.03,64.03,64.03,64.03,65.03,65.03,61.03,61.03,62.03,62.03,62.03,63.03,63.03,63.03,64.03,64.03,64.03,65.03,65.03,75.03,75.03,76.03,76.03,76.03,77.03,77.03,77.03,78.03,78.03,78.03,79.03,79.03,75.03,75.03,76.03,76.03,76.03,77.03,77.03,77.03,78.03,78.03,78.03,79.03,79.03,75.03,75.03,76.03,76.03,76.03,77.03,77.03,77.03,78.03,78.03,78.03,79.03,79.03,89.03,89.03,90.03,90.03,90.03,91.03,91.03,91.03,92.03,92.03,92.03,93.03,93.03,89.03,89.03,90.03,90.03,90.03,91.03,91.03,91.03,92.03,92.03,92.03,93.03,93.03,89.03,89.03,90.03,90.03,90.03,91.03,91.03,91.03,92.03,92.03,92.03,93.03,93.03,103.03,103.03,104.03,104.03,104.03,105.03,105.03,105.03,106.03,106.03,106.03,107.03,107.03,103.03,103.03,104.03,104.03,104.03,105.03,105.03,105.03,106.03,106.03,106.03,107.03,107.03,103.03,103.03,104.03,104.03,104.03,105.03,105.03,105.03,106.03,106.03,106.03,107.03,107.03,117.03,117.03,118.03,118.03,118.03,119.03,119.03,119.03,120.03,120.03,120.03,121.03,121.03,117.03,117.03,118.03,118.03,118.03,119.03,119.03,119.03,120.03,120.03,120.03,121.03,121.03])
15605         self.assertTrue(att3.getFieldOn(att3.getMyGodFather().getMeshAtPosition((1,3)),"YY").isEqualWithoutConsideringStr(exp11,1e-12))
15606         del att3
15607         ###
15608         att4.synchronizeAllGhostZonesAtASpecifiedLevel(2)
15609         for pos in [(),(0,),(1,),(2,)]:
15610             self.assertTrue(att4.getFieldOn(att4.getMyGodFather().getMeshAtPosition(pos),"YY").isEqual(att5.getFieldOn(att5.getMyGodFather().getMeshAtPosition(pos),"YY"),1e-12))
15611             pass
15612         exp12=DataArrayDouble([0.04,1.04,2.04,3.04,4.04,5.04,6.04,7.04,146.05,147.05,148.05,149.05,150.05,151.05,152.05,153.05,154.05,155.05,156.05,157.05,50.06,51.06,52.06,53.06,54.06,55.06,56.06,57.06,58.06,59.06,60.06,61.06,32.04,33.04,34.04,35.04,36.04,37.04,38.04,39.04,40.04,41.04,162.05,163.05,164.05,165.05,166.05,167.05,168.05,169.05,170.05,171.05,172.05,173.05,66.06,67.06,68.06,69.06,70.06,71.06,72.06,73.06,74.06,75.06,76.06,77.06,66.04,67.04,68.04,69.04,70.04,71.04,72.04,73.04,74.04,75.04,76.04,77.04,78.04,79.04,80.04,81.04,82.04,83.04,84.04,85.04,86.04,87.04,88.04,89.04,90.04,91.04,92.04,93.04,94.04,95.04,96.04,97.04,98.04,99.04,100.04,101.04,102.04,103.04,104.04,105.04,106.04,107.04,108.04,109.04,110.04,111.04,112.04,113.04,114.04,115.04,116.04,117.04,118.04,119.04,120.04,121.04,122.04,123.04,124.04,125.04,126.04,127.04,128.04,129.04,130.04,131.04,132.04,133.04,134.04,135.04,136.04,137.04,138.04,139.04,140.04,141.04,142.04,143.04,144.04,145.04,146.04,147.04,148.04,149.04,150.04,151.04,152.04,153.04,154.04,155.04,156.04,157.04,158.04,159.04,160.04,161.04,162.04,163.04,164.04,165.04,166.04,167.04,168.04,169.04,170.04,171.04,172.04,173.04,174.04,175.04,176.04,177.04,178.04,179.04,180.04,181.04,182.04,183.04,184.04,185.04,186.04,187.04,188.04,189.04,190.04,191.04,192.04,193.04,194.04,195.04,196.04,197.04,198.04,199.04,200.04,201.04,202.04,203.04,204.04,205.04,206.04,207.04,208.04,209.04,210.04,211.04,212.04,213.04,214.04,215.04,216.04,217.04,218.04,219.04,220.04,221.04,222.04,223.04,224.04,225.04,226.04,227.04,228.04,229.04,230.04,231.04,232.04,233.04,234.04,235.04,236.04,237.04,238.04,239.04,240.04,241.04,242.04,243.04,244.04,245.04,246.04,247.04,248.04,249.04,250.04,251.04,252.04,253.04,254.04,255.04,256.04,257.04,258.04,259.04,260.04,261.04,262.04,263.04,264.04,265.04,266.04,267.04,268.04,269.04,270.04,271.04,272.04,273.04,274.04,275.04,276.04,277.04,278.04,279.04,280.04,281.04,282.04,283.04,284.04,285.04,286.04,287.04,288.04,289.04,290.04,291.04,292.04,293.04,294.04,295.04,296.04,297.04,298.04,299.04,300.04,301.04,302.04,303.04,304.04,305.04,306.04,307.04,308.04,309.04,310.04,311.04,312.04,313.04,314.04,315.04,316.04,317.04,318.04,319.04,320.04,321.04,322.04,323.04,324.04,325.04,326.04,327.04,328.04,329.04,330.04,331.04,332.04,333.04,334.04,335.04,336.04,337.04,338.04,339.04,340.04,341.04,342.04,343.04,344.04,345.04,346.04,347.04,348.04,349.04,350.04,351.04,352.04,353.04,354.04,355.04,356.04,357.04,358.04,359.04,360.04,361.04,362.04,363.04,364.04,365.04,366.04,367.04,368.04,369.04,370.04,371.04,372.04,373.04,374.04,375.04,34.07,35.07,36.07,37.07,38.07,39.07,40.07,41.07,42.07,43.07,44.07,45.07,28.09,29.09,30.09,31.09,32.09,33.09,34.09,35.09,36.09,28.08,29.08,30.08,31.08,32.08,33.08,34.08,35.08,36.08,406.04,407.04,408.04,409.04,50.07,51.07,52.07,53.07,54.07,55.07,56.07,57.07,58.07,59.07,60.07,61.07,41.09,42.09,43.09,44.09,45.09,46.09,47.09,48.09,49.09,41.08,42.08,43.08,44.08,45.08,46.08,47.08,48.08,49.08,440.04,441.04])
15613         self.assertTrue(att4.getFieldOn(att4.getMyGodFather().getMeshAtPosition((0,0)),"YY").isEqualWithoutConsideringStr(exp12,1e-12))
15614         exp13=DataArrayDouble([[0.05,1.05,2.05,3.05,4.05,5.05,6.05,7.05,8.05,9.05,10.05,11.05,12.05,13.05,14.05,15.05,16.05,17.05,18.05,19.05,20.05,21.05,22.05,23.05,24.05,25.05,26.05,27.05,28.05,29.05,30.05,31.05,32.05,33.05,34.05,35.05,36.05,37.05,38.05,39.05,40.05,41.05,42.05,43.05,44.05,45.05,46.05,47.05,48.05,49.05,50.05,51.05,52.05,53.05,54.05,55.05,56.05,57.05,58.05,59.05,60.05,61.05,62.05,63.05,64.05,65.05,66.05,67.05,68.05,69.05,70.05,71.05,72.05,73.05,74.05,75.05,76.05,77.05,78.05,79.05,80.05,81.05,82.05,83.05,84.05,85.05,86.05,87.05,88.05,89.05,90.05,91.05,92.05,93.05,94.05,95.05,96.05,97.05,98.05,99.05,100.05,101.05,102.05,103.05,104.05,105.05,106.05,107.05,108.05,109.05,110.05,111.05,112.05,113.05,114.05,115.05,116.05,117.05,118.05,119.05,120.05,121.05,122.05,123.05,124.05,125.05,126.05,127.05,128.05,129.05,130.05,131.05,132.05,133.05,134.05,135.05,136.05,137.05,138.05,139.05,140.05,141.05,34.06,35.06,144.05,145.05,146.05,147.05,148.05,149.05,150.05,151.05,152.05,153.05,154.05,155.05,156.05,157.05,50.06,51.06,160.05,161.05,162.05,163.05,164.05,165.05,166.05,167.05,168.05,169.05,170.05,171.05,172.05,173.05,66.06,67.06,74.04,75.04,76.04,77.04,78.04,79.04,80.04,81.04,82.04,83.04,84.04,85.04,86.04,87.04,88.04,89.04,108.04,109.04,110.04,111.04,112.04,113.04,114.04,115.04,116.04,117.04,118.04,119.04,120.04,121.04,122.04,123.04]])
15615         self.assertTrue(att4.getFieldOn(att4.getMyGodFather().getMeshAtPosition((0,1)),"YY").isEqualWithoutConsideringStr(exp13,1e-12))
15616         exp14=DataArrayDouble([108.05,109.05,2.06,3.06,4.06,5.06,6.06,7.06,8.06,9.06,10.06,11.06,12.06,13.06,14.06,15.06,124.05,125.05,18.06,19.06,20.06,21.06,22.06,23.06,24.06,25.06,26.06,27.06,28.06,29.06,30.06,31.06,140.05,141.05,34.06,35.06,36.06,37.06,38.06,39.06,40.06,41.06,42.06,43.06,44.06,45.06,46.06,47.06,156.05,157.05,50.06,51.06,52.06,53.06,54.06,55.06,56.06,57.06,58.06,59.06,60.06,61.06,62.06,63.06,172.05,173.05,66.06,67.06,68.06,69.06,70.06,71.06,72.06,73.06,74.06,75.06,76.06,77.06,78.06,79.06,86.04,87.04,88.04,89.04,90.04,91.04,92.04,93.04,94.04,95.04,96.04,97.04,98.04,99.04,94.06,95.06,120.04,121.04,122.04,123.04,124.04,125.04,126.04,127.04,128.04,129.04,130.04,131.04,132.04,133.04,110.06,111.06])
15617         self.assertTrue(att4.getFieldOn(att4.getMyGodFather().getMeshAtPosition((0,2)),"YY").isEqualWithoutConsideringStr(exp14,1e-12))
15618         exp15=DataArrayDouble([0.07,1.07,308.04,309.04,310.04,311.04,312.04,313.04,314.04,315.04,316.04,317.04,318.04,319.04,320.04,321.04,16.07,17.07,342.04,343.04,344.04,345.04,346.04,347.04,348.04,349.04,350.04,351.04,352.04,353.04,354.04,355.04,32.07,33.07,34.07,35.07,36.07,37.07,38.07,39.07,40.07,41.07,42.07,43.07,44.07,45.07,28.09,29.09,48.07,49.07,50.07,51.07,52.07,53.07,54.07,55.07,56.07,57.07,58.07,59.07,60.07,61.07,41.09,42.09,64.07,65.07,66.07,67.07,68.07,69.07,70.07,71.07,72.07,73.07,74.07,75.07,76.07,77.07,54.09,55.09,80.07,81.07,82.07,83.07,84.07,85.07,86.07,87.07,88.07,89.07,90.07,91.07,92.07,93.07,67.09,68.09,96.07,97.07,98.07,99.07,100.07,101.07,102.07,103.07,104.07,105.07,106.07,107.07,108.07,109.07,80.09,81.09,112.07,113.07,114.07,115.07,116.07,117.07,118.07,119.07,120.07,121.07,122.07,123.07,124.07,125.07,93.09,94.09,128.07,129.07,130.07,131.07,132.07,133.07,134.07,135.07,136.07,137.07,138.07,139.07,140.07,141.07,106.09,107.09,144.07,145.07,146.07,147.07,148.07,149.07,150.07,151.07,152.07,153.07,154.07,155.07,156.07,157.07,119.09,120.09,160.07,161.07,162.07,163.07,164.07,165.07,166.07,167.07,168.07,169.07,170.07,171.07,172.07,173.07,132.09,133.09,176.07,177.07,178.07,179.07,180.07,181.07,182.07,183.07,184.07,185.07,186.07,187.07,188.07,189.07,28.1,29.1,192.07,193.07,194.07,195.07,196.07,197.07,198.07,199.07,200.07,201.07,202.07,203.07,204.07,205.07,41.1,42.1,208.07,209.07,210.07,211.07,212.07,213.07,214.07,215.07,216.07,217.07,218.07,219.07,220.07,221.07,54.1,55.1,224.07,225.07,226.07,227.07,228.07,229.07,230.07,231.07,232.07,233.07,234.07,235.07,236.07,237.07,67.1,68.1,240.07,241.07,242.07,243.07,244.07,245.07,246.07,247.07,248.07,249.07,250.07,251.07,252.07,253.07,80.1,81.1,256.07,257.07,258.07,259.07,260.07,261.07,262.07,263.07,264.07,265.07,266.07,267.07,268.07,269.07,93.1,94.1,272.07,273.07,274.07,275.07,276.07,277.07,278.07,279.07,280.07,281.07,282.07,283.07,284.07,285.07,106.1,107.1,288.07,289.07,290.07,291.07,292.07,293.07,294.07,295.07,296.07,297.07,298.07,299.07,300.07,301.07,119.1,120.1,304.07,305.07,306.07,307.07,308.07,309.07,310.07,311.07,312.07,313.07,314.07,315.07,316.07,317.07,132.1,133.1,320.07,321.07,322.07,323.07,324.07,325.07,326.07,327.07,328.07,329.07,330.07,331.07,332.07,333.07,334.07,335.07,336.07,337.07,338.07,339.07,340.07,341.07,342.07,343.07,344.07,345.07,346.07,347.07,348.07,349.07,350.07,351.07])
15619         self.assertTrue(att4.getFieldOn(att4.getMyGodFather().getMeshAtPosition((1,0)),"YY").isEqualWithoutConsideringStr(exp15,1e-12))
15620         exp16=DataArrayDouble([327.04,328.04,329.04,330.04,331.04,332.04,333.04,334.04,335.04,336.04,337.04,11.08,12.08,361.04,362.04,363.04,364.04,365.04,366.04,367.04,368.04,369.04,370.04,371.04,24.08,25.08,35.09,36.09,28.08,29.08,30.08,31.08,32.08,33.08,34.08,35.08,36.08,37.08,38.08,48.09,49.09,41.08,42.08,43.08,44.08,45.08,46.08,47.08,48.08,49.08,50.08,51.08,61.09,62.09,54.08,55.08,56.08,57.08,58.08,59.08,60.08,61.08,62.08,63.08,64.08,74.09,75.09,67.08,68.08,69.08,70.08,71.08,72.08,73.08,74.08,75.08,76.08,77.08,87.09,88.09,80.08,81.08,82.08,83.08,84.08,85.08,86.08,87.08,88.08,89.08,90.08,100.09,101.09,93.08,94.08,95.08,96.08,97.08,98.08,99.08,100.08,101.08,102.08,103.08,113.09,114.09,106.08,107.08,108.08,109.08,110.08,111.08,112.08,113.08,114.08,115.08,116.08,126.09,127.09,119.08,120.08,121.08,122.08,123.08,124.08,125.08,126.08,127.08,128.08,129.08,139.09,140.09,132.08,133.08,134.08,135.08,136.08,137.08,138.08,139.08,140.08,141.08,142.08,35.1,36.1,145.08,146.08,147.08,148.08,149.08,150.08,151.08,152.08,153.08,154.08,155.08,48.1,49.1,158.08,159.08,160.08,161.08,162.08,163.08,164.08,165.08,166.08,167.08,168.08,61.1,62.1,171.08,172.08,173.08,174.08,175.08,176.08,177.08,178.08,179.08,180.08,181.08,74.1,75.1,184.08,185.08,186.08,187.08,188.08,189.08,190.08,191.08,192.08,193.08,194.08,87.1,88.1,197.08,198.08,199.08,200.08,201.08,202.08,203.08,204.08,205.08,206.08,207.08])
15621         self.assertTrue(att4.getFieldOn(att4.getMyGodFather().getMeshAtPosition((1,1)),"YY").isEqualWithoutConsideringStr(exp16,1e-12))
15622         exp17=DataArrayDouble([318.04,319.04,320.04,321.04,322.04,323.04,324.04,325.04,326.04,327.04,328.04,329.04,330.04,352.04,353.04,354.04,355.04,356.04,357.04,358.04,359.04,360.04,361.04,362.04,363.04,364.04,44.07,45.07,28.09,29.09,30.09,31.09,32.09,33.09,34.09,35.09,36.09,28.08,29.08,60.07,61.07,41.09,42.09,43.09,44.09,45.09,46.09,47.09,48.09,49.09,41.08,42.08,76.07,77.07,54.09,55.09,56.09,57.09,58.09,59.09,60.09,61.09,62.09,54.08,55.08,92.07,93.07,67.09,68.09,69.09,70.09,71.09,72.09,73.09,74.09,75.09,67.08,68.08,108.07,109.07,80.09,81.09,82.09,83.09,84.09,85.09,86.09,87.09,88.09,80.08,81.08,124.07,125.07,93.09,94.09,95.09,96.09,97.09,98.09,99.09,100.09,101.09,93.08,94.08,140.07,141.07,106.09,107.09,108.09,109.09,110.09,111.09,112.09,113.09,114.09,106.08,107.08,156.07,157.07,119.09,120.09,121.09,122.09,123.09,124.09,125.09,126.09,127.09,119.08,120.08,172.07,173.07,132.09,133.09,134.09,135.09,136.09,137.09,138.09,139.09,140.09,132.08,133.08,188.07,189.07,28.1,29.1,30.1,31.1,32.1,33.1,34.1,35.1,36.1,145.08,146.08,204.07,205.07,41.1,42.1,43.1,44.1,45.1,46.1,47.1,48.1,49.1,158.08,159.08])
15623         self.assertTrue(att4.getFieldOn(att4.getMyGodFather().getMeshAtPosition((1,2)),"YY").isEqualWithoutConsideringStr(exp17,1e-12))
15624         exp18=DataArrayDouble([156.07,157.07,119.09,120.09,121.09,122.09,123.09,124.09,125.09,126.09,127.09,119.08,120.08,172.07,173.07,132.09,133.09,134.09,135.09,136.09,137.09,138.09,139.09,140.09,132.08,133.08,188.07,189.07,28.1,29.1,30.1,31.1,32.1,33.1,34.1,35.1,36.1,145.08,146.08,204.07,205.07,41.1,42.1,43.1,44.1,45.1,46.1,47.1,48.1,49.1,158.08,159.08,220.07,221.07,54.1,55.1,56.1,57.1,58.1,59.1,60.1,61.1,62.1,171.08,172.08,236.07,237.07,67.1,68.1,69.1,70.1,71.1,72.1,73.1,74.1,75.1,76.1,77.1,252.07,253.07,80.1,81.1,82.1,83.1,84.1,85.1,86.1,87.1,88.1,89.1,90.1,268.07,269.07,93.1,94.1,95.1,96.1,97.1,98.1,99.1,100.1,101.1,102.1,103.1,284.07,285.07,106.1,107.1,108.1,109.1,110.1,111.1,112.1,113.1,114.1,115.1,116.1,300.07,301.07,119.1,120.1,121.1,122.1,123.1,124.1,125.1,126.1,127.1,128.1,129.1,316.07,317.07,132.1,133.1,134.1,135.1,136.1,137.1,138.1,139.1,140.1,141.1,142.1,143.1,144.1,145.1,146.1,147.1,148.1,149.1,150.1,151.1,152.1,153.1,154.1,155.1,156.1,157.1,158.1,159.1,160.1,161.1,162.1,163.1,164.1,165.1,166.1,167.1,168.1])
15625         self.assertTrue(att4.getFieldOn(att4.getMyGodFather().getMeshAtPosition((1,3)),"YY").isEqualWithoutConsideringStr(exp18,1e-12))
15626         del att4
15627         ###
15628         att5.synchronizeAllGhostZonesAtASpecifiedLevelUsingOnlyFather(2)
15629         for pos in [(),(0,),(1,),(2,)]:
15630             self.assertTrue(att5.getFieldOn(att5.getMyGodFather().getMeshAtPosition(pos),"YY").isEqual(att6.getFieldOn(att6.getMyGodFather().getMeshAtPosition(pos),"YY"),1e-12))
15631             pass
15632         att5.buildCellFieldOnWithGhost(att5.getMyGodFather().getMeshAtPosition((0,0)),"YY")
15633         exp19=DataArrayDouble([57.02,57.02,58.02,58.02,58.02,59.02,59.02,59.02,60.02,60.02,60.02,61.02,61.02,61.02,62.02,62.02,62.02,63.02,63.02,63.02,64.02,64.02,64.02,65.02,65.02,65.02,66.02,66.02,66.02,67.02,67.02,67.02,68.02,68.02,57.02,57.02,58.02,58.02,58.02,59.02,59.02,59.02,60.02,60.02,60.02,61.02,61.02,61.02,62.02,62.02,62.02,63.02,63.02,63.02,64.02,64.02,64.02,65.02,65.02,65.02,66.02,66.02,66.02,67.02,67.02,67.02,68.02,68.02,71.02,71.02,70.04,71.04,72.04,73.04,74.04,75.04,76.04,77.04,78.04,79.04,80.04,81.04,82.04,83.04,84.04,85.04,86.04,87.04,88.04,89.04,90.04,91.04,92.04,93.04,94.04,95.04,96.04,97.04,98.04,99.04,82.02,82.02,71.02,71.02,104.04,105.04,106.04,107.04,108.04,109.04,110.04,111.04,112.04,113.04,114.04,115.04,116.04,117.04,118.04,119.04,120.04,121.04,122.04,123.04,124.04,125.04,126.04,127.04,128.04,129.04,130.04,131.04,132.04,133.04,82.02,82.02,71.02,71.02,138.04,139.04,140.04,141.04,142.04,143.04,144.04,145.04,146.04,147.04,148.04,149.04,150.04,151.04,152.04,153.04,154.04,155.04,156.04,157.04,158.04,159.04,160.04,161.04,162.04,163.04,164.04,165.04,166.04,167.04,82.02,82.02,85.02,85.02,172.04,173.04,174.04,175.04,176.04,177.04,178.04,179.04,180.04,181.04,182.04,183.04,184.04,185.04,186.04,187.04,188.04,189.04,190.04,191.04,192.04,193.04,194.04,195.04,196.04,197.04,198.04,199.04,200.04,201.04,96.02,96.02,85.02,85.02,206.04,207.04,208.04,209.04,210.04,211.04,212.04,213.04,214.04,215.04,216.04,217.04,218.04,219.04,220.04,221.04,222.04,223.04,224.04,225.04,226.04,227.04,228.04,229.04,230.04,231.04,232.04,233.04,234.04,235.04,96.02,96.02,85.02,85.02,240.04,241.04,242.04,243.04,244.04,245.04,246.04,247.04,248.04,249.04,250.04,251.04,252.04,253.04,254.04,255.04,256.04,257.04,258.04,259.04,260.04,261.04,262.04,263.04,264.04,265.04,266.04,267.04,268.04,269.04,96.02,96.02,99.02,99.02,274.04,275.04,276.04,277.04,278.04,279.04,280.04,281.04,282.04,283.04,284.04,285.04,286.04,287.04,288.04,289.04,290.04,291.04,292.04,293.04,294.04,295.04,296.04,297.04,298.04,299.04,300.04,301.04,302.04,303.04,110.02,110.02,99.02,99.02,308.04,309.04,310.04,311.04,312.04,313.04,314.04,315.04,316.04,317.04,318.04,319.04,320.04,321.04,322.04,323.04,324.04,325.04,326.04,327.04,328.04,329.04,330.04,331.04,332.04,333.04,334.04,335.04,336.04,337.04,110.02,110.02,99.02,99.02,342.04,343.04,344.04,345.04,346.04,347.04,348.04,349.04,350.04,351.04,352.04,353.04,354.04,355.04,356.04,357.04,358.04,359.04,360.04,361.04,362.04,363.04,364.04,365.04,366.04,367.04,368.04,369.04,370.04,371.04,110.02,110.02,113.02,113.02,114.02,114.02,114.02,115.02,115.02,115.02,116.02,116.02,116.02,117.02,117.02,117.02,118.02,118.02,118.02,119.02,119.02,119.02,120.02,120.02,120.02,121.02,121.02,121.02,122.02,122.02,122.02,123.02,123.02,123.02,124.02,124.02,113.02,113.02,114.02,114.02,114.02,115.02,115.02,115.02,116.02,116.02,116.02,117.02,117.02,117.02,118.02,118.02,118.02,119.02,119.02,119.02,120.02,120.02,120.02,121.02,121.02,121.02,122.02,122.02,122.02,123.02,123.02,123.02,124.02,124.02])
15634         self.assertTrue(att5.getFieldOn(att5.getMyGodFather().getMeshAtPosition((0,0)),"YY").isEqualWithoutConsideringStr(exp19,1e-12))
15635         exp20=DataArrayDouble([17.02,17.02,18.02,18.02,18.02,19.02,19.02,19.02,20.02,20.02,20.02,21.02,21.02,21.02,22.02,22.02,17.02,17.02,18.02,18.02,18.02,19.02,19.02,19.02,20.02,20.02,20.02,21.02,21.02,21.02,22.02,22.02,31.02,31.02,34.05,35.05,36.05,37.05,38.05,39.05,40.05,41.05,42.05,43.05,44.05,45.05,36.02,36.02,31.02,31.02,50.05,51.05,52.05,53.05,54.05,55.05,56.05,57.05,58.05,59.05,60.05,61.05,36.02,36.02,31.02,31.02,66.05,67.05,68.05,69.05,70.05,71.05,72.05,73.05,74.05,75.05,76.05,77.05,36.02,36.02,45.02,45.02,82.05,83.05,84.05,85.05,86.05,87.05,88.05,89.05,90.05,91.05,92.05,93.05,50.02,50.02,45.02,45.02,98.05,99.05,100.05,101.05,102.05,103.05,104.05,105.05,106.05,107.05,108.05,109.05,50.02,50.02,45.02,45.02,114.05,115.05,116.05,117.05,118.05,119.05,120.05,121.05,122.05,123.05,124.05,125.05,50.02,50.02,59.02,59.02,130.05,131.05,132.05,133.05,134.05,135.05,136.05,137.05,138.05,139.05,140.05,141.05,64.02,64.02,59.02,59.02,146.05,147.05,148.05,149.05,150.05,151.05,152.05,153.05,154.05,155.05,156.05,157.05,64.02,64.02,59.02,59.02,162.05,163.05,164.05,165.05,166.05,167.05,168.05,169.05,170.05,171.05,172.05,173.05,64.02,64.02,73.02,73.02,74.02,74.02,74.02,75.02,75.02,75.02,76.02,76.02,76.02,77.02,77.02,77.02,78.02,78.02,73.02,73.02,74.02,74.02,74.02,75.02,75.02,75.02,76.02,76.02,76.02,77.02,77.02,77.02,78.02,78.02])
15636         self.assertTrue(att5.getFieldOn(att5.getMyGodFather().getMeshAtPosition((0,1)),"YY").isEqualWithoutConsideringStr(exp20,1e-12))
15637         exp21=DataArrayDouble([49.02,49.02,50.02,50.02,50.02,51.02,51.02,51.02,52.02,52.02,52.02,53.02,53.02,53.02,54.02,54.02,49.02,49.02,50.02,50.02,50.02,51.02,51.02,51.02,52.02,52.02,52.02,53.02,53.02,53.02,54.02,54.02,63.02,63.02,34.06,35.06,36.06,37.06,38.06,39.06,40.06,41.06,42.06,43.06,44.06,45.06,68.02,68.02,63.02,63.02,50.06,51.06,52.06,53.06,54.06,55.06,56.06,57.06,58.06,59.06,60.06,61.06,68.02,68.02,63.02,63.02,66.06,67.06,68.06,69.06,70.06,71.06,72.06,73.06,74.06,75.06,76.06,77.06,68.02,68.02,77.02,77.02,78.02,78.02,78.02,79.02,79.02,79.02,80.02,80.02,80.02,81.02,81.02,81.02,82.02,82.02,77.02,77.02,78.02,78.02,78.02,79.02,79.02,79.02,80.02,80.02,80.02,81.02,81.02,81.02,82.02,82.02])
15638         self.assertTrue(att5.getFieldOn(att5.getMyGodFather().getMeshAtPosition((0,2)),"YY").isEqualWithoutConsideringStr(exp21,1e-12))
15639         exp22=DataArrayDouble([15.03,15.03,16.03,16.03,16.03,17.03,17.03,17.03,18.03,18.03,18.03,19.03,19.03,19.03,20.03,20.03,15.03,15.03,16.03,16.03,16.03,17.03,17.03,17.03,18.03,18.03,18.03,19.03,19.03,19.03,20.03,20.03,29.03,29.03,34.07,35.07,36.07,37.07,38.07,39.07,40.07,41.07,42.07,43.07,44.07,45.07,34.03,34.03,29.03,29.03,50.07,51.07,52.07,53.07,54.07,55.07,56.07,57.07,58.07,59.07,60.07,61.07,34.03,34.03,29.03,29.03,66.07,67.07,68.07,69.07,70.07,71.07,72.07,73.07,74.07,75.07,76.07,77.07,34.03,34.03,43.03,43.03,82.07,83.07,84.07,85.07,86.07,87.07,88.07,89.07,90.07,91.07,92.07,93.07,48.03,48.03,43.03,43.03,98.07,99.07,100.07,101.07,102.07,103.07,104.07,105.07,106.07,107.07,108.07,109.07,48.03,48.03,43.03,43.03,114.07,115.07,116.07,117.07,118.07,119.07,120.07,121.07,122.07,123.07,124.07,125.07,48.03,48.03,57.03,57.03,130.07,131.07,132.07,133.07,134.07,135.07,136.07,137.07,138.07,139.07,140.07,141.07,62.03,62.03,57.03,57.03,146.07,147.07,148.07,149.07,150.07,151.07,152.07,153.07,154.07,155.07,156.07,157.07,62.03,62.03,57.03,57.03,162.07,163.07,164.07,165.07,166.07,167.07,168.07,169.07,170.07,171.07,172.07,173.07,62.03,62.03,71.03,71.03,178.07,179.07,180.07,181.07,182.07,183.07,184.07,185.07,186.07,187.07,188.07,189.07,76.03,76.03,71.03,71.03,194.07,195.07,196.07,197.07,198.07,199.07,200.07,201.07,202.07,203.07,204.07,205.07,76.03,76.03,71.03,71.03,210.07,211.07,212.07,213.07,214.07,215.07,216.07,217.07,218.07,219.07,220.07,221.07,76.03,76.03,85.03,85.03,226.07,227.07,228.07,229.07,230.07,231.07,232.07,233.07,234.07,235.07,236.07,237.07,90.03,90.03,85.03,85.03,242.07,243.07,244.07,245.07,246.07,247.07,248.07,249.07,250.07,251.07,252.07,253.07,90.03,90.03,85.03,85.03,258.07,259.07,260.07,261.07,262.07,263.07,264.07,265.07,266.07,267.07,268.07,269.07,90.03,90.03,99.03,99.03,274.07,275.07,276.07,277.07,278.07,279.07,280.07,281.07,282.07,283.07,284.07,285.07,104.03,104.03,99.03,99.03,290.07,291.07,292.07,293.07,294.07,295.07,296.07,297.07,298.07,299.07,300.07,301.07,104.03,104.03,99.03,99.03,306.07,307.07,308.07,309.07,310.07,311.07,312.07,313.07,314.07,315.07,316.07,317.07,104.03,104.03,113.03,113.03,114.03,114.03,114.03,115.03,115.03,115.03,116.03,116.03,116.03,117.03,117.03,117.03,118.03,118.03,113.03,113.03,114.03,114.03,114.03,115.03,115.03,115.03,116.03,116.03,116.03,117.03,117.03,117.03,118.03,118.03])
15640         self.assertTrue(att5.getFieldOn(att5.getMyGodFather().getMeshAtPosition((1,0)),"YY").isEqualWithoutConsideringStr(exp22,1e-12))
15641         exp23=DataArrayDouble([22.03,22.03,23.03,23.03,23.03,24.03,24.03,24.03,25.03,25.03,25.03,26.03,26.03,22.03,22.03,23.03,23.03,23.03,24.03,24.03,24.03,25.03,25.03,25.03,26.03,26.03,36.03,36.03,28.08,29.08,30.08,31.08,32.08,33.08,34.08,35.08,36.08,40.03,40.03,36.03,36.03,41.08,42.08,43.08,44.08,45.08,46.08,47.08,48.08,49.08,40.03,40.03,36.03,36.03,54.08,55.08,56.08,57.08,58.08,59.08,60.08,61.08,62.08,40.03,40.03,50.03,50.03,67.08,68.08,69.08,70.08,71.08,72.08,73.08,74.08,75.08,54.03,54.03,50.03,50.03,80.08,81.08,82.08,83.08,84.08,85.08,86.08,87.08,88.08,54.03,54.03,50.03,50.03,93.08,94.08,95.08,96.08,97.08,98.08,99.08,100.08,101.08,54.03,54.03,64.03,64.03,106.08,107.08,108.08,109.08,110.08,111.08,112.08,113.08,114.08,68.03,68.03,64.03,64.03,119.08,120.08,121.08,122.08,123.08,124.08,125.08,126.08,127.08,68.03,68.03,64.03,64.03,132.08,133.08,134.08,135.08,136.08,137.08,138.08,139.08,140.08,68.03,68.03,78.03,78.03,145.08,146.08,147.08,148.08,149.08,150.08,151.08,152.08,153.08,82.03,82.03,78.03,78.03,158.08,159.08,160.08,161.08,162.08,163.08,164.08,165.08,166.08,82.03,82.03,78.03,78.03,171.08,172.08,173.08,174.08,175.08,176.08,177.08,178.08,179.08,82.03,82.03,92.03,92.03,93.03,93.03,93.03,94.03,94.03,94.03,95.03,95.03,95.03,96.03,96.03,92.03,92.03,93.03,93.03,93.03,94.03,94.03,94.03,95.03,95.03,95.03,96.03,96.03])
15642         self.assertTrue(att5.getFieldOn(att5.getMyGodFather().getMeshAtPosition((1,1)),"YY").isEqualWithoutConsideringStr(exp23,1e-12))
15643         exp24=DataArrayDouble([19.03,19.03,20.03,20.03,20.03,21.03,21.03,21.03,22.03,22.03,22.03,23.03,23.03,19.03,19.03,20.03,20.03,20.03,21.03,21.03,21.03,22.03,22.03,22.03,23.03,23.03,33.03,33.03,28.09,29.09,30.09,31.09,32.09,33.09,34.09,35.09,36.09,37.03,37.03,33.03,33.03,41.09,42.09,43.09,44.09,45.09,46.09,47.09,48.09,49.09,37.03,37.03,33.03,33.03,54.09,55.09,56.09,57.09,58.09,59.09,60.09,61.09,62.09,37.03,37.03,47.03,47.03,67.09,68.09,69.09,70.09,71.09,72.09,73.09,74.09,75.09,51.03,51.03,47.03,47.03,80.09,81.09,82.09,83.09,84.09,85.09,86.09,87.09,88.09,51.03,51.03,47.03,47.03,93.09,94.09,95.09,96.09,97.09,98.09,99.09,100.09,101.09,51.03,51.03,61.03,61.03,106.09,107.09,108.09,109.09,110.09,111.09,112.09,113.09,114.09,65.03,65.03,61.03,61.03,119.09,120.09,121.09,122.09,123.09,124.09,125.09,126.09,127.09,65.03,65.03,61.03,61.03,132.09,133.09,134.09,135.09,136.09,137.09,138.09,139.09,140.09,65.03,65.03,75.03,75.03,76.03,76.03,76.03,77.03,77.03,77.03,78.03,78.03,78.03,79.03,79.03,75.03,75.03,76.03,76.03,76.03,77.03,77.03,77.03,78.03,78.03,78.03,79.03,79.03])
15644         self.assertTrue(att5.getFieldOn(att5.getMyGodFather().getMeshAtPosition((1,2)),"YY").isEqualWithoutConsideringStr(exp24,1e-12))
15645         exp25=DataArrayDouble([61.03,61.03,62.03,62.03,62.03,63.03,63.03,63.03,64.03,64.03,64.03,65.03,65.03,61.03,61.03,62.03,62.03,62.03,63.03,63.03,63.03,64.03,64.03,64.03,65.03,65.03,75.03,75.03,28.1,29.1,30.1,31.1,32.1,33.1,34.1,35.1,36.1,79.03,79.03,75.03,75.03,41.1,42.1,43.1,44.1,45.1,46.1,47.1,48.1,49.1,79.03,79.03,75.03,75.03,54.1,55.1,56.1,57.1,58.1,59.1,60.1,61.1,62.1,79.03,79.03,89.03,89.03,67.1,68.1,69.1,70.1,71.1,72.1,73.1,74.1,75.1,93.03,93.03,89.03,89.03,80.1,81.1,82.1,83.1,84.1,85.1,86.1,87.1,88.1,93.03,93.03,89.03,89.03,93.1,94.1,95.1,96.1,97.1,98.1,99.1,100.1,101.1,93.03,93.03,103.03,103.03,106.1,107.1,108.1,109.1,110.1,111.1,112.1,113.1,114.1,107.03,107.03,103.03,103.03,119.1,120.1,121.1,122.1,123.1,124.1,125.1,126.1,127.1,107.03,107.03,103.03,103.03,132.1,133.1,134.1,135.1,136.1,137.1,138.1,139.1,140.1,107.03,107.03,117.03,117.03,118.03,118.03,118.03,119.03,119.03,119.03,120.03,120.03,120.03,121.03,121.03,117.03,117.03,118.03,118.03,118.03,119.03,119.03,119.03,120.03,120.03,120.03,121.03,121.03])
15646         self.assertTrue(att5.getFieldOn(att5.getMyGodFather().getMeshAtPosition((1,3)),"YY").isEqualWithoutConsideringStr(exp25,1e-12))
15647         pass
15648
15649     def testSwig2AMR11(self):
15650         """ Some tests in 3D with CondenseFineToCoarseGhost and SpreadCoarseToFineGhost"""
15651         coarse=DataArrayDouble((6+4)*(7+4)*(5+4)) ; coarse.iota()
15652         fine=DataArrayDouble((4*2+4)*(2*3+4)*(3*4+4))
15653         MEDCouplingIMesh.SpreadCoarseToFineGhost(coarse,[6,7,5],fine,[(1,5),(2,4),(1,4)],[2,3,4],2)
15654         exp0=DataArrayDouble([252.,252.,253.,253.,254.,254.,255.,255.,256.,256.,257.,257.,252.,252.,253.,253.,254.,254.,255.,255.,256.,256.,257.,257.,262.,262.,263.,263.,264.,264.,265.,265.,266.,266.,267.,267.,262.,262.,263.,263.,264.,264.,265.,265.,266.,266.,267.,267.,262.,262.,263.,263.,264.,264.,265.,265.,266.,266.,267.,267.,272.,272.,273.,273.,274.,274.,275.,275.,276.,276.,277.,277.,272.,272.,273.,273.,274.,274.,275.,275.,276.,276.,277.,277.,272.,272.,273.,273.,274.,274.,275.,275.,276.,276.,277.,277.,282.,282.,283.,283.,284.,284.,285.,285.,286.,286.,287.,287.,282.,282.,283.,283.,284.,284.,285.,285.,286.,286.,287.,287.])
15655         exp1=DataArrayDouble([362.,362.,363.,363.,364.,364.,365.,365.,366.,366.,367.,367.,362.,362.,363.,363.,364.,364.,365.,365.,366.,366.,367.,367.,372.,372.,373.,373.,374.,374.,375.,375.,376.,376.,377.,377.,372.,372.,373.,373.,374.,374.,375.,375.,376.,376.,377.,377.,372.,372.,373.,373.,374.,374.,375.,375.,376.,376.,377.,377.,382.,382.,383.,383.,384.,384.,385.,385.,386.,386.,387.,387.,382.,382.,383.,383.,384.,384.,385.,385.,386.,386.,387.,387.,382.,382.,383.,383.,384.,384.,385.,385.,386.,386.,387.,387.,392.,392.,393.,393.,394.,394.,395.,395.,396.,396.,397.,397.,392.,392.,393.,393.,394.,394.,395.,395.,396.,396.,397.,397.])
15656         exp2=DataArrayDouble([472.,472.,473.,473.,474.,474.,475.,475.,476.,476.,477.,477.,472.,472.,473.,473.,474.,474.,475.,475.,476.,476.,477.,477.,482.,482.,483.,483.,484.,484.,485.,485.,486.,486.,487.,487.,482.,482.,483.,483.,484.,484.,485.,485.,486.,486.,487.,487.,482.,482.,483.,483.,484.,484.,485.,485.,486.,486.,487.,487.,492.,492.,493.,493.,494.,494.,495.,495.,496.,496.,497.,497.,492.,492.,493.,493.,494.,494.,495.,495.,496.,496.,497.,497.,492.,492.,493.,493.,494.,494.,495.,495.,496.,496.,497.,497.,502.,502.,503.,503.,504.,504.,505.,505.,506.,506.,507.,507.,502.,502.,503.,503.,504.,504.,505.,505.,506.,506.,507.,507.])
15657         exp3=DataArrayDouble([582.,582.,583.,583.,584.,584.,585.,585.,586.,586.,587.,587.,582.,582.,583.,583.,584.,584.,585.,585.,586.,586.,587.,587.,592.,592.,593.,593.,594.,594.,595.,595.,596.,596.,597.,597.,592.,592.,593.,593.,594.,594.,595.,595.,596.,596.,597.,597.,592.,592.,593.,593.,594.,594.,595.,595.,596.,596.,597.,597.,602.,602.,603.,603.,604.,604.,605.,605.,606.,606.,607.,607.,602.,602.,603.,603.,604.,604.,605.,605.,606.,606.,607.,607.,602.,602.,603.,603.,604.,604.,605.,605.,606.,606.,607.,607.,612.,612.,613.,613.,614.,614.,615.,615.,616.,616.,617.,617.,612.,612.,613.,613.,614.,614.,615.,615.,616.,616.,617.,617.])
15658         exp4=DataArrayDouble([692.,692.,693.,693.,694.,694.,695.,695.,696.,696.,697.,697.,692.,692.,693.,693.,694.,694.,695.,695.,696.,696.,697.,697.,702.,702.,703.,703.,704.,704.,705.,705.,706.,706.,707.,707.,702.,702.,703.,703.,704.,704.,705.,705.,706.,706.,707.,707.,702.,702.,703.,703.,704.,704.,705.,705.,706.,706.,707.,707.,712.,712.,713.,713.,714.,714.,715.,715.,716.,716.,717.,717.,712.,712.,713.,713.,714.,714.,715.,715.,716.,716.,717.,717.,712.,712.,713.,713.,714.,714.,715.,715.,716.,716.,717.,717.,722.,722.,723.,723.,724.,724.,725.,725.,726.,726.,727.,727.,722.,722.,723.,723.,724.,724.,725.,725.,726.,726.,727.,727.])
15659         exp=DataArrayDouble.Aggregate([exp0,exp0,exp1,exp1,exp1,exp1,exp2,exp2,exp2,exp2,exp3,exp3,exp3,exp3,exp4,exp4])
15660         self.assertTrue(fine.isEqual(exp,1e-12))
15661         #
15662         fine.iota()
15663         coarse.iota(0.5)
15664         MEDCouplingIMesh.CondenseFineToCoarseGhost([6,7,5],fine,[(1,5),(2,4),(1,4)],[2,3,4],coarse,2)
15665         amr=MEDCouplingCartesianAMRMesh("mesh",3,[7,8,6],[0.,0.,0.],[1.,1.,1.])
15666         amr.addPatch([(1,5),(2,4),(1,4)],[2,3,4])
15667         att=MEDCouplingAMRAttribute(amr,[("YY",1)],2)
15668         att.alloc()
15669         exp1=DataArrayDouble(990) ; exp1.iota(0.5)
15670         ids=DataArrayInt([373,374,375,376,383,384,385,386,483,484,485,486,493,494,495,496,593,594,595,596,603,604,605,606])
15671         vals=DataArrayDouble([11004.,11052.,11100.,11148.,11868.,11916.,11964.,12012.,22524.,22572.,22620.,22668.,23388.,23436.,23484.,23532.,34044.,34092.,34140.,34188.,34908.,34956.,35004.,35052.])
15672         exp1[ids]=vals
15673         self.assertTrue(coarse.isEqual(exp1,1e-12))
15674         #
15675         MEDCouplingStructuredMesh.MultiplyPartOf([10,11,9],[(3,7),(4,6),(3,6)],1/24.,coarse)
15676         exp2=DataArrayDouble(990) ; exp2.iota(0.5)
15677         exp2[ids]=vals/24.
15678         self.assertTrue(coarse.isEqual(exp2,1e-12))
15679         #
15680         coarse.iota(0.5) ; fine.iota(0.1)
15681         MEDCouplingIMesh.SpreadCoarseToFineGhostZone(coarse,[6,7,5],fine,[(1,5),(2,4),(1,4)],[2,3,4],2)
15682         #
15683         coarse.iota(0.5) ; fine.iota(0.1)
15684         MEDCouplingIMesh.SpreadCoarseToFineGhostZone(coarse,[6,7,5],fine,[(1,5),(2,4),(1,4)],[2,3,4],2)
15685         exp00=DataArrayDouble.Aggregate([exp0,exp0]) ; exp00+=0.5
15686         self.assertTrue(fine[:240].isEqual(exp00,1e-12))
15687         exp44=DataArrayDouble.Aggregate([exp4,exp4]) ; exp44+=0.5
15688         self.assertTrue(fine[-240:].isEqual(exp44,1e-12))
15689         self.assertTrue(fine[240:-240].isEqual(DataArrayDouble([362.5,362.5,363.5,363.5,364.5,364.5,365.5,365.5,366.5,366.5,367.5,367.5,362.5,362.5,363.5,363.5,364.5,364.5,365.5,365.5,366.5,366.5,367.5,367.5,372.5,372.5,266.1,267.1,268.1,269.1,270.1,271.1,272.1,273.1,377.5,377.5,372.5,372.5,278.1,279.1,280.1,281.1,282.1,283.1,284.1,285.1,377.5,377.5,372.5,372.5,290.1,291.1,292.1,293.1,294.1,295.1,296.1,297.1,377.5,377.5,382.5,382.5,302.1,303.1,304.1,305.1,306.1,307.1,308.1,309.1,387.5,387.5,382.5,382.5,314.1,315.1,316.1,317.1,318.1,319.1,320.1,321.1,387.5,387.5,382.5,382.5,326.1,327.1,328.1,329.1,330.1,331.1,332.1,333.1,387.5,387.5,392.5,392.5,393.5,393.5,394.5,394.5,395.5,395.5,396.5,396.5,397.5,397.5,392.5,392.5,393.5,393.5,394.5,394.5,395.5,395.5,396.5,396.5,397.5,397.5,362.5,362.5,363.5,363.5,364.5,364.5,365.5,365.5,366.5,366.5,367.5,367.5,362.5,362.5,363.5,363.5,364.5,364.5,365.5,365.5,366.5,366.5,367.5,367.5,372.5,372.5,386.1,387.1,388.1,389.1,390.1,391.1,392.1,393.1,377.5,377.5,372.5,372.5,398.1,399.1,400.1,401.1,402.1,403.1,404.1,405.1,377.5,377.5,372.5,372.5,410.1,411.1,412.1,413.1,414.1,415.1,416.1,417.1,377.5,377.5,382.5,382.5,422.1,423.1,424.1,425.1,426.1,427.1,428.1,429.1,387.5,387.5,382.5,382.5,434.1,435.1,436.1,437.1,438.1,439.1,440.1,441.1,387.5,387.5,382.5,382.5,446.1,447.1,448.1,449.1,450.1,451.1,452.1,453.1,387.5,387.5,392.5,392.5,393.5,393.5,394.5,394.5,395.5,395.5,396.5,396.5,397.5,397.5,392.5,392.5,393.5,393.5,394.5,394.5,395.5,395.5,396.5,396.5,397.5,397.5,362.5,362.5,363.5,363.5,364.5,364.5,365.5,365.5,366.5,366.5,367.5,367.5,362.5,362.5,363.5,363.5,364.5,364.5,365.5,365.5,366.5,366.5,367.5,367.5,372.5,372.5,506.1,507.1,508.1,509.1,510.1,511.1,512.1,513.1,377.5,377.5,372.5,372.5,518.1,519.1,520.1,521.1,522.1,523.1,524.1,525.1,377.5,377.5,372.5,372.5,530.1,531.1,532.1,533.1,534.1,535.1,536.1,537.1,377.5,377.5,382.5,382.5,542.1,543.1,544.1,545.1,546.1,547.1,548.1,549.1,387.5,387.5,382.5,382.5,554.1,555.1,556.1,557.1,558.1,559.1,560.1,561.1,387.5,387.5,382.5,382.5,566.1,567.1,568.1,569.1,570.1,571.1,572.1,573.1,387.5,387.5,392.5,392.5,393.5,393.5,394.5,394.5,395.5,395.5,396.5,396.5,397.5,397.5,392.5,392.5,393.5,393.5,394.5,394.5,395.5,395.5,396.5,396.5,397.5,397.5,362.5,362.5,363.5,363.5,364.5,364.5,365.5,365.5,366.5,366.5,367.5,367.5,362.5,362.5,363.5,363.5,364.5,364.5,365.5,365.5,366.5,366.5,367.5,367.5,372.5,372.5,626.1,627.1,628.1,629.1,630.1,631.1,632.1,633.1,377.5,377.5,372.5,372.5,638.1,639.1,640.1,641.1,642.1,643.1,644.1,645.1,377.5,377.5,372.5,372.5,650.1,651.1,652.1,653.1,654.1,655.1,656.1,657.1,377.5,377.5,382.5,382.5,662.1,663.1,664.1,665.1,666.1,667.1,668.1,669.1,387.5,387.5,382.5,382.5,674.1,675.1,676.1,677.1,678.1,679.1,680.1,681.1,387.5,387.5,382.5,382.5,686.1,687.1,688.1,689.1,690.1,691.1,692.1,693.1,387.5,387.5,392.5,392.5,393.5,393.5,394.5,394.5,395.5,395.5,396.5,396.5,397.5,397.5,392.5,392.5,393.5,393.5,394.5,394.5,395.5,395.5,396.5,396.5,397.5,397.5,472.5,472.5,473.5,473.5,474.5,474.5,475.5,475.5,476.5,476.5,477.5,477.5,472.5,472.5,473.5,473.5,474.5,474.5,475.5,475.5,476.5,476.5,477.5,477.5,482.5,482.5,746.1,747.1,748.1,749.1,750.1,751.1,752.1,753.1,487.5,487.5,482.5,482.5,758.1,759.1,760.1,761.1,762.1,763.1,764.1,765.1,487.5,487.5,482.5,482.5,770.1,771.1,772.1,773.1,774.1,775.1,776.1,777.1,487.5,487.5,492.5,492.5,782.1,783.1,784.1,785.1,786.1,787.1,788.1,789.1,497.5,497.5,492.5,492.5,794.1,795.1,796.1,797.1,798.1,799.1,800.1,801.1,497.5,497.5,492.5,492.5,806.1,807.1,808.1,809.1,810.1,811.1,812.1,813.1,497.5,497.5,502.5,502.5,503.5,503.5,504.5,504.5,505.5,505.5,506.5,506.5,507.5,507.5,502.5,502.5,503.5,503.5,504.5,504.5,505.5,505.5,506.5,506.5,507.5,507.5,472.5,472.5,473.5,473.5,474.5,474.5,475.5,475.5,476.5,476.5,477.5,477.5,472.5,472.5,473.5,473.5,474.5,474.5,475.5,475.5,476.5,476.5,477.5,477.5,482.5,482.5,866.1,867.1,868.1,869.1,870.1,871.1,872.1,873.1,487.5,487.5,482.5,482.5,878.1,879.1,880.1,881.1,882.1,883.1,884.1,885.1,487.5,487.5,482.5,482.5,890.1,891.1,892.1,893.1,894.1,895.1,896.1,897.1,487.5,487.5,492.5,492.5,902.1,903.1,904.1,905.1,906.1,907.1,908.1,909.1,497.5,497.5,492.5,492.5,914.1,915.1,916.1,917.1,918.1,919.1,920.1,921.1,497.5,497.5,492.5,492.5,926.1,927.1,928.1,929.1,930.1,931.1,932.1,933.1,497.5,497.5,502.5,502.5,503.5,503.5,504.5,504.5,505.5,505.5,506.5,506.5,507.5,507.5,502.5,502.5,503.5,503.5,504.5,504.5,505.5,505.5,506.5,506.5,507.5,507.5,472.5,472.5,473.5,473.5,474.5,474.5,475.5,475.5,476.5,476.5,477.5,477.5,472.5,472.5,473.5,473.5,474.5,474.5,475.5,475.5,476.5,476.5,477.5,477.5,482.5,482.5,986.1,987.1,988.1,989.1,990.1,991.1,992.1,993.1,487.5,487.5,482.5,482.5,998.1,999.1,1000.1,1001.1,1002.1,1003.1,1004.1,1005.1,487.5,487.5,482.5,482.5,1010.1,1011.1,1012.1,1013.1,1014.1,1015.1,1016.1,1017.1,487.5,487.5,492.5,492.5,1022.1,1023.1,1024.1,1025.1,1026.1,1027.1,1028.1,1029.1,497.5,497.5,492.5,492.5,1034.1,1035.1,1036.1,1037.1,1038.1,1039.1,1040.1,1041.1,497.5,497.5,492.5,492.5,1046.1,1047.1,1048.1,1049.1,1050.1,1051.1,1052.1,1053.1,497.5,497.5,502.5,502.5,503.5,503.5,504.5,504.5,505.5,505.5,506.5,506.5,507.5,507.5,502.5,502.5,503.5,503.5,504.5,504.5,505.5,505.5,506.5,506.5,507.5,507.5,472.5,472.5,473.5,473.5,474.5,474.5,475.5,475.5,476.5,476.5,477.5,477.5,472.5,472.5,473.5,473.5,474.5,474.5,475.5,475.5,476.5,476.5,477.5,477.5,482.5,482.5,1106.1,1107.1,1108.1,1109.1,1110.1,1111.1,1112.1,1113.1,487.5,487.5,482.5,482.5,1118.1,1119.1,1120.1,1121.1,1122.1,1123.1,1124.1,1125.1,487.5,487.5,482.5,482.5,1130.1,1131.1,1132.1,1133.1,1134.1,1135.1,1136.1,1137.1,487.5,487.5,492.5,492.5,1142.1,1143.1,1144.1,1145.1,1146.1,1147.1,1148.1,1149.1,497.5,497.5,492.5,492.5,1154.1,1155.1,1156.1,1157.1,1158.1,1159.1,1160.1,1161.1,497.5,497.5,492.5,492.5,1166.1,1167.1,1168.1,1169.1,1170.1,1171.1,1172.1,1173.1,497.5,497.5,502.5,502.5,503.5,503.5,504.5,504.5,505.5,505.5,506.5,506.5,507.5,507.5,502.5,502.5,503.5,503.5,504.5,504.5,505.5,505.5,506.5,506.5,507.5,507.5,582.5,582.5,583.5,583.5,584.5,584.5,585.5,585.5,586.5,586.5,587.5,587.5,582.5,582.5,583.5,583.5,584.5,584.5,585.5,585.5,586.5,586.5,587.5,587.5,592.5,592.5,1226.1,1227.1,1228.1,1229.1,1230.1,1231.1,1232.1,1233.1,597.5,597.5,592.5,592.5,1238.1,1239.1,1240.1,1241.1,1242.1,1243.1,1244.1,1245.1,597.5,597.5,592.5,592.5,1250.1,1251.1,1252.1,1253.1,1254.1,1255.1,1256.1,1257.1,597.5,597.5,602.5,602.5,1262.1,1263.1,1264.1,1265.1,1266.1,1267.1,1268.1,1269.1,607.5,607.5,602.5,602.5,1274.1,1275.1,1276.1,1277.1,1278.1,1279.1,1280.1,1281.1,607.5,607.5,602.5,602.5,1286.1,1287.1,1288.1,1289.1,1290.1,1291.1,1292.1,1293.1,607.5,607.5,612.5,612.5,613.5,613.5,614.5,614.5,615.5,615.5,616.5,616.5,617.5,617.5,612.5,612.5,613.5,613.5,614.5,614.5,615.5,615.5,616.5,616.5,617.5,617.5,582.5,582.5,583.5,583.5,584.5,584.5,585.5,585.5,586.5,586.5,587.5,587.5,582.5,582.5,583.5,583.5,584.5,584.5,585.5,585.5,586.5,586.5,587.5,587.5,592.5,592.5,1346.1,1347.1,1348.1,1349.1,1350.1,1351.1,1352.1,1353.1,597.5,597.5,592.5,592.5,1358.1,1359.1,1360.1,1361.1,1362.1,1363.1,1364.1,1365.1,597.5,597.5,592.5,592.5,1370.1,1371.1,1372.1,1373.1,1374.1,1375.1,1376.1,1377.1,597.5,597.5,602.5,602.5,1382.1,1383.1,1384.1,1385.1,1386.1,1387.1,1388.1,1389.1,607.5,607.5,602.5,602.5,1394.1,1395.1,1396.1,1397.1,1398.1,1399.1,1400.1,1401.1,607.5,607.5,602.5,602.5,1406.1,1407.1,1408.1,1409.1,1410.1,1411.1,1412.1,1413.1,607.5,607.5,612.5,612.5,613.5,613.5,614.5,614.5,615.5,615.5,616.5,616.5,617.5,617.5,612.5,612.5,613.5,613.5,614.5,614.5,615.5,615.5,616.5,616.5,617.5,617.5,582.5,582.5,583.5,583.5,584.5,584.5,585.5,585.5,586.5,586.5,587.5,587.5,582.5,582.5,583.5,583.5,584.5,584.5,585.5,585.5,586.5,586.5,587.5,587.5,592.5,592.5,1466.1,1467.1,1468.1,1469.1,1470.1,1471.1,1472.1,1473.1,597.5,597.5,592.5,592.5,1478.1,1479.1,1480.1,1481.1,1482.1,1483.1,1484.1,1485.1,597.5,597.5,592.5,592.5,1490.1,1491.1,1492.1,1493.1,1494.1,1495.1,1496.1,1497.1,597.5,597.5,602.5,602.5,1502.1,1503.1,1504.1,1505.1,1506.1,1507.1,1508.1,1509.1,607.5,607.5,602.5,602.5,1514.1,1515.1,1516.1,1517.1,1518.1,1519.1,1520.1,1521.1,607.5,607.5,602.5,602.5,1526.1,1527.1,1528.1,1529.1,1530.1,1531.1,1532.1,1533.1,607.5,607.5,612.5,612.5,613.5,613.5,614.5,614.5,615.5,615.5,616.5,616.5,617.5,617.5,612.5,612.5,613.5,613.5,614.5,614.5,615.5,615.5,616.5,616.5,617.5,617.5,582.5,582.5,583.5,583.5,584.5,584.5,585.5,585.5,586.5,586.5,587.5,587.5,582.5,582.5,583.5,583.5,584.5,584.5,585.5,585.5,586.5,586.5,587.5,587.5,592.5,592.5,1586.1,1587.1,1588.1,1589.1,1590.1,1591.1,1592.1,1593.1,597.5,597.5,592.5,592.5,1598.1,1599.1,1600.1,1601.1,1602.1,1603.1,1604.1,1605.1,597.5,597.5,592.5,592.5,1610.1,1611.1,1612.1,1613.1,1614.1,1615.1,1616.1,1617.1,597.5,597.5,602.5,602.5,1622.1,1623.1,1624.1,1625.1,1626.1,1627.1,1628.1,1629.1,607.5,607.5,602.5,602.5,1634.1,1635.1,1636.1,1637.1,1638.1,1639.1,1640.1,1641.1,607.5,607.5,602.5,602.5,1646.1,1647.1,1648.1,1649.1,1650.1,1651.1,1652.1,1653.1,607.5,607.5,612.5,612.5,613.5,613.5,614.5,614.5,615.5,615.5,616.5,616.5,617.5,617.5,612.5,612.5,613.5,613.5,614.5,614.5,615.5,615.5,616.5,616.5,617.5,617.5]),1e-12))
15690         pass
15691
15692     def testSwig2AMR12(self):
15693         """ This test check the MEDCouplingAMRAttribute.projectTo method."""
15694         amr0=MEDCouplingCartesianAMRMesh("mesh",2,[11,11],[0.,0.],[1.,1.])
15695         amr0.addPatch([(3,8),(0,3)],[2,2])
15696         amr0.addPatch([(3,8),(3,6)],[2,2])
15697         att0=MEDCouplingAMRAttribute(amr0,[("YY",1)],2)
15698         att0.alloc()
15699         att0.getFieldOn(amr0,"YY").iota(0.01)
15700         att0.getFieldOn(amr0[0].getMesh(),"YY").iota(0.02)
15701         att0.getFieldOn(amr0[1].getMesh(),"YY").iota(0.03)
15702         amr1=MEDCouplingCartesianAMRMesh("mesh",2,[11,11],[0.,0.],[1.,1.])
15703         amr1.addPatch([(2,5),(1,4)],[2,2])
15704         att1=att0.projectTo(amr1)
15705         self.assertTrue(att1.getFieldOn(amr1,"YY").isEqualWithoutConsideringStr(att0.getFieldOn(amr0,"YY"),1e-12))
15706         self.assertTrue(att1.getFieldOn(amr1[0].getMesh(),"YY").isEqualWithoutConsideringStr(DataArrayDouble([31.01,31.01,32.01,32.01,33.01,33.01,34.01,34.01,35.01,35.01,31.01,31.01,32.01,32.01,33.01,33.01,34.01,34.01,35.01,35.01,45.01,45.01,46.01,46.01,58.02,59.02,60.02,61.02,49.01,49.01,45.01,45.01,46.01,46.01,72.02,73.02,74.02,75.02,49.01,49.01,59.01,59.01,60.01,60.01,86.02,87.02,88.02,89.02,63.01,63.01,59.01,59.01,60.01,60.01,100.02,101.02,102.02,103.02,63.01,63.01,73.01,73.01,74.01,74.01,30.03,31.03,32.03,33.03,77.01,77.01,73.01,73.01,74.01,74.01,44.03,45.03,46.03,47.03,77.01,77.01,87.01,87.01,88.01,88.01,89.01,89.01,90.01,90.01,91.01,91.01,87.01,87.01,88.01,88.01,89.01,89.01,90.01,90.01,91.01,91.01]),1e-12))
15707         #
15708         amr0=MEDCouplingCartesianAMRMesh("mesh",2,[11,11],[0.,0.],[1.,1.])
15709         amr0.addPatch([(2,5),(2,7)],[2,2])
15710         amr0.addPatch([(5,8),(2,7)],[2,2])
15711         att0=MEDCouplingAMRAttribute(amr0,[("YY",1)],2)
15712         att0.alloc()
15713         att0.getFieldOn(amr0,"YY").iota(0.01)
15714         att0.getFieldOn(amr0[0].getMesh(),"YY").iota(0.02)
15715         att0.getFieldOn(amr0[1].getMesh(),"YY").iota(0.03)
15716         amr1=MEDCouplingCartesianAMRMesh("mesh",2,[11,11],[0.,0.],[1.,1.])
15717         amr1.addPatch([(3,6),(2,7)],[2,2])
15718         amr1.addPatch([(6,9),(2,7)],[2,2])
15719         att1=att0.projectTo(amr1)
15720         self.assertTrue(att1.getFieldOn(amr1,"YY").isEqual(att0.getFieldOn(amr0,"YY"),1e-12))
15721         self.assertTrue(att1.getFieldOn(amr1[0].getMesh(),"YY").isEqualWithoutConsideringStr(DataArrayDouble([46.01,46.01,47.01,47.01,48.01,48.01,49.01,49.01,50.01,50.01,46.01,46.01,47.01,47.01,48.01,48.01,49.01,49.01,50.01,50.01,60.01,60.01,24.02,25.02,26.02,27.02,22.03,23.03,64.01,64.01,60.01,60.01,34.02,35.02,36.02,37.02,32.03,33.03,64.01,64.01,74.01,74.01,44.02,45.02,46.02,47.02,42.03,43.03,78.01,78.01,74.01,74.01,54.02,55.02,56.02,57.02,52.03,53.03,78.01,78.01,88.01,88.01,64.02,65.02,66.02,67.02,62.03,63.03,92.01,92.01,88.01,88.01,74.02,75.02,76.02,77.02,72.03,73.03,92.01,92.01,102.01,102.01,84.02,85.02,86.02,87.02,82.03,83.03,106.01,106.01,102.01,102.01,94.02,95.02,96.02,97.02,92.03,93.03,106.01,106.01,116.01,116.01,104.02,105.02,106.02,107.02,102.03,103.03,120.01,120.01,116.01,116.01,114.02,115.02,116.02,117.02,112.03,113.03,120.01,120.01,130.01,130.01,131.01,131.01,132.01,132.01,133.01,133.01,134.01,134.01,130.01,130.01,131.01,131.01,132.01,132.01,133.01,133.01,134.01,134.01]),1e-12))
15722         self.assertTrue(att1.getFieldOn(amr1[1].getMesh(),"YY").isEqualWithoutConsideringStr(DataArrayDouble([49.01,49.01,50.01,50.01,51.01,51.01,52.01,52.01,53.01,53.01,49.01,49.01,50.01,50.01,51.01,51.01,52.01,52.01,53.01,53.01,63.01,63.01,24.03,25.03,26.03,27.03,66.01,66.01,67.01,67.01,63.01,63.01,34.03,35.03,36.03,37.03,66.01,66.01,67.01,67.01,77.01,77.01,44.03,45.03,46.03,47.03,80.01,80.01,81.01,81.01,77.01,77.01,54.03,55.03,56.03,57.03,80.01,80.01,81.01,81.01,91.01,91.01,64.03,65.03,66.03,67.03,94.01,94.01,95.01,95.01,91.01,91.01,74.03,75.03,76.03,77.03,94.01,94.01,95.01,95.01,105.01,105.01,84.03,85.03,86.03,87.03,108.01,108.01,109.01,109.01,105.01,105.01,94.03,95.03,96.03,97.03,108.01,108.01,109.01,109.01,119.01,119.01,104.03,105.03,106.03,107.03,122.01,122.01,123.01,123.01,119.01,119.01,114.03,115.03,116.03,117.03,122.01,122.01,123.01,123.01,133.01,133.01,134.01,134.01,135.01,135.01,136.01,136.01,137.01,137.01,133.01,133.01,134.01,134.01,135.01,135.01,136.01,136.01,137.01,137.01]),1e-12))
15723         pass
15724
15725     def testSwig2AMR13(self):
15726         """ non regression test"""
15727         for fact,len1,len2 in [([2,2],64,48),([3,3],100,70),([4,4],144,96)]:
15728             amr=MEDCouplingCartesianAMRMesh("mesh",2,[5,5],[0.,0.],[1.,1.])
15729             amr.addPatch([(1,3),(0,2)],fact)
15730             amr.addPatch([(1,3),(3,4)],fact)
15731             att=MEDCouplingAMRAttribute(amr,[("YY",1)],2)
15732             att.alloc()
15733             att.getFieldOn(amr,"YY").iota(0.1)
15734             att.getFieldOn(amr[0].getMesh(),"YY").iota(0.2)
15735             att.getFieldOn(amr[1].getMesh(),"YY").iota(0.3)
15736             att.synchronizeAllGhostZonesOfDirectChidrenOf(amr)
15737             exp=DataArrayDouble(64) ; exp.iota(0.1)
15738             self.assertTrue(att.getFieldOn(amr,"YY").isEqualWithoutConsideringStr(exp,1e-12))
15739             exp0=DataArrayDouble(len1) ; exp0.iota(0.2)
15740             self.assertTrue(att.getFieldOn(amr[0].getMesh(),"YY").isEqualWithoutConsideringStr(exp0,1e-12))
15741             exp1=DataArrayDouble(len2) ; exp1.iota(0.3)
15742             self.assertTrue(att.getFieldOn(amr[1].getMesh(),"YY").isEqualWithoutConsideringStr(exp1,1e-12))
15743             pass
15744         pass
15745
15746     def testSwig2AMR14(self):
15747         """ non regression linked to VTHB write."""
15748         fact=[2,2] ; fact2=[3,3]
15749         amr=MEDCouplingCartesianAMRMesh("mesh",2,[5,5],[0.,0.],[1.,1.])
15750         amr.addPatch([(1,3),(0,2)],fact)
15751         amr.addPatch([(1,3),(3,4)],fact)
15752         amr[0].addPatch([(1,3),(1,3)],fact2)
15753         amr[1].addPatch([(1,3),(1,2)],fact2)
15754         att=MEDCouplingAMRAttribute(amr,[("YY",1)],2)
15755         att.alloc()
15756         att.getFieldOn(amr,"YY").iota(0.1)
15757         att.getFieldOn(amr[0].getMesh(),"YY").iota(0.2)
15758         att.getFieldOn(amr[1].getMesh(),"YY").iota(0.3)
15759         att.getFieldOn(amr[0][0].getMesh(),"YY").iota(0.4)
15760         att.getFieldOn(amr[1][0].getMesh(),"YY").iota(0.5)
15761         self.assertEqual(amr[0].getBLTRRangeRelativeToGF(),[(2,6),(0,4)])
15762         self.assertEqual(amr[1].getBLTRRangeRelativeToGF(),[(2,6),(6,8)])
15763         self.assertEqual(amr[0][0].getBLTRRangeRelativeToGF(),[(9,15),(3,9)])
15764         self.assertEqual(amr[1][0].getBLTRRangeRelativeToGF(),[(9,15),(21,24)])
15765         pass
15766
15767     def testSwig2Intersect2DMeshWith1DLine1(self):
15768         """A basic test with no colinearity between m1 and m2."""
15769         i=MEDCouplingIMesh("mesh",2,[5,5],[0.,0.],[1.,1.])
15770         m1=i.buildUnstructured()
15771         m2=MEDCouplingUMesh("mesh",1) ; m2.setCoords(DataArrayDouble([0.75,3.5,3.75,1.75],2,2)) ; m2.allocateCells() ; m2.insertNextCell(NORM_SEG2,[0,1])
15772         a,b,c,d=MEDCouplingUMesh.Intersect2DMeshWith1DLine(m1,m2,1e-12)
15773         self.assertTrue(a.getNodalConnectivity().isEqual(DataArrayInt([4,1,0,5,6,4,2,1,6,7,4,3,2,7,8,4,4,3,8,9,4,6,5,10,11,4,7,6,11,12,4,8,7,12,13,4,11,10,15,16,4,18,17,22,23,4,19,18,23,24,5,16,15,20,21,31,5,21,22,17,28,31,5,16,31,28,5,17,29,28,5,12,11,16,28,29,5,17,18,30,29,5,13,12,29,30,5,18,19,14,27,30,5,13,30,27,5,9,8,13,27,14])))
15774         self.assertTrue(b.getNodalConnectivity().isEqual(DataArrayInt([1,25,31,1,31,28,1,28,29,1,29,30,1,30,27,1,27,26])))
15775         self.assertTrue(a.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5,10,15,20,25,30,35,40,45,50,56,62,66,70,76,81,86,92,96,102])))
15776         self.assertTrue(b.getNodalConnectivityIndex().isEqual(DataArrayInt([0,3,6,9,12,15,18])))
15777         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
15778         self.assertTrue(a.getCoords()[:25].isEqual(m1.getCoords(),1e-12))
15779         self.assertTrue(a.getCoords()[25:25+2].isEqualWithoutConsideringStr(m2.getCoords(),1e-12))
15780         self.assertTrue(a.getCoords()[27:].isEqualWithoutConsideringStr(DataArrayDouble([(3.3214285714285716,2.),(1.6071428571428572,3.),(2.,2.7708333333333335),(3.,2.1875),(1.,3.354166666666667)]),1e-12))
15781         self.assertTrue(c.isEqual(DataArrayInt([0,1,2,3,4,5,6,8,14,15,12,13,13,9,9,10,10,11,11,7])))
15782         self.assertTrue(d.isEqual(DataArrayInt([(10,10),(11,12),(13,14),(15,16),(17,18),(19,19)])))
15783         pass
15784
15785     def testSwig2Intersect2DMeshWith1DLine2(self):
15786         """A basic test with colinearity between m1 and m2 and the last cell of m2 outside m1."""
15787         i=MEDCouplingIMesh("mesh",2,[5,5],[0.,0.],[1.,1.])
15788         m1=i.buildUnstructured()
15789         m2=MEDCouplingUMesh("mesh",1) ; m2.setCoords(DataArrayDouble([0.5,2.,2.25,2.,2.5,2.,2.75,2.,3.,2.,4.,2.,5.,2.],7,2)) ; m2.allocateCells()
15790         for i in xrange(6):
15791             m2.insertNextCell(NORM_SEG2,[i,i+1])
15792             pass
15793         a,b,c,d=MEDCouplingUMesh.Intersect2DMeshWith1DLine(m1,m2,1e-12)
15794         self.assertTrue(a.getNodalConnectivity().isEqual(DataArrayInt([4,1,0,5,6,4,2,1,6,7,4,3,2,7,8,4,4,3,8,9,4,16,15,20,21,4,17,16,21,22,4,18,17,22,23,4,19,18,23,24,5,6,5,10,25,11,5,7,6,11,12,5,8,7,12,26,27,28,13,5,9,8,13,14,5,11,25,10,15,16,5,12,11,16,17,5,13,28,27,26,12,17,18,5,14,13,18,19])))
15795         self.assertTrue(a.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5,10,15,20,25,30,35,40,46,51,59,64,70,75,83,88])))
15796         self.assertTrue(b.getNodalConnectivity().isEqual(DataArrayInt([1,25,11,1,11,12,1,12,26,1,26,27,1,27,28,1,28,13,1,13,14,1,14,31])))
15797         self.assertTrue(b.getNodalConnectivityIndex().isEqual(DataArrayInt([0,3,6,9,12,15,18,21,24])))
15798         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
15799         self.assertTrue(a.getCoords()[:25].isEqual(m1.getCoords(),1e-12))
15800         self.assertTrue(a.getCoords()[25:].isEqualWithoutConsideringStr(m2.getCoords(),1e-12))
15801         self.assertTrue(c.isEqual(DataArrayInt([0,1,2,3,12,13,14,15,4,5,6,7,8,9,10,11])))
15802         self.assertTrue(d.isEqual(DataArrayInt([(12,8),(13,9),(14,10),(14,10),(14,10),(14,10),(15,11),(-1,-1)])))
15803         pass
15804
15805     def testSwig2Intersect2DMeshWith1DLine3(self):
15806         """m2 fully included in cell #12. of m1"""
15807         i=MEDCouplingIMesh("mesh",2,[5,5],[0.,0.],[1.,1.])
15808         m1=i.buildUnstructured()
15809         m2=MEDCouplingUMesh("mesh",1) ; m2.setCoords(DataArrayDouble([(0.75,3.25),(0.5,3.5),(0.25,3.25)])) ; m2.allocateCells()
15810         for i in xrange(2):
15811             m2.insertNextCell(NORM_SEG2,[i,i+1])
15812             pass
15813         a,b,c,d=MEDCouplingUMesh.Intersect2DMeshWith1DLine(m1,m2,1e-12)
15814         self.assertTrue(a.getNodalConnectivity().isEqual(DataArrayInt([4,1,0,5,6,4,2,1,6,7,4,3,2,7,8,4,4,3,8,9,4,6,5,10,11,4,7,6,11,12,4,8,7,12,13,4,9,8,13,14,4,11,10,15,16,4,12,11,16,17,4,13,12,17,18,4,14,13,18,19,4,17,16,21,22,4,18,17,22,23,4,19,18,23,24,5,16,15,20,21])))
15815         self.assertTrue(a.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5,10,15,20,25,30,35,40,45,50,55,60,65,70,75,80])))
15816         self.assertTrue(b.getNodalConnectivity().isEqual(DataArrayInt([1,25,26,1,26,27])))
15817         self.assertTrue(b.getNodalConnectivityIndex().isEqual(DataArrayInt([0,3,6])))
15818         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
15819         self.assertTrue(a.getCoords()[:25].isEqual(m1.getCoords(),1e-12))
15820         self.assertTrue(a.getCoords()[25:].isEqualWithoutConsideringStr(m2.getCoords(),1e-12))
15821         self.assertTrue(c.isEqual(DataArrayInt([0,1,2,3,4,5,6,7,8,9,10,11,13,14,15,12])))
15822         self.assertTrue(d.isEqual(DataArrayInt([(15,15),(15,15)])))
15823         pass
15824
15825     def testSwig2Intersect2DMeshWith1DLine4(self):
15826         """A special case where an edge is simultaneously a cut and colinear. This tests also checks negative values in descending edges of m1."""
15827         i=MEDCouplingIMesh("mesh",2,[5,5],[0.,0.],[1.,1.])
15828         m1=i.buildUnstructured()
15829         part=DataArrayInt([0,1,2,3,4,7,8,11,12,13,14,15])
15830         m1_1=m1[part]
15831         m1_2=m1[part.buildComplement(m1.getNumberOfCells())]
15832         m1=MEDCouplingUMesh.MergeUMeshesOnSameCoords(m1_1,m1_2.buildSpreadZonesWithPoly())
15833         m1.zipCoords()
15834         m2=MEDCouplingUMesh("mesh",1) ; m2.setCoords(DataArrayDouble([(3.5,2.),(0.5,2.)])) ; m2.allocateCells()
15835         m2.insertNextCell(NORM_SEG2,[0,1])
15836         a,b,c,d=MEDCouplingUMesh.Intersect2DMeshWith1DLine(m1,m2,1e-12)
15837         self.assertTrue(a.getNodalConnectivity().isEqual(DataArrayInt([4,1,0,5,6,4,2,1,6,7,4,3,2,7,8,4,4,3,8,9,4,15,14,19,20,4,16,15,20,21,4,17,16,21,22,4,18,17,22,23,5,6,5,10,25,11,5,9,8,12,24,13,5,11,25,10,14,15,5,13,24,12,17,18,5,8,7,6,11,12,5,15,16,17,12,11])))
15838         self.assertTrue(a.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5,10,15,20,25,30,35,40,46,52,58,64,70,76])))
15839         self.assertTrue(b.getNodalConnectivity().isEqual(DataArrayInt([1,24,12,1,12,11,1,11,25])))
15840         self.assertTrue(b.getNodalConnectivityIndex().isEqual(DataArrayInt([0,3,6,9])))
15841         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
15842         self.assertTrue(a.getCoords()[:24].isEqual(m1.getCoords(),1e-12))
15843         self.assertTrue(a.getCoords()[24:].isEqualWithoutConsideringStr(m2.getCoords(),1e-12))
15844         self.assertTrue(c.isEqual(DataArrayInt([0,1,2,3,8,9,10,11,4,5,6,7,12,12])))
15845         self.assertTrue(d.isEqual(DataArrayInt([(9,11),(12,13),(8,10)])))
15846         pass
15847
15848     def testSwig2Intersect2DMeshWith1DLine5(self):
15849         """A test focusing on a special case for cut."""
15850         i=MEDCouplingIMesh("mesh",2,[5,5],[0.,0.],[1.,1.])
15851         m1=i.buildUnstructured()
15852         m2=MEDCouplingUMesh("mesh",1) ; m2.setCoords(DataArrayDouble([(1.,0.),(3.,2.),(1.,4.)])) ; m2.allocateCells()
15853         for i in xrange(2):
15854             m2.insertNextCell(NORM_SEG2,[i,i+1])
15855             pass
15856         a,b,c,d=MEDCouplingUMesh.Intersect2DMeshWith1DLine(m1,m2,1e-12)
15857         self.assertTrue(a.getNodalConnectivity().isEqual(DataArrayInt([4,1,0,5,6,4,3,2,7,8,4,4,3,8,9,4,6,5,10,11,4,7,6,11,12,4,9,8,13,14,4,11,10,15,16,4,12,11,16,17,4,14,13,18,19,4,16,15,20,21,4,18,17,22,23,4,19,18,23,24,5,6,7,1,5,2,1,7,5,12,13,7,5,8,7,13,5,12,17,13,5,18,13,17,5,16,21,17,5,22,17,21])))
15858         self.assertTrue(a.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5,10,15,20,25,30,35,40,45,50,55,60,64,68,72,76,80,84,88,92])))
15859         self.assertTrue(b.getNodalConnectivity().isEqual(DataArrayInt([1,1,7,1,7,13,1,13,17,1,17,21])))
15860         self.assertTrue(b.getNodalConnectivityIndex().isEqual(DataArrayInt([0,3,6,9,12])))
15861         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
15862         self.assertTrue(a.getCoords()[:25].isEqual(m1.getCoords(),1e-12))
15863         self.assertTrue(a.getCoords()[25:].isEqualWithoutConsideringStr(m2.getCoords(),1e-12))
15864         self.assertTrue(c.isEqual(DataArrayInt([0,2,3,4,5,7,8,9,11,12,14,15,1,1,6,6,10,10,13,13])))
15865         self.assertTrue(d.isEqual(DataArrayInt([(12,13),(14,15),(16,17),(18,19)])))
15866         pass
15867
15868     def testIntersect2DMeshWith1DLine6(self):
15869         """ Basic test for Intersect2DMeshWith1DLine: a vertical line intersecting a square. """
15870         m1c = MEDCouplingCMesh()
15871         coordX = DataArrayDouble([-1., 1., 2])
15872         m1c.setCoordsAt(0,coordX)
15873         coordY = DataArrayDouble([0., 2.])
15874         m1c.setCoordsAt(1,coordY);
15875         m1 = m1c.buildUnstructured()
15876
15877         # A simple line:
15878         m2 = MEDCouplingUMesh("bla", 1)
15879         coord2 = DataArrayDouble([0.,-1.0,  0.,1.,  0.,3.,  0.5,2.2], 4, 2)
15880         conn2 = DataArrayInt([NORM_SEG2,0,1,NORM_SEG3,1,2,3])
15881         connI2 = DataArrayInt([0,3,7])
15882         m2.setCoords(coord2)
15883         m2.setConnectivity(conn2, connI2)
15884
15885         # End of construction of input meshes m1bis and m2 -> start of specific part of the test
15886         a,b,c,d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(m1, m2, 1e-10)
15887         self.assertTrue(a.getNodalConnectivity().isEqual(DataArrayInt([4,2,1,4,5,32,0,3,11,7,10,14,15,16,17,18,32,4,1,10,7,11,19,20,21,22,23])))
15888         self.assertTrue(a.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5,16,27])))
15889         self.assertTrue(b.getNodalConnectivity().isEqual(DataArrayInt([1,6,10,1,10,7,2,7,11,12,2,11,8,13])))
15890         self.assertTrue(b.getNodalConnectivityIndex().isEqual(DataArrayInt([0,3,6,10,14])))
15891         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
15892         self.assertTrue(a.getCoords()[:6].isEqual(m1.getCoords(),1e-12))
15893         self.assertTrue(a.getCoords()[6:10].isEqual(m2.getCoords(),1e-12))
15894         self.assertTrue(a.getCoords()[10:].isEqual(DataArrayDouble([(0.,0.),(0.5164175471673584,2.),(0.3796918047064557,1.43726403104512),(0.3796918047064557,2.56273596895488),(-1.,1.),(-0.24179122641632078,2.),(0.3796918047064558,1.4372640310451201),(0.,0.5),(-0.5,0.),(1.,1.),(0.5,0.),(0.,0.5),(0.3796918047064558,1.4372640310451201),(0.7582087735836792,2.)]),1e-12))
15895         self.assertTrue(c.isEqual(DataArrayInt([1,0,0])))
15896         self.assertTrue(d.isEqual(DataArrayInt([(-1,-1),(1,2),(1,2),(-1,-1)])))
15897         pass
15898
15899     def testSwig2Intersect2DMeshWith1DLine7(self):
15900         """ Star pattern (a triangle intersecting another one upside down) """
15901         coords1 = DataArrayDouble([-2.,1.,   2.,1.,  0.,-2.], 3,2)
15902         coords2 = DataArrayDouble([0.,2.,   2.,-1.,  -2.,-1.,  0.,3.], 4,2)
15903         m1 = MEDCouplingUMesh("triangle", 2)
15904         m2 = MEDCouplingUMesh("tri_line", 1)
15905         m1.setCoords(coords1)
15906         m2.setCoords(coords2)
15907         m1.setConnectivity(DataArrayInt([NORM_TRI3, 0,1,2]), DataArrayInt([0,4]))
15908         m2.setConnectivity(DataArrayInt([NORM_SEG2,0,1,NORM_SEG2,1,2,NORM_SEG2,2,3]), DataArrayInt([0,3,6,9]))
15909     # End of construction of input meshes m1bis and m2 -> start of specific part of the test
15910         a,b,c,d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(m1, m2, 1e-10)
15911         self.assertTrue(a.getNodalConnectivity().isEqual(DataArrayInt([5,1,9,7,5,2,11,10,5,0,8,12,5,7,9,10,11,12,8])))
15912         self.assertTrue(a.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4,8,12,19])))
15913         self.assertTrue(b.getNodalConnectivity().isEqual(DataArrayInt([1,3,7,1,7,9,1,9,4,1,4,10,1,10,11,1,11,5,1,5,12,1,12,8,1,8,6])))
15914         self.assertTrue(b.getNodalConnectivityIndex().isEqual(DataArrayInt([0,3,6,9,12,15,18,21,24,27])))
15915         self.assertTrue(a.getCoords()[:3].isEqual(m1.getCoords(),1e-12))
15916         self.assertTrue(a.getCoords()[3:7].isEqual(m2.getCoords(),1e-12))
15917         self.assertTrue(a.getCoords()[7:].isEqual(DataArrayDouble([(0.6666666666666666,1.),(-1.,1.),(1.3333333333333333,1.1102230246251565e-16),(0.6666666666666665,-0.9999999999999996),(-0.6666666666666667,-1.),(-1.4285714285714284,0.14285714285714302)]),1e-12))
15918         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
15919         self.assertTrue(c.isEqual(DataArrayInt([0,0,0,0])))
15920         self.assertTrue(d.isEqual(DataArrayInt([(-1,-1),(0,3),(-1,-1),(-1,-1),(1,3),(-1,-1),(-1,-1),(2,3),(-1,-1)])))
15921         pass
15922
15923     def testSwig2Intersect2DMeshWith1DLine8(self):
15924         """ Line pieces ending (or fully located) in the middle of a cell """
15925         m1c = MEDCouplingCMesh()
15926         m1c.setCoordsAt(0,DataArrayDouble([-1., 1.]))
15927         m1c.setCoordsAt(1,DataArrayDouble([-1., 1.]));
15928         m1 = m1c.buildUnstructured()
15929         coords2 = DataArrayDouble([0.,0.,  0.,1.5, -1.5,0.,  0.5,0.0,  0.0,-0.5, 1.1,-0.6], 6,2)
15930         m2 = MEDCouplingUMesh("piecewise_line", 1)
15931         m2.setCoords(coords2)
15932         c = DataArrayInt([NORM_SEG2,2,1, NORM_SEG2,1,4, NORM_SEG2,4,3,  NORM_SEG2,3,5])
15933         cI = DataArrayInt([0,3,6,9,12])
15934         m2.setConnectivity(c, cI)
15935         a,b,c,d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(m1, m2, 1e-10)
15936         self.assertTrue(a.getNodalConnectivity().isEqual(DataArrayInt([5,2,11,10,5,3,13,7,8,12,5,1,0,10,11,12,8,7,13])))
15937         self.assertTrue(a.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4,10,19])))
15938         self.assertTrue(b.getNodalConnectivity().isEqual(DataArrayInt([1,6,10,1,10,11,1,11,5,1,5,12,1,12,8,1,8,7,1,7,13,1,13,9])))
15939         self.assertTrue(b.getNodalConnectivityIndex().isEqual(DataArrayInt([0,3,6,9,12,15,18,21,24])))
15940         self.assertTrue(a.getCoords()[:4].isEqual(m1.getCoords(),1e-12))
15941         self.assertTrue(a.getCoords()[4:10].isEqual(m2.getCoords(),1e-12))
15942         self.assertTrue(a.getCoords()[10:].isEqual(DataArrayDouble([(-1.,0.5),(-0.5,1.),(0.,1.),(1.,-0.5)]),1e-12))
15943         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
15944         self.assertTrue(c.isEqual(DataArrayInt([0,0,0])))
15945         self.assertTrue(d.isEqual(DataArrayInt([(-1,-1),(0,2),(-1,-1),(-1,-1),(1,2),(1,2),(1,2),(-1,-1)])))
15946         pass
15947
15948     def testSwig2Intersect2DMeshWith1DLine9(self):
15949         """ Intersection with a line whose connectivity is not consecutive """
15950         m1c = MEDCouplingCMesh()
15951         coordX = DataArrayDouble([-1., 1., 2])
15952         m1c.setCoordsAt(0,coordX)
15953         coordY = DataArrayDouble([0., 2.])
15954         m1c.setCoordsAt(1,coordY);
15955         m1 = m1c.buildUnstructured()
15956         # A simple line:
15957         m2 = MEDCouplingUMesh("bla", 1)
15958         coord2 = DataArrayDouble([0.,1.5,  0.5,1.,  0.0,0.5,  0.0,3.0,  0.0,-1.0], 5, 2)
15959         conn2 = DataArrayInt([NORM_SEG2,3,0,NORM_SEG3,0,2,1,NORM_SEG2,2,4])
15960         connI2 = DataArrayInt([0,3,7,10])
15961         m2.setCoords(coord2)
15962         m2.setConnectivity(conn2, connI2)
15963         # End of construction of input meshes m1bis and m2 -> start of specific part of the test
15964         a,b,c,d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(m1, m2, 1e-10)
15965         self.assertTrue(a.getNodalConnectivity().isEqual(DataArrayInt([4,2,1,4,5,32,4,1,11,8,6,12,14,15,16,17,18,19,32,0,3,12,6,8,11,20,21,22,23,24,25])))
15966         self.assertTrue(a.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5,18,31])))
15967         self.assertTrue(b.getNodalConnectivity().isEqual(DataArrayInt([1,9,12,1,12,6,2,6,8,13,1,8,11,1,11,10])))
15968         self.assertTrue(b.getNodalConnectivityIndex().isEqual(DataArrayInt([0,3,6,10,13,16])))
15969         self.assertTrue(a.getCoords()[:6].isEqual(m1.getCoords(),1e-12))
15970         self.assertTrue(a.getCoords()[6:11].isEqual(m2.getCoords(),1e-12))
15971         self.assertTrue(a.getCoords()[11:].isEqual(DataArrayDouble([(0.,0.),(0.,2.),(0.5,1.),(1.,1.),(0.5,0.),(0.,0.25),(0.5,1.),(0.,1.75),(0.5,2.),(-1.,1.),(-0.5,2.),(0.,1.75),(0.5,1.),(0.,0.25),(-0.5,0.)]),1e-12))
15972         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
15973         self.assertTrue(c.isEqual(DataArrayInt([1,0,0])))
15974         self.assertTrue(d.isEqual(DataArrayInt([(-1,-1),(1,2),(1,2),(1,2),(-1,-1)])))
15975         pass
15976
15977     def testSwig2Intersect2DMeshWith1DLine10(self):
15978         """ Intersection between a circle and various lines """
15979         eps = 1.0e-8
15980         m_circ = MEDCouplingDataForTest.buildCircle2(0.0, 0.0, 2.0)
15981         coords = [0.0,3.0,0.0,-3.0]
15982         connec = [0,1]
15983         m_line = MEDCouplingUMesh("seg", 1)
15984         m_line.allocateCells(1)
15985         meshCoords = DataArrayDouble.New(coords, len(coords)/2, 2)
15986         m_line.setCoords(meshCoords)
15987         m_line.insertNextCell(NORM_SEG2, connec)
15988         a, b, c, d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(m_circ, m_line, eps)
15989         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
15990         self.assertTrue(a.getCoords()[:m_circ.getNumberOfNodes()].isEqual(m_circ.getCoords(),1e-12))
15991         self.assertTrue(a.getCoords()[m_circ.getNumberOfNodes():m_circ.getNumberOfNodes()+m_line.getNumberOfNodes()].isEqual(m_line.getCoords(),1e-12))
15992         self.assertTrue(a.getCoords().isEqual(DataArrayDouble([(2.,0.),(1.4142135623730951,1.414213562373095),(0.,2.),(-1.414213562373095,1.4142135623730951),(-2.,0.),(-1.4142135623730954,-1.414213562373095),(0.,-2.),(1.4142135623730947,-1.4142135623730954),(0.,3.),(0.,-3.),(0.,-2.),(0.,2.),(2.,0.),(0.7653668647301797,-1.8477590650225735),(0.,0.),(0.7653668647301797,1.8477590650225735),(-2,0.),(-0.7653668647301795,1.8477590650225735),(0.,0.),(-0.7653668647301795,-1.8477590650225735)]),1e-12))
15993         self.assertEqual([32,1,7,10,11,12,13,14,15,32,5,3,11,10,16,17,18,19],a.getNodalConnectivity().getValues())
15994         self.assertEqual([0,9,18],  a.getNodalConnectivityIndex().getValues())
15995         self.assertEqual([1,8,11,1,11,10,1,10,9],b.getNodalConnectivity().getValues())
15996         self.assertEqual([0,3,6,9],b.getNodalConnectivityIndex().getValues())
15997         self.assertTrue(a.getCoords()[:8].isEqual(m_circ.getCoords(),1e-12))
15998         self.assertTrue(a.getCoords()[8:10].isEqual(m_line.getCoords(),1e-12))
15999         coo_tgt = DataArrayDouble([2.,0.,1.4142135623730951,1.414213562373095,1.2246467991473532e-16,2.,-1.414213562373095,1.4142135623730951,-2.,0.,-1.4142135623730954,-1.414213562373095,-3.6739403974420594e-16,-2.,1.4142135623730947,-1.4142135623730954,0.,3.,0.,-3.,0.,-2.,0.,2.,2.,0.,0.7653668647301797,-1.8477590650225735,0.,0.,0.7653668647301797,1.8477590650225735,-2.,0.,-0.7653668647301795,1.8477590650225735,0.,0.,-0.7653668647301795,-1.8477590650225735])
16000         self.assertTrue(a.getCoords().isEqualWithoutConsideringStr(coo_tgt,1.0e-12))
16001         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
16002         self.assertEqual([0,0],c.getValues())
16003         self.assertEqual([-1,-1,0,1,-1,-1],d.getValues())
16004
16005     def testSwig2Intersect2DMeshWith1DLine11(self):
16006         """ Quad line re-entering a square cell """
16007         eps = 1.0e-8
16008         m = MEDCouplingUMesh("box", 2)
16009         m.setCoords(DataArrayDouble([-1., -1., -1., 1., 1., 1., 1., -1.0],4,2))
16010         c, cI = [NORM_POLYGON, 0, 1, 2, 3], [0, 5]
16011         m.setConnectivity(DataArrayInt(c), DataArrayInt(cI))
16012         m.checkCoherency()
16013         coords2 = [0., 1.3, -1.3, 0., -0.6, 0.6, 0., -1.3, -0.5, -0.5]
16014         connec2, cI2 = [NORM_SEG3, 0, 1, 2, NORM_SEG3, 1, 3, 4], [0,4,8]
16015         m_line = MEDCouplingUMesh("seg", 1)
16016         m_line.setCoords(DataArrayDouble(coords2, len(coords2)/2, 2))
16017         m_line.setConnectivity(DataArrayInt(connec2), DataArrayInt(cI2))
16018         a, b, c, d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(m, m_line, eps)
16019         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
16020         self.assertTrue(a.getCoords()[:m.getNumberOfNodes()].isEqual(m.getCoords(),1e-12))
16021         self.assertTrue(a.getCoords()[m.getNumberOfNodes():m.getNumberOfNodes()+m_line.getNumberOfNodes()].isEqual(m_line.getCoords(),1e-12))
16022         self.assertTrue(a.getCoords().isEqual(DataArrayDouble([(-1.,-1.),(-1.,1.),(1.,1.),(1.,-1.),(0.,1.3),(-1.3,0.),(-0.6,0.6),(0.,-1.3),(-0.5,-0.5),(-1.,0.23453685964236054),(-1.,-0.13033276368660177),(-0.2345368596423598,1.),(-0.1303327636866019,-1.),(-0.11489196370692323,1.1481421036683868),(-0.6,0.6),(-1.1481421036683859,0.11489196370692323),(-1.147455889106615,-0.0593103465193594),(-0.5,-0.5),(-0.0593103465193594,-1.147455889106615),(1.,0.),(0.4348336181566991,-1.),(-0.5651663818433009,-1.),(-1.,-0.5651663818433009),(-1.,0.05210204797787939),(-0.6,0.6),(0.3827315701788201,1.),(-0.6172684298211799,1.),(-0.6,0.6),(-1.,0.6172684298211802),(-0.6,0.6),(0.3827315701788201,1.),(1.,0.),(0.4348336181566991,-1.),(-0.5,-0.5),(-1.,0.05210204797787939),(-1.,-0.5651663818433009),(-0.5,-0.5),(-0.5651663818433009,-1.)]),1e-12))
16023         self.assertEqual([32,9,11,2,3,12,10,29,30,31,32,33,34,32,0,10,12,35,36,37,32,1,11,9,26,27,28],a.getNodalConnectivity().getValues())
16024         self.assertEqual([0,13,20,27],a.getNodalConnectivityIndex().getValues())
16025         self.assertEqual([2,4,11,13,2,11,9,14,2,9,5,15,2,5,10,16,2,10,12,17,2,12,7,18],b.getNodalConnectivity().getValues())
16026         self.assertEqual([0,4,8,12,16,20,24],b.getNodalConnectivityIndex().getValues())
16027         self.assertTrue(a.getCoords()[:4].isEqual(m.getCoords(),1e-12))
16028         self.assertTrue(a.getCoords()[4:9].isEqual(m_line.getCoords(),1e-12))
16029         self.assertTrue(DataArrayInt([0,0,0]).isEqual(c))
16030         self.assertTrue(DataArrayInt([(-1,-1),(0,2),(-1,-1),(-1,-1),(0,1),(-1,-1)]).isEqual(d))
16031         pass
16032
16033     def testSwig2Intersect2DMeshWith1DLine12(self):
16034         """ Two squares one in the other intersected by an horizontal line """
16035         eps = 1.0e-8
16036         m = MEDCouplingUMesh("boxbox", 2)
16037         m.setCoords(DataArrayDouble([-0.5,-0.5,-0.5,0.5,0.5,0.5,0.5,-0.5,-0.25,-0.25,-0.25,0.25,0.25,0.25,0.25,-0.25],8,2))
16038         c = [NORM_POLYGON, 4, 5, 6, 7, NORM_POLYGON, 0, 1, 5, 4, NORM_POLYGON, 1, 2, 3, 0, 4, 7, 6, 5]
16039         cI = [0, 5, 10, 19]
16040         m.setConnectivity(DataArrayInt(c), DataArrayInt(cI))
16041         m.checkCoherency()
16042         coords2 = [-1., 0.25, 1., 0.25]
16043         connec2, cI2 = [NORM_SEG2, 0, 1], [0,3]
16044         m_line = MEDCouplingUMesh.New("seg", 1)
16045         m_line.setCoords(DataArrayDouble(coords2, len(coords2)/2, 2))
16046         m_line.setConnectivity(DataArrayInt(connec2), DataArrayInt(cI2))
16047         m_line2 = m_line.deepCpy()
16048         m2 = m.deepCpy()
16049         a, b, c, d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(m, m_line, eps)
16050         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
16051         self.assertTrue(a.getCoords()[:m.getNumberOfNodes()].isEqual(m.getCoords(),1e-12))
16052         self.assertTrue(a.getCoords()[m.getNumberOfNodes():m.getNumberOfNodes()+m_line.getNumberOfNodes()].isEqual(m_line.getCoords(),1e-12))
16053         self.assertTrue(a.getCoords().isEqual(DataArrayDouble([(-0.5,-0.5),(-0.5,0.5),(0.5,0.5),(0.5,-0.5),(-0.25,-0.25),(-0.25,0.25),(0.25,0.25),(0.25,-0.25),(-1.,0.25),(1.,0.25),(-0.5,0.25),(0.5,0.25)]),1e-12))
16054         self.assertEqual([5,4,5,6,7,5,1,5,10,5,4,0,10,5,5,5,1,2,11,6,5,3,0,4,7,6,11],a.getNodalConnectivity().getValues())
16055         self.assertEqual([0,5,9,14,20,27],a.getNodalConnectivityIndex().getValues())
16056         self.assertEqual([1,8,10,1,10,5,1,5,6,1,6,11,1,11,9],b.getNodalConnectivity().getValues())
16057         self.assertEqual([0,3,6,9,12,15],b.getNodalConnectivityIndex().getValues())
16058         self.assertTrue(c.isEqual(DataArrayInt([0,1,1,2,2])))
16059         self.assertTrue(d.isEqual(DataArrayInt([(-1,-1),(1,2),(3,0),(3,4),(-1,-1)])))
16060         pass
16061
16062     def testSwig2Intersect2DMeshWith1DLine13(self):
16063         """ A square (side length) in a circle intersected by a simple horizontal line """
16064         import math
16065         eps = 1.0e-8
16066         m = MEDCouplingUMesh("boxcircle", 2)
16067         sq2 = math.sqrt(2.0)
16068         soth = (sq2+1.0)/2.0
16069         coo = [2., 0., sq2, sq2, 0., 2., -sq2, sq2, -2., 0., -sq2, -sq2, 0., -2., sq2, -sq2, -1., -1., -1., 1., 1.,
16070          1., 1., -1., -1., 0., 0., 1., 1., 0., 0., -1., -soth, soth, soth,soth]
16071         coo = DataArrayDouble(coo); coo.rearrange(2)
16072         m.setCoords(coo)
16073         c = [NORM_QPOLYG, 8, 9, 10, 11, 12, 13, 14, 15, NORM_QPOLYG, 3, 1, 10, 9, 2, 17, 13, 16, NORM_QPOLYG, 1, 7, 5, 3, 9, 8, 11, 10, 0, 6, 4, 16, 12, 15, 14, 17]
16074         cI = [0, 9, 18, 35]
16075         m.setConnectivity(DataArrayInt(c), DataArrayInt(cI))
16076         m.checkCoherency()
16077         coords2 = [-2., 1., 2., 1.0]
16078         connec2, cI2 = [NORM_SEG2, 0, 1], [0,3]
16079         m_line = MEDCouplingUMesh("seg", 1)
16080         m_line.setCoords(DataArrayDouble(coords2, len(coords2)/2, 2))
16081         m_line.setConnectivity(DataArrayInt(connec2), DataArrayInt(cI2))
16082         a, b, c, d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(m, m_line, eps)
16083         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
16084         self.assertTrue(a.getCoords()[:m.getNumberOfNodes()].isEqual(m.getCoords(),1e-12))
16085         self.assertTrue(a.getCoords()[m.getNumberOfNodes():m.getNumberOfNodes()+m_line.getNumberOfNodes()].isEqual(m_line.getCoords(),1e-12))
16086         self.assertTrue(a.getCoords().isEqual(DataArrayDouble([(2.,0.),(1.4142135623730951,1.4142135623730951),(0.,2.),(-1.4142135623730951,1.4142135623730951),(-2.,0.),(-1.4142135623730951,-1.4142135623730951),(0.,-2.),(1.4142135623730951,-1.4142135623730951),(-1.,-1.),(-1.,1.),(1.,1.),(1.,-1.),(-1.,0.),(0.,1.),(1.,0.),(0.,-1.),(-1.2071067811865475,1.2071067811865475),(1.2071067811865475,1.2071067811865475),(-2.,1.),(2.,1.),(1.7320508075688772,1.),(-1.7320508075688772,1.),(-1.2071067811865475,1.2071067811865475),(-1.3660254037844386,1.),(-1.58670668058247,1.2175228580174415),(0.,-1.),(1.,0.),(1.2071067811865475,1.2071067811865475),(1.5867066805824703,1.2175228580174413),(1.9828897227476205,-0.26105238444010315),(0.,-2.),(-1.9828897227476205,-0.2610523844401032),(-1.3660254037844386,1.),(-1.,0.),(1.5867066805824703,1.2175228580174413),(1.3660254037844386,1.),(1.2071067811865475,1.2071067811865475),(0.,-2.),(-1.9828897227476205,-0.2610523844401032),(-1.3660254037844386,1.),(-1.,0.),(0.,-1.),(1.,0.),(1.3660254037844386,1.),(1.9828897227476205,-0.26105238444010315)]),1e-12))
16087         self.assertEqual([32,8,9,10,11,12,13,14,15,32,3,1,10,9,2,17,13,16,32,3,9,21,22,23,24,32,1,20,10,34,35,36,32,7,5,21,9,8,11,10,20,37,38,39,40,41,42,43,44],a.getNodalConnectivity().getValues())
16088         self.assertEqual([0,9,18,25,32,49],a.getNodalConnectivityIndex().getValues())
16089         self.assertEqual([1,18,21,1,21,9,1,9,10,1,10,20,1,20,19],b.getNodalConnectivity().getValues())
16090         self.assertEqual([0,3,6,9,12,15],b.getNodalConnectivityIndex().getValues())
16091         self.assertTrue(c.isEqual(DataArrayInt([0,1,2,2,2])))
16092         self.assertTrue(d.isEqual(DataArrayInt([(-1,-1),(2,4),(1,0),(3,4),(-1,-1)])))
16093         pass
16094
16095     def testSwig2Intersect2DMeshWith1DLine14(self):
16096         """ A circle in a circle intersected by a simple horizontal line, not tangent to the circles """
16097         eps = 1.0e-8
16098         m = MEDCouplingUMesh("boxcircle", 2)
16099         coo = [2.,0.,1.4142135623730951,1.414213562373095,0.,2.,-1.414213562373095,1.4142135623730951,-2.,0.,-1.4142135623730954,-1.414213562373095,0.,-2.,
16100                1.4142135623730947,-1.4142135623730954,1.,0.,0.7071067811865476,0.7071067811865475,0.,1.,-0.7071067811865475,0.7071067811865476,-1.,0.,-0.7071067811865477,-0.7071067811865475,
16101                0.,-1.,0.7071067811865474,-0.7071067811865477,1.060660171779821,-1.0606601717798214,-1.0606601717798214,-1.0606601717798212]
16102         coo = DataArrayDouble(coo); coo.rearrange(2)
16103         m.setCoords(coo)
16104         c = [NORM_QPOLYG, 15, 13, 11, 9, 14, 12, 10, 8, NORM_QPOLYG, 7, 5, 13, 15, 6, 17, 14, 16, NORM_QPOLYG, 5, 3, 1, 7, 15, 9, 11, 13, 4, 2, 0, 16, 8, 10, 12, 17]
16105         cI = [0, 9, 18, 35]
16106         m.setConnectivity(DataArrayInt(c), DataArrayInt(cI))
16107         m.checkCoherency()
16108         coords2 = [-2., 0., 2., 0.]
16109         connec2, cI2 = [NORM_SEG2, 0, 1], [0,3]
16110         m_line = MEDCouplingUMesh.New("seg", 1)
16111         m_line.setCoords(DataArrayDouble(coords2, len(coords2)/2, 2))
16112         m_line.setConnectivity(DataArrayInt(connec2), DataArrayInt(cI2))
16113         a, b, c, d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(m, m_line, eps)
16114         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
16115         self.assertTrue(a.getCoords()[:m.getNumberOfNodes()].isEqual(m.getCoords(),1e-12))
16116         self.assertTrue(a.getCoords()[m.getNumberOfNodes():m.getNumberOfNodes()+m_line.getNumberOfNodes()].isEqual(m_line.getCoords(),1e-12))
16117         self.assertTrue(a.getCoords().isEqual(DataArrayDouble([(2.,0.),(1.4142135623730951,1.414213562373095),(0.,2.),(-1.414213562373095,1.4142135623730951),(-2.,0.),(-1.4142135623730954,-1.414213562373095),(0.,-2.),(1.4142135623730947,-1.4142135623730954),(1.,0.),(0.7071067811865476,0.7071067811865475),(0.,1.),(-0.7071067811865475,0.7071067811865476),(-1.,0.),(-0.7071067811865477,-0.7071067811865475),(0.,-1.),(0.7071067811865474,-0.7071067811865477),(1.060660171779821,-1.0606601717798214),(-1.0606601717798214,-1.0606601717798212),(-2.,0.),(2.,0.),(-1.,0.),(1.,0.),(0.,2.),(1.8477590650225735,0.7653668647301795),(1.8477590650225735,-0.7653668647301797),(1.060660171779821,-1.0606601717798214),(0.9238795325112867,-0.38268343236508984),(0.9238795325112867,0.3826834323650897),(0.,1.),(-0.9238795325112867,0.3826834323650896),(-1.5,0.),(-1.8477590650225735,0.7653668647301792),(-1.0606601717798214,-1.0606601717798212),(-1.8477590650225733,-0.7653668647301799),(-1.5,0.),(-0.9238795325112866,-0.38268343236508995),(0.,1.),(-0.9238795325112867,0.3826834323650896),(-1.5,0.),(-1.8477590650225735,0.7653668647301792),(0.,2.),(1.8477590650225735,0.7653668647301795),(1.5,0.),(0.9238795325112867,0.3826834323650897),(1.060660171779821,-1.0606601717798214),(0.9238795325112867,-0.38268343236508984),(1.5,0.),(1.8477590650225735,-0.7653668647301797),(0.,1.),(0.9238795325112867,0.3826834323650897),(0.,0.),(-0.9238795325112867,0.3826834323650896),(0.,-1.),(-0.9238795325112866,-0.38268343236508995),(0.,0.),(0.9238795325112867,-0.38268343236508984)]),1e-12))
16118         self.assertEqual([32,7,5,13,15,6,17,14,16,32,9,11,20,18,3,1,19,21,36,37,38,39,40,41,42,43,32,7,15,21,19,44,45,46,47,32,13,5,18,20,32,33,34,35,32,11,9,21,20,48,49,50,51,32,15,13,20,21,52,53,54,55],a.getNodalConnectivity().getValues())
16119         self.assertEqual([0,9,26,35,44,53,62],a.getNodalConnectivityIndex().getValues())
16120         self.assertEqual([1,18,20,1,20,21,1,21,19],b.getNodalConnectivity().getValues())
16121         self.assertEqual([0,3,6,9],b.getNodalConnectivityIndex().getValues())
16122         self.assertTrue(c.isEqual(DataArrayInt([1,2,2,2,0,0])))
16123         self.assertTrue(d.isEqual(DataArrayInt([(1,3),(4,5),(1,2)])))
16124         pass
16125
16126     def testSwig2Intersect2DMeshWith1DLine15(self):
16127         """ Same as testSwig2Intersect2DMeshWith1DLine13 except that the line is colinear AND splits on of the common edge of 2D mesh."""
16128         import math
16129         eps = 1.0e-8
16130         m = MEDCouplingUMesh("boxcircle", 2)
16131         sq2 = math.sqrt(2.0)
16132         soth = (sq2+1.0)/2.0
16133         coo = [2., 0., sq2, sq2, 0., 2., -sq2, sq2, -2., 0., -sq2, -sq2, 0., -2., sq2, -sq2, -1., -1., -1., 1., 1.,
16134          1., 1., -1., -1., 0., 0., 1., 1., 0., 0., -1., -soth, soth, soth,soth]
16135         coo = DataArrayDouble(coo); coo.rearrange(2)
16136         m.setCoords(coo)
16137         c = [NORM_QPOLYG, 8, 9, 10, 11, 12, 13, 14, 15, NORM_QPOLYG, 3, 1, 10, 9, 2, 17, 13, 16, NORM_QPOLYG, 1, 7, 5, 3, 9, 8, 11, 10, 0, 6, 4, 16, 12, 15, 14, 17]
16138         cI = [0, 9, 18, 35]
16139         m.setConnectivity(DataArrayInt(c), DataArrayInt(cI))
16140         m.checkCoherency()
16141         coords2 = [(-2., 1.),(2.,1.),(0.,1)]
16142         connec2, cI2 = [NORM_SEG2, 0, 2, NORM_SEG2, 2, 1], [0,3,6]
16143         m_line = MEDCouplingUMesh("seg", 1)
16144         m_line.setCoords(DataArrayDouble(coords2))
16145         m_line.setConnectivity(DataArrayInt(connec2), DataArrayInt(cI2))
16146         a, b, c, d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(m, m_line, eps)
16147         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
16148         self.assertTrue(a.getCoords()[:m.getNumberOfNodes()].isEqual(m.getCoords(),1e-12))
16149         self.assertTrue(a.getCoords()[m.getNumberOfNodes():m.getNumberOfNodes()+m_line.getNumberOfNodes()].isEqual(m_line.getCoords(),1e-12))
16150         self.assertTrue(a.getCoords().isEqual(DataArrayDouble([(2.,0.),(1.4142135623730951,1.4142135623730951),(0.,2.),(-1.4142135623730951,1.4142135623730951),(-2.,0.),(-1.4142135623730951,-1.4142135623730951),(0.,-2.),(1.4142135623730951,-1.4142135623730951),(-1.,-1.),(-1.,1.),(1.,1.),(1.,-1.),(-1.,0.),(0.,1.),(1.,0.),(0.,-1.),(-1.2071067811865475,1.2071067811865475),(1.2071067811865475,1.2071067811865475),(-2.,1.),(2.,1.),(0.,1.),(1.7320508075688776,1.),(-1.7320508075688776,1.),(-0.5,1.),(0.5,1.),(0.5,1.),(-0.5,1.),(-1.2071067811865475,1.2071067811865475),(-1.3660254037844388,1.),(-1.58670668058247,1.2175228580174415),(0.,-1.),(1.,0.),(1.2071067811865475,1.2071067811865475),(1.5867066805824703,1.2175228580174413),(1.9828897227476205,-0.26105238444010315),(0.,-2.),(-1.9828897227476205,-0.2610523844401032),(-1.3660254037844388,1.),(-1.,0.),(1.5867066805824703,1.2175228580174413),(1.3660254037844388,1.),(1.2071067811865475,1.2071067811865475),(0.,-2.),(-1.9828897227476205,-0.2610523844401032),(-1.3660254037844388,1.),(-1.,0.),(0.,-1.),(1.,0.),(1.3660254037844388,1.),(1.9828897227476205,-0.26105238444010315)]),1e-12))
16151         self.assertEqual([32,8,9,20,10,11,12,23,24,14,15,32,3,1,10,20,9,2,17,25,26,16,32,3,9,22,27,28,29,32,1,21,10,39,40,41,32,7,5,22,9,8,11,10,21,42,43,44,45,46,47,48,49],a.getNodalConnectivity().getValues())
16152         self.assertEqual([0,11,22,29,36,53],a.getNodalConnectivityIndex().getValues())
16153         self.assertEqual([1,18,22,1,22,9,1,9,20,1,20,10,1,10,21,1,21,19],b.getNodalConnectivity().getValues())
16154         self.assertEqual([0,3,6,9,12,15,18],b.getNodalConnectivityIndex().getValues())
16155         self.assertTrue(c.isEqual(DataArrayInt([0,1,2,2,2])))
16156         self.assertTrue(d.isEqual(DataArrayInt([(-1,-1),(2,4),(1,0),(1,0),(3,4),(-1,-1)])))
16157         pass
16158
16159     def testSwig2Intersect2DMeshWith1DLine16(self):
16160         """ Same than testSwig2Intersect2DMeshWith1DLine13 except it is a vertical line. Non regression test."""
16161         import math
16162         eps = 1.0e-8
16163         m = MEDCouplingUMesh("boxcircle", 2)
16164         sq2 = math.sqrt(2.0)
16165         soth = (sq2+1.0)/2.0
16166         coo = [2., 0., sq2, sq2, 0., 2., -sq2, sq2, -2., 0., -sq2, -sq2, 0., -2., sq2, -sq2, -1., -1., -1., 1., 1.,
16167          1., 1., -1., -1., 0., 0., 1., 1., 0., 0., -1., -soth, soth, soth,soth]
16168         coo = DataArrayDouble(coo); coo.rearrange(2)
16169         m.setCoords(coo)
16170         c = [NORM_QPOLYG, 8, 9, 10, 11, 12, 13, 14, 15, NORM_QPOLYG, 3, 1, 10, 9, 2, 17, 13, 16, NORM_QPOLYG, 1, 7, 5, 3, 9, 8, 11, 10, 0, 6, 4, 16, 12, 15, 14, 17]
16171         cI = [0, 9, 18, 35]
16172         m.setConnectivity(DataArrayInt(c), DataArrayInt(cI))
16173         m.checkCoherency()
16174         coords2 = [1., 2., 1., -2.]
16175         connec2, cI2 = [NORM_SEG2, 0, 1], [0,3]
16176         m_line = MEDCouplingUMesh("seg", 1)
16177         m_line.setCoords(DataArrayDouble(coords2, len(coords2)/2, 2))
16178         m_line.setConnectivity(DataArrayInt(connec2), DataArrayInt(cI2))
16179         a, b, c, d = MEDCouplingUMesh.Intersect2DMeshWith1DLine(m, m_line, eps)
16180         self.assertTrue(a.getCoords().getHiddenCppPointer()==b.getCoords().getHiddenCppPointer())
16181         self.assertTrue(a.getCoords()[:m.getNumberOfNodes()].isEqual(m.getCoords(),1e-12))
16182         self.assertTrue(a.getCoords()[m.getNumberOfNodes():m.getNumberOfNodes()+m_line.getNumberOfNodes()].isEqual(m_line.getCoords(),1e-12))
16183         self.assertTrue(a.getCoords().isEqual(DataArrayDouble([(2., 0.),(1.4142135623730951,1.4142135623730951),(0.,2.),(-1.4142135623730951,1.4142135623730951),(-2.,0.),(-1.4142135623730951,-1.4142135623730951),(0.,-2.),(1.4142135623730951,-1.4142135623730951),(-1.,-1.),(-1.,1.),(1.,1.),(1.,-1.),(-1.,0.),(0.,1.),(1.,0.),(0.,-1.),(-1.2071067811865475,1.2071067811865475),(1.2071067811865475,1.2071067811865475),(1.,2.),(1.,-2.),(1.,1.7320508075688772),(1.,-1.7320508075688772),(1.2071067811865475,1.2071067811865475),(1.,1.3660254037844386),(1.217522858017441,1.5867066805824703),(-1.2071067811865475,1.2071067811865475),(-0.2610523844401028,1.9828897227476208),(1.,1.3660254037844386),(0.,1.),(1.2071067811865475,1.2071067811865475),(2.,0.),(1.217522858017441,-1.5867066805824703),(1.,-1.3660254037844386),(1.,0.),(-2.,0.),(-1.2071067811865475,1.2071067811865475),(-1.,0.),(0.,-1.),(1.,-1.3660254037844386),(-0.2610523844401028,-1.9828897227476208)]),1e-12))
16184         self.assertEqual([32,8,9,10,11,12,13,14,15,32,1,10,20,22,23,24,32,9,3,20,10,25,26,27,28,32,10,1,7,21,11,29,30,31,32,33,32,5,3,9,8,11,21,34,35,36,37,38,39],a.getNodalConnectivity().getValues())
16185         self.assertEqual([0,9,16,25,36,49],a.getNodalConnectivityIndex().getValues())
16186         self.assertEqual([1,18,20,1,20,10,1,10,11,1,11,21,1,21,19],b.getNodalConnectivity().getValues())
16187         self.assertEqual([0,3,6,9,12,15],b.getNodalConnectivityIndex().getValues())
16188         self.assertTrue(c.isEqual(DataArrayInt([0,1,1,2,2])))
16189         self.assertTrue(d.isEqual(DataArrayInt([(-1,-1),(1,2),(3,0),(3,4),(-1,-1)])))
16190         pass
16191
16192     def testOrderConsecutiveCells1D1(self):
16193         """A line in several unconnected pieces:"""
16194         m2 = MEDCouplingUMesh.New("bla", 1)
16195         c = DataArrayInt([NORM_SEG2,0,1,NORM_SEG3,1,3,2, NORM_SEG2,3,4,
16196                                NORM_SEG3,5,7,6, NORM_SEG3,7,9,8, NORM_SEG2,9,10,
16197                                NORM_SEG2,11,12,NORM_SEG2,12,13,
16198                                NORM_SEG2,14,15])
16199         cI = DataArrayInt([0,3,7,10,14,18,21,24,27,30])
16200         coords2 = DataArrayDouble([float(i) for i in range(32)], 16,2)
16201         m2.setCoords(coords2);
16202         m2.setConnectivity(c, cI);
16203         m2.checkCoherency2(1.0e-8);
16204
16205         # Shuffle a bit :-)
16206         m2.renumberCells(DataArrayInt([0,3,6,8,1,4,7,5,2]), True);
16207         res = m2.orderConsecutiveCells1D()
16208         expRes = [0,3,6,8,1,4,2,7,5]
16209         self.assertEqual(m2.getNumberOfCells(),res.getNumberOfTuples())
16210         self.assertEqual(expRes, res.getValues())
16211
16212         # A closed line (should also work)
16213         m3 = MEDCouplingUMesh.New("bla3", 1)
16214         conn3A = DataArrayInt([NORM_SEG2,0,1,NORM_SEG3,1,3,2, NORM_SEG2,3,0])
16215         coord3 = coords2[0:5]
16216         c.reAlloc(10)
16217         cI.reAlloc(4)
16218
16219         m3.setCoords(coord3)
16220         m3.setConnectivity(conn3A, cI)
16221         m3.checkCoherency2(1.0e-8)
16222         res2 = m3.orderConsecutiveCells1D()
16223         expRes2 = [0,1,2]
16224         self.assertEqual(m3.getNumberOfCells(),res2.getNumberOfTuples())
16225         self.assertEqual(expRes2, res2.getValues())
16226         pass
16227
16228     def testDADApplyFuncOnThis1(self):
16229         d=DataArrayDouble(5) ; d.iota(0.)
16230         d.applyFuncOnThis("2*x+1")
16231         self.assertTrue(d.isEqual(DataArrayDouble([1.,3.,5.,7.,9.]),1e-12))
16232         d=DataArrayDouble(6) ; d.iota(0.) ; d.rearrange(2)
16233         d.applyFuncOnThis("2*x+1")
16234         self.assertTrue(d.isEqual(DataArrayDouble([1.,3.,5.,7.,9.,11.],3,2),1e-12))
16235         d.applyFuncOnThis("1+2*3")
16236         self.assertTrue(d.isEqual(DataArrayDouble([(7.,7.),(7.,7.),(7.,7.)]),1e-12))
16237         pass
16238
16239     def testSwig2PointSetComputeFetchedNodeIds1(self):
16240         arr=DataArrayDouble(6) ; arr.iota()
16241         m=MEDCouplingCMesh() ; m.setCoords(arr,arr,arr)
16242         m=m.buildUnstructured()
16243         m0=m[[0,1,5,6,25,26,30,31,124]]
16244         ref=DataArrayInt([0,1,2,6,7,8,12,13,14,36,37,38,42,43,44,48,49,50,72,73,74,78,79,80,84,85,86,172,173,178,179,208,209,214,215])
16245         self.assertTrue(m0.computeFetchedNodeIds().isEqual(ref))
16246         self.assertTrue(MEDCoupling1SGTUMesh(m0).computeFetchedNodeIds().isEqual(ref))
16247         self.assertEqual(m0.getAllGeoTypes(),[NORM_HEXA8])
16248         m0.convertAllToPoly()
16249         self.assertEqual(m0.getAllGeoTypes(),[NORM_POLYHED])
16250         self.assertTrue(MEDCoupling1DGTUMesh(m0).computeFetchedNodeIds().isEqual(ref))
16251         pass
16252
16253     def testSwig2PartDefinition1(self):
16254         pd=PartDefinition.New(5,22,3)
16255         self.assertTrue(isinstance(pd,SlicePartDefinition))
16256         self.assertTrue(pd.toDAI().isEqual(DataArrayInt([5,8,11,14,17,20])))
16257         self.assertEqual(pd.getNumberOfElems(),6)
16258         self.assertEqual(pd.getEffectiveStop(),23)
16259         pd=PartDefinition.New(5,23,3)
16260         self.assertTrue(isinstance(pd,SlicePartDefinition))
16261         self.assertTrue(pd.toDAI().isEqual(DataArrayInt([5,8,11,14,17,20])))
16262         self.assertEqual(pd.getNumberOfElems(),6)
16263         self.assertEqual(pd.getEffectiveStop(),23)
16264         self.assertEqual(pd.getSlice(),slice(5,23,3))
16265         pd=PartDefinition.New(5,22,1)
16266         self.assertTrue(isinstance(pd,SlicePartDefinition))
16267         self.assertTrue(pd.toDAI().isEqual(DataArrayInt([5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21])))
16268         self.assertEqual(pd.getNumberOfElems(),17)
16269         self.assertEqual(pd.getEffectiveStop(),22)
16270         pd=PartDefinition.New(5,23,3)+PartDefinition.New(23,27,3)
16271         self.assertTrue(isinstance(pd,SlicePartDefinition))
16272         self.assertEqual(pd.getNumberOfElems(),8)
16273         self.assertTrue(pd.toDAI().isEqual(DataArrayInt([5,8,11,14,17,20,23,26])))
16274         self.assertEqual(pd.getEffectiveStop(),29)
16275         pd=SlicePartDefinition(5,22,1)
16276         self.assertTrue(isinstance(pd,SlicePartDefinition))
16277         self.assertTrue(pd.toDAI().isEqual(DataArrayInt([5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21])))
16278         self.assertEqual(pd.getNumberOfElems(),17)
16279         self.assertEqual(pd.getEffectiveStop(),22)
16280         d=DataArrayInt([2,4,5,6,10])
16281         pd=PartDefinition.New(d)
16282         self.assertTrue(isinstance(pd,DataArrayPartDefinition))
16283         self.assertEqual(pd.toDAI().getHiddenCppPointer(),d.getHiddenCppPointer())
16284         pd=DataArrayPartDefinition(d)
16285         self.assertEqual(pd.toDAI().getHiddenCppPointer(),d.getHiddenCppPointer())
16286         pd=DataArrayPartDefinition(d)+DataArrayPartDefinition(DataArrayInt([12,14,20]))
16287         self.assertTrue(isinstance(pd,DataArrayPartDefinition))
16288         self.assertEqual(pd.getNumberOfElems(),8)
16289         self.assertTrue(pd.toDAI().isEqual(DataArrayInt([2,4,5,6,10,12,14,20])))
16290         pass
16291
16292     def testSwig2SortEachPairToMakeALinkedList1(self):
16293         d=DataArrayInt([(50,49),(50,51),(51,52),(53,52),(53,54),(55,54),(55,56),(56,57),(58,57),(58,59),(60,59),(60,61),(61,62),(63,62),(63,64),(65,64),(65,66),(66,67)])
16294         d.sortEachPairToMakeALinkedList()
16295         self.assertTrue(d.isEqual(DataArrayInt([(49,50),(50,51),(51,52),(52,53),(53,54),(54,55),(55,56),(56,57),(57,58),(58,59),(59,60),(60,61),(61,62),(62,63),(63,64),(64,65),(65,66),(66,67)])))
16296         pass
16297
16298     def testSwig2DAIIsRange(self):
16299         d=DataArrayInt([2,6,10])
16300         a,b=d.isRange()
16301         self.assertTrue(a)
16302         self.assertEqual(b,slice(2,11,4))
16303         self.assertTrue(DataArrayInt.Range(b.start,b.stop,b.step).isEqual(d))
16304         #
16305         d=DataArrayInt([2,7,10])
16306         a,b=d.isRange()
16307         self.assertTrue(not a)
16308         self.assertTrue(b is None)
16309         #
16310         d=DataArrayInt([22,17,12])
16311         a,b=d.isRange()
16312         self.assertTrue(a)
16313         self.assertEqual(b,slice(22,11,-5))
16314         self.assertTrue(DataArrayInt.Range(b.start,b.stop,b.step).isEqual(d))
16315         #
16316         d=DataArrayInt([22,16,12])
16317         a,b=d.isRange()
16318         self.assertTrue(not a)
16319         self.assertTrue(b is None)
16320         #
16321         d=DataArrayInt([33])
16322         a,b=d.isRange()
16323         self.assertTrue(a)
16324         self.assertEqual(b,slice(33,34,1))
16325         self.assertTrue(DataArrayInt.Range(b.start,b.stop,b.step).isEqual(d))
16326         #
16327         d=DataArrayInt([])
16328         a,b=d.isRange()
16329         self.assertTrue(a)
16330         self.assertEqual(b,slice(0,0,1))
16331         self.assertTrue(DataArrayInt.Range(b.start,b.stop,b.step).isEqual(d))
16332         #
16333         d=DataArrayInt([2,6,10,2])
16334         a,b=d.isRange()
16335         self.assertTrue(not a)
16336         self.assertTrue(b is None)
16337         pass
16338
16339     def testSwig2PartDefinitionComposeWith1(self):
16340         f=PartDefinition.New(DataArrayInt([0,1,2,3,6,7,8,9]))
16341         g=PartDefinition.New(4,14,1)
16342         g2=g.deepCpy()
16343         self.assertTrue(g2.isEqual(g)[0])
16344         h=f.composeWith(g)
16345         self.assertTrue(isinstance(h,DataArrayPartDefinition))
16346         self.assertTrue(h.toDAI().isEqual(DataArrayInt([4,5,6,7,10,11,12,13])))
16347         f2=f.tryToSimplify()
16348         g2=g.tryToSimplify()
16349         self.assertEqual(f2.getHiddenCppPointer(),f.getHiddenCppPointer())# same because no simplification due to content of array
16350         self.assertEqual(g2.getHiddenCppPointer(),g.getHiddenCppPointer())# same because no simplification linked to type of PartDef
16351         p=PartDefinition.New(DataArrayInt([2,6,10]))
16352         p2=p.tryToSimplify()
16353         self.assertNotEqual(p2.getHiddenCppPointer(),p.getHiddenCppPointer())
16354         self.assertTrue(isinstance(p2,SlicePartDefinition))
16355         self.assertEqual(p2.getSlice(),slice(2,11,4))
16356         self.assertTrue(p2.isEqual(SlicePartDefinition(2,11,4))[0])
16357         self.assertTrue(p2.isEqual(p2.deepCpy())[0])
16358         self.assertTrue(not p2.isEqual(SlicePartDefinition(1,11,4))[0])
16359         self.assertTrue(not p2.isEqual(SlicePartDefinition(2,10,4))[0])
16360         self.assertTrue(not p2.isEqual(SlicePartDefinition(2,11,3))[0])
16361         pass
16362
16363     def testSwig2DAIGetIdsStrictlyNegative1(self):
16364         d=DataArrayInt([4,-5,-1,0,3,99,-7])
16365         self.assertTrue(d.getIdsStrictlyNegative().isEqual(DataArrayInt([1,2,6])))
16366         pass
16367
16368     def testSwig2DAIReplaceOneValByInThis1(self):
16369         d=DataArrayInt([4,-5,-1,0,-5,99,-7,5])
16370         d.replaceOneValByInThis(-5,900)
16371         self.assertTrue(d.isEqual(DataArrayInt([4,900,-1,0,900,99,-7,5])))
16372         pass
16373
16374     def testSwig2DAIGetMinMaxValues1(self):
16375         d=DataArrayInt([4,-5,-1,0,3,99,-7])
16376         a,b=d.getMinMaxValues()
16377         self.assertEqual(a,-7)
16378         self.assertEqual(b,99)
16379         pass
16380
16381     def testSwig2DAIBuildUniqueNotSorted1(self):
16382         d=DataArrayInt([-5,3,2,-1,2,3,-6,4,2,-5,3,7])
16383         self.assertTrue(d.buildUniqueNotSorted().isEqual(DataArrayInt([-5,3,2,-1,-6,4,7])))
16384         pass
16385
16386     def testSwig2UMeshChangeOrientationOfCells1(self):
16387         """ Here testing changeOrientationOfCell method on unstructured meshes lying on no coords."""
16388         m=MEDCouplingUMesh("mesh",1)
16389         c=DataArrayInt([NORM_SEG2,4,5,NORM_SEG2,10,8,NORM_SEG3,20,7,33,NORM_SEG3,13,15,12,NORM_SEG2,3,2,NORM_SEG4,5,6,8,10,NORM_SEG4,34,33,3,2])
16390         cI=DataArrayInt([0,3,6,10,14,17,22,27])
16391         m.setConnectivity(c,cI)
16392         m.changeOrientationOfCells()
16393         self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([NORM_SEG2,5,4,NORM_SEG2,8,10,NORM_SEG3,7,20,33,NORM_SEG3,15,13,12,NORM_SEG2,2,3,NORM_SEG4,6,5,10,8,NORM_SEG4,33,34,2,3])))
16394         self.assertTrue(m.getNodalConnectivityIndex().isEqual(cI))
16395         # testing 2D cells
16396         m=MEDCouplingUMesh("mesh",2)
16397         c=DataArrayInt([NORM_TRI3,0,1,2,NORM_QUAD4,3,4,5,6,NORM_POLYGON,7,8,9,10,11,NORM_TRI6,12,13,14,15,16,17,NORM_QUAD8,18,19,20,21,22,23,24,25,NORM_QPOLYG,26,27,28,29,30,31,32,33,34,35])
16398         cI=DataArrayInt([0,4,9,15,22,31,42])
16399         m.setConnectivity(c,cI)
16400         m.changeOrientationOfCells()
16401         self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([NORM_TRI3,0,2,1,NORM_QUAD4,3,6,5,4,NORM_POLYGON,7,11,10,9,8,NORM_TRI6,12,14,13,17,16,15,NORM_QUAD8,18,21,20,19,25,24,23,22,NORM_QPOLYG,26,30,29,28,27,35,34,33,32,31])))
16402         self.assertTrue(m.getNodalConnectivityIndex().isEqual(cI))
16403         pass
16404
16405     def testSwig2StructuredMeshCellLocation1(self):
16406         # 3D
16407         arrX=DataArrayDouble(5) ; arrX.iota()
16408         arrY=DataArrayDouble(4) ; arrY.iota()
16409         arrZ=DataArrayDouble(3) ; arrZ.iota()
16410         m=MEDCouplingCMesh() ; m.setCoords(arrX,arrY,arrZ)
16411         li=[]
16412         liExp3D=[(0,0,0),(1,0,0),(2,0,0),(3,0,0),(0,1,0),(1,1,0),(2,1,0),(3,1,0),(0,2,0),(1,2,0),(2,2,0),(3,2,0),(0,0,1),(1,0,1),(2,0,1),(3,0,1),(0,1,1),(1,1,1),(2,1,1),(3,1,1),(0,2,1),(1,2,1),(2,2,1),(3,2,1)]
16413         self.assertEqual(24,m.getNumberOfCells())
16414         for i in xrange(m.getNumberOfCells()):
16415             li.append(m.getLocationFromCellId(i))
16416             pass
16417         self.assertEqual(liExp3D,li)
16418         self.assertRaises(InterpKernelException,m.getLocationFromCellId,24)
16419         self.assertRaises(InterpKernelException,m.getLocationFromCellId,-1)
16420         # 2D
16421         arrX=DataArrayDouble(5) ; arrX.iota()
16422         arrY=DataArrayDouble(4) ; arrY.iota()
16423         m=MEDCouplingCMesh() ; m.setCoords(arrX,arrY)
16424         li=[]
16425         liExp2D=[(0,0),(1,0),(2,0),(3,0),(0,1),(1,1),(2,1),(3,1),(0,2),(1,2),(2,2),(3,2)]
16426         self.assertEqual(12,m.getNumberOfCells())
16427         for i in xrange(m.getNumberOfCells()):
16428             li.append(m.getLocationFromCellId(i))
16429             pass
16430         self.assertEqual(liExp2D,li)
16431         self.assertRaises(InterpKernelException,m.getLocationFromCellId,12)
16432         self.assertRaises(InterpKernelException,m.getLocationFromCellId,-1)
16433         # 1D
16434         arrX=DataArrayDouble(5) ; arrX.iota()
16435         m=MEDCouplingCMesh() ; m.setCoords(arrX)
16436         self.assertEqual(4,m.getNumberOfCells())
16437         for i in xrange(m.getNumberOfCells()):
16438             self.assertEqual((i,),m.getLocationFromCellId(i))
16439             pass
16440         self.assertRaises(InterpKernelException,m.getLocationFromCellId,4)
16441         self.assertRaises(InterpKernelException,m.getLocationFromCellId,-1)
16442         pass
16443
16444     def testSwig2StructuredMeshNodeLocation1(self):
16445         # 3D
16446         arrX=DataArrayDouble(5) ; arrX.iota()
16447         arrY=DataArrayDouble(4) ; arrY.iota()
16448         arrZ=DataArrayDouble(3) ; arrZ.iota()
16449         m=MEDCouplingCMesh() ; m.setCoords(arrX,arrY,arrZ)
16450         li=[]
16451         liExp3D=[(0,0,0),(1,0,0),(2,0,0),(3,0,0),(4,0,0),(0,1,0),(1,1,0),(2,1,0),(3,1,0),(4,1,0),(0,2,0),(1,2,0),(2,2,0),(3,2,0),(4,2,0),(0,3,0),(1,3,0),(2,3,0),(3,3,0),(4,3,0),(0,0,1),(1,0,1),(2,0,1),(3,0,1),(4,0,1),(0,1,1),(1,1,1),(2,1,1),(3,1,1),(4,1,1),(0,2,1),(1,2,1),(2,2,1),(3,2,1),(4,2,1),(0,3,1),(1,3,1),(2,3,1),(3,3,1),(4,3,1),(0,0,2),(1,0,2),(2,0,2),(3,0,2),(4,0,2),(0,1,2),(1,1,2),(2,1,2),(3,1,2),(4,1,2),(0,2,2),(1,2,2),(2,2,2),(3,2,2),(4,2,2),(0,3,2),(1,3,2),(2,3,2),(3,3,2),(4,3,2)]
16452         self.assertEqual(60,m.getNumberOfNodes())
16453         for i in xrange(m.getNumberOfNodes()):
16454             li.append(m.getLocationFromNodeId(i))
16455             pass
16456         self.assertEqual(liExp3D,li)
16457         self.assertRaises(InterpKernelException,m.getLocationFromNodeId,60)
16458         self.assertRaises(InterpKernelException,m.getLocationFromNodeId,-1)
16459         # 2D
16460         arrX=DataArrayDouble(5) ; arrX.iota()
16461         arrY=DataArrayDouble(4) ; arrY.iota()
16462         m=MEDCouplingCMesh() ; m.setCoords(arrX,arrY)
16463         li=[]
16464         liExp2D=[(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)]
16465         self.assertEqual(20,m.getNumberOfNodes())
16466         for i in xrange(m.getNumberOfNodes()):
16467             li.append(m.getLocationFromNodeId(i))
16468             pass
16469         self.assertEqual(liExp2D,li)
16470         self.assertRaises(InterpKernelException,m.getLocationFromNodeId,20)
16471         self.assertRaises(InterpKernelException,m.getLocationFromNodeId,-1)
16472         # 1D
16473         arrX=DataArrayDouble(5) ; arrX.iota()
16474         m=MEDCouplingCMesh() ; m.setCoords(arrX)
16475         self.assertEqual(5,m.getNumberOfNodes())
16476         for i in xrange(m.getNumberOfNodes()):
16477             self.assertEqual((i,),m.getLocationFromNodeId(i))
16478             pass
16479         self.assertRaises(InterpKernelException,m.getLocationFromCellId,5)
16480         self.assertRaises(InterpKernelException,m.getLocationFromCellId,-1)
16481         pass
16482
16483     def testSwig2DataArrayPrintNotTooLong1(self):
16484         """ Now that DataArrayDouble and DataArrayInt and pickelized they can appear in YACS ports. Avoid to have too heavy string representation of them."""
16485         d=DataArrayDouble(2000) ; d.iota() ; d.rearrange(2)
16486         st0=d.repr() ; st1=str(d) ; st2=d.reprNotTooLong()
16487         self.assertEqual(st0,st1) # 1000 tuples ( >=0 and <= 1000) -> str(d)==d.repr()
16488         self.assertEqual(st1,st2)
16489         #
16490         d=DataArrayDouble(2002) ; d.iota() ; d.rearrange(2)
16491         st0=d.repr() ; st1=str(d) ; st2=d.reprNotTooLong()
16492         self.assertNotEqual(st0,st1) # 1001 tuples ( > 1000) -> str(d)==d.reprNotTooLong()
16493         self.assertEqual(st1,st2)
16494         self.assertIn(len(st2),xrange(0,1000)) # no more than 1000 characters
16495         ## Now for DataArrayInt
16496         d=DataArrayInt(2000) ; d.iota() ; d.rearrange(2)
16497         st0=d.repr() ; st1=str(d) ; st2=d.reprNotTooLong()
16498         self.assertEqual(st0,st1) # 1000 tuples ( >=0 and <= 1000) -> str(d)==d.repr()
16499         self.assertEqual(st1,st2)
16500         #
16501         d=DataArrayInt(2002) ; d.iota() ; d.rearrange(2)
16502         st0=d.repr() ; st1=str(d) ; st2=d.reprNotTooLong()
16503         self.assertNotEqual(st0,st1) # 1001 tuples ( > 1000) -> str(d)==d.reprNotTooLong()
16504         self.assertEqual(st1,st2)
16505         self.assertIn(len(st2),xrange(0,1000)) # no more than 1000 characters
16506         pass
16507
16508     def testExtrudedMeshWithoutZipCoords1(self):
16509         """This test checks that MEDCouplingUMesh.buildExtrudedMesh do not perform a zipCoords."""
16510         arr=DataArrayDouble([(0.,0.),(1.,0.),(2.,0.),(3.,0.)])
16511         m=MEDCouplingUMesh("mesh",1) ; m.setCoords(arr)
16512         m.allocateCells()
16513         m.insertNextCell(NORM_SEG2,[1,2])
16514         arr1D=DataArrayDouble([(0.,0.),(0.,1.5),(0.,2.)])
16515         m1D=MEDCouplingUMesh("mesh1D",1) ; m1D.setCoords(arr1D)
16516         m1D.allocateCells()
16517         m1D.insertNextCell(NORM_SEG2,[0,1])
16518         m1D.insertNextCell(NORM_SEG2,[1,2])
16519         m2D=m.buildExtrudedMesh(m1D,0)
16520         self.assertEqual(m.getCoords().getHiddenCppPointer(),m2D.getCoords().getHiddenCppPointer())
16521         coo=DataArrayDouble([(0,0),(1,0),(2,0),(3,0),(0,1.5),(1,1.5),(2,1.5),(3,1.5),(0,2),(1,2),(2,2),(3,2)])
16522         self.assertTrue(m.getCoords().isEqual(coo,1e-12))
16523         self.assertTrue(m2D.getNodalConnectivity().isEqual(DataArrayInt([4,1,2,6,5,4,5,6,10,9])))
16524         self.assertTrue(m2D.getNodalConnectivityIndex().isEqual(DataArrayInt([0,5,10])))
16525         pass
16526
16527     def testPointSetAreAllNodesFetched1(self):
16528         m=MEDCouplingCMesh() ; arr=DataArrayDouble(10) ; arr.iota()
16529         m.setCoords(arr,arr)
16530         m=m.buildUnstructured()
16531         self.assertTrue(m.areAllNodesFetched())
16532         m2=m[[0,2,3,4,5]]
16533         self.assertTrue(not m2.areAllNodesFetched())
16534         m2.zipCoords()
16535         self.assertTrue(m2.areAllNodesFetched())
16536         pass
16537
16538     def testMEDCouplingPointSetComputeDiameterField1(self):
16539         arrX=DataArrayDouble([0.,1.1,1.7,2.1])
16540         arrY=DataArrayDouble([0.,0.7,0.8,1.9])
16541         arrZ=DataArrayDouble([0.,1.3,2.1,2.4])
16542         m=MEDCouplingCMesh() ; m.setCoords(arrX,arrY,arrZ) ; m=m.buildUnstructured()
16543         f=m.computeDiameterField()
16544         f.checkCoherency()
16545         exp=DataArrayDouble([1.8411952639521971,1.5937377450509227,1.5297058540778357,1.705872210923198,1.4352700094407325,1.3638181696985856,2.0273134932713295,1.8055470085267789,1.7492855684535902,1.5297058540778357,1.2206555615733703,1.1357816691600546,1.3638181696985856,1.004987562112089,0.9,1.7492855684535902,1.4866068747318506,1.4177446878757824,1.3379088160259651,0.9695359714832656,0.8602325267042626,1.1445523142259597,0.6782329983125266,0.5099019513592785,1.5842979517754858,1.2884098726725124,1.208304597359457])
16546         self.assertTrue(exp.isEqual(f.getArray(),1e-12))
16547         m1=m[::2]
16548         m2=m[1::2]
16549         m2.simplexize(PLANAR_FACE_5)
16550         m3=MEDCouplingUMesh.MergeUMeshesOnSameCoords(m1,m2)
16551         f=m3.computeDiameterField()
16552         f.checkCoherency()
16553         exp2=DataArrayDouble([1.8411952639521971,1.5297058540778357,1.4352700094407325,2.0273134932713295,1.7492855684535902,1.2206555615733703,1.3638181696985856,0.9,1.4866068747318506,1.3379088160259651,0.8602325267042626,0.6782329983125266,1.5842979517754858,1.208304597359457,1.47648230602334,1.47648230602334,1.47648230602334,1.47648230602334,1.47648230602334,1.7029386365926402,1.7029386365926402,1.7029386365926402,1.7029386365926402,1.7029386365926402,1.3601470508735445,1.3601470508735445,1.3601470508735445,1.3601470508735445,1.3601470508735445,1.70293863659264,1.70293863659264,1.70293863659264,1.70293863659264,1.70293863659264,1.3601470508735445,1.3601470508735445,1.3601470508735445,1.3601470508735445,1.3601470508735445,1.063014581273465,1.063014581273465,1.063014581273465,1.063014581273465,1.063014581273465,1.0,1.0,1.0,1.0,1.0,1.5556349186104046,1.5556349186104046,1.5556349186104046,1.5556349186104046,1.5556349186104046,1.3601470508735443,1.3601470508735443,1.3601470508735443,1.3601470508735443,1.3601470508735443,0.9219544457292886,0.9219544457292886,0.9219544457292886,0.9219544457292886,0.9219544457292886,1.140175425099138,1.140175425099138,1.140175425099138,1.140175425099138,1.140175425099138,0.5,0.5,0.5,0.5,0.5,1.2529964086141667,1.2529964086141667,1.2529964086141667,1.2529964086141667,1.2529964086141667])
16554         self.assertTrue(exp2.isEqual(f.getArray(),1e-12))
16555         # TRI3 - spacedim = 2
16556         coo=DataArrayDouble([(1,1),(5,1.9),(2.1,3)])
16557         m=MEDCoupling1SGTUMesh("mesh",NORM_TRI3) ; m.setCoords(coo)
16558         for c in [[0,1,2],[0,2,1],[2,1,0]]:
16559             m.setNodalConnectivity(DataArrayInt(c))
16560             self.assertAlmostEqual(m.computeDiameterField().getArray()[0],4.1,12)
16561             m2=m.buildUnstructured() ; m2.convertLinearCellsToQuadratic(0)
16562             self.assertAlmostEqual(m2.computeDiameterField().getArray()[0],4.1,12)
16563             m3=m.buildUnstructured() ; m3.convertLinearCellsToQuadratic(1)
16564             self.assertAlmostEqual(m3.computeDiameterField().getArray()[0],4.1,12)
16565         # TRI3 - spacedim = 3
16566         coo=DataArrayDouble([(1.3198537928820775,1.0991902391274959,-0.028645697595823361),(5.2486835106806335,2.2234012799688281,0.30368935050077939),(2.2973688139447361,3.1572023778066649,0.10937756365410012)])
16567         m=MEDCoupling1SGTUMesh("mesh",NORM_TRI3) ; m.setCoords(coo)
16568         for c in [[0,1,2],[0,2,1],[2,1,0]]:
16569             m.setNodalConnectivity(DataArrayInt(c))
16570             self.assertAlmostEqual(m.computeDiameterField().getArray()[0],4.1,12)
16571             m2=m.buildUnstructured() ; m2.convertLinearCellsToQuadratic(0)
16572             self.assertAlmostEqual(m2.computeDiameterField().getArray()[0],4.1,12)
16573             m3=m.buildUnstructured() ; m3.convertLinearCellsToQuadratic(1)
16574             self.assertAlmostEqual(m3.computeDiameterField().getArray()[0],4.1,12)
16575         # QUAD4 - spacedim = 2
16576         coo=DataArrayDouble([(0,2),(2,0),(6,4),(4,9)])
16577         m=MEDCoupling1SGTUMesh("mesh",NORM_QUAD4) ; m.setCoords(coo)
16578         exp3=sqrt(85.)
16579         for delta in xrange(4):
16580             c=[(elt+delta)%4 for elt in xrange(4)]
16581             m.setNodalConnectivity(DataArrayInt(c))
16582             self.assertAlmostEqual(m.computeDiameterField().getArray()[0],exp3,12)
16583             m2=m.buildUnstructured() ; m2.convertLinearCellsToQuadratic(0)
16584             self.assertAlmostEqual(m2.computeDiameterField().getArray()[0],exp3,12)
16585             m3=m.buildUnstructured() ; m3.convertLinearCellsToQuadratic(1)
16586             self.assertAlmostEqual(m3.computeDiameterField().getArray()[0],exp3,12)
16587             c.reverse()
16588             m.setNodalConnectivity(DataArrayInt(c))
16589             self.assertAlmostEqual(m.computeDiameterField().getArray()[0],exp3,12)
16590             m2=m.buildUnstructured() ; m2.convertLinearCellsToQuadratic(0)
16591             self.assertAlmostEqual(m2.computeDiameterField().getArray()[0],exp3,12)
16592             m3=m.buildUnstructured() ; m3.convertLinearCellsToQuadratic(1)
16593             self.assertAlmostEqual(m3.computeDiameterField().getArray()[0],exp3,12)
16594         # QUAD4 - spacedim = 3
16595         coo=DataArrayDouble([(0.26570992384234871,2.0405889913271817,-0.079134238105786903),(2.3739976619218064,0.15779148692781009,0.021842842914139737),(6.1207841448393197,4.3755532938679655,0.43666375769970678),(3.8363255342943359,9.2521096041694229,0.41551170895942313)])
16596         m=MEDCoupling1SGTUMesh("mesh",NORM_QUAD4) ; m.setCoords(coo)
16597         for delta in xrange(4):
16598             c=[(elt+delta)%4 for elt in xrange(4)]
16599             m.setNodalConnectivity(DataArrayInt(c))
16600             self.assertAlmostEqual(m.computeDiameterField().getArray()[0],exp3,12)
16601             m2=m.buildUnstructured() ; m2.convertLinearCellsToQuadratic(0)
16602             self.assertAlmostEqual(m2.computeDiameterField().getArray()[0],exp3,12)
16603             m3=m.buildUnstructured() ; m3.convertLinearCellsToQuadratic(1)
16604             self.assertAlmostEqual(m3.computeDiameterField().getArray()[0],exp3,12)
16605             c.reverse()
16606             m.setNodalConnectivity(DataArrayInt(c))
16607             self.assertAlmostEqual(m.computeDiameterField().getArray()[0],exp3,12)
16608             m2=m.buildUnstructured() ; m2.convertLinearCellsToQuadratic(0)
16609             self.assertAlmostEqual(m2.computeDiameterField().getArray()[0],exp3,12)
16610             m3=m.buildUnstructured() ; m3.convertLinearCellsToQuadratic(1)
16611             self.assertAlmostEqual(m3.computeDiameterField().getArray()[0],exp3,12)
16612         # PENTA6
16613         # noise of coo=DataArrayDouble([(0,0,0),(1,0,0),(0,1,0),(0,0,2),(1,0,2),(0,1,2)]) + rotation([0.7,-1.2,0.6],[-4,-1,10],0.3)
16614         coo=DataArrayDouble([(-0.28594726851554486,-0.23715005500928255,-0.10268080010083136),(0.6167364988633947,-0.008923258436324799,-0.08574087516687756),(-0.6132873463333834,0.6943403970881654,-0.2806118260037991),(-0.40705974936532896,-0.05868487929989308,1.7724055544436323),(0.5505955507861958,0.19145393798144705,1.8788156352163994),(-0.6092686217773406,0.812502961290914,1.685712743757831)])
16615         m=MEDCoupling1SGTUMesh("mesh",NORM_PENTA6) ; m.setCoords(coo)
16616         exp4=2.5041256256889888
16617         self.assertAlmostEqual(exp4,coo.buildEuclidianDistanceDenseMatrix().getMaxValue()[0],12)# <- the definition of diameter
16618         for delta in xrange(3):
16619             c=[(elt+delta)%3 for elt in xrange(3)]
16620             c+=[elt+3 for elt in c]
16621             m.setNodalConnectivity(DataArrayInt(c))
16622             self.assertAlmostEqual(m.computeDiameterField().getArray()[0],exp4,12)
16623             m2=m.buildUnstructured() ; m2.convertLinearCellsToQuadratic(0)
16624             self.assertAlmostEqual(m2.computeDiameterField().getArray()[0],exp4,12)
16625             c.reverse()
16626             m.setNodalConnectivity(DataArrayInt(c))
16627             self.assertAlmostEqual(m.computeDiameterField().getArray()[0],exp4,12)
16628             m2=m.buildUnstructured() ; m2.convertLinearCellsToQuadratic(0)
16629             self.assertAlmostEqual(m2.computeDiameterField().getArray()[0],exp4,12)
16630         # HEXA8
16631         # noise of coo=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)]) + rotation([0.7,-1.2,0.6],[-4,-1,10],0.3)
16632         coo=DataArrayDouble([(-0.21266406388867243,-0.3049569460042527,-0.11012394815006032),(0.7641037943272584,-0.06990814759929553,-0.0909613877456491),(0.47406560768559974,0.8681310650341907,-0.2577311403703061),(-0.5136830410871793,0.644390554940524,-0.21319015989794698),(-0.4080167737381202,-0.12853761670628505,1.7869166291979348),(0.5650318811550441,0.20476257733110748,1.8140158890821603),(0.3230844436386215,1.1660778242678538,1.7175073141333406),(-0.6656588358432984,0.918357550969698,1.7566470691880265)])
16633         m=MEDCoupling1SGTUMesh("mesh",NORM_HEXA8) ; m.setCoords(coo)
16634         exp5=2.5366409441884215
16635         self.assertAlmostEqual(exp5,coo.buildEuclidianDistanceDenseMatrix().getMaxValue()[0],12)# <- the definition of diameter
16636         for delta in xrange(4):
16637             c=[(elt+delta)%4 for elt in xrange(4)]
16638             c+=[elt+4 for elt in c]
16639             m.setNodalConnectivity(DataArrayInt(c))
16640             self.assertAlmostEqual(m.computeDiameterField().getArray()[0],exp5,12)
16641             m2=m.buildUnstructured() ; m2.convertLinearCellsToQuadratic(0)
16642             self.assertAlmostEqual(m2.computeDiameterField().getArray()[0],exp5,12)
16643             c.reverse()
16644             m.setNodalConnectivity(DataArrayInt(c))
16645             self.assertAlmostEqual(m.computeDiameterField().getArray()[0],exp5,12)
16646             m2=m.buildUnstructured() ; m2.convertLinearCellsToQuadratic(0)
16647             self.assertAlmostEqual(m2.computeDiameterField().getArray()[0],exp5,12)
16648         # PYRA5 (1) 5th node is further
16649         # noise of coo=DataArrayDouble([(0,0,0),(1,0,0),(1,1,0),(0,1,0),(0.5,0.5,2)]) + rotation([0.7,-1.2,0.6],[-4,-1,10],0.3)
16650         coo=DataArrayDouble([(-0.31638393672228626,-0.3157865246451914,-0.12555467233075002),(0.7281379795666488,0.03836511217237115,-0.08431662762197323),(0.4757967840735147,0.8798897996143908,-0.2680890320119049),(-0.5386339871809047,0.5933159894201252,-0.2975311238319419),(0.012042592988768974,0.534282135495012,1.7859521682027926)])
16651         m=MEDCoupling1SGTUMesh("mesh",NORM_PYRA5) ; m.setCoords(coo)
16652         exp6=2.1558368027391386
16653         self.assertAlmostEqual(exp6,coo.buildEuclidianDistanceDenseMatrix().getMaxValue()[0],12)# <- the definition of diameter
16654         for delta in xrange(4):
16655             c=[(elt+delta)%4 for elt in xrange(4)]
16656             c+=[4]
16657             m.setNodalConnectivity(DataArrayInt(c))
16658             self.assertAlmostEqual(m.computeDiameterField().getArray()[0],exp6,12)
16659             m2=m.buildUnstructured() ; m2.convertLinearCellsToQuadratic(0)
16660             self.assertAlmostEqual(m2.computeDiameterField().getArray()[0],exp6,12)
16661             pass
16662         # PYRA5 (2) 5th node is closer
16663         # noise of coo=DataArrayDouble([(0,0,0),(1,0,0),(1,1,0),(0,1,0),(0.5,0.5,0.1)]) + rotation([0.7,-1.2,0.6],[-4,-1,10],0.3)
16664         coo=DataArrayDouble([(-0.31638393672228626,-0.3157865246451914,-0.12555467233075002),(0.7281379795666488,0.03836511217237115,-0.08431662762197323),(0.4757967840735147,0.8798897996143908,-0.2680890320119049),(-0.5386339871809047,0.5933159894201252,-0.2975311238319419),(0.092964408350795,0.33389670321297005,-0.10171764888060142)])
16665         m=MEDCoupling1SGTUMesh("mesh",NORM_PYRA5) ; m.setCoords(coo)
16666         exp7=1.4413563787228953
16667         self.assertAlmostEqual(exp7,coo.buildEuclidianDistanceDenseMatrix().getMaxValue()[0],12)# <- the definition of diameter
16668         for delta in xrange(4):
16669             c=[(elt+delta)%4 for elt in xrange(4)]
16670             c+=[4]
16671             m.setNodalConnectivity(DataArrayInt(c))
16672             self.assertAlmostEqual(m.computeDiameterField().getArray()[0],exp7,12)
16673             m2=m.buildUnstructured() ; m2.convertLinearCellsToQuadratic(0)
16674             self.assertAlmostEqual(m2.computeDiameterField().getArray()[0],exp7,12)
16675             pass
16676         # TETRA4
16677         # noise of coo=DataArrayDouble([(0,0,0),(1,0,0),(0,1,0),(1,1,1)]) + rotation([0.7,-1.2,0.6],[-4,-1,10],0.3)
16678         coo=DataArrayDouble([(-0.2256894071281369,-0.27631691290428106,-0.20266086543995965),(0.655458695100186,-0.08173323565551605,-0.19254662462061933),(-0.49893490718947264,0.5848097154568599,-0.3039928255382145),(0.2988102920828487,1.0582266398878504,0.7347375047372364)])
16679         m=MEDCoupling1SGTUMesh("mesh",NORM_TETRA4) ; m.setCoords(coo)
16680         exp8=1.7131322579364157
16681         self.assertAlmostEqual(exp8,coo.buildEuclidianDistanceDenseMatrix().getMaxValue()[0],12)# <- the definition of diameter
16682         for c in [[0,1,2,3],[0,3,2,1],[0,1,3,2],[0,2,3,1],[0,3,1,2],[0,2,1,3]]:
16683             for i in xrange(4):
16684                 m.setNodalConnectivity(DataArrayInt([(elt+i)%4 for elt in c]))
16685                 self.assertAlmostEqual(m.computeDiameterField().getArray()[0],exp8,12)
16686                 m2=m.buildUnstructured() ; m2.convertLinearCellsToQuadratic(0)
16687                 self.assertAlmostEqual(m2.computeDiameterField().getArray()[0],exp8,12)
16688                 pass
16689             pass
16690         pass
16691
16692     def testMEDCouplingSkyLineArray(self):
16693         index = DataArrayInt([ 0, 3, 5, 6, 6 ])
16694         value = DataArrayInt([ 1, 2, 3, 2, 3, 3 ])
16695
16696         sla0 = MEDCouplingSkyLineArray()
16697         self.assertEqual( -1, sla0.getNumberOf() )
16698         self.assertEqual( 0,  sla0.getLength() )
16699         sla0.set( index, value )
16700         self.assertTrue( index.isEqual( sla0.getIndexArray() ))
16701         self.assertTrue( value.isEqual( sla0.getValueArray() ))
16702         self.assertEqual( 4, sla0.getNumberOf() )
16703         self.assertEqual( 6, sla0.getLength() )
16704
16705         sla1 = MEDCouplingSkyLineArray( index, value )
16706         self.assertTrue( index.isEqual( sla1.getIndexArray() ))
16707         self.assertTrue( value.isEqual( sla1.getValueArray() ))
16708         self.assertEqual( 4, sla1.getNumberOf() )
16709         self.assertEqual( 6, sla1.getLength() )
16710
16711         sla2 = MEDCouplingSkyLineArray( sla1 )
16712         self.assertTrue( index.isEqual( sla2.getIndexArray() ))
16713         self.assertTrue( value.isEqual( sla2.getValueArray() ))
16714         self.assertEqual( 4, sla2.getNumberOf() )
16715         self.assertEqual( 6, sla2.getLength() )
16716
16717         indexVec = ivec(); indexVec.reserve( len( index ))
16718         for i in index: indexVec.push_back( i[0] )
16719         valueVec = ivec(); valueVec.reserve( len( value ))
16720         for i in value: valueVec.push_back( i[0] )
16721         sla3 = MEDCouplingSkyLineArray( indexVec, valueVec )
16722         self.assertTrue( index.isEqual( sla3.getIndexArray() ))
16723         self.assertTrue( value.isEqual( sla3.getValueArray() ))
16724         self.assertEqual( 4, sla3.getNumberOf() )
16725         self.assertEqual( 6, sla3.getLength() )
16726
16727         pass
16728
16729     def testMEDCouplingUMeshgenerateGraph(self):
16730         # cartesian mesh 3x3
16731         arr=DataArrayDouble(4) ; arr.iota()
16732         c=MEDCouplingCMesh() ; c.setCoords(arr,arr)
16733         m=c.buildUnstructured()
16734         graph = m.generateGraph()
16735         # 0 1 2
16736         # 3 4 5
16737         # 6 7 8
16738         valRef=[ 0,1,3,
16739                  0,1,2,4,
16740                  1,2,5,
16741                  0,3,4,6,
16742                  1,3,4,5,7,
16743                  2,4,5,8,
16744                  3,6,7,
16745                  4,6,7,8,
16746                  5,7,8]
16747         self.assertEqual(valRef,list(graph.getValueArray().getValues()));
16748
16749         indRef=[0, 3, 7, 10, 14, 19, 23, 26, 30, 33]
16750         self.assertEqual(indRef,list(graph.getIndexArray().getValues()));
16751         pass
16752
16753     def testSwig2MEDCouplingCurveLinearReprQuick1(self):
16754         """Non regression test. Error in m.__str__ when m is a MEDCouplingCurveLinear with spaceDim != meshDim."""
16755         arr=DataArrayDouble(12) ; arr.iota() ; arr.rearrange(2)
16756         m=MEDCouplingCurveLinearMesh()
16757         m.setCoords(arr)
16758         m.setNodeGridStructure([3,2])
16759         m.checkCoherency()
16760         self.assertEqual(m.getMeshDimension(),2)
16761         self.assertEqual(m.getSpaceDimension(),2)
16762         self.assertTrue(not "mismatch" in m.__str__())
16763         self.assertTrue(not "mismatch" in m.__repr__())
16764         #
16765         arr=DataArrayDouble(18) ; arr.iota() ; arr.rearrange(3)
16766         m.setCoords(arr)
16767         self.assertEqual(m.getMeshDimension(),2)
16768         self.assertEqual(m.getSpaceDimension(),3)
16769         self.assertTrue(not "mismatch" in m.__str__())
16770         self.assertTrue(not "mismatch" in m.__repr__())# bug was here !
16771         pass
16772
16773     pass
16774
16775 if __name__ == '__main__':
16776     unittest.main()