src/MEDCoupling_Swig/MEDCouplingBasicsTest.py

   1 #  -*- coding: iso-8859-1 -*-
   2 # Copyright (C) 2007-2012  CEA/DEN, EDF R&D
   3 #
   4 # This library is free software; you can redistribute it and/or
   5 # modify it under the terms of the GNU Lesser General Public
   6 # License as published by the Free Software Foundation; either
   7 # version 2.1 of the License.
   8 #
   9 # This library is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 # Lesser General Public License for more details.
  13 #
  14 # You should have received a copy of the GNU Lesser General Public
  15 # License along with this library; if not, write to the Free Software
  16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  17 #
  18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  19 #
  20
  21 from MEDCoupling import *
  22 import unittest
  23 from math import pi,e,sqrt,cos,sin
  24 from MEDCouplingDataForTest import MEDCouplingDataForTest
  25
  26 class MEDCouplingBasicsTest(unittest.TestCase):
  27     def testArray2(self):
  28         arr=DataArrayDouble.New()
  29         arr.setValues([12.,11.,10.,9.,8.,7.,6.,5.,4.,3.,2.,1.],3,4)
  30         arr.setInfoOnComponent(0,"ggg");
  31         arr.setInfoOnComponent(1,"hhhh");
  32         arr.setInfoOnComponent(2,"jj");
  33         arr.setInfoOnComponent(3,"kkkkkk");
  34         arr2=arr.convertToIntArr();
  35         arr3=arr2.convertToDblArr();
  36         self.assertTrue(arr.isEqual(arr3,1e-14))
  37         pass
  38
  39     def testArray3(self):
  40         arr1=DataArrayInt.New();
  41         arr1Ref=[0,10,1,11,2,12,3,13,4,14,5,15,6,16]
  42         arr1.setValues(arr1Ref,7,2);
  43         self.assertEqual(7,arr1.getNumberOfTuples());
  44         self.assertEqual(2,arr1.getNumberOfComponents());
  45         self.assertEqual(arr1Ref,list(arr1.getValues()));
  46         arr2=arr1.substr(3);
  47         self.assertEqual(4,arr2.getNumberOfTuples());
  48         self.assertEqual(2,arr2.getNumberOfComponents());
  49         self.assertEqual(arr1Ref[6:],list(arr2.getValues()));
  50         arr3=arr1.substr(2,5);
  51         self.assertEqual(3,arr3.getNumberOfTuples());
  52         self.assertEqual(2,arr3.getNumberOfComponents());
  53         self.assertEqual(arr1Ref[4:10],list(arr3.getValues()));
  54         #
  55         arr4=DataArrayDouble.New();
  56         arr4Ref=[0.8,10.8,1.9,11.9,2.1,12.1,3.2,13.2,4.3,14.3,5.4,15.4,6.5,16.5]
  57         arr4.setValues(arr4Ref,7,2);
  58         self.assertEqual(7,arr4.getNumberOfTuples());
  59         self.assertEqual(2,arr4.getNumberOfComponents());
  60         tmp=arr4.getValues()
  61         for i in xrange(14):
  62             self.assertTrue(abs(arr4Ref[i]-tmp[i])<1e-14);
  63             pass
  64         arr5=arr4.substr(3);
  65         self.assertEqual(4,arr5.getNumberOfTuples());
  66         self.assertEqual(2,arr5.getNumberOfComponents());
  67         tmp=arr5.getValues()
  68         for i in xrange(8):
  69             self.assertTrue(abs(arr4Ref[6+i]-tmp[i])<1e-14);
  70             pass
  71         arr6=arr4.substr(2,5);
  72         self.assertEqual(3,arr6.getNumberOfTuples());
  73         self.assertEqual(2,arr6.getNumberOfComponents());
  74         tmp=arr6.getValues()
  75         for i in xrange(6):
  76             self.assertTrue(abs(arr4Ref[4+i]-tmp[i])<1e-14);
  77             pass
  78         pass
  79
  80     def testMesh(self):
  81         tab4=[1, 2, 8, 7, 2, 3, 9, 8, 3,
  82               4, 10, 9, 4, 5, 11, 10, 5,
  83               0, 6, 11, 0, 1, 7, 6 ]
  84         nbOfNodes=12
  85         nbOfCells=6
  86         coords=[ 0.024155, 0.04183768725682622, -0.305, 0.04831000000000001, -1.015761910347357e-17,
  87                  -0.305, 0.09662000000000001, -1.832979297858306e-18, -0.305, 0.120775, 0.04183768725682623,
  88                  -0.305, 0.09662000000000001, 0.08367537451365245, -0.305, 0.04831000000000001, 0.08367537451365246,
  89                  -0.305, 0.024155, 0.04183768725682622, -0.2863, 0.04831000000000001, -1.015761910347357e-17, -0.2863,
  90                  0.09662000000000001, -1.832979297858306e-18, -0.2863, 0.120775, 0.04183768725682623, -0.2863, 0.09662000000000001,
  91                  0.08367537451365245, -0.2863, 0.04831000000000001, 0.08367537451365246, -0.2863 ]
  92         mesh=MEDCouplingUMesh.New()
  93         mesh.setMeshDimension(2)
  94         mesh.allocateCells(8);
  95         mesh.setName("mesh1")
  96         self.assertTrue(mesh.getName()=="mesh1")
  97         for i in range(nbOfCells):
  98             mesh.insertNextCell(NORM_QUAD4,4,tab4[4*i:4*(i+1)]);
  99             pass
 100         mesh.finishInsertingCells()
 101         self.assertTrue(mesh.getNumberOfCells()==nbOfCells)
 102         self.assertTrue(mesh.getNodalConnectivity().getNbOfElems()==30)
 103         self.assertTrue(mesh.getNodalConnectivityIndex().getNbOfElems()==nbOfCells+1)
 104         myCoords=DataArrayDouble.New()
 105         myCoords.setValues(coords,nbOfNodes,3);
 106         self.assertTrue(myCoords.getIJ(3,2)==-0.305)
 107         mesh.setCoords(myCoords);
 108         mesh.checkCoherency();
 109         self.assertTrue(mesh.getAllTypes()==[4])
 110         myFalseConn=DataArrayInt.New()
 111         myFalseConn.setValues(tab4,6,4)
 112         self.assertTrue(myFalseConn.getIJ(1,1)==3)
 113         #
 114         field=MEDCouplingFieldDouble.New(ON_CELLS)
 115         field.setMesh(mesh)
 116         field.setNature(Integral)
 117         myCoords=DataArrayDouble.New()
 118         sampleTab=[]
 119         for i in range(nbOfCells*9):
 120             sampleTab.append(float(i))
 121         myCoords.setValues(sampleTab,nbOfCells,9);
 122         field.setArray(myCoords)
 123         self.assertTrue(3==mesh.getSpaceDimension())
 124         field.checkCoherency()
 125         mesh2=mesh.clone(False)
 126         mesh3=mesh.clone(True)
 127         mesh3=0
 128         mesh2=0
 129         ## deep full recursively copy of field -> both field and mesh underneath copied
 130         field2=field.clone(True)
 131         field2.setMesh(field.getMesh().clone(True))
 132         mesh3=mesh.clone(True)
 133         field3=mesh3.fillFromAnalytic(ON_CELLS,2,"x*IVec+(y+z)*JVec")
 134         field3.applyFunc("u*u*u+cos(u)")
 135         pass
 136
 137     def testMeshPointsCloud(self):
 138         targetCoords=[-0.3,-0.3,0.5, 0.2,-0.3,1., 0.7,-0.3,1.5,
 139                       -0.3,0.2,0.5, 0.2,0.2,1., 0.7,0.2,1.5, -0.3,0.7,0.5, 0.2,0.7,1., 0.7,0.7,1.5]
 140         targetMesh=MEDCouplingUMesh.New();
 141         targetMesh.setMeshDimension(0);
 142         targetMesh.allocateCells(8);
 143         targetMesh.insertNextCell(NORM_POINT1,1,[0]);
 144         targetMesh.insertNextCell(NORM_POINT1,1,[1]);
 145         targetMesh.insertNextCell(NORM_POINT1,1,[2]);
 146         targetMesh.insertNextCell(NORM_POINT1,1,[3]);
 147         targetMesh.insertNextCell(NORM_POINT1,1,[4]);
 148         targetMesh.insertNextCell(NORM_POINT1,1,[5]);
 149         targetMesh.insertNextCell(NORM_POINT1,1,[7]);
 150         targetMesh.insertNextCell(NORM_POINT1,1,[6]);
 151         targetMesh.finishInsertingCells();
 152         myCoords=DataArrayDouble.New();
 153         myCoords.setValues(targetCoords,9,3);
 154         targetMesh.setCoords(myCoords);
 155         self.assertEqual(targetMesh.getSpaceDimension(),3)
 156         self.assertEqual(targetMesh.getNumberOfCells(),8)
 157         self.assertEqual(targetMesh.getNumberOfNodes(),9)
 158         self.assertEqual(targetMesh.getMeshDimension(),0)
 159         pass
 160
 161     def testMeshM1D(self):
 162         meshM1D=MEDCouplingUMesh.New();
 163         self.assertRaises(InterpKernelException,meshM1D.getMeshDimension);
 164         self.assertRaises(InterpKernelException,meshM1D.getNumberOfNodes);
 165         self.assertRaises(InterpKernelException,meshM1D.getNumberOfCells);
 166         self.assertRaises(InterpKernelException,meshM1D.setMeshDimension,-2)
 167         self.assertRaises(InterpKernelException,meshM1D.setMeshDimension,-10)
 168         meshM1D.setMeshDimension(-1);
 169         meshM1D.checkCoherency();
 170         self.assertEqual(meshM1D.getMeshDimension(),-1);
 171         self.assertEqual(meshM1D.getNumberOfCells(),1);
 172         self.assertRaises(InterpKernelException,meshM1D.getNumberOfNodes);
 173         self.assertRaises(InterpKernelException,meshM1D.getSpaceDimension);
 174         cpy=meshM1D.clone(True);
 175         self.assertTrue(cpy.isEqual(meshM1D,1e-12));
 176         fieldOnCells=MEDCouplingFieldDouble.New(ON_CELLS);
 177         fieldOnCells.setMesh(meshM1D);
 178         array=DataArrayDouble.New();
 179         array.setValues(6*[7.],1,6);
 180         fieldOnCells.setArray(array);
 181         fieldOnCells.checkCoherency();
 182         pass
 183
 184     def testDeepCopy(self):
 185         array=DataArrayDouble.New();
 186         array.setValues(5*3*[7.],5,3);
 187         self.assertEqual(array.getIJ(3,2),7.);
 188         array2=array.deepCpy();
 189         self.assertEqual(array2.getIJ(3,2),7.)
 190         #
 191         array3=DataArrayInt.New();
 192         array3.setValues(5*3*[17],5,3);
 193         self.assertEqual(array3.getIJ(3,2),17);
 194         array4=array3.deepCpy();
 195         self.assertEqual(array4.getIJ(3,2),17);
 196         pass
 197
 198     def testRevNodal(self):
 199         mesh=MEDCouplingDataForTest.build2DTargetMesh_1()
 200         revNodal,revNodalIndx=mesh.getReverseNodalConnectivity();
 201         revNodalExpected=[0,0,1,1,2,0,3,0,1,2,3,4,2,4,3,3,4,4];
 202         revNodalIndexExpected=[0,1,3,5,7,12,14,15,17,18];
 203         self.assertEqual(revNodal.getNbOfElems(),18)
 204         self.assertEqual(revNodalIndx.getNbOfElems(),10)
 205         self.assertEqual(list(revNodal.getValues()),revNodalExpected)
 206         self.assertEqual(list(revNodalIndx.getValues()),revNodalIndexExpected)
 207         pass
 208
 209     def testConvertToPolyTypes(self):
 210         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
 211         elts=[1,3];
 212         mesh.convertToPolyTypes(elts);
 213         mesh.checkCoherency();
 214         self.assertEqual(5,mesh.getNumberOfCells());
 215         self.assertEqual(23,mesh.getNodalConnectivity().getNumberOfTuples());
 216         expected1=[4, 0, 3, 4, 1, 5, 1, 4, 2, 3, 4, 5, 2, 5, 6, 7, 4, 3, 4, 7, 8, 5, 4]
 217         self.assertEqual(expected1,list(mesh.getNodalConnectivity().getValues()));
 218         #
 219         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
 220         mesh.convertToPolyTypes(elts);
 221         mesh.checkCoherency();
 222         self.assertEqual(8,mesh.getNumberOfCells());
 223         self.assertEqual(114,mesh.getNodalConnectivity().getNumberOfTuples());
 224         mesh.convertToPolyTypes(elts);
 225         mesh.checkCoherency();
 226         self.assertEqual(8,mesh.getNumberOfCells());
 227         self.assertEqual(114,mesh.getNodalConnectivity().getNumberOfTuples());
 228         pass
 229
 230     def testDescConn2D(self):
 231         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
 232         desc=DataArrayInt.New();
 233         descIndx=DataArrayInt.New();
 234         revDesc=DataArrayInt.New();
 235         revDescIndx=DataArrayInt.New();
 236         mesh2=mesh.buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
 237         mesh2.checkCoherency();
 238         self.assertEqual(1,mesh2.getMeshDimension());
 239         self.assertEqual(13,mesh2.getNumberOfCells());
 240         self.assertEqual(14,revDescIndx.getNbOfElems()); self.assertEqual(14,revDescIndx.getNumberOfTuples());
 241         self.assertEqual(6,descIndx.getNbOfElems()); self.assertEqual(6,descIndx.getNumberOfTuples());
 242         self.assertEqual(18,desc.getNbOfElems()); self.assertEqual(18,desc.getNumberOfTuples());
 243         self.assertEqual(18,revDesc.getNbOfElems()); self.assertEqual(18,revDesc.getNumberOfTuples());
 244         expected1=[0,1,2,3, 2,4,5, 6,7,4, 8,9,1,10, 11,12,6,9];
 245         self.assertEqual(expected1,list(desc.getValues()));
 246         expected2=[0,4,7,10,14,18];
 247         self.assertEqual(expected2,list(descIndx.getValues()));
 248         expected3=[0,1,3,5,6,8,9,11,12,13,15,16,17,18];
 249         self.assertEqual(expected3,list(revDescIndx.getValues()));
 250         expected4=[0, 0,3, 0,1, 0, 1,2, 1, 2,4, 2, 3, 3,4, 3, 4, 4];
 251         self.assertEqual(expected4,list(revDesc.getValues()));
 252         conn=mesh2.getNodalConnectivity();
 253         connIndex=mesh2.getNodalConnectivityIndex();
 254         expected5=[0,3,6,9,12,15,18,21,24,27,30,33,36,39];
 255         self.assertEqual(expected5,list(connIndex.getValues()));
 256         expected6=[1, 0, 3, 1, 3, 4, 1, 4, 1, 1, 1, 0, 1, 4, 2, 1, 2, 1, 1, 4, 5, 1, 5, 2, 1, 6, 7, 1, 7, 4, 1, 3, 6, 1, 7, 8, 1, 8, 5];
 257         self.assertEqual(expected6,list(conn.getValues()));
 258         #
 259         eltsV=[1,3];
 260         mesh.convertToPolyTypes(eltsV);
 261         mesh.checkCoherency();
 262         #
 263         desc=DataArrayInt.New();
 264         descIndx=DataArrayInt.New();
 265         revDesc=DataArrayInt.New();
 266         revDescIndx=DataArrayInt.New();
 267         #
 268         mesh2=mesh.buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
 269         mesh2.checkCoherency();
 270         self.assertEqual(1,mesh2.getMeshDimension());
 271         self.assertEqual(13,mesh2.getNumberOfCells());
 272         self.assertEqual(14,revDescIndx.getNbOfElems()); self.assertEqual(14,revDescIndx.getNumberOfTuples());
 273         self.assertEqual(6,descIndx.getNbOfElems()); self.assertEqual(6,descIndx.getNumberOfTuples());
 274         self.assertEqual(18,desc.getNbOfElems()); self.assertEqual(18,desc.getNumberOfTuples());
 275         self.assertEqual(18,revDesc.getNbOfElems()); self.assertEqual(18,revDesc.getNumberOfTuples());
 276         self.assertEqual(expected1,list(desc.getValues()));
 277         self.assertEqual(expected2,list(descIndx.getValues()));
 278         self.assertEqual(expected3,list(revDescIndx.getValues()));
 279         self.assertEqual(expected4,list(revDesc.getValues()));
 280         conn=mesh2.getNodalConnectivity();
 281         connIndex=mesh2.getNodalConnectivityIndex();
 282         self.assertEqual(expected5,list(connIndex.getValues()));
 283         self.assertEqual(expected6,list(conn.getValues()));
 284         pass
 285
 286     def testDescConn3D(self):
 287         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
 288         desc=DataArrayInt.New();
 289         descIndx=DataArrayInt.New();
 290         revDesc=DataArrayInt.New();
 291         revDescIndx=DataArrayInt.New();
 292         #
 293         mesh2=mesh.buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
 294         mesh2.checkCoherency();
 295         self.assertEqual(2,mesh2.getMeshDimension());
 296         self.assertEqual(36,mesh2.getNumberOfCells());
 297         self.assertEqual(37,revDescIndx.getNbOfElems()); self.assertEqual(37,revDescIndx.getNumberOfTuples());
 298         self.assertEqual(9,descIndx.getNbOfElems()); self.assertEqual(9,descIndx.getNumberOfTuples());
 299         self.assertEqual(48,desc.getNbOfElems()); self.assertEqual(48,desc.getNumberOfTuples());
 300         self.assertEqual(48,revDesc.getNbOfElems()); self.assertEqual(48,revDesc.getNumberOfTuples());
 301         expected1=[0, 6, 12, 18, 24, 30, 36, 42, 48]
 302         expected2=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 3, 11, 12, 4, 13, 14, 15, 16, 17, 10, 18, 19, 13, 1, 20, 21, 22, 23, 24, 7, 25, 26, 27, 28, 22, 12, 29, 23, 30, 31, 32, 17, 33, 28, 34, 35, 30]
 303         expected3=[0, 1, 3, 4, 6, 8, 9, 10, 12, 13, 14, 16, 17, 19, 21, 22, 23, 24, 26, 27, 28, 29, 30, 32, 34, 35, 36, 37, 38, 40, 41, 43, 44, 45, 46, 47, 48]
 304         expected4=[0, 0, 4, 0, 0, 1, 0, 2, 0, 1, 1, 5, 1, 1, 1, 3, 2, 2, 6, 2, 3, 2, 2, 3, 3, 7, 3, 3, 4, 4, 4, 5, 4, 6, 4, 5, 5, 5, 5, 7, 6, 6, 7, 6, 6, 7, 7, 7]
 305         expected5=[0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95, 100, 105, 110, 115, 120, 125, 130, 135, 140, 145, 150, 155, 160, 165, 170, 175, 180]
 306         expected6=[4, 0, 1, 4, 3, 4, 9, 12, 13, 10, 4, 0, 9, 10, 1, 4, 1, 10, 13, 4, 4, 4, 13, 12, 3, 4, 3, 12, 9, 0, 4, 1, 2, 5, 4, 4, 10, 13, 14, 11, 4, 1, 10, 11, 2, 4, 2, 11, 14,
 307                    5, 4, 5, 14, 13, 4, 4, 3, 4, 7, 6, 4, 12, 15, 16, 13, 4, 4, 13, 16, 7, 4, 7, 16, 15, 6, 4, 6, 15, 12, 3, 4, 4, 5, 8, 7, 4, 13, 16, 17, 14, 4, 5, 14, 17, 8, 4, 8,
 308                    17, 16, 7, 4, 18, 21, 22, 19, 4, 9, 18, 19, 10, 4, 10, 19, 22, 13, 4, 13, 22, 21, 12, 4, 12, 21, 18, 9, 4, 19, 22, 23, 20, 4, 10, 19, 20, 11, 4, 11, 20, 23, 14, 4,
 309                    14, 23, 22, 13, 4, 21, 24, 25, 22, 4, 13, 22, 25, 16, 4, 16, 25, 24, 15, 4, 15, 24, 21, 12, 4, 22, 25, 26, 23, 4, 14, 23, 26, 17, 4, 17, 26, 25, 16]
 310         expected7=[4, 0, 1, 4, 3, 4, 9, 12, 13, 10, 4, 0, 9, 10, 1, 4, 1, 10, 13, 4, 4, 4, 13, 12, 3, 4, 3, 12, 9, 0, 5, 1, 2, 5, 4, 5, 10, 13, 14, 11, 5, 1, 10, 11, 2, 5, 2, 11, 14,
 311                    5, 5, 5, 14, 13, 4, 4, 3, 4, 7, 6, 4, 12, 15, 16, 13, 4, 4, 13, 16, 7, 4, 7, 16, 15, 6, 4, 6, 15, 12, 3, 5, 4, 5, 8, 7, 5, 13, 16, 17, 14, 5, 5, 14, 17, 8, 5, 8,
 312                    17, 16, 7, 4, 18, 21, 22, 19, 4, 9, 18, 19, 10, 4, 10, 19, 22, 13, 4, 13, 22, 21, 12, 4, 12, 21, 18, 9, 4, 19, 22, 23, 20, 4, 10, 19, 20, 11, 4, 11, 20, 23, 14, 4,
 313                    14, 23, 22, 13, 4, 21, 24, 25, 22, 4, 13, 22, 25, 16, 4, 16, 25, 24, 15, 4, 15, 24, 21, 12, 4, 22, 25, 26, 23, 4, 14, 23, 26, 17, 4, 17, 26, 25, 16]
 314
 315         self.assertEqual(expected1,list(descIndx.getValues()));
 316         self.assertEqual(expected2,list(desc.getValues()));
 317         self.assertEqual(expected3,list(revDescIndx.getValues()));
 318         self.assertEqual(expected4,list(revDesc.getValues()));
 319         self.assertEqual(expected5,list(mesh2.getNodalConnectivityIndex().getValues()));
 320         self.assertEqual(expected6,list(mesh2.getNodalConnectivity().getValues()));
 321         #
 322         eltsV=[1,3]
 323         mesh.convertToPolyTypes(eltsV);
 324         mesh.checkCoherency();
 325         desc=DataArrayInt.New();
 326         descIndx=DataArrayInt.New();
 327         revDesc=DataArrayInt.New();
 328         revDescIndx=DataArrayInt.New();
 329         mesh2=mesh.buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
 330         mesh2.checkCoherency();
 331         self.assertEqual(2,mesh2.getMeshDimension());
 332         self.assertEqual(36,mesh2.getNumberOfCells());
 333         self.assertEqual(37,revDescIndx.getNbOfElems()); self.assertEqual(37,revDescIndx.getNumberOfTuples());
 334         self.assertEqual(9,descIndx.getNbOfElems()); self.assertEqual(9,descIndx.getNumberOfTuples());
 335         self.assertEqual(48,desc.getNbOfElems()); self.assertEqual(48,desc.getNumberOfTuples());
 336         self.assertEqual(48,revDesc.getNbOfElems()); self.assertEqual(48,revDesc.getNumberOfTuples());
 337         self.assertEqual(expected1,list(descIndx.getValues()));
 338         self.assertEqual(expected2,list(desc.getValues()));
 339         self.assertEqual(expected3,list(revDescIndx.getValues()));
 340         self.assertEqual(expected4,list(revDesc.getValues()));
 341         self.assertEqual(expected5,list(mesh2.getNodalConnectivityIndex().getValues()));
 342         self.assertEqual(expected7,list(mesh2.getNodalConnectivity().getValues()));
 343         pass
 344
 345     def testFindBoundaryNodes(self):
 346         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
 347         boundaryNodes=mesh.findBoundaryNodes();
 348         expected1=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26];
 349         self.assertEqual(expected1,boundaryNodes.getValues());
 350         pass
 351
 352     def testBoundaryMesh(self):
 353         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
 354         mesh2=mesh.buildBoundaryMesh(False);
 355         self.assertEqual(24,mesh2.getNumberOfCells());
 356         self.assertEqual(26,mesh2.getNumberOfNodes());
 357         pass
 358
 359     def testBuildPartOfMySelf(self):
 360         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
 361         mesh.setName("Toto");
 362         tab1=[0,4]
 363         tab2=[0,2,3]
 364         #
 365         subMesh=mesh.buildPart(tab1)
 366         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
 367         subMesh=mesh.buildPartOfMySelf(tab1,True);
 368         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
 369         name=subMesh.getName();
 370         self.assertEqual(2,len(mesh.getAllTypes()));
 371         self.assertEqual(NORM_TRI3,mesh.getAllTypes()[0]);
 372         self.assertEqual(NORM_QUAD4,mesh.getAllTypes()[1]);
 373         self.assertEqual(1,len(subMesh.getAllTypes()));
 374         self.assertEqual(NORM_QUAD4,subMesh.getAllTypes()[0]);
 375         self.assertEqual(name,"PartOf_Toto");
 376         self.assertEqual(2,subMesh.getNumberOfCells());
 377         subConn=[4,0,3,4,1,4,7,8,5,4];
 378         subConnIndex=[0,5,10];
 379         self.assertEqual(10,subMesh.getNodalConnectivity().getNbOfElems());
 380         self.assertEqual(3,subMesh.getNodalConnectivityIndex().getNbOfElems());
 381         self.assertEqual(subConn[0:10],list(subMesh.getNodalConnectivity().getValues()));
 382         self.assertEqual(subConnIndex[0:3],list(subMesh.getNodalConnectivityIndex().getValues()));
 383         #
 384         subMesh=mesh.buildPartOfMySelf(tab2[0:3],True);
 385         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh));
 386         name=subMesh.getName();
 387         self.assertEqual(2,len(subMesh.getAllTypes()));
 388         self.assertEqual(NORM_TRI3,subMesh.getAllTypes()[0]);
 389         self.assertEqual(NORM_QUAD4,subMesh.getAllTypes()[1]);
 390         self.assertEqual(name,"PartOf_Toto");
 391         self.assertEqual(3,subMesh.getNumberOfCells());
 392         subConn2=[4,0,3,4,1,3,4,5,2,4,6,7,4,3]
 393         subConnIndex2=[0,5,9,14]
 394         self.assertEqual(14,subMesh.getNodalConnectivity().getNbOfElems());
 395         self.assertEqual(4,subMesh.getNodalConnectivityIndex().getNbOfElems());
 396         self.assertEqual(subConn2[0:14],list(subMesh.getNodalConnectivity().getValues()));
 397         self.assertEqual(subConnIndex2[0:4],list(subMesh.getNodalConnectivityIndex().getValues()));
 398         dd=DataArrayInt.New()
 399         dd.alloc(3,1)
 400         dd.iota(0)
 401         dd.setName("coucou")
 402         subMesh=subMesh.buildPartOfMySelf(dd,True);
 403         self.assertEqual("coucou",subMesh.getName());
 404         pass
 405
 406     def testBuildPartOfMySelfNode(self):
 407         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
 408         tab1=[5,7,8,4]
 409         subMesh=mesh.buildPartOfMySelfNode(tab1[0:4],True);
 410         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
 411         self.assertEqual(1,len(subMesh.getAllTypes()));
 412         self.assertEqual(NORM_QUAD4,subMesh.getAllTypes()[0]);
 413         self.assertEqual(1,subMesh.getNumberOfCells());
 414         self.assertEqual(5,subMesh.getNodalConnectivity().getNbOfElems());
 415         self.assertEqual(2,subMesh.getNodalConnectivityIndex().getNbOfElems());
 416         subConn=[4,7,8,5,4]
 417         subConnIndex=[0,5]
 418         self.assertEqual(subConn[0:5],list(subMesh.getNodalConnectivity().getValues()));
 419         self.assertEqual(subConnIndex[0:2],list(subMesh.getNodalConnectivityIndex().getValues()));
 420         #
 421         ddd=DataArrayInt.New()
 422         ddd.setValues(tab1[0:2],2,1)
 423         ddd.setName("ddd")
 424         subMesh=mesh.buildPartOfMySelfNode(ddd,False);
 425         self.assertEqual("ddd",subMesh.getName())
 426         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
 427         self.assertEqual(2,len(subMesh.getAllTypes()));
 428         self.assertEqual(NORM_TRI3,subMesh.getAllTypes()[0]);
 429         self.assertEqual(NORM_QUAD4,subMesh.getAllTypes()[1]);
 430         self.assertEqual(3,subMesh.getNumberOfCells());
 431         self.assertEqual(14,subMesh.getNodalConnectivity().getNbOfElems());
 432         self.assertEqual(4,subMesh.getNodalConnectivityIndex().getNbOfElems());
 433         subConn2=[3,4,5,2,4,6,7,4,3,4,7,8,5,4]
 434         subConnIndex2=[0,4,9,14]
 435         self.assertEqual(subConn2[0:14],list(subMesh.getNodalConnectivity().getValues()));
 436         self.assertEqual(subConnIndex2[0:4],list(subMesh.getNodalConnectivityIndex().getValues()));
 437         #testing the case where length of tab2 is greater than max number of node per cell.
 438         tab2=[0,3,2,1,4,5,6]
 439         subMesh=mesh.buildPartOfMySelfNode(tab2[0:7],True);
 440         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
 441         self.assertEqual(2,len(subMesh.getAllTypes()));
 442         self.assertEqual(NORM_TRI3,subMesh.getAllTypes()[0]);
 443         self.assertEqual(NORM_QUAD4,subMesh.getAllTypes()[1]);
 444         self.assertEqual(3,subMesh.getNumberOfCells());
 445         pass
 446
 447     def testZipCoords(self):
 448         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
 449         self.assertEqual(2,len(mesh.getAllTypes()));
 450         self.assertEqual(2,mesh.getSpaceDimension());
 451         self.assertEqual(9,mesh.getNumberOfNodes());
 452         self.assertEqual(5,mesh.getNumberOfCells());
 453         oldConn=mesh.getNodalConnectivity().getValues()[0:mesh.getNodalConnectivity().getNbOfElems()];
 454         oldConnIndex=mesh.getNodalConnectivityIndex().getValues()[0:mesh.getNumberOfCells()+1]
 455         oldCoords=mesh.getCoords();
 456         mesh.zipCoords();
 457         self.assertEqual(2,len(mesh.getAllTypes()));
 458         self.assertEqual(2,mesh.getSpaceDimension());
 459         self.assertEqual(9,mesh.getNumberOfNodes());
 460         self.assertEqual(5,mesh.getNumberOfCells());
 461         self.assertEqual(mesh.getCoords().getValues()[0:2*9],oldCoords.getValues());
 462         self.assertEqual(list(oldConn),list(mesh.getNodalConnectivity().getValues()));
 463         self.assertEqual(list(oldConnIndex),list(mesh.getNodalConnectivityIndex().getValues()));
 464         #
 465         tab1=[0,4]
 466         subMesh=mesh.buildPartOfMySelf(tab1,True);
 467         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
 468         traducer=subMesh.zipCoordsTraducer();
 469         expectedTraducer=[0, 1, -1, 2, 3, 4, -1, 5, 6]
 470         self.assertEqual(expectedTraducer,list(traducer.getValues()));
 471         self.assertEqual(NORM_QUAD4,subMesh.getAllTypes()[0]);
 472         self.assertEqual(2,subMesh.getNumberOfCells());
 473         subConn=[4,0,2,3,1,4,5,6,4,3]
 474         subConnIndex=[0,5,10]
 475         self.assertEqual(7,subMesh.getNumberOfNodes());
 476         self.assertEqual(10,subMesh.getNodalConnectivity().getNbOfElems());
 477         self.assertEqual(3,subMesh.getNodalConnectivityIndex().getNbOfElems());
 478         self.assertEqual(subConn,list(subMesh.getNodalConnectivity().getValues()));
 479         self.assertEqual(subConnIndex,list(subMesh.getNodalConnectivityIndex().getValues()));
 480         #
 481         subMesh=mesh.buildPartOfMySelf(tab1,False);
 482         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
 483         self.assertEqual(NORM_QUAD4,subMesh.getAllTypes()[0]);
 484         self.assertEqual(2,subMesh.getNumberOfCells());
 485         self.assertEqual(7,subMesh.getNumberOfNodes());
 486         self.assertEqual(10,subMesh.getNodalConnectivity().getNbOfElems());
 487         self.assertEqual(3,subMesh.getNodalConnectivityIndex().getNbOfElems());
 488         self.assertEqual(subConn,list(subMesh.getNodalConnectivity().getValues()));
 489         self.assertEqual(subConnIndex,list(subMesh.getNodalConnectivityIndex().getValues()));
 490         pass
 491
 492     def testZipConnectivity(self):
 493         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
 494         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
 495         cells1=[2,3,4]
 496         m3=m2.buildPartOfMySelf(cells1,True);
 497         self.assertTrue(isinstance(m3,MEDCouplingUMesh))
 498         m4=MEDCouplingDataForTest.build2DSourceMesh_1();
 499         m5=MEDCouplingUMesh.MergeUMeshes(m1,m3);
 500         m6=MEDCouplingUMesh.MergeUMeshes(m5,m4);
 501         #
 502         self.assertEqual(10,m6.getNumberOfCells());
 503         self.assertEqual(22,m6.getNumberOfNodes());
 504         (arr,areNodesMerged,newNbOfNodes)=m6.mergeNodes(1e-13);
 505         self.assertTrue(areNodesMerged);
 506         self.assertEqual(10,m6.getNumberOfCells());
 507         self.assertEqual(9,m6.getNumberOfNodes());
 508         #
 509         arr=m6.zipConnectivityTraducer(0);
 510         self.assertEqual(7,m6.getNumberOfCells());
 511         m7=m6.clone(True);
 512         arr=m6.zipConnectivityTraducer(0);
 513         self.assertTrue(m7.isEqual(m6,1e-12));
 514         self.assertEqual(7,m6.getNumberOfCells());
 515         pass
 516
 517     def testEqualMesh(self):
 518         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
 519         mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
 520         #
 521         self.assertTrue(mesh1.isEqual(mesh1,1e-12));
 522         #
 523         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
 524         self.assertTrue(mesh2.isEqual(mesh1,1e-12));
 525         pt=mesh2.getCoords().getValues();
 526         tmp=pt[1]
 527         mesh2.getCoords().setIJ(0,1,5.999);
 528         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
 529         self.assertTrue(not mesh2.isEqual(mesh1,1e-12));
 530         mesh2.getCoords().setIJ(0,1,tmp);
 531         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
 532         self.assertTrue(mesh2.isEqual(mesh1,1e-12));
 533         #
 534         pt2=mesh1.getNodalConnectivity().getValues();
 535         mesh1.getNodalConnectivity().setIJ(5,0,int(pt2[5])+1);
 536         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
 537         self.assertTrue(not mesh2.isEqual(mesh1,1e-12));
 538         mesh1.getNodalConnectivity().setIJ(5,0,int(pt2[5]));
 539         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
 540         self.assertTrue(mesh2.isEqual(mesh1,1e-12));
 541         #
 542         pt2=mesh1.getNodalConnectivityIndex().getValues();
 543         mesh1.getNodalConnectivityIndex().setIJ(1,0,int(pt2[1]+1));
 544         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
 545         self.assertTrue(not mesh2.isEqual(mesh1,1e-12));
 546         mesh1.getNodalConnectivityIndex().setIJ(1,0,int(pt2[1]));
 547         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
 548         self.assertTrue(mesh2.isEqual(mesh1,1e-12));
 549         #
 550         tmp3=mesh1.getName();
 551         mesh1.setName("lllll");
 552         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
 553         self.assertTrue(not mesh2.isEqual(mesh1,1e-12));
 554         mesh1.setName(tmp3);
 555         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
 556         self.assertTrue(mesh2.isEqual(mesh1,1e-12));
 557         #
 558         tmp3=mesh2.getCoords().getInfoOnComponent(1);
 559         mesh2.getCoords().setInfoOnComponent(1,"kkkkkk");
 560         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
 561         self.assertTrue(not mesh2.isEqual(mesh1,1e-12));
 562         mesh2.getCoords().setInfoOnComponent(1,tmp3);
 563         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
 564         self.assertTrue(mesh2.isEqual(mesh1,1e-12));
 565         pass
 566
 567     def testEqualFieldDouble(self):
 568         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
 569         mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
 570         #
 571         fieldOnCells1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
 572         fieldOnCells1.setMesh(mesh1);
 573         fieldOnCells2=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
 574         fieldOnCells2.setMesh(mesh2);
 575         #
 576         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 577         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 578         #
 579         fieldOnNodes1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
 580         self.assertTrue(not fieldOnCells1.isEqual(fieldOnNodes1,1e-12,1e-15));
 581         self.assertTrue(not fieldOnNodes1.isEqual(fieldOnCells1,1e-12,1e-15));
 582         #
 583         fieldOnCells2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
 584         self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 585         self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 586         fieldOnCells1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
 587         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 588         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 589         fieldOnCells1.setTime(4.,6,7);
 590         self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 591         self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 592         fieldOnCells2.setTime(4.,6,7);
 593         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 594         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 595         fieldOnCells1.setName("Power");
 596         self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 597         self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 598         fieldOnCells2.setName("Power");
 599         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 600         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 601         #
 602         fieldOnCells1.setMesh(mesh1);
 603         self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 604         self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 605         fieldOnCells2.setMesh(mesh1);
 606         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 607         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 608         arr=DataArrayDouble.New();
 609         arr.setName("popo");
 610         arr.setValues(mesh1.getNumberOfCells()*3*[6.],mesh1.getNumberOfCells(),3);
 611         fieldOnCells1.setArray(arr);
 612         self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 613         self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 614         fieldOnCells2.setArray(arr);
 615         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 616         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 617         #
 618         arr2=arr.deepCpy();
 619         fieldOnCells2.setArray(arr2);
 620         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 621         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 622         arr.setIJ(1,2,6.1);
 623         self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 624         self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 625         arr.setIJ(1,2,6.);
 626         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 627         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 628         arr2.setName("popo2");
 629         self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 630         self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 631         #
 632         arr2.setName("popo");
 633         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 634         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 635         #
 636         arr2.setInfoOnComponent(2,"jjj");
 637         self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 638         self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 639         arr.setInfoOnComponent(2,"jjj");
 640         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 641         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 642         pass
 643
 644     def testNatureChecking(self):
 645         field=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
 646         field.setNature(Integral);
 647         field.setNature(ConservativeVolumic);
 648         field.setNature(IntegralGlobConstraint);
 649         field=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
 650         field.setNature(ConservativeVolumic);
 651         self.assertRaises(InterpKernelException,field.setNature,Integral);
 652         self.assertRaises(InterpKernelException,field.setNature,IntegralGlobConstraint);
 653         pass
 654
 655     def testBuildSubMeshData(self):
 656         targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1()
 657         #check buildSubMesh on field on cells
 658         fieldCells=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
 659         fieldCells.setMesh(targetMesh);
 660         elts=[1,2,4]
 661         ret1,di=fieldCells.buildSubMeshData(elts);
 662         self.assertTrue(isinstance(ret1,MEDCouplingUMesh))
 663         self.assertEqual(3,ret1.getNumberOfCells());
 664         self.assertEqual(9,ret1.getNumberOfNodes());
 665         self.assertEqual(3,di.getNumberOfTuples());
 666         self.assertEqual(1,di.getNumberOfComponents());
 667         toCheck=di.getValues();
 668         self.assertTrue(elts,toCheck);
 669         #check buildSubMesh on field on nodes
 670         fieldNodes=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
 671         fieldNodes.setMesh(targetMesh);
 672         ret2,di=fieldNodes.buildSubMeshData(elts);
 673         self.assertTrue(isinstance(ret2,MEDCouplingUMesh))
 674         self.assertEqual(3,ret2.getNumberOfCells());
 675         self.assertEqual(6,ret2.getNumberOfNodes());
 676         self.assertEqual(6,di.getNumberOfTuples());
 677         self.assertEqual(1,di.getNumberOfComponents());
 678         toCheck=di.getValues();
 679         expected=[1,2,4,5,7,8]
 680         self.assertEqual(expected,list(toCheck));
 681         pass
 682
 683     def testExtrudedMesh1(self):
 684         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
 685         ext=MEDCouplingExtrudedMesh.New(mesh3D,mesh2D,1);
 686         self.assertEqual(18,ext.getNumberOfCells());
 687         self.assertEqual(60,ext.getNumberOfNodes());
 688         ids3D=ext.getMesh3DIds();
 689         ids3DExpected=[5,4,3,2,1,0, 11,10,9,8,7,6, 17,16,15,14,13,12]
 690         self.assertEqual(18,ids3D.getNumberOfTuples());
 691         self.assertEqual(1,ids3D.getNumberOfComponents());
 692         self.assertEqual(ids3DExpected,list(ids3D.getValues()));
 693         mesh1D=ext.getMesh1D();
 694         self.assertEqual(4,mesh1D.getNumberOfNodes());
 695         self.assertEqual(3,mesh1D.getNumberOfCells());
 696         mesh1DExpected=[0.66666666666666663, 1.4583333333333333, 0, 0.66666666666666663,
 697                         1.4583333333333333, 1, 0.66666666666666663, 1.4583333333333333,
 698                         2, 0.66666666666666663, 1.4583333333333333, 3]
 699         mesh1DCoords=mesh1D.getCoords();
 700         self.assertEqual(4,mesh1DCoords.getNumberOfTuples());
 701         self.assertEqual(3,mesh1DCoords.getNumberOfComponents());
 702         self.assertEqual(mesh1DExpected,mesh1DCoords.getValues());
 703         conn1D=mesh1D.getNodalConnectivity();
 704         self.assertEqual(9,conn1D.getNumberOfTuples());
 705         self.assertEqual(1,conn1D.getNumberOfComponents());
 706         conn1DExpected=[1,0,1,1,1,2,1,2,3]
 707         self.assertEqual(conn1DExpected,list(conn1D.getValues()));
 708         pass
 709
 710     def testExtrudedMesh3(self):
 711         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
 712         m1.changeSpaceDimension(3);
 713         m2=MEDCouplingDataForTest.buildCU1DMesh_U();
 714         m2.changeSpaceDimension(3);
 715         center=[0.,0.,0.]
 716         vector=[0.,1.,0.]
 717         m2.rotate(center,vector,-pi/2.);
 718         m3=m1.buildExtrudedMesh(m2,0);
 719         #
 720         m4=MEDCouplingExtrudedMesh.New(m3,m1,0);
 721         self.assertEqual(15,m4.getNumberOfCells());
 722         self.assertEqual(5,m4.getMesh2D().getNumberOfCells());
 723         self.assertEqual(3,m4.getMesh1D().getNumberOfCells());
 724         m3DIds=m4.getMesh3DIds().getValues();
 725         self.assertEqual(range(15),list(m3DIds));
 726         #some random in cells to check that extrusion alg find it correctly
 727         expected1=[1,3,2,0,6,5,7,10,11,8,12,9,14,13,4]
 728         m3.renumberCells(expected1,False);
 729         m4=MEDCouplingExtrudedMesh.New(m3,m1,0);
 730         self.assertEqual(15,m4.getNumberOfCells());
 731         self.assertEqual(5,m4.getMesh2D().getNumberOfCells());
 732         self.assertEqual(3,m4.getMesh1D().getNumberOfCells());
 733         m3DIds=m4.getMesh3DIds().getValues();
 734         self.assertEqual(expected1,list(m3DIds));
 735         #play with polygons and polyedrons
 736         cells=[2,3]
 737         m1.convertToPolyTypes(cells);
 738         m3=m1.buildExtrudedMesh(m2,0);
 739         self.assertEqual(NORM_HEXA8,m3.getTypeOfCell(0));
 740         self.assertEqual(NORM_PENTA6,m3.getTypeOfCell(1));
 741         self.assertEqual(NORM_POLYHED,m3.getTypeOfCell(2));
 742         self.assertEqual(NORM_POLYHED,m3.getTypeOfCell(3));
 743         self.assertEqual(NORM_HEXA8,m3.getTypeOfCell(4));
 744         m3.renumberCells(expected1,False);
 745         m4=MEDCouplingExtrudedMesh.New(m3,m1,0);
 746         self.assertEqual(15,m4.getNumberOfCells());
 747         self.assertEqual(5,m4.getMesh2D().getNumberOfCells());
 748         self.assertEqual(3,m4.getMesh1D().getNumberOfCells());
 749         m3DIds=m4.getMesh3DIds().getValues();
 750         self.assertEqual(expected1,list(m3DIds));
 751         pass
 752
 753     def testExtrudedMesh4(self):
 754         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
 755         cells=[2,4];
 756         m1.convertToPolyTypes(cells);
 757         m1.changeSpaceDimension(3);
 758         m2=MEDCouplingDataForTest.buildCU1DMesh_U();
 759         m2.changeSpaceDimension(3);
 760         center=[0.,0.,0.]
 761         vector=[0.,1.,0.]
 762         m2.rotate(center,vector,-pi/2.);
 763         m3=m1.buildExtrudedMesh(m2,0);
 764         expected1=[1,3,2,0,6,5,7,10,11,8,12,9,14,13,4]
 765         rexpected1=[3, 0, 2, 1, 14, 5, 4, 6, 9, 11, 7, 8, 10, 13, 12]
 766         m3.renumberCells(expected1,False);
 767         m4=MEDCouplingExtrudedMesh.New(m3,m1,0);
 768         self.assertEqual(NORM_HEXA8,m4.getTypeOfCell(0));
 769         self.assertEqual(NORM_HEXA8,m4.getTypeOfCell(1));
 770         self.assertEqual(NORM_POLYHED,m4.getTypeOfCell(2));
 771         self.assertEqual(NORM_PENTA6,m4.getTypeOfCell(7));
 772         f=m4.getMeasureField(True);
 773         arr=f.getArray();
 774         self.assertEqual(15,arr.getNumberOfTuples());
 775         self.assertEqual(1,arr.getNumberOfComponents());
 776         arrPtr=arr.getValues();
 777         expected2=[0.075,0.0375,0.0375,0.075,0.075,
 778                    0.1125,0.05625,0.05625,0.1125,0.1125,
 779                    0.0625,0.03125,0.03125,0.0625,0.0625]
 780         for i in xrange(15):
 781             self.assertAlmostEqual(expected2[rexpected1[i]],arrPtr[i],16);
 782             pass
 783         m5=m4.build3DUnstructuredMesh();
 784         self.assertTrue(m5.isEqual(m3,1e-12));
 785         f=m5.getMeasureField(True);
 786         f.setMesh(m4)
 787         self.assertTrue(isinstance(f.getMesh(),MEDCouplingExtrudedMesh))
 788         arr=f.getArray();
 789         arrPtr=arr.getValues();
 790         for i in xrange(15):
 791             self.assertAlmostEqual(expected2[rexpected1[i]],arrPtr[i],15);
 792             pass
 793         pass
 794
 795     def testFindCommonNodes(self):
 796         targetMesh=MEDCouplingDataForTest.build3DTargetMesh_1();
 797         comm,commI=targetMesh.findCommonNodes(1e-10,-1);
 798         self.assertEqual(1,commI.getNumberOfTuples());
 799         self.assertEqual(0,comm.getNumberOfTuples());
 800         o2n,newNbOfNodes=targetMesh.buildNewNumberingFromCommonNodesFormat(comm,commI);
 801         self.assertEqual(27,newNbOfNodes);
 802         self.assertEqual(27,o2n.getNumberOfTuples());
 803         o2nExp1=range(27)
 804         self.assertEqual(o2nExp1,list(o2n.getValues()));
 805         #
 806         targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
 807         self.assertEqual(31,targetMesh.getNumberOfNodes());
 808         comm,commI=targetMesh.findCommonNodes(1e-10);# testing default parameter
 809         self.assertEqual(3,commI.getNumberOfTuples());
 810         self.assertEqual(6,comm.getNumberOfTuples());
 811         commExpected=[1,27,28,29,23,30]
 812         commIExpected=[0,4,6]
 813         self.assertEqual(commExpected,list(comm.getValues()));
 814         self.assertEqual(commIExpected,list(commI.getValues()));
 815         o2n,newNbOfNodes=targetMesh.buildNewNumberingFromCommonNodesFormat(comm,commI);
 816         self.assertEqual(31,o2n.getNumberOfTuples());
 817         self.assertEqual(27,newNbOfNodes);
 818         o2nExp2=[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,
 819                  21,22,23,24,25,26,1,1,1,23]
 820         self.assertEqual(o2nExp2,list(o2n.getValues()));
 821         #
 822         targetMesh=MEDCouplingDataForTest.build3DTargetMesh_1();
 823         time=targetMesh.getTimeOfThis();
 824         o2n,areNodesMerged,newNbOfNodes=targetMesh.mergeNodes(1e-10);
 825         targetMesh.updateTime();
 826         self.assertEqual(time,targetMesh.getTimeOfThis());
 827         self.assertTrue(not areNodesMerged);
 828         #
 829         targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
 830         time=targetMesh.getTimeOfThis();
 831         o2n,areNodesMerged,newNbOfNodes=targetMesh.mergeNodes(1e-10);
 832         targetMesh.updateTime();
 833         self.assertTrue(time!=targetMesh.getTimeOfThis());
 834         self.assertTrue(areNodesMerged);
 835         connExp=[18,0,1,4,3,9,10,13,12, 18,1,2,5,4,10,11,14,13, 18,3,4,7,6,12,13,16,15,
 836                  18,4,5,8,7,13,14,17,16,
 837                  18,9,10,13,12,18,19,22,21, 18,10,11,14,13,19,20,23,22, 18,12,13,16,15,21,22,25,24,
 838                  18,13,14,17,16,22,23,26,25]
 839         self.assertEqual(72,targetMesh.getNodalConnectivity().getNumberOfTuples());
 840         self.assertEqual(connExp,list(targetMesh.getNodalConnectivity().getValues()));
 841         self.assertEqual(27,targetMesh.getCoords().getNumberOfTuples());
 842         coordsExp=[ 0., 0., 0., 50., 0., 0. , 200., 0., 0.  , 0., 50., 0., 50., 50., 0. ,
 843                     200., 50., 0.,   0., 200., 0., 50., 200., 0. , 200., 200., 0. ,
 844                     0., 0., 50., 50., 0., 50. , 200., 0., 50.  , 0., 50., 50., 50.,
 845                     50., 50. , 200., 50., 50.,   0., 200., 50., 50., 200., 50. ,
 846                     200., 200., 50. , 0., 0., 200., 50., 0., 200. , 200., 0., 200.
 847                     , 0., 50., 200., 50., 50., 200. , 200., 50., 200.,
 848                     0., 200., 200., 50., 200., 200. , 200., 200., 200. ]
 849         self.assertEqual(coordsExp,targetMesh.getCoords().getValues());
 850         # 2D
 851         targetMesh=MEDCouplingDataForTest.build2DTargetMeshMergeNode_1();
 852         self.assertEqual(18,targetMesh.getNumberOfNodes());
 853         time=targetMesh.getTimeOfThis();
 854         o2n,areNodesMerged,newNbOfNodes=targetMesh.mergeNodes(1e-10);
 855         self.assertTrue(time!=targetMesh.getTimeOfThis());
 856         self.assertTrue(areNodesMerged);
 857         self.assertEqual(9,targetMesh.getNumberOfNodes());
 858         connExp2=[4,0,4,3,1, 3,1,3,2, 3,3,5,2, 4,4,6,7,3, 4,7,8,5,3]
 859         self.assertEqual(23,targetMesh.getNodalConnectivity().getNumberOfTuples());
 860         self.assertEqual(connExp2,list(targetMesh.getNodalConnectivity().getValues()));
 861         coordsExp2=[-0.3,-0.3, 0.2,-0.3, 0.7,-0.3, 0.2,0.2, -0.3,0.2, 0.7,0.2, -0.3,0.7, 0.2,0.7, 0.7,0.7]
 862         self.assertEqual(9,targetMesh.getCoords().getNumberOfTuples());
 863         self.assertEqual(coordsExp2,targetMesh.getCoords().getValues());
 864         pass
 865
 866     def testCheckButterflyCells(self):
 867         sourceMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
 868         cells=sourceMesh.checkButterflyCells();
 869         self.assertEqual(0,len(cells));
 870         conn=sourceMesh.getNodalConnectivity()
 871         tmp=conn.getIJ(15,0)
 872         conn.setIJ(15,0,conn.getIJ(16,0))
 873         conn.setIJ(16,0,tmp)
 874         cells=sourceMesh.checkButterflyCells();
 875         self.assertEqual(1,len(cells));
 876         self.assertEqual([3],cells.getValues());
 877         tmp=conn.getIJ(15,0)
 878         conn.setIJ(15,0,conn.getIJ(16,0))
 879         conn.setIJ(16,0,tmp)
 880         cells=sourceMesh.checkButterflyCells();
 881         self.assertEqual(0,len(cells));
 882         # 3D surf
 883         sourceMesh=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
 884         cells=sourceMesh.checkButterflyCells();
 885         self.assertEqual(0,len(cells));
 886         conn=sourceMesh.getNodalConnectivity()
 887         tmp=conn.getIJ(15,0)
 888         conn.setIJ(15,0,conn.getIJ(16,0))
 889         conn.setIJ(16,0,tmp)
 890         cells=sourceMesh.checkButterflyCells();
 891         self.assertEqual(1,len(cells));
 892         self.assertEqual([3],cells.getValues());
 893         tmp=conn.getIJ(15,0)
 894         conn.setIJ(15,0,conn.getIJ(16,0))
 895         conn.setIJ(16,0,tmp)
 896         cells=sourceMesh.checkButterflyCells();
 897         self.assertEqual(0,len(cells));
 898         pass
 899
 900     def testMergeMesh1(self):
 901         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
 902         m2=MEDCouplingDataForTest.build2DSourceMesh_1();
 903         vec=[1.,0.]
 904         m2.translate(vec);
 905         m3=m1.mergeMyselfWith(m2);
 906         self.assertTrue(isinstance(m3,MEDCouplingUMesh));
 907         m3.checkCoherency();
 908         m4=MEDCouplingDataForTest.build2DTargetMeshMerged_1();
 909         self.assertTrue(m3.isEqual(m4,1.e-12));
 910         da,isMerged,newNbOfNodes=m3.mergeNodes(1.e-12);
 911         self.assertEqual(11,m3.getNumberOfNodes());
 912         self.assertTrue(isMerged);
 913         pass
 914
 915     def testMergeMeshOnSameCoords1(self):
 916         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
 917         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
 918         cells=range(5);
 919         m2.convertToPolyTypes(cells);
 920         m1.tryToShareSameCoords(m2,1e-12);
 921         m3=MEDCouplingDataForTest.build2DTargetMesh_1();
 922         m3.tryToShareSameCoords(m2,1e-12);
 923         meshes=[m1,m2,m3]
 924         m4=MEDCouplingUMesh.MergeUMeshesOnSameCoords(meshes);
 925         m4.checkCoherency();
 926         self.assertEqual(15,m4.getNumberOfCells());
 927         cells1=[0,1,2,3,4]
 928         m1_1=m4.buildPartOfMySelf(cells1,True);
 929         m1_1.setName(m1.getName());
 930         self.assertTrue(m1.isEqual(m1_1,1e-12));
 931         cells2=[5,6,7,8,9]
 932         m2_1=m4.buildPartOfMySelf(cells2,True);
 933         m2_1.setName(m2.getName());
 934         self.assertTrue(m2.isEqual(m2_1,1e-12));
 935         cells3=[10,11,12,13,14]
 936         m3_1=m4.buildPartOfMySelf(cells3,True);
 937         m3_1.setName(m3.getName());
 938         self.assertTrue(m3.isEqual(m3_1,1e-12));
 939         pass
 940
 941     def testMergeField1(self):
 942         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
 943         m2=MEDCouplingDataForTest.build2DSourceMesh_1();
 944         vec=[1.,0.]
 945         m2.translate(vec);
 946         f1=m1.getMeasureField(True);
 947         f2=m2.getMeasureField(True);
 948         f3=MEDCouplingFieldDouble.MergeFields(f1,f2);
 949         f3.checkCoherency();
 950         m4=MEDCouplingDataForTest.build2DTargetMeshMerged_1();
 951         self.assertTrue(f3.getMesh().isEqual(m4,1.e-12));
 952         name=f3.getName();
 953         self.assertEqual(name,"MeasureOfMesh_");
 954         self.assertEqual(f3.getTypeOfField(),ON_CELLS);
 955         self.assertEqual(f3.getTimeDiscretization(),NO_TIME);
 956         self.assertEqual(1,f3.getNumberOfComponents());
 957         self.assertEqual(7,f3.getNumberOfTuples());
 958         values=[0.25,0.125,0.125,0.25,0.25,0.5,0.5]
 959         tmp=f3.getArray().getValues();
 960         self.assertEqual(len(values),len(tmp))
 961         for i in xrange(7):
 962             self.assertTrue(abs(values[i]-tmp[i])<1e-12)
 963             pass
 964         pass
 965
 966     def testFillFromAnalytic(self):
 967         m=MEDCouplingDataForTest.build2DTargetMesh_1();
 968         f1=m.fillFromAnalytic(ON_CELLS,1,"x+y");
 969         f1.checkCoherency();
 970         self.assertEqual(f1.getTypeOfField(),ON_CELLS);
 971         self.assertEqual(f1.getTimeDiscretization(),NO_TIME);
 972         self.assertEqual(1,f1.getNumberOfComponents());
 973         self.assertEqual(5,f1.getNumberOfTuples());
 974         values1=[-0.1,0.23333333333333336,0.56666666666666665,0.4,0.9]
 975         tmp=f1.getArray().getValues();
 976         self.assertEqual(len(values1),len(tmp))
 977         for i in xrange(len(tmp)):
 978             self.assertTrue(abs(tmp[i]-values1[i])<1.e-12)
 979             pass
 980         #
 981         f1=m.fillFromAnalytic(ON_NODES,1,"x+y");
 982         f1.checkCoherency();
 983         self.assertEqual(f1.getTypeOfField(),ON_NODES);
 984         self.assertEqual(f1.getTimeDiscretization(),NO_TIME);
 985         self.assertEqual(1,f1.getNumberOfComponents());
 986         self.assertEqual(9,f1.getNumberOfTuples());
 987         values2=[-0.6,-0.1,0.4,-0.1,0.4,0.9,0.4,0.9,1.4]
 988         tmp=f1.getArray().getValues();
 989         self.assertEqual(len(values2),len(tmp))
 990         for i in xrange(len(tmp)):
 991             self.assertTrue(abs(tmp[i]-values2[i])<1.e-12)
 992             pass
 993         #
 994         f1=m.fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+(2*(x+y))*JVec");
 995         f1.checkCoherency();
 996         self.assertEqual(f1.getTypeOfField(),ON_NODES);
 997         self.assertEqual(f1.getTimeDiscretization(),NO_TIME);
 998         self.assertEqual(2,f1.getNumberOfComponents());
 999         self.assertEqual(9,f1.getNumberOfTuples());
1000         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]
1001         tmp=f1.getArray().getValues();
1002         self.assertEqual(len(values3),len(tmp))
1003         for i in xrange(len(tmp)):
1004             self.assertTrue(abs(tmp[i]-values3[i])<1.e-12)
1005             pass
1006         values4=f1.accumulate();
1007         self.assertEqual(2,len(values4))
1008         self.assertTrue(abs(3.6-values4[0])<1.e-12);
1009         self.assertTrue(abs(7.2-values4[1])<1.e-12);
1010         values4=f1.integral(True);
1011         self.assertEqual(2,len(values4))
1012         self.assertTrue(abs(0.5-values4[0])<1.e-12);
1013         self.assertTrue(abs(1.-values4[1])<1.e-12);
1014         #
1015         self.assertRaises(InterpKernelException,m.fillFromAnalytic,ON_NODES,1,"1./(x-0.2)");
1016         pass
1017
1018     def testFillFromAnalytic2(self):
1019         m=MEDCouplingDataForTest.build2DTargetMesh_1();
1020         f1=m.fillFromAnalytic(ON_CELLS,1,"y+x");
1021         f1.checkCoherency();
1022         self.assertEqual(f1.getTypeOfField(),ON_CELLS);
1023         self.assertEqual(f1.getTimeDiscretization(),NO_TIME);
1024         self.assertEqual(1,f1.getNumberOfComponents());
1025         self.assertEqual(5,f1.getNumberOfTuples());
1026         values1=[-0.1,0.23333333333333336,0.56666666666666665,0.4,0.9]
1027         tmp=f1.getArray().getValues();
1028         self.assertEqual(len(values1),len(tmp))
1029         for i in xrange(len(values1)):
1030             self.assertTrue(abs(values1[i]-tmp[i])<1.e-12);
1031             pass
1032         #
1033         f1=m.fillFromAnalytic(ON_NODES,1,"y+2*x");
1034         f1.checkCoherency();
1035         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1036         self.assertEqual(f1.getTimeDiscretization(),NO_TIME);
1037         self.assertEqual(1,f1.getNumberOfComponents());
1038         self.assertEqual(9,f1.getNumberOfTuples());
1039         values2=[-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1]
1040         tmp=f1.getArray().getValues();
1041         self.assertEqual(len(values2),len(tmp))
1042         for i in xrange(len(values2)):
1043             self.assertTrue(abs(values2[i]-tmp[i])<1.e-12);
1044             pass
1045         f1=m.fillFromAnalytic(ON_NODES,1,"2.*x+y");
1046         f1.checkCoherency();
1047         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1048         self.assertEqual(f1.getTimeDiscretization(),NO_TIME);
1049         self.assertEqual(1,f1.getNumberOfComponents());
1050         self.assertEqual(9,f1.getNumberOfTuples());
1051         tmp=f1.getArray().getValues();
1052         values2Bis=[-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1]
1053         self.assertEqual(len(values2Bis),len(tmp))
1054         for i in xrange(len(values2Bis)):
1055             self.assertTrue(abs(values2Bis[i]-tmp[i])<1.e-12);
1056             pass
1057         #
1058         f1=m.fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+2*(x+y)*JVec");
1059         f1.checkCoherency();
1060         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1061         self.assertEqual(f1.getTimeDiscretization(),NO_TIME);
1062         self.assertEqual(2,f1.getNumberOfComponents());
1063         self.assertEqual(9,f1.getNumberOfTuples());
1064         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]
1065         tmp=f1.getArray().getValues();
1066         self.assertEqual(len(values3),len(tmp))
1067         for i in xrange(len(values3)):
1068             self.assertTrue(abs(values3[i]-tmp[i])<1.e-12);
1069             pass
1070         values4=f1.accumulate();
1071         self.assertTrue(abs(3.6-values4[0])<1.e-12);
1072         self.assertTrue(abs(7.2-values4[1])<1.e-12);
1073         values4=f1.integral(True);
1074         self.assertTrue(abs(0.5-values4[0])<1.e-12);
1075         self.assertTrue(abs(1.-values4[1])<1.e-12);
1076         pass
1077
1078     def testApplyFunc(self):
1079         m=MEDCouplingDataForTest.build2DTargetMesh_1();
1080         f1=m.fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+(2*(x+y))*JVec");
1081         f1.checkCoherency();
1082         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1083         self.assertEqual(f1.getTimeDiscretization(),NO_TIME);
1084         self.assertEqual(2,f1.getNumberOfComponents());
1085         self.assertEqual(9,f1.getNumberOfTuples());
1086         f1.applyFunc(1,"x+y");
1087         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1088         self.assertEqual(f1.getTimeDiscretization(),NO_TIME);
1089         self.assertEqual(1,f1.getNumberOfComponents());
1090         self.assertEqual(9,f1.getNumberOfTuples());
1091         values1=[-1.8,-0.3,1.2,-0.3,1.2,2.7,1.2,2.7,4.2]
1092         tmp=f1.getArray().getValues();
1093         self.assertEqual(len(values1),len(tmp))
1094         for i in xrange(len(tmp)):
1095             self.assertTrue(abs(tmp[i]-values1[i])<1.e-12)
1096             pass
1097         pass
1098
1099     def testApplyFunc2(self):
1100         m=MEDCouplingDataForTest.build2DTargetMesh_1();
1101         f1=m.fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+2*(x+y)*JVec");
1102         f1.checkCoherency();
1103         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1104         self.assertEqual(f1.getTimeDiscretization(),NO_TIME);
1105         self.assertEqual(2,f1.getNumberOfComponents());
1106         self.assertEqual(9,f1.getNumberOfTuples());
1107         #
1108         f2=f1.clone(True);
1109         self.assertRaises(InterpKernelException, f2.applyFunc, 1, "a+b+c+d");
1110         self.assertRaises(InterpKernelException, f2.applyFunc, 1, "a/0");
1111         self.assertRaises(InterpKernelException, f2.applyFunc, "a/0");
1112         f2.applyFunc("abs(u)^2.4+2*u");
1113         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1114         self.assertEqual(f1.getTimeDiscretization(),NO_TIME);
1115         self.assertEqual(2,f1.getNumberOfComponents());
1116         self.assertEqual(9,f1.getNumberOfTuples());
1117         values2=[-0.9065304805418678, -0.85105859001709905, -0.19601892829446504, -0.37898777756476987,
1118                  0.91090317490482353, 2.1853504664669781, -0.19601892829446504, -0.37898777756476987,
1119                  0.91090317490482353, 2.1853504664669781, 2.5765725275664879, 7.6987743736515295,
1120                  0.91090317490482353, 2.1853504664669781, 2.5765725275664879, 7.6987743736515295,
1121                  5.0423700574830965, 17.435300118916864]
1122         tmp=f2.getArray().getValues();
1123         self.assertEqual(len(tmp),len(values2))
1124         for i in xrange(len(tmp)):
1125             self.assertTrue(abs(tmp[i]-values2[i])<1.e-12)
1126             pass
1127         #
1128         f1.applyFunc(1,"x+y");
1129         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1130         self.assertEqual(f1.getTimeDiscretization(),NO_TIME);
1131         self.assertEqual(1,f1.getNumberOfComponents());
1132         self.assertEqual(9,f1.getNumberOfTuples());
1133         values1=[-1.8,-0.3,1.2,-0.3,1.2,2.7,1.2,2.7,4.2]
1134         tmp=f1.getArray().getValues();
1135         self.assertEqual(len(tmp),len(values1))
1136         for i in xrange(len(tmp)):
1137             self.assertTrue(abs(tmp[i]-values1[i])<1.e-12)
1138             pass
1139         pass
1140
1141     def testOperationsOnFields(self):
1142         m=MEDCouplingDataForTest.build2DTargetMesh_1();
1143         f1=m.fillFromAnalytic(ON_NODES,1,"x+y");
1144         f2=m.fillFromAnalytic(ON_NODES,1,"x+y");
1145         f1.checkCoherency();
1146         f2.checkCoherency();
1147         f3=f1+f2;
1148         f3.checkCoherency();
1149         self.assertEqual(f3.getTypeOfField(),ON_NODES);
1150         self.assertEqual(f3.getTimeDiscretization(),NO_TIME);
1151         values1=[-1.2,-0.2,0.8,-0.2,0.8,1.8,0.8,1.8,2.8]
1152         tmp=f3.getArray().getValues();
1153         self.assertEqual(len(values1),len(tmp))
1154         for i in xrange(len(tmp)):
1155             self.assertTrue(abs(tmp[i]-values1[i])<1.e-12)
1156             pass
1157         #
1158         f3=f1*f2;
1159         f3.checkCoherency();
1160         self.assertEqual(f3.getTypeOfField(),ON_NODES);
1161         self.assertEqual(f3.getTimeDiscretization(),NO_TIME);
1162         values2=[0.36,0.01,0.16,0.01,0.16,0.81,0.16,0.81,1.96]
1163         tmp=f3.getArray().getValues();
1164         self.assertEqual(len(values2),len(tmp))
1165         for i in xrange(len(tmp)):
1166             self.assertTrue(abs(tmp[i]-values2[i])<1.e-12)
1167             pass
1168         #
1169         f3=f1+f2;
1170         f4=f1-f3;
1171         f4.checkCoherency();
1172         self.assertEqual(f4.getTypeOfField(),ON_NODES);
1173         self.assertEqual(f4.getTimeDiscretization(),NO_TIME);
1174         values3=[0.6,0.1,-0.4,0.1,-0.4,-0.9,-0.4,-0.9,-1.4]
1175         tmp=f4.getArray().getValues();
1176         self.assertEqual(len(values3),len(tmp))
1177         for i in xrange(len(tmp)):
1178             self.assertTrue(abs(tmp[i]-values3[i])<1.e-12)
1179             pass
1180         #
1181         f3=f1+f2;
1182         f4=f3/f2;
1183         f4.checkCoherency();
1184         self.assertEqual(f4.getTypeOfField(),ON_NODES);
1185         self.assertEqual(f4.getTimeDiscretization(),NO_TIME);
1186         tmp=f4.getArray().getValues();
1187         for i in xrange(len(tmp)):
1188             self.assertTrue(abs(tmp[i]-2.)<1.e-12)
1189             pass
1190         #
1191         f4=f2.buildNewTimeReprFromThis(ONE_TIME,False);
1192         f4.checkCoherency();
1193         self.assertEqual(f4.getTypeOfField(),ON_NODES);
1194         self.assertEqual(f4.getTimeDiscretization(),ONE_TIME);
1195         self.assertRaises(InterpKernelException,f1.__add__,f4);
1196         f5=f4.buildNewTimeReprFromThis(NO_TIME,False);
1197         self.assertEqual(f5.getTypeOfField(),ON_NODES);
1198         self.assertEqual(f5.getTimeDiscretization(),NO_TIME);
1199         f3=f1+f5;
1200         tmp=f3.getArray().getValues();
1201         values4=[-1.2,-0.2,0.8,-0.2,0.8,1.8,0.8,1.8,2.8]
1202         self.assertEqual(len(values3),len(tmp))
1203         for i in xrange(len(tmp)):
1204             self.assertTrue(abs(tmp[i]-values4[i])<1.e-12)
1205             pass
1206         #
1207         f4=f2.buildNewTimeReprFromThis(ONE_TIME,True);
1208         f4.checkCoherency();
1209         self.assertEqual(f4.getTypeOfField(),ON_NODES);
1210         self.assertEqual(f4.getTimeDiscretization(),ONE_TIME);
1211         self.assertRaises(InterpKernelException,f1.__add__,f4);
1212         f5=f4.buildNewTimeReprFromThis(NO_TIME,True);
1213         self.assertEqual(f5.getTypeOfField(),ON_NODES);
1214         self.assertEqual(f5.getTimeDiscretization(),NO_TIME);
1215         f3=f1+f5;
1216         tmp=f3.getArray().getValues();
1217         values5=[-1.2,-0.2,0.8,-0.2,0.8,1.8,0.8,1.8,2.8]
1218         self.assertEqual(len(values5),len(tmp))
1219         for i in xrange(len(tmp)):
1220             self.assertTrue(abs(tmp[i]-values5[i])<1.e-12)
1221             pass
1222         pass
1223
1224     def testOperationsOnFields2(self):
1225         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1226         f1=m.fillFromAnalytic(ON_NODES,1,"x+y+z");
1227         f2=m.fillFromAnalytic(ON_NODES,1,"a*a+b+c*c");
1228         f3=f1/f2;
1229         f3.checkCoherency();
1230         self.assertEqual(f3.getTypeOfField(),ON_NODES);
1231         self.assertEqual(f3.getTimeDiscretization(),NO_TIME);
1232         expected1=[-2.4999999999999991, 1.2162162162162162, 0.77868852459016391,
1233                    0.7407407407407407, 1.129032258064516, 0.81632653061224492,
1234                    0.86538461538461531, 1.0919540229885056, 0.84302325581395343]
1235         self.assertEqual(1,f3.getNumberOfComponents());
1236         self.assertEqual(9,f3.getNumberOfTuples());
1237         val=f3.getArray().getValues();
1238         for i in xrange(9):
1239             self.assertTrue(abs(expected1[i]-val[i])<1.e-12);
1240         #
1241         f1=m.buildOrthogonalField();
1242         f2=m.fillFromAnalytic(ON_CELLS,1,"x");
1243         f3=f1*f2;
1244         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]
1245         val=f3.getArray().getValues();
1246         for i in xrange(15):
1247             self.assertTrue(abs(expected2[i]-val[i])<1.e-12);
1248             pass
1249         #
1250         f3=f2*f1;
1251         val=f3.getArray().getValues();
1252         for i in xrange(15):
1253             self.assertTrue(abs(expected2[i]-val[i])<1.e-12);
1254             pass
1255         pass
1256
1257     def testOperationsOnFields3(self):
1258         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1259         f1=m.fillFromAnalytic(ON_NODES,1,"x+y+z");
1260         f2=m.fillFromAnalytic(ON_NODES,1,"a*a+b+c*c");
1261         f1/=f2
1262         f1.checkCoherency();
1263         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1264         self.assertEqual(f1.getTimeDiscretization(),NO_TIME);
1265         expected1=[-2.4999999999999991, 1.2162162162162162, 0.77868852459016391,
1266                    0.7407407407407407, 1.129032258064516, 0.81632653061224492,
1267                    0.86538461538461531, 1.0919540229885056, 0.84302325581395343]
1268         self.assertEqual(1,f1.getNumberOfComponents());
1269         self.assertEqual(9,f1.getNumberOfTuples());
1270         val=f1.getArray().getValues();
1271         for i in xrange(9):
1272             self.assertTrue(abs(expected1[i]-val[i])<1.e-12);
1273             pass
1274         #
1275         f1=m.buildOrthogonalField();
1276         f2=m.fillFromAnalytic(ON_CELLS,1,"x");
1277         f1*=f2
1278         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]
1279         val=f1.getArray().getValues();
1280         for i in xrange(15):
1281             self.assertTrue(abs(expected2[i]-val[i])<1.e-12);
1282             pass
1283         #
1284         f1=m.buildOrthogonalField();
1285         # to avoid valgrind leaks
1286         # self.assertRaises(InterpKernelException,f2.__imul__,f1);
1287         pass
1288
1289     def testOperationsOnFields4(self):
1290         m=MEDCouplingDataForTest.build2DTargetMesh_1();
1291         nbOfCells=m.getNumberOfCells();
1292         f1=MEDCouplingFieldDouble.New(ON_CELLS,CONST_ON_TIME_INTERVAL);
1293         f1.setMesh(m);
1294         array=DataArrayDouble.New();
1295         f1.setArray(array);
1296         self.assertRaises(InterpKernelException,f1.setEndArray,array);
1297         self.assertRaises(InterpKernelException,f1.getEndArray);
1298         arr1=[0.,10.,20.,1.,11.,21.,2.,12.,22.,3.,13.,23.,4.,14.,24.]
1299         arr2=[5.,15.,25.,6.,16.,26.,7.,17.,27.,8.,18.,28.,9.,19.,29.]
1300         array.setValues(arr1,nbOfCells,3);
1301         f1.setStartTime(2.,0,0);
1302         f1.setEndTime(3.,0,0);
1303         f1.checkCoherency();
1304         pos=[0.3,-0.2]
1305         res=f1.getValueOn(pos);
1306         self.assertTrue(abs(arr1[3]-res[0])<1.e-12);
1307         self.assertTrue(abs(arr1[4]-res[1])<1.e-12);
1308         self.assertTrue(abs(arr1[5]-res[2])<1.e-12);
1309         res=None
1310         res=f1.getValueOn(pos,2.2);
1311         self.assertTrue(abs(arr1[3]-res[0])<1.e-12);
1312         self.assertTrue(abs(arr1[4]-res[1])<1.e-12);
1313         self.assertTrue(abs(arr1[5]-res[2])<1.e-12);
1314         res=None
1315         self.assertRaises(InterpKernelException,f1.getValueOn,pos,3.2)
1316         f2=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
1317         f2.setMesh(m);
1318         f2.setArray(f1.getArray());
1319         f2.setStartTime(2.,3,0);
1320         f2.setEndTime(4.,13,0);
1321         self.assertRaises(InterpKernelException,f2.checkCoherency)
1322         array2=DataArrayDouble.New();
1323         array2.setValues(arr2,nbOfCells,3);
1324         f2.setEndArray(array2);
1325         f2.checkCoherency();
1326         #
1327         res=None
1328         res=f2.getValueOn(pos,3.21);
1329         self.assertTrue(abs(4.025-res[0])<1.e-12);
1330         self.assertTrue(abs(14.025-res[1])<1.e-12);
1331         self.assertTrue(abs(24.025-res[2])<1.e-12);
1332         f3=f2.clone(True);
1333         self.assertTrue(f2.isEqual(f3,1e-12,1e-12));
1334         f3.getEndArray().setIJ(0,0,5.001);
1335         self.assertTrue(not f2.isEqual(f3,1e-12,1e-12));
1336         self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1337         f3.setStartTime(2.1,3,0);
1338         self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1339         f3.setStartTime(2.,3,0);
1340         self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1341         f3.setStartTime(2.,4,0);
1342         self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1343         f3.setStartTime(2.,3,1);
1344         self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1345         f3.setStartTime(2.,3,0);
1346         self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1347         f3.setEndTime(4.1,13,0);
1348         self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1349         f3.setEndTime(4.,13,0);
1350         self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1351         f3.setEndTime(4.,14,0);
1352         self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1353         f3.setEndTime(4.,13,1);
1354         self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1355         f3.setEndTime(4.,13,0);
1356         self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1357         f4=f2+f2
1358         res=None
1359         res=f4.getValueOn(pos,3.21);
1360         self.assertTrue(abs(8.05-res[0])<1.e-12);
1361         self.assertTrue(abs(28.05-res[1])<1.e-12);
1362         self.assertTrue(abs(48.05-res[2])<1.e-12);
1363         f4+=f2;
1364         res=None
1365         res=f4.getValueOn(pos,3.21);
1366         self.assertTrue(abs(12.075-res[0])<1.e-12);
1367         self.assertTrue(abs(42.075-res[1])<1.e-12);
1368         self.assertTrue(abs(72.075-res[2])<1.e-12);
1369         pass
1370
1371     def testMergeNodesOnField(self):
1372         targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
1373         f1=targetMesh.fillFromAnalytic(ON_NODES,1,"x+y+z");
1374         f1.mergeNodes(1e-10);
1375         #
1376         targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
1377         f1=targetMesh.fillFromAnalytic(ON_NODES,1,"x+y+z");
1378         tmp=f1.getArray()
1379         tmp.setIJ(0,0,1000.);
1380         f1.mergeNodes(1e-10);
1381         #
1382         targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
1383         f1=targetMesh.fillFromAnalytic(ON_NODES,1,"x+y+z");
1384         tmp=f1.getArray()
1385         tmp.setIJ(1,0,1000.);
1386         self.assertRaises(InterpKernelException,f1.mergeNodes,1.e-10)
1387         pass
1388
1389     def testCheckConsecutiveCellTypes(self):
1390         sourceMesh=MEDCouplingDataForTest.build2DSourceMesh_1();
1391         targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1392         self.assertTrue(sourceMesh.checkConsecutiveCellTypes());
1393         order1=[NORM_TRI3,NORM_QUAD4]
1394         order2=[NORM_QUAD4,NORM_TRI3]
1395         self.assertTrue(not targetMesh.checkConsecutiveCellTypes());
1396         self.assertTrue(not targetMesh.checkConsecutiveCellTypesAndOrder(order1));
1397         self.assertTrue(not targetMesh.checkConsecutiveCellTypesAndOrder(order2));
1398         da=targetMesh.getRenumArrForConsecutiveCellTypesSpec(order1);
1399         self.assertEqual(5,da.getNumberOfTuples());
1400         self.assertEqual(1,da.getNumberOfComponents());
1401         expected1=[2,0,1,3,4]
1402         self.assertTrue(expected1==list(da.getValues()));
1403         da=targetMesh.getRenumArrForConsecutiveCellTypesSpec(order2);
1404         self.assertEqual(5,da.getNumberOfTuples());
1405         self.assertEqual(1,da.getNumberOfComponents());
1406         expected2=[0,3,4,1,2]
1407         self.assertTrue(expected2==list(da.getValues()));
1408         renumber1=[4,0,1,2,3]
1409         targetMesh.renumberCells(renumber1,False);
1410         self.assertTrue(targetMesh.checkConsecutiveCellTypes());
1411         self.assertTrue(targetMesh.checkConsecutiveCellTypesAndOrder(order1));
1412         self.assertTrue(not targetMesh.checkConsecutiveCellTypesAndOrder(order2));
1413         pass
1414
1415     def testRearrange2ConsecutiveCellTypes(self):
1416         m1_1=MEDCouplingDataForTest.build2DSourceMesh_1();
1417         m2_1=MEDCouplingDataForTest.build2DTargetMesh_1();
1418         arr1=m1_1.rearrange2ConsecutiveCellTypes();
1419         m1_2=MEDCouplingDataForTest.build2DSourceMesh_1();
1420         self.assertTrue(m1_2.isEqual(m1_1,1e-12));
1421         expected1=[0,1]
1422         self.assertEqual(2,arr1.getNumberOfTuples());
1423         self.assertEqual(1,arr1.getNumberOfComponents());
1424         self.assertEqual(expected1,arr1.getValues());
1425         expected2=[0,3,4,1,2]
1426         arr1=m2_1.rearrange2ConsecutiveCellTypes();
1427         self.assertEqual(5,arr1.getNumberOfTuples());
1428         self.assertEqual(1,arr1.getNumberOfComponents());
1429         self.assertEqual(expected2,list(arr1.getValues()));
1430         m2_2=MEDCouplingDataForTest.build2DTargetMesh_1();
1431         self.assertEqual(5,arr1.getNumberOfTuples());
1432         self.assertEqual(1,arr1.getNumberOfComponents());
1433         self.assertEqual(expected2,list(arr1.getValues()));
1434         self.assertTrue(not m2_2.isEqual(m2_1,1e-12));
1435         m2_2.renumberCells(expected2,False);
1436         self.assertTrue(m2_2.isEqual(m2_1,1e-12));
1437         pass
1438
1439     def testSplitByType(self):
1440         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1441         v=m1.splitByType();
1442         self.assertEqual(3,len(v));
1443         m2=MEDCouplingUMesh.MergeUMeshesOnSameCoords(v);
1444         m2.setName(m1.getName());
1445         self.assertTrue(m1.isEqual(m2,1.e-12));
1446         pass
1447
1448     def testFuseUMeshesOnSameCoords(self):
1449         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
1450         cells1=[2,3,4]
1451         m3=m2.buildPartOfMySelf(cells1,True);
1452         self.assertTrue(isinstance(m3,MEDCouplingUMesh))
1453         cells2=[1,2,4]
1454         m4=m2.buildPartOfMySelf(cells2,True);
1455         self.assertTrue(isinstance(m4,MEDCouplingUMesh))
1456         cells3=[1,2]
1457         m5=m2.buildPartOfMySelf(cells3,True);
1458         self.assertTrue(isinstance(m5,MEDCouplingUMesh))
1459         meshes=[m3,m4,m5]
1460         #
1461         m7,corr=MEDCouplingUMesh.FuseUMeshesOnSameCoords(meshes,0);
1462         self.assertEqual(4,m7.getNumberOfCells());
1463         self.assertEqual(3,len(corr));
1464         expectedVals1=[3,3,2]
1465         expectedVals2=[[0,1,2],[3,0,2],[3,0]]
1466         for i in xrange(3):
1467             arr=corr[i];
1468             self.assertEqual(1,arr.getNumberOfComponents());
1469             nbOfVals=expectedVals1[i];
1470             self.assertEqual(nbOfVals,arr.getNumberOfTuples());
1471             vals=arr.getValues();
1472             self.assertEqual(expectedVals2[i],list(vals));
1473             pass
1474         arr2,fidsOfGroups=DataArrayInt.MakePartition(corr,m7.getNumberOfCells());
1475         fidExp=[5,1,3,4]
1476         fidsGrp=[[1,3,5],[3,4,5],[4,5]]
1477         self.assertEqual(3,len(fidsOfGroups));
1478         self.assertEqual(1,arr2.getNumberOfComponents());
1479         self.assertEqual(4,arr2.getNumberOfTuples());
1480         self.assertEqual(fidExp,list(arr2.getValues()));
1481         for i in xrange(3):
1482             nbOfVals=expectedVals1[i];
1483             self.assertEqual(list(fidsOfGroups[i]),fidsGrp[i]);
1484             pass
1485         pass
1486
1487     def testFuseUMeshesOnSameCoords2(self):
1488         m1,m2=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
1489         part1=[2,3,6,4,10]
1490         m3=m1.buildPartOfMySelf(part1,True);
1491         part2=[5,6,4,7]
1492         m4=m1.buildPartOfMySelf(part2,True);
1493         meshes=[m1,m3,m3,m4]
1494         m5,corr=MEDCouplingUMesh.FuseUMeshesOnSameCoords(meshes,0);
1495         self.assertEqual(18,m5.getNumberOfCells());
1496         exp2=[
1497             [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17],
1498             [2,3,6,4,10],
1499             [2,3,6,4,10],
1500             [5,6,4,7]]
1501         i=0;
1502         for it in corr:
1503             self.assertEqual(exp2[i],list(it.getValues()));
1504             i+=1
1505             pass
1506         pass
1507
1508     def testBuildOrthogonalField(self):
1509         targetMesh=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1510         field=targetMesh.buildOrthogonalField();
1511         expected=[0.70710678118654746,0.,-0.70710678118654746]
1512         self.assertEqual(5,field.getNumberOfTuples());
1513         self.assertEqual(3,field.getNumberOfComponents());
1514         vals=field.getArray().getValues();
1515         for i in xrange(15):
1516             self.assertTrue(abs(expected[i%3]-vals[i])<1e-12);
1517         # testing
1518         targetCoords=[0.,0.,0.,0.5,0.,0.5,1.,0.,1.,0.,1.,0.]
1519         targetConn=[0,1,2,3]
1520         targetMesh=MEDCouplingUMesh.New();
1521         targetMesh.setMeshDimension(2);
1522         targetMesh.allocateCells(1);
1523         targetMesh.insertNextCell(NORM_QUAD4,targetConn[0:4])
1524         targetMesh.finishInsertingCells();
1525         myCoords=DataArrayDouble.New();
1526         myCoords.setValues(targetCoords,4,3);
1527         targetMesh.setCoords(myCoords);
1528         field=targetMesh.buildOrthogonalField();
1529         self.assertEqual(1,field.getNumberOfTuples());
1530         self.assertEqual(3,field.getNumberOfComponents());
1531         vals=field.getArray().getValues();
1532         self.assertTrue(abs(-0.70710678118654746-vals[0])<1e-12);
1533         self.assertTrue(abs(0.-vals[1])<1e-12);
1534         self.assertTrue(abs(0.70710678118654746-vals[2])<1e-12);
1535         pass
1536
1537     def testGetCellsContainingPoint(self):
1538         targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1539         pos=[0.,0.,0.4,0.4,0.,0.4,0.1,0.1,0.25,0.,0.65,0.]
1540         #2D basic
1541         t1,t2=targetMesh.getCellsContainingPoints(pos,6,1e-12);
1542         self.assertEqual(6,t1.getNumberOfTuples());
1543         self.assertEqual(1,t1.getNumberOfComponents());
1544         self.assertEqual(7,t2.getNumberOfTuples());
1545         self.assertEqual(1,t2.getNumberOfComponents());
1546         expectedValues1=[0,4,3,0,1,2]
1547         expectedValues2=[0,1,2,3,4,5,6]
1548         self.assertEqual(list(t1.getValues()),expectedValues1);
1549         self.assertEqual(list(t2.getValues()),expectedValues2);
1550         #2D with no help of bounding box.
1551         center=[0.2,0.2]
1552         MEDCouplingPointSet.Rotate2DAlg(center,0.78539816339744830962,6,pos);
1553         targetMesh.rotate(center,0.78539816339744830962);
1554         t1=None
1555         t2=None
1556         t1,t2=targetMesh.getCellsContainingPoints(pos,1e-12);
1557         self.assertEqual(6,t1.getNumberOfTuples());
1558         self.assertEqual(7,t2.getNumberOfTuples());
1559         self.assertEqual(list(t1.getValues()),expectedValues1);
1560         self.assertEqual(list(t2.getValues()),expectedValues2);
1561         t1,t2=targetMesh.getCellsContainingPoints(DataArrayDouble.New(pos,6,2),1e-12);
1562         self.assertEqual(6,t1.getNumberOfTuples());
1563         self.assertEqual(7,t2.getNumberOfTuples());
1564         self.assertEqual(list(t1.getValues()),expectedValues1);
1565         self.assertEqual(list(t2.getValues()),expectedValues2);
1566         self.assertRaises(InterpKernelException,targetMesh.getCellsContainingPoints,DataArrayDouble.New(pos,4,3),1e-12);
1567         #2D outside
1568         pos1bis=[-0.3303300858899107,-0.11819805153394641]
1569         self.assertEqual(-1,targetMesh.getCellContainingPoint(pos1bis,1e-12));
1570         #test limits 2D
1571         targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1572         pos2=[0.2,-0.05]
1573         t1=None
1574         t1=targetMesh.getCellsContainingPoint(pos2,1e-12)
1575         self.assertEqual(2,len(t1));
1576         expectedValues3=[0,1]
1577         self.assertEqual(list(t1.getValues()),expectedValues3);
1578         pos3=[0.2,0.2]
1579         t1=None
1580         t1=targetMesh.getCellsContainingPoint(pos3,1e-12);
1581         self.assertEqual(5,len(t1));
1582         expectedValues4=[0,1,2,3,4]
1583         self.assertEqual(list(t1.getValues()),expectedValues4);
1584         self.assertEqual(0,targetMesh.getCellContainingPoint(pos3,1e-12));
1585         #3D
1586         targetMesh=MEDCouplingDataForTest.build3DTargetMesh_1();
1587         pos4=[25.,25.,25.]
1588         self.assertEqual(0,targetMesh.getCellContainingPoint(pos4,1e-12));
1589         pos5=[50.,50.,50.]
1590         t1=None
1591         t1=targetMesh.getCellsContainingPoint(pos5,1e-12);
1592         self.assertEqual(8,len(t1));
1593         expectedValues5=[0,1,2,3,4,5,6,7]
1594         self.assertEqual(list(t1.getValues()),expectedValues5);
1595         pos6=[0., 50., 0.]
1596         t1=None
1597         t1=targetMesh.getCellsContainingPoint(pos6,1e-12);
1598         self.assertEqual(2,len(t1));
1599         expectedValues6=[0,2]
1600         self.assertEqual(list(t1.getValues()),expectedValues6);
1601         #3D outside
1602         pos7=[-1.0,-1.0,0.]
1603         self.assertEqual(-1,targetMesh.getCellContainingPoint(pos7,1e-12));
1604         #3D outside 2
1605         center2=[0.,0.,0.]
1606         vec2=[0.,-1.,0.]
1607         targetMesh.rotate(center2,vec2,0.78539816339744830962);
1608         pos8=[-25.,25.,12.]
1609         self.assertEqual(-1,targetMesh.getCellContainingPoint(pos8,1e-12));
1610         pass
1611
1612     def testGetValueOn1(self):
1613         targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1614         fieldOnCells=MEDCouplingFieldDouble.New(ON_CELLS);
1615         nbOfCells=targetMesh.getNumberOfCells();
1616         fieldOnCells.setMesh(targetMesh);
1617         array=DataArrayDouble.New();
1618         tmp=2*nbOfCells*[None]
1619         for i in xrange(nbOfCells):
1620             tmp[2*i]=7.+float(i);
1621             tmp[2*i+1]=17.+float(i)
1622             pass
1623         array.setValues(tmp,nbOfCells,2);
1624         fieldOnCells.setArray(array);
1625         #
1626         pos1=[0.25,0.]
1627         res=fieldOnCells.getValueOn(pos1);
1628         self.assertEqual(2,len(res))
1629         self.assertTrue(abs(8.-res[0])<1e-12);
1630         self.assertTrue(abs(18.-res[1])<1e-12);
1631         #
1632         #
1633         targetMesh=MEDCouplingDataForTest.build2DSourceMesh_1();
1634         fieldOnNodes=MEDCouplingFieldDouble.New(ON_NODES);
1635         nbOfNodes=targetMesh.getNumberOfNodes();
1636         fieldOnNodes.setMesh(targetMesh);
1637         array=DataArrayDouble.New();
1638         tmp=2*nbOfNodes*[None]
1639         for i in xrange(nbOfNodes):
1640             tmp[2*i]=17.+float(i);
1641             tmp[2*i+1]=27.+float(i)
1642             pass
1643         array.setValues(tmp,nbOfNodes,2);
1644         fieldOnNodes.setArray(array);
1645         #
1646         pos2=[-0.13333333333333333,-0.13333333333333333]
1647         res=None
1648         res=fieldOnNodes.getValueOn(pos2);
1649         self.assertEqual(2,len(res))
1650         self.assertTrue(abs(17.5-res[0])<1e-12);
1651         self.assertTrue(abs(27.5-res[1])<1e-12);
1652         pos3=[0.033333333333333326,0.36666666666666664]
1653         res=None
1654         res=fieldOnNodes.getValueOn(pos3);
1655         self.assertEqual(2,len(res))
1656         self.assertTrue(abs(18.666666666666667-res[0])<1e-12);
1657         self.assertTrue(abs(28.666666666666667-res[1])<1e-12);
1658         pass
1659
1660     def testCMesh0(self):
1661         mesh=MEDCouplingCMesh.New();
1662         meshEmpty=mesh.clone(True);
1663         self.assertTrue(meshEmpty.isEqual(mesh, 1e-12));
1664
1665         coordsX=DataArrayDouble.New();
1666         arrX=[ -1., 1., 2., 4. ]
1667         coordsX.setValues(arrX, 4, 1);
1668         coordsY=DataArrayDouble.New();
1669         arrY=[ -2., 2., 4., 8. ]
1670         coordsY.setValues(arrY, 4, 1);
1671         coordsZ=DataArrayDouble.New();
1672         arrZ=[ -3., 3., 6., 12. ]
1673         coordsZ.setValues(arrZ, 4, 1);
1674         mesh.setCoords(coordsX, coordsY, coordsZ);
1675         #
1676         fieldOnNodes=mesh.fillFromAnalytic(ON_NODES, 1, "x+y/2.+z/3.");
1677         self.assertEqual(1, fieldOnNodes.getNumberOfComponents());
1678         self.assertEqual(64, fieldOnNodes.getNumberOfTuples());
1679         expected1=[-3., -1., 0., 2., -1., 1., 2., 4., 0., 2., 3., 5., 2., 4., 5., 7., -1., 1., 2.,
1680                     4., 1., 3., 4., 6., 2., 4., 5., 7., 4., 6., 7., 9., 0., 2., 3., 5., 2., 4., 5.,
1681                     7., 3., 5., 6., 8., 5., 7., 8., 10., 2., 4., 5.,
1682                     7., 4., 6., 7., 9., 5., 7., 8., 10., 7., 9., 10., 12.];
1683
1684         val=fieldOnNodes.getArray().getValues();
1685         for i in xrange(64):
1686           self.assertAlmostEqual(expected1[i], val[i], 12)
1687         res=fieldOnNodes.getValueOnPos(1, 3, 2);
1688         self.assertAlmostEqual(7., res[0], 12);
1689         #
1690         fieldOnCells=mesh.fillFromAnalytic(ON_CELLS, 1, "x+y/2.+z/3.");
1691         self.assertEqual(1, fieldOnCells.getNumberOfComponents());
1692         self.assertEqual(27, fieldOnCells.getNumberOfTuples());
1693         val=fieldOnCells.getArray().getValues();
1694         expected2=[0, 1.5, 3, 1.5, 3, 4.5, 3, 4.5, 6, 1.5, 3, 4.5, 3, 4.5,
1695                     6, 4.5, 6, 7.5, 3, 4.5, 6, 4.5, 6, 7.5, 6, 7.5, 9];
1696         for i in xrange(27):
1697           self.assertAlmostEqual(expected2[i], val[i], 12);
1698         #res=fieldOnCells.getValueOnPos(1,2,1);
1699         #self.assertAlmostEqual(6.,res,12);
1700         #
1701         meshDeepCopy=mesh.deepCpy();
1702         meshClone=mesh.clone(False);
1703
1704         meshEmpty.copyTinyStringsFrom(mesh);
1705         #no data in meshEmpty, expected False
1706         self.assertTrue(not meshEmpty.isEqual(mesh, 1e-12));
1707
1708         self.assertTrue(meshDeepCopy.isEqual(mesh, 1e-12));
1709         meshDeepCopy.copyTinyStringsFrom(mesh);
1710         self.assertTrue(meshDeepCopy.isEqual(mesh, 1e-12));
1711         self.assertTrue(meshClone.isEqual(mesh, 1e-12));
1712
1713         self.assertEqual(CARTESIAN, mesh.getType());
1714         self.assertEqual(CARTESIAN, meshEmpty.getType());
1715         self.assertEqual(CARTESIAN, meshDeepCopy.getType());
1716         self.assertEqual(CARTESIAN, meshClone.getType());
1717         pass
1718
1719     def testCMesh1(self):
1720         mesh1=MEDCouplingCMesh.New();
1721         coordsX1=DataArrayDouble.New();
1722         arrX1=[ -1., 1., 2., 4. ]
1723         coordsX1.setValues(arrX1, 4, 1);
1724         coordsY1=DataArrayDouble.New();
1725         arrY1=[ -2., 2., 4., 8. ]
1726         coordsY1.setValues(arrY1, 4, 1);
1727         coordsZ1=DataArrayDouble.New();
1728         arrZ1=[ -3., 3., 6., 12. ]
1729         coordsZ1.setValues(arrZ1, 4, 1);
1730         mesh1.setCoords(coordsX1, coordsY1, coordsZ1);
1731
1732         mesh2=MEDCouplingCMesh.New();
1733         coordsX2=DataArrayDouble.New();
1734         arrX2=[ -1., 1., 2., 4. ]
1735         coordsX2.setValues(arrX2, 4, 1);
1736         coordsY2=DataArrayDouble.New();
1737         arrY2=[ -2., 2., 4., 8. ]
1738         coordsY2.setValues(arrY2, 4, 1);
1739         coordsZ2=DataArrayDouble.New();
1740         arrZ2=[ -3., 3., 6., 12.+1e-6 ]
1741         coordsZ2.setValues(arrZ2, 4, 1);
1742         mesh2.setCoords(coordsX2, coordsY2, coordsZ2);
1743
1744         mesh3=MEDCouplingCMesh.New();
1745         coordsX3=DataArrayDouble.New();
1746         arrX3=[-1.]
1747         coordsX3.setValues(arrX3, 1, 1);
1748         coordsY3=DataArrayDouble.New();
1749         arrY3=[-2.]
1750         coordsY3.setValues(arrY3, 1, 1);
1751         coordsZ3=DataArrayDouble.New();
1752         arrZ3=[-3.]
1753         coordsZ3.setValues(arrZ3, 1, 1);
1754         mesh3.setCoords(coordsX3, coordsY3, coordsZ3);
1755
1756         self.assertEqual(3, mesh1.getSpaceDimension());
1757         self.assertEqual(3, mesh1.getMeshDimension());
1758
1759         self.assertTrue(not mesh1.isEqual(mesh2, 1e-12));
1760         self.assertTrue(not mesh2.isEqual(mesh1, 1e-12));
1761         self.assertTrue(not mesh2.isEqualWithoutConsideringStr(mesh1, 1e-12));
1762         self.assertTrue(mesh1.isEqual(mesh2, 1e-5));
1763         self.assertTrue(not mesh1.isEqual(mesh2, 1e-7));
1764
1765         self.assertRaises(InterpKernelException, mesh3.checkCoherency1, 1e-12);
1766         mesh1.checkCoherency2(1e-12);
1767         self.assertEqual(NORM_HEXA8, mesh1.getTypeOfCell(1));
1768
1769         self.assertEqual(NORM_HEXA8, mesh1.getAllGeoTypes()[0]);
1770         self.assertEqual(27, mesh1.getNumberOfCellsWithType(NORM_HEXA8));
1771         self.assertRaises(InterpKernelException, mesh1.getNumberOfCellsWithType, NORM_QUAD4);
1772
1773         coo=mesh1.getCoordinatesOfNode(0);
1774         self.assertEqual(3, len(coo));
1775         self.assertAlmostEqual(-1., coo[0], 14);
1776         self.assertAlmostEqual(-2., coo[1], 14);
1777         self.assertAlmostEqual(-3., coo[2], 14);
1778         coo=mesh1.getCoordinatesOfNode(63);
1779         self.assertEqual(3, len(coo));
1780         self.assertAlmostEqual(4., coo[0], 14);
1781         self.assertAlmostEqual(8., coo[1], 14);
1782         self.assertAlmostEqual(12., coo[2], 14);
1783
1784         a=str(mesh1)
1785         repr=mesh1.simpleRepr();
1786         repr=mesh1.advancedRepr();
1787         self.assertTrue("Cartesian" in repr);
1788         self.assertTrue("Number of components : 1" in repr);
1789         self.assertTrue("Number of tuples : 4" in repr);
1790         self.assertTrue("Z Array :" in repr);
1791         pass
1792
1793     def testCMesh2(self):
1794         mesh1=MEDCouplingCMesh.New();
1795         coordsX1=DataArrayDouble.New();
1796         arrX1=[ -1., 1., 2., 4. ]
1797         coordsX1.setValues(arrX1, 4, 1);
1798         coordsY1=DataArrayDouble.New();
1799         arrY1=[ -2., 2., 4., 8. ]
1800         coordsY1.setValues(arrY1, 4, 1);
1801         coordsZ1=DataArrayDouble.New();
1802         arrZ1=[ -3., 3., 6., 12. ]
1803         coordsZ1.setValues(arrZ1, 4, 1);
1804         mesh1.setCoords(coordsX1, coordsY1, coordsZ1);
1805
1806         dis=mesh1.getDistributionOfTypes();
1807         self.assertEqual(1, len(dis));
1808         self.assertEqual(NORM_HEXA8, dis[0][0]);
1809         self.assertEqual(27, dis[0][1]);
1810         self.assertEqual(0, dis[0][2]);
1811
1812         idsPerType=[]
1813         self.assertRaises(InterpKernelException, mesh1.checkTypeConsistencyAndContig, dis, idsPerType);
1814         dis[0][2]=-1;
1815         idsPerType=[]
1816         self.assertTrue(not mesh1.checkTypeConsistencyAndContig(dis, idsPerType));
1817         dis[0][0]=NORM_QUAD4;
1818         self.assertRaises(InterpKernelException, mesh1.checkTypeConsistencyAndContig, dis, idsPerType);
1819         dis[0][0]=NORM_HEXA8;
1820         dis[0][2]=0;
1821         ids=DataArrayInt.New();
1822         ids.alloc(10, 1);
1823         ids.fillWithValue(111);
1824         idsPerType=[ids];
1825         check=mesh1.checkTypeConsistencyAndContig(dis, idsPerType);
1826         self.assertTrue(check);
1827         self.assertTrue(check.isEqual(ids));
1828
1829         code, idsInPflPerType, pfls=mesh1.splitProfilePerType(ids);
1830         self.assertEqual(3, len(code));
1831         self.assertEqual(NORM_HEXA8, code[0]);
1832         self.assertEqual(27, code[1]);
1833         self.assertEqual(0, code[2]);
1834         self.assertEqual(1, len(idsInPflPerType));
1835         self.assertEqual(1, len(pfls));
1836         self.assertTrue(idsInPflPerType[0].isEqual(ids));
1837         self.assertTrue(pfls[0].isEqual(ids));
1838
1839         cells1=[0, 1, 25, 26]
1840         partMesh1=mesh1.buildPart(cells1)
1841         self.assertTrue(isinstance(partMesh1,MEDCouplingMesh))
1842         self.assertEqual(4, partMesh1.getNumberOfCellsWithType(NORM_HEXA8));
1843         self.assertEqual(64, mesh1.getNumberOfNodes());
1844         self.assertEqual(64, partMesh1.getNumberOfNodes());
1845
1846         cells2=[25, 26]
1847         partMesh2, arr1=mesh1.buildPartAndReduceNodes(cells2)
1848         self.assertTrue(isinstance(partMesh2,MEDCouplingUMesh))
1849         self.assertEqual(2,partMesh2.getNumberOfCellsWithType(NORM_HEXA8));
1850         self.assertEqual(12,partMesh2.getNumberOfNodes());
1851
1852         cells3=[2, 3]
1853         partMesh3, arr2=partMesh1.buildPartAndReduceNodes(cells3)
1854         self.assertTrue(isinstance(partMesh3,MEDCouplingUMesh))
1855         self.assertEqual(2, partMesh3.getNumberOfCellsWithType(NORM_HEXA8));
1856         self.assertEqual(12, partMesh3.getNumberOfNodes());
1857
1858         self.assertRaises(InterpKernelException, mesh1.simplexize, 0);
1859         self.assertRaises(InterpKernelException, mesh1.getMeasureFieldOnNode, True);
1860
1861         #double bbox1[6];
1862         #double bbox2[6];
1863         bbox1=mesh1.getBoundingBox(); #[(-1.0, 4.0), (-2.0, 8.0), (-3.0, 12.0)]
1864         bbox2=partMesh1.getBoundingBox();
1865         self.assertTrue(bbox1==bbox2);
1866         bbox1=partMesh3.getBoundingBox();
1867         bbox2=partMesh2.getBoundingBox();
1868         self.assertTrue(bbox1==bbox2);
1869
1870         self.assertRaises(InterpKernelException, mesh1.buildOrthogonalField);
1871         mesh2d=MEDCouplingCMesh.New();
1872         mesh2d.setCoords(coordsX1, coordsY1);
1873         f1=mesh2d.buildOrthogonalField();
1874
1875         pass
1876
1877     def testScale(self):
1878         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1879         pos=[0.2,0.2]
1880         mesh.scale(pos,0.5);
1881         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,
1882                    -0.05,0.45, 0.2,0.45, 0.45,0.45]
1883         val=mesh.getCoords().getValues();
1884         self.assertEqual(18,len(val))
1885         for i in xrange(18):
1886             self.assertTrue(abs(expected1[i]-val[i])<1e-12);
1887             pass
1888         pass
1889
1890     def testTryToShareSameCoords(self):
1891         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
1892         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
1893         self.assertTrue(m1.getCoords().getHiddenCppPointer()!=m2.getCoords().getHiddenCppPointer());
1894         m1.tryToShareSameCoords(m2,1e-12);
1895         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1896         m1.tryToShareSameCoords(m2,1e-12);
1897         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1898         m2.tryToShareSameCoords(m1,1e-12);
1899         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1900         #
1901         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
1902         m2=MEDCouplingDataForTest.build2DTargetMesh_2();
1903         self.assertTrue(m1.getCoords().getHiddenCppPointer()!=m2.getCoords().getHiddenCppPointer());
1904         m1.tryToShareSameCoords(m2,1e-12);
1905         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1906         m1.tryToShareSameCoords(m2,1e-12);
1907         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1908         m2.tryToShareSameCoords(m1,1e-12);
1909         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1910         #
1911         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
1912         m2=MEDCouplingDataForTest.build2DSourceMesh_1();
1913         self.assertTrue(m1.getCoords().getHiddenCppPointer()!=m2.getCoords().getHiddenCppPointer());
1914         self.assertRaises(InterpKernelException,m1.tryToShareSameCoords,m2,1e-12)
1915         pass
1916
1917     def testFindNodeOnPlane(self):
1918         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
1919         pt=[300.,300.,0.]
1920         v=[0.,0.,2.]
1921         n=mesh.findNodesOnPlane(pt,v,1e-12);
1922         self.assertEqual(9,len(n));
1923         m3dSurf=mesh.buildFacePartOfMySelfNode(n,True);
1924         self.assertTrue(isinstance(m3dSurf,MEDCouplingUMesh))
1925         me=MEDCouplingExtrudedMesh.New(mesh,m3dSurf,0);
1926         da=me.getMesh3DIds();
1927         self.assertEqual(8,me.getNumberOfCells());
1928         expected=[0,1,2,3,4,5,6,7]
1929         val=da.getValues();
1930         self.assertEqual(expected,list(val));
1931         #
1932         m3dSurf=mesh.buildFacePartOfMySelfNode(n,True);
1933         self.assertTrue(isinstance(m3dSurf,MEDCouplingUMesh))
1934         me=MEDCouplingExtrudedMesh.New(mesh,m3dSurf,0);
1935         da=me.getMesh3DIds();
1936         self.assertEqual(8,me.getNumberOfCells());
1937         expected=[0,1,2,3,4,5,6,7]
1938         val=da.getValues();
1939         self.assertEqual(expected,list(val));
1940         pass
1941
1942     def testRenumberCells(self):
1943         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1944         m2=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1945         self.assertTrue(m.isEqual(m2,0));
1946         arr=[12,3,25,2,26]
1947         m.renumberCells(arr,True);
1948         self.assertTrue(not m.isEqual(m2,0));
1949         self.assertEqual(NORM_QUAD4,m.getTypeOfCell(0));
1950         self.assertEqual(NORM_TRI3,m.getTypeOfCell(1));
1951         self.assertEqual(NORM_QUAD4,m.getTypeOfCell(2));
1952         self.assertEqual(NORM_TRI3,m.getTypeOfCell(3));
1953         self.assertEqual(NORM_QUAD4,m.getTypeOfCell(4));
1954         arr2=[5,-1,-5,4,8]
1955         m.renumberCells(arr2,True);
1956         self.assertTrue(m.isEqual(m2,0));
1957         pass
1958
1959     def testChangeSpaceDimension(self):
1960         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1961         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
1962         #
1963         self.assertEqual(3,m1.getSpaceDimension());
1964         m1.changeSpaceDimension(2);
1965         self.assertEqual(2,m1.getSpaceDimension());
1966         m1.setName(m2.getName());
1967         self.assertTrue(m1.isEqual(m2,1e-12));
1968         m1.changeSpaceDimension(3);
1969         self.assertEqual(3,m1.getSpaceDimension());
1970         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.]
1971         val=m1.getCoords().getValues();
1972         for i in xrange(27):
1973             self.assertTrue(abs(expected[i]-val[i])<1e-14);
1974             pass
1975         pass
1976
1977     def testGaussPointField1(self):
1978         _a=0.446948490915965;
1979         _b=0.091576213509771;
1980         _p1=0.11169079483905;
1981         _p2=0.0549758718227661;
1982         refCoo1=[ 0.,0., 1.,0., 0.,1. ]
1983         gsCoo1=[ 2*_b-1, 1-4*_b, 2*_b-1, 2.07*_b-1, 1-4*_b,
1984                  2*_b-1, 1-4*_a, 2*_a-1, 2*_a-1, 1-4*_a, 2*_a-1, 2*_a-1 ]
1985         wg1=[ 4*_p2, 4*_p2, 4*_p2, 4*_p1, 4*_p1, 4*_p1 ]
1986         _refCoo1=refCoo1
1987         _gsCoo1=gsCoo1
1988         _wg1=wg1
1989         #
1990         m=MEDCouplingDataForTest.build2DTargetMesh_1();
1991         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,NO_TIME);
1992         f.setMesh(m);
1993         self.assertEqual(5,f.getNumberOfMeshPlacesExpected());
1994         self.assertEqual(0,f.getNbOfGaussLocalization());
1995         f.setGaussLocalizationOnType(NORM_TRI3,_refCoo1,_gsCoo1,_wg1);
1996         f.setGaussLocalizationOnType(NORM_TRI3,_refCoo1,_gsCoo1,_wg1); # not a bug only to check that it works well
1997         self.assertRaises(InterpKernelException,f.setGaussLocalizationOnType,NORM_QUAD4,_refCoo1,_gsCoo1,_wg1)
1998         self.assertEqual(1,f.getNbOfGaussLocalization());
1999         refCoo2=[ 0.,0., 1.,0., 1.,1., 0.,1. ]
2000         _refCoo2=refCoo2
2001         _gsCoo1=_gsCoo1[0:4]
2002         _wg1=_wg1[0:2]
2003         f.setGaussLocalizationOnType(NORM_QUAD4,_refCoo2,_gsCoo1,_wg1);
2004         self.assertEqual(2,f.getNbOfGaussLocalization());
2005         array=DataArrayDouble.New();
2006         ptr=18*2*[None]
2007         for i in xrange(18*2):
2008             ptr[i]=float(i+1)
2009         array.setValues(ptr,18,2);
2010         ptr=array.getPointer();
2011         f.setArray(array);
2012         f.setName("MyFirstFieldOnGaussPoint");
2013         f.checkCoherency();
2014         self.assertAlmostEqual(27.,f.getIJK(2,5,0),14);
2015         self.assertAlmostEqual(16.,f.getIJK(1,5,1),14);
2016         #
2017         f.clearGaussLocalizations();
2018         self.assertEqual(0,f.getNbOfGaussLocalization());
2019         self.assertRaises(InterpKernelException,f.checkCoherency);
2020         ids1=[0,1,3,4]
2021         self.assertRaises(InterpKernelException,f.setGaussLocalizationOnCells,ids1,_refCoo2,_gsCoo1,_wg1);
2022         self.assertEqual(0,f.getNbOfGaussLocalization());
2023         ids2=[0,4]
2024         f.setGaussLocalizationOnCells(ids2,_refCoo2,_gsCoo1,_wg1);
2025         self.assertEqual(1,f.getNbOfGaussLocalization());
2026         self.assertEqual(0,f.getGaussLocalizationIdOfOneCell(0));
2027         self.assertRaises(InterpKernelException,f.getGaussLocalizationIdOfOneCell,1);
2028         ids3=[1,2]
2029         f.setGaussLocalizationOnCells(ids3,_refCoo1,_gsCoo1,_wg1);
2030         self.assertEqual(2,f.getNbOfGaussLocalization());
2031         self.assertEqual(0,f.getGaussLocalizationIdOfOneCell(0));
2032         self.assertEqual(1,f.getGaussLocalizationIdOfOneCell(1));
2033         self.assertEqual(1,f.getGaussLocalizationIdOfOneCell(2));
2034         self.assertRaises(InterpKernelException,f.checkCoherency);#<- cell 3 has no localization
2035         ids4=[3]
2036         _gsCoo2=_gsCoo1;
2037         _wg2=_wg1;
2038         _gsCoo2[0]=0.8888777776666;
2039         _wg2[0]=0.1234567892377;
2040         f.setGaussLocalizationOnCells(ids4,_refCoo2,_gsCoo2,_wg2);
2041         self.assertEqual(3,f.getNbOfGaussLocalization());
2042         tmpIds=f.getCellIdsHavingGaussLocalization(0);
2043         self.assertEqual(ids2,list(tmpIds.getValues()));
2044         self.assertRaises(InterpKernelException,f.checkCoherency);#<- it's always not ok because undelying array not with the good size.
2045         array2=f.getArray().substr(0,10);
2046         f.setArray(array2);
2047         f.checkCoherency();#<- here it is OK
2048         f2=f.clone(True);
2049         self.assertTrue(f.isEqual(f2,1e-14,1e-14));
2050         gl1=f2.getGaussLocalization(0);
2051         tmp=gl1.getGaussCoord(1,1);
2052         self.assertAlmostEqual(2.07*_b-1,tmp,14);
2053         gl1.setGaussCoord(1,1,0.07);
2054         self.assertTrue(not f.isEqual(f2,1e-14,1e-14));
2055         gl1.setGaussCoord(1,1,tmp);
2056         self.assertTrue(f.isEqual(f2,1e-14,1e-14));
2057         f2.checkCoherency();
2058         pass
2059
2060     def testGaussPointNEField1(self):
2061         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2062         f=MEDCouplingFieldDouble.New(ON_GAUSS_NE,NO_TIME);
2063         f.setMesh(m);
2064         self.assertEqual(5,f.getNumberOfMeshPlacesExpected());
2065         f.setName("MyFirstFieldOnNE");
2066         f.setDescription("MyDescriptionNE");
2067         array=DataArrayDouble.New();
2068         tmp=18*2*[None]
2069         for i in xrange(18*2):
2070             tmp[i]=float(i+7)
2071             pass
2072         array.setValues(tmp,18,2);
2073         ptr=array.getPointer();
2074         f.setArray(array);
2075         #
2076         f.checkCoherency();
2077         f2=f.clone(True);
2078         self.assertTrue(f.isEqual(f2,1e-14,1e-14));
2079         self.assertAlmostEqual(21.,f.getIJK(2,0,0),14);
2080         self.assertAlmostEqual(18.,f.getIJK(1,1,1),14);
2081         pass
2082
2083     def testCellOrientation1(self):
2084         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2085         vec=[0.,0.,-1.]
2086         self.assertRaises(InterpKernelException,m.are2DCellsNotCorrectlyOriented,vec,False);
2087         m.changeSpaceDimension(3);
2088         res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2089         self.assertTrue(len(res1)==0);
2090         vec[2]=1.;
2091         res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2092         self.assertEqual(5,len(res1));
2093         #
2094         vec[2]=-1.;
2095         # connectivity inversion
2096         conn=m.getNodalConnectivity().getValues();
2097         tmp=conn[11];
2098         conn[11]=conn[12];
2099         conn[12]=tmp;
2100         m.getNodalConnectivity().setValues(conn,len(conn),1)
2101         res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2102         self.assertEqual(1,len(res1));
2103         self.assertEqual(2,res1.getValues()[0]);
2104         m.orientCorrectly2DCells(vec,False);
2105         res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2106         self.assertTrue(len(res1)==0);
2107         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
2108         m2.changeSpaceDimension(3);
2109         self.assertTrue(m.isEqual(m2,1e-12));
2110         pass
2111
2112     def testCellOrientation2(self):
2113         m2,m1=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
2114         res1=m2.arePolyhedronsNotCorrectlyOriented();
2115         self.assertEqual(6,len(res1));
2116         m2.orientCorrectlyPolyhedrons();
2117         res1=m2.arePolyhedronsNotCorrectlyOriented();
2118         self.assertTrue(len(res1)==0);
2119         m2.checkCoherency();
2120         self.assertEqual(18,m2.getNumberOfCells());
2121         cellIds2=[0,6,12]
2122         m2.convertToPolyTypes(cellIds2);
2123         m2.orientCorrectlyPolyhedrons();
2124         res1=m2.arePolyhedronsNotCorrectlyOriented();
2125         self.assertTrue(len(res1)==0);
2126         f2=m2.getMeasureField(False);
2127         f2Ptr=f2.getArray().getValues();
2128         #Test to check global reverse in MEDCouplingUMesh::tryToCorrectPolyhedronOrientation
2129         m3=MEDCouplingDataForTest.build2DTargetMesh_1();
2130         vec=[0.,0.,1.]
2131         m3.changeSpaceDimension(3);
2132         ids2=[0,1,2,3,4]
2133         m3.convertToPolyTypes(ids2);
2134         m3.orientCorrectly2DCells(vec,False);
2135         m4=MEDCouplingDataForTest.buildCU1DMesh_U();
2136         m4.changeSpaceDimension(3);
2137         center=[0.,0.,0.]
2138         vector=[0.,1.,0.]
2139         m4.rotate(center,vector,-pi/2.);
2140         m5=m3.buildExtrudedMesh(m4,0);
2141         res1=m5.arePolyhedronsNotCorrectlyOriented();
2142         self.assertEqual(15,len(res1));
2143         m5.orientCorrectlyPolyhedrons();
2144         res1=m5.arePolyhedronsNotCorrectlyOriented();
2145         self.assertTrue(len(res1)==0);
2146         f3=m5.getMeasureField(False);
2147         self.assertEqual(15,f3.getArray().getNumberOfTuples());
2148         self.assertEqual(1,f3.getNumberOfComponents());
2149         f3Ptr=f3.getArray().getValues();
2150         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];
2151         for i in xrange(15):
2152             self.assertTrue(abs(expected1[i]-f3Ptr[i])<1e-12);
2153             pass
2154         f4=m5.getBarycenterAndOwner();
2155         self.assertEqual(15,f4.getNumberOfTuples());
2156         self.assertEqual(3,f4.getNumberOfComponents());
2157         f4Ptr=f4.getValues();
2158         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];
2159         for i in xrange(45):
2160             self.assertTrue(abs(expected2[i]-f4Ptr[i])<1e-12);
2161             pass
2162         pass
2163
2164     def testPolyhedronBarycenter(self):
2165         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];
2166         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];
2167         meshN=MEDCouplingUMesh.New();
2168         meshN.setName("ForBary");
2169         meshN.setMeshDimension(3);
2170         meshN.allocateCells(4);
2171         meshN.insertNextCell(NORM_POLYHED,29,connN[0:29])
2172         meshN.finishInsertingCells();
2173         myCoords=DataArrayDouble.New();
2174         myCoords.setValues(coords,9,3);
2175         meshN.setCoords(myCoords);
2176         meshN.checkCoherency();
2177         #
2178         res1=meshN.arePolyhedronsNotCorrectlyOriented();
2179         meshN.orientCorrectlyPolyhedrons();
2180         self.assertTrue(len(res1)==0);
2181         da=meshN.getBarycenterAndOwner();
2182         self.assertEqual(1,da.getNumberOfTuples());
2183         self.assertEqual(3,da.getNumberOfComponents());
2184         daPtr=da.getValues();
2185         ref=meshN.getCoords().getValues()[24:];
2186         for i in xrange(3):
2187             self.assertTrue(abs(ref[i]-daPtr[i])<1e-12);
2188             pass
2189         #
2190         center=[0.,0.,0.]
2191         vec=[0.,2.78,0.]
2192         da=meshN.getBarycenterAndOwner();
2193         daPtr=da.getValues();
2194         ref=meshN.getCoords().getValues()[24:];
2195         for i in xrange(3):
2196             self.assertTrue(abs(ref[i]-daPtr[i])<1e-12);
2197             pass
2198         #
2199         meshN.rotate(center,vec,pi/7.);
2200         meshN.translate(vec);
2201         da=meshN.getBarycenterAndOwner();
2202         daPtr=da.getValues();
2203         ref=meshN.getCoords().getValues()[24:];
2204         for i in xrange(3):
2205             self.assertTrue(abs(ref[i]-daPtr[i])<1e-12);
2206             pass
2207         #
2208         center2=[1.12,3.45,6.78]
2209         vec2=[4.5,9.3,2.8]
2210         meshN.rotate(center2,vec2,e);
2211         meshN.translate(vec2);
2212         da=meshN.getBarycenterAndOwner();
2213         daPtr=da.getValues();
2214         ref=meshN.getCoords().getValues()[24:];
2215         for i in xrange(3):
2216             self.assertTrue(abs(ref[i]-daPtr[i])<1e-10);
2217             pass
2218         pass
2219
2220     def testNormL12Integ1D(self):
2221         m1=MEDCouplingDataForTest.build1DTargetMesh_3();
2222         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2223         f1.setMesh(m1);
2224         array=DataArrayDouble.New();
2225         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]
2226         array.setValues(arr,m1.getNumberOfCells(),3);
2227         f1.setArray(array);
2228         #
2229         f3=m1.getBarycenterAndOwner();
2230         self.assertEqual(4,f3.getNumberOfTuples());
2231         self.assertEqual(1,f3.getNumberOfComponents());
2232         expected9=[0.75,5.105,0.8,5.155]
2233         ptr=f3.getValues();
2234         for i in xrange(4):
2235             self.assertTrue(abs(expected9[i]-ptr[i])<1e-12);
2236             pass
2237         #
2238         f2=m1.getMeasureField(False);
2239         self.assertEqual(4,f2.getArray().getNumberOfTuples());
2240         self.assertEqual(1,f2.getNumberOfComponents());
2241         expected1=[0.5,0.21,-0.6,-0.31]
2242         ptr=f2.getArray().getValues();
2243         for i in xrange(4):
2244             self.assertTrue(abs(expected1[i]-ptr[i])<1e-12);
2245             pass
2246         expected2=[0.5,0.21,0.6,0.31]
2247         f2=m1.getMeasureField(True);
2248         ptr=f2.getArray().getValues();
2249         for i in xrange(4):
2250             self.assertTrue(abs(expected2[i]-ptr[i])<1e-12);
2251             pass
2252         #integral
2253         self.assertTrue(4,f1.getNumberOfTuples())
2254         res=f1.integral(False);
2255         self.assertTrue(3,len(res))
2256         expected3=[0.9866,-0.3615,0.4217]
2257         for i in xrange(3):
2258             self.assertTrue(abs(expected3[i]-res[i])<1e-12);
2259             pass
2260         self.assertTrue(abs(expected3[0]-f1.integral(0,False))<1e-12);
2261         self.assertTrue(abs(expected3[1]-f1.integral(1,False))<1e-12);
2262         self.assertTrue(abs(expected3[2]-f1.integral(2,False))<1e-12);
2263         res=f1.integral(True);
2264         expected4=[-3.4152,8.7639,-14.6879]
2265         for i in xrange(3):
2266             self.assertTrue(abs(expected4[i]-res[i])<1e-12);
2267             pass
2268         #normL1
2269         res=f1.normL1();
2270         self.assertTrue(3,len(res))
2271         expected5=[6.979506172839505, 16.89018518518518, 27.02969135802469]
2272         for i in xrange(3):
2273             self.assertTrue(abs(expected5[i]-res[i])<1e-12);
2274             pass
2275         self.assertTrue(abs(expected5[0]-f1.normL1(0))<1e-12);
2276         self.assertTrue(abs(expected5[1]-f1.normL1(1))<1e-12);
2277         self.assertTrue(abs(expected5[2]-f1.normL1(2))<1e-12);
2278         #normL2
2279         res=f1.normL2();
2280         self.assertTrue(3,len(res))
2281         expected7=[7.090910979452395, 16.9275542960123, 27.053271464160858]
2282         for i in xrange(3):
2283             self.assertTrue(abs(expected7[i]-res[i])<1e-9);
2284             pass
2285         self.assertTrue(abs(expected7[0]-f1.normL2(0))<1e-9);
2286         self.assertTrue(abs(expected7[1]-f1.normL2(1))<1e-9);
2287         self.assertTrue(abs(expected7[2]-f1.normL2(2))<1e-9);
2288         #buildMeasureField
2289         f4=f1.buildMeasureField(False);
2290         self.assertTrue(abs(-0.2-f4.accumulate(0))<1e-12);
2291         f4=f1.buildMeasureField(True);
2292         self.assertTrue(abs(1.62-f4.accumulate(0))<1e-12);
2293         # Testing with 2D Curve
2294         m1=MEDCouplingDataForTest.build2DCurveTargetMesh_3();
2295         f2=m1.getMeasureField(False);
2296         self.assertEqual(4,f2.getArray().getNumberOfTuples());
2297         self.assertEqual(1,f2.getNumberOfComponents());
2298         ptr=f2.getArray().getValues();
2299         for i in xrange(4):
2300             self.assertTrue(abs(sqrt(2.)*expected2[i]-ptr[i])<1e-12);
2301             pass
2302         f2=m1.getMeasureField(True);
2303         self.assertEqual(4,f2.getArray().getNumberOfTuples());
2304         self.assertEqual(1,f2.getNumberOfComponents());
2305         ptr=f2.getArray().getValues();
2306         for i in xrange(4):
2307             self.assertTrue(abs(expected2[i]*sqrt(2.)-ptr[i])<1e-12);
2308             pass
2309         #bary
2310         f3=m1.getBarycenterAndOwner();
2311         self.assertEqual(4,f3.getNumberOfTuples());
2312         self.assertEqual(2,f3.getNumberOfComponents());
2313         expected10=[0.75,0.75,5.105,5.105,0.8,0.8,5.155,5.155]
2314         ptr=f3.getValues();
2315         for i in xrange(8):
2316             self.assertTrue(abs(expected10[i]-ptr[i])<1e-12);
2317             pass
2318         #
2319         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2320         f1.setMesh(m1);
2321         array=DataArrayDouble.New();
2322         array.setValues(arr,m1.getNumberOfCells(),3);
2323         f1.setArray(array);
2324         res=f1.integral(False);
2325         for i in xrange(3):
2326             self.assertTrue(abs(sqrt(2.)*expected4[i]-res[i])<1e-12);
2327             pass
2328         res=f1.integral(True);
2329         for i in xrange(3):
2330             self.assertTrue(abs(sqrt(2.)*expected4[i]-res[i])<1e-12);
2331             pass
2332         res=f1.normL1();
2333         for i in xrange(3):
2334             self.assertTrue(abs(expected5[i]-res[i])<1e-12);
2335             pass
2336         res=f1.normL2();
2337         for i in xrange(3):
2338             self.assertTrue(abs(expected7[i]-res[i])<1e-12);
2339             pass
2340         pass
2341
2342     def testAreaBary2D(self):
2343         m1=MEDCouplingDataForTest.build2DTargetMesh_3();
2344         f1=m1.getMeasureField(False);
2345         self.assertEqual(10,f1.getArray().getNumberOfTuples());
2346         self.assertEqual(1,f1.getNumberOfComponents());
2347         expected1=[-0.5,-1,-1.5,-0.5,-1,  0.5,1,1.5,0.5,1]
2348         ptr=f1.getArray().getValues();
2349         for i in xrange(10):
2350             self.assertTrue(abs(expected1[i]-ptr[i])<1e-12);
2351             pass
2352         f1=m1.getMeasureField(True);
2353         ptr=f1.getArray().getValues();
2354         for i in xrange(10):
2355             self.assertTrue(abs(abs(expected1[i])-ptr[i])<1e-12);
2356             pass
2357         f2=m1.getBarycenterAndOwner();
2358         self.assertEqual(10,f2.getNumberOfTuples());
2359         self.assertEqual(2,f2.getNumberOfComponents());
2360         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]
2361         ptr=f2.getValues();
2362         for i in xrange(20):
2363             self.assertTrue(abs(expected2[i]-ptr[i])<1e-12);
2364             pass
2365         m1.changeSpaceDimension(3);
2366         f1=m1.getMeasureField(False);
2367         self.assertEqual(10,f1.getArray().getNumberOfTuples());
2368         self.assertEqual(1,f1.getNumberOfComponents());
2369         ptr=f1.getArray().getValues();
2370         for i in xrange(10):
2371             self.assertTrue(abs(abs(expected1[i])-ptr[i])<1e-12);
2372             pass
2373         f2=m1.getBarycenterAndOwner();
2374         self.assertEqual(10,f2.getNumberOfTuples());
2375         self.assertEqual(3,f2.getNumberOfComponents());
2376         ptr=f2.getValues();
2377         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.]
2378         for i in xrange(30):
2379             self.assertTrue(abs(expected3[i]-ptr[i])<1e-12);
2380             pass
2381         pass
2382
2383     def testAreaBary3D(self):
2384         coords=[ 0.241310763507 , 0.0504777305619 , 0.0682283524903 , 0.252501053866 , -0.0625176732937 , 0.137272639894 ,
2385                  0.152262663601 , 0.241816569527 , 0.133812556197 , 0.18047750211 , -0.0789949051358 , 0.339098173401 ,
2386                  0.151741971857 , 0.238885278571 , 0.137715037333 , 0.242532155481 , -0.0928169086456 , 0.0678043417367 ,
2387                  0.240941965335 , -0.015461491464 , 0.0617186345825 , 0.24127650112 , 0.0499427876717 , 0.0679634099148 ,
2388                  -0.145828917428 , 0.206291632565 , 0.0310071927543 , 0.0125651775307 , 0.266262085828 , 0.105228430543 ,
2389                  -0.0994066533286 , 0.233224271238 , 0.0572213839567 , -0.0951345338317 , 0.234819509426 , 0.0592126284538 ,
2390                  0.136580574205 , -0.205486212579 , 0.0572866072014 , 0.0637270784978 , -0.168886355238 , 0.446614057077 ,
2391                  0.041337157151 , -0.213402568198 , 0.372407095999 , 0.0411601970268 , -0.202387875756 , 0.411334979491 ,
2392                  -0.108355701857 , 0.193636239335 , 0.204886756738 , 0.00639779029829 , 0.155296981517 , 0.252585892979 ,
2393                  0.0262473111702 , -0.112919732543 , 0.424286639249 ,-0.224103052733 , -0.139430015438 , -0.0122352295701 ,
2394                 -0.0312760589481 , -0.274272003594 , 0.0323959636568 , -0.166663422532 , -0.217754445175 , 0.00392109070364 ,
2395                  -0.30586619777 , -0.0475168041091 , -0.0144585228182 , -0.280881480586 , 0.135571293538 , 0.00623923647986 ,
2396                  -0.25548538234 , 0.156819217766 , 0.0645277879769 , -0.131567009284 , 0.184133752309 , 0.206021802753 ,
2397                  -0.196204010965 , 0.151602971681 , 0.212974777736 , -0.183713879463 , 0.0802946639531 , 0.260115662599 ,
2398                  -0.244241178767 , -0.0738873389604 , 0.144590565817 , -0.155804057829 , -0.164892720025 , 0.210613950558 ,
2399                  -0.170950800428 , -0.215099334026 , 0.00610122860092 , -0.30552634869 , -0.0490020791904 , -0.0132786533145 ,
2400                  0.271831011884 , 0.15105657296 , 0.0230534827908 , 0.281919192283 , 0.0898544306288 , -0.0625201489143 ,
2401                  0.260240727276 , -0.0120688706637 , -0.0532316588626 , 0.244947737722 , 0.0197984684293 , 0.0309341209233 ,
2402                  0.23439631578 , 0.229825279875 , 0.0508520585381 , 0.160921316875 , 0.265078502128 , 0.121716560626 ,
2403                  -0.315088694175 , 0.0747700471918 , -0.245836615071 , -0.327728781776 , 0.0857114674649 , -0.239431905957 ,
2404                  -0.308385460634 , 0.145142997084 , -0.149886828433 , 0.0488236045164 , 0.309462801914 , 0.0849169148265 ,
2405                 -0.0244964803395 , 0.33145611751 , -0.0476415818061 , 0.0060567994229 , 0.32418412014 , 0.0367779543812 ,
2406                  -0.0950221448063 , 0.236675326003 , 0.0572594453983 , 0.248723023186 , 0.0886648784791 , -0.176629430538 ,
2407                  0.116796984 , 0.256596599567 , -0.292863523603 , 0.118024552914 , 0.229154257843 , -0.34233232501 ,
2408                  0.217507892549 , -0.0417822335742 , -0.176771782888 , -0.224429321304 , 0.0125595300114 , -0.362064725588 ,
2409                  0.0937301100955 , -0.0500824832657 , -0.299713548444 , -0.244162220397 , 0.0383853931293 , -0.389856984411 ,
2410                  -0.0281989366102 , 0.097392811563 , -0.458244577284 , -0.385010847162 , 0.10122766194 , -0.140052859922 ,
2411                  -0.377936358012 , 0.110875172128 , -0.176207095463 , 0.244483045556 , -0.0991073977045 , 0.0575134372934 ,
2412                 0.262605120167 , -0.100243191645 , -0.0495620806935 , 0.240306880972 , -0.136153701579 , -0.114745281696 ,
2413                  0.215763176129 , -0.0836766059189 , -0.183249640616 , 0.237870396603 , -0.132449578286 , -0.121598854639 ,
2414                  -0.0637683083097 , -0.27921020214 , -0.149112321992 , -0.0856211014977 , -0.2973233473 , -0.0446878139589 ,
2415                  0.104675342288 , -0.0625908305324 , -0.290346256534 , 0.0248264249186 , -0.247797708548 , -0.165830884019 ,
2416                  0.0719302438309 , -0.178468260473 , -0.211432157345 , 0.142871843159 , -0.208769948542 , 0.0454101128246 ,
2417                  0.167803379307 , -0.207851396623 , -0.088802726124 , 0.12868717152 , -0.230920439715 , 0.00760508389036 ,
2418                  -0.0372812069535 , -0.286740286332 , 0.00963701291166 ]
2419
2420         connN = [ #polyhedron 0
2421             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
2422             , 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
2423             , 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
2424             , 22 , 19 , 21 , 30 , 31 , -1 , 22 , 31 , 28 , 27 , 26 , 24 , 23 , -1 , 31 , 30 , 29 , 28,
2425             # polyhedron 1
2426             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
2427             , 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
2428             , 33 , 34 , 48 , 45 , -1 , 35 , 34 , 48 , 50 , 49 , 38 , -1 , 41 , 43 , 42 , 46 , 36 , 37 , -1 , 38 , 39 , 51 , 49 , -1
2429             , 39 , 40 , 42 , 46 , 47 , 52 , 51 , -1 , 45 , 47 , 52 , 50 , 48 , -1 , 52 , 51 , 49 , 50,
2430             # polyhedron 2
2431             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
2432             , 23 , 53 , 54 , 40 , 8 , -1 , 53 , 22 , 23 , -1 , 39 , 54 , 40,
2433             # polyhedron 3
2434             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
2435             , 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
2436             , 55 , 5 , 12 , 65 , -1 , 66 , 67 , 65 , 55 , 56 , 57 , -1 , 63 , 66 , 57 , 59 , 64 , -1 , 64 , 62 , 58 , 59 , -1
2437             , 60 , 63 , 66 , 67 , 68 , 61 , -1 , 61 , 68 , 20 , 21 , -1 , 67 , 68 , 20 , 12 , 65]
2438
2439         barys = [ -0.0165220465527 , -0.0190922868195 , 0.158882733414 ,
2440                   0.0287618656076 , 0.135874379934 , -0.14601588119 ,
2441                   -0.147128055553 , 0.0465995097041 , -0.049391174453 ,
2442                   -0.00142506732317 , -0.0996953090351 , -0.115159183132 ]
2443         meshN=MEDCouplingUMesh.New();
2444         meshN.setName("ForBary");
2445         meshN.setMeshDimension(3);
2446         meshN.allocateCells(4);
2447         meshN.insertNextCell(NORM_POLYHED,113,connN);
2448         meshN.insertNextCell(NORM_POLYHED,99,connN[113:]);
2449         meshN.insertNextCell(NORM_POLYHED,43,connN[212:]);
2450         meshN.insertNextCell(NORM_POLYHED,92,connN[255:]);
2451         meshN.finishInsertingCells();
2452         myCoords=DataArrayDouble.New();
2453         myCoords.setValues(coords,69,3);
2454         meshN.setCoords(myCoords);
2455         meshN.checkCoherency();
2456         res1=meshN.arePolyhedronsNotCorrectlyOriented();
2457         meshN.orientCorrectlyPolyhedrons();
2458         res1=meshN.arePolyhedronsNotCorrectlyOriented();
2459         self.assertTrue(len(res1)==0);
2460         #
2461         da=meshN.getBarycenterAndOwner();
2462         self.assertEqual(4,da.getNumberOfTuples());
2463         self.assertEqual(3,da.getNumberOfComponents());
2464         daPtr=da.getValues();
2465         for i in xrange(12):
2466             self.assertTrue(abs(barys[i]-daPtr[i])<1e-12);
2467             pass
2468         pass
2469
2470     def testRenumberCellsForFields(self):
2471         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2472         f=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2473         f.setMesh(m);
2474         arr=DataArrayDouble.New();
2475         nbOfCells=m.getNumberOfCells();
2476         values1=[7.,107.,10007.,8.,108.,10008.,9.,109.,10009.,10.,110.,10010.,11.,111.,10011.]
2477         arr.setValues(values1,nbOfCells,3);
2478         f.setArray(arr);
2479         renumber1=[3,1,0,4,2]
2480         loc=[-0.05,-0.05, 0.55,-0.25, 0.55,0.15, -0.05,0.45, 0.45,0.45]
2481         for j in xrange(5):
2482             res=f.getValueOn(loc[2*j:2*j+2]);
2483             for i in xrange(3):
2484                 self.assertTrue(abs(values1[i+3*j]-res[i])<1e-12);
2485                 pass
2486             pass
2487         f.renumberCells(renumber1,False);
2488         ptr=f.getArray().getValues();
2489         expected1=[9.,109.,10009.,8.,108.,10008.,11.,111.,10011.,7.,107.,10007.,10.,110.,10010.]
2490         for i in xrange(15):
2491             self.assertTrue(abs(expected1[i]-ptr[i])<1e-12);
2492             pass
2493         #check that fields remains the same geometrically
2494         for j in xrange(5):
2495             res=f.getValueOn(loc[2*j:2*(j+1)]);
2496             for i in xrange(3):
2497                 self.assertTrue(abs(values1[i+3*j]-res[i])<1e-12);
2498                 pass
2499             pass
2500         #On gauss
2501         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,NO_TIME);
2502         f.setMesh(m);
2503         _a=0.446948490915965;
2504         _b=0.091576213509771;
2505         _p1=0.11169079483905;
2506         _p2=0.0549758718227661;
2507         refCoo1=[ 0.,0., 1.,0., 0.,1. ]
2508         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 ];
2509         wg1=[ 4*_p2, 4*_p2, 4*_p2, 4*_p1, 4*_p1, 4*_p1 ]
2510         _refCoo1=refCoo1[0:6];
2511         _gsCoo1=gsCoo1[0:12];
2512         _wg1=wg1[0:6];
2513         f.setGaussLocalizationOnType(NORM_TRI3,_refCoo1,_gsCoo1,_wg1);
2514         refCoo2=[ 0.,0., 1.,0., 1.,1., 0.,1. ]
2515         _refCoo2=refCoo2[0:8];
2516         _gsCoo1=_gsCoo1[0:4]
2517         _wg1=_wg1[0:2]
2518         f.setGaussLocalizationOnType(NORM_QUAD4,_refCoo2,_gsCoo1,_wg1);
2519         arr=DataArrayDouble.New();
2520         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.]
2521         arr.setValues(values2,18,2);
2522         f.setArray(arr);
2523         f.checkCoherency();
2524         fCpy=f.clone(True);
2525         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2526         f.renumberCells(renumber1,False);
2527         self.assertTrue(not f.isEqual(fCpy,1e-12,1e-12));
2528         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.]
2529         ptr=f.getArray().getValues();
2530         for i in xrange(36):
2531             self.assertTrue(abs(expected2[i]-ptr[i])<1e-12);
2532             pass
2533         renumber2=[2,1,4,0,3]
2534         f.renumberCells(renumber2,False);
2535         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2536         #GaussNE
2537         f=MEDCouplingFieldDouble.New(ON_GAUSS_NE,NO_TIME);
2538         f.setMesh(m);
2539         arr=DataArrayDouble.New();
2540         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.]
2541         arr.setValues(values3,18,2);
2542         f.setArray(arr);
2543         f.checkCoherency();
2544         fCpy=f.clone(True);
2545         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2546         f.renumberCells(renumber1,False);
2547         self.assertTrue(not f.isEqual(fCpy,1e-12,1e-12));
2548         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.]
2549         ptr=f.getArray().getValues();
2550         for i in xrange(36):
2551             self.assertTrue(abs(expected3[i]-ptr[i])<1e-12);
2552             pass
2553         f.renumberCells(renumber2,False);#perform reverse operation of renumbering to check that the resulting field is equal.
2554         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2555         #
2556         pass
2557
2558     def testRenumberNodesForFields(self):
2559         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2560         f=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
2561         f.setMesh(m);
2562         self.assertEqual(9,f.getNumberOfMeshPlacesExpected());
2563         arr=DataArrayDouble.New();
2564         nbOfNodes=m.getNumberOfNodes();
2565         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.]
2566         arr.setValues(values1,nbOfNodes,3);
2567         f.setArray(arr);
2568         f.checkCoherency();
2569         renumber1=[0,4,1,3,5,2,6,7,8]
2570         loc=[0.5432,-0.2432, 0.5478,0.1528]
2571         expected1=[9.0272, 109.0272, 10009.0272, 11.4124,111.4124,10011.4124]
2572         for j in xrange(2):
2573             res=f.getValueOn(loc[2*j:2*j+2]);
2574             for i in xrange(3):
2575                 self.assertTrue(abs(expected1[i+3*j]-res[i])<1e-12);
2576                 pass
2577             pass
2578         fCpy=f.clone(True);
2579         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2580         f.renumberNodes(renumber1);
2581         self.assertTrue(not f.isEqual(fCpy,1e-12,1e-12));
2582         for j in xrange(2):
2583             res=f.getValueOn(loc[2*j:2*j+2]);
2584             for i in xrange(3):
2585                 self.assertTrue(abs(expected1[i+3*j]-res[i])<1e-12);
2586                 pass
2587             pass
2588         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.]
2589         for i in xrange(27):
2590             self.assertTrue(abs(expected2[i]-f.getArray().getValues()[i])<1e-12);
2591             pass
2592         renumber2=[0,2,5,3,1,4,6,7,8]
2593         f.renumberNodes(renumber2);
2594         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2595         pass
2596
2597     def testConvertQuadraticCellsToLinear(self):
2598         mesh=MEDCouplingDataForTest.build2DTargetMesh_3();
2599         mesh.checkCoherency();
2600         types=mesh.getAllTypes();
2601         types.sort()
2602         self.assertEqual(5,len(types));
2603         expected1=[NORM_POLYGON, NORM_TRI3, NORM_QUAD4, NORM_TRI6, NORM_QUAD8]
2604         expected1.sort()
2605         self.assertEqual(expected1,types);
2606         self.assertTrue(mesh.isPresenceOfQuadratic());
2607         self.assertEqual(62,mesh.getMeshLength());
2608         f1=mesh.getMeasureField(False);
2609         #
2610         mesh.convertQuadraticCellsToLinear();
2611         self.assertTrue(not mesh.isPresenceOfQuadratic());
2612         #
2613         mesh.checkCoherency();
2614         f2=mesh.getMeasureField(False);
2615         self.assertTrue(f1.getArray().isEqual(f2.getArray(),1e-12));
2616         self.assertEqual(48,mesh.getMeshLength());
2617         types2=mesh.getAllTypes();
2618         types2.sort()
2619         self.assertEqual(3,len(types2));
2620         expected2=[NORM_POLYGON, NORM_TRI3, NORM_QUAD4]
2621         expected2.sort()
2622         self.assertEqual(expected2,types2);
2623         pass
2624
2625     def testCheckGeoEquivalWith(self):
2626         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2627         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2628         #First test mesh1
2629         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh1,0,1e-12);#deepEqual
2630         self.assertTrue(cellCor==None);
2631         self.assertTrue(nodeCor==None);
2632         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh1,1,1e-12);#fastEqual
2633         self.assertTrue(cellCor==None);
2634         self.assertTrue(nodeCor==None);
2635         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh1,10,1e-12);#deepEqual with geo permutations
2636         self.assertTrue(cellCor==None);
2637         self.assertTrue(nodeCor==None);
2638         #Second test mesh1 and mesh2 are 2 different meshes instance
2639         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,0,1e-12);#deepEqual
2640         self.assertTrue(cellCor==None);
2641         self.assertTrue(nodeCor==None);
2642         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,1,1e-12);#fastEqual
2643         self.assertTrue(cellCor==None);
2644         self.assertTrue(nodeCor==None);
2645         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);#deepEqual with geo permutations
2646         self.assertTrue(cellCor==None);
2647         self.assertTrue(nodeCor==None);
2648         #Third test : cell permutation by keeping the first the middle and the last as it is.
2649         renum=[0,2,1,3,4,5,6,8,7,9]
2650         mesh2.renumberCells(renum,False);
2651         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12);#deepEqual fails
2652         self.assertTrue(cellCor==None);
2653         self.assertTrue(nodeCor==None);
2654         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,1,1e-12);#fastEqual do not see anything
2655         self.assertTrue(cellCor==None);
2656         self.assertTrue(nodeCor==None);
2657         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);#deepEqual with geo permutations
2658         self.assertTrue(cellCor);
2659         self.assertEqual(10,cellCor.getNumberOfTuples());
2660         self.assertEqual(1,cellCor.getNumberOfComponents());
2661         self.assertEqual(renum,list(cellCor.getValues()))
2662         self.assertTrue(nodeCor==None);
2663         cellCor=0;
2664         self.assertTrue(nodeCor==None);
2665         #4th test : cell and node permutation by keeping the first the middle and the last as it is.
2666         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2667         renum2=[0,2,1,3,4,5,6,8,7,9,10]
2668         mesh2.renumberCells(renum,False);
2669         mesh2.renumberNodes(renum2,11);
2670         cellCor=None
2671         nodeCor=None
2672         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12);#deepEqual fails
2673         self.assertTrue(cellCor==None);
2674         self.assertTrue(nodeCor==None);
2675         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,1,1e-12);#fastEqual do not see anything
2676         self.assertTrue(cellCor==None);
2677         self.assertTrue(nodeCor==None);
2678         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);#deepEqual with geo permutations
2679         self.assertTrue(cellCor);
2680         self.assertEqual(10,cellCor.getNumberOfTuples());
2681         self.assertEqual(1,cellCor.getNumberOfComponents());
2682         self.assertEqual(renum,list(cellCor.getValues()))
2683         self.assertTrue(nodeCor);
2684         self.assertEqual(11,nodeCor.getNumberOfTuples());
2685         self.assertEqual(1,nodeCor.getNumberOfComponents());
2686         self.assertEqual(renum2,list(nodeCor.getValues()))
2687         cellCor=0;
2688         nodeCor=0;
2689         #5th test : modification of the last cell to check fastCheck detection.
2690         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2691         renum3=[0,2,1,3,4,5,6,8,9,7]
2692         mesh2.renumberCells(renum3,False);
2693         mesh2.renumberNodes(renum2,11);
2694         cellCor=None
2695         nodeCor=None
2696         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12)
2697         self.assertTrue(cellCor==None);
2698         self.assertTrue(nodeCor==None);
2699         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,1,1e-12)
2700         self.assertTrue(cellCor==None);
2701         self.assertTrue(nodeCor==None);
2702         cellCor,nodeCor=mesh2.checkGeoEquivalWith(mesh1,10,1e-12);#deepEqual with geo permutations
2703         self.assertTrue(cellCor!=None);
2704         self.assertEqual(10,cellCor.getNumberOfTuples());
2705         self.assertEqual(1,cellCor.getNumberOfComponents());
2706         self.assertEqual(renum3,list(cellCor.getValues()))
2707         self.assertTrue(nodeCor!=None);
2708         self.assertEqual(11,nodeCor.getNumberOfTuples());
2709         self.assertEqual(1,nodeCor.getNumberOfComponents());
2710         self.assertEqual(renum2,list(nodeCor.getValues()));
2711         pass
2712
2713     def testCheckGeoEquivalWith2(self):
2714         mesh1=MEDCouplingDataForTest.build2DTargetMesh_4();
2715         mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
2716         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);
2717         self.assertEqual(None,cellCor);
2718         self.assertNotEqual(None,nodeCor);
2719         expected1=[0, 1, 3, 4, 5, 6, 7, 8, 9]
2720         for i in xrange(9):
2721             self.assertEqual(expected1[i],nodeCor.getIJ(i,0));
2722             pass
2723         pass
2724
2725     def testCopyTinyStringsFromOnFields(self):
2726         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2727         nbOfCells=m.getNumberOfCells();
2728         f=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
2729         f.setMesh(m);
2730         self.assertEqual(5,f.getNumberOfMeshPlacesExpected());
2731         f.setName("a");
2732         f.setDescription("b");
2733         a1=DataArrayDouble.New();
2734         a1.alloc(nbOfCells,2);
2735         a1.fillWithZero();
2736         a1.setInfoOnComponent(0,"c");
2737         a1.setInfoOnComponent(1,"d");
2738         a2=a1.deepCpy();
2739         a2.setInfoOnComponent(0,"e");
2740         a2.setInfoOnComponent(1,"f");
2741         f.setArray(a1);
2742         f.setEndArray(a2);
2743         f.setEndTime(3.,3,4);
2744         m.setName("g");
2745         m.getCoords().setInfoOnComponent(0,"h");
2746         m.getCoords().setInfoOnComponent(1,"i");
2747         m.getCoords().setInfoOnComponent(2,"j");
2748         #
2749         f.checkCoherency();
2750         f2=f.clone(True);
2751         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2752         f2.setName("smth");
2753         self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2754         f2.copyTinyStringsFrom(f);
2755         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2756         f2.setDescription("GGG");
2757         self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2758         f2.copyTinyStringsFrom(f);
2759         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2760         f2.getArray().setInfoOnComponent(0,"mmmm");
2761         self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2762         f2.copyTinyStringsFrom(f);
2763         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2764         f2.getEndArray().setInfoOnComponent(1,"mmmm");
2765         self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2766         f2.copyTinyStringsFrom(f);
2767         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2768         m2=m.clone(True);
2769         self.assertTrue(m2.isEqual(m,1e-12));
2770         m2.setName("123");
2771         self.assertTrue(not m2.isEqual(m,1e-12));
2772         m2.copyTinyStringsFrom(m);
2773         self.assertTrue(m2.isEqual(m,1e-12));
2774         m2.getCoords().setInfoOnComponent(1,"eee");
2775         self.assertTrue(not m2.isEqual(m,1e-12));
2776         m2.copyTinyStringsFrom(m);
2777         self.assertTrue(m2.isEqual(m,1e-12));
2778         pass
2779
2780     def testTryToShareSameCoordsPermute(self):
2781         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2782         m2=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2783         #self.assertTrue(m.getCoords()!=m2.getCoords());
2784         m.tryToShareSameCoordsPermute(m2,1e-12);
2785         #self.assertTrue(m.getCoords()==m2.getCoords());
2786         self.assertTrue(m2.isEqual(m,1e-12));
2787         renum1=[1,2,0,5,8,7,4,3,6]
2788         r1=DataArrayInt.New()
2789         r1.setValues(renum1,len(renum1),1)
2790         m.renumberNodes(r1,9);
2791         #self.assertTrue(m.getCoords()!=m2.getCoords());
2792         self.assertTrue(not m2.isEqual(m,1e-12));
2793         m.tryToShareSameCoordsPermute(m2,1e-12);
2794         #self.assertTrue(m.getCoords()==m2.getCoords());
2795         self.assertTrue(m2.isEqual(m,1e-12));
2796         pass
2797
2798     def testTryToShareSameCoordsPermute2(self):
2799         m1=MEDCouplingDataForTest.build2DTargetMesh_4();
2800         targetCoords=[-0.3,-0.3, 0.2,-0.3, -0.3,0.2, 0.2,0.2 ]
2801         targetConn=[0,2,3,1]
2802         m2=MEDCouplingUMesh.New();
2803         m2.setMeshDimension(2);
2804         m2.allocateCells(1);
2805         m2.insertNextCell(NORM_QUAD4,targetConn[0:4])
2806         m2.finishInsertingCells();
2807         myCoords=DataArrayDouble.New();
2808         myCoords.setValues(targetCoords,4,2);
2809         m2.setCoords(myCoords);
2810         m2.checkCoherency();
2811         m1.checkCoherency();
2812         #
2813         expected1=[0.25,0.125,0.125,0.25,0.25]
2814         f1=m1.getMeasureField(False);
2815         f2=m2.getMeasureField(False);
2816         self.assertEqual(5,f1.getArray().getNumberOfTuples());
2817         self.assertEqual(1,f2.getArray().getNumberOfTuples());
2818         for i in xrange(5):
2819             self.assertAlmostEqual(expected1[i],f1.getIJ(i,0),12);
2820             pass
2821         self.assertAlmostEqual(expected1[0],f2.getIJ(0,0),12);
2822         self.assertRaises(InterpKernelException,m1.tryToShareSameCoordsPermute,m2,1e-12);# <- here in this order the sharing is impossible.
2823         # Let's go for deeper test of tryToShareSameCoordsPermute
2824         m2.tryToShareSameCoordsPermute(m1,1e-12);
2825         f1=m1.getMeasureField(False);
2826         f2=m2.getMeasureField(False);
2827         self.assertEqual(5,f1.getArray().getNumberOfTuples());
2828         self.assertEqual(1,f2.getArray().getNumberOfTuples());
2829         for i in xrange(5):
2830             self.assertAlmostEqual(expected1[i],f1.getIJ(i,0),12);
2831             pass
2832         self.assertAlmostEqual(expected1[0],f2.getIJ(0,0),12);
2833         pass
2834
2835     def testChangeUnderlyingMesh1(self):
2836         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2837         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2838         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2839         f1.setMesh(mesh1);
2840         array=DataArrayDouble.New();
2841         arr=[7., 107., 8., 108., 9., 109., 10., 110., 11., 111., 12., 112., 13., 113., 14., 114., 15., 115., 16., 116.]
2842         array.setValues(arr,mesh1.getNumberOfCells(),2);
2843         f1.setArray(array);
2844         #
2845         renum=[0,2,1,3,4,5,6,8,7,9]
2846         mesh2.renumberCells(renum,False);
2847         #self.assertTrue(f1.getMesh()==mesh1);
2848         f1.changeUnderlyingMesh(mesh1,10,1e-12);# nothing done only to check that nothing done.
2849         #self.assertTrue(f1.getMesh()==mesh1);
2850         f1.changeUnderlyingMesh(mesh2,10,1e-12);
2851         #self.assertTrue(f1.getMesh()==mesh2);
2852         expected1=[7.,107.,9.,109.,8.,108.,10.,110.,11.,111.,12.,112.,13.,113.,15.,115.,14.,114.,16.,116.]
2853         for i in xrange(20):
2854             self.assertAlmostEqual(expected1[i],f1.getArray().getIJ(0,i),12);
2855             pass
2856         #
2857         f1=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
2858         f1.setMesh(mesh1);
2859         array=DataArrayDouble.New();
2860         arr2=[7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.,17.,117.]
2861         array.setValues(arr2,mesh1.getNumberOfNodes(),2);
2862         f1.setArray(array);
2863         #
2864         renum2=[0,2,10,3,4,5,6,8,7,9,1]
2865         mesh2.renumberNodes(renum2,11);
2866         #self.assertTrue(f1.getMesh()==mesh1);
2867         f1.changeUnderlyingMesh(mesh2,10,1e-12);
2868         #self.assertTrue(f1.getMesh()==mesh2);
2869         expected2=[7.,107.,17.,117.,8.,108.,10.,110.,11.,111.,12.,112.,13.,113.,15.,115.,14.,114.,16.,116.,9.,109.]
2870         for i in xrange(22):
2871             self.assertAlmostEqual(expected2[i],f1.getArray().getIJ(0,i),12);
2872             pass
2873         pass
2874
2875     def testGetMaxValue1(self):
2876         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2877         nbOfCells=m.getNumberOfCells();
2878         f=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
2879         f.setMesh(m);
2880         a1=DataArrayDouble.New();
2881         val1=[3.,4.,5.,6.,7.]
2882         a1.setValues(val1,nbOfCells,1);
2883         a2=DataArrayDouble.New();
2884         val2=[0.,1.,2.,8.,7.]
2885         a2.setValues(val2,nbOfCells,1);
2886         f.setArray(a1);
2887         f.setEndArray(a2);
2888         f.setEndTime(3.,3,4);
2889         f.checkCoherency();
2890         #
2891         self.assertAlmostEqual(8.,f.getMaxValue(),14);
2892         self.assertAlmostEqual(0.,f.getMinValue(),14);
2893         self.assertAlmostEqual(5.,f.getAverageValue(),14);
2894         self.assertAlmostEqual(5.125,f.getWeightedAverageValue(),14);
2895         a1.setIJ(0,2,9.5);
2896         self.assertAlmostEqual(9.5,f.getMaxValue(),14);
2897         self.assertAlmostEqual(0.,f.getMinValue(),14);
2898         a2.setIJ(0,0,9.);
2899         self.assertAlmostEqual(9.5,f.getMaxValue(),14);
2900         self.assertAlmostEqual(1.,f.getMinValue(),14);
2901         pass
2902
2903     def testSubstractInPlaceDM1(self):
2904         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2905         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2906         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2907         f1.setMesh(mesh1);
2908         array=DataArrayDouble.New();
2909         arr=[7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.]
2910         array.setValues(arr,mesh1.getNumberOfCells(),2);
2911         f1.setArray(array);
2912         #
2913         self.assertEqual(10,f1.getNumberOfTuples());
2914         self.assertEqual(2,f1.getNumberOfComponents());
2915         self.assertEqual(20,f1.getNumberOfValues());
2916         #
2917         renum=[0,2,3,1,4,5,6,8,7,9]
2918         mesh2.renumberCells(renum,False);
2919         #
2920         f2=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2921         f2.setMesh(mesh2);
2922         array=DataArrayDouble.New();
2923         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]
2924         array.setValues(arr2,mesh2.getNumberOfCells(),2);
2925         f2.setArray(array);
2926         #
2927         f1.substractInPlaceDM(f2,10,1e-12);
2928         f1.applyFunc(1,"abs(x+y+0.2)");
2929         self.assertAlmostEqual(0.,f1.getMaxValue(),13);
2930         pass
2931
2932     def testDotCrossProduct1(self):
2933         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2934         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
2935         f1.setTime(2.3,5,6);
2936         f1.setMesh(mesh1);
2937         array=DataArrayDouble.New();
2938         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.]
2939         array.setValues(arr1,mesh1.getNumberOfCells(),3);
2940         f1.setArray(array);
2941         f2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
2942         f2.setTime(7.8,4,5);
2943         f2.setMesh(mesh1);
2944         array=DataArrayDouble.New();
2945         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.]
2946         array.setValues(arr2,mesh1.getNumberOfCells(),3);
2947         f2.setArray(array);
2948         #
2949         f3=f1.dot(f2);
2950         expected1=[842.,1820.,2816.,3830.,4862.,5912.,6980.,8066.,9170.,10292.]
2951         for i in xrange(10):
2952             self.assertAlmostEqual(expected1[i],f3.getIJ(i,0),9);
2953             pass
2954         #
2955         f4=f1.crossProduct(f2);
2956         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.]
2957         for i in xrange(30):
2958             self.assertAlmostEqual(expected2[i],f4.getIJ(0,i),9);
2959             pass
2960         pass
2961
2962     def testMinMaxFields1(self):
2963         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2964         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
2965         f1.setTime(2.3,5,6);
2966         f1.setMesh(mesh1);
2967         array=DataArrayDouble.New();
2968         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.]
2969         array.setValues(arr1,mesh1.getNumberOfCells(),3);
2970         f1.setArray(array);
2971         f2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
2972         f2.setTime(7.8,4,5);
2973         f2.setMesh(mesh1);
2974         array=DataArrayDouble.New();
2975         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.]
2976         array.setValues(arr2,mesh1.getNumberOfCells(),3);
2977         f2.setArray(array);
2978         #
2979         f3=f1.max(f2);
2980         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.]
2981         for i in xrange(30):
2982             self.assertAlmostEqual(expected1[i],f3.getIJ(0,i),9);
2983             pass
2984         #
2985         f4=f1.min(f2);
2986         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.]
2987         for i in xrange(30):
2988             self.assertAlmostEqual(expected2[i],f4.getIJ(0,i),9);
2989             pass
2990         #
2991         pass
2992
2993     def testApplyLin1(self):
2994         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2995         f1=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
2996         f1.setMesh(mesh1);
2997         array=DataArrayDouble.New();
2998         arr=[7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.]
2999         array.setValues(arr,mesh1.getNumberOfCells(),2);
3000         f1.setArray(array);
3001         #
3002         f1.applyLin(2.,3.,0);
3003         expected1=[17.,107.,19.,108.,21.,109.,23.,110.,25.,111.,27.,112.,29.,113.,31.,114.,33.,115.,35.,116.]
3004         for i in xrange(20):
3005             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),9);
3006             pass
3007         #
3008         arr2=[2.,102.,3.,103.,4.,104.,5.,105.,6.,106.,7.,107.,8.,108.,9.,109.,10.,110.,11.,111.]
3009         array=DataArrayDouble.New();
3010         array.setValues(arr2,mesh1.getNumberOfCells(),2);
3011         f1.setEndArray(array);
3012         #
3013         f1.applyLin(4.,5.,1);
3014         #
3015         expected2=[17.,433.,19.,437.,21.,441.,23.,445.,25.,449.,27.,453.,29.,457.,31.,461.,33.,465.,35.,469.]
3016         for i in xrange(20):
3017             self.assertAlmostEqual(expected2[i],f1.getIJ(0,i),9);
3018             pass
3019         expected3=[2.,413.,3.,417.,4.,421.,5.,425.,6.,429.,7.,433.,8.,437.,9.,441.,10.,445.,11.,449.]
3020         for i in xrange(20):
3021             self.assertAlmostEqual(expected3[i],f1.getEndArray().getIJ(0,i),9);
3022             pass
3023         #
3024         pass
3025
3026     def testGetIdsInRange1(self):
3027         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
3028         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3029         f1.setTime(2.3,5,6);
3030         f1.setMesh(mesh1);
3031         array=DataArrayDouble.New();
3032         arr1=[2.,8.,6.,5.,11.,7.,9.,3.,10.,4.]
3033         array.setValues(arr1,mesh1.getNumberOfCells(),1);
3034         f1.setArray(array);
3035         #
3036         f1.checkCoherency();
3037         da=f1.getIdsInRange(2.9,7.1);
3038         self.failUnlessEqual(5,da.getNbOfElems());
3039         expected1=[2,3,5,7,9]
3040         self.failUnlessEqual(expected1,list(da.getValues()));
3041         da=f1.getIdsInRange(8.,12.);
3042         self.failUnlessEqual(4,da.getNbOfElems());
3043         expected2=[1,4,6,8]
3044         self.failUnlessEqual(expected2,list(da.getValues()));
3045         #
3046         pass
3047
3048     def testBuildSubPart1(self):
3049         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3050         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3051         f1.setTime(2.3,5,6);
3052         f1.setMesh(mesh1);
3053         array=DataArrayDouble.New();
3054         arr1=[3.,103.,4.,104.,5.,105.,6.,106.,7.,107.]
3055         array.setValues(arr1,mesh1.getNumberOfCells(),2);
3056         f1.setArray(array);
3057         #
3058         part1=[2,1,4]
3059         f2=f1[part1];
3060         f2.zipCoords()
3061         self.failUnlessEqual(3,f2.getNumberOfTuples());
3062         self.failUnlessEqual(2,f2.getNumberOfComponents());
3063         expected1=[5.,105.,4.,104.,7.,107.]
3064         for i in xrange(6):
3065             self.assertAlmostEqual(f2.getIJ(0,i),expected1[i],12);
3066             pass
3067         self.failUnlessEqual(3,f2.getMesh().getNumberOfCells());
3068         self.failUnlessEqual(6,f2.getMesh().getNumberOfNodes());
3069         self.failUnlessEqual(2,f2.getMesh().getSpaceDimension());
3070         self.failUnlessEqual(2,f2.getMesh().getMeshDimension());
3071         m2C=f2.getMesh();
3072         self.failUnlessEqual(13,m2C.getMeshLength());
3073         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]
3074         for i in xrange(12):
3075             self.assertAlmostEqual(expected2[i],m2C.getCoords().getIJ(0,i),12);
3076             pass
3077         expected3=[3,2,3,1,3,0,2,1,4,4,5,3,2]
3078         self.failUnlessEqual(expected3,list(m2C.getNodalConnectivity().getValues()));
3079         expected4=[0,4,8,13]
3080         self.failUnlessEqual(expected4,list(m2C.getNodalConnectivityIndex().getValues()));
3081         # Test with field on nodes.
3082         f1=MEDCouplingFieldDouble.New(ON_NODES,ONE_TIME);
3083         f1.setTime(2.3,5,6);
3084         f1.setMesh(mesh1);
3085         array=DataArrayDouble.New();
3086         arr2=[3.,103.,4.,104.,5.,105.,6.,106.,7.,107.,8.,108.,9.,109.,10.,110.,11.,111.]
3087         array.setValues(arr2,mesh1.getNumberOfNodes(),2);
3088         f1.setArray(array);
3089         part2=[1,2]
3090         f2=f1.buildSubPart(part2);
3091         self.failUnlessEqual(4,f2.getNumberOfTuples());
3092         self.failUnlessEqual(2,f2.getNumberOfComponents());
3093         expected5=[4.,104.,5.,105.,7.,107.,8.,108.]
3094         for i in xrange(8):
3095             self.assertAlmostEqual(f2.getIJ(0,i),expected5[i],12);
3096             pass
3097         self.failUnlessEqual(2,f2.getMesh().getNumberOfCells());
3098         self.failUnlessEqual(4,f2.getMesh().getNumberOfNodes());
3099         self.failUnlessEqual(2,f2.getMesh().getSpaceDimension());
3100         self.failUnlessEqual(2,f2.getMesh().getMeshDimension());
3101         m2C=f2.getMesh();
3102         self.failUnlessEqual(8,m2C.getMeshLength());
3103         for i in xrange(8):#8 is not an error
3104             self.assertAlmostEqual(expected2[i],m2C.getCoords().getIJ(0,i),12);
3105             pass
3106         self.failUnlessEqual(expected3[:4],list(m2C.getNodalConnectivity().getValues())[4:]);
3107         self.failUnlessEqual(expected3[4:8],list(m2C.getNodalConnectivity().getValues())[:4]);
3108         self.failUnlessEqual(expected4[:3],list(m2C.getNodalConnectivityIndex().getValues()));
3109         #idem previous because nodes of cell#4 are not fully present in part3
3110         part3=[1,2]
3111         arrr=DataArrayInt.New();
3112         arrr.setValues(part3,2,1);
3113         f2=f1.buildSubPart(arrr);
3114         self.failUnlessEqual(4,f2.getNumberOfTuples());
3115         self.failUnlessEqual(2,f2.getNumberOfComponents());
3116         for i in xrange(8):
3117             self.assertAlmostEqual(f2.getIJ(0,i),expected5[i],12);
3118             pass
3119         self.failUnlessEqual(2,f2.getMesh().getNumberOfCells());
3120         self.failUnlessEqual(4,f2.getMesh().getNumberOfNodes());
3121         self.failUnlessEqual(2,f2.getMesh().getSpaceDimension());
3122         self.failUnlessEqual(2,f2.getMesh().getMeshDimension());
3123         m2C=f2.getMesh();
3124         self.failUnlessEqual(8,m2C.getMeshLength());
3125         for i in xrange(8):#8 is not an error
3126             self.assertAlmostEqual(expected2[i],m2C.getCoords().getIJ(0,i),12);
3127             pass
3128         self.failUnlessEqual(expected3[:4],list(m2C.getNodalConnectivity().getValues())[4:8]);
3129         self.failUnlessEqual(expected3[4:8],list(m2C.getNodalConnectivity().getValues())[:4]);
3130         self.failUnlessEqual(expected4[:3],list(m2C.getNodalConnectivityIndex().getValues()));
3131         #
3132         part4=[1,2,4]
3133         f2=f1.buildSubPart(part4);
3134         self.failUnlessEqual(6,f2.getNumberOfTuples());
3135         self.failUnlessEqual(2,f2.getNumberOfComponents());
3136         expected6=[4.,104.,5.,105.,7.,107.,8.,108.,10.,110.,11.,111.]
3137         for i in xrange(12):
3138             self.assertAlmostEqual(f2.getIJ(0,i),expected6[i],12);
3139             pass
3140         self.failUnlessEqual(3,f2.getMesh().getNumberOfCells());
3141         self.failUnlessEqual(6,f2.getMesh().getNumberOfNodes());
3142         self.failUnlessEqual(2,f2.getMesh().getSpaceDimension());
3143         self.failUnlessEqual(2,f2.getMesh().getMeshDimension());
3144         m2C=f2.getMesh();
3145         self.failUnlessEqual(13,m2C.getMeshLength());
3146         for i in xrange(12):
3147             self.assertAlmostEqual(expected2[i],m2C.getCoords().getIJ(0,i),12);
3148             pass
3149         self.failUnlessEqual(expected3[0:4],list(m2C.getNodalConnectivity().getValues())[4:8]);
3150         self.failUnlessEqual(expected3[4:8],list(m2C.getNodalConnectivity().getValues())[0:4]);
3151         self.failUnlessEqual(expected3[8:13],list(m2C.getNodalConnectivity().getValues())[8:13]);
3152         self.failUnlessEqual(expected4,list(m2C.getNodalConnectivityIndex().getValues()));
3153         pass
3154
3155     def testDoublyContractedProduct1(self):
3156         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3157         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3158         f1.setMesh(mesh1);
3159         array=DataArrayDouble.New();
3160         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]
3161         array.setValues(arr1,mesh1.getNumberOfCells(),6);
3162         f1.setArray(array);
3163         f1.checkCoherency();
3164         #
3165         f2=f1.doublyContractedProduct();
3166         f2.checkCoherency();
3167         self.assertEqual(1,f2.getNumberOfComponents());
3168         self.assertEqual(5,f2.getNumberOfTuples());
3169         for i in xrange(5):
3170             self.assertAlmostEqual(3906.56,f2.getIJ(i,0),9);
3171             pass
3172         #
3173         pass
3174
3175     def testDeterminant1(self):
3176         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3177         f1=MEDCouplingFieldDouble.New(ON_CELLS,CONST_ON_TIME_INTERVAL);
3178         f1.setTime(2.3,5,6);
3179         f1.setEndTime(3.8,7,3);
3180         f1.setMesh(mesh1);
3181         array=DataArrayDouble.New();
3182         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]
3183         array.setValues(arr1,mesh1.getNumberOfCells(),4);
3184         f1.setArray(array);
3185         #4 components
3186         f1.checkCoherency();
3187         f2=f1.determinant();
3188         f2.checkCoherency();
3189         self.assertEqual(CONST_ON_TIME_INTERVAL,f2.getTimeDiscretization());
3190         self.assertEqual(1,f2.getNumberOfComponents());
3191         self.assertEqual(5,f2.getNumberOfValues());
3192         for i in xrange(5):
3193             self.assertAlmostEqual(-2.42,f2.getIJ(i,0),13);
3194             pass
3195         #6 components multi arrays with end array not defined
3196         f1=MEDCouplingFieldDouble.New(ON_NODES,LINEAR_TIME);
3197         f1.setTime(2.3,5,6);
3198         f1.setEndTime(3.8,7,3);
3199         f1.setMesh(mesh1);
3200         array=DataArrayDouble.New();
3201         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,
3202               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]
3203         array.setValues(arr2,mesh1.getNumberOfNodes(),6);
3204         f1.setArray(array);
3205         self.assertRaises(InterpKernelException,f1.checkCoherency);#no end array specified !
3206         #
3207         f2=f1.determinant();
3208         self.assertEqual(LINEAR_TIME,f2.getTimeDiscretization());
3209         self.assertEqual(1,f2.getArray().getNumberOfComponents());
3210         self.assertEqual(9,f2.getNumberOfTuples());
3211         for i in xrange(9):
3212             self.assertAlmostEqual(137.335,f2.getIJ(i,0),10);
3213             pass
3214         #6 components multi arrays with end array defined
3215         array=DataArrayDouble.New();
3216         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,
3217               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]
3218         array.setValues(arr3,mesh1.getNumberOfNodes(),6);
3219         f1.setEndArray(array);
3220         f1.checkCoherency();
3221         f2=f1.determinant();
3222         f2.checkCoherency();
3223         self.assertEqual(LINEAR_TIME,f2.getTimeDiscretization());
3224         self.assertEqual(1,f2.getNumberOfComponents());
3225         self.assertEqual(9,f2.getNumberOfTuples());
3226         time2,it,order=f2.getTime()
3227         self.assertAlmostEqual(2.3,time2,12);
3228         self.assertEqual(5,it);
3229         self.assertEqual(6,order);
3230         time2,it,order=f2.getEndTime()
3231         self.assertAlmostEqual(3.8,time2,12);
3232         self.assertEqual(7,it);
3233         self.assertEqual(3,order);
3234         for i in xrange(9):
3235             self.assertAlmostEqual(137.335,f2.getIJ(i,0),10);
3236             self.assertAlmostEqual(1289.685,f2.getEndArray().getIJ(i,0),9);
3237             pass
3238         #9 components
3239         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3240         f1.setTime(7.8,10,2);
3241         f1.setMesh(mesh1);
3242         array=DataArrayDouble.New();
3243         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]
3244         array.setValues(arr4,mesh1.getNumberOfCells(),9);
3245         f1.setArray(array);
3246         #
3247         f1.checkCoherency();
3248         f2=f1.determinant();
3249         f2.checkCoherency();
3250         self.assertEqual(ONE_TIME,f2.getTimeDiscretization());
3251         self.assertEqual(1,f2.getNumberOfComponents());
3252         self.assertEqual(5,f2.getNumberOfTuples());
3253         time2,it,order=f2.getTime()
3254         self.assertAlmostEqual(7.8,time2,12);
3255         self.assertEqual(10,it);
3256         self.assertEqual(2,order);
3257         for i in xrange(5):
3258             self.assertAlmostEqual(3.267,f2.getIJ(i,0),13);
3259             pass
3260         pass
3261
3262     def testEigenValues1(self):
3263         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3264         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3265         f1.setMesh(mesh1);
3266         array=DataArrayDouble.New();
3267         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]
3268         array.setValues(arr1,mesh1.getNumberOfCells(),6);
3269         f1.setArray(array);
3270         f1.checkCoherency();
3271         #
3272         f2=f1.eigenValues();
3273         f2.checkCoherency();
3274         self.assertEqual(3,f2.getNumberOfComponents());
3275         self.assertEqual(5,f2.getNumberOfTuples());
3276         expected1=[13.638813677891717,-4.502313844635971,-2.2364998332557486]
3277         for i in xrange(5):
3278             self.assertAlmostEqual(expected1[0],f2.getIJ(i,0),13);
3279             self.assertAlmostEqual(expected1[1],f2.getIJ(i,1),13);
3280             self.assertAlmostEqual(expected1[2],f2.getIJ(i,2),13);
3281             pass
3282         pass
3283
3284     def testEigenVectors1(self):
3285         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3286         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3287         f1.setMesh(mesh1);
3288         array=DataArrayDouble.New();
3289         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]
3290         array.setValues(arr1,mesh1.getNumberOfCells(),6);
3291         f1.setArray(array);
3292         f1.checkCoherency();
3293         #
3294         f2=f1.eigenVectors();
3295         f2.checkCoherency();
3296         self.assertEqual(9,f2.getNumberOfComponents());
3297         self.assertEqual(5,f2.getNumberOfTuples());
3298         expected1=[0.5424262364180696, 0.5351201064614425, 0.6476266283176001,#eigenvect 0
3299                    0.7381111277307373, 0.06458838384003074, -0.6715804522117897,#eigenvect 1
3300                    -0.4012053603397987, 0.8423032781211455, -0.3599436712889738#eigenvect 2
3301                    ]
3302         for i in xrange(5):
3303             self.assertAlmostEqual(expected1[0],f2.getIJ(i,0),13);
3304             self.assertAlmostEqual(expected1[1],f2.getIJ(i,1),13);
3305             self.assertAlmostEqual(expected1[2],f2.getIJ(i,2),13);
3306             self.assertAlmostEqual(expected1[3],f2.getIJ(i,3),13);
3307             self.assertAlmostEqual(expected1[4],f2.getIJ(i,4),13);
3308             self.assertAlmostEqual(expected1[5],f2.getIJ(i,5),13);
3309             self.assertAlmostEqual(expected1[6],f2.getIJ(i,6),13);
3310             self.assertAlmostEqual(expected1[7],f2.getIJ(i,7),13);
3311             self.assertAlmostEqual(expected1[8],f2.getIJ(i,8),13);
3312             pass
3313         #
3314         pass
3315
3316     def testInverse1(self):
3317         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3318         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3319         f1.setMesh(mesh1);
3320         array=DataArrayDouble.New();
3321         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]
3322         array.setValues(arr1,mesh1.getNumberOfCells(),9);
3323         f1.setArray(array);
3324         f1.checkCoherency();
3325         #
3326         f2=f1.inverse();
3327         f2.checkCoherency();
3328         self.assertEqual(9,f2.getNumberOfComponents());
3329         self.assertEqual(5,f2.getNumberOfTuples());
3330         expected1=[-2.6538108356290113, 2.855831037649208, -1.1111111111111067, 3.461891643709813, -4.775022956841121, 2.2222222222222143, -1.1111111111111054, 2.222222222222214, -1.1111111111111072]
3331         for i in xrange(5):
3332             self.assertAlmostEqual(expected1[0],f2.getIJ(i,0),13);
3333             self.assertAlmostEqual(expected1[1],f2.getIJ(i,1),13);
3334             self.assertAlmostEqual(expected1[2],f2.getIJ(i,2),13);
3335             self.assertAlmostEqual(expected1[3],f2.getIJ(i,3),13);
3336             self.assertAlmostEqual(expected1[4],f2.getIJ(i,4),13);
3337             self.assertAlmostEqual(expected1[5],f2.getIJ(i,5),13);
3338             self.assertAlmostEqual(expected1[6],f2.getIJ(i,6),13);
3339             self.assertAlmostEqual(expected1[7],f2.getIJ(i,7),13);
3340             self.assertAlmostEqual(expected1[8],f2.getIJ(i,8),13);
3341             pass
3342         #
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         array.setValues(arr3,mesh1.getNumberOfCells(),6);
3346         f1.setArray(array);
3347         f1.checkCoherency();
3348         #
3349         f2=f1.inverse();
3350         f2.checkCoherency();
3351         self.assertEqual(6,f2.getNumberOfComponents());
3352         self.assertEqual(5,f2.getNumberOfTuples());
3353         expected3=[-0.3617705098531818, -0.8678630828458127, -0.026843764174972983, 0.5539957431465833, 0.13133439560823013, -0.05301294502145887]
3354         for i in xrange(5):
3355             self.assertAlmostEqual(expected3[0],f2.getIJ(i,0),13);
3356             self.assertAlmostEqual(expected3[1],f2.getIJ(i,1),13);
3357             self.assertAlmostEqual(expected3[2],f2.getIJ(i,2),13);
3358             self.assertAlmostEqual(expected3[3],f2.getIJ(i,3),13);
3359             self.assertAlmostEqual(expected3[4],f2.getIJ(i,4),13);
3360             self.assertAlmostEqual(expected3[5],f2.getIJ(i,5),13);
3361             pass
3362         #
3363         array=DataArrayDouble.New();
3364         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]
3365         array.setValues(arr2,mesh1.getNumberOfCells(),4);
3366         f1.setArray(array);
3367         f1.checkCoherency();
3368         #
3369         f2=f1.inverse();
3370         f2.checkCoherency();
3371         self.assertEqual(4,f2.getNumberOfComponents());
3372         self.assertEqual(5,f2.getNumberOfTuples());
3373         expected2=[-1.8595041322314059, 0.9504132231404963, 1.404958677685951, -0.49586776859504156]
3374         for i in xrange(5):
3375             self.assertAlmostEqual(expected2[0],f2.getIJ(i,0),13);
3376             self.assertAlmostEqual(expected2[1],f2.getIJ(i,1),13);
3377             self.assertAlmostEqual(expected2[2],f2.getIJ(i,2),13);
3378             self.assertAlmostEqual(expected2[3],f2.getIJ(i,3),13);
3379             pass
3380         #
3381         pass
3382
3383     def testTrace1(self):
3384         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3385         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3386         f1.setMesh(mesh1);
3387         array=DataArrayDouble.New();
3388         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]
3389         array.setValues(arr1,mesh1.getNumberOfCells(),9);
3390         f1.setArray(array);
3391         f1.checkCoherency();
3392         #
3393         f2=f1.trace();
3394         f2.checkCoherency();
3395         self.assertEqual(1,f2.getNumberOfComponents());
3396         self.assertEqual(5,f2.getNumberOfTuples());
3397         for i in xrange(5):
3398             self.assertAlmostEqual(15.9,f2.getIJ(i,0),13);
3399             pass
3400         #
3401         array=DataArrayDouble.New();
3402         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]
3403         array.setValues(arr3,mesh1.getNumberOfCells(),6);
3404         f1.setArray(array);
3405         f1.checkCoherency();
3406         #
3407         f2=f1.trace();
3408         f2.checkCoherency();
3409         self.assertEqual(1,f2.getNumberOfComponents());
3410         self.assertEqual(5,f2.getNumberOfTuples());
3411         for i in xrange(5):
3412             self.assertAlmostEqual(25.8,f2.getIJ(i,0),13);
3413             pass
3414         #
3415         array=DataArrayDouble.New();
3416         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]
3417         array.setValues(arr2,mesh1.getNumberOfCells(),4);
3418         f1.setArray(array);
3419         f1.checkCoherency();
3420         #
3421         f2=f1.trace();
3422         f2.checkCoherency();
3423         self.assertEqual(1,f2.getNumberOfComponents());
3424         self.assertEqual(5,f2.getNumberOfTuples());
3425         for i in xrange(5):
3426             self.assertAlmostEqual(5.7,f2.getIJ(i,0),13);
3427             pass
3428         #
3429         pass
3430
3431     def testDeviator1(self):
3432         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3433         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3434         f1.setMesh(mesh1);
3435         array=DataArrayDouble.New();
3436         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]
3437         array.setValues(arr1,mesh1.getNumberOfCells(),6);
3438         f1.setArray(array);
3439         f1.checkCoherency();
3440         #
3441         f2=f1.deviator();
3442         f2.checkCoherency();
3443         self.assertEqual(6,f2.getNumberOfComponents());
3444         self.assertEqual(5,f2.getNumberOfTuples());
3445         expected1=[-1.1,0.,1.1,4.5,5.6,6.7]
3446         for i in xrange(5):
3447             self.assertAlmostEqual(expected1[0],f2.getIJ(i,0),13);
3448             self.assertAlmostEqual(expected1[1],f2.getIJ(i,1),13);
3449             self.assertAlmostEqual(expected1[2],f2.getIJ(i,2),13);
3450             self.assertAlmostEqual(expected1[3],f2.getIJ(i,3),13);
3451             self.assertAlmostEqual(expected1[4],f2.getIJ(i,4),13);
3452             self.assertAlmostEqual(expected1[5],f2.getIJ(i,5),13);
3453             pass
3454         #
3455         pass
3456
3457     def testMagnitude1(self):
3458         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3459         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3460         f1.setMesh(mesh1);
3461         array=DataArrayDouble.New();
3462         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]
3463         array.setValues(arr1,mesh1.getNumberOfCells(),5);
3464         f1.setArray(array);
3465         f1.checkCoherency();
3466         #
3467         f2=f1.magnitude();
3468         f2.checkCoherency();
3469         self.assertEqual(1,f2.getNumberOfComponents());
3470         self.assertEqual(5,f2.getNumberOfTuples());
3471         for i in xrange(5):
3472             self.assertAlmostEqual(8.3606219864313918,f2.getIJ(i,0),13);
3473             pass
3474         #
3475         pass
3476
3477     def testMaxPerTuple1(self):
3478         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3479         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3480         f1.setMesh(mesh1);
3481         array=DataArrayDouble.New();
3482         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]
3483         array.setValues(arr1,mesh1.getNumberOfCells(),5);
3484         f1.setArray(array);
3485         f1.checkCoherency();
3486         #
3487         f2=f1.maxPerTuple();
3488         f2.checkCoherency();
3489         self.assertEqual(1,f2.getNumberOfComponents());
3490         self.assertEqual(5,f2.getNumberOfTuples());
3491         for i in xrange(5):
3492             self.assertAlmostEqual(5.6,f2.getIJ(i,0),13);
3493             pass
3494         #
3495         pass
3496
3497     def testChangeNbOfComponents(self):
3498         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3499         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3500         f1.setMesh(mesh1);
3501         array=DataArrayDouble.New();
3502         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]
3503         array.setValues(arr1,mesh1.getNumberOfCells(),5);
3504         f1.setArray(array);
3505         f1.checkCoherency();
3506         #
3507         f1.changeNbOfComponents(3,7.77);
3508         f1.checkCoherency();
3509         self.assertEqual(3,f1.getNumberOfComponents());
3510         self.assertEqual(5,f1.getNumberOfTuples());
3511         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]
3512         for i in xrange(15):
3513             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),13);
3514             pass
3515         f1.changeNbOfComponents(4,7.77);
3516         f1.checkCoherency();
3517         self.assertEqual(4,f1.getNumberOfComponents());
3518         self.assertEqual(5,f1.getNumberOfTuples());
3519         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]
3520         for i in xrange(20):
3521             self.assertAlmostEqual(expected2[i],f1.getIJ(0,i),13);
3522             pass
3523         #
3524         pass
3525
3526     def testSortPerTuple1(self):
3527         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3528         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3529         f1.setMesh(mesh1);
3530         array=DataArrayDouble.New();
3531         arr1=[1.2,2.3,3.4,4.5,5.6, 1.2,3.4,4.5,5.6,2.3, 3.4,4.5,5.6,1.2,2.3, 5.6,1.2,2.3,3.4,4.5, 4.5,5.6,1.2,2.3,3.4]
3532         array.setValues(arr1,mesh1.getNumberOfCells(),5);
3533         f1.setArray(array);
3534         f1.checkCoherency();
3535         #
3536         f1.sortPerTuple(True);
3537         f1.checkCoherency();
3538         self.assertEqual(5,f1.getNumberOfComponents());
3539         self.assertEqual(5,f1.getNumberOfTuples());
3540         for i in xrange(5):
3541             self.assertAlmostEqual(arr1[0],f1.getIJ(i,0),13);
3542             self.assertAlmostEqual(arr1[1],f1.getIJ(i,1),13);
3543             self.assertAlmostEqual(arr1[2],f1.getIJ(i,2),13);
3544             self.assertAlmostEqual(arr1[3],f1.getIJ(i,3),13);
3545             self.assertAlmostEqual(arr1[4],f1.getIJ(i,4),13);
3546             pass
3547         #
3548         f1.sortPerTuple(False);
3549         f1.checkCoherency();
3550         self.assertEqual(5,f1.getNumberOfComponents());
3551         self.assertEqual(5,f1.getNumberOfTuples());
3552         for i in xrange(5):
3553             self.assertAlmostEqual(arr1[4],f1.getIJ(i,0),13);
3554             self.assertAlmostEqual(arr1[3],f1.getIJ(i,1),13);
3555             self.assertAlmostEqual(arr1[2],f1.getIJ(i,2),13);
3556             self.assertAlmostEqual(arr1[1],f1.getIJ(i,3),13);
3557             self.assertAlmostEqual(arr1[0],f1.getIJ(i,4),13);
3558             pass
3559         #
3560         pass
3561
3562     def testIsEqualWithoutConsideringStr1(self):
3563         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3564         mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
3565         #
3566         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3567         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3568         mesh2.setName("rr");
3569         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
3570         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3571         da1,da2=mesh1.checkGeoEquivalWith(mesh2,2,1e-12);
3572         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12);
3573         mesh2.setName("");
3574         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3575         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3576         mesh2.getCoords().setInfoOnComponent(0,"tty");
3577         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
3578         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3579         mesh2.getCoords().setInfoOnComponent(0,"");
3580         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3581         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3582         mesh2.getCoords().setInfoOnComponent(1,"tty");
3583         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
3584         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3585         mesh2.getCoords().setInfoOnComponent(1,"");
3586         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3587         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3588         tmp=mesh2.getCoords().getIJ(0,3);
3589         mesh2.getCoords().setIJ(0,3,9999.);
3590         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
3591         self.assertTrue(not mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3592         mesh2.getCoords().setIJ(0,3,tmp);
3593         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3594         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3595         tmp2=mesh2.getNodalConnectivity().getIJ(0,4);
3596         mesh2.getNodalConnectivity().setIJ(0,4,0);
3597         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
3598         self.assertTrue(not mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3599         mesh2.getNodalConnectivity().setIJ(0,4,tmp2);
3600         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3601         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3602         #
3603         f1=mesh1.getMeasureField(True);
3604         f2=mesh2.getMeasureField(True);
3605         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
3606         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3607         f2.setName("ftest");
3608         self.assertTrue(not f1.isEqual(f2,1e-12,1e-12));
3609         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3610         f1.setName("ftest");
3611         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
3612         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3613         #
3614         f2.getArray().setInfoOnComponent(0,"eee");
3615         self.assertTrue(not f1.isEqual(f2,1e-12,1e-12));
3616         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3617         f2.getArray().setInfoOnComponent(0,"");
3618         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
3619         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3620         #
3621         f2.getArray().setIJ(1,0,0.123);
3622         self.assertTrue(not f1.isEqual(f2,1e-12,1e-12));
3623         self.assertTrue(not f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3624         f2.getArray().setIJ(1,0,0.125);
3625         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
3626         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3627         #
3628         pass
3629
3630     def testGetNodeIdsOfCell1(self):
3631         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3632         li=mesh1.getNodeIdsOfCell(1)
3633         expected1=[1, 4, 2]
3634         self.assertEqual(expected1,list(li))
3635         li=mesh1.getCoordinatesOfNode(4)
3636         self.assertEqual(2,len(li))
3637         self.assertAlmostEqual(0.2,li[0],13);
3638         self.assertAlmostEqual(0.2,li[1],13);
3639         li=mesh1.getCoords().getValuesAsTuple()
3640         self.assertEqual(9,len(li))
3641         li2=mesh1.getNodalConnectivityIndex().getValuesAsTuple()
3642         self.assertEqual(6,len(li2))
3643         pass
3644
3645     def testGetEdgeRatioField1(self):
3646         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
3647         f1=m1.getEdgeRatioField();
3648         self.assertEqual(m1.getNumberOfCells(),f1.getNumberOfTuples());
3649         self.assertEqual(5,f1.getNumberOfTuples());
3650         self.assertEqual(1,f1.getNumberOfComponents());
3651         expected1=[1.,1.4142135623730951, 1.4142135623730951,1.,1.]
3652         for i in xrange(5):
3653             self.assertAlmostEqual(expected1[i],f1.getIJ(i,0),14);
3654             pass
3655         #
3656         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
3657         f1=m1.getEdgeRatioField();
3658         self.assertEqual(m1.getNumberOfCells(),f1.getNumberOfTuples());
3659         self.assertEqual(5,f1.getNumberOfTuples());
3660         self.assertEqual(1,f1.getNumberOfComponents());
3661         expected2=[1.4142135623730951, 1.7320508075688772, 1.7320508075688772, 1.4142135623730951, 1.4142135623730951]
3662         for i in xrange(5):
3663             self.assertAlmostEqual(expected2[i],f1.getIJ(i,0),14);
3664             pass
3665         pass
3666
3667     def testFillFromAnalytic3(self):
3668         m=MEDCouplingDataForTest.build2DTargetMesh_1()
3669         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME)
3670         self.assertRaises(InterpKernelException,f1.fillFromAnalytic,1,"y+x");
3671         f1.setMesh(m)
3672         f1.setName("myField");
3673         f1.fillFromAnalytic(1,"y+x");
3674         f1.checkCoherency();
3675         self.assertEqual(f1.getName(),"myField");
3676         self.assertEqual(f1.getTypeOfField(),ON_CELLS);
3677         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
3678         self.assertEqual(1,f1.getNumberOfComponents());
3679         self.assertEqual(5,f1.getNumberOfTuples());
3680         values1=[-0.1,0.23333333333333336,0.56666666666666665,0.4,0.9]
3681         tmp=f1.getArray().getValues();
3682         self.assertEqual(len(values1),len(tmp))
3683         for i in xrange(len(values1)):
3684             self.assertTrue(abs(values1[i]-tmp[i])<1.e-12);
3685             pass
3686         #
3687         f1=MEDCouplingFieldDouble.New(ON_NODES,CONST_ON_TIME_INTERVAL)
3688         f1.setMesh(m)
3689         f1.fillFromAnalytic(1,"y+2*x");
3690         f1.setEndTime(1.2,3,4);
3691         f1.checkCoherency();
3692         self.assertEqual(f1.getTypeOfField(),ON_NODES);
3693         self.assertEqual(f1.getTimeDiscretization(),CONST_ON_TIME_INTERVAL);
3694         self.assertEqual(1,f1.getNumberOfComponents());
3695         self.assertEqual(9,f1.getNumberOfTuples());
3696         values2=[-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1]
3697         tmp=f1.getArray().getValues();
3698         self.assertEqual(len(values2),len(tmp))
3699         for i in xrange(len(values2)):
3700             self.assertTrue(abs(values2[i]-tmp[i])<1.e-12);
3701             pass
3702         f1=MEDCouplingFieldDouble.New(ON_NODES,LINEAR_TIME);
3703         f1.setMesh(m)
3704         f1.fillFromAnalytic(1,"2.*x+y");
3705         f1.setEndTime(1.2,3,4);
3706         f1.checkCoherency();
3707         self.assertEqual(f1.getTypeOfField(),ON_NODES);
3708         self.assertEqual(f1.getTimeDiscretization(),LINEAR_TIME);
3709         self.assertEqual(1,f1.getNumberOfComponents());
3710         self.assertEqual(9,f1.getNumberOfTuples());
3711         tmp=f1.getArray().getValues();
3712         values2Bis=[-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1]
3713         self.assertEqual(len(values2Bis),len(tmp))
3714         for i in xrange(len(values2Bis)):
3715             self.assertTrue(abs(values2Bis[i]-tmp[i])<1.e-12);
3716             pass
3717         tmp=f1.getEndArray().getValues();
3718         self.assertEqual(len(values2Bis),len(tmp))
3719         for i in xrange(len(values2Bis)):
3720             self.assertTrue(abs(values2Bis[i]-tmp[i])<1.e-12);
3721             pass
3722         #
3723         f1=MEDCouplingFieldDouble.New(ON_NODES,ONE_TIME);
3724         f1.setMesh(m)
3725         f1.fillFromAnalytic(2,"(x+y)*IVec+2*(x+y)*JVec");
3726         f1.checkCoherency();
3727         self.assertEqual(f1.getTypeOfField(),ON_NODES);
3728         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
3729         self.assertEqual(2,f1.getNumberOfComponents());
3730         self.assertEqual(9,f1.getNumberOfTuples());
3731         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]
3732         tmp=f1.getArray().getValues();
3733         self.assertEqual(len(values3),len(tmp))
3734         for i in xrange(len(values3)):
3735             self.assertTrue(abs(values3[i]-tmp[i])<1.e-12);
3736             pass
3737         values4=f1.accumulate();
3738         self.assertTrue(abs(3.6-values4[0])<1.e-12);
3739         self.assertTrue(abs(7.2-values4[1])<1.e-12);
3740         values4=f1.integral(True);
3741         self.assertTrue(abs(0.5-values4[0])<1.e-12);
3742         self.assertTrue(abs(1.-values4[1])<1.e-12);
3743         #
3744         f1=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
3745         f1.setMesh(m);
3746         self.assertRaises(InterpKernelException,f1.fillFromAnalytic,1,"1./(x-0.2)");
3747         pass
3748
3749     def testFieldDoubleOpEqual1(self):
3750         m=MEDCouplingDataForTest.build2DTargetMesh_1();
3751         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3752         self.assertRaises(InterpKernelException,f1.assign,0.07);
3753         f1.setMesh(m);
3754         f1.assign(0.07);
3755         f1.checkCoherency();
3756         self.assertEqual(1,f1.getNumberOfComponents());
3757         self.assertEqual(5,f1.getNumberOfTuples());
3758         for i in xrange(5):
3759             self.assertAlmostEqual(0.07,f1.getIJ(i,0),16);
3760             pass
3761         f1.assign(0.09);
3762         f1.checkCoherency();
3763         self.assertEqual(1,f1.getNumberOfComponents());
3764         self.assertEqual(5,f1.getNumberOfTuples());
3765         for i in xrange(5):
3766             self.assertAlmostEqual(0.09,f1.getIJ(i,0),16);
3767             pass
3768         #
3769         f1=MEDCouplingFieldDouble.New(ON_NODES,LINEAR_TIME);
3770         f1.setEndTime(4.5,2,3);
3771         f1.setMesh(m);
3772         f1.assign(0.08);
3773         f1.checkCoherency();
3774         self.assertEqual(1,f1.getNumberOfComponents());
3775         self.assertEqual(9,f1.getNumberOfTuples());
3776         for i in xrange(9):
3777             self.assertAlmostEqual(0.08,f1.getIJ(i,0),16);
3778             pass
3779         self.assertEqual(1,f1.getEndArray().getNumberOfComponents());
3780         self.assertEqual(9,f1.getEndArray().getNumberOfTuples());
3781         for i in xrange(9):
3782             self.assertAlmostEqual(0.08,f1.getEndArray().getIJ(i,0),16);
3783             pass
3784         pass
3785
3786     def testAreaBary3D2(self):
3787         coordsForHexa8=[-75.45749305371, 180.95495078401, 39.515472018008,
3788                         -9.755591679144, 23.394927935279, 5.108794294848,
3789                         14.337630157832, 61.705351002702, 160.42422501908,
3790                         -27.273893776752, 167.567731083961, 192.830034145464,
3791                         99.857193154796,264.499264735586,-8.287335493412,
3792                         144.939882761126,156.38626563134,-31.896173894226,
3793                         161.34096835726,182.4654895809,73.832387065572,
3794                         132.680430393685,255.37973247196,96.15235602819];
3795         volHexa8=3258520.29637466;
3796         baryHexa8=[43.925705821778, 155.31893955289, 65.874418109644]
3797
3798         coordsForPenta6=[-68.199829618726,178.938498373416,62.608505919588,
3799                          8.461744647847,76.653979804423,165.00018874933,
3800                          -27.273893776752,167.567731083961,192.830034145464,
3801                          106.586501038965,262.629609408327,13.124533008813,
3802                          155.465082847275,197.414118382622,78.408350795821,
3803                          132.680430393685,255.37973247196,96.15235602819];
3804         volPenta6=944849.868507338;
3805         baryPenta6=[39.631002313543,182.692711783428,106.98540473964]
3806
3807         coordsForPyra5=[132.680430393685,255.37973247196,96.15235602819,
3808                         -27.273893776752,167.567731083961,192.830034145464,
3809                         8.461744647847,76.653979804423,165.00018874933,
3810                         155.465082847275,197.414118382622,78.408350795821,
3811                         -68.199829618726,178.938498373416,62.608505919588];
3812         volPyra5=756943.92980254;
3813         baryPyra5=[29.204294116618,172.540129749156,118.01035951483]
3814         mesh=MEDCouplingUMesh.New("Bary3D2",3);
3815         coo=DataArrayDouble.New();
3816         tmp=coordsForHexa8+coordsForPenta6+coordsForPyra5
3817         coo.setValues(tmp,19,3);
3818         mesh.setCoords(coo);
3819         #
3820         tmpConn=[0,1,2,3,4,5,6,7]
3821         mesh.allocateCells(3);
3822         self.assertRaises(InterpKernelException,mesh.insertNextCell,NORM_HEXA8,9,tmpConn[0:8])
3823         mesh.insertNextCell(NORM_HEXA8,tmpConn[0:8])
3824         mesh.insertNextCell(NORM_PENTA6,6,[i+8 for i in tmpConn])
3825         mesh.insertNextCell(NORM_PYRA5,5,[i+14 for i in tmpConn])
3826         mesh.finishInsertingCells();
3827         mesh.checkCoherency();
3828         mesh.mergeNodes(1e-7)
3829         self.assertEqual(12,mesh.getNumberOfNodes());
3830         vols=mesh.getMeasureField(True);
3831         self.assertEqual(3,vols.getNumberOfTuples());
3832         self.assertEqual(1,vols.getNumberOfComponents());
3833         self.assertAlmostEqual(volHexa8,vols.getIJ(0,0),6);
3834         self.assertAlmostEqual(volPenta6,vols.getIJ(1,0),7);
3835         self.assertAlmostEqual(volPyra5,vols.getIJ(2,0),7);
3836         bary=mesh.getBarycenterAndOwner();
3837         self.assertEqual(3,bary.getNumberOfTuples());
3838         self.assertEqual(3,bary.getNumberOfComponents());
3839         self.assertAlmostEqual(baryHexa8[0],bary.getIJ(0,0),11);
3840         self.assertAlmostEqual(baryHexa8[1],bary.getIJ(0,1),11);
3841         self.assertAlmostEqual(baryHexa8[2],bary.getIJ(0,2),11);
3842         self.assertAlmostEqual(baryPenta6[0],bary.getIJ(1,0),11);
3843         self.assertAlmostEqual(baryPenta6[1],bary.getIJ(1,1),11);
3844         self.assertAlmostEqual(baryPenta6[2],bary.getIJ(1,2),11);
3845         self.assertAlmostEqual(baryPyra5[0],bary.getIJ(2,0),11);
3846         self.assertAlmostEqual(baryPyra5[1],bary.getIJ(2,1),11);
3847         self.assertAlmostEqual(baryPyra5[2],bary.getIJ(2,2),11);
3848         pass
3849
3850     def testGetMeasureFieldCMesh1(self):
3851         m=MEDCouplingCMesh.New();
3852         da=DataArrayDouble.New();
3853         discX=[2.3,3.4,5.8,10.2]
3854         discY=[12.3,23.4,45.8]
3855         discZ=[-0.7,1.2,1.25,2.13,2.67]
3856         da.setValues(discX,4,1);
3857         m.setCoordsAt(0,da);
3858         m.checkCoherency();
3859         self.assertEqual(4,m.getNumberOfNodes());
3860         self.assertEqual(3,m.getNumberOfCells());
3861         self.assertEqual(1,m.getSpaceDimension());
3862         f=m.getMeasureField(True);
3863         self.assertEqual(3,f.getNumberOfTuples());
3864         self.assertEqual(1,f.getNumberOfComponents());
3865         expected1=[1.1,2.4,4.4]
3866         for i in xrange(3):
3867             self.assertAlmostEqual(expected1[i],f.getIJ(i,0),12);
3868             pass
3869         coords=m.getCoordinatesAndOwner();
3870         self.assertEqual(4,coords.getNumberOfTuples());
3871         self.assertEqual(1,coords.getNumberOfComponents());
3872         for i in xrange(4):
3873             self.assertAlmostEqual(discX[i],coords.getIJ(i,0),12);
3874             pass
3875         coords=m.getBarycenterAndOwner();
3876         self.assertEqual(3,coords.getNumberOfTuples());
3877         self.assertEqual(1,coords.getNumberOfComponents());
3878         expected1_3=[2.85,4.6,8.]
3879         for i in xrange(3):
3880             self.assertAlmostEqual(expected1_3[i],coords.getIJ(i,0),12);
3881             pass
3882         #
3883         da=DataArrayDouble.New();
3884         da.setValues(discY,3,1);
3885         m.setCoordsAt(1,da);
3886         m.checkCoherency();
3887         self.assertEqual(12,m.getNumberOfNodes());
3888         self.assertEqual(6,m.getNumberOfCells());
3889         self.assertEqual(2,m.getSpaceDimension());
3890         f=m.getMeasureField(True);
3891         self.assertEqual(6,f.getNumberOfTuples());
3892         self.assertEqual(1,f.getNumberOfComponents());
3893         expected2=[12.21,26.64,48.84,24.64,53.76,98.56]
3894         for i in xrange(6):
3895             self.assertAlmostEqual(expected2[i],f.getIJ(i,0),12);
3896             pass
3897         coords=m.getCoordinatesAndOwner();
3898         self.assertEqual(12,coords.getNumberOfTuples());
3899         self.assertEqual(2,coords.getNumberOfComponents());
3900         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]
3901         for i in xrange(24):
3902             self.assertAlmostEqual(expected2_2[i],coords.getIJ(0,i),12);
3903             pass
3904         coords=m.getBarycenterAndOwner();
3905         self.assertEqual(6,coords.getNumberOfTuples());
3906         self.assertEqual(2,coords.getNumberOfComponents());
3907         expected2_3=[2.85,17.85,4.6,17.85,8.,17.85, 2.85,34.6,4.6,34.6,8.,34.6]
3908         for i in xrange(12):
3909             self.assertAlmostEqual(expected2_3[i],coords.getIJ(0,i),12);
3910             pass
3911         #
3912         da=DataArrayDouble.New();
3913         da.setValues(discZ,5,1);
3914         m.setCoordsAt(2,da);
3915         m.checkCoherency();
3916         self.assertEqual(60,m.getNumberOfNodes());
3917         self.assertEqual(24,m.getNumberOfCells());
3918         self.assertEqual(3,m.getSpaceDimension());
3919         f=m.getMeasureField(True);
3920         self.assertEqual(24,f.getNumberOfTuples());
3921         self.assertEqual(1,f.getNumberOfComponents());
3922         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]
3923         for i in xrange(24):
3924             self.assertAlmostEqual(expected3[i],f.getIJ(i,0),12);
3925             pass
3926         coords=m.getCoordinatesAndOwner();
3927         self.assertEqual(60,coords.getNumberOfTuples());
3928         self.assertEqual(3,coords.getNumberOfComponents());
3929         expected3_2=[
3930             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,
3931             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,
3932             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,
3933             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,
3934             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];
3935         for i in xrange(180):
3936             self.assertAlmostEqual(expected3_2[i],coords.getIJ(0,i),12);
3937             pass
3938         coords=m.getBarycenterAndOwner();
3939         self.assertEqual(24,coords.getNumberOfTuples());
3940         self.assertEqual(3,coords.getNumberOfComponents());
3941         expected3_3=[
3942             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,
3943             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,
3944             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,
3945             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];
3946         for i in xrange(72):
3947             self.assertAlmostEqual(expected3_3[i],coords.getIJ(0,i),12);
3948             pass
3949         pass
3950
3951     def testFieldDoubleZipCoords1(self):
3952         m=MEDCouplingDataForTest.build2DTargetMeshMergeNode_1();
3953         f=m.fillFromAnalytic(ON_NODES,2,"x*2.");
3954         f.getArray().setInfoOnComponent(0,"titi");
3955         f.getArray().setInfoOnComponent(1,"tutu");
3956         f.checkCoherency();
3957         self.assertEqual(18,f.getNumberOfTuples());
3958         self.assertEqual(2,f.getNumberOfComponents());
3959         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]
3960         for i in xrange(36):
3961             self.assertAlmostEqual(expected1[i],f.getIJ(0,i),12);
3962             pass
3963         self.assertTrue(f.zipCoords());
3964         f.checkCoherency();
3965         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]
3966         for i in xrange(30):
3967             self.assertAlmostEqual(expected2[i],f.getIJ(0,i),12);
3968             pass
3969         self.assertTrue(not f.zipCoords());
3970         f.checkCoherency();
3971         for i in xrange(30):
3972             self.assertAlmostEqual(expected2[i],f.getIJ(0,i),12);
3973             pass
3974         self.assertTrue(f.getArray().getInfoOnComponent(0)=="titi");
3975         self.assertTrue(f.getArray().getInfoOnComponent(1)=="tutu");
3976         pass
3977
3978     def testFieldDoubleZipConnectivity1(self):
3979         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
3980         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
3981         cells1=[2,3,4]
3982         m3_1=m2.buildPartOfMySelf(cells1,True);
3983         m3=m3_1;
3984         m4=MEDCouplingDataForTest.build2DSourceMesh_1();
3985         m5=MEDCouplingUMesh.MergeUMeshes(m1,m3);
3986         m6=MEDCouplingUMesh.MergeUMeshes(m5,m4);
3987         #
3988         self.assertEqual(10,m6.getNumberOfCells());
3989         self.assertEqual(22,m6.getNumberOfNodes());
3990         arr,areNodesMerged,newNbOfNodes=m6.mergeNodes(1e-13);
3991         self.assertEqual(9,m6.getNumberOfNodes());
3992         f=m6.fillFromAnalytic(ON_CELLS,2,"x");
3993         f2=m6.fillFromAnalytic(ON_NODES,2,"x");
3994         self.assertEqual(10,f.getNumberOfTuples());
3995         self.assertEqual(2,f.getNumberOfComponents());
3996         expected1=[-0.05, -0.05, 0.3666666666666667, 0.3666666666666667, 0.53333333333333321, 0.53333333333333321,
3997                    -0.05, -0.05, 0.45, 0.45, 0.53333333333333321, 0.53333333333333321, -0.05, -0.05, 0.45, 0.45,
3998                    0.36666666666666659, 0.36666666666666659, 0.033333333333333326, 0.033333333333333326];
3999         for i in xrange(20):
4000             self.assertAlmostEqual(expected1[i],f.getIJ(0,i),12);
4001             pass
4002         f.getArray().setInfoOnComponent(0,"titi");
4003         f.getArray().setInfoOnComponent(1,"tutu");
4004         f.checkCoherency();
4005         self.assertTrue(f.zipConnectivity(0));
4006         expected2=[-0.05, -0.05, 0.3666666666666667, 0.3666666666666667, 0.53333333333333321, 0.53333333333333321,
4007                    -0.05, -0.05, 0.45, 0.45, 0.36666666666666659, 0.36666666666666659, 0.033333333333333326, 0.033333333333333326];
4008         self.assertEqual(7,f.getNumberOfTuples());
4009         self.assertEqual(2,f.getNumberOfComponents());
4010         for i in xrange(14):
4011             self.assertAlmostEqual(expected2[i],f.getIJ(0,i),12);
4012             pass
4013         self.assertTrue(f.getArray().getInfoOnComponent(0)=="titi");
4014         self.assertTrue(f.getArray().getInfoOnComponent(1)=="tutu");
4015         self.assertTrue(not f.zipConnectivity(0));
4016         #
4017         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,
4018                    -0.3, -0.3, 0.2, 0.2, 0.7, 0.7];
4019         self.assertEqual(9,f2.getNumberOfTuples());
4020         self.assertEqual(2,f2.getNumberOfComponents());
4021         for i in xrange(18):
4022             self.assertAlmostEqual(expected3[i],f2.getIJ(0,i),12);
4023             pass
4024         self.assertTrue(f2.zipConnectivity(0));
4025         self.assertEqual(9,f2.getNumberOfTuples());
4026         self.assertEqual(2,f2.getNumberOfComponents());
4027         for i in xrange(18):
4028             self.assertAlmostEqual(expected3[i],f2.getIJ(0,i),12);
4029             pass
4030         pass
4031
4032     def testDaDoubleRenumber1(self):
4033         a=DataArrayDouble.New();
4034         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]
4035         a.setValues(arr1,7,2);
4036         a.setInfoOnComponent(0,"toto");
4037         a.setInfoOnComponent(1,"tata");
4038         #
4039         arr2=[3,1,0,6,5,4,2]
4040         b=a.renumber(arr2);
4041         self.assertEqual(7,b.getNumberOfTuples());
4042         self.assertEqual(2,b.getNumberOfComponents());
4043         self.assertTrue(b.getInfoOnComponent(0)=="toto");
4044         self.assertTrue(b.getInfoOnComponent(1)=="tata");
4045         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]
4046         for i in xrange(14):
4047             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
4048             pass
4049         #
4050         c=DataArrayInt.New();
4051         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4052         c.setValues(arr3,7,2);
4053         c.setInfoOnComponent(0,"toto");
4054         c.setInfoOnComponent(1,"tata");
4055         d=c.renumber(arr2);
4056         self.assertEqual(7,d.getNumberOfTuples());
4057         self.assertEqual(2,d.getNumberOfComponents());
4058         self.assertTrue(d.getInfoOnComponent(0)=="toto");
4059         self.assertTrue(d.getInfoOnComponent(1)=="tata");
4060         expected2=[3, 13, 2, 12, 7, 17, 1, 11, 6, 16, 5, 15, 4, 14]
4061         for i in xrange(14):
4062             self.assertEqual(expected2[i],d.getIJ(0,i));
4063             pass
4064         pass
4065
4066     def testDaDoubleRenumberAndReduce1(self):
4067         a=DataArrayDouble.New();
4068         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]
4069         a.setValues(arr1,7,2);
4070         a.setInfoOnComponent(0,"toto");
4071         a.setInfoOnComponent(1,"tata");
4072         #
4073         arr2=[2,-1,1,-1,0,4,3]
4074         b=a.renumberAndReduce(arr2,5);
4075         self.assertEqual(5,b.getNumberOfTuples());
4076         self.assertEqual(2,b.getNumberOfComponents());
4077         self.assertTrue(b.getInfoOnComponent(0)=="toto");
4078         self.assertTrue(b.getInfoOnComponent(1)=="tata");
4079         expected1=[5.1,15.1,3.1,13.1,1.1,11.1,7.1,17.1,6.1,16.1]
4080         for i in xrange(10):
4081             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
4082             pass
4083         #
4084         c=DataArrayInt.New();
4085         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4086         c.setValues(arr3,7,2);
4087         c.setInfoOnComponent(0,"toto");
4088         c.setInfoOnComponent(1,"tata");
4089         d=c.renumberAndReduce(arr2,5);
4090         self.assertEqual(5,d.getNumberOfTuples());
4091         self.assertEqual(2,d.getNumberOfComponents());
4092         self.assertTrue(d.getInfoOnComponent(0)=="toto");
4093         self.assertTrue(d.getInfoOnComponent(1)=="tata");
4094         expected2=[5,15,3,13,1,11,7,17,6,16]
4095         for i in xrange(10):
4096             self.assertEqual(expected2[i],d.getIJ(0,i));
4097             pass
4098         pass
4099
4100     def testDaDoubleRenumberInPlace1(self):
4101         a=DataArrayDouble.New();
4102         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]
4103         a.setValues(arr1,7,2);
4104         #
4105         arr2=[3,1,0,6,5,4,2]
4106         a.renumberInPlace(arr2);
4107         self.assertEqual(7,a.getNumberOfTuples());
4108         self.assertEqual(2,a.getNumberOfComponents());
4109         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]
4110         for i in xrange(14):
4111             self.assertAlmostEqual(expected1[i],a.getIJ(0,i),14);
4112             pass
4113         #
4114         c=DataArrayInt.New();
4115         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4116         c.setValues(arr3,7,2);
4117         c.renumberInPlace(arr2);
4118         self.assertEqual(7,c.getNumberOfTuples());
4119         self.assertEqual(2,c.getNumberOfComponents());
4120         expected2=[3, 13, 2, 12, 7, 17, 1, 11, 6, 16, 5, 15, 4, 14]
4121         for i in xrange(14):
4122             self.assertEqual(expected2[i],c.getIJ(0,i));
4123             pass
4124         pass
4125
4126     def testDaDoubleRenumberR1(self):
4127         a=DataArrayDouble.New();
4128         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]
4129         a.setValues(arr1,7,2);
4130         a.setInfoOnComponent(0,"toto");
4131         a.setInfoOnComponent(1,"tata");
4132         #
4133         arr2=[3,1,0,6,5,4,2]
4134         b=a.renumberR(arr2);
4135         self.assertEqual(7,b.getNumberOfTuples());
4136         self.assertEqual(2,b.getNumberOfComponents());
4137         self.assertTrue(b.getInfoOnComponent(0)=="toto");
4138         self.assertTrue(b.getInfoOnComponent(1)=="tata");
4139         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]
4140         for i in xrange(14):
4141             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
4142             pass
4143         #
4144         c=DataArrayInt.New();
4145         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4146         c.setValues(arr3,7,2);
4147         c.setInfoOnComponent(0,"toto");
4148         c.setInfoOnComponent(1,"tata");
4149         d=c.renumberR(arr2);
4150         self.assertEqual(7,d.getNumberOfTuples());
4151         self.assertEqual(2,d.getNumberOfComponents());
4152         self.assertTrue(d.getInfoOnComponent(0)=="toto");
4153         self.assertTrue(d.getInfoOnComponent(1)=="tata");
4154         expected2=[4, 14, 2, 12, 1, 11, 7, 17, 6, 16, 5, 15, 3, 13]
4155         for i in xrange(14):
4156             self.assertEqual(expected2[i],d.getIJ(0,i));
4157             pass
4158         pass
4159
4160     def testDaDoubleRenumberInPlaceR1(self):
4161         a=DataArrayDouble.New();
4162         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]
4163         a.setValues(arr1,7,2);
4164         #
4165         arr2=[3,1,0,6,5,4,2]
4166         a.renumberInPlaceR(arr2);
4167         self.assertEqual(7,a.getNumberOfTuples());
4168         self.assertEqual(2,a.getNumberOfComponents());
4169         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]
4170         for i in xrange(14):
4171             self.assertAlmostEqual(expected1[i],a.getIJ(0,i),14);
4172             pass
4173         #
4174         c=DataArrayInt.New();
4175         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4176         c.setValues(arr3,7,2);
4177         c.renumberInPlaceR(arr2);
4178         self.assertEqual(7,c.getNumberOfTuples());
4179         self.assertEqual(2,c.getNumberOfComponents());
4180         expected2=[4, 14, 2, 12, 1, 11, 7, 17, 6, 16, 5, 15, 3, 13]
4181         for i in xrange(14):
4182             self.assertEqual(expected2[i],c.getIJ(0,i));
4183             pass
4184         pass
4185
4186     def testDaDoubleSelectByTupleId1(self):
4187         a=DataArrayDouble.New();
4188         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]
4189         a.setValues(arr1,7,2);
4190         a.setInfoOnComponent(0,"toto");
4191         a.setInfoOnComponent(1,"tata");
4192         #
4193         arr2=[4,2,0,6,5]
4194         b=a.selectByTupleId(arr2);
4195         self.assertEqual(5,b.getNumberOfTuples());
4196         self.assertEqual(2,b.getNumberOfComponents());
4197         self.assertTrue(b.getInfoOnComponent(0)=="toto");
4198         self.assertTrue(b.getInfoOnComponent(1)=="tata");
4199         expected1=[5.1,15.1,3.1,13.1,1.1,11.1,7.1,17.1,6.1,16.1]
4200         for i in xrange(10):
4201             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
4202             pass
4203         #
4204         c=DataArrayInt.New();
4205         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4206         c.setValues(arr3,7,2);
4207         c.setInfoOnComponent(0,"toto");
4208         c.setInfoOnComponent(1,"tata");
4209         d=c.selectByTupleId(arr2);
4210         self.assertEqual(5,d.getNumberOfTuples());
4211         self.assertEqual(2,d.getNumberOfComponents());
4212         self.assertTrue(d.getInfoOnComponent(0)=="toto");
4213         self.assertTrue(d.getInfoOnComponent(1)=="tata");
4214         expected2=[5,15,3,13,1,11,7,17,6,16]
4215         for i in xrange(10):
4216             self.assertEqual(expected2[i],d.getIJ(0,i));
4217             pass
4218         pass
4219
4220     def testDaDoubleGetMinMaxValues1(self):
4221         a=DataArrayDouble.New();
4222         arr1=[2.34,4.56,-6.77,4.55,4.56,2.24,2.34,1.02,4.56]
4223         a.setValues(arr1,9,1);
4224         m,where=a.getMaxValue();
4225         self.assertEqual(1,where);
4226         self.assertAlmostEqual(4.56,m,12);
4227         m,ws=a.getMaxValue2();
4228         self.assertAlmostEqual(4.56,m,12);
4229         self.assertEqual(3,ws.getNumberOfTuples());
4230         self.assertEqual(1,ws.getNumberOfComponents());
4231         expected1=[1,4,8]
4232         for i in xrange(3):
4233             self.assertEqual(expected1[i],ws.getIJ(i,0));
4234             pass
4235         a=DataArrayDouble.New();
4236         arr2=[-2.34,-4.56,6.77,-4.55,-4.56,-2.24,-2.34,-1.02,-4.56]
4237         a.setValues(arr2,9,1);
4238         m,where=a.getMinValue();
4239         self.assertEqual(1,where);
4240         self.assertAlmostEqual(-4.56,m,12);
4241         m,ws=a.getMinValue2();
4242         self.assertAlmostEqual(-4.56,m,12);
4243         self.assertEqual(3,ws.getNumberOfTuples());
4244         self.assertEqual(1,ws.getNumberOfComponents());
4245         for i in xrange(3):
4246             self.assertEqual(expected1[i],ws.getIJ(i,0));
4247             pass
4248         pass
4249
4250     def testFieldDoubleGetMinMaxValues2(self):
4251         m2,m1=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
4252         self.assertEqual(18,m2.getNumberOfCells());
4253         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]
4254         f=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
4255         a=DataArrayDouble.New();
4256         a.setValues(arr1,18,1);
4257         f.setArray(a);
4258         f.setMesh(m2);
4259         #
4260         f.checkCoherency();
4261         m=f.getMaxValue();
4262         self.assertAlmostEqual(8.71,m,12);
4263         m,ws=f.getMaxValue2();
4264         self.assertAlmostEqual(8.71,m,12);
4265         self.assertEqual(4,ws.getNumberOfTuples());
4266         self.assertEqual(1,ws.getNumberOfComponents());
4267         expected1=[0,3,7,17]
4268         for i in xrange(4):
4269             self.assertEqual(expected1[i],ws.getIJ(i,0));
4270             pass
4271         #
4272         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]
4273         a.setValues(arr2,18,1);
4274         f.checkCoherency();
4275         m=f.getMinValue();
4276         self.assertAlmostEqual(-8.71,m,12);
4277         m,ws=f.getMinValue2();
4278         self.assertAlmostEqual(-8.71,m,12);
4279         self.assertEqual(4,ws.getNumberOfTuples());
4280         self.assertEqual(1,ws.getNumberOfComponents());
4281         for i in xrange(4):
4282             self.assertEqual(expected1[i],ws.getIJ(i,0));
4283             pass
4284         pass
4285
4286     def testBuildUnstructuredCMesh1(self):
4287         m=MEDCouplingCMesh.New();
4288         da=DataArrayDouble.New();
4289         discX=[2.3,3.4,5.8,10.2]
4290         discY=[12.3,23.4,45.8]
4291         discZ=[-0.7,1.2,1.25,2.13,2.67]
4292         da.setValues(discX,4,1);
4293         m.setCoordsAt(0,da);
4294         m.checkCoherency();
4295         self.assertEqual(0,m.getCellContainingPoint([2.4],1e-12));
4296         self.assertEqual(1,m.getCellContainingPoint([3.7],1e-12));
4297         self.assertEqual(2,m.getCellContainingPoint([5.9],1e-12));
4298         self.assertEqual(-1,m.getCellContainingPoint([10.3],1e-12));
4299         self.assertEqual(-1,m.getCellContainingPoint([1.3],1e-12));
4300         #
4301         m2=m.buildUnstructured();
4302         m2.checkCoherency();
4303         f1=m.getMeasureField(False);
4304         f2=m2.getMeasureField(False);
4305         self.assertTrue(isinstance(f1.getMesh(),MEDCouplingCMesh))
4306         self.assertEqual(f1.getNumberOfTuples(),3);
4307         self.assertEqual(f2.getNumberOfTuples(),3);
4308         self.assertEqual(1,m2.getMeshDimension());
4309         self.assertEqual(1,m2.getSpaceDimension());
4310         for i in xrange(3):
4311             self.assertAlmostEqual(f1.getIJ(i,0),f2.getIJ(i,0),10);
4312             pass
4313         da=DataArrayDouble.New();
4314         da.setValues(discY,3,1);
4315         m.setCoordsAt(1,da);
4316         #
4317         m2=m.buildUnstructured();
4318         m2.checkCoherency();
4319         f1=m.getMeasureField(False);
4320         f2=m2.getMeasureField(False);
4321         self.assertEqual(f1.getNumberOfTuples(),6);
4322         self.assertEqual(f2.getNumberOfTuples(),6);
4323         self.assertEqual(2,m2.getMeshDimension());
4324         self.assertEqual(2,m2.getSpaceDimension());
4325         for i in xrange(6):
4326             self.assertAlmostEqual(f1.getIJ(i,0),f2.getIJ(i,0),10);
4327             pass
4328         #
4329         da=DataArrayDouble.New();
4330         da.setValues(discZ,5,1);
4331         m.setCoordsAt(2,da);
4332         m2=m.buildUnstructured();
4333         m2.checkCoherency();
4334         f1=m.getMeasureField(False);
4335         f2=m2.getMeasureField(False);
4336         self.assertEqual(f1.getNumberOfTuples(),24);
4337         self.assertEqual(f2.getNumberOfTuples(),24);
4338         self.assertEqual(3,m2.getMeshDimension());
4339         self.assertEqual(3,m2.getSpaceDimension());
4340         for i in xrange(24):
4341             self.assertAlmostEqual(f1.getIJ(i,0),f2.getIJ(i,0),10);
4342             pass
4343         #
4344         pos1=[5.,30.,2.]
4345         self.assertEqual(16,m.getCellContainingPoint(pos1,1e-12));
4346         #
4347         elems=m2.getCellsInBoundingBox([3.5,6.,12.2,25.,0.,1.5],1e-7)
4348         self.assertEqual([1, 2, 4, 5, 7, 8, 10, 11, 13, 14, 16, 17],elems.getValues())
4349         #
4350         pt=[2.4,12.7,-3.4]
4351         m.scale(pt,3.7);
4352         m3=m.buildUnstructured();
4353         m2.scale(pt,3.7);
4354         self.assertTrue(m3.isEqual(m2,1e-12));
4355         pass
4356
4357     def testDataArrayIntInvertO2NNO21(self):
4358         arr1=[2,0,4,1,5,3]
4359         da=DataArrayInt.New();
4360         da.setValues(arr1,6,1);
4361         da2=da.invertArrayO2N2N2O(6);
4362         self.assertEqual(6,da2.getNumberOfTuples());
4363         self.assertEqual(1,da2.getNumberOfComponents());
4364         expected1=[1,3,0,5,2,4]
4365         for i in xrange(6):
4366             self.assertEqual(expected1[i],da2.getIJ(i,0));
4367             pass
4368         da3=da2.invertArrayN2O2O2N(6);
4369         for i in xrange(6):
4370             self.assertEqual(arr1[i],da3.getIJ(i,0));
4371             pass
4372         #
4373         arr2=[3,-1,5,4,-1,0,-1,1,2,-1]
4374         da=DataArrayInt.New();
4375         da.setValues(arr2,10,1);
4376         da2=da.invertArrayO2N2N2O(6);
4377         self.assertEqual(6,da2.getNumberOfTuples());
4378         self.assertEqual(1,da2.getNumberOfComponents());
4379         expected2=[5,7,8,0,3,2]
4380         for i in xrange(6):
4381             self.assertEqual(expected2[i],da2.getIJ(i,0));
4382             pass
4383         da3=da2.invertArrayN2O2O2N(10);
4384         for i in xrange(10):
4385             self.assertEqual(arr2[i],da3.getIJ(i,0));
4386             pass
4387         pass
4388
4389     def testKeepSetSelectedComponent1(self):
4390         arr1=[1.,2.,3.,4., 11.,12.,13.,14., 21.,22.,23.,24., 31.,32.,33.,34., 41.,42.,43.,44.]
4391         a1=DataArrayDouble.New();
4392         a1.setValues(arr1,5,4);
4393         expp=[21.,22.,23.,24.]
4394         self.assertEqual(4,len(a1.getTuple(2)));
4395         for i in xrange(4):
4396             self.assertAlmostEqual(expp[i],a1.getTuple(2)[i],12)
4397             pass
4398         a1.setInfoOnComponent(0,"aaaa");
4399         a1.setInfoOnComponent(1,"bbbb");
4400         a1.setInfoOnComponent(2,"cccc");
4401         a1.setInfoOnComponent(3,"dddd");
4402         arr2V=[1,2,1,2,0,0]
4403         a2=a1.keepSelectedComponents(arr2V);
4404         self.assertEqual(6,a2.getNumberOfComponents());
4405         self.assertEqual(5,a2.getNumberOfTuples());
4406         self.assertTrue(a2.getInfoOnComponent(0)=="bbbb");
4407         self.assertTrue(a2.getInfoOnComponent(1)=="cccc");
4408         self.assertTrue(a2.getInfoOnComponent(2)=="bbbb");
4409         self.assertTrue(a2.getInfoOnComponent(3)=="cccc");
4410         self.assertTrue(a2.getInfoOnComponent(4)=="aaaa");
4411         self.assertTrue(a2.getInfoOnComponent(5)=="aaaa");
4412         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.]
4413         for i in xrange(30):
4414             self.assertAlmostEqual(expected1[i],a2.getIJ(0,i),14);
4415             pass
4416         a3=a1.convertToIntArr();
4417         self.assertEqual([21,22,23,24],a3.getTuple(2))
4418         a4=a3.keepSelectedComponents(arr2V);
4419         self.assertEqual(6,a4.getNumberOfComponents());
4420         self.assertEqual(5,a4.getNumberOfTuples());
4421         self.assertTrue(a4.getInfoOnComponent(0)=="bbbb");
4422         self.assertTrue(a4.getInfoOnComponent(1)=="cccc");
4423         self.assertTrue(a4.getInfoOnComponent(2)=="bbbb");
4424         self.assertTrue(a4.getInfoOnComponent(3)=="cccc");
4425         self.assertTrue(a4.getInfoOnComponent(4)=="aaaa");
4426         self.assertTrue(a4.getInfoOnComponent(5)=="aaaa");
4427         for i in xrange(30):
4428             self.assertEqual(int(expected1[i]),a4.getIJ(0,i));
4429             pass
4430         # setSelectedComponents
4431         arr3V=[3,2]
4432         a5=a1.keepSelectedComponents(arr3V);
4433         a5.setInfoOnComponent(0,"eeee");
4434         a5.setInfoOnComponent(1,"ffff");
4435         arr4V=[1,2]
4436         a2.setSelectedComponents(a5,arr4V);
4437         self.assertEqual(6,a2.getNumberOfComponents());
4438         self.assertEqual(5,a2.getNumberOfTuples());
4439         self.assertTrue(a2.getInfoOnComponent(0)=="bbbb");
4440         self.assertTrue(a2.getInfoOnComponent(1)=="eeee");
4441         self.assertTrue(a2.getInfoOnComponent(2)=="ffff");
4442         self.assertTrue(a2.getInfoOnComponent(3)=="cccc");
4443         self.assertTrue(a2.getInfoOnComponent(4)=="aaaa");
4444         self.assertTrue(a2.getInfoOnComponent(5)=="aaaa");
4445         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.]
4446         for i in xrange(30):
4447             self.assertAlmostEqual(expected2[i],a2.getIJ(0,i),14);
4448             pass
4449         a6=a5.convertToIntArr();
4450         a6.setInfoOnComponent(0,"eeee");
4451         a6.setInfoOnComponent(1,"ffff");
4452         a4.setSelectedComponents(a6,arr4V);
4453         self.assertEqual(6,a4.getNumberOfComponents());
4454         self.assertEqual(5,a4.getNumberOfTuples());
4455         self.assertTrue(a4.getInfoOnComponent(0)=="bbbb");
4456         self.assertTrue(a4.getInfoOnComponent(1)=="eeee");
4457         self.assertTrue(a4.getInfoOnComponent(2)=="ffff");
4458         self.assertTrue(a4.getInfoOnComponent(3)=="cccc");
4459         self.assertTrue(a4.getInfoOnComponent(4)=="aaaa");
4460         self.assertTrue(a4.getInfoOnComponent(5)=="aaaa");
4461         for i in xrange(30):
4462             self.assertEqual(int(expected2[i]),a4.getIJ(0,i));
4463             pass
4464         # test of throw
4465         arr5V=[2,3,6]
4466         arr6V=[2,7,5]
4467         arr7V=[2,1,4,6]
4468         self.assertRaises(InterpKernelException,a2.keepSelectedComponents,arr5V);
4469         self.assertRaises(InterpKernelException,a2.keepSelectedComponents,arr6V);
4470         self.assertRaises(InterpKernelException,a2.setSelectedComponents,a1,arr7V);
4471         arr7V=arr7V[0:3]
4472         self.assertRaises(InterpKernelException,a2.setSelectedComponents,a1,arr7V);
4473         #
4474         pass
4475
4476     def testKeepSetSelectedComponent2(self):
4477         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
4478         arr1=[1.,2.,3.,4., 11.,12.,13.,14., 21.,22.,23.,24., 31.,32.,33.,34., 41.,42.,43.,44.]
4479         a1=DataArrayDouble.New();
4480         a1.setValues(arr1,5,4);
4481         a1.setInfoOnComponent(0,"aaaa");
4482         a1.setInfoOnComponent(1,"bbbb");
4483         a1.setInfoOnComponent(2,"cccc");
4484         a1.setInfoOnComponent(3,"dddd");
4485         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
4486         f1.setTime(2.3,4,5);
4487         f1.setMesh(m1);
4488         f1.setName("f1");
4489         f1.setArray(a1);
4490         f1.checkCoherency();
4491         #
4492         arr2V=[1,2,1,2,0,0]
4493         f2=f1.keepSelectedComponents(arr2V);
4494         self.assertTrue(f2.getTimeDiscretization()==ONE_TIME);
4495         t,dt,it=f2.getTime()
4496         self.assertAlmostEqual(2.3,t,13);
4497         self.assertEqual(4,dt);
4498         self.assertEqual(5,it);
4499         f2.checkCoherency();
4500         self.assertEqual(6,f2.getNumberOfComponents());
4501         self.assertEqual(5,f2.getNumberOfTuples());
4502         self.assertTrue(f2.getArray().getInfoOnComponent(0)=="bbbb");
4503         self.assertTrue(f2.getArray().getInfoOnComponent(1)=="cccc");
4504         self.assertTrue(f2.getArray().getInfoOnComponent(2)=="bbbb");
4505         self.assertTrue(f2.getArray().getInfoOnComponent(3)=="cccc");
4506         self.assertTrue(f2.getArray().getInfoOnComponent(4)=="aaaa");
4507         self.assertTrue(f2.getArray().getInfoOnComponent(5)=="aaaa");
4508         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.]
4509         for i in xrange(30):
4510             self.assertAlmostEqual(expected1[i],f2.getIJ(0,i),14);
4511             pass
4512         #setSelectedComponents
4513         arr3V=[3,2]
4514         f5=f1.keepSelectedComponents(arr3V);
4515         f5.setTime(6.7,8,9);
4516         f5.getArray().setInfoOnComponent(0,"eeee");
4517         f5.getArray().setInfoOnComponent(1,"ffff");
4518         f5.checkCoherency();
4519         arr4V=[1,2]
4520         f2.setSelectedComponents(f5,arr4V);
4521         self.assertEqual(6,f2.getNumberOfComponents());
4522         self.assertEqual(5,f2.getNumberOfTuples());
4523         f2.checkCoherency();
4524         t,dt,it=f2.getTime()
4525         self.assertAlmostEqual(2.3,t,13);
4526         self.assertEqual(4,dt);
4527         self.assertEqual(5,it);
4528         self.assertTrue(f2.getArray().getInfoOnComponent(0)=="bbbb");
4529         self.assertTrue(f2.getArray().getInfoOnComponent(1)=="eeee");
4530         self.assertTrue(f2.getArray().getInfoOnComponent(2)=="ffff");
4531         self.assertTrue(f2.getArray().getInfoOnComponent(3)=="cccc");
4532         self.assertTrue(f2.getArray().getInfoOnComponent(4)=="aaaa");
4533         self.assertTrue(f2.getArray().getInfoOnComponent(5)=="aaaa");
4534         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.]
4535         for i in xrange(30):
4536             self.assertAlmostEqual(expected2[i],f2.getIJ(0,i),14);
4537             pass
4538         #
4539         pass
4540
4541     def testElementaryDAThrowAndSpecialCases(self):
4542         da=DataArrayInt.New();
4543         self.assertRaises(InterpKernelException, da.checkAllocated);
4544         self.assertRaises(InterpKernelException, da.fillWithValue, 1);
4545         self.assertRaises(InterpKernelException, da.iota, 1);
4546         da.alloc(7,1);
4547         da.fillWithValue(11); #11,11,11,11...
4548         da.iota(10); #10,11,12,13...
4549
4550         db=DataArrayInt.New();
4551         db.alloc(7,2);
4552
4553         dbl2=DataArrayDouble.New();
4554         dbl2.alloc(7,2);
4555         self.assertRaises(InterpKernelException, dbl2.isUniform, 10., 1e-15);
4556         self.assertRaises(InterpKernelException, dbl2.sort);
4557         self.assertRaises(InterpKernelException, dbl2.reverse);
4558         self.assertRaises(InterpKernelException, dbl2.iota, 10.);
4559
4560         dbl=DataArrayDouble.New();
4561         #DataArrayDouble not allocated yet
4562         self.assertRaises(InterpKernelException, dbl.iota, 10.);
4563         self.assertRaises(InterpKernelException, dbl.isUniform, 10., 1e-15);
4564         self.assertRaises(InterpKernelException, dbl.sort);
4565         self.assertRaises(InterpKernelException, dbl.reverse);
4566         self.assertRaises(InterpKernelException, dbl.fromNoInterlace);
4567         self.assertRaises(InterpKernelException, dbl.toNoInterlace);
4568
4569         dbl.alloc(7,1);
4570         dbl.iota(10.);
4571         self.assertTrue(not dbl.isUniform(10.,1e-15));
4572         dbl.sort();
4573         self.assertTrue(dbl.isMonotonic(True, .99));
4574         self.assertTrue(dbl.isMonotonic(True, -.99));
4575         self.assertTrue(not dbl.isMonotonic(True, 1.1));
4576         self.assertTrue(not dbl.isMonotonic(True, -1.1));
4577         dbl.reverse();
4578         self.assertTrue(dbl.isMonotonic(False, .99));
4579         self.assertTrue(not dbl.isMonotonic(False, 1.1));
4580         self.assertTrue(not dbl.isMonotonic(False, -1.1));
4581
4582         dc=DataArrayInt.New();
4583         dc.alloc(14,1);
4584
4585         dd=DataArrayDouble.New();
4586         self.assertRaises(InterpKernelException, dd.checkAllocated);
4587         self.assertRaises(InterpKernelException, dd.fillWithValue, 1.);
4588         self.assertRaises(InterpKernelException, dd.iota, 1.);
4589         self.assertTrue(not ((dd.repr().find("No data"))==-1));
4590
4591         dd.alloc(0,1); #Allocated but nbOfElements==0!
4592         self.assertTrue(not ((dd.repr().find("Number of tuples : 0"))==-1));
4593         self.assertTrue(not ((dd.repr().find("Empty Data"))==-1));
4594         dd.fillWithValue(11); #?!...ok
4595         dd.iota(10); #?!...ok
4596         self.assertTrue(dd.isMonotonic(True, 1.));  #nothing is monotonic
4597         self.assertTrue(dd.isMonotonic(False, 1.));
4598
4599         self.assertRaises(InterpKernelException, db.copyStringInfoFrom, da);
4600         self.assertRaises(InterpKernelException, db.copyStringInfoFrom, da);
4601         cIds=[2,2]
4602         self.assertRaises(InterpKernelException, da.copyPartOfStringInfoFrom, db, cIds);
4603         cIds[0]=1;
4604         cIds[0]=-1;
4605         self.assertRaises(InterpKernelException, da.copyPartOfStringInfoFrom, db, cIds);
4606
4607         info=["infoOfOneComponent"]*2;
4608         self.assertRaises(InterpKernelException, da.setInfoOnComponents, info);
4609         self.assertRaises(InterpKernelException, da.setInfoOnComponent, 1, info[0]);
4610         db.setInfoOnComponents(info);
4611
4612         self.assertRaises(InterpKernelException, da.getInfoOnComponent, -1);
4613         self.assertRaises(InterpKernelException, da.getInfoOnComponent, 2);
4614         self.assertTrue(db.getInfoOnComponent(1)==db.getInfoOnComponent(0));
4615         self.assertRaises(InterpKernelException, db.getVarOnComponent, -1);
4616         self.assertRaises(InterpKernelException, db.getVarOnComponent, 2);
4617         self.assertRaises(InterpKernelException, db.getUnitOnComponent, -1);
4618         self.assertRaises(InterpKernelException, db.getUnitOnComponent, 2);
4619
4620         self.assertTrue(da.GetVarNameFromInfo("varname unit ")=="varname unit ");
4621         self.assertTrue(da.GetVarNameFromInfo("varname]unit[")=="varname]unit[");
4622         self.assertTrue(da.GetVarNameFromInfo("[unit]")=="");
4623         self.assertTrue(da.GetVarNameFromInfo("varname [unit]")=="varname");
4624
4625         self.assertTrue(da.GetUnitFromInfo("varname unit ")=="");
4626         self.assertTrue(da.GetUnitFromInfo("varname]unit[")=="");
4627         self.assertTrue(da.GetUnitFromInfo("[unit]")=="unit");
4628         self.assertTrue(da.GetUnitFromInfo("varname [unit]")=="unit");
4629
4630         self.assertRaises(InterpKernelException, da.checkNbOfTuplesAndComp, db, "theMessageInThrow");
4631         self.assertRaises(InterpKernelException, da.checkNbOfTuplesAndComp, dc, "theMessageInThrow");
4632         self.assertRaises(InterpKernelException, db.checkNbOfTuplesAndComp, dc, "theMessageInThrow");
4633
4634         self.assertRaises(InterpKernelException, da.checkNbOfTuplesAndComp, 7, 2, "theMessageInThrow");
4635         da.checkNbOfTuplesAndComp(7,1,"theMessageInThrow");
4636
4637         self.assertRaises(InterpKernelException, db.checkNbOfElems, 7*2+1, "theMessageInThrow");
4638         db.checkNbOfElems(7*2,"theMessageInThrow");
4639
4640         self.assertRaises(InterpKernelException, db.GetNumberOfItemGivenBES, 10, 9, 1, "theMessageInThrow");
4641         self.assertRaises(InterpKernelException, db.GetNumberOfItemGivenBES, 0, 1, -1, "theMessageInThrow");
4642         self.assertEqual(10,db.GetNumberOfItemGivenBES(0,10,1,"theMessageInThrow"));
4643         self.assertEqual(5,db.GetNumberOfItemGivenBES(0,10,2,"theMessageInThrow"));
4644         self.assertEqual(6,db.GetNumberOfItemGivenBES(0,11,2,"theMessageInThrow"));
4645
4646         self.assertTrue(not ((da.repr().find("Number of components : 1"))==-1));
4647         self.assertTrue(not ((dd.repr().find("Number of components : 1"))==-1));
4648         self.assertTrue(not ((dbl.repr().find("Number of components : 1"))==-1));
4649
4650         self.assertTrue(not ((da.reprZip().find("Number of components : 1"))==-1));
4651         self.assertTrue(not ((dd.reprZip().find("Number of components : 1"))==-1));
4652         self.assertTrue(not ((dbl.reprZip().find("Number of components : 1"))==-1));
4653
4654         self.assertRaises(InterpKernelException, dbl.selectByTupleId2, 0, 1, -1);
4655         self.assertRaises(InterpKernelException, dbl.substr, -1, 1);
4656         self.assertRaises(InterpKernelException, dbl.substr, 8, 1);
4657         self.assertRaises(InterpKernelException, dbl.substr, 0, 8);
4658         self.assertRaises(InterpKernelException, dbl.meldWith, dd);
4659
4660         self.assertRaises(InterpKernelException, dbl.setPartOfValuesAdv, dbl2, da); #dbl dbl2 not have the same number of components
4661         self.assertRaises(InterpKernelException, dbl.setPartOfValuesAdv, dd, da);  #da tuple selector DataArrayInt instance not have exactly 2 components
4662
4663         dbl3=DataArrayDouble.New();
4664         dbl3.alloc(6,2);
4665         dbl3.fillWithValue(11.);
4666         #bad number of components
4667         self.assertRaises(InterpKernelException, dbl3.getMaxValue);
4668         self.assertRaises(InterpKernelException, dd.getMaxValue);
4669         self.assertRaises(InterpKernelException, dbl3.getMinValue);
4670         self.assertRaises(InterpKernelException, dd.getMinValue);
4671         self.assertRaises(InterpKernelException, dbl3.getAverageValue);
4672         self.assertRaises(InterpKernelException, dd.getAverageValue);
4673         self.assertRaises(InterpKernelException, dd.accumulate, 100);
4674         self.assertRaises(InterpKernelException, dbl.fromPolarToCart);
4675         self.assertRaises(InterpKernelException, dbl3.fromCylToCart);
4676         self.assertRaises(InterpKernelException, dbl3.fromSpherToCart);
4677         self.assertRaises(InterpKernelException, dbl3.doublyContractedProduct);
4678         self.assertRaises(InterpKernelException, dbl3.determinant);
4679         self.assertRaises(InterpKernelException, dbl3.eigenValues);
4680         self.assertRaises(InterpKernelException, dbl3.eigenVectors);
4681         self.assertRaises(InterpKernelException, dbl3.inverse);
4682         self.assertRaises(InterpKernelException, dbl3.trace);
4683         self.assertRaises(InterpKernelException, dbl3.deviator);
4684
4685         dbl3.setIJ(5,1,12.);
4686         self.assertTrue(dbl3.getMaxValueInArray()==12.);
4687         self.assertTrue(dbl3.getMinValueInArray()==11.);
4688
4689         db.fillWithValue(100); #bad Ids
4690         self.assertRaises(InterpKernelException, dbl3.setPartOfValuesAdv, dbl2, db);
4691         db.fillWithValue(-1); #bad Ids
4692         self.assertRaises(InterpKernelException, dbl3.setPartOfValuesAdv, dbl2, db);
4693         db.fillWithValue(6); #bad Ids for dbl3
4694         self.assertRaises(InterpKernelException, dbl3.setPartOfValuesAdv, dbl2, db);
4695
4696         dbl3.checkNoNullValues();
4697         dbl3.setIJ(5,0,0.);
4698         self.assertRaises(InterpKernelException, dbl3.checkNoNullValues);
4699         self.assertRaises(InterpKernelException, dbl3.applyInv, 1.);  #div by zero
4700         self.assertRaises(InterpKernelException, dbl2.getIdsInRange, 1., 2.);
4701         a=[]
4702         self.assertRaises(InterpKernelException, DataArrayDouble_Aggregate, a);
4703         self.assertRaises(InterpKernelException, DataArrayDouble_Meld, a);
4704
4705         a=[dbl2,dbl]; #Nb of components mismatch
4706         self.assertRaises(InterpKernelException, DataArrayDouble_Aggregate, a);
4707
4708         self.assertRaises(InterpKernelException, DataArrayDouble_Dot, dbl2, dbl);
4709
4710         self.assertRaises(InterpKernelException, DataArrayDouble_CrossProduct, dbl2, dbl); #Nb of components mismatch
4711         self.assertRaises(InterpKernelException, DataArrayDouble_CrossProduct, dbl2, dbl2); #Nb of components must be equal to 3
4712         dbl4=DataArrayDouble.New();
4713         dbl4.alloc(6,3);
4714         dbl5=DataArrayDouble.New();
4715         dbl5.alloc(7,3);
4716         self.assertRaises(InterpKernelException, DataArrayDouble_CrossProduct, dbl4, dbl5); #Nb of tuples mismatch
4717
4718         a[0]=dbl4; #Nb of tuple mismatch
4719         a[1]=dbl5; #Nb of tuple mismatch
4720         self.assertRaises(InterpKernelException, DataArrayDouble_Meld, a);
4721         self.assertRaises(InterpKernelException, DataArrayDouble_Dot, dbl4, dbl5);
4722         pass
4723
4724     def testDAIGetIdsEqual1(self):
4725         tab1=[5,-2,-4,-2,3,2,-2];
4726         da=DataArrayInt.New();
4727         da.setValues(tab1,7,1);
4728         da2=da.getIdsEqual(-2);
4729         self.assertEqual(3,da2.getNumberOfTuples());
4730         self.assertEqual(1,da2.getNumberOfComponents());
4731         expected1=[1,3,6];
4732         self.assertEqual(expected1,da2.getValues());
4733         pass
4734
4735     def testDAIGetIdsEqualList1(self):
4736         tab1=[5,-2,-4,-2,3,2,-2];
4737         da=DataArrayInt.New();
4738         da.setValues(tab1,7,1);
4739         da2=da.getIdsEqualList([3,-2,0]);
4740         self.assertEqual(4,da2.getNumberOfTuples());
4741         self.assertEqual(1,da2.getNumberOfComponents());
4742         expected1=[1,3,4,6];
4743         self.assertEqual(expected1,da2.getValues());
4744         pass
4745
4746     def testDAFromNoInterlace1(self):
4747         tab1=[1,11,21,31,41,2,12,22,32,42,3,13,23,33,43]
4748         da=DataArrayInt.New();
4749         da.setValues(tab1,5,3);
4750         da2=da.fromNoInterlace();
4751         expected1=[1,2,3,11,12,13,21,22,23,31,32,33,41,42,43]
4752         self.assertEqual(5,da2.getNumberOfTuples());
4753         self.assertEqual(3,da2.getNumberOfComponents());# it's not a bug. Avoid to have 1 million components !
4754         self.assertEqual(expected1,da2.getValues());
4755         da3=da.convertToDblArr();
4756         da4=da3.fromNoInterlace();
4757         self.assertEqual(5,da4.getNumberOfTuples());
4758         self.assertEqual(3,da4.getNumberOfComponents());# it's not a bug. Avoid to have 1 million components !
4759         for i in xrange(15):
4760             self.assertAlmostEqual(expected1[i],da4.getIJ(0,i),14);
4761             pass
4762         pass
4763
4764     def testDAToNoInterlace1(self):
4765         tab1=[1,2,3,11,12,13,21,22,23,31,32,33,41,42,43]
4766         da=DataArrayInt.New();
4767         da.setValues(tab1,5,3);
4768         da2=da.toNoInterlace();
4769         expected1=[1,11,21,31,41,2,12,22,32,42,3,13,23,33,43]
4770         self.assertEqual(5,da2.getNumberOfTuples());
4771         self.assertEqual(3,da2.getNumberOfComponents());# it's not a bug. Avoid to have 1 million components !
4772         self.assertEqual(expected1,da2.getValues());
4773         da3=da.convertToDblArr();
4774         da4=da3.toNoInterlace();
4775         self.assertEqual(5,da4.getNumberOfTuples());
4776         self.assertEqual(3,da4.getNumberOfComponents());# it's not a bug. Avoid to have 1 million components !
4777         for i in xrange(15):
4778             self.assertAlmostEqual(expected1[i],da4.getIJ(0,i),14);
4779             pass
4780         pass
4781
4782     def testDAIsUniform1(self):
4783         tab1=[1,1,1,1,1]
4784         da=DataArrayInt.New();
4785         da.setValues(tab1,5,1);
4786         self.assertTrue(da.isUniform(1));
4787         da.setIJ(2,0,2);
4788         self.assertTrue(not da.isUniform(1));
4789         da.setIJ(2,0,1);
4790         self.assertTrue(da.isUniform(1));
4791         da2=da.convertToDblArr();
4792         self.assertTrue(da2.isUniform(1.,1.e-12));
4793         da2.setIJ(1,0,1.+1.e-13);
4794         self.assertTrue(da2.isUniform(1.,1.e-12));
4795         da2.setIJ(1,0,1.+1.e-11);
4796         self.assertTrue(not da2.isUniform(1.,1.e-12));
4797         pass
4798
4799     def testDADFromPolarToCart1(self):
4800         tab1=[2.,0.2,2.5,0.7]
4801         da=DataArrayDouble.New();
4802         da.setValues(tab1,2,2);
4803         da2=da.fromPolarToCart();
4804         expected1=[1.9601331556824833,0.39733866159012243, 1.9121054682112213,1.6105442180942275]
4805         for i in xrange(4):
4806             self.assertAlmostEqual(expected1[i],da2.getIJ(0,i),13);
4807             pass
4808         pass
4809
4810     def testDADFromCylToCart1(self):
4811         tab1=[2.,0.2,4.,2.5,0.7,9.]
4812         da=DataArrayDouble.New();
4813         da.setValues(tab1,2,3);
4814         da2=da.fromCylToCart();
4815         expected1=[1.9601331556824833,0.39733866159012243,4., 1.9121054682112213,1.6105442180942275,9.]
4816         for i in xrange(6):
4817             self.assertAlmostEqual(expected1[i],da2.getIJ(0,i),13);
4818             pass
4819         pass
4820
4821     def testDADFromSpherToCart1(self):
4822         tab1=[2.,0.2,0.3,2.5,0.7,0.8]
4823         da=DataArrayDouble.New();
4824         da.setValues(tab1,2,3);
4825         da2=da.fromSpherToCart();
4826         expected1=[0.37959212195737485,0.11742160338765303,1.9601331556824833, 1.1220769624465328,1.1553337045129035,1.9121054682112213]
4827         for i in xrange(6):
4828             self.assertAlmostEqual(expected1[i],da2.getIJ(0,i),13);
4829             pass
4830         pass
4831
4832     def testUnPolyze1(self):
4833         elts=[0,1,2,3,4,5,6,7]
4834         eltsV=elts;
4835         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
4836         mesh.convertToPolyTypes(eltsV);
4837         mesh.unPolyze();
4838         mesh2=MEDCouplingDataForTest.build3DTargetMesh_1();
4839         mesh.checkCoherency();
4840         self.assertTrue(mesh.isEqual(mesh2,1e-12));
4841         mesh.convertToPolyTypes(eltsV);
4842         self.assertTrue(not mesh.isEqual(mesh2,1e-12));
4843         mesh.getNodalConnectivity().setIJ(0,6,10);
4844         mesh.getNodalConnectivity().setIJ(0,7,9);
4845         mesh.getNodalConnectivity().setIJ(0,8,12);
4846         mesh.getNodalConnectivity().setIJ(0,9,13);
4847         mesh.unPolyze();
4848         self.assertTrue(mesh.isEqual(mesh2,1e-12));
4849         mesh.convertToPolyTypes(eltsV);
4850         mesh.getNodalConnectivity().setIJ(0,6,12);
4851         mesh.getNodalConnectivity().setIJ(0,7,13);
4852         mesh.getNodalConnectivity().setIJ(0,8,10);
4853         mesh.getNodalConnectivity().setIJ(0,9,9);
4854         mesh.unPolyze();
4855         self.assertTrue(mesh.isEqual(mesh2,1e-12));
4856         mesh.convertToPolyTypes(eltsV);
4857         mesh.getNodalConnectivity().setIJ(0,6,12);
4858         mesh.getNodalConnectivity().setIJ(0,7,10);
4859         mesh.getNodalConnectivity().setIJ(0,8,13);
4860         mesh.getNodalConnectivity().setIJ(0,9,9);
4861         mesh.unPolyze();
4862         self.assertTrue(not mesh.isEqual(mesh2,1e-12));
4863         # Test for 2D mesh
4864         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
4865         mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
4866         eltsV=eltsV[:5];
4867         mesh.convertToPolyTypes(eltsV);
4868         self.assertTrue(not mesh.isEqual(mesh2,1e-12));
4869         mesh.unPolyze();
4870         self.assertTrue(mesh.isEqual(mesh2,1e-12));
4871         pass
4872
4873     def testConvertDegeneratedCells1(self):
4874         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
4875         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]
4876         mesh.allocateCells(4);
4877         mesh.insertNextCell(NORM_HEXA8,8,conn[0:8])
4878         mesh.insertNextCell(NORM_HEXA8,8,conn[8:16])
4879         mesh.insertNextCell(NORM_HEXA8,8,conn[16:24])
4880         mesh.insertNextCell(NORM_HEXA8,8,conn[24:32])
4881         mesh.finishInsertingCells();
4882         mesh.checkCoherency();
4883         self.assertEqual(4,mesh.getNumberOfCells());
4884         self.assertEqual(NORM_HEXA8,mesh.getTypeOfCell(0));
4885         self.assertEqual(NORM_HEXA8,mesh.getTypeOfCell(1));
4886         self.assertEqual(NORM_HEXA8,mesh.getTypeOfCell(2));
4887         self.assertEqual(NORM_HEXA8,mesh.getTypeOfCell(3));
4888         f1=mesh.getMeasureField(True);
4889         mesh.convertDegeneratedCells();
4890         mesh.checkCoherency();
4891         f2=mesh.getMeasureField(True);
4892         self.assertEqual(4,mesh.getNumberOfCells());
4893         self.assertEqual(NORM_PENTA6,mesh.getTypeOfCell(0));
4894         self.assertEqual(NORM_PYRA5,mesh.getTypeOfCell(1));
4895         self.assertEqual(NORM_TETRA4,mesh.getTypeOfCell(2));
4896         self.assertEqual(NORM_PYRA5,mesh.getTypeOfCell(3));
4897         for i in xrange(4):
4898             self.assertAlmostEqual(f1.getArray().getIJ(0,i),f2.getArray().getIJ(0,i),5);
4899             pass
4900         pass
4901
4902     def testGetNodeIdsNearPoints1(self):
4903         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
4904         coords=mesh.getCoords();
4905         tmp=DataArrayDouble.New();
4906         vals=[0.2,0.2,0.1,0.2,0.2,0.2]
4907         tmp.setValues(vals,3,2);
4908         tmp2=DataArrayDouble.Aggregate(coords,tmp);
4909         mesh.setCoords(tmp2);
4910         pts=[0.2,0.2,0.1,0.3,-0.3,0.7]
4911         c=mesh.getNodeIdsNearPoint(pts[:2],1e-7);
4912         self.assertEqual([4,9,11],c.getValues());
4913         c,cI=mesh.getNodeIdsNearPoints(pts,3,1e-7);
4914         self.assertEqual([0,3,3,4],cI.getValues());
4915         self.assertEqual([4,9,11,6],c.getValues());
4916         c,cI=mesh.getNodeIdsNearPoints(pts,1e-7);
4917         self.assertEqual([0,3,3,4],cI.getValues());
4918         self.assertEqual([4,9,11,6],c.getValues());
4919         c,cI=mesh.getNodeIdsNearPoints(DataArrayDouble.New(pts,3,2),1e-7);
4920         self.assertEqual([0,3,3,4],cI.getValues());
4921         self.assertEqual([4,9,11,6],c.getValues());
4922         self.assertRaises(InterpKernelException,mesh.getNodeIdsNearPoints,DataArrayDouble.New(pts,2,3),1e-7);
4923         pass
4924
4925     def testFieldCopyTinyAttrFrom1(self):
4926         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
4927         f1.setName("f1");
4928         f1.setTimeTolerance(1.e-5);
4929         f1.setDescription("f1Desc");
4930         f1.setTime(1.23,4,5);
4931         f2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
4932         f2.setName("f2");
4933         f2.setDescription("f2Desc");
4934         f2.setTime(6.78,9,10);
4935         f2.setTimeTolerance(4.556e-12);
4936         #
4937         f1.copyTinyAttrFrom(f2);
4938         self.assertAlmostEqual(4.556e-12,f1.getTimeTolerance(),24);
4939         t,dt,it=f1.getTime()
4940         self.assertAlmostEqual(6.78,t,12);
4941         self.assertEqual(9,dt);
4942         self.assertEqual(10,it);
4943         self.assertTrue(f1.getName()=="f1");#name unchanged
4944         self.assertTrue(f1.getDescription()=="f1Desc");#description unchanged
4945         #
4946         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
4947         f1.setName("f1");
4948         f1.setTimeTolerance(1.e-5);
4949         f1.setDescription("f1Desc");
4950         f2=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
4951         f2.setName("f2");
4952         f2.setDescription("f2Desc");
4953         f2.setTimeTolerance(4.556e-12);
4954         #
4955         f1.copyTinyAttrFrom(f2);
4956         self.assertAlmostEqual(4.556e-12,f1.getTimeTolerance(),24);
4957         self.assertTrue(f1.getName()=="f1");#name unchanged
4958         self.assertTrue(f1.getDescription()=="f1Desc");#description unchanged
4959         #
4960         f1=MEDCouplingFieldDouble.New(ON_CELLS,CONST_ON_TIME_INTERVAL);
4961         f1.setName("f1");
4962         f1.setTimeTolerance(1.e-5);
4963         f1.setDescription("f1Desc");
4964         f1.setTime(1.23,4,5);
4965         f1.setEndTime(5.43,2,1);
4966         f2=MEDCouplingFieldDouble.New(ON_CELLS,CONST_ON_TIME_INTERVAL);
4967         f2.setName("f2");
4968         f2.setDescription("f2Desc");
4969         f2.setTimeTolerance(4.556e-12);
4970         f2.setTime(6.78,9,10);
4971         f2.setEndTime(10.98,7,6);
4972         #
4973         f1.copyTinyAttrFrom(f2);
4974         self.assertAlmostEqual(4.556e-12,f1.getTimeTolerance(),24);
4975         self.assertTrue(f1.getName()=="f1");#name unchanged
4976         self.assertTrue(f1.getDescription()=="f1Desc");#description unchanged
4977         t,dt,it=f1.getTime()
4978         self.assertAlmostEqual(6.78,t,12);
4979         self.assertEqual(9,dt);
4980         self.assertEqual(10,it);
4981         t,dt,it=f1.getEndTime()
4982         self.assertAlmostEqual(10.98,t,12);
4983         self.assertEqual(7,dt);
4984         self.assertEqual(6,it);
4985         #
4986         f1=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
4987         f1.setName("f1");
4988         f1.setTimeTolerance(1.e-5);
4989         f1.setDescription("f1Desc");
4990         f1.setTime(1.23,4,5);
4991         f1.setEndTime(5.43,2,1);
4992         f2=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
4993         f2.setName("f2");
4994         f2.setDescription("f2Desc");
4995         f2.setTimeTolerance(4.556e-12);
4996         f2.setTime(6.78,9,10);
4997         f2.setEndTime(10.98,7,6);
4998         #
4999         f1.copyTinyAttrFrom(f2);
5000         self.assertAlmostEqual(4.556e-12,f1.getTimeTolerance(),24);
5001         self.assertTrue(f1.getName()=="f1");#name unchanged
5002         self.assertTrue(f1.getDescription()=="f1Desc");#description unchanged
5003         t,dt,it=f1.getTime()
5004         self.assertAlmostEqual(6.78,t,12);
5005         self.assertEqual(9,dt);
5006         self.assertEqual(10,it);
5007         t,dt,it=f1.getEndTime()
5008         self.assertAlmostEqual(10.98,t,12);
5009         self.assertEqual(7,dt);
5010         self.assertEqual(6,it);
5011         pass
5012
5013     def testExtrudedMesh5(self):
5014         coo1=[0.,1.,2.,3.5]
5015         a=DataArrayDouble.New();
5016         a.setValues(coo1,4,1);
5017         b=MEDCouplingCMesh.New();
5018         b.setCoordsAt(0,a);
5019         c=b.buildUnstructured();
5020         self.assertEqual(1,c.getSpaceDimension());
5021         c.changeSpaceDimension(2);
5022         #
5023         d=DataArrayDouble.New();
5024         d.alloc(13,1);
5025         d.iota();
5026         e=MEDCouplingCMesh.New();
5027         e.setCoordsAt(0,d);
5028         f=e.buildUnstructured();
5029         g=f.getCoords().applyFunc(2,"3.5*IVec+x/6*3.14159265359*JVec");
5030         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 !
5031         h=g.fromPolarToCart();
5032         f.setCoords(h);
5033         i=c.buildExtrudedMesh(f,1);
5034         self.assertEqual(52,i.getNumberOfNodes());
5035         tmp,tmp2,tmp3=i.mergeNodes(1e-9);
5036         self.assertTrue(tmp2);
5037         self.assertEqual(37,tmp3);
5038         i.convertDegeneratedCells();
5039         i.checkCoherency();
5040         self.assertEqual(36,i.getNumberOfCells());
5041         self.assertEqual(37,i.getNumberOfNodes());
5042         self.assertEqual(12,i.getNumberOfCellsWithType(NORM_TRI3));
5043         self.assertEqual(24,i.getNumberOfCellsWithType(NORM_QUAD4));
5044         expected1=[0.25,0.75,2.0625]
5045         j=i.getMeasureField(True);
5046         for ii in xrange(12):
5047             for k in xrange(3):
5048                 self.assertAlmostEqual(expected1[k],j.getIJ(0,ii*3+k),10);
5049                 pass
5050             pass
5051         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]
5052         m=i.getBarycenterAndOwner();
5053         for i in xrange(72):
5054             self.assertAlmostEqual(expected2[i],m.getIJ(0,i),10);
5055             pass
5056         #
5057         pass
5058
5059     def testExtrudedMesh6(self):
5060         coo1=[0.,1.,2.,3.5]
5061         a=DataArrayDouble.New();
5062         a.setValues(coo1,4,1);
5063         b=MEDCouplingCMesh.New();
5064         b.setCoordsAt(0,a);
5065         c=b.buildUnstructured();
5066         self.assertEqual(1,c.getSpaceDimension());
5067         c.changeSpaceDimension(2);
5068         #
5069         d=DataArrayDouble.New();
5070         d.alloc(5,1);
5071         d.iota();
5072         e=MEDCouplingCMesh.New();
5073         e.setCoordsAt(0,d);
5074         f=e.buildUnstructured();
5075         d2=f.getCoords().applyFunc("x*x/2");
5076         f.setCoords(d2);
5077         f.changeSpaceDimension(2);
5078         #
5079         center=[0.,0.]
5080         f.rotate(center,None,pi/3);
5081         g=c.buildExtrudedMesh(f,0);
5082         g.checkCoherency();
5083         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 ]
5084         f1=g.getMeasureField(True);
5085         for i in xrange(12):
5086             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),12);
5087             pass
5088         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]
5089         f2=g.getBarycenterAndOwner();
5090         for i in xrange(24):
5091             self.assertAlmostEqual(expected2[i],f2.getIJ(0,i),12);
5092             pass
5093         pass
5094
5095     def testExtrudedMesh7(self):
5096         coo1=[0.,1.,2.,3.5]
5097         a=DataArrayDouble.New();
5098         a.setValues(coo1,4,1);
5099         b=MEDCouplingCMesh.New();
5100         b.setCoordsAt(0,a);
5101         c=b.buildUnstructured();
5102         self.assertEqual(1,c.getSpaceDimension());
5103         c.changeSpaceDimension(2);
5104         #
5105         d=DataArrayDouble.New();
5106         d.alloc(13,1);
5107         d.iota();
5108         e=MEDCouplingCMesh.New();
5109         e.setCoordsAt(0,d);
5110         f=e.buildUnstructured();
5111         g=f.getCoords().applyFunc(2,"3.5*IVec+x/6*3.14159265359*JVec");
5112         h=g.fromPolarToCart();
5113         f.setCoords(h);
5114         i=c.buildExtrudedMesh(f,1);
5115         self.assertEqual(52,i.getNumberOfNodes());
5116         tmp,tmp2,tmp3=i.mergeNodes(1e-9);
5117         self.assertTrue(tmp2);
5118         self.assertEqual(37,tmp3);
5119         i.convertDegeneratedCells();
5120         vec1=[10.,0]
5121         i.translate(vec1);
5122         g2=h.applyFunc(3,"13.5/3.5*x*IVec+0*JVec+13.5/3.5*y*KVec");
5123         f.setCoords(g2);
5124         i.changeSpaceDimension(3);
5125         i3=i.buildExtrudedMesh(f,1);
5126         f2=i3.getMeasureField(True);
5127         tmp,tmp2,tmp3=i.mergeNodes(1e-9);
5128         self.assertTrue(tmp2);
5129         self.assertEqual(444,tmp3);
5130         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]
5131         for ii in xrange(12):
5132             for jj in xrange(36):
5133                 self.assertAlmostEqual(expected1[jj],f2.getIJ(0,ii*36+jj),9);
5134                 pass
5135         #
5136         pass
5137
5138     def testSimplexize1(self):
5139         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5140         m.convertToPolyTypes([3]);
5141         da=m.simplexize(0);
5142         self.assertEqual(7,da.getNumberOfTuples());
5143         self.assertEqual(1,da.getNumberOfComponents());
5144         expected2=[0,0,1,2,3,4,4]
5145         for i in xrange(7):
5146             self.assertEqual(expected2[i],da.getIJ(i,0));
5147             pass
5148         m.checkCoherency();
5149         self.assertEqual(7,m.getNumberOfCells());
5150         self.assertEqual(NORM_TRI3,m.getTypeOfCell(0));
5151         self.assertEqual(NORM_TRI3,m.getTypeOfCell(1));
5152         self.assertEqual(NORM_TRI3,m.getTypeOfCell(2));
5153         self.assertEqual(NORM_TRI3,m.getTypeOfCell(3));
5154         self.assertEqual(NORM_POLYGON,m.getTypeOfCell(4));
5155         self.assertEqual(NORM_TRI3,m.getTypeOfCell(5));
5156         self.assertEqual(NORM_TRI3,m.getTypeOfCell(6));
5157         expected1=[0.125,0.125,0.125,0.125,0.25,0.125,0.125]
5158         f=m.getMeasureField(False);
5159         for i in xrange(7):
5160             self.assertAlmostEqual(expected1[i]*sqrt(2.),f.getIJ(i,0),10);
5161             pass
5162         types=m.getAllTypes();
5163         self.assertEqual([NORM_TRI3,NORM_POLYGON],types);
5164         #
5165         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5166         m.convertToPolyTypes([3]);
5167         da=m.simplexize(1);
5168         self.assertEqual(7,da.getNumberOfTuples());
5169         self.assertEqual(1,da.getNumberOfComponents());
5170         for i in xrange(7):
5171             self.assertEqual(expected2[i],da.getIJ(i,0));
5172             pass
5173         m.checkCoherency();
5174         types=m.getAllTypes();
5175         self.assertEqual([NORM_TRI3,NORM_POLYGON],types);
5176         self.assertEqual(7,m.getNumberOfCells());
5177         self.assertEqual(NORM_TRI3,m.getTypeOfCell(0));
5178         self.assertEqual(NORM_TRI3,m.getTypeOfCell(1));
5179         self.assertEqual(NORM_TRI3,m.getTypeOfCell(2));
5180         self.assertEqual(NORM_TRI3,m.getTypeOfCell(3));
5181         self.assertEqual(NORM_POLYGON,m.getTypeOfCell(4));
5182         self.assertEqual(NORM_TRI3,m.getTypeOfCell(5));
5183         self.assertEqual(NORM_TRI3,m.getTypeOfCell(6));
5184         f=m.getMeasureField(False);
5185         for i in xrange(7):
5186             self.assertAlmostEqual(expected1[i]*sqrt(2.),f.getIJ(i,0),10);
5187             pass
5188         pass
5189
5190     def testSimplexize2(self):
5191         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5192         m.convertToPolyTypes([3]);
5193         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
5194         f1.setMesh(m);
5195         arr=DataArrayDouble.New();
5196         arr1=[10.,110.,20.,120.,30.,130.,40.,140.,50.,150.]
5197         arr.setValues(arr1,5,2);
5198         f1.setArray(arr);
5199         #
5200         f1.checkCoherency();
5201         self.assertTrue(f1.simplexize(0));
5202         f1.checkCoherency();
5203         expected1=[10.,110.,10.,110.,20.,120.,30.,130.,40.,140.,50.,150.,50.,150.]
5204         for i in xrange(14):
5205             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),10);
5206             pass
5207         self.assertTrue(not f1.simplexize(0));
5208         for i in xrange(14):
5209             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),10);
5210             pass
5211         #
5212         pass
5213
5214     def testDAMeld1(self):
5215         da1=DataArrayDouble.New();
5216         da1.alloc(7,2);
5217         da2=DataArrayDouble.New();
5218         da2.alloc(7,1);
5219         #
5220         da1.fillWithValue(7.);
5221         da2.iota(0.);
5222         da3=da2.applyFunc(3,"10*x*IVec+100*x*JVec+1000*x*KVec");
5223         #
5224         da1.setInfoOnComponent(0,"c0da1");
5225         da1.setInfoOnComponent(1,"c1da1");
5226         da3.setInfoOnComponent(0,"c0da3");
5227         da3.setInfoOnComponent(1,"c1da3");
5228         da3.setInfoOnComponent(2,"c2da3");
5229         #
5230         da1C=da1.deepCpy();
5231         da1.meldWith(da3);
5232         self.assertEqual(5,da1.getNumberOfComponents());
5233         self.assertEqual(7,da1.getNumberOfTuples());
5234         self.assertTrue(da1.getInfoOnComponent(0)=="c0da1");
5235         self.assertTrue(da1.getInfoOnComponent(1)=="c1da1");
5236         self.assertTrue(da1.getInfoOnComponent(2)=="c0da3");
5237         self.assertTrue(da1.getInfoOnComponent(3)=="c1da3");
5238         self.assertTrue(da1.getInfoOnComponent(4)=="c2da3");
5239         #
5240         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.]
5241         for i in xrange(35):
5242             self.assertAlmostEqual(expected1[i],da1.getIJ(0,i),10);
5243             pass
5244         #
5245         dai1=da1C.convertToIntArr();
5246         dai3=da3.convertToIntArr();
5247         dai1.meldWith(dai3);
5248         self.assertEqual(5,dai1.getNumberOfComponents());
5249         self.assertEqual(7,dai1.getNumberOfTuples());
5250         self.assertTrue(dai1.getInfoOnComponent(0)=="c0da1");
5251         self.assertTrue(dai1.getInfoOnComponent(1)=="c1da1");
5252         self.assertTrue(dai1.getInfoOnComponent(2)=="c0da3");
5253         self.assertTrue(dai1.getInfoOnComponent(3)=="c1da3");
5254         self.assertTrue(dai1.getInfoOnComponent(4)=="c2da3");
5255         for i in xrange(35):
5256             self.assertEqual(int(expected1[i]),dai1.getIJ(0,i));
5257             pass
5258         # test of static method DataArrayDouble::meld
5259         da4=DataArrayDouble.Meld(da1C,da3);
5260         tmp=DataArrayDouble.Meld([da1C,da3]);
5261         self.assertTrue(da4.isEqual(tmp,1e-10))
5262         self.assertEqual(5,da4.getNumberOfComponents());
5263         self.assertEqual(7,da4.getNumberOfTuples());
5264         self.assertTrue(da4.getInfoOnComponent(0)=="c0da1");
5265         self.assertTrue(da4.getInfoOnComponent(1)=="c1da1");
5266         self.assertTrue(da4.getInfoOnComponent(2)=="c0da3");
5267         self.assertTrue(da4.getInfoOnComponent(3)=="c1da3");
5268         self.assertTrue(da4.getInfoOnComponent(4)=="c2da3");
5269         for i in xrange(35):
5270             self.assertAlmostEqual(expected1[i],da4.getIJ(0,i),10);
5271             pass
5272         # test of static method DataArrayInt::meld
5273         dai1=da1C.convertToIntArr();
5274         dai4=DataArrayInt.Meld(dai1,dai3);
5275         tmp=DataArrayInt.Meld([dai1,dai3]);
5276         self.assertTrue(dai4.isEqual(tmp))
5277         self.assertEqual(5,dai4.getNumberOfComponents());
5278         self.assertEqual(7,dai4.getNumberOfTuples());
5279         self.assertTrue(dai4.getInfoOnComponent(0)=="c0da1");
5280         self.assertTrue(dai4.getInfoOnComponent(1)=="c1da1");
5281         self.assertTrue(dai4.getInfoOnComponent(2)=="c0da3");
5282         self.assertTrue(dai4.getInfoOnComponent(3)=="c1da3");
5283         self.assertTrue(dai4.getInfoOnComponent(4)=="c2da3");
5284         for i in xrange(35):
5285             self.assertEqual(int(expected1[i]),dai4.getIJ(0,i));
5286             pass
5287         pass
5288
5289     def testFieldMeld1(self):
5290         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5291         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
5292         f1.setMesh(m);
5293         da1=DataArrayDouble.New();
5294         arr1=[12.,23.,34.,45.,56.]
5295         da1.setValues(arr1,5,1);
5296         da1.setInfoOnComponent(0,"aaa");
5297         f1.setArray(da1);
5298         f1.setTime(3.4,2,1);
5299         f1.checkCoherency();
5300         #
5301         f2=f1.deepCpy();
5302         f2.setMesh(f1.getMesh());
5303         f2.checkCoherency();
5304         f2.changeNbOfComponents(2,5.);
5305         f2.assign(5.);
5306         f2.getArray().setInfoOnComponent(0,"bbb");
5307         f2.getArray().setInfoOnComponent(1,"ccc");
5308         f2.checkCoherency();
5309         #
5310         f3=MEDCouplingFieldDouble.MeldFields(f2,f1);
5311         f3.checkCoherency();
5312         self.assertEqual(5,f3.getNumberOfTuples());
5313         self.assertEqual(3,f3.getNumberOfComponents());
5314         self.assertTrue(f3.getArray().getInfoOnComponent(0)=="bbb");
5315         self.assertTrue(f3.getArray().getInfoOnComponent(1)=="ccc");
5316         self.assertTrue(f3.getArray().getInfoOnComponent(2)=="aaa");
5317         expected1=[5.,5.,12.,5.,5.,23.,5.,5.,34.,5.,5.,45.,5.,5.,56.]
5318         for i in xrange(15):
5319             self.assertAlmostEqual(expected1[i],f3.getIJ(0,i),12);
5320             pass
5321         time,dt,it=f3.getTime();
5322         self.assertAlmostEqual(3.4,time,14);
5323         self.assertEqual(2,dt);
5324         self.assertEqual(1,it);
5325         #
5326         f4=f2.buildNewTimeReprFromThis(NO_TIME,False);
5327         f5=f1.buildNewTimeReprFromThis(NO_TIME,False);
5328         f6=MEDCouplingFieldDouble.MeldFields(f4,f5);
5329         f6.checkCoherency();
5330         self.assertEqual(5,f6.getNumberOfTuples());
5331         self.assertEqual(3,f6.getNumberOfComponents());
5332         self.assertTrue(f6.getArray().getInfoOnComponent(0)=="bbb");
5333         self.assertTrue(f6.getArray().getInfoOnComponent(1)=="ccc");
5334         self.assertTrue(f6.getArray().getInfoOnComponent(2)=="aaa");
5335         for i in xrange(15):
5336             self.assertAlmostEqual(expected1[i],f6.getIJ(0,i),12);
5337             pass
5338         #
5339         pass
5340
5341     def testMergeNodes2(self):
5342         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5343         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
5344         vec=[0.002,0.]
5345         m2.translate(vec);
5346         #
5347         m3=MEDCouplingUMesh.MergeUMeshes([m1,m2]);
5348         da,b,newNbOfNodes=m3.mergeNodes2(0.01);
5349         self.assertEqual(9,m3.getNumberOfNodes());
5350         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]
5351         for i in xrange(18):
5352             self.assertAlmostEqual(expected1[i],m3.getCoords().getIJ(0,i),13);
5353             pass
5354         #
5355         pass
5356
5357     def testMergeField2(self):
5358         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5359         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
5360         f1.setMesh(m);
5361         arr=DataArrayDouble.New();
5362         arr.alloc(5,2);
5363         arr.fillWithValue(2.);
5364         f1.setArray(arr);
5365         f2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
5366         f2.setMesh(m);
5367         arr=DataArrayDouble.New();
5368         arr.alloc(5,2);
5369         arr.fillWithValue(5.);
5370         f2.setArray(arr);
5371         f3=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
5372         f3.setMesh(m);
5373         arr=DataArrayDouble.New();
5374         arr.alloc(5,2);
5375         arr.fillWithValue(7.);
5376         f3.setArray(arr);
5377         #
5378         f4=MEDCouplingFieldDouble.MergeFields([f1,f2,f3]);
5379         self.assertEqual(15,f4.getMesh().getNumberOfCells());
5380         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.]
5381         for i in xrange(30):
5382             self.assertAlmostEqual(expected1[i],f4.getIJ(0,i),13);
5383             pass
5384         #
5385         pass
5386
5387     def testDAIBuildComplement1(self):
5388         a=DataArrayInt.New();
5389         tab=[3,1,7,8]
5390         a.setValues(tab,4,1);
5391         b=a.buildComplement(12);
5392         self.assertEqual(8,b.getNumberOfTuples());
5393         self.assertEqual(1,b.getNumberOfComponents());
5394         expected1=[0,2,4,5,6,9,10,11]
5395         for i in xrange(8):
5396             self.assertEqual(expected1[i],b.getIJ(0,i));
5397             pass
5398         pass
5399
5400     def testDAIBuildUnion1(self):
5401         a=DataArrayInt.New();
5402         tab1=[3,1,7,8]
5403         a.setValues(tab1,4,1);
5404         c=DataArrayInt.New();
5405         tab2=[5,3,0,18,8]
5406         c.setValues(tab2,5,1);
5407         b=a.buildUnion(c);
5408         self.assertEqual(7,b.getNumberOfTuples());
5409         self.assertEqual(1,b.getNumberOfComponents());
5410         expected1=[0,1,3,5,7,8,18]
5411         for i in xrange(7):
5412             self.assertEqual(expected1[i],b.getIJ(0,i));
5413             pass
5414         b=DataArrayInt.BuildUnion([a,c]);
5415         self.assertEqual(7,b.getNumberOfTuples());
5416         self.assertEqual(1,b.getNumberOfComponents());
5417         expected1=[0,1,3,5,7,8,18]
5418         for i in xrange(7):
5419             self.assertEqual(expected1[i],b.getIJ(0,i));
5420             pass
5421         pass
5422
5423     def testDAIBuildIntersection1(self):
5424         a=DataArrayInt.New();
5425         tab1=[3,1,7,8]
5426         a.setValues(tab1,4,1);
5427         c=DataArrayInt.New();
5428         tab2=[5,3,0,18,8]
5429         c.setValues(tab2,5,1);
5430         b=a.buildIntersection(c);
5431         self.assertEqual(2,b.getNumberOfTuples());
5432         self.assertEqual(1,b.getNumberOfComponents());
5433         expected1=[3,8]
5434         for i in xrange(2):
5435             self.assertEqual(expected1[i],b.getIJ(0,i));
5436             pass
5437         b=DataArrayInt.BuildIntersection([a,c]);
5438         self.assertEqual(2,b.getNumberOfTuples());
5439         self.assertEqual(1,b.getNumberOfComponents());
5440         expected1=[3,8]
5441         for i in xrange(2):
5442             self.assertEqual(expected1[i],b.getIJ(0,i));
5443             pass
5444         pass
5445
5446     def testDAIDeltaShiftIndex1(self):
5447         a=DataArrayInt.New();
5448         tab=[1,3,6,7,7,9,15]
5449         a.setValues(tab,7,1);
5450         b=a.deltaShiftIndex();
5451         self.assertEqual(6,b.getNumberOfTuples());
5452         self.assertEqual(1,b.getNumberOfComponents());
5453         expected1=[2,3,1,0,2,6]
5454         for i in xrange(6):
5455             self.assertEqual(expected1[i],b.getIJ(0,i));
5456             pass
5457         pass
5458
5459     def testDaDoubleSelectByTupleIdSafe1(self):
5460         a=DataArrayDouble.New();
5461         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]
5462         a.setValues(arr1,7,2);
5463         a.setInfoOnComponent(0,"toto");
5464         a.setInfoOnComponent(1,"tata");
5465         #
5466         arr2=[4,2,0,6,5]
5467         b=a.selectByTupleIdSafe(arr2);
5468         self.assertEqual(5,b.getNumberOfTuples());
5469         self.assertEqual(2,b.getNumberOfComponents());
5470         self.assertTrue(b.getInfoOnComponent(0)=="toto");
5471         self.assertTrue(b.getInfoOnComponent(1)=="tata");
5472         expected1=[5.1,15.1,3.1,13.1,1.1,11.1,7.1,17.1,6.1,16.1]
5473         for i in xrange(10):
5474             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
5475             pass
5476         arr4=[4,-1,0,6,5]
5477         self.assertRaises(InterpKernelException,a.selectByTupleIdSafe,arr4);
5478         arr5=[4,2,0,6,7]
5479         self.assertRaises(InterpKernelException,a.selectByTupleIdSafe,arr5);
5480         #
5481         c=DataArrayInt.New();
5482         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
5483         c.setValues(arr3,7,2);
5484         c.setInfoOnComponent(0,"toto");
5485         c.setInfoOnComponent(1,"tata");
5486         d=c.selectByTupleIdSafe(arr2);
5487         self.assertEqual(5,d.getNumberOfTuples());
5488         self.assertEqual(2,d.getNumberOfComponents());
5489         self.assertTrue(d.getInfoOnComponent(0)=="toto");
5490         self.assertTrue(d.getInfoOnComponent(1)=="tata");
5491         expected2=[5,15,3,13,1,11,7,17,6,16]
5492         for i in xrange(10):
5493             self.assertEqual(expected2[i],d.getIJ(0,i));
5494             pass
5495         self.assertRaises(InterpKernelException,c.selectByTupleIdSafe,arr4);
5496         self.assertRaises(InterpKernelException,c.selectByTupleIdSafe,arr5);
5497         pass
5498
5499     def testAreCellsIncludedIn1(self):
5500         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5501         pt=[1,3]
5502         m2=m.buildPartOfMySelf(pt,True);
5503         ret,tmp=m.areCellsIncludedIn(m2,0)
5504         self.assertTrue(ret);
5505         self.assertEqual(2,tmp.getNumberOfTuples());
5506         self.assertEqual(1,tmp.getNumberOfComponents());
5507         self.assertEqual(pt[0],tmp.getIJ(0,0));
5508         self.assertEqual(pt[1],tmp.getIJ(0,1));
5509         ret,tmp=m2.areCellsIncludedIn(m,0)
5510         self.assertTrue(not ret);
5511         pass
5512
5513     def testSwigErrorProtection1(self):
5514         m=MEDCouplingDataForTest.build3DTargetMesh_1();
5515         m.rotate([0.,0.,0.],[0.3,0.6,1.2],0.37)
5516         m.rotate([0.,0.,0.],[0.3,6,1.2],0.37)
5517         self.assertRaises(InterpKernelException,m.rotate,[0.,0.,0.],(0.3,6,"1.2"),0.37)
5518         self.assertRaises(InterpKernelException,m.rotate,[0.,"0.",0.],[0.3,0.6,1.2],0.37)
5519         self.assertRaises(InterpKernelException,m.rotate,[0.,0.,0.],[0.3,'0.6',1.2],0.37)
5520         m2=m.buildPartOfMySelf([2,5],True)
5521         m3=m.buildPartOfMySelf((2,5),True)
5522         self.assertTrue(m2.isEqual(m3,1e-12))
5523         self.assertRaises(InterpKernelException,m.buildPartOfMySelf,[2,5.],True)
5524         da1=m.getCoords().keepSelectedComponents([1])
5525         da2=m.getCoords().keepSelectedComponents((1,))
5526         self.assertTrue(da1.isEqual(da2,1e-12))
5527         self.assertRaises(InterpKernelException,m.getCoords().keepSelectedComponents,["1"])
5528         pass
5529
5530     def testDAIBuildSubstraction1(self):
5531         a=DataArrayInt.New()
5532         aa=[2,3,6,8,9]
5533         a.setValues(aa,5,1)
5534         b=DataArrayInt.New()
5535         bb=[1,3,5,9,11]
5536         b.setValues(bb,5,1)
5537         self.assertEqual([2,6,8],a.buildSubstraction(b).getValues())
5538         pass
5539
5540     def testBuildOrthogonalField2(self):
5541         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5542         d1=DataArrayInt.New();
5543         d2=DataArrayInt.New();
5544         d3=DataArrayInt.New();
5545         d4=DataArrayInt.New();
5546         m1=m.buildDescendingConnectivity(d1,d2,d3,d4);
5547         #
5548         f1=m1.buildOrthogonalField();
5549         da1=f1.getArray();
5550         self.assertEqual(2,da1.getNumberOfComponents());
5551         self.assertEqual(13,da1.getNumberOfTuples());
5552         #
5553         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.];
5554         for i in xrange(26):
5555             self.assertAlmostEqual(expected1[i],da1.getIJ(0,i),14);
5556             pass
5557         pass
5558
5559     def testSwigErrorProtection2(self):
5560         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5561         coo=m.getCoords()
5562         c=m.getNodalConnectivity()
5563         ci=m.getNodalConnectivityIndex()
5564         del m
5565         self.assertEqual(2,coo.getNumberOfComponents());
5566         self.assertEqual(6,ci.getNumberOfTuples());
5567         self.assertEqual(23,c.getNumberOfTuples());
5568         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5569         f=m.getMeasureField(True)
5570         c=f.getArray()
5571         del f
5572         self.assertEqual(1,c.getNumberOfComponents());
5573         m=MEDCouplingCMesh.New()
5574         x=DataArrayDouble.New()
5575         x.setValues([1.,2.,4.],3,1)
5576         m.setCoordsAt(0,x)
5577         del x
5578         xx=m.getCoordsAt(0)
5579         del m
5580         self.assertEqual(3,xx.getNumberOfTuples());
5581         #
5582         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5583         f=m.getMeasureField(True)
5584         m2=f.getMesh()
5585         del m
5586         del f
5587         self.assertEqual(5,m2.getNumberOfCells());
5588         pass
5589
5590     def testUMInsertNextCell1(self):
5591         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 ]
5592         targetConn=[0,3,4,1, 1,4,2, 4,5,2, 6,7,4,3, 7,8,5,4]
5593         targetMesh=MEDCouplingUMesh.New();
5594         targetMesh.allocateCells(5);
5595         self.assertRaises(InterpKernelException,targetMesh.insertNextCell,NORM_QUAD4,4,targetConn[0:4])
5596         targetMesh.setMeshDimension(2);
5597         targetMesh.insertNextCell(NORM_QUAD4,4,targetConn[0:4])
5598         self.assertRaises(InterpKernelException,targetMesh.insertNextCell,NORM_TETRA4,4,targetConn[0:4])
5599         self.assertRaises(InterpKernelException,targetMesh.insertNextCell,NORM_SEG2,2,targetConn[0:2])
5600         self.assertRaises(InterpKernelException,targetMesh.insertNextCell,NORM_POINT1,1,targetConn[0:1])
5601         targetMesh.insertNextCell(NORM_TRI3,3,targetConn[4:7])
5602         targetMesh.insertNextCell(NORM_TRI3,3,targetConn[7:10])
5603         targetMesh.insertNextCell(NORM_QUAD4,4,targetConn[10:14])
5604         targetMesh.insertNextCell(NORM_QUAD4,4,targetConn[14:18])
5605         targetMesh.finishInsertingCells();
5606         myCoords=DataArrayDouble.New();
5607         myCoords.setValues(targetCoords,9,2);
5608         targetMesh.setCoords(myCoords);
5609         targetMesh.checkCoherency();
5610         pass
5611
5612     def testFieldOperatorDivDiffComp1(self):
5613         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5614         m1,d0,d1,d2,d3=m.buildDescendingConnectivity();
5615         #
5616         f1=m1.buildOrthogonalField();
5617         arr1=[2.,3.,4.,5.,6.,7.,8.,9.,10.,11.,12.,13.,14.]
5618         arr=DataArrayDouble.New();
5619         arr.setValues(arr1,13,1);
5620         f2=MEDCouplingFieldDouble.New(ON_CELLS);
5621         f2.setArray(arr);
5622         f2.setMesh(m1);
5623         f2.checkCoherency();
5624         #
5625         f3=f1/f2;
5626         self.assertRaises(InterpKernelException,f2.__div__,f1)
5627         f3.checkCoherency();
5628         f1/=f2;
5629         #self.assertRaises(InterpKernelException,f2.__idiv__,f1) # mem leaks
5630         self.assertTrue(f1.isEqual(f3,1e-10,1e-10));
5631         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]
5632         for i in xrange(26):
5633             self.assertAlmostEqual(expected1[i],f3.getIJ(0,i),10);
5634             pass
5635         pass
5636
5637     def testDARearrange1(self):
5638         da1=DataArrayInt.New();
5639         da1.alloc(12,1);
5640         da1.iota(0);
5641         #
5642         self.assertEqual(12,da1.getNbOfElems());
5643         self.assertEqual(1,da1.getNumberOfComponents());
5644         self.assertEqual(12,da1.getNumberOfTuples());
5645         da1.rearrange(4);
5646         self.assertEqual(12,da1.getNbOfElems());
5647         self.assertEqual(4,da1.getNumberOfComponents());
5648         self.assertEqual(3,da1.getNumberOfTuples());
5649         for i in xrange(12):
5650             self.assertEqual(i,da1.getIJ(0,i));
5651         #
5652         da1.rearrange(6);
5653         self.assertEqual(12,da1.getNbOfElems());
5654         self.assertEqual(6,da1.getNumberOfComponents());
5655         self.assertEqual(2,da1.getNumberOfTuples());
5656         for i in xrange(12):
5657             self.assertEqual(i,da1.getIJ(0,i));
5658         #
5659         self.assertRaises(InterpKernelException,da1.rearrange,7);
5660         #
5661         da1.rearrange(12);
5662         self.assertEqual(12,da1.getNbOfElems());
5663         self.assertEqual(12,da1.getNumberOfComponents());
5664         self.assertEqual(1,da1.getNumberOfTuples());
5665         for i in xrange(12):
5666             self.assertEqual(i,da1.getIJ(0,i));
5667         #
5668         da1.rearrange(3);
5669         self.assertEqual(12,da1.getNbOfElems());
5670         self.assertEqual(3,da1.getNumberOfComponents());
5671         self.assertEqual(4,da1.getNumberOfTuples());
5672         for i in xrange(12):
5673             self.assertEqual(i,da1.getIJ(0,i));
5674         #double
5675         da2=da1.convertToDblArr();
5676         st=da2.getHiddenCppPointer()
5677         #
5678         self.assertEqual(12,da2.getNbOfElems());
5679         self.assertEqual(3,da2.getNumberOfComponents());
5680         self.assertEqual(4,da2.getNumberOfTuples());
5681         da2.rearrange(4);
5682         self.assertEqual(12,da2.getNbOfElems());
5683         self.assertEqual(4,da2.getNumberOfComponents());
5684         self.assertEqual(3,da2.getNumberOfTuples());
5685         for i in xrange(12):
5686             self.assertAlmostEqual(float(i),da2.getIJ(0,i),14);
5687         #
5688         da2.rearrange(6);
5689         self.assertEqual(12,da2.getNbOfElems());
5690         self.assertEqual(6,da2.getNumberOfComponents());
5691         self.assertEqual(2,da2.getNumberOfTuples());
5692         for i in xrange(12):
5693             self.assertAlmostEqual(float(i),da2.getIJ(0,i),14);
5694         #
5695         self.assertRaises(InterpKernelException,da2.rearrange,7);
5696         #
5697         da2.rearrange(1);
5698         self.assertEqual(st,da2.getHiddenCppPointer())
5699         self.assertEqual(12,da2.getNbOfElems());
5700         self.assertEqual(1,da2.getNumberOfComponents());
5701         self.assertEqual(12,da2.getNumberOfTuples());
5702         for i in xrange(12):
5703             self.assertAlmostEqual(float(i),da2.getIJ(0,i),14);
5704         #
5705         da2.rearrange(3);
5706         self.assertEqual(12,da2.getNbOfElems());
5707         self.assertEqual(3,da2.getNumberOfComponents());
5708         self.assertEqual(4,da2.getNumberOfTuples());
5709         for i in xrange(12):
5710             self.assertAlmostEqual(float(i),da2.getIJ(0,i),14);
5711         pass
5712
5713     def testDARearrange2(self):
5714         da1=DataArrayInt.New();
5715         arr=[1,2,3,2,2,3,5,1,5,5,2,2]
5716         da1.setValues(arr,4,3);
5717         s=da1.getDifferentValues();
5718         expected1=[1,2,3,5]
5719         self.assertEqual(expected1,s);
5720         pass
5721
5722     def testSwigErrorProtection3(self):
5723         da=DataArrayInt.New()
5724         da.setValues([1,2,3,4],4,3)
5725         self.assertEqual([1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0],da.getValues())
5726         self.assertEqual(3,da.getNumberOfComponents());
5727         self.assertEqual(4,da.getNumberOfTuples());
5728         da=DataArrayInt.New()
5729         da.setValues((1,2,3,4,4,3),4,3)
5730         self.assertEqual([1, 2, 3, 4, 4, 3, 0, 0, 0, 0, 0, 0],da.getValues())
5731         self.assertEqual(3,da.getNumberOfComponents());
5732         self.assertEqual(4,da.getNumberOfTuples());
5733         da.setValues(10*[1]+290*[2],4,3)
5734         self.assertEqual(10*[1]+[2,2],da.getValues())
5735         self.assertEqual(3,da.getNumberOfComponents());
5736         self.assertEqual(4,da.getNumberOfTuples());
5737         #
5738         da=DataArrayDouble.New()
5739         da.setValues([1,2,3.,4],4,3)
5740         self.assertEqual([1., 2., 3., 4., 0., 0., 0., 0., 0., 0., 0., 0.],da.getValues())
5741         self.assertEqual(3,da.getNumberOfComponents());
5742         self.assertEqual(4,da.getNumberOfTuples());
5743         da=DataArrayDouble.New()
5744         da.setValues((1,2,3,4.,4,3),4,3)
5745         self.assertEqual([1., 2., 3., 4., 4., 3., 0., 0., 0., 0., 0., 0.],da.getValues())
5746         self.assertEqual(3,da.getNumberOfComponents());
5747         self.assertEqual(4,da.getNumberOfTuples());
5748         da.setValues(10*[1]+290*[2],4,3)
5749         self.assertEqual(10*[1.]+[2.,2.],da.getValues())
5750         self.assertEqual(3,da.getNumberOfComponents());
5751         self.assertEqual(4,da.getNumberOfTuples());
5752         pass
5753
5754     def testDAIBuildPermutationArr1(self):
5755         a=DataArrayInt.New()
5756         a.setValues([4,5,6,7,8],5,1)
5757         b=DataArrayInt.New()
5758         b.setValues([5,4,8,6,7],5,1)
5759         c=a.buildPermutationArr(b)
5760         self.assertEqual([1,0,4,2,3],c.getValues())
5761         self.assertTrue(a.isEqualWithoutConsideringStrAndOrder(b))
5762         b.setIJ(0,0,9)
5763         self.assertTrue(not a.isEqualWithoutConsideringStrAndOrder(b))
5764         self.assertRaises(InterpKernelException,a.buildPermutationArr,b)
5765         a.setIJ(3,0,4)
5766         b.setIJ(0,0,5)
5767         b.setIJ(4,0,4)#a==[4,5,6,4,8] and b==[5,4,8,6,4]
5768         self.assertTrue(a.isEqualWithoutConsideringStrAndOrder(b))
5769         c=a.buildPermutationArr(b)
5770         self.assertEqual([1,3,4,2,3],c.getValues())
5771         d=b.convertToDblArr()
5772         expect3=[4,4,5,6,8]
5773         b.sort()
5774         self.assertEqual(expect3,b.getValues())
5775         d.sort()
5776         self.assertEqual(5,d.getNumberOfTuples());
5777         self.assertEqual(1,d.getNumberOfComponents());
5778         for i in xrange(5):
5779             self.assertAlmostEqual(float(expect3[i]),d.getIJ(i,0),14);
5780             pass
5781         pass
5782
5783     def testAreCellsIncludedIn2(self):
5784         myName="Vitoo";
5785         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5786         m2=m.buildPartOfMySelf([],True);
5787         self.assertEqual(0,m2.getNumberOfCells());
5788         self.assertEqual(3,m2.getSpaceDimension());
5789         self.assertEqual(2,m2.getMeshDimension());
5790         m2.setName(myName);
5791         test,tmp=m.areCellsIncludedIn(m2,0)
5792         self.assertTrue(test);
5793         self.assertEqual(myName,tmp.getName());
5794         self.assertEqual(0,tmp.getNumberOfTuples())
5795         self.assertEqual(1,tmp.getNumberOfComponents())
5796         pass
5797
5798     def testUMeshGetPartBarycenterAndOwner1(self):
5799         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5800         part1=[1,0,4];
5801         part=DataArrayInt.New();
5802         part.setValues(part1,3,1);
5803         b=m1.getPartBarycenterAndOwner(part);
5804         self.assertEqual(2,b.getNumberOfComponents());
5805         self.assertEqual(3,b.getNumberOfTuples());
5806         expected1=[0.36666666666666665,-0.13333333333333333,-0.05,-0.05,0.45,0.45];
5807         for i in xrange(6):
5808             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
5809             pass
5810         pass
5811
5812     def testUMeshGetPartMeasureField1(self):
5813         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5814         part1=[1,0,4];
5815         part=DataArrayInt.New();
5816         part.setValues(part1,3,1);
5817         b=m1.getPartMeasureField(True,part);
5818         self.assertEqual(1,b.getNumberOfComponents());
5819         self.assertEqual(3,b.getNumberOfTuples());
5820         expected1=[0.125,0.25,0.25];
5821         for i in xrange(3):
5822             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
5823             pass
5824         pass
5825
5826     def testUMeshBuildPartOrthogonalField1(self):
5827         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5828         m1.changeSpaceDimension(3);
5829         part1=[1,0,4];
5830         part=DataArrayInt.New();
5831         part.setValues(part1,3,1);
5832         b=m1.buildPartOrthogonalField(part);
5833         self.assertEqual(3,b.getArray().getNumberOfComponents());
5834         self.assertEqual(3,b.getArray().getNumberOfTuples());
5835         expected1=[0.,0.,-1.,0.,0.,-1.,0.,0.,-1.];
5836         for i in xrange(9):
5837             self.assertAlmostEqual(expected1[i],b.getArray().getIJ(0,i),14);
5838             pass
5839         pass
5840
5841     def testUMeshGetTypesOfPart1(self):
5842         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5843         part1=[0,3,4];
5844         p1=DataArrayInt.New()
5845         p1.setValues(part1,3,1)
5846         s=m1.getTypesOfPart(p1);
5847         self.assertEqual([NORM_QUAD4],s);
5848         part2=[2,2,2,1];
5849         p2=DataArrayInt.New()
5850         p2.setValues(part2,4,1)
5851         s=m1.getTypesOfPart(p2);
5852         self.assertEqual([NORM_TRI3],s);
5853         part3=[3,2,1];
5854         p3=DataArrayInt.New()
5855         p3.setValues(part3,3,1)
5856         s=m1.getTypesOfPart(p3);
5857         self.assertEqual(s,[NORM_TRI3,NORM_QUAD4]);
5858         pass
5859
5860     def testUMeshKeepCellIdsByType1(self):
5861         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5862         part1=[0,3,4]
5863         p1=DataArrayInt.New()
5864         p1.setValues(part1,3,1)
5865         p1.setName("p1")
5866         a=m1.keepCellIdsByType(NORM_TRI3,p1);
5867         self.assertEqual("p1",a.getName())
5868         self.assertEqual(1,a.getNumberOfComponents());
5869         self.assertEqual(0,a.getNumberOfTuples());
5870         #
5871         part2=[3,2,0,2,4]
5872         p2=DataArrayInt.New()
5873         p2.setValues(part2,5,1)
5874         p2.setName("p2")
5875         a=m1.keepCellIdsByType(NORM_TRI3,p2);
5876         self.assertEqual("p2",a.getName())
5877         self.assertEqual(1,a.getNumberOfComponents());
5878         self.assertEqual(2,a.getNumberOfTuples());
5879         self.assertEqual(2,a.getIJ(0,0));
5880         self.assertEqual(2,a.getIJ(1,0));
5881         #
5882         a=m1.keepCellIdsByType(NORM_QUAD4,p2);
5883         self.assertEqual("p2",a.getName())
5884         self.assertEqual(1,a.getNumberOfComponents());
5885         self.assertEqual(3,a.getNumberOfTuples());
5886         self.assertEqual(3,a.getIJ(0,0));
5887         self.assertEqual(0,a.getIJ(1,0));
5888         self.assertEqual(4,a.getIJ(2,0));
5889         pass
5890
5891     def testSwigErrorDaIntSelectByTupleId1(self):
5892         a=DataArrayInt.New();
5893         arr1=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
5894         a.setValues(arr1,7,2);
5895         a.setInfoOnComponent(0,"toto");
5896         a.setInfoOnComponent(1,"tata");
5897         #
5898         arr2=[4,2,0,6,5]
5899         b=a.selectByTupleId(arr2);
5900         self.assertEqual(5,b.getNumberOfTuples());
5901         self.assertEqual(2,b.getNumberOfComponents());
5902         self.assertTrue(b.getInfoOnComponent(0)=="toto");
5903         self.assertTrue(b.getInfoOnComponent(1)=="tata");
5904         expected1=[5,15,3,13,1,11,7,17,6,16]
5905         self.assertEqual(expected1,b.getValues())
5906         #
5907         a2=DataArrayInt.New()
5908         a2.setValues(arr2,5,1)
5909         b=a.selectByTupleId(a2);
5910         self.assertEqual(5,b.getNumberOfTuples());
5911         self.assertEqual(2,b.getNumberOfComponents());
5912         self.assertTrue(b.getInfoOnComponent(0)=="toto");
5913         self.assertTrue(b.getInfoOnComponent(1)=="tata");
5914         expected1=[5,15,3,13,1,11,7,17,6,16]
5915         self.assertEqual(expected1,b.getValues())
5916         pass
5917
5918     def testSwigErrorRenum(self):
5919         da=DataArrayDouble.New()
5920         da.setValues([7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.],10,2)
5921         d=DataArrayInt.New()
5922         d.setValues([0,2,3,1,4,5,6,8,7,9],10,1)
5923         da.renumberInPlace(d)
5924         da.renumber(d)
5925         pass
5926
5927     def testSwigGetItem1(self):
5928         da=DataArrayInt.New()
5929         da.alloc(16,3)
5930         da.rearrange(1)
5931         da.iota(7)
5932         da.rearrange(3)
5933         da.setInfoOnComponent(0,"X [m]")
5934         da.setInfoOnComponent(1,"Y [m]")
5935         da.setInfoOnComponent(2,"Z [km]")
5936         da2=da[5:-1]
5937         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())
5938         da2=da[4]
5939         self.assertEqual([19, 20, 21],da2.getValues())
5940         try:
5941             da2=da[4:17]
5942         except InterpKernelException as e:
5943             self.assertTrue(True)
5944         else:
5945             self.assertTrue(False)
5946             pass
5947         da2=da[5:-2,2]
5948         self.assertEqual([24, 27, 30, 33, 36, 39, 42, 45, 48],da2.getValues())
5949         da2=da[5:8,:]
5950         self.assertEqual([22, 23, 24, 25, 26, 27, 28, 29, 30],da2.getValues())
5951         da2=da[:]
5952         self.assertTrue(da2.isEqual(da))
5953         da2=da[:,:]
5954         self.assertTrue(da2.isEqual(da))
5955         try:
5956             da2=da[:,:,:]
5957         except InterpKernelException as e:
5958             self.assertTrue(True)
5959         else:
5960             self.assertTrue(False)
5961             pass
5962         try:
5963             da2=da[5:8,-2]
5964         except InterpKernelException as e:
5965             self.assertTrue(True)
5966         else:
5967             self.assertTrue(False)
5968             pass
5969         da2=da[5:8,:-2]
5970         self.assertEqual([22, 25, 28],da2.getValues())
5971         try:
5972             da2=da[5:-18,2]
5973         except InterpKernelException as e:
5974             self.assertTrue(True)
5975         else:
5976             self.assertTrue(False)
5977             pass
5978         da2=da[5:5,2]
5979         self.assertEqual([],da2.getValues())
5980         pass
5981
5982     def testSwigGetItem2(self):
5983         da=DataArrayDouble.New()
5984         da.alloc(16,3)
5985         da.rearrange(1)
5986         da.iota(7)
5987         da.rearrange(3)
5988         da.setInfoOnComponent(0,"X [m]")
5989         da.setInfoOnComponent(1,"Y [m]")
5990         da.setInfoOnComponent(2,"Z [km]")
5991         da2=da[5:-1]
5992         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())
5993         da2=da[4]
5994         self.assertEqual([19., 20., 21],da2.getValues())
5995         try:
5996             da2=da[4:17]
5997         except InterpKernelException as e:
5998             self.assertTrue(True)
5999         else:
6000             self.assertTrue(False)
6001             pass
6002         da2=da[5:-2,2]
6003         self.assertEqual([24., 27., 30., 33., 36., 39., 42., 45., 48.],da2.getValues())
6004         da2=da[5:8,:]
6005         self.assertEqual([22., 23., 24., 25., 26., 27., 28., 29., 30.],da2.getValues())
6006         da2=da[:]
6007         self.assertTrue(da2.isEqual(da,1e-12))
6008         da2=da[:,:]
6009         self.assertTrue(da2.isEqual(da,1e-12))
6010         try:
6011             da2=da[:,:,:]
6012         except InterpKernelException as e:
6013             self.assertTrue(True)
6014         else:
6015             self.assertTrue(False)
6016             pass
6017         try:
6018             da2=da[5:8,-2]
6019         except InterpKernelException as e:
6020             self.assertTrue(True)
6021         else:
6022             self.assertTrue(False)
6023             pass
6024         da2=da[5:8,:-2]
6025         self.assertEqual([22., 25., 28.],da2.getValues())
6026         try:
6027             da2=da[5:-18,2]
6028         except InterpKernelException as e:
6029             self.assertTrue(True)
6030         else:
6031             self.assertTrue(False)
6032             pass
6033         da2=da[5:5,2]
6034         self.assertEqual([],da2.getValues())
6035         pass
6036
6037     def testSwigSetItem1(self):
6038         da=DataArrayInt.New()
6039         da.alloc(20,1)
6040         da.iota(7)
6041         da.rearrange(5)
6042         da.setInfoOnComponent(0,"X [m]") ; da.setInfoOnComponent(1,"Y [km]") ; da.setInfoOnComponent(2,"Y [m]")
6043         da.setInfoOnComponent(3,"Z [W]") ; da.setInfoOnComponent(4,"ZZ [km]") ;
6044         da[:,2]=3
6045         self.assertEqual([7, 8, 3, 10, 11, 12, 13, 3, 15, 16, 17, 18, 3, 20, 21, 22, 23, 3, 25, 26],da.getValues())
6046         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6047         da[2]=3
6048         self.assertEqual([7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 3, 3, 3, 3, 3, 22, 23, 24, 25, 26],da.getValues())
6049         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6050         da[[0,3]]=-1
6051         self.assertEqual([-1, -1, -1, -1, -1, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, -1, -1, -1, -1, -1],da.getValues())
6052         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6053         da[:,[1,3,4]]=-3
6054         self.assertEqual([7, -3, 9, -3, -3, 12, -3, 14, -3, -3, 17, -3, 19, -3, -3, 22, -3, 24, -3, -3],da.getValues())
6055         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6056         da2=DataArrayInt.New() ; da2.setValues([0,2,3],3,1)
6057         da[da2]=-7
6058         self.assertEqual([-7, -7, -7, -7, -7, 12, 13, 14, 15, 16, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7],da.getValues())
6059         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6060         da[da2,-2:]=-7
6061         self.assertEqual([7, 8, 9, -7, -7, 12, 13, 14, 15, 16, 17, 18, 19, -7, -7, 22, 23, 24, -7, -7],da.getValues())
6062         # Let's test with DAI right hand side
6063         da1=DataArrayInt.New()
6064         da1.setValues([25,26,27,125,126,127],2,3)
6065         #
6066         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6067         da[-2:,1:4]=da1
6068         self.assertEqual([7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 25, 26, 27, 21, 22, 125, 126, 127, 26],da.getValues())
6069         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6070         da[1:,3]=[225,226,227]
6071         self.assertEqual([7, 8, 9, 10, 11, 12, 13, 14, 225, 16, 17, 18, 19, 226, 21, 22, 23, 24, 227, 26],da.getValues())
6072         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6073         da[1,2:]=[225,226,227]
6074         self.assertEqual([7, 8, 9, 10, 11, 12, 13, 225, 226, 227, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26],da.getValues())
6075         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6076         da[da2,-2:]=[88,99,1010,1111,1212,1313]
6077         self.assertEqual([7, 8, 9, 88, 99, 12, 13, 14, 15, 16, 17, 18, 19, 1010, 1111, 22, 23, 24, 1212, 1313],da.getValues())
6078         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6079         da3=DataArrayInt.New(); da3.setValues([88,99,1010,1111,1212,1313],3,2)
6080         da[da2,-2:]=da3
6081         self.assertEqual([7, 8, 9, 88, 99, 12, 13, 14, 15, 16, 17, 18, 19, 1010, 1111, 22, 23, 24, 1212, 1313],da.getValues())
6082         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6083         da[da2,[0,2]]=da3
6084         self.assertEqual([88, 8, 99, 10, 11, 12, 13, 14, 15, 16, 1010, 18, 1111, 20, 21, 1212, 23, 1313, 25, 26],da.getValues())
6085         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6086         da[da2,0:3:2]=da3
6087         self.assertEqual([88, 8, 99, 10, 11, 12, 13, 14, 15, 16, 1010, 18, 1111, 20, 21, 1212, 23, 1313, 25, 26],da.getValues())
6088         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6089         da[da2,0:3:2]=-8
6090         self.assertEqual([-8, 8, -8, 10, 11, 12, 13, 14, 15, 16, -8, 18, -8, 20, 21, -8, 23, -8, 25, 26],da.getValues())
6091         pass
6092
6093     def testSwigSetItem2(self):
6094         da=DataArrayDouble.New()
6095         da.alloc(20,1)
6096         da.iota(7)
6097         da.rearrange(5)
6098         da.setInfoOnComponent(0,"X [m]") ; da.setInfoOnComponent(1,"Y [km]") ; da.setInfoOnComponent(2,"Y [m]")
6099         da.setInfoOnComponent(3,"Z [W]") ; da.setInfoOnComponent(4,"ZZ [km]") ;
6100         da[:,2]=3.
6101         self.assertEqual([7., 8., 3., 10., 11., 12., 13., 3., 15., 16., 17., 18., 3., 20., 21., 22., 23., 3., 25., 26.],da.getValues())
6102         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6103         da[2]=3.
6104         self.assertEqual([7., 8., 9., 10., 11., 12., 13., 14., 15., 16., 3., 3., 3., 3., 3., 22., 23., 24., 25., 26.],da.getValues())
6105         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6106         da[[0,3]]=-1.
6107         self.assertEqual([-1., -1., -1., -1., -1., 12., 13., 14., 15., 16., 17., 18., 19., 20., 21., -1., -1., -1., -1., -1.],da.getValues())
6108         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6109         da[:,[1,3,4]]=-3.
6110         self.assertEqual([7., -3., 9., -3., -3., 12., -3., 14., -3., -3., 17., -3., 19., -3., -3., 22., -3., 24., -3., -3.],da.getValues())
6111         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6112         da2=DataArrayInt.New() ; da2.setValues([0,2,3],3,1)
6113         da[da2]=-7.
6114         self.assertEqual([-7., -7., -7., -7., -7., 12., 13., 14., 15., 16., -7., -7., -7., -7., -7., -7., -7., -7., -7., -7.],da.getValues())
6115         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6116         da[da2,-2:]=-7
6117         self.assertEqual([7., 8., 9., -7., -7., 12., 13., 14., 15., 16., 17., 18., 19., -7., -7., 22., 23., 24., -7., -7.],da.getValues())
6118         # Let's test with DAI right hand side
6119         da1=DataArrayDouble.New()
6120         da1.setValues([25,26,27,125,126,127],2,3)
6121         #
6122         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6123         da[-2:,1:4]=da1
6124         self.assertEqual([7., 8., 9., 10., 11., 12., 13., 14., 15., 16., 17., 25., 26., 27., 21., 22., 125., 126., 127., 26.],da.getValues())
6125         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6126         da[1:,3]=[225.,226.,227.]
6127         self.assertEqual([7., 8., 9., 10., 11., 12., 13., 14., 225., 16., 17., 18., 19., 226., 21., 22., 23., 24., 227., 26.],da.getValues())
6128         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6129         da[1,2:]=[225,226,227]
6130         self.assertEqual([7., 8., 9., 10., 11., 12., 13., 225., 226., 227., 17., 18., 19., 20., 21., 22., 23., 24., 25., 26.],da.getValues())
6131         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6132         da[da2,-2:]=[88,99,1010,1111,1212,1313]
6133         self.assertEqual([7., 8., 9., 88., 99., 12., 13., 14., 15., 16., 17., 18., 19., 1010., 1111., 22., 23., 24., 1212., 1313.],da.getValues())
6134         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6135         da3=DataArrayDouble.New(); da3.setValues([88,99,1010,1111,1212,1313],3,2)
6136         da[da2,-2:]=da3
6137         self.assertEqual([7., 8., 9., 88., 99., 12., 13., 14., 15., 16., 17., 18., 19., 1010., 1111., 22., 23., 24., 1212., 1313.],da.getValues())
6138         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6139         da[da2,[0,2]]=da3
6140         self.assertEqual([88., 8., 99., 10., 11., 12., 13., 14., 15., 16., 1010., 18., 1111., 20., 21., 1212., 23., 1313., 25., 26.],da.getValues())
6141         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6142         da[da2,0:3:2]=da3
6143         self.assertEqual([88., 8., 99., 10., 11., 12., 13., 14., 15., 16., 1010., 18., 1111., 20., 21., 1212., 23., 1313., 25., 26.],da.getValues())
6144         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6145         da[da2,0:3:2]=-8.
6146         self.assertEqual([-8., 8., -8., 10., 11., 12., 13., 14., 15., 16., -8., 18., -8., 20., 21., -8., 23., -8., 25., 26.],da.getValues())
6147         pass
6148
6149     def testSwigDADOp(self):
6150         da=DataArrayDouble.New()
6151         da.alloc(12,1)
6152         da.iota(7.)
6153         da1=DataArrayDouble.New()
6154         da1.alloc(12,1)
6155         da1.iota(8.)
6156         da2=da+da1
6157         self.assertEqual([15., 17., 19., 21., 23., 25., 27., 29., 31., 33., 35., 37.],da2.getValues())
6158         da2=da+3
6159         da3=3+da
6160         self.assertTrue(da2.isEqual(da3,1e-12))
6161         da2=da-1.
6162         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())
6163         da2=1-da
6164         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())
6165         da2=da*3
6166         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())
6167         da2=3.*da
6168         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())
6169         da2=da*da1
6170         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())
6171         da2=da/4.
6172         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())
6173         da3=4./da
6174         da4=da3*da2
6175         self.assertTrue(da4.isUniform(1.,1e-12))
6176         st1=da.getHiddenCppPointer()
6177         da+=1
6178         st2=da.getHiddenCppPointer()
6179         self.assertEqual(st1,st2)
6180         self.assertTrue(da.isEqual(da1,1e-12))
6181         da-=8
6182         st2=da.getHiddenCppPointer()
6183         self.assertEqual(st1,st2)
6184         self.assertEqual(range(12),da.getValues())
6185         da+=da1
6186         st2=da.getHiddenCppPointer()
6187         self.assertEqual(st1,st2)
6188         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())
6189         da*=0.5
6190         st2=da.getHiddenCppPointer()
6191         self.assertEqual(st1,st2)
6192         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())
6193         da*=da1
6194         st2=da.getHiddenCppPointer()
6195         self.assertEqual(st1,st2)
6196         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())
6197         da/=da1
6198         self.assertEqual(st1,st2)
6199         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())
6200         da/=2
6201         st2=da.getHiddenCppPointer()
6202         self.assertEqual(st1,st2)
6203         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())
6204         da.rearrange(3)
6205         da5=DataArrayDouble.New()
6206         da5.setValues([5.,4.,3.,2.],4,1)
6207         da*=da5 # it works with unmathing number of compo
6208         st2=da.getHiddenCppPointer()
6209         self.assertEqual(st1,st2)
6210         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())
6211         #
6212         da.alloc(30,1)
6213         da.iota(7.)
6214         da.rearrange(3)
6215         ids=DataArrayInt.New()
6216         ids.setValues([3,4,7],3,1)
6217         da[ids,:]=[5.,8.,9.]
6218         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())
6219         #
6220         da.rearrange(1) ; da.iota(7) ; da.rearrange(3)
6221         da[ids,[1,2]]=[5,8]
6222         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())
6223         pass
6224
6225     def testSwigDAIOp(self):
6226         da=DataArrayInt.New()
6227         da.alloc(12,1)
6228         da.iota(7)
6229         da1=DataArrayInt.New()
6230         da1.alloc(12,1)
6231         da1.iota(8)
6232         da2=da+da1
6233         self.assertEqual([15,17,19,21,23,25,27,29,31,33,35,37],da2.getValues())
6234         da2=da+3
6235         da3=3+da
6236         self.assertTrue(da2.isEqual(da3))
6237         da2=da-1
6238         self.assertEqual([6,7,8,9,10,11,12,13,14,15,16,17],da2.getValues())
6239         da2=1-da
6240         self.assertEqual([-6,-7,-8,-9,-10,-11,-12,-13,-14,-15,-16,-17],da2.getValues())
6241         da2=da*3
6242         self.assertEqual([21,24,27,30,33,36,39,42,45,48,51,54.0],da2.getValues())
6243         da2=3*da
6244         self.assertEqual([21,24,27,30,33,36,39,42,45,48,51,54.0],da2.getValues())
6245         da2=da*da1
6246         self.assertEqual([56,72,90,110,132,156,182,210,240,272,306,342.0],da2.getValues())
6247         da2=da/4
6248         self.assertEqual([1,2,2,2,2,3,3,3,3,4,4,4],da2.getValues())
6249         da3=4/da
6250         da4=da3*da2
6251         self.assertTrue(da4.isUniform(0))
6252         st1=da.getHiddenCppPointer()
6253         da+=1
6254         st2=da.getHiddenCppPointer()
6255         self.assertEqual(st1,st2)
6256         self.assertTrue(da.isEqual(da1))
6257         da-=8
6258         st2=da.getHiddenCppPointer()
6259         self.assertEqual(st1,st2)
6260         self.assertEqual(range(12),da.getValues())
6261         da+=da1
6262         st2=da.getHiddenCppPointer()
6263         self.assertEqual(st1,st2)
6264         self.assertEqual([8,10,12,14,16,18,20,22,24,26,28,30],da.getValues())
6265         da/=2
6266         st2=da.getHiddenCppPointer()
6267         self.assertEqual(st1,st2)
6268         self.assertEqual([4,5,6,7,8,9,10,11,12,13,14,15],da.getValues())
6269         da*=da1
6270         st2=da.getHiddenCppPointer()
6271         self.assertEqual(st1,st2)
6272         self.assertEqual([32,45,60,77,96,117,140,165,192,221,252,285],da.getValues())
6273         da/=da1
6274         self.assertEqual(st1,st2)
6275         self.assertEqual([4,5,6,7,8,9,10,11,12,13,14,15],da.getValues())
6276         da/=2
6277         st2=da.getHiddenCppPointer()
6278         self.assertEqual(st1,st2)
6279         self.assertEqual([2,2, 3,3, 4,4, 5,5, 6,6, 7,7],da.getValues())
6280         da.rearrange(3)
6281         da5=DataArrayInt.New()
6282         da5.setValues([5,4,3,2],4,1)
6283         da*=da5 # it works with unmathing number of compo
6284         st2=da.getHiddenCppPointer()
6285         self.assertEqual(st1,st2)
6286         self.assertEqual([10,10, 15,12,16,16,15,15, 18,12,14,14],da.getValues())
6287         da%=6
6288         st2=da.getHiddenCppPointer()
6289         self.assertEqual(st1,st2)
6290         self.assertEqual([4,4,3,0,4,4,3,3,0,0,2,2],da.getValues())
6291         #
6292         da.alloc(30,1)
6293         da.iota(7)
6294         da.rearrange(3)
6295         ids=DataArrayInt.New()
6296         ids.setValues([3,4,7],3,1)
6297         da[ids,:]=[5,8,9]
6298         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())
6299         #
6300         da.rearrange(1) ; da.iota(7) ; da.rearrange(3)
6301         da[ids,[1,2]]=[5,8]
6302         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())
6303         pass
6304
6305     def testSwigDAIOp2(self):
6306         da=DataArrayInt.New()
6307         st=da.getHiddenCppPointer()
6308         da.alloc(10,3)
6309         da.rearrange(1)
6310         da.iota(0)
6311         da.rearrange(3)
6312         da[:,1]+=4
6313         da[-2:,2]+=10
6314         da[-2:,2]+=10
6315         da[:,2]+=da[:,0]
6316         da[da[0],:]=7
6317         self.assertEqual(st,da.getHiddenCppPointer())
6318         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])
6319         pass
6320
6321     def testSwigDAIOp3(self):
6322         da=DataArrayInt.New()
6323         self.assertRaises(InterpKernelException,da.__len__)
6324         self.assertRaises(InterpKernelException,da.__int__)
6325         for elt in da:
6326             self.assertTrue(False)
6327             pass
6328         da.alloc(12,3)
6329         da.rearrange(1) ; da.fillWithZero()
6330         l1=list(da)
6331         self.assertEqual(36,len(da));
6332         da.rearrange(3)
6333         tmp=da[0]
6334         self.assertRaises(InterpKernelException,tmp.__int__)
6335         self.assertEqual(12,len(da));
6336         l=list(da)
6337         for elt in enumerate(l):
6338             elt[1][2]=elt[0]
6339             pass
6340         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]
6341         self.assertEqual(ref,da.getValues());
6342         da.rearrange(1)
6343         l=[int(elt) for elt in l1]
6344         self.assertEqual(ref,da.getValues());
6345         self.assertEqual(11,int(da[-1:]))
6346         pass
6347
6348     def testSwigDADOp3(self):
6349         da=DataArrayDouble.New()
6350         self.assertRaises(InterpKernelException,da.__len__)
6351         self.assertRaises(InterpKernelException,da.__float__)
6352         for elt in da:
6353             self.assertTrue(False)
6354             pass
6355         da.alloc(12,3)
6356         da.rearrange(1) ; da.fillWithZero()
6357         l1=list(da)
6358         self.assertEqual(36,len(da));
6359         da.rearrange(3)
6360         tmp=da[0]
6361         self.assertRaises(InterpKernelException,tmp.__float__)
6362         self.assertEqual(12,len(da));
6363         l=list(da)
6364         for elt in enumerate(l):
6365             elt[1][2]=elt[0]
6366             pass
6367         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.]
6368         self.assertEqual(ref,da.getValues());
6369         da.rearrange(1)
6370         l=[float(elt) for elt in l1]
6371         self.assertEqual(ref,da.getValues());
6372         self.assertEqual(11.,float(da[-1:]))
6373         pass
6374
6375     def testSwigDataArrayIntIterator1(self):
6376         da=DataArrayInt.New()
6377         da.alloc(12,1)
6378         da.iota(2)
6379         da.rearrange(3)
6380         # __getitem__ testing
6381         li=[]
6382         for it in da:
6383             li+=it[1:]
6384             pass
6385         self.assertEqual([3, 4, 6, 7, 9, 10, 12, 13],li)
6386         li=[]
6387         for it in da:
6388             li+=[it[-1]]
6389             pass
6390         self.assertEqual([4, 7, 10, 13],li)
6391         li=[]
6392         for it in da:
6393             li+=it[[2,1,0]]
6394             pass
6395         self.assertEqual([4, 3, 2, 7, 6, 5, 10, 9, 8, 13, 12, 11],li)
6396         # __setitem__ testing
6397         da3=da.deepCpy()
6398         da2=DataArrayInt.New()
6399         da2.alloc(12,1)
6400         da2.iota(2002)
6401         da2.rearrange(3)
6402         it2=da2.__iter__()
6403         i=0
6404         for it in da:
6405             pt=it2.next()
6406             it[:]=pt
6407             pass
6408         self.assertTrue(da.isEqual(da2))
6409         da=da3
6410         da3=da.deepCpy()
6411         #
6412         for it in da:
6413             it[:]=5
6414             pass
6415         da.rearrange(1)
6416         self.assertTrue(da.isUniform(5))
6417         da=da3
6418         da3=da.deepCpy()
6419         #
6420         for it in da:
6421             it[:]=[8,9,12]
6422             pass
6423         self.assertEqual([8, 9, 12, 8, 9, 12, 8, 9, 12, 8, 9, 12],da.getValues())
6424         da=da3
6425         da3=da.deepCpy()
6426         #
6427         for it in da:
6428             it[2]=[7]
6429             pass
6430         self.assertEqual([2, 3, 7, 5, 6, 7, 8, 9, 7, 11, 12, 7],da.getValues())
6431         pass
6432
6433     def testSwigDataArrayDoubleIterator1(self):
6434         da=DataArrayDouble.New()
6435         da.alloc(12,1)
6436         da.iota(2)
6437         da.rearrange(3)
6438         # __getitem__ testing
6439         li=[]
6440         for it in da:
6441             li+=it[1:]
6442             pass
6443         self.assertEqual([3, 4, 6, 7, 9, 10, 12, 13],li)
6444         li=[]
6445         for it in da:
6446             li+=[it[-1]]
6447             pass
6448         self.assertEqual([4, 7, 10, 13],li)
6449         li=[]
6450         for it in da:
6451             li+=it[[2,1,0]]
6452             pass
6453         self.assertEqual([4, 3, 2, 7, 6, 5, 10, 9, 8, 13, 12, 11],li)
6454         # __setitem__ testing
6455         da3=da.deepCpy()
6456         da2=DataArrayDouble.New()
6457         da2.alloc(12,1)
6458         da2.iota(2002)
6459         da2.rearrange(3)
6460         it2=da2.__iter__()
6461         i=0
6462         for it in da:
6463             pt=it2.next()
6464             it[:]=pt
6465             pass
6466         self.assertTrue(da.isEqual(da2,1e-12))
6467         da=da3
6468         da3=da.deepCpy()
6469         #
6470         for it in da:
6471             it[:]=5
6472             pass
6473         da.rearrange(1)
6474         self.assertTrue(da.isUniform(5,1e-12))
6475         da=da3
6476         da3=da.deepCpy()
6477         #
6478         for it in da:
6479             it[:]=[8,9,12]
6480             pass
6481         self.assertEqual([8, 9, 12, 8, 9, 12, 8, 9, 12, 8, 9, 12],da.getValues())
6482         da=da3
6483         da3=da.deepCpy()
6484         #
6485         for it in da:
6486             it[2]=[7]
6487             pass
6488         self.assertEqual([2, 3, 7, 5, 6, 7, 8, 9, 7, 11, 12, 7],da.getValues())
6489         pass
6490
6491     def testSwigUMeshIterator1(self):
6492         m=MEDCouplingDataForTest.build2DTargetMesh_1()
6493         li1=[]
6494         li2=[]
6495         for cell in m:
6496             li1+=cell.getAllConn()[1:]
6497             li2+=[cell.getType()]
6498             pass
6499         self.assertEqual(li1,[0, 3, 4, 1, 1, 4, 2, 4, 5, 2, 6, 7, 4, 3, 7, 8, 5, 4])
6500         self.assertEqual(li2,[4, 3, 3, 4, 4])
6501         pass
6502
6503     def testSwigUMeshIterator2(self):
6504         m=MEDCouplingDataForTest.build2DTargetMesh_1()
6505         self.assertRaises(InterpKernelException,m.cellsByType);
6506         m.rearrange2ConsecutiveCellTypes()
6507         li1=[]
6508         li2=[]
6509         li3=[]
6510         for cellsByType in m.cellsByType():
6511             li1.append(cellsByType.getType())
6512             li2.append(cellsByType.getNumberOfElems())
6513             temp=[]
6514             for cell in cellsByType:
6515                 t=[None,None]
6516                 t[0]=cell.getType()
6517                 t[1]=cell.getAllConn()[1:]
6518                 temp.append(t)
6519                 pass
6520             li3.append(temp)
6521             pass
6522         self.assertEqual(li1,[4, 3])
6523         self.assertEqual(li2,[3, 2])
6524         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)]]])
6525         pass
6526
6527     def testDAIAggregateMulti1(self):
6528         a=DataArrayInt.New()
6529         a.setValues(range(4),2,2)
6530         a.setName("aa")
6531         b=DataArrayInt.New()
6532         b.setValues(range(6),3,2)
6533         c=DataArrayInt.Aggregate([a,b])
6534         self.assertEqual(range(4)+range(6),c.getValues())
6535         self.assertEqual("aa",c.getName())
6536         self.assertEqual(5,c.getNumberOfTuples())
6537         self.assertEqual(2,c.getNumberOfComponents())
6538         pass
6539
6540     def testMergeUMeshes2(self):
6541         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6542         m2=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6543         m3=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6544         #
6545         vec1=[0,2,3]
6546         m2_2=m2.buildPartOfMySelf(vec1,False);
6547         vec2=[1,1]
6548         m3_2=m3.buildPartOfMySelf(vec2,False);
6549         #
6550         ms=[m1,m2_2,m3_2];
6551         #
6552         self.assertRaises(InterpKernelException,MEDCouplingUMesh.MergeUMeshes,ms+[None]);
6553         self.assertRaises(InterpKernelException,MEDCouplingUMesh.MergeUMeshes,ms+[3.4])
6554         m4=MEDCouplingUMesh.MergeUMeshes(ms);
6555         m4.checkCoherency();
6556         self.assertEqual(10,m4.getNumberOfCells());
6557         self.assertEqual(20,m4.getNumberOfNodes());
6558         self.assertEqual(45,m4.getMeshLength());
6559         m4bis=MEDCouplingMesh.MergeMeshes(ms);
6560         self.assertTrue(m4.isEqual(m4bis,1e-12))
6561         del m4bis
6562         #
6563         vec3=[0,1,2,3,4]
6564         m4_1=m4.buildPartOfMySelf(vec3,False);
6565         m4_1.setName(m1.getName());
6566         self.assertTrue(m4_1.isEqual(m1,1e-12));
6567         #
6568         vec4=[5,6,7]
6569         m4_2=m4.buildPartOfMySelf(vec4,False);
6570         cellCor,nodeCor=m4_2.checkGeoEquivalWith(m2_2,10,1e-12);
6571         #
6572         vec5=[8,9]
6573         m4_3=m4.buildPartOfMySelf(vec5,False);
6574         self.assertEqual(2,m4_3.getNumberOfCells());
6575         self.assertEqual(3,m4_3.getNumberOfNodes());
6576         m3_2.zipCoords();
6577         m4_3.setName(m3_2.getName());
6578         self.assertTrue(m4_3.isEqual(m3_2,1e-12));
6579         #
6580         pass
6581
6582     def testBuild0DMeshFromCoords1(self):
6583         sourceCoords=[-0.3,-0.3,0., 0.7,-0.3,0., -0.3,0.7,0., 0.7,0.7,0.]
6584         coo=DataArrayDouble.New();
6585         coo.setValues(sourceCoords,4,3);
6586         coo.setName("My0D");
6587         m=MEDCouplingUMesh.Build0DMeshFromCoords(coo);
6588         m.checkCoherency();
6589         self.assertEqual(4,m.getNumberOfNodes());
6590         self.assertEqual(4,m.getNumberOfCells());
6591         self.assertEqual(3,m.getSpaceDimension());
6592         self.assertEqual(0,m.getMeshDimension());
6593         types1=m.getAllTypes();
6594         self.assertEqual([NORM_POINT1],types1);
6595         for i in xrange(4):
6596             conn=m.getNodeIdsOfCell(i);
6597             self.assertEqual([i],conn);
6598             self.assertTrue(NORM_POINT1==m.getTypeOfCell(i));
6599             pass
6600         self.assertEqual(m.getName(),"My0D");
6601         pass
6602
6603     def testDescriptionInMeshTimeUnit1(self):
6604         text1="totoTTEDD";
6605         m=MEDCouplingDataForTest.build2DTargetMesh_1();
6606         m.setDescription(text1);
6607         self.assertEqual(m.getDescription(),text1);
6608         m2=m.deepCpy();
6609         self.assertTrue(m.isEqual(m2,1e-12));
6610         self.assertEqual(m2.getDescription(),text1);
6611         m2.setDescription("ggg");
6612         self.assertTrue(not m.isEqual(m2,1e-12));
6613         #
6614         f=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
6615         f.setTimeUnit(text1);
6616         self.assertEqual(f.getTimeUnit(),text1);
6617         f2=f.deepCpy();
6618         self.assertEqual(f2.getTimeUnit(),text1);
6619         #
6620         pass
6621
6622     def testMultiFields1(self):
6623         mfs=MEDCouplingDataForTest.buildMultiFields_1();
6624         ms=mfs.getMeshes();
6625         dms,refs=mfs.getDifferentMeshes()
6626         das=mfs.getArrays();
6627         das2,refs2=mfs.getDifferentArrays()
6628         self.assertEqual(5,len(mfs.getFields()))
6629         self.assertEqual(1,len(mfs.getFields()[0].getArrays()));
6630         self.assertEqual(2,len(mfs.getFields()[1].getArrays()));
6631         self.assertEqual(1,len(mfs.getFields()[2].getArrays()));
6632         self.assertEqual(1,len(mfs.getFields()[3].getArrays()));
6633         self.assertEqual(1,len(mfs.getFields()[4].getArrays()));
6634         self.assertEqual(5,len(ms));
6635         self.assertEqual(2,len(dms));
6636         self.assertEqual(6,len(das));
6637         self.assertEqual(5,len(das2));
6638         mfs2=mfs.deepCpy();
6639         self.assertTrue(mfs.isEqual(mfs2,1e-12,1e-12))
6640         pass
6641
6642     def testFieldOverTime1(self):
6643         fs=MEDCouplingDataForTest.buildMultiFields_2();
6644         self.assertRaises(InterpKernelException,MEDCouplingFieldOverTime.New,fs);
6645         f4bis=fs[4].buildNewTimeReprFromThis(ONE_TIME,False);
6646         fs[4]=f4bis;
6647         self.assertRaises(InterpKernelException,MEDCouplingFieldOverTime.New,fs);
6648         f4bis.setTime(2.7,20,21);
6649         fot=MEDCouplingFieldOverTime.New(fs);
6650         dt=fot.getDefinitionTimeZone();
6651         hs=dt.getHotSpotsTime();
6652         self.assertEqual(6,len(hs));
6653         expected1=[0.2,0.7,1.2,1.35,1.7,2.7]
6654         for i in xrange(6):
6655             self.assertAlmostEqual(expected1[i],hs[i],12);
6656             pass
6657         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(0.2);
6658         self.assertEqual(0,meshId);
6659         self.assertEqual(0,arrId);
6660         self.assertEqual(0,arrIdInField);
6661         self.assertEqual(0,fieldId);
6662         #
6663         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(0.7);
6664         self.assertEqual(0,meshId);
6665         self.assertEqual(1,arrId);
6666         self.assertEqual(0,arrIdInField);
6667         self.assertEqual(1,fieldId);
6668         #
6669         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeLeft(1.2);#**** WARNING left here
6670         self.assertEqual(0,meshId);
6671         self.assertEqual(2,arrId);
6672         self.assertEqual(1,arrIdInField);
6673         self.assertEqual(1,fieldId);
6674         #
6675         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(1.2);#**** WARNING right again here
6676         self.assertEqual(1,meshId);
6677         self.assertEqual(3,arrId);
6678         self.assertEqual(0,arrIdInField);
6679         self.assertEqual(2,fieldId);
6680         #
6681         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(1.35);
6682         self.assertEqual(1,meshId);
6683         self.assertEqual(3,arrId);
6684         self.assertEqual(0,arrIdInField);
6685         self.assertEqual(2,fieldId);
6686         #
6687         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(1.7);
6688         self.assertEqual(0,meshId);
6689         self.assertEqual(3,arrId);
6690         self.assertEqual(0,arrIdInField);
6691         self.assertEqual(3,fieldId);
6692         #
6693         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(2.7);
6694         self.assertEqual(1,meshId);
6695         self.assertEqual(4,arrId);
6696         self.assertEqual(0,arrIdInField);
6697         self.assertEqual(4,fieldId);
6698         #
6699         dt2=MEDCouplingDefinitionTime();
6700         self.assertTrue(not dt2.isEqual(dt));
6701         dt2.assign(dt);
6702         dt2.assign(dt);#to check memory management
6703         self.assertTrue(dt2.isEqual(dt));
6704         #
6705         dt3=MEDCouplingDefinitionTime();
6706         #
6707         pass
6708
6709     def testDAICheckAndPreparePermutation1(self):
6710         vals1=[9,10,0,6,4,11,3,7];
6711         expect1=[5,6,0,3,2,7,1,4];
6712         vals2=[9,10,0,6,10,11,3,7];
6713         da=DataArrayInt.New();
6714         da.setValues(vals1,8,1);
6715         da2=da.checkAndPreparePermutation();
6716         self.assertEqual(8,da2.getNumberOfTuples());
6717         self.assertEqual(1,da2.getNumberOfComponents());
6718         for i in xrange(8):
6719             self.assertEqual(expect1[i],da2.getIJ(i,0));
6720             pass
6721         #
6722         da=DataArrayInt.New();
6723         da.alloc(8,1);
6724         da.iota(0);
6725         da2=da.checkAndPreparePermutation();
6726         self.assertEqual(8,da2.getNumberOfTuples());
6727         self.assertEqual(1,da2.getNumberOfComponents());
6728         self.assertTrue(da2.isIdentity());
6729         #
6730         da=DataArrayInt.New();
6731         da.alloc(8,1);
6732         da.setValues(vals2,8,1);
6733         self.assertRaises(InterpKernelException,da.checkAndPreparePermutation);
6734         pass
6735
6736     def testDAIChangeSurjectiveFormat1(self):
6737         vals1=[0,3,2,3,2,2,1,2]
6738         expected1=[0,1,2,6,8]
6739         expected2=[0,  6,  2,4,5,7,  1,3]
6740         da=DataArrayInt.New();
6741         da.setValues(vals1,8,1);
6742         #
6743         da2,da2I=da.changeSurjectiveFormat(4);
6744         self.assertEqual(5,da2I.getNumberOfTuples());
6745         self.assertEqual(8,da2.getNumberOfTuples());
6746         self.assertEqual(expected1,da2I.getValues());
6747         self.assertEqual(expected2,da2.getValues());
6748         #
6749         self.assertRaises(InterpKernelException,da.changeSurjectiveFormat,3);
6750         #
6751         pass
6752
6753     def testUMeshGetCellIdsLyingOnNodes1(self):
6754         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6755         nodeIds1=[1,2,3,4,6]
6756         nodeIds2=[6,7]
6757         da=m.getCellIdsLyingOnNodes(nodeIds1,True);
6758         self.assertEqual(1,da.getNumberOfTuples());
6759         self.assertEqual(1,da.getNumberOfComponents());
6760         self.assertEqual(1,da.getIJ(0,0));
6761         da2=DataArrayInt.New()
6762         da2.setValues(nodeIds2,2,1)
6763         da=m.getCellIdsLyingOnNodes(da2,False);
6764         self.assertEqual(2,da.getNumberOfTuples());
6765         self.assertEqual(1,da.getNumberOfComponents());
6766         self.assertEqual(3,da.getIJ(0,0));
6767         self.assertEqual(4,da.getIJ(1,0));
6768         pass
6769
6770     def testUMeshFindCellIdsOnBoundary1(self):
6771         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6772         da5=m.findCellIdsOnBoundary();
6773         self.assertEqual(5,da5.getNumberOfTuples());
6774         self.assertTrue(da5.isIdentity());
6775         pass
6776
6777     def testMeshSetTime1(self):
6778         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6779         m2=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6780         #
6781         self.assertTrue(m1.isEqual(m2,1e-12));
6782         m1.setTime(3.14,6,7);
6783         tmp3,tmp1,tmp2=m1.getTime();
6784         self.assertEqual(6,tmp1);
6785         self.assertEqual(7,tmp2);
6786         self.assertAlmostEqual(3.14,tmp3,12);
6787         self.assertTrue(not m1.isEqual(m2,1e-12));
6788         m2.setTime(3.14,6,7);
6789         self.assertTrue(m1.isEqual(m2,1e-12));
6790         m1.setTimeUnit("ms");
6791         self.assertTrue(m1.getTimeUnit()=="ms");
6792         m1.setTimeUnit("us");
6793         self.assertTrue(m1.getTimeUnit()=="us");
6794         self.assertTrue(not m1.isEqual(m2,1e-12));
6795         m2.setTimeUnit("us");
6796         self.assertTrue(m1.isEqual(m2,1e-12));
6797         m2.setTime(3.14,6,8);
6798         self.assertTrue(not m1.isEqual(m2,1e-12));
6799         m2.setTime(3.14,7,7);
6800         self.assertTrue(not m1.isEqual(m2,1e-12));
6801         m2.setTime(3.15,6,7);
6802         self.assertTrue(not m1.isEqual(m2,1e-12));
6803         #
6804         m1.setTime(10.34,55,12);
6805         m3=m1.deepCpy();
6806         self.assertTrue(m1.isEqual(m3,1e-12));
6807         tmp3,tmp1,tmp2=m3.getTime();
6808         self.assertEqual(55,tmp1);
6809         self.assertEqual(12,tmp2);
6810         self.assertAlmostEqual(10.34,tmp3,12);
6811         #
6812         # testing CMesh
6813         coo1=[0.,1.,2.,3.5]
6814         a=DataArrayDouble.New();
6815         a.setValues(coo1,4,1);
6816         b=MEDCouplingCMesh.New();
6817         b.setCoordsAt(0,a);
6818         #
6819         b.setTime(5.67,8,100);
6820         tmp3,tmp1,tmp2=b.getTime();
6821         self.assertEqual(8,tmp1);
6822         self.assertEqual(100,tmp2);
6823         self.assertAlmostEqual(5.67,tmp3,12);
6824         c=b.deepCpy();
6825         self.assertTrue(c.isEqual(b,1e-12));
6826         tmp3,tmp1,tmp2=c.getTime();
6827         self.assertEqual(8,tmp1);
6828         self.assertEqual(100,tmp2);
6829         self.assertAlmostEqual(5.67,tmp3,12);
6830         pass
6831
6832     def testApplyFuncTwo1(self):
6833         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6834         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
6835         f1.setMesh(m1);
6836         #
6837         vals=[1.,11.,21.,2.,12.,22.,3.,13.,23.,4.,14.,24.,5.,15.,25.]
6838         da=DataArrayDouble.New();
6839         da.setValues(vals,5,3);
6840         f1.setArray(da);
6841         #
6842         self.assertRaises(InterpKernelException,da.applyFunc2,1,"y+z");
6843         da.setInfoOnComponent(0,"x [m]");
6844         da.setInfoOnComponent(1,"y [mm]");
6845         da.setInfoOnComponent(2,"z [km]");
6846
6847         self.assertRaises(InterpKernelException, da.applyFunc2, 1, "x+y+zz+zzz");
6848         self.assertRaises(InterpKernelException, da.applyFunc2, 1, "toto(x+y)");
6849         self.assertRaises(InterpKernelException, da.applyFunc2, 1, "x/0");
6850
6851         da2=da.applyFunc2(1,"y+z");
6852         self.assertEqual(1,da2.getNumberOfComponents());
6853         self.assertEqual(5,da2.getNumberOfTuples());
6854         expected1=[32.,34.,36.,38.,40.]
6855         for i in xrange(5):
6856             self.assertAlmostEqual(expected1[i],da2.getIJ(0,i),12);
6857             pass
6858         da2=da.applyFunc(1,"y+z");
6859         expected2=[12.,14.,16.,18.,20.]
6860         for i in xrange(5):
6861             self.assertAlmostEqual(expected2[i],da2.getIJ(0,i),12);
6862             pass
6863         #
6864         self.assertEqual(3,f1.getNumberOfComponents());
6865         self.assertEqual(5,f1.getNumberOfTuples());
6866         f1.applyFunc2(1,"y+z");
6867         self.assertEqual(1,f1.getNumberOfComponents());
6868         self.assertEqual(5,f1.getNumberOfTuples());
6869         for i in xrange(5):
6870             self.assertAlmostEqual(expected1[i],f1.getArray().getIJ(0,i),12);
6871             pass
6872         #
6873         pass
6874
6875     def testApplyFuncThree1(self):
6876         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6877         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
6878         f1.setMesh(m1);
6879         #
6880         vals=[1.,11.,21.,2.,12.,22.,3.,13.,23.,4.,14.,24.,5.,15.,25.]
6881         da=DataArrayDouble.New();
6882         da.setValues(vals,5,3);
6883         f1.setArray(da);
6884         #
6885         vs=3*[None];
6886         vs[0]="x"; vs[1]="Y"; vs[2]="z";
6887         self.assertRaises(InterpKernelException, da.applyFunc3, 1, vs, "y+z");
6888         self.assertRaises(InterpKernelException, da.applyFunc3, 1, vs, "x+Y+z+zz+zzz");
6889         self.assertRaises(InterpKernelException, da.applyFunc3, 1, vs, "x/0");
6890         vs[1]="y";
6891         da2=da.applyFunc3(1,vs,"y+z");
6892         expected1=[32.,34.,36.,38.,40.]
6893         for i in xrange(5):
6894             self.assertAlmostEqual(expected1[i],da2.getIJ(0,i),12);
6895             pass
6896         self.assertRaises(InterpKernelException, da.applyFunc3, 1, ["x","y","z","a"],"x+a")
6897         f1.setArray(da);
6898         self.assertEqual(3,f1.getNumberOfComponents());
6899         self.assertEqual(5,f1.getNumberOfTuples());
6900         f1.applyFunc3(1,vs,"y+z");
6901         self.assertEqual(1,f1.getNumberOfComponents());
6902         self.assertEqual(5,f1.getNumberOfTuples());
6903         for i in xrange(5):
6904             self.assertAlmostEqual(expected1[i],f1.getArray().getIJ(0,i),12);
6905             pass
6906         pass
6907
6908     def testFillFromAnalyticTwo1(self):
6909         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6910         self.assertRaises(InterpKernelException,m1.fillFromAnalytic2,ON_NODES,1,"y+z");
6911         m1.getCoords().setInfoOnComponent(0,"x [m]");
6912         m1.getCoords().setInfoOnComponent(1,"y");
6913         m1.getCoords().setInfoOnComponent(2,"z");
6914         f1=m1.fillFromAnalytic2(ON_NODES,1,"y+z");
6915         self.assertEqual(1,f1.getNumberOfComponents());
6916         self.assertEqual(9,f1.getNumberOfTuples());
6917         expected1=[0.2, 0.7, 1.2, 0.7, 1.2, 1.7, 1.2, 1.7, 2.2]
6918         for i in xrange(9):
6919             self.assertAlmostEqual(expected1[i],f1.getArray().getIJ(0,i),12);
6920             pass
6921         pass
6922
6923     def testFillFromAnalyticThree1(self):
6924         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6925         vs=3*[None];
6926         vs[0]="x"; vs[1]="Y"; vs[2]="z";
6927         self.assertRaises(InterpKernelException,m1.fillFromAnalytic3,ON_NODES,1,vs,"y+z");
6928         vs[1]="y";
6929         f1=m1.fillFromAnalytic3(ON_NODES,1,vs,"y+z");
6930         self.assertEqual(1,f1.getNumberOfComponents());
6931         self.assertEqual(9,f1.getNumberOfTuples());
6932         expected1=[0.2, 0.7, 1.2, 0.7, 1.2, 1.7, 1.2, 1.7, 2.2]
6933         for i in xrange(9):
6934             self.assertAlmostEqual(expected1[i],f1.getArray().getIJ(0,i),12);
6935             pass
6936         pass
6937
6938     def testDAUnitVar1(self):
6939         da=DataArrayDouble.New();
6940         da.alloc(1,3);
6941         da.setInfoOnComponent(0,"XPS [m]");
6942         st1=da.getVarOnComponent(0);
6943         self.assertTrue(st1=="XPS");
6944         st2=da.getUnitOnComponent(0);
6945         self.assertTrue(st2=="m");
6946         #
6947         da.setInfoOnComponent(0,"XPS         [m]");
6948         st1=da.getVarOnComponent(0);
6949         self.assertTrue(st1=="XPS");
6950         st2=da.getUnitOnComponent(0);
6951         self.assertTrue(st2=="m");
6952         #
6953         da.setInfoOnComponent(0,"XPP         [m]");
6954         st1=da.getVarOnComponent(0);
6955         self.assertTrue(st1=="XPP");
6956         st2=da.getUnitOnComponent(0);
6957         self.assertTrue(st2=="m");
6958         #
6959         da.setInfoOnComponent(0,"XPP kdep  kefer   [ m  ]");
6960         st1=da.getVarOnComponent(0);
6961         self.assertTrue(st1=="XPP kdep  kefer");
6962         st2=da.getUnitOnComponent(0);
6963         self.assertTrue(st2==" m  ");
6964         #
6965         da.setInfoOnComponent(0,"     XPP k[  dep  k]efer   [ m^ 2/s^3*kJ  ]");
6966         st1=da.getVarOnComponent(0);
6967         self.assertTrue(st1=="     XPP k[  dep  k]efer");
6968         st2=da.getUnitOnComponent(0);
6969         self.assertTrue(st2==" m^ 2/s^3*kJ  ");
6970         #
6971         da.setInfoOnComponent(0,"     XPP kefer   ");
6972         st1=da.getVarOnComponent(0);
6973         self.assertTrue(st1=="     XPP kefer   ");
6974         st2=da.getUnitOnComponent(0);
6975         self.assertTrue(st2=="");
6976         #
6977         da.setInfoOnComponent(0,"temperature( bof)");
6978         st1=da.getVarOnComponent(0);
6979         self.assertTrue(st1=="temperature( bof)");
6980         st2=da.getUnitOnComponent(0);
6981         self.assertTrue(st2=="");
6982         #
6983         da.setInfoOnComponent(0,"kkk [m]");
6984         da.setInfoOnComponent(1,"ppp   [m^2/kJ]");
6985         da.setInfoOnComponent(2,"abcde   [MW/s]");
6986         #
6987         vs=da.getVarsOnComponent();
6988         self.assertEqual(3,len(vs));
6989         self.assertTrue(vs[0]=="kkk");
6990         self.assertTrue(vs[1]=="ppp");
6991         self.assertTrue(vs[2]=="abcde");
6992         vs=da.getUnitsOnComponent();
6993         self.assertEqual(3,len(vs));
6994         self.assertTrue(vs[0]=="m");
6995         self.assertTrue(vs[1]=="m^2/kJ");
6996         self.assertTrue(vs[2]=="MW/s");
6997         pass
6998
6999     def testGaussCoordinates1(self):
7000         #Testing 1D cell types
7001         m1=MEDCouplingDataForTest.build1DMultiTypes_1();
7002         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,ONE_TIME);
7003         f.setMesh(m1);
7004         wg1=[0.3];
7005         gsCoo1=[0.2];
7006         refCoo1=[-1.0,1.0];
7007         f.setGaussLocalizationOnType(NORM_SEG2,refCoo1,gsCoo1,wg1);
7008         wg2=wg1;
7009         gsCoo2=[0.2];
7010         refCoo2=[-1.0,1.0,0.0];
7011         f.setGaussLocalizationOnType(NORM_SEG3,refCoo2,gsCoo2,wg2);
7012         #
7013         resToTest=f.getLocalizationOfDiscr();
7014         self.assertEqual(3,resToTest.getNumberOfComponents());
7015         self.assertEqual(2,resToTest.getNumberOfTuples());
7016         expected1=[0.6,0.6,0.6, 0.6,0.6,0.6]
7017         for i in xrange(6):
7018             self.assertAlmostEqual(expected1[i],resToTest.getIJ(0,i),14);
7019             pass
7020         #
7021         #Testing 2D cell types
7022         m2=MEDCouplingDataForTest.build2DMultiTypes_1();
7023         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,ONE_TIME);
7024         f.setMesh(m2);
7025         wg3=[0.3,0.3];
7026         tria3CooGauss=[ 0.1, 0.8, 0.2, 0.7 ]
7027         gsCoo3=tria3CooGauss
7028         tria3CooRef=[ 0.0, 0.0, 1.0 , 0.0, 0.0, 1.0 ]
7029         refCoo3=tria3CooRef;
7030         f.setGaussLocalizationOnType(NORM_TRI3,refCoo3,gsCoo3,wg3);
7031         wg4=[0.3,0.3,0.3];
7032         tria6CooGauss=[ 0.3, 0.2, 0.2, 0.1, 0.2, 0.4 ]
7033         gsCoo4=tria6CooGauss;
7034         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]
7035         refCoo4=tria6CooRef;
7036         f.setGaussLocalizationOnType(NORM_TRI6,refCoo4,gsCoo4,wg4);
7037         wg5=[0.3,0.3,0.3,0.3];
7038         quad4CooGauss=[ 0.3, 0.2, 0.2, 0.1, 0.2, 0.4, 0.15, 0.27 ]
7039         gsCoo5=quad4CooGauss;
7040         quad4CooRef=[-1.0, 1.0, -1.0, -1.0, 1.0, -1.0, 1.0, 1.0]
7041         refCoo5=quad4CooRef;
7042         f.setGaussLocalizationOnType(NORM_QUAD4,refCoo5,gsCoo5,wg5);
7043         wg6=[0.3,0.3,0.3,0.3];
7044         quad8CooGauss=[ 0.34, 0.16, 0.21, 0.3, 0.23, 0.4, 0.14, 0.37 ]
7045         gsCoo6=quad8CooGauss;
7046         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]
7047         refCoo6=quad8CooRef;
7048         f.setGaussLocalizationOnType(NORM_QUAD8,refCoo6,gsCoo6,wg6);
7049         #
7050         resToTest=f.getLocalizationOfDiscr();
7051         self.assertEqual(3,resToTest.getNumberOfComponents());
7052         self.assertEqual(13,resToTest.getNumberOfTuples());#2+3+4+4 gauss points for resp TRI3,TRI6,QUAD4,QUAD8
7053         expected2=[5.1,1.55,0.0, 4.7,1.65,0.0,
7054                    2.32,1.52,0.0, 1.6,1.32,0.0, 3.52,1.26,0.0,#TRI6
7055                    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
7056                    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
7057         for i in xrange(39):
7058             self.assertAlmostEqual(expected2[i],resToTest.getIJ(0,i),14);
7059             pass
7060         #
7061         #Testing 3D cell types
7062         m3=MEDCouplingDataForTest.build3DMultiTypes_1();
7063         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,ONE_TIME);
7064         f.setMesh(m3);
7065         #
7066         wg7=[0.3];
7067         tetra4CooGauss=[0.34, 0.16, 0.21]
7068         gsCoo7=tetra4CooGauss;
7069         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]
7070         refCoo7=tetra4CooRef;
7071         f.setGaussLocalizationOnType(NORM_TETRA4,refCoo7,gsCoo7,wg7);
7072         wg8=[0.3];
7073         tetra10CooGauss=[0.2, 0.3, 0.1]
7074         gsCoo8=tetra10CooGauss;
7075         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]
7076         refCoo8=tetra10CooRef;
7077         f.setGaussLocalizationOnType(NORM_TETRA10,refCoo8,gsCoo8,wg8);
7078         wg9=[0.3];
7079         pyra5CooGauss=[0.2, 0.3, 0.1]
7080         gsCoo9=pyra5CooGauss;
7081         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]
7082         refCoo9=pyra5CooRef;
7083         f.setGaussLocalizationOnType(NORM_PYRA5,refCoo9,gsCoo9,wg9);
7084         wg10=[0.3];
7085         pyra13CooGauss=[0.1, 0.2, 0.7]
7086         gsCoo10=pyra13CooGauss;
7087         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]
7088         refCoo10=pyra13CooRef;
7089         f.setGaussLocalizationOnType(NORM_PYRA13,refCoo10,gsCoo10,wg10);
7090         wg11=[0.3];
7091         penta6CooGauss=[0.2, 0.3, 0.1]
7092         gsCoo11=penta6CooGauss;
7093         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]
7094         refCoo11=penta6CooRef;
7095         f.setGaussLocalizationOnType(NORM_PENTA6,refCoo11,gsCoo11,wg11);
7096         wg12=[0.3];
7097         penta15CooGauss=[0.2, 0.3,0.15]
7098         gsCoo12=penta15CooGauss;
7099         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]
7100         refCoo12=penta15CooRef;
7101         f.setGaussLocalizationOnType(NORM_PENTA15,refCoo12,gsCoo12,wg12);
7102         wg13=[0.3];
7103         hexa8CooGauss=[0.2,0.3,0.15]
7104         gsCoo13=hexa8CooGauss;
7105         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]
7106         refCoo13=hexa8CooRef;
7107         f.setGaussLocalizationOnType(NORM_HEXA8,refCoo13,gsCoo13,wg13);
7108         wg14=[0.3];
7109         hexa20CooGauss=[0.11,0.3,0.55]
7110         gsCoo14=hexa20CooGauss;
7111         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]
7112         refCoo14=hexa20CooRef;
7113         f.setGaussLocalizationOnType(NORM_HEXA20,refCoo14,gsCoo14,wg14);
7114         #
7115         resToTest=f.getLocalizationOfDiscr();
7116         self.assertEqual(3,resToTest.getNumberOfComponents());
7117         self.assertEqual(8,resToTest.getNumberOfTuples());#2+3+4+4 gauss points for resp TRI3,TRI6,QUAD4,QUAD8
7118         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]
7119         for i in xrange(24):
7120             self.assertAlmostEqual(expected3[i],resToTest.getIJ(0,i),14);
7121             pass
7122         #
7123         pass
7124
7125     def testP2Localization1(self):
7126         m=MEDCouplingUMesh.New("testP2",2);
7127         coords=[0.,2.,3.5,0.,4.5,1.5,1.2,0.32,3.4,1.,2.1,2.4]
7128         conn=[0,1,2,3,4,5]
7129         coo=DataArrayDouble.New();
7130         coo.setValues(coords,6,2);
7131         m.setCoords(coo);
7132         m.allocateCells(1);
7133         m.insertNextCell(NORM_TRI6,6,conn[0:6])
7134         m.finishInsertingCells();
7135         #
7136         f=MEDCouplingFieldDouble.New(ON_NODES,ONE_TIME);
7137         f.setMesh(m);
7138         da=DataArrayDouble.New();
7139         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]
7140         da.setValues(vals1,6,3);
7141         f.setArray(da);
7142         #
7143         loc=[2.27,1.3]
7144         locs=f.getValueOnMulti(loc);
7145         expected1=[6.0921164547752236, 7.1921164547752232, 8.2921164547752255]
7146         for i in xrange(3):
7147             self.assertAlmostEqual(expected1[i],locs.getIJ(0,i),12);
7148             pass
7149         pass
7150
7151     def testP2Localization2(self):
7152         m=MEDCouplingUMesh.New("testP2_2",3);
7153         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]
7154         conn=[0,1,2,3,4,5,6,7,8,9]
7155         coo=DataArrayDouble.New();
7156         coo.setValues(coords,10,3);
7157         m.setCoords(coo);
7158         m.allocateCells(1);
7159         m.insertNextCell(NORM_TETRA10,10,conn[0:10])
7160         m.finishInsertingCells();
7161         #
7162         f=MEDCouplingFieldDouble.New(ON_NODES,ONE_TIME);
7163         f.setMesh(m);
7164         da=DataArrayDouble.New();
7165         vals1=[1.1,2.1,3.1,4.1,5.2,6.2,7.2,8.2,9.2,10.2]
7166         da.setValues(vals1,10,1);
7167         f.setArray(da);
7168         #
7169         loc=[0.64637931739890486, -0.16185896817550552, 0.22678966365273748]
7170         locs=f.getValueOnMulti(loc);
7171         expected1=[10.0844021968047]
7172         for i in xrange(1):
7173             self.assertAlmostEqual(expected1[i],locs.getIJ(0,i),12);
7174             pass
7175         pass
7176
7177     def testGetValueOn2(self):
7178         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7179         f=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
7180         f.setMesh(m);
7181         arr=DataArrayDouble.New();
7182         nbOfCells=m.getNumberOfCells();
7183         f.setArray(arr);
7184         values1=[7.,107.,10007.,8.,108.,10008.,9.,109.,10009.,10.,110.,10010.,11.,111.,10011.]
7185         arr.setValues(values1,nbOfCells,3);
7186         loc=[-0.05,-0.05, 0.55,-0.25, 0.55,0.15, -0.05,0.45, 0.45,0.45]
7187         f.checkCoherency();
7188         locs=f.getValueOnMulti(loc);
7189         self.assertEqual(5,locs.getNumberOfTuples());
7190         self.assertEqual(3,locs.getNumberOfComponents());
7191         for j in xrange(15):
7192             self.assertAlmostEqual(values1[j],locs.getIJ(0,j),12);
7193             pass
7194         # Testing ON_NODES
7195         f=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
7196         f.setMesh(m);
7197         arr=DataArrayDouble.New();
7198         nbOfNodes=m.getNumberOfNodes();
7199         f.setArray(arr);
7200         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.]
7201         arr.setValues(values2,nbOfNodes,3);
7202         loc2=[0.5432,-0.2432, 0.5478,0.1528, 0.5432,-0.2432, 0.5432,-0.2432]
7203         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]
7204         f.checkCoherency();
7205         loc3=DataArrayDouble.New()
7206         loc3.setValues(loc2,4,2);
7207         locs=f.getValueOnMulti(loc3);
7208         self.assertEqual(4,locs.getNumberOfTuples());
7209         self.assertEqual(3,locs.getNumberOfComponents());
7210         for i in xrange(12):
7211             self.assertAlmostEqual(expected2[i],locs.getIJ(0,i),12);
7212             pass
7213         #
7214         pass
7215
7216     def testDAIGetIdsNotEqual1(self):
7217         d=DataArrayInt.New();
7218         vals1=[2,3,5,6,8,5,5,6,1,-5]
7219         d.setValues(vals1,10,1);
7220         d2=d.getIdsNotEqual(5);
7221         self.assertEqual(7,d2.getNumberOfTuples());
7222         self.assertEqual(1,d2.getNumberOfComponents());
7223         expected1=[0,1,3,4,7,8,9]
7224         for i in xrange(7):
7225             self.assertEqual(expected1[i],d2.getIJ(0,i));
7226             pass
7227         d.rearrange(2);
7228         self.assertRaises(InterpKernelException,d.getIdsNotEqual,5);
7229         vals2=[-4,5,6]
7230         vals3=vals2;
7231         d.rearrange(1);
7232         d3=d.getIdsNotEqualList(vals3);
7233         self.assertEqual(5,d3.getNumberOfTuples());
7234         self.assertEqual(1,d3.getNumberOfComponents());
7235         expected2=[0,1,4,8,9]
7236         for i in xrange(5):
7237             self.assertEqual(expected2[i],d3.getIJ(0,i));
7238             pass
7239         pass
7240
7241     def testDAIComputeOffsets1(self):
7242         d=DataArrayInt.New();
7243         vals1=[3,5,1,2,0,8]
7244         expected1=[0,3,8,9,11,11]
7245         d.setValues(vals1,6,1);
7246         d.computeOffsets();
7247         self.assertEqual(6,d.getNumberOfTuples());
7248         self.assertEqual(1,d.getNumberOfComponents());
7249         for i in xrange(6):
7250             self.assertEqual(expected1[i],d.getIJ(0,i));
7251             pass
7252         pass
7253
7254     def testUMeshHexagonPrism1(self):
7255         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,
7256                 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];
7257         conn=[1,2,3,4,5,0,7,8,9,10,11,6]
7258         mesh=MEDCouplingUMesh.New("MyFirstHexagonalPrism",3);
7259         coo=DataArrayDouble.New();
7260         coo.setValues(coords,12,3);
7261         mesh.setCoords(coo);
7262         mesh.allocateCells(1);
7263         mesh.insertNextCell(NORM_HEXGP12,12,conn[0:12])
7264         mesh.finishInsertingCells();
7265         #
7266         mesh.checkCoherency();
7267         vols=mesh.getMeasureField(False);
7268         self.assertEqual(1,vols.getNumberOfTuples());
7269         self.assertEqual(1,vols.getNumberOfComponents());
7270         self.assertAlmostEqual(-5.196152422706632,vols.getIJ(0,0),12);
7271         bary=mesh.getBarycenterAndOwner();
7272         self.assertEqual(1,bary.getNumberOfTuples());
7273         self.assertEqual(3,bary.getNumberOfComponents());
7274         expected1=[0.,0.,1.]
7275         for i in xrange(3):
7276             self.assertAlmostEqual(expected1[i],bary.getIJ(0,i),12);
7277             pass
7278         d1=DataArrayInt.New();
7279         d2=DataArrayInt.New();
7280         d3=DataArrayInt.New();
7281         d4=DataArrayInt.New();
7282         m2=mesh.buildDescendingConnectivity(d1,d2,d3,d4);
7283         self.assertEqual(8,m2.getNumberOfCells());
7284         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]];
7285         expected2=[NORM_POLYGON, NORM_POLYGON, NORM_QUAD4, NORM_QUAD4, NORM_QUAD4, NORM_QUAD4, NORM_QUAD4, NORM_QUAD4];
7286         expected3=[6,6,4,4,4,4,4,4]
7287         for i in xrange(8):
7288             self.assertTrue(m2.getTypeOfCell(i)==expected2[i]);
7289             v=m2.getNodeIdsOfCell(i);
7290             self.assertTrue(len(v)==expected3[i]);
7291             self.assertEqual(expected4[i],v);
7292         #
7293         mesh.convertAllToPoly();
7294         self.assertTrue(NORM_POLYHED==mesh.getTypeOfCell(0));
7295         mesh.unPolyze();
7296         self.assertTrue(NORM_HEXGP12==mesh.getTypeOfCell(0));
7297         self.assertEqual(13,mesh.getMeshLength());
7298         #
7299         pass
7300
7301     def testDADCheckIsMonotonic(self):
7302         da=DataArrayDouble.New();
7303         da.setValues([-1.,1.01,2.03,6.],2,2);
7304         self.assertRaises(InterpKernelException,da.isMonotonic,True,1e-12);
7305         da.rearrange(1);
7306         self.assertTrue(da.isMonotonic(True,1e-12));
7307         da.checkMonotonic(True,1e-12);
7308         da.setIJ(2,0,6.1);
7309         self.assertTrue(not da.isMonotonic(True,1e-12));
7310         self.assertRaises(InterpKernelException,da.checkMonotonic,True,1e-12);
7311         da.setIJ(2,0,5.99);
7312         self.assertTrue(da.isMonotonic(True,1e-12));
7313         self.assertTrue(not da.isMonotonic(True,1e-1));
7314         pass
7315
7316     def testCheckCoherencyDeeper1(self):
7317         m=MEDCouplingDataForTest.build3DSourceMesh_1();
7318         m.checkCoherency();
7319         m.checkCoherency1();
7320         m.getNodalConnectivity().setIJ(8,0,-1);
7321         m.checkCoherency();
7322         self.assertRaises(InterpKernelException,m.checkCoherency1);
7323         m.getNodalConnectivity().setIJ(8,0,-6);
7324         m.checkCoherency();
7325         self.assertRaises(InterpKernelException,m.checkCoherency1);
7326         m.getNodalConnectivity().setIJ(8,0,9);#9>=NbOfNodes
7327         m.checkCoherency();
7328         self.assertRaises(InterpKernelException,m.checkCoherency1);
7329         m.getNodalConnectivity().setIJ(8,0,8);#OK
7330         m.checkCoherency();
7331         m.checkCoherency1();
7332         elts=[1,5]
7333         m.convertToPolyTypes(elts);
7334         m.checkCoherency();
7335         m.checkCoherency1();
7336         m.getNodalConnectivity().setIJ(2,0,9);#9>=NbOfNodes
7337         m.checkCoherency();
7338         self.assertRaises(InterpKernelException,m.checkCoherency1);
7339         m.getNodalConnectivity().setIJ(2,0,-3);
7340         m.checkCoherency();
7341         self.assertRaises(InterpKernelException,m.checkCoherency1);
7342         m.getNodalConnectivity().setIJ(2,0,-1);
7343         m.checkCoherency();
7344         self.assertRaises(InterpKernelException,m.checkCoherency1);#Throw because cell#0 is not a polyhedron
7345         m.getNodalConnectivity().setIJ(2,0,4);
7346         m.checkCoherency();
7347         m.checkCoherency1();
7348         m.getNodalConnectivity().setIJ(7,0,-1);
7349         m.checkCoherency();
7350         m.checkCoherency1();#OK because we are in polyhedron connec
7351         m.getNodalConnectivity().setIJ(36,0,14);
7352         m.checkCoherency();
7353         self.assertRaises(InterpKernelException,m.checkCoherency1);#Throw beacause now cell 5 is a TETRA4 (14) so mimatch of number index and static type.
7354         pass
7355
7356     def testUnPolyze2(self):
7357         m=MEDCouplingUMesh.New("jjj",3);
7358         coo=DataArrayDouble.New();
7359         coo.alloc(4,3);
7360         coo.rearrange(1);
7361         coo.iota(0);
7362         coo.rearrange(3);
7363         m.setCoords(coo);
7364         m.allocateCells(2);
7365         m.insertNextCell(NORM_TETRA4,4,[0,1,2,3]);
7366         m.insertNextCell(NORM_TETRA4,4,[0,1,2,3]);
7367         m.finishInsertingCells();
7368         m2=MEDCouplingUMesh.MergeUMeshesOnSameCoords(4*[m]);
7369         m2.convertToPolyTypes([2]);
7370         m2.unPolyze();
7371         self.assertEqual(NORM_TETRA4,m2.getTypeOfCell(2));
7372         self.assertEqual(40,m2.getMeshLength());
7373         temp2=m2.getNodeIdsOfCell(2);
7374         self.assertEqual(temp2,[0,1,2,3]);
7375         m2.checkCoherency1();
7376         m3=m2.deepCpy();
7377         m2.unPolyze();
7378         self.assertTrue(m3.isEqual(m2,1e-12));
7379         pass
7380
7381     def testDACpyFrom1(self):
7382         d=DataArrayDouble.New();
7383         d.alloc(12,1);
7384         d.iota(14.);
7385         d.rearrange(3);
7386         d.setName("Toto");
7387         d.setInfoOnComponent(0,"X [m]");
7388         d.setInfoOnComponent(1,"Y [m]");
7389         d.setInfoOnComponent(2,"Z [m]");
7390         #
7391         d1=DataArrayDouble.New();
7392         self.assertTrue(not d.isEqual(d1,1e-12));
7393         d1.cpyFrom(d);
7394         self.assertTrue(d.isEqual(d1,1e-12));
7395         d1.cpyFrom(d);
7396         self.assertTrue(d.isEqual(d1,1e-12));
7397         d1.rearrange(2);
7398         self.assertTrue(not d.isEqual(d1,1e-12));
7399         d1.cpyFrom(d);
7400         self.assertTrue(d.isEqual(d1,1e-12));
7401         #
7402         d2=d.convertToIntArr();
7403         d4=DataArrayInt.New();
7404         self.assertTrue(not d2.isEqual(d4));
7405         d4.cpyFrom(d2);
7406         self.assertTrue(d2.isEqual(d4));
7407         d4.cpyFrom(d2);
7408         self.assertTrue(d2.isEqual(d4));
7409         d4.rearrange(2);
7410         self.assertTrue(not d2.isEqual(d4));
7411         d4.cpyFrom(d2);
7412         self.assertTrue(d2.isEqual(d4));
7413         pass
7414
7415     def testDAITransformWithIndArr1(self):
7416         tab1=[17,18,22,19]
7417         tab2=[0,1,1,3,3,0,1,3,2,2,3,0]
7418         expected=[17,18,18,19,19,17,18,19,22,22,19,17]
7419         d=DataArrayInt.New();
7420         d.setValues(tab1,4,1);
7421         d1=DataArrayInt.New();
7422         d1.setValues(tab2,12,1);
7423         d2=d1[:]
7424         #
7425         d1.transformWithIndArr(d);
7426         self.assertEqual(12,d1.getNumberOfTuples());
7427         self.assertEqual(1,d1.getNumberOfComponents());
7428         for i in xrange(12):
7429             self.assertEqual(expected[i],d1.getIJ(i,0));
7430             pass
7431         #
7432         d1=d2
7433         d1.transformWithIndArr(tab1)
7434         self.assertEqual(12,d1.getNumberOfTuples());
7435         self.assertEqual(1,d1.getNumberOfComponents());
7436         for i in xrange(12):
7437             self.assertEqual(expected[i],d1.getIJ(i,0));
7438             pass
7439         pass
7440
7441     def testDAIBuildPermArrPerLevel1(self):
7442         arr=[2,0,1,1,0,1,2,0,1,1,0,0]
7443         expected1=[10,0,5,6,1,7,11,2,8,9,3,4]
7444         da=DataArrayInt.New();
7445         da.setValues(arr,12,1);
7446         da2=da.buildPermArrPerLevel();
7447         self.assertEqual(12,da2.getNumberOfTuples());
7448         self.assertEqual(1,da2.getNumberOfComponents());
7449         for i in xrange(12):
7450             self.assertEqual(expected1[i],da2.getIJ(i,0));
7451             pass
7452         pass
7453
7454     def testDAIOperations1(self):
7455         arr1=[-1,-2,4,7,3,2,6,6,4,3,0,1]
7456         da=DataArrayInt.New();
7457         da.setValues(arr1,4,3);
7458         da1=DataArrayInt.New();
7459         da1.alloc(12,1);
7460         da1.iota(2);
7461         self.assertRaises(InterpKernelException,DataArrayInt.Add,da,da1);#not same number of tuples/Components
7462         da1.rearrange(3);
7463         da2=DataArrayInt.Add(da,da1);
7464         self.assertEqual(4,da2.getNumberOfTuples());
7465         self.assertEqual(3,da2.getNumberOfComponents());
7466         expected1=[1,1,8,12,9,9,14,15,14,14,12,14]
7467         for i in xrange(12):
7468             self.assertEqual(expected1[i],da2.getIJ(0,i));
7469             pass
7470         da1.substractEqual(da);
7471         expected2=[3,5,0,-2,3,5,2,3,6,8,12,12]
7472         for i in xrange(12):
7473             self.assertEqual(expected2[i],da1.getIJ(0,i));
7474             pass
7475         da1.rearrange(1); da1.iota(2); da1.rearrange(3);
7476         da1.addEqual(da);
7477         for i in xrange(12):
7478             self.assertEqual(expected1[i],da1.getIJ(0,i));
7479             pass
7480         da1.rearrange(1); da1.iota(2); da1.rearrange(3);
7481         da2=DataArrayInt.Multiply(da,da1);
7482         self.assertEqual(4,da2.getNumberOfTuples());
7483         self.assertEqual(3,da2.getNumberOfComponents());
7484         expected3=[-2,-6,16,35,18,14,48,54,40,33,0,13]
7485         for i in xrange(12):
7486             self.assertEqual(expected3[i],da2.getIJ(0,i));
7487             pass
7488         da.divideEqual(da1);
7489         self.assertEqual(4,da.getNumberOfTuples());
7490         self.assertEqual(3,da.getNumberOfComponents());
7491         expected4=[0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0]
7492         for i in xrange(12):
7493             self.assertEqual(expected4[i],da.getIJ(0,i));
7494             pass
7495         da.setValues(arr1,4,3);
7496         da1.multiplyEqual(da);
7497         self.assertEqual(4,da1.getNumberOfTuples());
7498         self.assertEqual(3,da1.getNumberOfComponents());
7499         for i in xrange(12):
7500             self.assertEqual(expected3[i],da1.getIJ(0,i));
7501             pass
7502         da1.rearrange(1); da1.iota(2); da1.rearrange(3);
7503         da2=DataArrayInt.Divide(da,da1);
7504         self.assertEqual(4,da2.getNumberOfTuples());
7505         self.assertEqual(3,da2.getNumberOfComponents());
7506         for i in xrange(12):
7507             self.assertEqual(expected4[i],da2.getIJ(0,i));
7508             pass
7509         da1.applyInv(321);
7510         self.assertEqual(4,da1.getNumberOfTuples());
7511         self.assertEqual(3,da1.getNumberOfComponents());
7512         expected5=[160,107,80,64,53,45,40,35,32,29,26,24]
7513         for i in xrange(12):
7514             self.assertEqual(expected5[i],da1.getIJ(0,i));
7515             pass
7516         da1.applyDivideBy(2);
7517         self.assertEqual(4,da1.getNumberOfTuples());
7518         self.assertEqual(3,da1.getNumberOfComponents());
7519         expected6=[80,53,40,32,26,22,20,17,16,14,13,12]
7520         for i in xrange(12):
7521             self.assertEqual(expected6[i],da1.getIJ(0,i));
7522             pass
7523         expected7=[3,4,5,4,5,1,6,3,2,0,6,5]
7524         da1.applyModulus(7);
7525         for i in xrange(12):
7526             self.assertEqual(expected7[i],da1.getIJ(0,i));
7527             pass
7528         da1.applyLin(1,1);
7529         expected8=[3,3,3,3,3,1,3,3,0,0,3,3]
7530         da1.applyRModulus(3);
7531         for i in xrange(12):
7532             self.assertEqual(expected8[i],da1.getIJ(0,i));
7533             pass
7534         pass
7535
7536     def testEmulateMEDMEMBDC1(self):
7537         m,m1=MEDCouplingDataForTest.buildPointe_1();
7538         m2,da1,da2,da3,da4,da5,da0=m.emulateMEDMEMBDC(m1)
7539         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]
7540         expected1=[1,32,29,23,41,36]
7541         self.assertEqual(47,da0.getNumberOfTuples());
7542         self.assertEqual(1,da0.getNumberOfComponents());
7543         for i in xrange(47):
7544             self.assertEqual(expected0[i],da0.getIJ(0,i));
7545             pass
7546         self.assertEqual(6,da5.getNumberOfTuples());
7547         self.assertEqual(1,da5.getNumberOfComponents());
7548         for i in xrange(6):
7549             self.assertEqual(expected1[i],da5.getIJ(0,i));
7550             pass
7551         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]
7552         self.assertEqual(70,da1.getNumberOfTuples());
7553         self.assertEqual(1,da1.getNumberOfComponents());
7554         for i in xrange(70):
7555             self.assertEqual(expected2[i],da1.getIJ(0,i));
7556             pass
7557         expected3=[0,4,8,12,16,20,24,28,32,36,40,44,48,53,58,64,70]
7558         self.assertEqual(17,da2.getNumberOfTuples());
7559         self.assertEqual(1,da2.getNumberOfComponents());
7560         for i in xrange(17):
7561             self.assertEqual(expected3[i],da2.getIJ(0,i));
7562             pass
7563         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]
7564         #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];
7565         self.assertEqual(48,da4.getNumberOfTuples());
7566         self.assertEqual(1,da4.getNumberOfComponents());
7567         for i in xrange(48):
7568             self.assertEqual(expected4[i],da4.getIJ(0,i));
7569             pass
7570         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]
7571         self.assertEqual(70,da3.getNumberOfTuples());
7572         self.assertEqual(1,da3.getNumberOfComponents());
7573         for i in xrange(70):
7574             self.assertEqual(expected5[i],da3.getIJ(0,i));
7575             pass
7576         pass
7577
7578     def testGetLevArrPerCellTypes1(self):
7579         m,m1=MEDCouplingDataForTest.buildPointe_1();
7580         m1,d0,d1,d2,d3=m.buildDescendingConnectivity();
7581         order=[NORM_TRI3,NORM_QUAD4];
7582         da0,da1=m1.getLevArrPerCellTypes(order);
7583         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]
7584         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]
7585         self.assertEqual(47,da0.getNumberOfTuples());
7586         self.assertEqual(1,da0.getNumberOfComponents());
7587         for i in xrange(47):
7588             self.assertEqual(expected0[i],da0.getIJ(0,i));
7589             pass
7590         self.assertEqual(2,da1.getNumberOfTuples());
7591         self.assertEqual(1,da1.getNumberOfComponents());
7592         self.assertEqual(36,da1.getIJ(0,0));#36 TRI3
7593         self.assertEqual(11,da1.getIJ(1,0));#11 QUAD4
7594         #
7595         da2=da0.buildPermArrPerLevel();
7596         #
7597         self.assertEqual(47,da2.getNumberOfTuples());
7598         self.assertEqual(1,da2.getNumberOfComponents());
7599         for i in xrange(47):
7600             self.assertEqual(expected1[i],da2.getIJ(0,i));
7601             pass
7602         pass
7603
7604     def testSortCellsInMEDFileFrmt1(self):
7605         m,m1=MEDCouplingDataForTest.buildPointe_1();
7606         m2=m.deepCpy()
7607         da=DataArrayInt.New()
7608         da.setValues([0,1,2,14,3,12,4,5,15,6,7,8,9,10,11,13],16,1)
7609         daa=da.invertArrayN2O2O2N(16)
7610         m.renumberCells(daa,False)
7611         da2=m.sortCellsInMEDFileFrmt()
7612         self.assertEqual(da2.getValues(),[0,1,2,14,3,12,4,5,15,6,7,8,9,10,11,13])
7613         self.assertTrue(m.isEqual(m2,1e-12))
7614         self.assertTrue(da.isEqual(da2))
7615         pass
7616
7617     def testBuildPartAndReduceNodes1(self):
7618         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7619         arr=[1,0]
7620         m2,da=m.buildPartAndReduceNodes(arr);
7621         self.assertEqual(5,m2.getNumberOfNodes());
7622         self.assertEqual(2,m2.getNumberOfCells());
7623         f=m2.getMeasureField(True);
7624         self.assertAlmostEqual(0.125,f.getArray().getIJ(0,0),12);
7625         self.assertAlmostEqual(0.25,f.getArray().getIJ(1,0),12);
7626         #
7627         arr2=DataArrayInt.New()
7628         arr2.setValues(arr,2,1)
7629         m2,da=m.buildPartAndReduceNodes(arr2);
7630         self.assertEqual(5,m2.getNumberOfNodes());
7631         self.assertEqual(2,m2.getNumberOfCells());
7632         f=m2.getMeasureField(True);
7633         self.assertAlmostEqual(0.125,f.getArray().getIJ(0,0),12);
7634         self.assertAlmostEqual(0.25,f.getArray().getIJ(1,0),12);
7635         pass
7636
7637     def testDAITransformWithIndArrR1(self):
7638         tab1=[2,4,5,3,6,7]
7639         tab2=[-1,-1,0,1,2,3,4,5,-1,-1,-1,-1]
7640         expected=[0,3,1,2,4,5]
7641         d=DataArrayInt.New();
7642         d.setValues(tab1,6,1);
7643         d1=DataArrayInt.New();
7644         d1.setValues(tab2,12,1);
7645         d2=d1[:]
7646         #
7647         d3=d.transformWithIndArrR(d1);
7648         self.assertEqual(6,d3.getNumberOfTuples());
7649         self.assertEqual(1,d3.getNumberOfComponents());
7650         for i in xrange(6):
7651             self.assertEqual(expected[i],d3.getIJ(i,0));
7652             pass
7653         #
7654         d1=d2
7655         d3=d.transformWithIndArrR(tab2)
7656         self.assertEqual(6,d3.getNumberOfTuples());
7657         self.assertEqual(1,d3.getNumberOfComponents());
7658         for i in xrange(6):
7659             self.assertEqual(expected[i],d3.getIJ(i,0));
7660             pass
7661         pass
7662
7663     def testDAISplitByValueRange1(self):
7664         val1=[6,5,0,3,2,7,8,1,4]
7665         val2=[0,4,9]
7666         d=DataArrayInt.New();
7667         d.setValues(val1,9,1);
7668         e,f,g=d.splitByValueRange(val2);
7669         self.assertEqual(9,e.getNumberOfTuples());
7670         self.assertEqual(1,e.getNumberOfComponents());
7671         self.assertEqual(9,f.getNumberOfTuples());
7672         self.assertEqual(1,f.getNumberOfComponents());
7673         self.assertEqual(2,g.getNumberOfTuples());
7674         self.assertEqual(1,g.getNumberOfComponents());
7675         #
7676         expected1=[1,1,0,0,0,1,1,0,1]
7677         expected2=[2,1,0,3,2,3,4,1,0]
7678         for i in xrange(9):
7679             self.assertEqual(expected1[i],e.getIJ(i,0));
7680             self.assertEqual(expected2[i],f.getIJ(i,0));
7681             pass
7682         self.assertEqual(0,g.getIJ(0,0));
7683         self.assertEqual(1,g.getIJ(1,0));
7684         #
7685         d.setIJ(6,0,9);
7686         self.assertRaises(InterpKernelException,d.splitByValueRange,val2);
7687         pass
7688
7689     def testUMeshSplitProfilePerType1(self):
7690         val0=[2,0,1,3,4]
7691         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7692         m.renumberCells(val0,False);
7693         #
7694         val1=[0,2,3]
7695         d=DataArrayInt.New();
7696         d.setValues(val1,3,1);
7697         d.setName("sup")
7698         code,idsInPflPerType,pfls=m.splitProfilePerType(d);
7699         self.assertEqual(6,len(code));
7700         self.assertEqual(2,len(idsInPflPerType));
7701         expected1=[3,1,0, 4,2,1]
7702         for i in xrange(6):
7703             self.assertEqual(expected1[i],code[i]);
7704             pass
7705         self.assertEqual(2,len(idsInPflPerType));
7706         self.assertEqual(1,idsInPflPerType[0].getNumberOfTuples());
7707         self.assertEqual(0,idsInPflPerType[0].getIJ(0,0));
7708         self.assertEqual(2,idsInPflPerType[1].getNumberOfTuples());
7709         self.assertEqual(1,idsInPflPerType[1].getIJ(0,0));
7710         self.assertEqual(2,idsInPflPerType[1].getIJ(1,0));
7711         #
7712         self.assertEqual(2,len(pfls));
7713         self.assertEqual("sup",pfls[0].getName())
7714         self.assertEqual(1,pfls[0].getNumberOfTuples());
7715         self.assertEqual(0,pfls[0].getIJ(0,0));
7716         self.assertEqual("sup",pfls[1].getName())
7717         self.assertEqual(2,pfls[1].getNumberOfTuples());
7718         self.assertEqual(0,pfls[1].getIJ(0,0));
7719         self.assertEqual(1,pfls[1].getIJ(1,0));
7720         #
7721         val2=[0,2,3,4]
7722         d=DataArrayInt.New();
7723         d.setValues(val2,4,1);
7724         code,idsInPflPerType,pfls=m.splitProfilePerType(d);
7725         self.assertEqual(6,len(code));
7726         self.assertEqual(2,len(idsInPflPerType));
7727         expected2=[3,1,0, 4,3,-1]
7728         for i in xrange(6):
7729             self.assertEqual(expected2[i],code[i]);
7730             pass
7731         self.assertEqual(2,len(idsInPflPerType));
7732         self.assertEqual(1,idsInPflPerType[0].getNumberOfTuples());
7733         self.assertEqual(0,idsInPflPerType[0].getIJ(0,0));
7734         self.assertEqual(3,idsInPflPerType[1].getNumberOfTuples());
7735         self.assertEqual(1,idsInPflPerType[1].getIJ(0,0));
7736         self.assertEqual(2,idsInPflPerType[1].getIJ(1,0));
7737         self.assertEqual(3,idsInPflPerType[1].getIJ(2,0));
7738         #
7739         self.assertEqual(1,len(pfls));
7740         self.assertEqual(1,pfls[0].getNumberOfTuples());
7741         self.assertEqual(0,pfls[0].getIJ(0,0));
7742         #
7743         val3=[1,0,2]
7744         d=DataArrayInt.New();
7745         d.setValues(val3,3,1);
7746         code,idsInPflPerType,pfls=m.splitProfilePerType(d);
7747         self.assertEqual(6,len(code));
7748         self.assertEqual(2,len(idsInPflPerType));
7749         expected3=[3,2,0, 4,1,1]
7750         for i in xrange(6):
7751             self.assertEqual(expected3[i],code[i]);
7752             pass
7753         self.assertEqual(2,len(idsInPflPerType));
7754         self.assertEqual(2,idsInPflPerType[0].getNumberOfTuples());
7755         self.assertEqual(0,idsInPflPerType[0].getIJ(0,0));
7756         self.assertEqual(1,idsInPflPerType[0].getIJ(1,0));
7757         self.assertEqual(1,idsInPflPerType[1].getNumberOfTuples());
7758         self.assertEqual(2,idsInPflPerType[1].getIJ(0,0));
7759         #
7760         self.assertEqual(2,len(pfls));
7761         self.assertEqual(2,pfls[0].getNumberOfTuples());
7762         self.assertEqual(1,pfls[0].getIJ(0,0));
7763         self.assertEqual(0,pfls[0].getIJ(1,0));
7764         self.assertEqual(0,pfls[1].getIJ(0,0));
7765         #
7766         val4=[3,4]
7767         d=DataArrayInt.New();
7768         d.setValues(val4,2,1);
7769         code,idsInPflPerType,pfls=m.splitProfilePerType(d);
7770         self.assertEqual(3,len(code));
7771         self.assertEqual(1,len(idsInPflPerType));
7772         expected4=[4,2,0]
7773         for i in xrange(3):
7774             self.assertEqual(expected4[i],code[i]);
7775             pass
7776         self.assertEqual(1,len(idsInPflPerType));
7777         self.assertEqual(2,idsInPflPerType[0].getNumberOfTuples());
7778         self.assertEqual(0,idsInPflPerType[0].getIJ(0,0));
7779         self.assertEqual(1,idsInPflPerType[0].getIJ(1,0));
7780         #
7781         self.assertEqual(1,len(pfls));
7782         self.assertEqual(2,pfls[0].getNumberOfTuples());
7783         self.assertEqual(1,pfls[0].getIJ(0,0));
7784         self.assertEqual(2,pfls[0].getIJ(1,0));
7785         pass
7786
7787     def testDAIBuildExplicitArrByRanges1(self):
7788         d=DataArrayInt.New();
7789         vals1=[0,2,3]
7790         d.setValues(vals1,3,1);
7791         e=DataArrayInt.New();
7792         vals2=[0,3,6,10,14,20]
7793         e.setValues(vals2,6,1);
7794         #
7795         f=d.buildExplicitArrByRanges(e);
7796         self.assertEqual(11,f.getNumberOfTuples());
7797         self.assertEqual(1,f.getNumberOfComponents());
7798         expected1=[0,1,2,6,7,8,9,10,11,12,13]
7799         for i in xrange(11):
7800             self.assertEqual(expected1[i],f.getIJ(i,0));
7801             pass
7802         pass
7803
7804     def testDAIComputeOffsets2(self):
7805         d=DataArrayInt.New();
7806         vals1=[3,5,1,2,0,8]
7807         expected1=[0,3,8,9,11,11,19]
7808         d.setValues(vals1,6,1);
7809         d.computeOffsets2();
7810         self.assertEqual(7,d.getNumberOfTuples());
7811         self.assertEqual(1,d.getNumberOfComponents());
7812         for i in xrange(7):
7813             self.assertEqual(expected1[i],d.getIJ(0,i));
7814             pass
7815         pass
7816
7817     def testMergeField3(self):
7818         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7819         m.getCoords().setInfoOnComponent(0,"x [m]");
7820         m.getCoords().setInfoOnComponent(1,"z [km]");
7821         m.setName("m");
7822         m.setDescription("desc");
7823         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
7824         f1.setName("f1");
7825         f1.setMesh(m);
7826         arr=DataArrayDouble.New();
7827         arr.alloc(5,2);
7828         arr.setInfoOnComponent(0,"X [m]");
7829         arr.setInfoOnComponent(1,"YY [mm]");
7830         arr.fillWithValue(2.);
7831         f1.setArray(arr);
7832         #
7833         f2=MEDCouplingFieldDouble.MergeFields([f1]);
7834         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
7835         #
7836         pass
7837
7838     def testGetDistributionOfTypes1(self):
7839         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7840         tab1=[2,0,1,3,4]
7841         self.assertRaises(InterpKernelException,m.getDistributionOfTypes);
7842         m.renumberCells(tab1,False);
7843         code=m.getDistributionOfTypes();
7844         self.assertEqual(2,len(code));
7845         self.assertEqual(3,code[0][0]);
7846         self.assertEqual(2,code[0][1]);
7847         self.assertEqual(0,code[0][2]);
7848         self.assertEqual(4,code[1][0]);
7849         self.assertEqual(3,code[1][1]);
7850         self.assertEqual(0,code[1][2]);
7851         pass
7852
7853     def testNorm2_1(self):
7854         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7855         f=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
7856         f.setMesh(m);
7857         #
7858         d=DataArrayDouble.New();
7859         tab=[1.2,1.3,2.2,2.3,3.2,3.3,4.2,4.3,5.2,5.3]
7860         d.setValues(tab,5,2);
7861         f.setArray(d);
7862         f.checkCoherency();
7863         #
7864         self.assertAlmostEqual(11.209371079592289,f.norm2(),14);
7865         #
7866         pass
7867
7868     def testNormMax1(self):
7869         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7870         f=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
7871         f.setMesh(m);
7872         #
7873         d=DataArrayDouble.New();
7874         tab=[2.3,-1.2,6.3,-7.8,2.9,7.7,2.1,0.,3.6,-7.6]
7875         d.setValues(tab,5,2);
7876         f.setArray(d);
7877         f.checkCoherency();
7878         #
7879         self.assertAlmostEqual(7.8,f.normMax(),14);
7880         #
7881         pass
7882
7883     def testFindAndCorrectBadOriented3DExtrudedCells1(self):
7884         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];
7885         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]
7886         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]
7887         invalidCells=[2,3,6,7]
7888         m=MEDCouplingUMesh.New("Example",3);
7889         coo=DataArrayDouble.New();
7890         coo.setValues(coords,38,3);
7891         m.setCoords(coo);
7892         m.allocateCells(8);
7893         m.insertNextCell(NORM_PENTA6,6,conn[0:6])
7894         m.insertNextCell(NORM_PENTA6,6,conn[6:12])
7895         m.insertNextCell(NORM_PENTA6,6,conn[12:18])
7896         m.insertNextCell(NORM_PENTA6,6,conn[18:24])
7897         m.insertNextCell(NORM_HEXA8,8,conn[24:32])
7898         m.insertNextCell(NORM_HEXA8,8,conn[32:40])
7899         m.insertNextCell(NORM_HEXA8,8,conn[40:48])
7900         m.insertNextCell(NORM_HEXA8,8,conn[48:56])
7901         m.finishInsertingCells();
7902         #
7903         v=m.findAndCorrectBadOriented3DExtrudedCells();
7904         self.assertEqual(4,len(v));
7905         self.assertEqual(v.getValues(),invalidCells);
7906         self.assertEqual(connExp,m.getNodalConnectivity().getValues());
7907         #
7908         pass
7909
7910     def testConvertExtrudedPolyhedra1(self):
7911         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]
7912         m=MEDCouplingUMesh.New("Example",3);
7913         coo=DataArrayDouble.New();
7914         coo.alloc(73,3);
7915         coo.rearrange(1); coo.iota(0); coo.rearrange(3);
7916         m.setCoords(coo);
7917         m.allocateCells(9);
7918         m.insertNextCell(NORM_TETRA4,4,conn[0:4])
7919         m.insertNextCell(NORM_HEXA8,8,conn[4:12])
7920         m.insertNextCell(NORM_TETRA4,4,conn[12:16])
7921         m.insertNextCell(NORM_POLYHED,6,conn[16:22])
7922         m.insertNextCell(NORM_PENTA6,6,conn[22:28])
7923         m.insertNextCell(NORM_POLYHED,10,conn[28:38])
7924         m.insertNextCell(NORM_HEXA8,8,conn[38:46])
7925         m.insertNextCell(NORM_HEXGP12,12,conn[46:58])
7926         m.insertNextCell(NORM_POLYHED,14,conn[58:72])
7927         m.finishInsertingCells();
7928         #
7929         m.convertExtrudedPolyhedra();
7930         da=m.getNodalConnectivity();
7931         dai=m.getNodalConnectivityIndex();
7932         self.assertEqual(10,dai.getNbOfElems());
7933         self.assertEqual(159,da.getNbOfElems());
7934         #
7935         expected1=[14, 1, 2, 3, 4,
7936                    18, 5, 6, 7, 8, 9, 10, 11, 12,
7937                    14, 13, 14, 15, 16,
7938                    31, 17, 18, 19, -1, 20, 22, 21, -1, 17, 18, 21, 20, -1, 18, 19, 22, 21, -1, 19, 17, 20, 22,
7939                    16, 23, 24, 25, 26, 27, 28,
7940                    31, 29, 30, 31, 32, 33, -1, 34, 38, 37, 36, 35, -1, 29, 30, 35, 34, -1, 30, 31, 36, 35, -1, 31, 32, 37, 36, -1, 32, 33, 38, 37, -1, 33, 29, 34, 38,
7941                    18, 39, 40, 41, 42, 43, 44, 45, 46,
7942                    22, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
7943                    31, 59, 60, 61, 62, 63, 64, 65, -1, 66, 72, 71, 70, 69, 68, 67, -1, 59, 60, 67, 66, -1, 60, 61, 68, 67, -1, 61, 62, 69, 68, -1, 62, 63, 70, 69, -1, 63, 64, 71, 70, -1, 64, 65, 72, 71, -1, 65, 59, 66, 72];
7944         expected2=[0,5,14,19,42,49,86,95,108,159]
7945         self.assertEqual(expected1,da.getValues());
7946         self.assertEqual(expected2,dai.getValues());
7947         m.checkCoherency2()
7948         pass
7949
7950     def testNonRegressionCopyTinyStrings(self):
7951         m=MEDCouplingDataForTest.build2DTargetMesh_1()
7952         f1=m.getMeasureField(True)
7953         f1.getArray().setInfoOnComponent(0,"P [N/m^2]")
7954         bary=m.getBarycenterAndOwner()
7955         f2=f1.buildNewTimeReprFromThis(ONE_TIME,False)
7956         f2.setArray(bary)
7957         self.assertRaises(InterpKernelException,f2.copyTinyAttrFrom,f1)
7958         pass
7959
7960     def testDaDSetPartOfValuesAdv1(self):
7961         tab1=[3.,4.,5., 13.,14.,15., 23.,24.,25., 33.,34.,35., 43.,44.,45., 53.,54.,55.]
7962         tab2=[6.,7.,8., 16.,17.,18., 26.,27.,28.]
7963         tab3=[4,1, 2,2, 3,0]
7964         a=DataArrayDouble.New();
7965         a.setValues(tab1,6,3);
7966         b=DataArrayDouble.New();
7967         b.setValues(tab2,3,3);
7968         c=DataArrayInt.New();
7969         c.setValues(tab3,3,2);
7970         #
7971         a.setPartOfValuesAdv(b,c);
7972         expected1=[3.,4.,5., 13.,14.,15., 26.,27.,28., 6.,7.,8., 16.,17.,18., 53.,54.,55.]
7973         self.assertEqual(expected1,a.getValues());
7974         pass
7975
7976     def testUMeshBuildSetInstanceFromThis1(self):
7977         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
7978         m2=m.buildSetInstanceFromThis(3);
7979         self.assertTrue(m.isEqual(m2,1e-12));
7980         #
7981         m=MEDCouplingUMesh.New("toto",2);
7982         m2=m.buildSetInstanceFromThis(3);
7983         self.assertEqual(0,m2.getNumberOfNodes());
7984         self.assertEqual(0,m2.getNumberOfCells());
7985         pass
7986
7987     def testUMeshMergeMeshesCVW1(self):
7988         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
7989         m2=MEDCouplingUMesh.New("toto",2);
7990         m3=MEDCouplingUMesh.MergeUMeshes([m,m2]);
7991         m3.setName(m.getName());
7992         self.assertTrue(m.isEqual(m3,1e-12));
7993         pass
7994
7995     def testChangeUnderlyingMeshWithCMesh1(self):
7996         mesh=MEDCouplingCMesh.New();
7997         coordsX=DataArrayDouble.New();
7998         arrX=[ -1., 1., 2., 4. ]
7999         coordsX.setValues(arrX,4,1);
8000         coordsY=DataArrayDouble.New();
8001         arrY=[ -2., 2., 4., 8. ]
8002         coordsY.setValues(arrY,4,1);
8003         coordsZ=DataArrayDouble.New();
8004         arrZ=[ -3., 3., 6., 12. ]
8005         coordsZ.setValues(arrZ,4,1);
8006         mesh.setCoords(coordsX,coordsY,coordsZ);
8007         f=mesh.getMeasureField(True)
8008         mesh2=mesh.deepCpy()
8009         for myId in [0,1,2,10,11,12,20,21,22]:
8010             f=mesh.getMeasureField(True)
8011             f.changeUnderlyingMesh(mesh2,myId,1e-12);
8012             pass
8013         mesh2.setName("uuuu")
8014         for myId in [1,2,10,11,12,20,21,22]:
8015             f=mesh.getMeasureField(True)
8016             f.changeUnderlyingMesh(mesh2,myId,1e-12);
8017             pass
8018         pass
8019
8020     def testDADFindCommonTuples1(self):
8021         da=DataArrayDouble.New();
8022         # nbOftuples=1
8023         array1=[2.3,1.2,1.3,2.3,2.301,0.8]
8024         da.setValues(array1,6,1)
8025         c,cI=da.findCommonTuples(1e-2);
8026         expected1=[0,3,4]
8027         expected2=[0,3]
8028         self.assertEqual(3,c.getNbOfElems());
8029         self.assertEqual(2,cI.getNbOfElems());
8030         self.assertEqual(expected1,c.getValues())
8031         self.assertEqual(expected2,cI.getValues())
8032         c,cI=da.findCommonTuples(2e-1)
8033         expected3=[0,3,4,1,2]
8034         expected4=[0,3,5]
8035         self.assertEqual(5,c.getNbOfElems());
8036         self.assertEqual(3,cI.getNbOfElems());
8037         self.assertEqual(expected3,c.getValues())
8038         self.assertEqual(expected4,cI.getValues())
8039         # nbOftuples=2
8040         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]
8041         da.setValues(array2,6,2)
8042         c,cI=da.findCommonTuples(1e-2);
8043         self.assertEqual(3,c.getNbOfElems());
8044         self.assertEqual(2,cI.getNbOfElems());
8045         self.assertEqual(expected1,c.getValues())
8046         self.assertEqual(expected2,cI.getValues())
8047         c,cI=da.findCommonTuples(2e-1)
8048         self.assertEqual(5,c.getNbOfElems());
8049         self.assertEqual(3,cI.getNbOfElems());
8050         self.assertEqual(expected3,c.getValues())
8051         self.assertEqual(expected4,cI.getValues())
8052         # nbOftuples=3
8053         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]
8054         da.setValues(array3,6,3)
8055         c,cI=da.findCommonTuples(1e-2);
8056         self.assertEqual(3,c.getNbOfElems());
8057         self.assertEqual(2,cI.getNbOfElems());
8058         self.assertEqual(expected1,c.getValues())
8059         self.assertEqual(expected2,cI.getValues())
8060         c,cI=da.findCommonTuples(2e-1)
8061         self.assertEqual(5,c.getNbOfElems());
8062         self.assertEqual(3,cI.getNbOfElems());
8063         self.assertEqual(expected3,c.getValues())
8064         self.assertEqual(expected4,cI.getValues())
8065         # nbOftuples=1, no common groups
8066         array11=[2.3,1.2,1.3,2.4,2.5,0.8]
8067         da.setValues(array11,6,1)
8068         c,cI=da.findCommonTuples(1e-2);
8069         self.assertEqual(0,c.getNbOfElems());
8070         self.assertEqual(1,cI.getNbOfElems());
8071         self.assertEqual([0],cI.getValues())
8072
8073         array12=[0.]*(6*4)
8074         da.setValues(array12,6,4) #bad NumberOfComponents
8075         self.assertRaises(InterpKernelException, da.findCommonTuples, 1e-2);
8076         pass
8077
8078     def testDABack1(self):
8079         da=DataArrayDouble.New();
8080         array1=[2.3,1.2,1.3,2.3,2.301,0.8]
8081         da.setValues(array1,6,1);
8082         self.assertAlmostEqual(0.8,da.back(),14);
8083         da.rearrange(2);
8084         self.assertRaises(InterpKernelException,da.back);
8085         da.alloc(0,1);
8086         self.assertRaises(InterpKernelException,da.back);
8087         #
8088         da=DataArrayInt.New();
8089         array2=[4,7,8,2]
8090         da.setValues(array2,4,1);
8091         self.assertEqual(2,da.back());
8092         da.rearrange(2);
8093         self.assertRaises(InterpKernelException,da.back);
8094         da.alloc(0,1);
8095         self.assertRaises(InterpKernelException,da.back);
8096         pass
8097
8098     def testDADGetDifferentValues1(self):
8099         da=DataArrayDouble.New();
8100         array1=[2.3,1.2,1.3,2.3,2.301,0.8]
8101         da.setValues(array1,6,1)
8102         #
8103         expected1=[2.301,1.2,1.3,0.8]
8104         dv=da.getDifferentValues(1e-2);
8105         self.assertEqual(4,dv.getNbOfElems());
8106         for i in xrange(4):
8107             self.assertAlmostEqual(expected1[i],dv.getIJ(i,0),14);
8108             pass
8109         #
8110         dv=da.getDifferentValues(2e-1);
8111         expected2=[2.301,1.3,0.8]
8112         self.assertEqual(3,dv.getNbOfElems());
8113         for i in xrange(3):
8114             self.assertAlmostEqual(expected2[i],dv.getIJ(i,0),14);
8115             pass
8116         pass
8117
8118     def testDAIBuildOld2NewArrayFromSurjectiveFormat2(self):
8119         arr=[0,3, 5,7,9]
8120         arrI=[0,2,5]
8121         a=DataArrayInt.New();
8122         a.setValues(arr,5,1);
8123         b=DataArrayInt.New();
8124         b.setValues(arrI,3,1);
8125         ret,newNbTuple=DataArrayInt.BuildOld2NewArrayFromSurjectiveFormat2(10,a,b);
8126         expected=[0,1,2,0,3,4,5,4,6,4]
8127         self.assertEqual(10,ret.getNbOfElems());
8128         self.assertEqual(7,newNbTuple);
8129         self.assertEqual(1,ret.getNumberOfComponents());
8130         self.assertEqual(expected,ret.getValues());
8131         pass
8132
8133     def testDADIReverse1(self):
8134         arr=[0,3,5,7,9,2]
8135         a=DataArrayInt.New();
8136         a.setValues(arr,6,1);
8137         self.assertEqual(2,a.back());
8138         a.reverse();
8139         for i in xrange(6):
8140             self.assertEqual(arr[5-i],a.getIJ(i,0));
8141             pass
8142         a.setValues(arr[:-1],5,1);
8143         a.reverse();
8144         for i in xrange(5):
8145             self.assertEqual(arr[4-i],a.getIJ(i,0));
8146             pass
8147         #
8148         arr2=[0.,3.,5.,7.,9.,2.]
8149         b=DataArrayDouble.New();
8150         b.setValues(arr2,6,1);
8151         b.reverse();
8152         for i in xrange(6):
8153             self.assertAlmostEqual(arr2[5-i],b.getIJ(i,0),14);
8154             pass
8155         b.setValues(arr2,5,1);
8156         self.assertAlmostEqual(9.,b.back(),14)
8157         b.reverse();
8158         for i in xrange(5):
8159             self.assertAlmostEqual(arr2[4-i],b.getIJ(i,0),14);
8160             pass
8161         pass
8162
8163     def testGetNodeIdsInUse1(self):
8164         m0=MEDCouplingDataForTest.build2DTargetMesh_1();
8165         CellIds=[1,2]
8166         m1=m0.buildPartOfMySelf(CellIds,True);
8167         arr,newNbOfNodes=m1.getNodeIdsInUse();
8168         expected=[-1,0,1,-1,2,3,-1,-1,-1]
8169         self.assertEqual(4,newNbOfNodes);
8170         self.assertEqual(9,arr.getNbOfElems());
8171         self.assertEqual(expected,arr.getValues());
8172         arr2=arr.invertArrayO2N2N2O(newNbOfNodes);
8173         self.assertEqual(4,arr2.getNbOfElems());
8174         expected2=[1,2,4,5]
8175         self.assertEqual(expected2,arr2.getValues());
8176         pass
8177
8178     def testBuildDescendingConnec2(self):
8179         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
8180         #
8181         mesh2,desc,descIndx,revDesc,revDescIndx=mesh.buildDescendingConnectivity2();
8182         mesh2.checkCoherency();
8183         self.assertEqual(1,mesh2.getMeshDimension());
8184         self.assertEqual(13,mesh2.getNumberOfCells());
8185         self.assertEqual(14,revDescIndx.getNbOfElems()); self.assertEqual(14,revDescIndx.getNumberOfTuples());
8186         self.assertEqual(6,descIndx.getNbOfElems()); self.assertEqual(6,descIndx.getNumberOfTuples());
8187         self.assertEqual(18,desc.getNbOfElems()); self.assertEqual(18,desc.getNumberOfTuples());
8188         self.assertEqual(18,revDesc.getNbOfElems()); self.assertEqual(18,revDesc.getNumberOfTuples());
8189         expected1=[1,2,3,4,-3,5,6, 7,8,-5,9,10,-2,11, 12,13,-7,-10]
8190         self.assertEqual(expected1,desc.getValues());
8191         expected2=[0,4,7,10,14,18]
8192         self.assertEqual(expected2,descIndx.getValues());
8193         expected3=[0,1,3,5,6,8,9,11,12,13,15,16,17,18]
8194         self.assertEqual(expected3,revDescIndx.getValues());
8195         expected4=[0, 0,3, 0,1, 0, 1,2, 1, 2,4, 2, 3, 3,4, 3, 4, 4]
8196         self.assertEqual(expected4,revDesc.getValues());
8197         conn=mesh2.getNodalConnectivity();
8198         connIndex=mesh2.getNodalConnectivityIndex();
8199         expected5=[0,3,6,9,12,15,18,21,24,27,30,33,36,39]
8200         self.assertEqual(expected5,connIndex.getValues());
8201         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]
8202         self.assertEqual(expected6,conn.getValues());
8203         pass
8204
8205     def testIntersect2DMeshesTmp1(self):
8206         m1c=MEDCouplingCMesh.New();
8207         coordsX=DataArrayDouble.New();
8208         arrX=[ -1., 1., 2., 4. ]
8209         coordsX.setValues(arrX,4,1);
8210         m1c.setCoordsAt(0,coordsX);
8211         coordsY=DataArrayDouble.New();
8212         arrY=[ -2., 2., 4., 8. ]
8213         coordsY.setValues(arrY,4,1);
8214         m1c.setCoordsAt(1,coordsY);
8215         m1=m1c.buildUnstructured()
8216         m1bis=m1.buildPartOfMySelf([3,4,5],False)
8217         m2=m1.deepCpy()
8218         m2=m2.buildPartOfMySelf([0,1,2],False)
8219         m2.translate([0.5,0.5])
8220         #
8221         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m1bis,m2,1e-10)
8222         expected1=[0,0,1,1,1,2,2,2]
8223         expected2=[0,-1,0,1,-1,1,2,-1]
8224         self.assertEqual(8,d1.getNumberOfTuples());
8225         self.assertEqual(8,d2.getNumberOfTuples());
8226         self.assertEqual(8,m3.getNumberOfCells());
8227         self.assertEqual(22,m3.getNumberOfNodes());
8228         self.assertEqual(2,m3.getSpaceDimension());
8229         self.assertEqual(expected1,d1.getValues());
8230         self.assertEqual(expected2,d2.getValues());
8231         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]
8232         expected4=[0,5,12,17,22,28,33,38,44]
8233         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]
8234         self.assertEqual(44,m3.getNodalConnectivity().getNumberOfTuples());
8235         self.assertEqual(9,m3.getNodalConnectivityIndex().getNumberOfTuples());
8236         self.assertEqual(expected3,m3.getNodalConnectivity().getValues());
8237         self.assertEqual(expected4,m3.getNodalConnectivityIndex().getValues());
8238         for i in xrange(44):
8239             self.assertAlmostEqual(expected5[i],m3.getCoords().getIJ(0,i),12);
8240             pass
8241         pass
8242
8243     def testFindNodesOnLine1(self):
8244         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
8245         pt=[-0.3,-0.3]
8246         pt2=[0.,0.,0.]
8247         pt3=[-0.3,0.,0.]
8248         vec=[0.,1.]
8249         vec2=[1.,0.,0.]
8250         vec3=[0.,1.,1.]
8251         expected1=[0,3,6]
8252         res=mesh.findNodesOnLine(pt,vec,1e-12);
8253         self.assertEqual(3,len(res));
8254         self.assertEqual(expected1,res.getValues());
8255         #
8256         mesh.changeSpaceDimension(3);
8257         mesh.rotate(pt2,vec2,pi/4.);
8258         res=mesh.findNodesOnLine(pt3,vec3,1e-12);
8259         self.assertEqual(3,len(res));
8260         self.assertEqual(expected1,res.getValues());
8261         pass
8262
8263     def testIntersect2DMeshesTmp2(self):
8264         m1c=MEDCouplingCMesh.New();
8265         coordsX1=DataArrayDouble.New();
8266         arrX1=[ 0., 1., 1.5, 2. ]
8267         coordsX1.setValues(arrX1,4,1);
8268         m1c.setCoordsAt(0,coordsX1);
8269         coordsY1=DataArrayDouble.New();
8270         arrY1=[ 0., 1.5, 3.]
8271         coordsY1.setValues(arrY1,3,1);
8272         m1c.setCoordsAt(1,coordsY1);
8273         m1=m1c.buildUnstructured();
8274         m2c=MEDCouplingCMesh.New();
8275         coordsX2=DataArrayDouble.New();
8276         arrX2=[ 0., 1., 2. ]
8277         coordsX2.setValues(arrX2,3,1);
8278         m2c.setCoordsAt(0,coordsX2);
8279         coordsY2=DataArrayDouble.New();
8280         arrY2=[ 0., 1., 3.]
8281         coordsY2.setValues(arrY2,3,1);
8282         m2c.setCoordsAt(1,coordsY2);
8283         m2=m2c.buildUnstructured();
8284         #
8285         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m1,m2,1e-10)
8286         #
8287         expected1=[0,0,1,1,2,2,3,4,5]
8288         expected2=[0,2,1,3,1,3,2,3,3]
8289         self.assertEqual(9,d1.getNumberOfTuples());
8290         self.assertEqual(9,d2.getNumberOfTuples());
8291         self.assertEqual(9,m3.getNumberOfCells());
8292         self.assertEqual(22,m3.getNumberOfNodes());
8293         self.assertEqual(2,m3.getSpaceDimension());
8294         self.assertEqual(expected1,d1.getValues());
8295         self.assertEqual(expected2,d2.getValues());
8296         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]
8297         expected4=[0,5,10,15,20,25,30,35,40,45]
8298         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]
8299         self.assertEqual(45,m3.getNodalConnectivity().getNumberOfTuples());
8300         self.assertEqual(10,m3.getNodalConnectivityIndex().getNumberOfTuples());
8301         self.assertEqual(expected3,m3.getNodalConnectivity().getValues());
8302         self.assertEqual(expected4,m3.getNodalConnectivityIndex().getValues());
8303         for i in xrange(44):
8304             self.assertAlmostEqual(expected5[i],m3.getCoords().getIJ(0,i),12);
8305             pass
8306         pass
8307
8308     def testBuildPartOfMySelfSafe1(self):
8309         mesh=MEDCouplingDataForTest.build2DTargetMesh_1()
8310         self.assertRaises(InterpKernelException,mesh.buildPartOfMySelf,[0,-1,4,2],True)
8311         self.assertRaises(InterpKernelException,mesh.buildPartOfMySelf,[0,4,5,4],True)
8312         pass
8313
8314     def testIntersect2DMeshesTmp3(self):
8315         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];
8316         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];
8317         m1=MEDCouplingUMesh.New();
8318         m1.setMeshDimension(2);
8319         m1.allocateCells(8);
8320         m1.insertNextCell(NORM_TRI6,6,m1Conn[0:6]);
8321         m1.insertNextCell(NORM_QUAD8,8,m1Conn[6:14]);
8322         m1.insertNextCell(NORM_TRI6,6,m1Conn[14:20]);
8323         m1.insertNextCell(NORM_QUAD8,8,m1Conn[20:28]);
8324         m1.insertNextCell(NORM_TRI6,6,m1Conn[28:34]);
8325         m1.insertNextCell(NORM_QUAD8,8,m1Conn[34:42]);
8326         m1.insertNextCell(NORM_TRI6,6,m1Conn[42:48]);
8327         m1.insertNextCell(NORM_QUAD8,8,m1Conn[48:56]);
8328         m1.finishInsertingCells();
8329         myCoords1=DataArrayDouble.New();
8330         myCoords1.setValues(m1Coords,25,2);
8331         m1.setCoords(myCoords1);
8332         #
8333         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.]
8334         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]
8335         m2=MEDCouplingUMesh.New();
8336         m2.setMeshDimension(2);
8337         m2.allocateCells(8);
8338         for i in xrange(8):
8339             m2.insertNextCell(NORM_QUAD4,4,m2Conn[4*i:4*(i+1)])
8340             pass
8341         m2.finishInsertingCells();
8342         myCoords2=DataArrayDouble.New();
8343         myCoords2.setValues(m2Coords,15,2);
8344         m2.setCoords(myCoords2);
8345         #
8346         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m1,m2,1e-10)
8347         m3.unPolyze()
8348         #
8349         expected1=[0,1,1,1,2,3,3,3,4,5,5,5,6,7,7,7]
8350         expected2=[0,0,1,-1,2,2,3,-1,4,4,5,-1,6,6,7,-1]
8351         self.assertEqual(16,d1.getNumberOfTuples());
8352         self.assertEqual(16,d2.getNumberOfTuples());
8353         self.assertEqual(16,m3.getNumberOfCells());
8354         self.assertEqual(104,m3.getNumberOfNodes());
8355         self.assertEqual(2,m3.getSpaceDimension());
8356         self.assertEqual(expected1,d1.getValues());
8357         self.assertEqual(expected2,d2.getValues());
8358         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]
8359         expected4=[0,7,16,25,34,41,50,59,68,75,84,93,102,109,118,127,136]
8360         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]
8361         self.assertEqual(136,m3.getNodalConnectivity().getNumberOfTuples());
8362         self.assertEqual(17,m3.getNodalConnectivityIndex().getNumberOfTuples());
8363         self.assertEqual(expected3,m3.getNodalConnectivity().getValues());
8364         self.assertEqual(expected4,m3.getNodalConnectivityIndex().getValues());
8365         for i in xrange(208):
8366             self.assertAlmostEqual(expected5[i],m3.getCoords().getIJ(0,i),12);
8367             pass
8368         pass
8369
8370     def testUMeshTessellate2D1(self):
8371         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];
8372         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];
8373         m1=MEDCouplingUMesh.New();
8374         m1.setMeshDimension(2);
8375         m1.allocateCells(8);
8376         m1.insertNextCell(NORM_TRI6,6,m1Conn[0:6]);
8377         m1.insertNextCell(NORM_QUAD8,8,m1Conn[6:14]);
8378         m1.insertNextCell(NORM_TRI6,6,m1Conn[14:20]);
8379         m1.insertNextCell(NORM_QUAD8,8,m1Conn[20:28]);
8380         m1.insertNextCell(NORM_TRI6,6,m1Conn[28:34]);
8381         m1.insertNextCell(NORM_QUAD8,8,m1Conn[34:42]);
8382         m1.insertNextCell(NORM_TRI6,6,m1Conn[42:48]);
8383         m1.insertNextCell(NORM_QUAD8,8,m1Conn[48:56]);
8384         m1.finishInsertingCells();
8385         myCoords1=DataArrayDouble.New();
8386         myCoords1.setValues(m1Coords,25,2);
8387         m1.setCoords(myCoords1);
8388         #
8389         m11=m1.deepCpy();
8390         m11.tessellate2D(1.);
8391         self.assertTrue(m11.getCoords().isEqual(m11.getCoords(),1e-12));
8392         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]
8393         expected2=[0,5,12,17,24,29,36,41,48]
8394         self.assertEqual(48,m11.getNodalConnectivity().getNumberOfTuples());
8395         self.assertEqual(9,m11.getNodalConnectivityIndex().getNumberOfTuples());
8396         self.assertEqual(expected1,m11.getNodalConnectivity().getValues());
8397         self.assertEqual(expected2,m11.getNodalConnectivityIndex().getValues());
8398         #
8399         m12=m1.deepCpy();
8400         m12.tessellate2D(0.5);
8401         self.assertEqual(41,m12.getNumberOfNodes());
8402         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]
8403         expected4=[0,6,15,21,30,36,45,51,60]
8404         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]
8405         for i in xrange(82):
8406             self.assertAlmostEqual(expected5[i],m12.getCoords().getIJ(0,i),12);
8407             pass
8408         self.assertEqual(60,m12.getNodalConnectivity().getNumberOfTuples());
8409         self.assertEqual(9,m12.getNodalConnectivityIndex().getNumberOfTuples());
8410         self.assertEqual(expected3,m12.getNodalConnectivity().getValues());
8411         self.assertEqual(expected4,m12.getNodalConnectivityIndex().getValues());
8412         pass
8413
8414     def testIntersect2DMeshesTmp4(self):
8415         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];
8416         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];
8417         m1=MEDCouplingUMesh.New();
8418         m1.setMeshDimension(2);
8419         m1.allocateCells(8);
8420         m1.insertNextCell(NORM_TRI6,6,m1Conn[0:6]);
8421         m1.insertNextCell(NORM_QUAD8,8,m1Conn[6:14]);
8422         m1.insertNextCell(NORM_TRI6,6,m1Conn[14:20]);
8423         m1.insertNextCell(NORM_QUAD8,8,m1Conn[20:28]);
8424         m1.insertNextCell(NORM_TRI6,6,m1Conn[28:34]);
8425         m1.insertNextCell(NORM_QUAD8,8,m1Conn[34:42]);
8426         m1.insertNextCell(NORM_TRI6,6,m1Conn[42:48]);
8427         m1.insertNextCell(NORM_QUAD8,8,m1Conn[48:56]);
8428         m1.finishInsertingCells();
8429         myCoords1=DataArrayDouble.New();
8430         myCoords1.setValues(m1Coords,25,2);
8431         m1.setCoords(myCoords1);
8432         #
8433         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.]
8434         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]
8435         m2=MEDCouplingUMesh.New();
8436         m2.setMeshDimension(2);
8437         m2.allocateCells(8);
8438         for i in xrange(8):
8439             m2.insertNextCell(NORM_QUAD4,4,m2Conn[4*i:4*(i+1)])
8440             pass
8441         m2.finishInsertingCells();
8442         myCoords2=DataArrayDouble.New();
8443         myCoords2.setValues(m2Coords,15,2);
8444         m2.setCoords(myCoords2);
8445         #
8446         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m2,m1,1e-10)
8447         m3.unPolyze()
8448         #
8449         expected1=[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
8450         expected2=[0,1,1,-1,2,3,3,-1,4,5,5,-1,6,7,7,-1]
8451         self.assertEqual(16,d1.getNumberOfTuples());
8452         self.assertEqual(16,d2.getNumberOfTuples());
8453         self.assertEqual(16,m3.getNumberOfCells());
8454         self.assertEqual(104,m3.getNumberOfNodes());
8455         self.assertEqual(2,m3.getSpaceDimension());
8456         self.assertEqual(expected1,d1.getValues());
8457         self.assertEqual(expected2,d2.getValues());
8458         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]
8459         expected4=[0,7,16,25,34,41,50,59,68,75,84,93,102,109,118,127,136]
8460         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]
8461         self.assertEqual(136,m3.getNodalConnectivity().getNumberOfTuples());
8462         self.assertEqual(17,m3.getNodalConnectivityIndex().getNumberOfTuples());
8463         self.assertEqual(expected3,m3.getNodalConnectivity().getValues());
8464         self.assertEqual(expected4,m3.getNodalConnectivityIndex().getValues());
8465         for i in xrange(208):
8466             self.assertAlmostEqual(expected5[i],m3.getCoords().getIJ(0,i),12);
8467             pass
8468         pass
8469
8470     def testGetCellIdsCrossingPlane1(self):
8471         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
8472         vec=[-0.07,1.,0.07]
8473         origin=[1.524,1.4552,1.74768]
8474         ids1=mesh3D.getCellIdsCrossingPlane(origin,vec,1e-10)
8475         self.assertEqual([1,3,4,7,9,10,13,15,16],ids1.getValues())
8476         vec2=[0.,0.,1.]
8477         ids2=mesh3D.getCellIdsCrossingPlane(origin,vec2,1e-10)
8478         self.assertEqual([6,7,8,9,10,11],ids2.getValues())
8479         pass
8480
8481     def testBuildSlice3D1(self):
8482         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
8483         vec1=[-0.07,1.,0.07]
8484         origin1=[1.524,1.4552,1.74768]
8485         slice1,ids=mesh3D.buildSlice3D(origin1,vec1,1e-10);
8486         expected1=[1,3,4,7,9,10,13,15,16]
8487         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]
8488         expected3=[0,6,11,17,22,27,32,37,42,47]
8489         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.]
8490         self.assertEqual(2,slice1.getMeshDimension());
8491         self.assertEqual(3,slice1.getSpaceDimension());
8492         self.assertEqual(57,slice1.getNumberOfNodes());
8493         self.assertEqual(9,slice1.getNumberOfCells());
8494         self.assertEqual(9,ids.getNumberOfTuples());
8495         self.assertEqual(47,slice1.getNodalConnectivity().getNumberOfTuples());
8496         self.assertEqual(10,slice1.getNodalConnectivityIndex().getNumberOfTuples());
8497         self.assertEqual(expected1,ids.getValues());
8498         self.assertEqual(expected2,slice1.getNodalConnectivity().getValues());
8499         self.assertEqual(expected3,slice1.getNodalConnectivityIndex().getValues());
8500         for i in xrange(171):
8501             self.assertAlmostEqual(expected4[i],slice1.getCoords().getIJ(0,i),12);
8502             pass
8503         # 2nd slice based on already existing nodes of mesh3D.
8504         vec2=[0.,3.,1.]
8505         origin2=[2.5,1.,3.]
8506         slice1,ids=mesh3D.buildSlice3D(origin2,vec2,1e-10);
8507         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]
8508         expected6=[0,5,10,15,21,26,32,38,43,49]
8509         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]
8510         self.assertEqual(2,slice1.getMeshDimension());
8511         self.assertEqual(3,slice1.getSpaceDimension());
8512         self.assertEqual(60,slice1.getNumberOfNodes());
8513         self.assertEqual(9,slice1.getNumberOfCells());
8514         self.assertEqual(9,ids.getNumberOfTuples());
8515         self.assertEqual(49,slice1.getNodalConnectivity().getNumberOfTuples());
8516         self.assertEqual(10,slice1.getNodalConnectivityIndex().getNumberOfTuples());
8517         self.assertEqual(expected1,ids.getValues());
8518         self.assertEqual(expected5,slice1.getNodalConnectivity().getValues());
8519         self.assertEqual(expected6,slice1.getNodalConnectivityIndex().getValues());
8520         for i in xrange(180):
8521             self.assertAlmostEqual(expected7[i],slice1.getCoords().getIJ(0,i),12);
8522             pass
8523         # 3rd slice based on shared face of mesh3D.
8524         vec3=[0.,0.,1.]
8525         origin3=[2.5,1.,2.]
8526         slice1,ids=mesh3D.buildSlice3D(origin3,vec3,1e-10);
8527         expected8=[6,7,8,9,10,11,12,13,14,15,16,17]
8528         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]
8529         expected10=[0,5,12,17,22,29,34,39,46,51,56,63,68]
8530         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.]
8531         self.assertEqual(2,slice1.getMeshDimension());
8532         self.assertEqual(3,slice1.getSpaceDimension());
8533         self.assertEqual(45,slice1.getNumberOfNodes());
8534         self.assertEqual(12,slice1.getNumberOfCells());
8535         self.assertEqual(12,ids.getNumberOfTuples());
8536         self.assertEqual(68,slice1.getNodalConnectivity().getNumberOfTuples());
8537         self.assertEqual(13,slice1.getNodalConnectivityIndex().getNumberOfTuples());
8538         self.assertEqual(expected8,ids.getValues());
8539         self.assertEqual(expected9,slice1.getNodalConnectivity().getValues());
8540         self.assertEqual(expected10,slice1.getNodalConnectivityIndex().getValues());
8541         for i in xrange(135):
8542             self.assertAlmostEqual(expected11[i],slice1.getCoords().getIJ(0,i),12);
8543             pass
8544         pass
8545
8546     def testBuildSlice3DSurf1(self):
8547         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
8548         mesh2D=mesh3D.buildDescendingConnectivity()[0];
8549         vec1=[-0.07,1.,0.07]
8550         origin1=[1.524,1.4552,1.74768]
8551         slice1,ids=mesh2D.buildSlice3DSurf(origin1,vec1,1e-10);
8552         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]
8553         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]
8554         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];
8555         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.]
8556         self.assertEqual(1,slice1.getMeshDimension());
8557         self.assertEqual(3,slice1.getSpaceDimension());
8558         self.assertEqual(57,slice1.getNumberOfNodes());
8559         self.assertEqual(25,slice1.getNumberOfCells());
8560         self.assertEqual(25,ids.getNumberOfTuples());
8561         self.assertEqual(75,slice1.getNodalConnectivity().getNumberOfTuples());
8562         self.assertEqual(26,slice1.getNodalConnectivityIndex().getNumberOfTuples());
8563         self.assertEqual(expected1,ids.getValues());
8564         self.assertEqual(expected2,slice1.getNodalConnectivity().getValues());
8565         self.assertEqual(expected3,slice1.getNodalConnectivityIndex().getValues());
8566         for i in xrange(171):
8567             self.assertAlmostEqual(expected4[i],slice1.getCoords().getIJ(0,i),12);
8568             pass
8569         #
8570         vec2=[0.,0.,1.]
8571         origin2=[2.5,1.,2.]
8572         slice1,ids=mesh2D.buildSlice3DSurf(origin2,vec2,1e-10);
8573         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]
8574         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]
8575         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];
8576         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.]
8577         self.assertEqual(1,slice1.getMeshDimension());
8578         self.assertEqual(3,slice1.getSpaceDimension());
8579         self.assertEqual(45,slice1.getNumberOfNodes());
8580         self.assertEqual(68,slice1.getNumberOfCells());
8581         self.assertEqual(68,ids.getNumberOfTuples());
8582         self.assertEqual(204,slice1.getNodalConnectivity().getNumberOfTuples());
8583         self.assertEqual(69,slice1.getNodalConnectivityIndex().getNumberOfTuples());
8584         self.assertEqual(expected5,ids.getValues());
8585         self.assertEqual(expected6,slice1.getNodalConnectivity().getValues());
8586         self.assertEqual(expected7,slice1.getNodalConnectivityIndex().getValues());
8587         for i in xrange(135):
8588             self.assertAlmostEqual(expected8[i],slice1.getCoords().getIJ(0,i),12);
8589             pass
8590         pass
8591
8592     def testDataArrayDoubleAdvSetting1(self):
8593         data1=[1.,11.,2.,12.,3.,13.,4.,14.,5.,15.,6.,16.,7.,17.]
8594         data2=[8.,38.,9.,39.,0.,30.,11.,41.,12.,42.]
8595         compsCpp=["comp1","comp2"]
8596         da=DataArrayDouble.New();
8597         da.setInfoAndChangeNbOfCompo(compsCpp);
8598         da.setName("da");
8599         da.alloc(7,2);
8600         compsCpp=compsCpp[:-1]
8601         self.assertRaises(InterpKernelException,da.setInfoAndChangeNbOfCompo,compsCpp);
8602         da.setValues(data1,7,2)
8603         #
8604         p=[(0,3),(3,5),(5,7)]
8605         tmp=da.selectByTupleRanges(p);
8606         self.assertTrue(tmp.isEqual(da,1e-14));
8607         p=[(0,2),(3,4),(5,7)]
8608         tmp=da.selectByTupleRanges(p);
8609         expected1=[1.,11.,2.,12.,4.,14.,6.,16.,7.,17.]
8610         self.assertEqual(5,tmp.getNumberOfTuples());
8611         self.assertEqual(2,tmp.getNumberOfComponents());
8612         for i in xrange(10):
8613             self.assertAlmostEqual(expected1[i],tmp.getIJ(0,i),14);
8614             pass
8615         p=[(0,2),(0,2),(5,6)]
8616         tmp=da.selectByTupleRanges(p);
8617         expected2=[1.,11.,2.,12.,1.,11.,2.,12.,6.,16.]
8618         self.assertEqual(5,tmp.getNumberOfTuples());
8619         self.assertEqual(2,tmp.getNumberOfComponents());
8620         for i in xrange(10):
8621             self.assertAlmostEqual(expected2[i],tmp.getIJ(0,i),14);
8622             pass
8623         p=[(0,2),(-1,2),(5,6)]
8624         self.assertRaises(InterpKernelException,da.selectByTupleRanges,p);
8625         p=[(0,2),(0,2),(5,8)]
8626         self.assertRaises(InterpKernelException,da.selectByTupleRanges,p);
8627         #
8628         da2=DataArrayDouble.New();
8629         da2.setValues(data2,5,2);
8630         #
8631         dac=da.deepCpy();
8632         dac.setContigPartOfSelectedValues2(1,da2,2,4,1);
8633         expected3=[1.,11.,0.,30.,11.,41.,4.,14.,5.,15.,6.,16.,7.,17.]
8634         for i in xrange(14):
8635             self.assertAlmostEqual(expected3[i],dac.getIJ(0,i),14);
8636             pass
8637         #
8638         dac=da.deepCpy();
8639         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,3,da2,0,5,1);
8640         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,0,da2,4,6,1);
8641         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,3,da2,5,0,1);
8642         dac.setContigPartOfSelectedValues2(3,da2,1,5,1);
8643         expected4=[1.,11.,2.,12.,3.,13.,9.,39.,0.,30.,11.,41.,12.,42.]
8644         for i in xrange(14):
8645             self.assertAlmostEqual(expected4[i],dac.getIJ(0,i),14);
8646             pass
8647         #
8648         ids=DataArrayInt.New();
8649         ids.alloc(3,1);
8650         dac=da.deepCpy();
8651         ids.setIJ(0,0,2); ids.setIJ(1,0,0); ids.setIJ(2,0,4);
8652         dac.setContigPartOfSelectedValues(2,da2,ids);
8653         expected5=[1.,11.,2.,12.,0.,30.,8.,38.,12.,42.,6.,16.,7.,17.]
8654         for i in xrange(14):
8655             self.assertAlmostEqual(expected5[i],dac.getIJ(0,i),14);
8656             pass
8657         #
8658         dac=da.deepCpy();
8659         ids.setIJ(0,0,2); ids.setIJ(1,0,5); ids.setIJ(2,0,4);
8660         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,1,da2,ids);
8661         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,-1);
8662         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,1,da2,ids);
8663         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,1);
8664         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,5,da2,ids);
8665         #
8666         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,1);
8667         dac=da.deepCpy();
8668         dac.setContigPartOfSelectedValues(4,da2,ids);
8669         expected6=[1.,11.,2.,12.,3.,13.,4.,14.,0.,30.,0.,30.,9.,39.]
8670         for i in xrange(14):
8671             self.assertAlmostEqual(expected6[i],dac.getIJ(0,i),14);
8672             pass
8673         pass
8674
8675     def testDataArrayIntAdvSetting1(self):
8676         data1=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
8677         data2=[8,38,9,39,0,30,11,41,12,42]
8678         compsCpp=["comp1","comp2"]
8679         da=DataArrayInt.New();
8680         da.setInfoAndChangeNbOfCompo(compsCpp);
8681         da.setName("da");
8682         da.alloc(7,2);
8683         compsCpp=compsCpp[:-1]
8684         self.assertRaises(InterpKernelException,da.setInfoAndChangeNbOfCompo,compsCpp);
8685         da.setValues(data1,7,2)
8686         #
8687         p=[(0,3),(3,5),(5,7)]
8688         tmp=da.selectByTupleRanges(p);
8689         self.assertTrue(tmp.isEqual(da));
8690         p=[(0,2),(3,4),(5,7)]
8691         tmp=da.selectByTupleRanges(p);
8692         expected1=[1,11,2,12,4,14,6,16,7,17]
8693         self.assertEqual(5,tmp.getNumberOfTuples());
8694         self.assertEqual(2,tmp.getNumberOfComponents());
8695         for i in xrange(10):
8696             self.assertEqual(expected1[i],tmp.getIJ(0,i));
8697             pass
8698         p=[(0,2),(0,2),(5,6)]
8699         tmp=da.selectByTupleRanges(p);
8700         expected2=[1,11,2,12,1,11,2,12,6,16]
8701         self.assertEqual(5,tmp.getNumberOfTuples());
8702         self.assertEqual(2,tmp.getNumberOfComponents());
8703         for i in xrange(10):
8704             self.assertEqual(expected2[i],tmp.getIJ(0,i));
8705             pass
8706         p=[(0,2),(-1,2),(5,6)]
8707         self.assertRaises(InterpKernelException,da.selectByTupleRanges,p);
8708         p=[(0,2),(0,2),(5,8)]
8709         self.assertRaises(InterpKernelException,da.selectByTupleRanges,p);
8710         #
8711         da2=DataArrayInt.New();
8712         da2.setValues(data2,5,2);
8713         #
8714         dac=da.deepCpy();
8715         dac.setContigPartOfSelectedValues2(1,da2,2,4,1);
8716         expected3=[1,11,0,30,11,41,4,14,5,15,6,16,7,17]
8717         for i in xrange(14):
8718             self.assertEqual(expected3[i],dac.getIJ(0,i));
8719             pass
8720         #
8721         dac=da.deepCpy();
8722         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,3,da2,0,5,1);
8723         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,0,da2,4,6,1);
8724         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,3,da2,5,0,1);
8725         dac.setContigPartOfSelectedValues2(3,da2,1,5,1);
8726         expected4=[1,11,2,12,3,13,9,39,0,30,11,41,12,42]
8727         for i in xrange(14):
8728             self.assertEqual(expected4[i],dac.getIJ(0,i));
8729             pass
8730         #
8731         ids=DataArrayInt.New();
8732         ids.alloc(3,1);
8733         dac=da.deepCpy();
8734         ids.setIJ(0,0,2); ids.setIJ(1,0,0); ids.setIJ(2,0,4);
8735         dac.setContigPartOfSelectedValues(2,da2,ids);
8736         expected5=[1,11,2,12,0,30,8,38,12,42,6,16,7,17]
8737         for i in xrange(14):
8738             self.assertEqual(expected5[i],dac.getIJ(0,i));
8739             pass
8740         #
8741         dac=da.deepCpy();
8742         ids.setIJ(0,0,2); ids.setIJ(1,0,5); ids.setIJ(2,0,4);
8743         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,1,da2,ids);
8744         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,-1);
8745         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,1,da2,ids);
8746         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,1);
8747         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,5,da2,ids);
8748         #
8749         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,1);
8750         dac=da.deepCpy();
8751         dac.setContigPartOfSelectedValues(4,da2,ids);
8752         expected6=[1,11,2,12,3,13,4,14,0,30,0,30,9,39]
8753         for i in xrange(14):
8754             self.assertEqual(expected6[i],dac.getIJ(0,i));
8755             pass
8756         pass
8757
8758     def testBuildDescendingConnec2Of3DMesh1(self):
8759         mesh=MEDCouplingDataForTest.build3DSourceMesh_1();
8760         #
8761         mesh2,desc,descIndx,revDesc,revDescIndx=mesh.buildDescendingConnectivity2();
8762         mesh2.checkCoherency();
8763         self.assertEqual(2,mesh2.getMeshDimension());
8764         self.assertEqual(30,mesh2.getNumberOfCells());
8765         self.assertEqual(31,revDescIndx.getNbOfElems()); self.assertEqual(31,revDescIndx.getNumberOfTuples());
8766         self.assertEqual(13,descIndx.getNbOfElems()); self.assertEqual(13,descIndx.getNumberOfTuples());
8767         self.assertEqual(48,desc.getNbOfElems()); self.assertEqual(48,desc.getNumberOfTuples());
8768         self.assertEqual(48,revDesc.getNbOfElems()); self.assertEqual(48,revDesc.getNumberOfTuples());
8769         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]
8770         self.assertEqual(expected1,desc.getValues());
8771         expected2=[0,4,8,12,16,20,24,28,32,36,40,44,48]
8772         self.assertEqual(expected2,descIndx.getValues());
8773         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]
8774         self.assertEqual(expected3,revDescIndx.getValues());
8775         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]
8776         self.assertEqual(expected4,revDesc.getValues());
8777         conn=mesh2.getNodalConnectivity();
8778         connIndex=mesh2.getNodalConnectivityIndex();
8779         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]
8780         self.assertEqual(expected5,connIndex.getValues());
8781         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]
8782         self.assertEqual(expected6,conn.getValues());
8783         pass
8784
8785     def testAre2DCellsNotCorrectlyOriented1(self):
8786         m1Coords=[1.,1.,-1.,-1.,-1.,-1.,1.,-1.]
8787         m1Conn=[0,3,1,2]
8788         m1=MEDCouplingUMesh.New();
8789         m1.setMeshDimension(2);
8790         m1.allocateCells(1);
8791         m1.insertNextCell(NORM_QUAD4,4,m1Conn[0:4])
8792         m1.finishInsertingCells();
8793         myCoords1=DataArrayDouble.New();
8794         myCoords1.setValues(m1Coords,4,2);
8795         m1.setCoords(myCoords1);
8796         #
8797         vec1=[0.,0.,1.]
8798         for i in xrange(18):
8799             vec2=[3.*cos(pi/9.*i),3.*sin(pi/9.*i)];
8800             m1Cpy=m1.deepCpy();
8801             m1Cpy.translate(vec2);
8802             self.assertRaises(InterpKernelException,m1Cpy.are2DCellsNotCorrectlyOriented,vec1,False);
8803             m1Cpy.changeSpaceDimension(3);
8804             res=m1Cpy.are2DCellsNotCorrectlyOriented(vec1,False)
8805             self.assertEqual([0],res.getValues());
8806             pass
8807         pass
8808
8809     def testDataArrayAbs1(self):
8810         d1=DataArrayDouble.New();
8811         val1=[2.,-3.,-5.,6.,-7.,-8.,9.,10.,-11.,-12.,-13.,-15.]
8812         expected1=[2.,3.,5.,6.,7.,8.,9.,10.,11.,12.,13.,15.]
8813         d1.setValues(val1,6,2);
8814         d2=d1.convertToIntArr();
8815         #
8816         d1.abs();
8817         for i in xrange(12):
8818             self.assertAlmostEqual(expected1[i],d1.getIJ(0,i),14);
8819             pass
8820         #
8821         expected2=[2,3,5,6,7,8,9,10,11,12,13,15]
8822         d2.abs();
8823         for i in xrange(12):
8824             self.assertEqual(expected2[i],d2.getIJ(0,i));
8825             pass
8826         #
8827         pass
8828
8829     # test on 1D
8830     def testGetValueOn3(self):
8831         v=[0.,1.,1.5,2.]
8832         v2=[0.7,1.25,0.,2.,1.5]
8833         disp=[5.,50.,500.,6.,60.,600.,7.,70.,700.,8.,80.,800.]
8834         m=MEDCouplingUMesh.New("myMesh",1)
8835         nbNodes=len(v)
8836         nbCells=nbNodes-1
8837         m.allocateCells(nbCells)
8838         coords=DataArrayDouble.New() ; coords.setValues(v,nbNodes,1)
8839         m.setCoords(coords)
8840         m.insertNextCell(NORM_SEG2,2,[0,1])
8841         m.insertNextCell(NORM_SEG2,2,[2,1])
8842         m.insertNextCell(NORM_SEG2,2,[2,3])
8843         m.finishInsertingCells()
8844         f=MEDCouplingFieldDouble.New(ON_NODES)
8845         f.setMesh(m)
8846         array=DataArrayDouble.New(); array.setValues(disp,m.getNumberOfNodes(),3)
8847         f.setArray(array)
8848         arr1=f.getValueOnMulti(v2)
8849         self.assertEqual(5,arr1.getNumberOfTuples());
8850         self.assertEqual(3,arr1.getNumberOfComponents());
8851         expected1=[5.7,57.,570.,6.5,65.,650.,5.,50.,500.,8.,80.,800.,7.,70.,700.]
8852         for i in xrange(15):
8853             self.assertAlmostEqual(expected1[i],arr1.getIJ(0,i),14);
8854             pass
8855         pass
8856
8857     def testGetNodeIdsOfCell2(self):
8858         m1c=MEDCouplingCMesh.New();
8859         coordsX=DataArrayDouble.New();
8860         arrX=[ -1., 1., 2., 4., 4.5 ]
8861         coordsX.setValues(arrX,5,1);
8862         coordsY=DataArrayDouble.New();
8863         arrY=[ -2., 2., 4., 8.]
8864         coordsY.setValues(arrY,4,1);
8865         coordsZ=DataArrayDouble.New();
8866         arrZ=[ -2., 2., 4.]
8867         coordsZ.setValues(arrZ,3,1);
8868         # test in 1D
8869         m1c.setCoordsAt(0,coordsX);
8870         expected1=[[0,1],[1,2],[2,3],[3,4]]
8871         self.assertEqual(4,m1c.getNumberOfCells())
8872         for i in xrange(m1c.getNumberOfCells()):
8873             self.assertEqual(expected1[i],m1c.getNodeIdsOfCell(i))
8874             pass
8875         # test in 2D
8876         m1c.setCoordsAt(1,coordsY);
8877         self.assertEqual(12,m1c.getNumberOfCells())
8878         expected2=[[0,1,6,5],[1,2,7,6],[2,3,8,7],[3,4,9,8],[4,5,11,10],[5,6,12,11],[6,7,13,12],[7,8,14,13],[8,9,16,15],[9,10,17,16],[10,11,18,17],[11,12,19,18]]
8879         for i in xrange(m1c.getNumberOfCells()):
8880             self.assertEqual(expected2[i],m1c.getNodeIdsOfCell(i))
8881             pass
8882         # test in 3D
8883         m1c.setCoordsAt(2,coordsZ);
8884         expected3=[[0,1,6,5,20,21,26,25],[1,2,7,6,21,22,27,26],[2,3,8,7,22,23,28,27],[3,4,9,8,23,24,29,28],[4,5,11,10,24,25,31,30],[5,6,12,11,25,26,32,31],[6,7,13,12,26,27,33,32],[7,8,14,13,27,28,34,33],[8,9,16,15,28,29,36,35],[9,10,17,16,29,30,37,36],[10,11,18,17,30,31,38,37],[11,12,19,18,31,32,39,38],[20,21,26,25,40,41,46,45],[21,22,27,26,41,42,47,46],[22,23,28,27,42,43,48,47],[23,24,29,28,43,44,49,48],[24,25,31,30,44,45,51,50],[25,26,32,31,45,46,52,51],[26,27,33,32,46,47,53,52],[27,28,34,33,47,48,54,53],[28,29,36,35,48,49,56,55],[29,30,37,36,49,50,57,56],[30,31,38,37,50,51,58,57],[31,32,39,38,51,52,59,58]]
8885         self.assertEqual(24,m1c.getNumberOfCells())
8886         for i in xrange(m1c.getNumberOfCells()):
8887             self.assertEqual(expected3[i],m1c.getNodeIdsOfCell(i))
8888             pass
8889         pass
8890
8891     def testSwigDADOp4(self):
8892         da=DataArrayDouble.New(range(6,30),12,2)
8893         self.assertEqual(12,da.getNumberOfTuples());
8894         self.assertEqual(2,da.getNumberOfComponents());
8895         for i in xrange(24):
8896             self.assertAlmostEqual(da.getIJ(0,i),float(i+6),13)
8897             pass
8898         # operator transpose
8899         da.transpose()
8900         self.assertEqual(2,da.getNumberOfTuples());
8901         self.assertEqual(12,da.getNumberOfComponents());
8902         for i in xrange(24):
8903             self.assertAlmostEqual(da.getIJ(0,i),float(i+6),13)
8904             pass
8905         da.transpose()
8906         # operator __neg__
8907         da2=DataArrayDouble.New(12,1)
8908         da2.iota(0.)
8909         dabis=-da
8910         for i in xrange(24):
8911             self.assertAlmostEqual(dabis.getIJ(0,i),-float(i+6),13)
8912             pass
8913         # operator+=
8914         da+=da2
8915         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.]
8916         for i in xrange(24):
8917             self.assertAlmostEqual(da.getIJ(0,i),expected1[i],13)
8918             pass
8919         da=-dabis
8920         da+=[100.,101.]
8921         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.]
8922         self.assertEqual(12,da.getNumberOfTuples());
8923         self.assertEqual(2,da.getNumberOfComponents());
8924         for i in xrange(24):
8925             self.assertAlmostEqual(da.getIJ(0,i),expected2[i],13)
8926             pass
8927         for pos,elt in enumerate(dabis):
8928             da[pos]+=elt
8929             pass
8930         self.assertEqual(12,da.getNumberOfTuples());
8931         self.assertEqual(2,da.getNumberOfComponents());
8932         for elt in da:
8933             li=elt[:]
8934             self.assertAlmostEqual(li[0],100.,13) ; self.assertAlmostEqual(li[1],101.,13)
8935             pass
8936         # operator-=
8937         da=DataArrayDouble.New(range(6,30),12,2)
8938         da2=DataArrayDouble.New(range(12),12,1)
8939         dabis=-da
8940         da-=da2
8941         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.]
8942         for i in xrange(24):
8943             self.assertAlmostEqual(da.getIJ(0,i),expected1[i],13)
8944             pass
8945         da=-dabis
8946         da-=[100.,101.]
8947         expected2=[-94.,-94.,-92.,-92.,-90.,-90.,-88.,-88.,-86.,-86.,-84.,-84.,-82.,-82.,-80.,-80.,-78.,-78.,-76.,-76.,-74.,-74.,-72.,-72.]
8948         self.assertEqual(12,da.getNumberOfTuples());
8949         self.assertEqual(2,da.getNumberOfComponents());
8950         for i in xrange(24):
8951             self.assertAlmostEqual(da.getIJ(0,i),expected2[i],13)
8952             pass
8953         for pos,elt in enumerate(dabis):
8954             da[pos]-=elt
8955             pass
8956         self.assertEqual(12,da.getNumberOfTuples());
8957         self.assertEqual(2,da.getNumberOfComponents());
8958         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.]
8959         for i in xrange(24):
8960             self.assertAlmostEqual(da.getIJ(0,i),expected3[i],13)
8961             pass
8962         # operator*=
8963         da=DataArrayDouble.New(range(6,30),12,2)
8964         da2=DataArrayDouble.New(range(12),12,1)
8965         dabis=-da
8966         da*=da2
8967         expected1=[0.,0.,8.,9.,20.,22.,36.,39.,56.,60.,80.,85.,108.,114.,140.,147.,176.,184.,216.,225.,260.,270.,308.,319.]
8968         for i in xrange(24):
8969             self.assertAlmostEqual(da.getIJ(0,i),expected1[i],13)
8970             pass
8971         da=-dabis
8972         da*=[100.,101.]
8973         expected2=[600.,707.,800.,909.,1000.,1111.,1200.,1313.,1400.,1515.,1600.,1717.,1800.,1919.,2000.,2121.,2200.,2323.,2400.,2525.,2600.,2727.,2800.,2929.]
8974         self.assertEqual(12,da.getNumberOfTuples());
8975         self.assertEqual(2,da.getNumberOfComponents());
8976         for i in xrange(24):
8977             self.assertAlmostEqual(da.getIJ(0,i),expected2[i],13)
8978             pass
8979         for pos,elt in enumerate(dabis):
8980             da[pos]*=elt
8981             pass
8982         self.assertEqual(12,da.getNumberOfTuples());
8983         self.assertEqual(2,da.getNumberOfComponents());
8984         expected3=[-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]
8985         for i in xrange(24):
8986             self.assertAlmostEqual(da.getIJ(0,i),expected3[i],13)
8987             pass
8988         # operator/=
8989         da=DataArrayDouble.New(range(6,30),12,2)
8990         da2=DataArrayDouble.New(range(1,13),12,1)
8991         dabis=-da
8992         da/=da2
8993         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]
8994         for i in xrange(24):
8995             self.assertAlmostEqual(da.getIJ(0,i),expected1[i],13)
8996             pass
8997         da=-dabis
8998         da/=[100.,101.]
8999         expected2=[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]
9000         self.assertEqual(12,da.getNumberOfTuples());
9001         self.assertEqual(2,da.getNumberOfComponents());
9002         for i in xrange(24):
9003             self.assertAlmostEqual(da.getIJ(0,i),expected2[i],13)
9004             pass
9005         for pos,elt in enumerate(dabis):
9006             da[pos]/=elt
9007             pass
9008         self.assertEqual(12,da.getNumberOfTuples());
9009         self.assertEqual(2,da.getNumberOfComponents());
9010         expected3=[-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]
9011         for i in xrange(24):
9012             self.assertAlmostEqual(da.getIJ(0,i),expected3[i],13)
9013             pass
9014         pass
9015
9016     def testSwigDAIOp4(self):
9017         da=DataArrayInt.New(range(6,30),12,2)
9018         self.assertEqual(12,da.getNumberOfTuples());
9019         self.assertEqual(2,da.getNumberOfComponents());
9020         for i in xrange(24):
9021             self.assertEqual(da.getIJ(0,i),i+6)
9022             pass
9023         # operator transpose
9024         da.transpose()
9025         self.assertEqual(2,da.getNumberOfTuples());
9026         self.assertEqual(12,da.getNumberOfComponents());
9027         for i in xrange(24):
9028             self.assertEqual(da.getIJ(0,i),i+6)
9029             pass
9030         da.transpose()
9031         # operator __neg__
9032         da2=DataArrayInt.New(12,1)
9033         da2.iota(0)
9034         dabis=-da
9035         for i in xrange(24):
9036             self.assertEqual(dabis.getIJ(0,i),-(i+6))
9037             pass
9038         # operator+=
9039         da+=da2
9040         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]
9041         for i in xrange(24):
9042             self.assertEqual(da.getIJ(0,i),expected1[i])
9043             pass
9044         da=-dabis
9045         da+=[100,101]
9046         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]
9047         self.assertEqual(12,da.getNumberOfTuples());
9048         self.assertEqual(2,da.getNumberOfComponents());
9049         for i in xrange(24):
9050             self.assertEqual(da.getIJ(0,i),expected2[i])
9051             pass
9052         for pos,elt in enumerate(dabis):
9053             da[pos]+=elt
9054             pass
9055         self.assertEqual(12,da.getNumberOfTuples());
9056         self.assertEqual(2,da.getNumberOfComponents());
9057         for elt in da:
9058             li=elt[:]
9059             self.assertEqual(li[0],100) ; self.assertEqual(li[1],101)
9060             pass
9061         # operator-=
9062         da=DataArrayInt.New(range(6,30),12,2)
9063         da2=DataArrayInt.New(range(12),12,1)
9064         dabis=-da
9065         da-=da2
9066         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]
9067         for i in xrange(24):
9068             self.assertEqual(da.getIJ(0,i),expected1[i])
9069             pass
9070         da=-dabis
9071         da-=[100,101]
9072         expected2=[-94,-94,-92,-92,-90,-90,-88,-88,-86,-86,-84,-84,-82,-82,-80,-80,-78,-78,-76,-76,-74,-74,-72,-72]
9073         self.assertEqual(12,da.getNumberOfTuples());
9074         self.assertEqual(2,da.getNumberOfComponents());
9075         for i in xrange(24):
9076             self.assertEqual(da.getIJ(0,i),expected2[i])
9077             pass
9078         for pos,elt in enumerate(dabis):
9079             da[pos]-=elt
9080             pass
9081         self.assertEqual(12,da.getNumberOfTuples());
9082         self.assertEqual(2,da.getNumberOfComponents());
9083         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]
9084         for i in xrange(24):
9085             self.assertEqual(da.getIJ(0,i),expected3[i])
9086             pass
9087         # operator*=
9088         da=DataArrayInt.New(range(6,30),12,2)
9089         da2=DataArrayInt.New(range(12),12,1)
9090         dabis=-da
9091         da*=da2
9092         expected1=[0,0,8,9,20,22,36,39,56,60,80,85,108,114,140,147,176,184,216,225,260,270,308,319]
9093         for i in xrange(24):
9094             self.assertEqual(da.getIJ(0,i),expected1[i])
9095             pass
9096         da=-dabis
9097         da*=[100,101]
9098         expected2=[600,707,800,909,1000,1111,1200,1313,1400,1515,1600,1717,1800,1919,2000,2121,2200,2323,2400,2525,2600,2727,2800,2929]
9099         self.assertEqual(12,da.getNumberOfTuples());
9100         self.assertEqual(2,da.getNumberOfComponents());
9101         for i in xrange(24):
9102             self.assertEqual(da.getIJ(0,i),expected2[i])
9103             pass
9104         for pos,elt in enumerate(dabis):
9105             da[pos]*=elt
9106             pass
9107         self.assertEqual(12,da.getNumberOfTuples());
9108         self.assertEqual(2,da.getNumberOfComponents());
9109         expected3=[-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]
9110         for i in xrange(24):
9111             self.assertEqual(da.getIJ(0,i),expected3[i])
9112             pass
9113         # operator/=
9114         da=DataArrayInt.New(range(6,30),12,2)
9115         da2=DataArrayInt.New(range(1,13),12,1)
9116         dabis=-da
9117         da/=da2
9118         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]
9119         for i in xrange(24):
9120             self.assertEqual(da.getIJ(0,i),expected1[i])
9121             pass
9122         da=-dabis
9123         da/=DataArrayInt.New([2,3],1,2)
9124         self.assertEqual(12,da.getNumberOfTuples());
9125         self.assertEqual(2,da.getNumberOfComponents());
9126         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]
9127         for i in xrange(24):
9128             self.assertEqual(da.getIJ(0,i),expected2[i])
9129             pass
9130         pass
9131
9132     def testSwigDADOp5(self):
9133         da=DataArrayDouble.New([5,6,7,8,9,6,7,-2,3,9,8,10])
9134         da.rearrange(3)
9135         da2=DataArrayDouble.New([5.,8.,10.,12])
9136         self.assertEqual(4,da2.getNumberOfTuples());
9137         self.assertEqual(1,da2.getNumberOfComponents());
9138         da3=da+da2
9139         self.assertEqual(4,da3.getNumberOfTuples());
9140         self.assertEqual(3,da3.getNumberOfComponents());
9141         expected1=[10.,11.,12.,16.,17.,14.,17.,8.,13.,21.,20.,22.]
9142         for i in xrange(12):
9143             self.assertAlmostEqual(da3.getIJ(0,i),expected1[i],13)
9144             pass
9145         da3=da2+da
9146         self.assertEqual(4,da3.getNumberOfTuples());
9147         self.assertEqual(3,da3.getNumberOfComponents());
9148         for i in xrange(12):
9149             self.assertAlmostEqual(da3.getIJ(0,i),expected1[i],13)
9150             pass
9151         # Test new API of classmethod DataArrayDouble.New
9152         vals=[5,6,7,8,9,6,7,-2,3,9,8,10]
9153         da=DataArrayDouble.New(vals)
9154         self.assertEqual(12,da.getNumberOfTuples());
9155         self.assertEqual(1,da.getNumberOfComponents());
9156         for i in xrange(12):
9157             self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
9158             pass
9159         da=DataArrayDouble.New(vals,12)
9160         self.assertEqual(12,da.getNumberOfTuples());
9161         self.assertEqual(1,da.getNumberOfComponents());
9162         for i in xrange(12):
9163             self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
9164             pass
9165         da=DataArrayDouble.New(vals,1,12)
9166         self.assertEqual(1,da.getNumberOfTuples());
9167         self.assertEqual(12,da.getNumberOfComponents());
9168         for i in xrange(12):
9169             self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
9170             pass
9171         da=DataArrayDouble.New(vals,6,2)
9172         self.assertEqual(6,da.getNumberOfTuples());
9173         self.assertEqual(2,da.getNumberOfComponents());
9174         for i in xrange(12):
9175             self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
9176             pass
9177         da=DataArrayDouble.New(vals,4,3)
9178         self.assertEqual(4,da.getNumberOfTuples());
9179         self.assertEqual(3,da.getNumberOfComponents());
9180         for i in xrange(12):
9181             self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
9182             pass
9183         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,11);
9184         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,13);
9185         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,5,2);
9186         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,7,2);
9187         pass
9188
9189     def testSwigDADOp6(self):
9190         da=DataArrayInt.New([5,6,7,8,9,6,7,-2,3,9,8,10])
9191         da.rearrange(3)
9192         da2=DataArrayInt.New([5,8,10,12])
9193         self.assertEqual(4,da2.getNumberOfTuples());
9194         self.assertEqual(1,da2.getNumberOfComponents());
9195         da3=da+da2
9196         self.assertEqual(4,da3.getNumberOfTuples());
9197         self.assertEqual(3,da3.getNumberOfComponents());
9198         expected1=[10,11,12,16,17,14,17,8,13,21,20,22]
9199         for i in xrange(12):
9200             self.assertEqual(da3.getIJ(0,i),expected1[i])
9201             pass
9202         da3=da2+da
9203         self.assertEqual(4,da3.getNumberOfTuples());
9204         self.assertEqual(3,da3.getNumberOfComponents());
9205         for i in xrange(12):
9206             self.assertEqual(da3.getIJ(0,i),expected1[i])
9207             pass
9208         da3=da+DataArrayInt.New(da2.getValues())
9209         # Test new API of classmethod DataArrayInt.New
9210         vals=[5,6,7,8,9,6,7,-2,3,9,8,10]
9211         da=DataArrayDouble.New(vals)
9212         self.assertEqual(12,da.getNumberOfTuples());
9213         self.assertEqual(1,da.getNumberOfComponents());
9214         for i in xrange(12):
9215             self.assertEqual(da.getIJ(0,i),vals[i])
9216             pass
9217         da=DataArrayDouble.New(vals,12)
9218         self.assertEqual(12,da.getNumberOfTuples());
9219         self.assertEqual(1,da.getNumberOfComponents());
9220         for i in xrange(12):
9221             self.assertEqual(da.getIJ(0,i),vals[i])
9222             pass
9223         da=DataArrayDouble.New(vals,1,12)
9224         self.assertEqual(1,da.getNumberOfTuples());
9225         self.assertEqual(12,da.getNumberOfComponents());
9226         for i in xrange(12):
9227             self.assertEqual(da.getIJ(0,i),vals[i])
9228             pass
9229         da=DataArrayDouble.New(vals,6,2)
9230         self.assertEqual(6,da.getNumberOfTuples());
9231         self.assertEqual(2,da.getNumberOfComponents());
9232         for i in xrange(12):
9233             self.assertEqual(da.getIJ(0,i),vals[i])
9234             pass
9235         da=DataArrayDouble.New(vals,4,3)
9236         self.assertEqual(4,da.getNumberOfTuples());
9237         self.assertEqual(3,da.getNumberOfComponents());
9238         for i in xrange(12):
9239             self.assertEqual(da.getIJ(0,i),vals[i])
9240             pass
9241         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,11);
9242         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,13);
9243         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,5,2);
9244         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,7,2);
9245         pass
9246
9247     def testSwigDADOp9(self):
9248         l1=[(1.,2.,3),(4.,5.,6.),(7.,8.,9.),[10.,11.,12.]]
9249         da1=DataArrayDouble(l1,4,3)
9250         self.assertEqual(4,da1.getNumberOfTuples());
9251         self.assertEqual(3,da1.getNumberOfComponents());
9252         da2=DataArrayDouble(12) ; da2.iota(1.) ; da2.rearrange(3)
9253         self.assertTrue(da2.isEqual(da1,1e-12))
9254         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,3,4);
9255         da3=DataArrayDouble(l1,4)
9256         self.assertTrue(da3.isEqual(da1,1e-12))
9257         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,3);
9258         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,5);
9259         l1=[(1.,2.,3),(4.,(5.),((6.))),(7.,8.,9.),[10.,11.,12.]]
9260         da1=DataArrayDouble(l1,4,3)
9261         self.assertEqual(4,da1.getNumberOfTuples());
9262         self.assertEqual(3,da1.getNumberOfComponents());
9263         da2=DataArrayDouble(12) ; da2.iota(1.) ; da2.rearrange(3)
9264         self.assertTrue(da2.isEqual(da1,1e-12))
9265         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,3,4);
9266         da3=DataArrayDouble(l1,4)
9267         self.assertTrue(da3.isEqual(da1,1e-12))
9268         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,3);
9269         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,5);
9270         #
9271         l1=[(1,2,3),(4,5,6),(7,8,9),[10,11,12]]
9272         da1=DataArrayInt(l1,4,3)
9273         self.assertEqual(4,da1.getNumberOfTuples());
9274         self.assertEqual(3,da1.getNumberOfComponents());
9275         da2=DataArrayInt(12) ; da2.iota(1) ; da2.rearrange(3)
9276         self.assertTrue(da2.isEqual(da1))
9277         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,3,4);
9278         da3=DataArrayInt(l1,4)
9279         self.assertTrue(da3.isEqual(da1))
9280         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,3);
9281         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,5);
9282         l1=[(1,[2],3),(4,[(5)],6),((([7])),8,9),[10,11,12]]
9283         da1=DataArrayInt(l1,4,3)
9284         self.assertEqual(4,da1.getNumberOfTuples());
9285         self.assertEqual(3,da1.getNumberOfComponents());
9286         da2=DataArrayInt(12) ; da2.iota(1) ; da2.rearrange(3)
9287         self.assertTrue(da2.isEqual(da1))
9288         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,3,4);
9289         da3=DataArrayInt(l1,4)
9290         self.assertTrue(da3.isEqual(da1))
9291         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,3);
9292         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,5);
9293         pass
9294
9295     def testRenumberNodesInConn1(self):
9296         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. ]
9297         mesh2DConn=[1,4,2, 4,5,2, 0,3,4,1, 6,7,4,3, 7,8,5,4]
9298         mesh2D=MEDCouplingUMesh.New("mesh",2);
9299         mesh2D.allocateCells(5);
9300         mesh2D.insertNextCell(NORM_TRI3,3,mesh2DConn[0:3])
9301         mesh2D.insertNextCell(NORM_TRI3,3,mesh2DConn[3:6])
9302         mesh2D.insertNextCell(NORM_QUAD4,4,mesh2DConn[6:10])
9303         mesh2D.insertNextCell(NORM_QUAD4,4,mesh2DConn[10:14])
9304         mesh2D.insertNextCell(NORM_QUAD4,4,mesh2DConn[14:18])
9305         mesh2D.finishInsertingCells();
9306         myCoords=DataArrayDouble.New(mesh2DCoords,9,3);
9307         mesh2D.setCoords(myCoords);
9308         mesh2D.checkCoherency();
9309         #
9310         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. ]
9311         mesh3DConn=[0,1,2,3,4,5,6,7]
9312         mesh3D=MEDCouplingUMesh.New("mesh",3);
9313         mesh3D.allocateCells(1);
9314         mesh3D.insertNextCell(NORM_HEXA8,8,mesh3DConn[:])
9315         mesh3D.finishInsertingCells();
9316         myCoords3D=DataArrayDouble.New(mesh3DCoords,8,3);
9317         mesh3D.setCoords(myCoords3D);
9318         mesh3D.checkCoherency();
9319         #
9320         mesh3D_2=mesh3D.deepCpy();
9321         mesh2D_2=mesh2D.deepCpy();
9322         mesh3D_4=mesh3D.deepCpy();
9323         mesh2D_4=mesh2D.deepCpy();
9324         oldNbOf3DNodes=mesh3D.getNumberOfNodes();
9325         renumNodes=DataArrayInt.New();
9326         renumNodes.alloc(mesh2D.getNumberOfNodes(),1);
9327         renumNodes.iota(oldNbOf3DNodes);
9328         coo=DataArrayDouble.Aggregate(mesh3D.getCoords(),mesh2D.getCoords());
9329         mesh3D.setCoords(coo);
9330         mesh2D.setCoords(coo);
9331         mesh2DCpy=mesh2D.deepCpy()
9332         mesh2D_3=mesh2D.deepCpy();
9333         mesh2D_3.shiftNodeNumbersInConn(oldNbOf3DNodes);
9334         mesh2D.renumberNodesInConn(renumNodes);
9335         mesh2DCpy.renumberNodesInConn(renumNodes.getValues());
9336         self.assertTrue(mesh2D.isEqual(mesh2DCpy,1e-12))
9337         self.assertTrue(mesh2D.isEqual(mesh2D_3,1e-12))
9338         #
9339         da1,da2=mesh3D.checkGeoEquivalWith(mesh3D_2,10,1e-12);
9340         self.assertTrue(da1==None);
9341         self.assertEqual(8,da2.getNumberOfTuples());
9342         self.assertEqual(1,da2.getNumberOfComponents());
9343         expected1=[8,11,12,9,4,5,6,7]
9344         for i in xrange(8):
9345             self.assertEqual(expected1[i],da2.getIJ(i,0));
9346             pass
9347         #
9348         da1,da2=mesh2D.checkGeoEquivalWith(mesh2D_2,10,1e-12);
9349         self.assertTrue(da1==None);
9350         self.assertEqual(9,da2.getNumberOfTuples());
9351         self.assertEqual(1,da2.getNumberOfComponents());
9352         for i in xrange(9):
9353             self.assertEqual(8+i,da2.getIJ(i,0));
9354             pass
9355         #
9356         mesh2D_5=mesh2D_4.deepCpy();
9357         mesh2D_5.translate([1.,0.,0.]);
9358         meshes=[mesh3D_4,mesh2D_4,mesh2D_5];
9359         MEDCouplingUMesh.PutUMeshesOnSameAggregatedCoords(meshes);
9360         self.assertTrue(mesh3D_4.getCoords().getHiddenCppPointer()==mesh2D_4.getCoords().getHiddenCppPointer());
9361         self.assertTrue(mesh2D_4.getCoords().getHiddenCppPointer()==mesh2D_5.getCoords().getHiddenCppPointer());
9362         mesh3D_4.checkCoherency(); mesh2D_4.checkCoherency(); mesh2D_5.checkCoherency();
9363         self.assertEqual(26,mesh3D_4.getNumberOfNodes());
9364         self.assertEqual(3,mesh3D_4.getSpaceDimension());
9365         self.assertEqual(9,mesh3D_4.getNodalConnectivity().getNumberOfTuples());
9366         self.assertEqual(23,mesh2D_4.getNodalConnectivity().getNumberOfTuples());
9367         self.assertEqual(23,mesh2D_5.getNodalConnectivity().getNumberOfTuples());
9368         expected2=[18,0,1,2,3,4,5,6,7]
9369         expected3=[3,9,12,10, 3,12,13,10, 4,8,11,12,9, 4,14,15,12,11, 4,15,16,13,12]
9370         expected4=[3,18,21,19, 3,21,22,19, 4,17,20,21,18, 4,23,24,21,20, 4,24,25,22,21]
9371         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]
9372         self.assertEqual(expected2,mesh3D_4.getNodalConnectivity().getValues());
9373         self.assertEqual(expected3,mesh2D_4.getNodalConnectivity().getValues());
9374         self.assertEqual(expected4,mesh2D_5.getNodalConnectivity().getValues());
9375         for i in xrange(78):
9376             self.assertAlmostEqual(expected5[i],mesh3D_4.getCoords().getIJ(0,i),12);
9377             pass
9378         #
9379         MEDCouplingUMesh.MergeNodesOnUMeshesSharingSameCoords(meshes,1e-12);
9380         mesh3D_4.checkCoherency(); mesh2D_4.checkCoherency(); mesh2D_5.checkCoherency();
9381         self.assertTrue(mesh3D_4.getCoords().getHiddenCppPointer()==mesh2D_4.getCoords().getHiddenCppPointer());
9382         self.assertTrue(mesh2D_4.getCoords().getHiddenCppPointer()==mesh2D_5.getCoords().getHiddenCppPointer());
9383         self.assertEqual(19,mesh3D_4.getNumberOfNodes());
9384         self.assertEqual(3,mesh3D_4.getSpaceDimension());
9385         self.assertEqual(9,mesh3D_4.getNodalConnectivity().getNumberOfTuples());
9386         self.assertEqual(23,mesh2D_4.getNodalConnectivity().getNumberOfTuples());
9387         self.assertEqual(23,mesh2D_5.getNodalConnectivity().getNumberOfTuples());
9388         expected6=[18,0,1,2,3,4,5,6,7]
9389         expected7=[3,3,2,8, 3,2,9,8, 4,0,1,2,3, 4,10,11,2,1, 4,11,12,9,2]
9390         expected8=[3,13,15,14, 3,15,16,14, 4,8,9,15,13, 4,12,17,15,9, 4,17,18,16,15]
9391         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.,
9392                     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.,
9393                     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.]
9394         self.assertEqual(expected6,mesh3D_4.getNodalConnectivity().getValues());
9395         self.assertEqual(expected7,mesh2D_4.getNodalConnectivity().getValues());
9396         self.assertEqual(expected8,mesh2D_5.getNodalConnectivity().getValues());
9397         for i in xrange(57):
9398             self.assertAlmostEqual(expected9[i],mesh3D_4.getCoords().getIJ(0,i),12);
9399             pass
9400         #
9401         pass
9402
9403     def testComputeNeighborsOfCells1(self):
9404         m=MEDCouplingDataForTest.build2DTargetMesh_1();
9405         d1,d2=m.computeNeighborsOfCells();
9406         self.assertEqual(6,d2.getNumberOfTuples());
9407         self.assertEqual(10,d1.getNumberOfTuples());
9408         expected1=[0,2,4,6,8,10]
9409         expected2=[3,1,0,2,4,1,4,0,2,3]
9410         self.assertEqual(expected1,d2.getValues());
9411         self.assertEqual(expected2,d1.getValues());
9412         pass
9413
9414     def testCheckButterflyCellsBug1(self):
9415         mesh2DCoords=[323.85,120.983748908684,317.5,131.982271536747,336.55,120.983748908686,330.2,131.982271536751,323.85,142.98079416481]
9416         mesh2DConn=[4,1,0,2,3]
9417         mesh2D=MEDCouplingUMesh.New("mesh",2);
9418         mesh2D.allocateCells(1);
9419         mesh2D.insertNextCell(NORM_POLYGON,5,mesh2DConn[0:5])
9420         mesh2D.finishInsertingCells();
9421         myCoords=DataArrayDouble.New(mesh2DCoords,5,2);
9422         mesh2D.setCoords(myCoords);
9423         mesh2D.checkCoherency();
9424         #
9425         v=mesh2D.checkButterflyCells();
9426         self.assertTrue(v.empty());
9427         pass
9428
9429     def testDataArrayIntRange1(self):
9430         d=DataArrayInt.Range(2,17,7);
9431         expected1=[2,9,16]
9432         self.assertEqual(3,d.getNumberOfTuples());
9433         self.assertEqual(1,d.getNumberOfComponents());
9434         self.assertEqual(expected1,d.getValues());
9435         #
9436         d=DataArrayInt.Range(2,23,7);
9437         self.assertEqual(3,d.getNumberOfTuples());
9438         self.assertEqual(1,d.getNumberOfComponents());
9439         self.assertEqual(expected1,d.getValues());
9440         #
9441         d=DataArrayInt.Range(2,24,7);
9442         expected2=[2,9,16,23]
9443         self.assertEqual(4,d.getNumberOfTuples());
9444         self.assertEqual(1,d.getNumberOfComponents());
9445         self.assertEqual(expected2,d.getValues());
9446         #
9447         d=DataArrayInt.Range(24,2,-7);
9448         expected3=[24,17,10,3]
9449         self.assertEqual(4,d.getNumberOfTuples());
9450         self.assertEqual(1,d.getNumberOfComponents());
9451         self.assertEqual(expected3,d.getValues());
9452         #
9453         d=DataArrayInt.Range(23,2,-7);
9454         expected4=[23,16,9]
9455         self.assertEqual(3,d.getNumberOfTuples());
9456         self.assertEqual(1,d.getNumberOfComponents());
9457         self.assertEqual(expected4,d.getValues());
9458         #
9459         d=DataArrayInt.Range(23,22,-7);
9460         self.assertEqual(1,d.getNumberOfTuples());
9461         self.assertEqual(1,d.getNumberOfComponents());
9462         self.assertEqual(23,d.getIJ(0,0));
9463         #
9464         d=DataArrayInt.Range(22,23,7);
9465         self.assertEqual(1,d.getNumberOfTuples());
9466         self.assertEqual(1,d.getNumberOfComponents());
9467         self.assertEqual(22,d.getIJ(0,0));
9468         #
9469         d=DataArrayInt.Range(22,22,7);
9470         self.assertEqual(0,d.getNumberOfTuples());
9471         self.assertEqual(1,d.getNumberOfComponents());
9472         #
9473         d=DataArrayInt.Range(22,22,-7);
9474         self.assertEqual(0,d.getNumberOfTuples());
9475         self.assertEqual(1,d.getNumberOfComponents());
9476         #
9477         self.assertRaises(InterpKernelException,DataArrayInt.Range,22,23,-7);
9478         self.assertRaises(InterpKernelException,DataArrayInt.Range,23,22,7);
9479         self.assertRaises(InterpKernelException,DataArrayInt.Range,23,22,0);
9480         self.assertRaises(InterpKernelException,DataArrayInt.Range,22,23,0);
9481         pass
9482
9483     def testSwigUMeshGetItem1(self):
9484         m=MEDCouplingDataForTest.build2DTargetMesh_1();
9485         subMesh=m.buildPartOfMySelf([1,3],True);
9486         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
9487         m1=m[[1,3]]
9488         self.assertTrue(isinstance(m1,MEDCouplingUMesh))
9489         m2=m[(1,3)]
9490         self.assertTrue(isinstance(m2,MEDCouplingUMesh))
9491         m3=m[1::2]
9492         self.assertTrue(isinstance(m3,MEDCouplingUMesh))
9493         m4=m[DataArrayInt.New([1,3])]
9494         m5_1=m[1]
9495         self.assertTrue(isinstance(m5_1,MEDCouplingUMesh))
9496         m5_2=m[3]
9497         self.assertTrue(isinstance(m5_2,MEDCouplingUMesh))
9498         m5=MEDCouplingUMesh.MergeUMeshesOnSameCoords([m5_1,m5_2]);
9499         m5.setName(subMesh.getName())
9500         self.assertTrue(isinstance(m4,MEDCouplingUMesh))
9501         self.assertTrue(subMesh.isEqual(m1,1e-12))
9502         self.assertTrue(subMesh.isEqual(m2,1e-12))
9503         self.assertTrue(subMesh.isEqual(m3,1e-12))
9504         self.assertTrue(subMesh.isEqual(m4,1e-12))
9505         self.assertTrue(subMesh.isEqual(m5,1e-12))
9506         self.assertRaises(InterpKernelException,m.buildPartOfMySelf,[1,5],True);
9507         pass
9508
9509     def testSwigGetItem3(self):
9510         da=DataArrayInt.New([4,5,6])
9511         self.assertEqual(5,da[1])
9512         self.assertRaises(InterpKernelException,da.__getitem__,-1)
9513         self.assertRaises(InterpKernelException,da.__getitem__,3)
9514         da=DataArrayInt.New([4,5,6,7,8,9],2,3)
9515         self.assertEqual(9,da[1,2])
9516         da=DataArrayDouble.New([4.1,5.2,6.3])
9517         self.assertAlmostEqual(5.2,da[1],12)
9518         self.assertRaises(InterpKernelException,da.__getitem__,-1)
9519         self.assertRaises(InterpKernelException,da.__getitem__,3)
9520         da=DataArrayDouble.New([4.12,5.12,6.12,7.12,8.12,9.12],2,3)
9521         self.assertAlmostEqual(9.12,da[1,2],12)
9522         pass
9523
9524     def testSwigDADISub1(self):
9525         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
9526         bary=mesh3D.getBarycenterAndOwner()
9527         bary=bary[:,:2]
9528         pts=bary.getDifferentValues(1e-12)
9529         expected=[[0,6,12],[1,7,13],[2,8,14],[3,9,15],[4,10,16],[5,11,17]]
9530         for pos,pt in enumerate(pts):
9531             bary2=bary[:,:2]
9532             bary2[:]-=pt
9533             norm=bary2.magnitude()
9534             self.assertEqual(expected[pos],norm.getIdsInRange(-1.,1e-5).getValues())
9535             pass
9536         expected2=[[3.,54.],[-141.,180.],[21.,54.],[39.,72.],[-15.,90.],[21.,90.]]
9537         for pos,pt in enumerate(pts):
9538             bary2=bary[:,:2]
9539             bary2[:]+=pt
9540             self.assertAlmostEqual(expected2[pos][0],bary2.accumulate()[0],12);
9541             self.assertAlmostEqual(expected2[pos][1],bary2.accumulate()[1],12);
9542             pass
9543         expected3=[[-3.,22.5],[45.,337.5],[-9., 22.5],[-15.,67.5],[3.,112.5],[-9.,112.5]]
9544         for pos,pt in enumerate(pts):
9545             bary2=bary[:,:2]
9546             bary2[:]*=pt
9547             self.assertAlmostEqual(expected3[pos][0],bary2.accumulate()[0],12);
9548             self.assertAlmostEqual(expected3[pos][1],bary2.accumulate()[1],12);
9549             pass
9550         expected4=[[-12.,90.],[0.8,6.],[-4,90.],[-2.4,30.],[12.,18],[-4,18.]]
9551         for pos,pt in enumerate(pts):
9552             bary2=bary[:,:2]
9553             bary2[:]/=pt
9554             self.assertAlmostEqual(expected4[pos][0],bary2.accumulate()[0],12);
9555             self.assertAlmostEqual(expected4[pos][1],bary2.accumulate()[1],12);
9556             pass
9557         #
9558         d=DataArrayInt.New([1,2,0,1,0,2],3,2)
9559         e=DataArrayInt.New([1,11,101,2,12,102,3,13,103,4,14,104],4,3)
9560         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]]
9561         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]]
9562         for pos,tup in enumerate(d):
9563             f=e[:]
9564             self.assertTrue(isinstance(f,DataArrayInt))
9565             f[tup]=77
9566             self.assertEqual(expected5[pos],f.getValues())
9567             self.assertEqual(6*[77],f[tup].getValues())
9568             f=e[:]
9569             f[:,tup]=77
9570             self.assertEqual(expected6[pos],f.getValues())
9571             self.assertEqual(8*[77],f[:,tup].getValues())
9572             pass
9573         #
9574         e=e.convertToDblArr()
9575         for pos,tup in enumerate(d):
9576             f=e[:]
9577             self.assertTrue(isinstance(f,DataArrayDouble))
9578             f[tup]=77.
9579             self.assertEqual(expected5[pos],f.convertToIntArr().getValues())
9580             self.assertEqual(6*[77],f[tup].convertToIntArr().getValues())
9581             f=e[:]
9582             f[:,tup]=77.
9583             self.assertEqual(expected6[pos],f.convertToIntArr().getValues())
9584             self.assertEqual(8*[77],f[:,tup].convertToIntArr().getValues())
9585             pass
9586         pass
9587
9588     def testDataArrayDoubleGetMinMaxPerComponent1(self):
9589         values1=[1.,2.,3.,-0.9,2.1,3.,1.3,1.7,3.,1.,1.8,3.]
9590         d1=DataArrayDouble.New();
9591         self.assertRaises(InterpKernelException,d1.getMinMaxPerComponent)
9592         d1=DataArrayDouble.New(values1,4,3);
9593         res=d1.getMinMaxPerComponent();
9594         self.assertTrue(isinstance(res,list))
9595         self.assertEqual(3,len(res))
9596         for i in xrange(3):
9597             self.assertTrue(isinstance(res[i],tuple))
9598             self.assertEqual(2,len(res[i]))
9599             pass
9600         expected1=[-0.9,1.3,1.7,2.1,3.,3.]
9601         for i in xrange(6):
9602             self.assertAlmostEqual(expected1[i],res[i/2][i%2],14)
9603             pass
9604         #
9605         d1.rearrange(2);
9606         res=d1.getMinMaxPerComponent();
9607         self.assertTrue(isinstance(res,list))
9608         self.assertEqual(2,len(res))
9609         for i in xrange(2):
9610             self.assertTrue(isinstance(res[i],tuple))
9611             self.assertEqual(2,len(res[i]))
9612             pass
9613         expected2=[1.,3.,-0.9,3.]
9614         for i in xrange(4):
9615             self.assertAlmostEqual(expected2[i],res[i/2][i%2],14)
9616             pass
9617         #
9618         d1.rearrange(1);
9619         res=d1.getMinMaxPerComponent();
9620         self.assertTrue(isinstance(res,list))
9621         self.assertEqual(1,len(res))
9622         for i in xrange(1):
9623             self.assertTrue(isinstance(res[i],tuple))
9624             self.assertEqual(2,len(res[i]))
9625             pass
9626         expected3=[-0.9,3.]
9627         for i in xrange(2):
9628             self.assertAlmostEqual(expected3[i],res[i/2][i%2],14)
9629             pass
9630         pass
9631
9632     def testDataArrayIntGetHashCode1(self):
9633         d1=DataArrayInt.New(range(3545))
9634         d2=DataArrayInt.New(range(3545))
9635         self.assertEqual(d2.getHashCode(),d1.getHashCode())
9636         self.assertEqual(232341068,d1.getHashCode())
9637         d1[886]=6
9638         self.assertEqual(232340188,d1.getHashCode())
9639         pass
9640
9641     def testZipConnectivityPol1(self):
9642         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
9643         cells1=[2,3,4]
9644         m2_1=m1.buildPartOfMySelf(cells1,True);
9645         m2=m2_1
9646         self.assertTrue(isinstance(m2,MEDCouplingUMesh))
9647         # no permutation policy 0
9648         isOk,arr=m1.areCellsIncludedIn(m2,0)
9649         self.assertTrue(isOk);
9650         self.assertEqual(3,arr.getNumberOfTuples());
9651         self.assertEqual(1,arr.getNumberOfComponents());
9652         self.assertEqual(cells1,arr.getValues())
9653         # no permutation policy 1
9654         isOk,arr=m1.areCellsIncludedIn(m2,1)
9655         self.assertTrue(isOk);
9656         self.assertEqual(3,arr.getNumberOfTuples());
9657         self.assertEqual(1,arr.getNumberOfComponents());
9658         self.assertEqual(cells1,arr.getValues())
9659         # no permutation policy 2
9660         isOk,arr=m1.areCellsIncludedIn(m2,2)
9661         self.assertTrue(isOk);
9662         self.assertEqual(3,arr.getNumberOfTuples());
9663         self.assertEqual(1,arr.getNumberOfComponents());
9664         self.assertEqual(cells1,arr.getValues())
9665         # some modification into m2
9666         modif1=[2,4,5]
9667         m2.getNodalConnectivity()[1:4]=modif1
9668         #policy 0 fails because cell0 in m2 has same orientation be not same connectivity
9669         expected1=[5,3,4]
9670         isOk,arr=m1.areCellsIncludedIn(m2,0)
9671         self.assertTrue(not isOk);
9672         self.assertEqual(3,arr.getNumberOfTuples());
9673         self.assertEqual(1,arr.getNumberOfComponents());
9674         self.assertEqual(expected1,arr.getValues())
9675         #policy 1 succeeds because cell0 in m2 has not exactly the same conn
9676         isOk,arr=m1.areCellsIncludedIn(m2,1)
9677         self.assertTrue(isOk);
9678         self.assertEqual(3,arr.getNumberOfTuples());
9679         self.assertEqual(1,arr.getNumberOfComponents());
9680         self.assertEqual(cells1,arr.getValues())
9681         #policy 2 succeeds because cell0 in m2 has same nodes in connectivity
9682         isOk,arr=m1.areCellsIncludedIn(m2,2)
9683         self.assertTrue(isOk);
9684         self.assertEqual(3,arr.getNumberOfTuples());
9685         self.assertEqual(1,arr.getNumberOfComponents());
9686         self.assertEqual(cells1,arr.getValues())
9687         #some new modification into m2
9688         modif2=[2,5,4]
9689         m2.getNodalConnectivity()[1:4]=modif2
9690         #policy 0 fails because cell0 in m2 has not exactly the same conn
9691         isOk,arr=m1.areCellsIncludedIn(m2,0)
9692         self.assertTrue(not isOk);
9693         self.assertEqual(3,arr.getNumberOfTuples());
9694         self.assertEqual(1,arr.getNumberOfComponents());
9695         self.assertEqual(expected1,arr.getValues())
9696         #policy 1 fails too because cell0 in m2 has not same orientation
9697         isOk,arr=m1.areCellsIncludedIn(m2,1)
9698         self.assertTrue(not isOk);
9699         self.assertEqual(3,arr.getNumberOfTuples());
9700         self.assertEqual(1,arr.getNumberOfComponents());
9701         self.assertEqual(expected1,arr.getValues())
9702         #policy 2 succeeds because cell0 in m2 has same nodes in connectivity
9703         isOk,arr=m1.areCellsIncludedIn(m2,2)
9704         self.assertTrue(isOk);
9705         self.assertEqual(3,arr.getNumberOfTuples());
9706         self.assertEqual(1,arr.getNumberOfComponents());
9707         self.assertEqual(cells1,arr.getValues())
9708         # Now 1D
9709         cells2=[3,2]
9710         m1=MEDCouplingDataForTest.build1DSourceMesh_2();
9711         m2_1=m1.buildPartOfMySelf(cells2,True);
9712         m2=m2_1
9713         self.assertTrue(isinstance(m2,MEDCouplingUMesh))
9714         # no permutation policy 0
9715         isOk,arr=m1.areCellsIncludedIn(m2,0)
9716         self.assertTrue(isOk);
9717         self.assertEqual(2,arr.getNumberOfTuples());
9718         self.assertEqual(1,arr.getNumberOfComponents());
9719         self.assertEqual(cells2,arr.getValues())
9720         # no permutation policy 1
9721         isOk,arr=m1.areCellsIncludedIn(m2,1)
9722         self.assertTrue(isOk);
9723         self.assertEqual(2,arr.getNumberOfTuples());
9724         self.assertEqual(1,arr.getNumberOfComponents());
9725         self.assertEqual(cells2,arr.getValues())
9726         # no permutation policy 2
9727         isOk,arr=m1.areCellsIncludedIn(m2,2)
9728         self.assertTrue(isOk);
9729         self.assertEqual(2,arr.getNumberOfTuples());
9730         self.assertEqual(1,arr.getNumberOfComponents());
9731         self.assertEqual(cells2,arr.getValues())
9732         # some modification into m2
9733         modif3=[4,3]
9734         m2.getNodalConnectivity()[1:3]=modif3
9735         #policy 0 fails because cell0 in m2 has not exactly the same conn
9736         expected2=[4,2]
9737         isOk,arr=m1.areCellsIncludedIn(m2,0)
9738         self.assertTrue(not isOk);
9739         self.assertEqual(2,arr.getNumberOfTuples());
9740         self.assertEqual(1,arr.getNumberOfComponents());
9741         self.assertEqual(expected2,arr.getValues())
9742         #policy 1 fails too because cell0 in m2 has not same orientation
9743         isOk,arr=m1.areCellsIncludedIn(m2,1)
9744         self.assertTrue(not isOk);
9745         self.assertEqual(2,arr.getNumberOfTuples());
9746         self.assertEqual(1,arr.getNumberOfComponents());
9747         self.assertEqual(expected2,arr.getValues())
9748         #policy 2 succeeds because cell0 in m2 has same nodes in connectivity
9749         isOk,arr=m1.areCellsIncludedIn(m2,2)
9750         self.assertTrue(isOk);
9751         self.assertEqual(2,arr.getNumberOfTuples());
9752         self.assertEqual(1,arr.getNumberOfComponents());
9753         self.assertEqual(cells2,arr.getValues())
9754         pass
9755
9756     def toSeeIfDaIIopsAreOK(self,d):
9757         d+=5
9758         d*=6
9759         d/=3
9760         d-=2
9761         d%=7
9762         pass
9763
9764     def testSwigDAIOp5(self):
9765         d=DataArrayInt.New([4,5,6,10,3,-1],2,3)
9766         self.toSeeIfDaIIopsAreOK(d)
9767         dExp=DataArrayInt.New([2,4,6,0,0,6],2,3)
9768         self.assertTrue(d.isEqual(dExp));
9769         pass
9770
9771     def toSeeIfDaDIopsAreOK(self,d):
9772         d+=5
9773         d*=6
9774         d/=3
9775         d-=2
9776         pass
9777
9778     def testSwigDADOp7(self):
9779         d=DataArrayDouble.New([4.,5.,6.,10.,3.,-1.],2,3)
9780         self.toSeeIfDaDIopsAreOK(d)
9781         dExp=DataArrayDouble.New([16.,18.,20.,28.,14.,6.],2,3)
9782         self.assertTrue(d.isEqual(dExp,1e-14));
9783         pass
9784
9785     def testConvexEnvelop2D1(self):
9786         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]
9787         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]
9788         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]
9789         #
9790         m=MEDCouplingUMesh.New("convexhull",2);
9791         m.allocateCells(331);
9792         for i in xrange(331):
9793             m.insertNextCell(NORM_POLYGON,conn[connI[i]:connI[i+1]]);
9794             pass
9795         m.finishInsertingCells();
9796         coordsDa=DataArrayDouble.New(coords,331,2);
9797         m.setCoords(coordsDa);
9798         m.checkCoherency();
9799         #
9800         da=m.convexEnvelop2D();
9801         m.checkCoherency()
9802         self.assertEqual(coordsDa.getHiddenCppPointer(),m.getCoords().getHiddenCppPointer())
9803         daC=da.buildComplement(m.getNumberOfCells());
9804         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]);
9805         self.assertTrue(expected2.isEqual(daC));
9806         #
9807         vals=m.getMeasureField(ON_CELLS).getArray()
9808         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]
9809         vals-=DataArrayDouble.New(ref)
9810         vals.abs()
9811         theTest=vals.getIdsInRange(-1.,1e-7)
9812         self.assertTrue(theTest.isIdentity())
9813         self.assertEqual(331,len(theTest))
9814         pass
9815
9816     def testSwigDAIOp8(self):
9817         da=DataArrayInt.New([7,5,6,7,8,9,9,10,12,13,47,15])
9818         self.assertTrue(7 in da)
9819         self.assertTrue(47 in da)
9820         self.assertTrue(15 in da)
9821         self.assertEqual(0,da.index(7))
9822         self.assertEqual(10,da.index(47))
9823         self.assertTrue(14 not in da)
9824         self.assertEqual(5,da.search([9,9]))
9825         self.assertEqual(-1,da.search([5,8]))
9826         da.rearrange(2)
9827         self.assertTrue([47,16] not in da)
9828         self.assertTrue([5,6] not in da)
9829         self.assertTrue([6,7] in da)
9830         self.assertEqual(4,da.index([12,13]))
9831         pass
9832
9833     def testDataArraySort1(self):
9834         arr=DataArrayInt.New();
9835         self.assertRaises(InterpKernelException,arr.sort,True)
9836         self.assertRaises(InterpKernelException,arr.sort,False)
9837         values=[2,1,6,5,4,7]
9838         arr.alloc(3,2);
9839         self.assertRaises(InterpKernelException,arr.sort,True)
9840         self.assertRaises(InterpKernelException,arr.sort,False)
9841         arr.rearrange(1);
9842         arr.setValues(values,6,1)
9843         arr1=arr.deepCpy();
9844         arr2=arr.deepCpy();
9845         arr1.sort(True);
9846         expected1=[1,2,4,5,6,7]
9847         self.assertEqual(6,arr1.getNumberOfTuples());
9848         self.assertEqual(1,arr1.getNumberOfComponents());
9849         self.assertEqual(expected1,arr1.getValues());
9850         arr2.sort(False);
9851         expected2=[7,6,5,4,2,1]
9852         self.assertEqual(6,arr2.getNumberOfTuples());
9853         self.assertEqual(1,arr2.getNumberOfComponents());
9854         self.assertTrue(expected2,arr2.getValues());
9855         #
9856         ard=DataArrayDouble.New();
9857         self.assertRaises(InterpKernelException,ard.sort,True)
9858         self.assertRaises(InterpKernelException,ard.sort,False)
9859         valuesD=[2.,1.,6.,5.,4.,7.]
9860         ard.alloc(3,2);
9861         self.assertRaises(InterpKernelException,ard.sort,True)
9862         self.assertRaises(InterpKernelException,ard.sort,False)
9863         ard.rearrange(1);
9864         ard.setValues(valuesD,6,1)
9865         ard1=ard.deepCpy();
9866         ard2=ard.deepCpy();
9867         ard1.sort(True);
9868         expected3=[1.,2.,4.,5.,6.,7.]
9869         self.assertEqual(6,ard1.getNumberOfTuples());
9870         self.assertEqual(1,ard1.getNumberOfComponents());
9871         for i in xrange(6):
9872             self.assertAlmostEqual(expected3[i],ard1.getIJ(i,0),12)
9873             pass
9874         ard2.sort(False);
9875         expected4=[7.,6.,5.,4.,2.,1.]
9876         self.assertEqual(6,ard2.getNumberOfTuples());
9877         self.assertEqual(1,ard2.getNumberOfComponents());
9878         for i in xrange(6):
9879             self.assertAlmostEqual(expected4[i],ard2.getIJ(i,0),12)
9880             pass
9881         pass
9882
9883     def testPartitionBySpreadZone1(self):
9884         m=MEDCouplingDataForTest.build2DTargetMesh_1();
9885         m4=MEDCouplingUMesh.MergeUMeshes([m,m[-3:],m[0:2]]);
9886         m4.renumberCells([5,2,9,6,4,7,0,1,3,8]);
9887         #
9888         v2=m4.partitionBySpreadZone();
9889         self.assertTrue(3,len(v2));
9890         self.assertTrue(v2[0].isEqual(DataArrayInt.New([0,1,7])))
9891         self.assertTrue(v2[1].isEqual(DataArrayInt.New([2,4,5,6,9])))
9892         self.assertTrue(v2[2].isEqual(DataArrayInt.New([3,8])))
9893         #
9894         m5=m4.buildSpreadZonesWithPoly();
9895         self.assertEqual(3,m5.getNumberOfCells());
9896         self.assertTrue(m5.getCoords().getHiddenCppPointer()==m4.getCoords().getHiddenCppPointer());
9897         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())
9898         self.assertEqual([0,8,17,23],m5.getNodalConnectivityIndex().getValues())
9899         #
9900         pass
9901
9902     def testGiveCellsWithType1(self):
9903         expected0=[1,2]
9904         expected1=[0,3,4]
9905         m=MEDCouplingDataForTest.build2DTargetMesh_1();
9906         da=m.giveCellsWithType(NORM_TRI3);
9907         self.assertEqual(2,da.getNumberOfTuples());
9908         self.assertEqual(1,da.getNumberOfComponents());
9909         self.assertEqual(expected0,da.getValues())
9910         #
9911         da=m.giveCellsWithType(NORM_QUAD4);
9912         self.assertEqual(3,da.getNumberOfTuples());
9913         self.assertEqual(1,da.getNumberOfComponents());
9914         self.assertEqual(expected1,da.getValues())
9915         #
9916         da=m.giveCellsWithType(NORM_TRI6);
9917         self.assertEqual(0,da.getNumberOfTuples());
9918         self.assertEqual(1,da.getNumberOfComponents());
9919         #
9920         self.assertRaises(InterpKernelException,m.giveCellsWithType,NORM_SEG2)
9921         self.assertRaises(InterpKernelException,m.giveCellsWithType,NORM_HEXA8)
9922         pass
9923
9924     def testSwigDAOp1(self):
9925         d=DataArrayDouble.New(5,2)
9926         d.rearrange(1) ; d.iota(2.) ; d.rearrange(2)
9927         d.setInfoOnComponents(["X [m]","Y [m]"])
9928         d.setName("AName")
9929         #
9930         d1=d+[8,9]
9931         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))
9932         d1bis=DataArrayDouble.New([8,9],1,2)+d
9933         self.assertTrue(d1bis.isEqual(d1,1e-12))
9934         d1ter=[8,9]+d
9935         self.assertTrue(d1ter.isEqual(d1,1e-12))
9936         #
9937         d2=d1-[8,9]
9938         self.assertTrue(d2.isEqual(d,1e-12))
9939         self.assertRaises(InterpKernelException,d1.__rsub__,[8,9])#[8,9]-d1
9940         #
9941         d3=d*[8,9]
9942         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))
9943         d3bis=DataArrayDouble.New([8,9],1,2)*d
9944         self.assertTrue(d3bis.isEqual(d3,1e-12))
9945         d3ter=[8,9]*d
9946         self.assertTrue(d3ter.isEqual(d3,1e-12))
9947         #
9948         d4=d3/[8,9]
9949         self.assertTrue(d4.isEqual(d,1e-12))
9950         #
9951         d=DataArrayInt.New(5,2)
9952         d.rearrange(1) ; d.iota(2) ; d.rearrange(2)
9953         d.setInfoOnComponents(["X [m]","Y [m]"])
9954         d.setName("AName")
9955         #
9956         d1=d+[8,9]
9957         self.assertEqual(d1.getValues(),[10,12,12,14,14,16,16,18,18,20])
9958         d1bis=DataArrayInt.New([8,9],1,2)+d
9959         self.assertTrue(d1bis.isEqual(d1))
9960         d1ter=[8,9]+d
9961         self.assertTrue(d1ter.isEqual(d1))
9962         #
9963         d2=d1-[8,9]
9964         self.assertTrue(d2.isEqual(d))
9965         self.assertRaises(InterpKernelException,d1.__rsub__,[8,9])
9966         #
9967         d3=d*[8,9]
9968         self.assertEqual(d3.getValues(),[16,27,32,45,48,63,64,81,80,99])
9969         d3bis=DataArrayInt.New([8,9],1,2)*d
9970         self.assertTrue(d3bis.isEqual(d3))
9971         d3ter=[8,9]*d
9972         self.assertTrue(d3ter.isEqual(d3))
9973         #
9974         d4=d3/[8,9]
9975         self.assertTrue(d4.isEqual(d))
9976         #
9977         d5=d%[4,5]
9978         self.assertEqual(d5.getValues(),[2,3,0,0,2,2,0,4,2,1])
9979         pass
9980
9981     def testSwigSelectTupleId2DAIBug1(self):
9982         da=DataArrayInt.New([0,1,2,3,12,13,4,5,6,7,14,15,8,9,10,11,16,17])
9983         self.assertEqual([2,6,10],da[2::6].getValues())
9984         self.assertEqual([0,4,8],da[::6].getValues())
9985         self.assertEqual([5,9],da[7::6].getValues())
9986         self.assertEqual([5],da[7:-5:6].getValues())
9987         pass
9988
9989     def testSwigCpp5Safe1(self):
9990         m=MEDCouplingUMesh.New("toto",2)
9991         coords=DataArrayDouble.New([0.,0.,1.,0.,1.,1.,0.,1.],4,2)
9992         m.setCoords(coords)
9993         vecs=DataArrayDouble.New([2.,3.,4.,5.,6.,7.],3,2)
9994         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]]
9995         for pos,vec in enumerate(vecs):
9996             m2=m.deepCpy()
9997             m2.translate(vec)
9998             self.assertTrue(m2.getCoords().isEqual(DataArrayDouble.New(expected1[pos],4,2),1e-12))
9999             pass
10000         for pos,vec in enumerate(vecs):
10001             m2=m.deepCpy()
10002             m2.translate(vec.buildDADouble())
10003             self.assertTrue(m2.getCoords().isEqual(DataArrayDouble.New(expected1[pos],4,2),1e-12))
10004             pass
10005         pass
10006
10007     def testSwigBugNonRegressionZipDA(self):
10008         angles=map(lambda x:pi/3*x,xrange(6))
10009         radius=3
10010         #
10011         dad=DataArrayDouble.New(6, 2)
10012         dad[:,0]=radius
10013         dad[:,1]=angles
10014         #
10015         dad2=dad.fromPolarToCart()
10016         dads=[dad2.deepCpy() for elt in 7*[None]]
10017         #
10018         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.)]]
10019         for d,t in zip(dads,translationToPerform):
10020             d+=t
10021             pass
10022         for elt in dads:
10023             self.assertTrue(not dad2.isEqual(elt,1e-12))
10024             pass
10025         for d,t in zip(dads,translationToPerform):
10026             d-=t
10027             pass
10028         for elt in dads:
10029             self.assertTrue(dad2.isEqual(elt,1e-12))
10030             pass
10031         pass
10032
10033     def testBuildSlice3D2(self):
10034         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
10035         vec1=[-0.07,1.,0.07]
10036         origin1=[1.524,1.4552,1.74768]
10037         slice1,ids=mesh3D.buildSlice3D(origin1,vec1,1e-10);
10038         f=MEDCouplingFieldDouble(ON_CELLS,ONE_TIME)
10039         f.setTime(4.5,6,7) ; f.setMesh(mesh3D)
10040         arr=DataArrayDouble(mesh3D.getNumberOfCells(),2)
10041         arr.rearrange(1) ; arr.iota(2.) ; arr.rearrange(2)
10042         f.setArray(arr)
10043         f.checkCoherency()
10044         expected1=DataArrayInt([1,3,4,7,9,10,13,15,16])
10045         self.assertTrue(expected1.isEqual(ids))
10046         arr2=arr[expected1]
10047         #
10048         f2=f.extractSlice3D(origin1,vec1,1e-10)
10049         self.assertTrue(f2.getArray().isEqual(arr2,1e-12));
10050         self.assertTrue(slice1.isEqual(f2.getMesh(),1e-12))
10051         self.assertEqual(6,f2.getTime()[1]) ; self.assertEqual(7,f2.getTime()[2])
10052         self.assertAlmostEqual(4.5,f2.getTime()[0],12);
10053         pass
10054
10055     def testComputeTupleIdsToSelectFromCellIds1(self):
10056         m=MEDCouplingDataForTest.build2DTargetMesh_3()
10057         f=MEDCouplingFieldDouble.New(ON_GAUSS_NE,NO_TIME);
10058         f.setMesh(m);
10059         arr=DataArrayDouble(52,2) ; arr.rearrange(1) ; arr.iota(7.) ; arr.rearrange(2)
10060         f.setArray(arr)
10061         #
10062         f2=f.buildSubPart([1,5,9])
10063         f2.checkCoherency()
10064         cI=m.computeNbOfNodesPerCell()
10065         cI.computeOffsets2()
10066         sel=DataArrayInt([1,5,9])
10067         res=sel.buildExplicitArrByRanges(cI)
10068         arr2=arr[res]
10069         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))
10070         self.assertTrue(arr2.isEqual(f2.getArray(),1e-12))
10071         pass
10072
10073     def testComputeSkin1(self):
10074         arrX=DataArrayDouble([2.,3.4,5.6,7.7,8.0]) ; arrY=DataArrayDouble([2.,3.4,5.6,7.7,9.0,14.2])
10075         cmesh=MEDCouplingCMesh() ; cmesh.setCoordsAt(0,arrX) ; cmesh.setCoordsAt(1,arrY)
10076         umesh=cmesh.buildUnstructured()
10077         #
10078         skin=umesh.computeSkin()
10079         self.assertEqual(18,skin.getNumberOfCells())
10080         self.assertEqual(1,skin.getMeshDimension())
10081         self.assertTrue(skin.getCoords().getHiddenCppPointer()==umesh.getCoords().getHiddenCppPointer())
10082         self.assertEqual([0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48,51,54],skin.getNodalConnectivityIndex().getValues())
10083         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())
10084         ids=skin.computeFetchedNodeIds()
10085         self.assertEqual([0,1,2,3,4,5,9,10,14,15,19,20,24,25,26,27,28,29],ids.getValues())
10086         part=umesh.buildFacePartOfMySelfNode(ids,True)
10087         part.setName(skin.getName());
10088         self.assertTrue(part.isEqual(skin,1e-12))
10089         part2=part[1::2]
10090         part[::2]=part2
10091         self.assertTrue(not part.isEqual(skin,1e-12))
10092         trad=part.zipConnectivityTraducer(0)
10093         self.assertEqual(9,part.getNumberOfCells())
10094         self.assertEqual([0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8],trad.getValues())
10095         pass
10096
10097     def testUMeshSetPartOfMySelf2(self):
10098         # resize with explicit ids list
10099         m=MEDCouplingDataForTest.build2DTargetMesh_1()
10100         self.assertEqual([3,4],m.getAllTypes())
10101         part=m[[0,3,4]]
10102         part.simplexize(0)
10103         part2=part[[1,2,5]]
10104         m[[0,3,4]]=part2
10105         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())
10106         self.assertEqual([0,4,8,12,16,20],m.getNodalConnectivityIndex().getValues())
10107         self.assertEqual([3],m.getAllTypes())
10108         # no resize with explicit ids list
10109         m=MEDCouplingDataForTest.build2DTargetMesh_1()
10110         part=m[[0,3]]
10111         part.convertAllToPoly()
10112         m[[3,4]]=part
10113         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())
10114         self.assertEqual([0,5,9,13,18,23],m.getNodalConnectivityIndex().getValues())
10115         self.assertEqual([3,4,5],m.getAllTypes())
10116         # resize with range ids
10117         m=MEDCouplingDataForTest.build2DTargetMesh_1()
10118         part=m[3:]
10119         m[1:3]=part
10120         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())
10121         self.assertEqual([0,5,10,15,20,25],m.getNodalConnectivityIndex().getValues())
10122         self.assertEqual([4],m.getAllTypes())
10123         # no resize with range ids
10124         m=MEDCouplingDataForTest.build2DTargetMesh_1()
10125         part=m[0::3]
10126         part.convertAllToPoly()
10127         m[3:]=part
10128         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())
10129         self.assertEqual([0,5,9,13,18,23],m.getNodalConnectivityIndex().getValues())
10130         self.assertEqual([3,4,5],m.getAllTypes())
10131         # no resize with range ids negative direction
10132         m=MEDCouplingDataForTest.build2DTargetMesh_1()
10133         part=m[3::-3]
10134         part.convertAllToPoly()
10135         m[:-3:-1]=part
10136         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())
10137         self.assertEqual([0,5,9,13,18,23],m.getNodalConnectivityIndex().getValues())
10138         self.assertEqual([3,4,5],m.getAllTypes())
10139         pass
10140
10141     def testUnPolyze3(self):
10142         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]
10143         conn=[1,2,5,4,-1,4,3,0,1,-1,2,0,3,5,-1,0,2,1,-1,4,5,3]
10144         m=MEDCouplingUMesh.New("a mesh",3);
10145         m.allocateCells(1);
10146         m.insertNextCell(NORM_POLYHED,22,conn[0:22])
10147         m.finishInsertingCells();
10148         coords=DataArrayDouble(coord,6,3);
10149         m.setCoords(coords);
10150         m.checkCoherency();
10151         #
10152         vol=m.getMeasureField(ON_CELLS);
10153         self.assertEqual(1,vol.getArray().getNumberOfTuples());
10154         self.assertAlmostEqual(0.5,vol.getArray().getIJ(0,0),12)
10155         #
10156         m.unPolyze();
10157         #
10158         self.assertEqual([NORM_PENTA6],m.getAllTypes())
10159         self.assertTrue(DataArrayInt([0,7]).isEqual(m.getNodalConnectivityIndex()))
10160         self.assertTrue(DataArrayInt([16,0,2,1,3,5,4]).isEqual(m.getNodalConnectivity()))
10161         #
10162         vol=m.getMeasureField(ON_CELLS);
10163         self.assertEqual(1,vol.getArray().getNumberOfTuples());
10164         self.assertAlmostEqual(0.5,vol.getArray().getIJ(0,0),12)
10165         pass
10166
10167     def testKrSpatialDiscretization1(self):
10168         srcPointCoordsX=[0.8401877171547095, 0.7830992237586059, 0.9116473579367843, 0.335222755714889, 0.2777747108031878, 0.4773970518621602, 0.3647844727918433, 0.9522297251747128, 0.6357117279599009, 0.1416025553558034]
10169         srcFieldValsOnPoints=[2.129892434968836, 2.295320474540621, 1.931948594981134, 2.728013590937196, 2.715603240418478, 2.661778472822935, 2.695696990104364, 1.893710234970982, 2.529628016549284, 2.728432341300668]
10170         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]
10171         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]
10172         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])
10173         #
10174         nbOfInputPoints=10;
10175         f=MEDCouplingFieldDouble.New(ON_NODES_KR,ONE_TIME);
10176         srcArrX=DataArrayDouble.New(srcPointCoordsX,nbOfInputPoints,1);
10177         cmesh=MEDCouplingCMesh.New("aMesh");
10178         cmesh.setCoordsAt(0,srcArrX);
10179         umesh=cmesh.buildUnstructured();
10180         f.setMesh(umesh);
10181         srcVals=DataArrayDouble.New(srcFieldValsOnPoints,nbOfInputPoints,1);
10182         f.setArray(srcVals);
10183         f.checkCoherency();
10184         #
10185         res0=f.getValueOn(targetPointCoordsX[:1]);
10186         self.assertAlmostEqual(targetFieldValsExpected[0],res0[0],10)
10187         #
10188         valuesToTest=f.getValueOnMulti(targetPointCoordsX);
10189         self.assertEqual(40,valuesToTest.getNumberOfTuples());
10190         self.assertEqual(1,valuesToTest.getNumberOfComponents());
10191         for i in xrange(40):
10192             self.assertAlmostEqual(targetFieldValsExpected[i],valuesToTest.getIJ(i,0),10)
10193             pass
10194         fd=f.getDiscretization()
10195         del f
10196         self.assertTrue(isinstance(fd,MEDCouplingFieldDiscretizationKriging))
10197         coeffs,isDrift=fd.computeVectorOfCoefficients(umesh,srcVals)
10198         self.assertEqual(2,isDrift)
10199         self.assertTrue(coeffsExpected.isEqual(coeffs,1e-8))
10200         #
10201         pass
10202
10203     def testDuplicateEachTupleNTimes1(self):
10204         d=DataArrayDouble.New([9.,8.,7.,6.],4,1) ; d.setInfoOnComponents(["mass [kg]"]) ; d.setName("aname")
10205         d2=d.duplicateEachTupleNTimes(3)
10206         self.assertTrue(d2.isEqualWithoutConsideringStr(DataArrayDouble.New([9.,9.,9.,8.,8.,8.,7.,7.,7.,6.,6.,6.],4*3,1),1e-14))
10207         self.assertEqual("aname",d2.getName())
10208         self.assertEqual(["mass [kg]"],d2.getInfoOnComponents())
10209         #
10210         d=DataArrayInt.New([9,8,7,6],4,1) ; d.setInfoOnComponents(["mass [kg]"]) ; d.setName("aname")
10211         d2=d.duplicateEachTupleNTimes(3)
10212         self.assertTrue(d2.isEqualWithoutConsideringStr(DataArrayInt.New([9,9,9,8,8,8,7,7,7,6,6,6],4*3,1)))
10213         self.assertEqual("aname",d2.getName())
10214         self.assertEqual(["mass [kg]"],d2.getInfoOnComponents())
10215         pass
10216
10217     def testSwigComputeTupleIdsNearTuples1(self):
10218         da=DataArrayDouble([5.,6.,-5.,-6.,5.,-6.,-5.,6.,5.,6.],5,2)
10219         arr,arrI=da.computeTupleIdsNearTuples(DataArrayDouble([5.,-6.,5.,6.,-5.,-6.],3,2),1e-10)
10220         self.assertEqual([2,0,4,1],arr.getValues())
10221         self.assertEqual([0,1,3,4],arrI.getValues())
10222         arr,arrI=da.computeTupleIdsNearTuples([5.,-6.,5.,6.,-5.,-6.],1e-10)
10223         self.assertEqual([2,0,4,1],arr.getValues())
10224         self.assertEqual([0,1,3,4],arrI.getValues())
10225         expected0=[[2],[0,4],[1]]
10226         expected1=[[0,1],[0,2],[0,1]]
10227         for pos,it in enumerate(DataArrayDouble([5.,-6.,5.,6.,-5.,-6.],3,2)):
10228             arr,arrI=da.computeTupleIdsNearTuples(it,1e-10)
10229             self.assertEqual(expected0[pos],arr.getValues())
10230             self.assertEqual(expected1[pos],arrI.getValues())
10231             pass
10232         pass
10233
10234     def testSwigDataTupleIOp1(self):
10235         d=DataArrayDouble(10,1)
10236         d.iota(7.)
10237         for elt in d:
10238             elt+=2.
10239             pass
10240         toTest=DataArrayDouble([9.0,10.0,11.0,12.0,13.0,14.0,15.0,16.0,17.0,18.0])
10241         self.assertTrue(toTest.isEqual(d,1e-12))
10242         for elt in d:
10243             elt-=2.
10244             pass
10245         toTest=DataArrayDouble([7.0,8.0,9.0,10.0,11.0,12.0,13.0,14.0,15.0,16.0])
10246         self.assertTrue(toTest.isEqual(d,1e-12))
10247         for elt in d:
10248             elt*=2.
10249             pass
10250         toTest=DataArrayDouble([14.0,16.0,18.0,20.0,22.0,24.0,26.0,28.0,30.0,32.0])
10251         self.assertTrue(toTest.isEqual(d,1e-12))
10252         for elt in d:
10253             elt/=2.
10254             pass
10255         toTest=DataArrayDouble([7.0,8.0,9.0,10.0,11.0,12.0,13.0,14.0,15.0,16.0])
10256         self.assertTrue(toTest.isEqual(d,1e-12))
10257         #
10258         d=DataArrayInt(10,1)
10259         d.iota(7)
10260         for elt in d:
10261             elt+=2
10262             pass
10263         self.assertEqual(d.getValues(),[9,10,11,12,13,14,15,16,17,18])
10264         for elt in d:
10265             elt-=2
10266             pass
10267         self.assertEqual(d.getValues(),[7,8,9,10,11,12,13,14,15,16])
10268         for elt in d:
10269             elt*=2
10270             pass
10271         self.assertEqual(d.getValues(),[14,16,18,20,22,24,26,28,30,32])
10272         for elt in d:
10273             elt/=2
10274             pass
10275         self.assertEqual(d.getValues(),[7,8,9,10,11,12,13,14,15,16])
10276         for elt in d:
10277             elt%=3
10278             pass
10279         self.assertEqual(d.getValues(),[1,2,0,1,2,0,1,2,0,1])
10280         pass
10281
10282     def testIntersect2DMeshesTmp5(self):
10283         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)
10284         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)
10285         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)
10286         #
10287         m1=MEDCouplingUMesh.New("Fix",2);
10288         m1.setCoords(coords);
10289         m1.setConnectivity(conn,connI,True);
10290         #
10291         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)
10292         # connectivity
10293         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);
10294         conn.setName("");
10295         connI=DataArrayInt([0,9,18,27,36,45,54,63,72],9)
10296         m2=MEDCouplingUMesh.New("Mobile",2);
10297         m2.setCoords(coords);
10298         m2.setConnectivity(conn,connI,True);
10299         #
10300         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m1,m2,1e-10);
10301         self.assertEqual(105,m3.getNumberOfCells());
10302         self.assertEqual(105,d1.getNumberOfTuples());
10303         self.assertEqual(105,d2.getNumberOfTuples());
10304         self.assertEqual(704,m3.getNumberOfNodes());
10305         #
10306         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]
10307         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]
10308         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]
10309         f3=m3.getMeasureField(ON_CELLS).getArray().getValues();
10310         for i in xrange(105):
10311             self.assertAlmostEqual(areaExpected[i],f3[i],10)
10312             pass
10313         self.assertEqual(expected1,d1.getValues())
10314         self.assertEqual(expected2,d2.getValues())
10315         pass
10316
10317     def testDAIBuildUnique1(self):
10318         d=DataArrayInt([1,2,2,3,3,3,3,4,5,5,7,7,7,19])
10319         e=d.buildUnique()
10320         self.assertTrue(e.isEqual(DataArrayInt([1,2,3,4,5,7,19])))
10321         pass
10322
10323     def testDAIPartitionByDifferentValues1(self):
10324         d=DataArrayInt([1,0,1,2,0,2,2,-3,2])
10325         expected=[[-3,[7]],[0,[1,4]],[1,[0,2]],[2,[3,5,6,8]]]
10326         for i,elt in enumerate(zip(*d.partitionByDifferentValues())):
10327             self.assertEqual(expected[i][0],elt[1])
10328             self.assertEqual(expected[i][1],elt[0].getValues())
10329             pass
10330         pass
10331
10332     def testFieldGaussMultiDiscPerType1(self):
10333         coords=DataArrayDouble([0.,0.,0.,1.,1.,1.,1.,0.,0.,0.5,0.5,1.,1.,0.5,0.5,0.],8,2)
10334         mQ8=MEDCouplingUMesh("",2) ; mQ8.setCoords(coords)
10335         mQ8.allocateCells(1)
10336         mQ8.insertNextCell(NORM_QUAD8,range(8))
10337         mQ8.finishInsertingCells()
10338         mQ4=MEDCouplingUMesh("",2) ; mQ4.setCoords(coords)
10339         mQ4.allocateCells(1)
10340         mQ4.insertNextCell(NORM_QUAD4,range(4))
10341         mQ4.finishInsertingCells()
10342         mT3=MEDCouplingUMesh("",2) ; mT3.setCoords(coords)
10343         mT3.allocateCells(1)
10344         mT3.insertNextCell(NORM_TRI3,range(3))
10345         mT3.finishInsertingCells()
10346
10347         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.]]
10348         ms=2*[mQ4]+7*[mQ8]+11*[mT3]
10349         ms[:]=(elt.deepCpy() for elt in ms)
10350         for m,t in zip(ms,tr):
10351             d=m.getCoords() ; d+= t
10352             pass
10353         m=MEDCouplingUMesh.MergeUMeshes(ms)
10354         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,NO_TIME)
10355         f.setMesh(m)
10356         # throw because cell 0,1 are QUAD4 and cell 3 is QUAD8
10357         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])
10358         f.setGaussLocalizationOnCells([0,1],[0.,0.,1.,0.,1.,1.,0.,1.],[0.3,0.3,0.7,0.7],[0.8,0.2])
10359         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])
10360         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])
10361         f.setGaussLocalizationOnCells([9,10,11,12,13],[0.,0.,1.,0.,1.,1.],[0.4,0.4],[1.])
10362         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])
10363         self.assertEqual(46,f.getNumberOfTuplesExpected())
10364         vals=DataArrayDouble.New(46*3,1) ; vals.iota(7.7) ; vals.rearrange(3)
10365         f.setArray(vals)
10366         f.checkCoherency()
10367         #f.getLocalizationOfDiscr()
10368         self.assertRaises(InterpKernelException,f.getGaussLocalizationIdOfOneType,NORM_QUAD8) #throw because several loc
10369         self.assertEqual([1,2],f.getGaussLocalizationIdsOfOneType(NORM_QUAD8))
10370         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())
10371         fc=f[[1,2,3,8]]
10372         fc.checkCoherency()
10373         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))
10374         fc.renumberCells([3,2,0,1])
10375         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))
10376         fc.getArray()
10377         pass
10378
10379     def testSwigRotate(self):
10380         d=DataArrayDouble([1.,2.,3.,4.,6.,5.],2,3)
10381         MEDCouplingPointSet.Rotate3DAlg([0.,0.,0.],[0.,1.,0.],1.5707963267948966,d)
10382         self.assertTrue(d.isEqual(DataArrayDouble([3.,2.,-1.,5.,6.,-4.],2,3),1e-12))
10383         d=DataArrayDouble([1.,2.,3.,4.,6.,5.],3,2)
10384         MEDCouplingPointSet.Rotate2DAlg([0.,0.],1.5707963267948966,d)
10385         self.assertTrue(d.isEqual(DataArrayDouble([-2.,1.,-4.,3.,-5.,6.],3,2),1e-12))
10386         pass
10387
10388     def testSwigCMeshProtection(self):
10389         cm=MEDCouplingCMesh()
10390         self.assertRaises(InterpKernelException,cm.setCoordsAt,0,DataArrayDouble([4.,4.5,6.,7.],2,2))
10391         self.assertRaises(InterpKernelException,cm.setCoords,DataArrayDouble([4.,4.5,6.,7.],2,2))
10392         pass
10393
10394     def testSwigCellsInBoundingBox1(self):
10395         m3D=MEDCouplingDataForTest.build3DExtrudedUMesh_1()[0]
10396         self.assertTrue(m3D.getCellsInBoundingBox([(0,3),(0,3),(0,1)],-1e-12).isEqual(DataArrayInt([0,1,2,3,4,5])))
10397         self.assertRaises(InterpKernelException,m3D.getCellsInBoundingBox,[(0,3,0),(3,0,1)],-1e-12)
10398         pass
10399
10400     def setUp(self):
10401         pass
10402     pass
10403
10404 unittest.main()