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         self.assertRaises(InterpKernelException,f.setGaussLocalizationOnType,NORM_QUAD4,_refCoo1,_gsCoo1,_wg1)
1997         self.assertEqual(1,f.getNbOfGaussLocalization());
1998         refCoo2=[ 0.,0., 1.,0., 1.,1., 0.,1. ]
1999         _refCoo2=refCoo2
2000         _gsCoo1=_gsCoo1[0:4]
2001         _wg1=_wg1[0:2]
2002         f.setGaussLocalizationOnType(NORM_QUAD4,_refCoo2,_gsCoo1,_wg1);
2003         self.assertEqual(2,f.getNbOfGaussLocalization());
2004         array=DataArrayDouble.New();
2005         ptr=18*2*[None]
2006         for i in xrange(18*2):
2007             ptr[i]=float(i+1)
2008         array.setValues(ptr,18,2);
2009         ptr=array.getPointer();
2010         f.setArray(array);
2011         f.setName("MyFirstFieldOnGaussPoint");
2012         f.checkCoherency();
2013         self.assertAlmostEqual(27.,f.getIJK(2,5,0),14);
2014         self.assertAlmostEqual(16.,f.getIJK(1,5,1),14);
2015         #
2016         f.clearGaussLocalizations();
2017         self.assertEqual(0,f.getNbOfGaussLocalization());
2018         self.assertRaises(InterpKernelException,f.checkCoherency);
2019         ids1=[0,1,3,4]
2020         self.assertRaises(InterpKernelException,f.setGaussLocalizationOnCells,ids1,_refCoo2,_gsCoo1,_wg1);
2021         self.assertEqual(0,f.getNbOfGaussLocalization());
2022         ids2=[0,4]
2023         f.setGaussLocalizationOnCells(ids2,_refCoo2,_gsCoo1,_wg1);
2024         self.assertEqual(1,f.getNbOfGaussLocalization());
2025         self.assertEqual(0,f.getGaussLocalizationIdOfOneCell(0));
2026         self.assertRaises(InterpKernelException,f.getGaussLocalizationIdOfOneCell,1);
2027         ids3=[1,2]
2028         f.setGaussLocalizationOnCells(ids3,_refCoo1,_gsCoo1,_wg1);
2029         self.assertEqual(2,f.getNbOfGaussLocalization());
2030         self.assertEqual(0,f.getGaussLocalizationIdOfOneCell(0));
2031         self.assertEqual(1,f.getGaussLocalizationIdOfOneCell(1));
2032         self.assertEqual(1,f.getGaussLocalizationIdOfOneCell(2));
2033         self.assertRaises(InterpKernelException,f.checkCoherency);#<- cell 3 has no localization
2034         ids4=[3]
2035         _gsCoo2=_gsCoo1;
2036         _wg2=_wg1;
2037         _gsCoo2[0]=0.8888777776666;
2038         _wg2[0]=0.1234567892377;
2039         f.setGaussLocalizationOnCells(ids4,_refCoo2,_gsCoo2,_wg2);
2040         self.assertEqual(3,f.getNbOfGaussLocalization());
2041         tmpIds=f.getCellIdsHavingGaussLocalization(0);
2042         self.assertEqual(ids2,list(tmpIds.getValues()));
2043         self.assertRaises(InterpKernelException,f.checkCoherency);#<- it's always not ok because undelying array not with the good size.
2044         array2=f.getArray().substr(0,10);
2045         f.setArray(array2);
2046         f.checkCoherency();#<- here it is OK
2047         f2=f.clone(True);
2048         self.assertTrue(f.isEqual(f2,1e-14,1e-14));
2049         gl1=f2.getGaussLocalization(0);
2050         tmp=gl1.getGaussCoord(1,1);
2051         self.assertAlmostEqual(2.07*_b-1,tmp,14);
2052         gl1.setGaussCoord(1,1,0.07);
2053         self.assertTrue(not f.isEqual(f2,1e-14,1e-14));
2054         gl1.setGaussCoord(1,1,tmp);
2055         self.assertTrue(f.isEqual(f2,1e-14,1e-14));
2056         f2.checkCoherency();
2057         pass
2058
2059     def testGaussPointNEField1(self):
2060         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2061         f=MEDCouplingFieldDouble.New(ON_GAUSS_NE,NO_TIME);
2062         f.setMesh(m);
2063         self.assertEqual(5,f.getNumberOfMeshPlacesExpected());
2064         f.setName("MyFirstFieldOnNE");
2065         f.setDescription("MyDescriptionNE");
2066         array=DataArrayDouble.New();
2067         tmp=18*2*[None]
2068         for i in xrange(18*2):
2069             tmp[i]=float(i+7)
2070             pass
2071         array.setValues(tmp,18,2);
2072         ptr=array.getPointer();
2073         f.setArray(array);
2074         #
2075         f.checkCoherency();
2076         f2=f.clone(True);
2077         self.assertTrue(f.isEqual(f2,1e-14,1e-14));
2078         self.assertAlmostEqual(21.,f.getIJK(2,0,0),14);
2079         self.assertAlmostEqual(18.,f.getIJK(1,1,1),14);
2080         pass
2081
2082     def testCellOrientation1(self):
2083         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2084         vec=[0.,0.,-1.]
2085         self.assertRaises(InterpKernelException,m.are2DCellsNotCorrectlyOriented,vec,False);
2086         m.changeSpaceDimension(3);
2087         res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2088         self.assertTrue(len(res1)==0);
2089         vec[2]=1.;
2090         res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2091         self.assertEqual(5,len(res1));
2092         #
2093         vec[2]=-1.;
2094         # connectivity inversion
2095         conn=m.getNodalConnectivity().getValues();
2096         tmp=conn[11];
2097         conn[11]=conn[12];
2098         conn[12]=tmp;
2099         m.getNodalConnectivity().setValues(conn,len(conn),1)
2100         res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2101         self.assertEqual(1,len(res1));
2102         self.assertEqual(2,res1.getValues()[0]);
2103         m.orientCorrectly2DCells(vec,False);
2104         res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2105         self.assertTrue(len(res1)==0);
2106         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
2107         m2.changeSpaceDimension(3);
2108         self.assertTrue(m.isEqual(m2,1e-12));
2109         pass
2110
2111     def testCellOrientation2(self):
2112         m2,m1=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
2113         res1=m2.arePolyhedronsNotCorrectlyOriented();
2114         self.assertEqual(6,len(res1));
2115         m2.orientCorrectlyPolyhedrons();
2116         res1=m2.arePolyhedronsNotCorrectlyOriented();
2117         self.assertTrue(len(res1)==0);
2118         m2.checkCoherency();
2119         self.assertEqual(18,m2.getNumberOfCells());
2120         cellIds2=[0,6,12]
2121         m2.convertToPolyTypes(cellIds2);
2122         m2.orientCorrectlyPolyhedrons();
2123         res1=m2.arePolyhedronsNotCorrectlyOriented();
2124         self.assertTrue(len(res1)==0);
2125         f2=m2.getMeasureField(False);
2126         f2Ptr=f2.getArray().getValues();
2127         #Test to check global reverse in MEDCouplingUMesh::tryToCorrectPolyhedronOrientation
2128         m3=MEDCouplingDataForTest.build2DTargetMesh_1();
2129         vec=[0.,0.,1.]
2130         m3.changeSpaceDimension(3);
2131         ids2=[0,1,2,3,4]
2132         m3.convertToPolyTypes(ids2);
2133         m3.orientCorrectly2DCells(vec,False);
2134         m4=MEDCouplingDataForTest.buildCU1DMesh_U();
2135         m4.changeSpaceDimension(3);
2136         center=[0.,0.,0.]
2137         vector=[0.,1.,0.]
2138         m4.rotate(center,vector,-pi/2.);
2139         m5=m3.buildExtrudedMesh(m4,0);
2140         res1=m5.arePolyhedronsNotCorrectlyOriented();
2141         self.assertEqual(15,len(res1));
2142         m5.orientCorrectlyPolyhedrons();
2143         res1=m5.arePolyhedronsNotCorrectlyOriented();
2144         self.assertTrue(len(res1)==0);
2145         f3=m5.getMeasureField(False);
2146         self.assertEqual(15,f3.getArray().getNumberOfTuples());
2147         self.assertEqual(1,f3.getNumberOfComponents());
2148         f3Ptr=f3.getArray().getValues();
2149         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];
2150         for i in xrange(15):
2151             self.assertTrue(abs(expected1[i]-f3Ptr[i])<1e-12);
2152             pass
2153         f4=m5.getBarycenterAndOwner();
2154         self.assertEqual(15,f4.getNumberOfTuples());
2155         self.assertEqual(3,f4.getNumberOfComponents());
2156         f4Ptr=f4.getValues();
2157         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];
2158         for i in xrange(45):
2159             self.assertTrue(abs(expected2[i]-f4Ptr[i])<1e-12);
2160             pass
2161         pass
2162
2163     def testPolyhedronBarycenter(self):
2164         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];
2165         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];
2166         meshN=MEDCouplingUMesh.New();
2167         meshN.setName("ForBary");
2168         meshN.setMeshDimension(3);
2169         meshN.allocateCells(4);
2170         meshN.insertNextCell(NORM_POLYHED,29,connN[0:29])
2171         meshN.finishInsertingCells();
2172         myCoords=DataArrayDouble.New();
2173         myCoords.setValues(coords,9,3);
2174         meshN.setCoords(myCoords);
2175         meshN.checkCoherency();
2176         #
2177         res1=meshN.arePolyhedronsNotCorrectlyOriented();
2178         meshN.orientCorrectlyPolyhedrons();
2179         self.assertTrue(len(res1)==0);
2180         da=meshN.getBarycenterAndOwner();
2181         self.assertEqual(1,da.getNumberOfTuples());
2182         self.assertEqual(3,da.getNumberOfComponents());
2183         daPtr=da.getValues();
2184         ref=meshN.getCoords().getValues()[24:];
2185         for i in xrange(3):
2186             self.assertTrue(abs(ref[i]-daPtr[i])<1e-12);
2187             pass
2188         #
2189         center=[0.,0.,0.]
2190         vec=[0.,2.78,0.]
2191         da=meshN.getBarycenterAndOwner();
2192         daPtr=da.getValues();
2193         ref=meshN.getCoords().getValues()[24:];
2194         for i in xrange(3):
2195             self.assertTrue(abs(ref[i]-daPtr[i])<1e-12);
2196             pass
2197         #
2198         meshN.rotate(center,vec,pi/7.);
2199         meshN.translate(vec);
2200         da=meshN.getBarycenterAndOwner();
2201         daPtr=da.getValues();
2202         ref=meshN.getCoords().getValues()[24:];
2203         for i in xrange(3):
2204             self.assertTrue(abs(ref[i]-daPtr[i])<1e-12);
2205             pass
2206         #
2207         center2=[1.12,3.45,6.78]
2208         vec2=[4.5,9.3,2.8]
2209         meshN.rotate(center2,vec2,e);
2210         meshN.translate(vec2);
2211         da=meshN.getBarycenterAndOwner();
2212         daPtr=da.getValues();
2213         ref=meshN.getCoords().getValues()[24:];
2214         for i in xrange(3):
2215             self.assertTrue(abs(ref[i]-daPtr[i])<1e-10);
2216             pass
2217         pass
2218
2219     def testNormL12Integ1D(self):
2220         m1=MEDCouplingDataForTest.build1DTargetMesh_3();
2221         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2222         f1.setMesh(m1);
2223         array=DataArrayDouble.New();
2224         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]
2225         array.setValues(arr,m1.getNumberOfCells(),3);
2226         f1.setArray(array);
2227         #
2228         f3=m1.getBarycenterAndOwner();
2229         self.assertEqual(4,f3.getNumberOfTuples());
2230         self.assertEqual(1,f3.getNumberOfComponents());
2231         expected9=[0.75,5.105,0.8,5.155]
2232         ptr=f3.getValues();
2233         for i in xrange(4):
2234             self.assertTrue(abs(expected9[i]-ptr[i])<1e-12);
2235             pass
2236         #
2237         f2=m1.getMeasureField(False);
2238         self.assertEqual(4,f2.getArray().getNumberOfTuples());
2239         self.assertEqual(1,f2.getNumberOfComponents());
2240         expected1=[0.5,0.21,-0.6,-0.31]
2241         ptr=f2.getArray().getValues();
2242         for i in xrange(4):
2243             self.assertTrue(abs(expected1[i]-ptr[i])<1e-12);
2244             pass
2245         expected2=[0.5,0.21,0.6,0.31]
2246         f2=m1.getMeasureField(True);
2247         ptr=f2.getArray().getValues();
2248         for i in xrange(4):
2249             self.assertTrue(abs(expected2[i]-ptr[i])<1e-12);
2250             pass
2251         #integral
2252         self.assertTrue(4,f1.getNumberOfTuples())
2253         res=f1.integral(False);
2254         self.assertTrue(3,len(res))
2255         expected3=[0.9866,-0.3615,0.4217]
2256         for i in xrange(3):
2257             self.assertTrue(abs(expected3[i]-res[i])<1e-12);
2258             pass
2259         self.assertTrue(abs(expected3[0]-f1.integral(0,False))<1e-12);
2260         self.assertTrue(abs(expected3[1]-f1.integral(1,False))<1e-12);
2261         self.assertTrue(abs(expected3[2]-f1.integral(2,False))<1e-12);
2262         res=f1.integral(True);
2263         expected4=[-3.4152,8.7639,-14.6879]
2264         for i in xrange(3):
2265             self.assertTrue(abs(expected4[i]-res[i])<1e-12);
2266             pass
2267         #normL1
2268         res=f1.normL1();
2269         self.assertTrue(3,len(res))
2270         expected5=[6.979506172839505, 16.89018518518518, 27.02969135802469]
2271         for i in xrange(3):
2272             self.assertTrue(abs(expected5[i]-res[i])<1e-12);
2273             pass
2274         self.assertTrue(abs(expected5[0]-f1.normL1(0))<1e-12);
2275         self.assertTrue(abs(expected5[1]-f1.normL1(1))<1e-12);
2276         self.assertTrue(abs(expected5[2]-f1.normL1(2))<1e-12);
2277         #normL2
2278         res=f1.normL2();
2279         self.assertTrue(3,len(res))
2280         expected7=[7.090910979452395, 16.9275542960123, 27.053271464160858]
2281         for i in xrange(3):
2282             self.assertTrue(abs(expected7[i]-res[i])<1e-9);
2283             pass
2284         self.assertTrue(abs(expected7[0]-f1.normL2(0))<1e-9);
2285         self.assertTrue(abs(expected7[1]-f1.normL2(1))<1e-9);
2286         self.assertTrue(abs(expected7[2]-f1.normL2(2))<1e-9);
2287         #buildMeasureField
2288         f4=f1.buildMeasureField(False);
2289         self.assertTrue(abs(-0.2-f4.accumulate(0))<1e-12);
2290         f4=f1.buildMeasureField(True);
2291         self.assertTrue(abs(1.62-f4.accumulate(0))<1e-12);
2292         # Testing with 2D Curve
2293         m1=MEDCouplingDataForTest.build2DCurveTargetMesh_3();
2294         f2=m1.getMeasureField(False);
2295         self.assertEqual(4,f2.getArray().getNumberOfTuples());
2296         self.assertEqual(1,f2.getNumberOfComponents());
2297         ptr=f2.getArray().getValues();
2298         for i in xrange(4):
2299             self.assertTrue(abs(sqrt(2.)*expected2[i]-ptr[i])<1e-12);
2300             pass
2301         f2=m1.getMeasureField(True);
2302         self.assertEqual(4,f2.getArray().getNumberOfTuples());
2303         self.assertEqual(1,f2.getNumberOfComponents());
2304         ptr=f2.getArray().getValues();
2305         for i in xrange(4):
2306             self.assertTrue(abs(expected2[i]*sqrt(2.)-ptr[i])<1e-12);
2307             pass
2308         #bary
2309         f3=m1.getBarycenterAndOwner();
2310         self.assertEqual(4,f3.getNumberOfTuples());
2311         self.assertEqual(2,f3.getNumberOfComponents());
2312         expected10=[0.75,0.75,5.105,5.105,0.8,0.8,5.155,5.155]
2313         ptr=f3.getValues();
2314         for i in xrange(8):
2315             self.assertTrue(abs(expected10[i]-ptr[i])<1e-12);
2316             pass
2317         #
2318         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2319         f1.setMesh(m1);
2320         array=DataArrayDouble.New();
2321         array.setValues(arr,m1.getNumberOfCells(),3);
2322         f1.setArray(array);
2323         res=f1.integral(False);
2324         for i in xrange(3):
2325             self.assertTrue(abs(sqrt(2.)*expected4[i]-res[i])<1e-12);
2326             pass
2327         res=f1.integral(True);
2328         for i in xrange(3):
2329             self.assertTrue(abs(sqrt(2.)*expected4[i]-res[i])<1e-12);
2330             pass
2331         res=f1.normL1();
2332         for i in xrange(3):
2333             self.assertTrue(abs(expected5[i]-res[i])<1e-12);
2334             pass
2335         res=f1.normL2();
2336         for i in xrange(3):
2337             self.assertTrue(abs(expected7[i]-res[i])<1e-12);
2338             pass
2339         pass
2340
2341     def testAreaBary2D(self):
2342         m1=MEDCouplingDataForTest.build2DTargetMesh_3();
2343         f1=m1.getMeasureField(False);
2344         self.assertEqual(10,f1.getArray().getNumberOfTuples());
2345         self.assertEqual(1,f1.getNumberOfComponents());
2346         expected1=[-0.5,-1,-1.5,-0.5,-1,  0.5,1,1.5,0.5,1]
2347         ptr=f1.getArray().getValues();
2348         for i in xrange(10):
2349             self.assertTrue(abs(expected1[i]-ptr[i])<1e-12);
2350             pass
2351         f1=m1.getMeasureField(True);
2352         ptr=f1.getArray().getValues();
2353         for i in xrange(10):
2354             self.assertTrue(abs(abs(expected1[i])-ptr[i])<1e-12);
2355             pass
2356         f2=m1.getBarycenterAndOwner();
2357         self.assertEqual(10,f2.getNumberOfTuples());
2358         self.assertEqual(2,f2.getNumberOfComponents());
2359         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]
2360         ptr=f2.getValues();
2361         for i in xrange(20):
2362             self.assertTrue(abs(expected2[i]-ptr[i])<1e-12);
2363             pass
2364         m1.changeSpaceDimension(3);
2365         f1=m1.getMeasureField(False);
2366         self.assertEqual(10,f1.getArray().getNumberOfTuples());
2367         self.assertEqual(1,f1.getNumberOfComponents());
2368         ptr=f1.getArray().getValues();
2369         for i in xrange(10):
2370             self.assertTrue(abs(abs(expected1[i])-ptr[i])<1e-12);
2371             pass
2372         f2=m1.getBarycenterAndOwner();
2373         self.assertEqual(10,f2.getNumberOfTuples());
2374         self.assertEqual(3,f2.getNumberOfComponents());
2375         ptr=f2.getValues();
2376         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.]
2377         for i in xrange(30):
2378             self.assertTrue(abs(expected3[i]-ptr[i])<1e-12);
2379             pass
2380         pass
2381
2382     def testAreaBary3D(self):
2383         coords=[ 0.241310763507 , 0.0504777305619 , 0.0682283524903 , 0.252501053866 , -0.0625176732937 , 0.137272639894 ,
2384                  0.152262663601 , 0.241816569527 , 0.133812556197 , 0.18047750211 , -0.0789949051358 , 0.339098173401 ,
2385                  0.151741971857 , 0.238885278571 , 0.137715037333 , 0.242532155481 , -0.0928169086456 , 0.0678043417367 ,
2386                  0.240941965335 , -0.015461491464 , 0.0617186345825 , 0.24127650112 , 0.0499427876717 , 0.0679634099148 ,
2387                  -0.145828917428 , 0.206291632565 , 0.0310071927543 , 0.0125651775307 , 0.266262085828 , 0.105228430543 ,
2388                  -0.0994066533286 , 0.233224271238 , 0.0572213839567 , -0.0951345338317 , 0.234819509426 , 0.0592126284538 ,
2389                  0.136580574205 , -0.205486212579 , 0.0572866072014 , 0.0637270784978 , -0.168886355238 , 0.446614057077 ,
2390                  0.041337157151 , -0.213402568198 , 0.372407095999 , 0.0411601970268 , -0.202387875756 , 0.411334979491 ,
2391                  -0.108355701857 , 0.193636239335 , 0.204886756738 , 0.00639779029829 , 0.155296981517 , 0.252585892979 ,
2392                  0.0262473111702 , -0.112919732543 , 0.424286639249 ,-0.224103052733 , -0.139430015438 , -0.0122352295701 ,
2393                 -0.0312760589481 , -0.274272003594 , 0.0323959636568 , -0.166663422532 , -0.217754445175 , 0.00392109070364 ,
2394                  -0.30586619777 , -0.0475168041091 , -0.0144585228182 , -0.280881480586 , 0.135571293538 , 0.00623923647986 ,
2395                  -0.25548538234 , 0.156819217766 , 0.0645277879769 , -0.131567009284 , 0.184133752309 , 0.206021802753 ,
2396                  -0.196204010965 , 0.151602971681 , 0.212974777736 , -0.183713879463 , 0.0802946639531 , 0.260115662599 ,
2397                  -0.244241178767 , -0.0738873389604 , 0.144590565817 , -0.155804057829 , -0.164892720025 , 0.210613950558 ,
2398                  -0.170950800428 , -0.215099334026 , 0.00610122860092 , -0.30552634869 , -0.0490020791904 , -0.0132786533145 ,
2399                  0.271831011884 , 0.15105657296 , 0.0230534827908 , 0.281919192283 , 0.0898544306288 , -0.0625201489143 ,
2400                  0.260240727276 , -0.0120688706637 , -0.0532316588626 , 0.244947737722 , 0.0197984684293 , 0.0309341209233 ,
2401                  0.23439631578 , 0.229825279875 , 0.0508520585381 , 0.160921316875 , 0.265078502128 , 0.121716560626 ,
2402                  -0.315088694175 , 0.0747700471918 , -0.245836615071 , -0.327728781776 , 0.0857114674649 , -0.239431905957 ,
2403                  -0.308385460634 , 0.145142997084 , -0.149886828433 , 0.0488236045164 , 0.309462801914 , 0.0849169148265 ,
2404                 -0.0244964803395 , 0.33145611751 , -0.0476415818061 , 0.0060567994229 , 0.32418412014 , 0.0367779543812 ,
2405                  -0.0950221448063 , 0.236675326003 , 0.0572594453983 , 0.248723023186 , 0.0886648784791 , -0.176629430538 ,
2406                  0.116796984 , 0.256596599567 , -0.292863523603 , 0.118024552914 , 0.229154257843 , -0.34233232501 ,
2407                  0.217507892549 , -0.0417822335742 , -0.176771782888 , -0.224429321304 , 0.0125595300114 , -0.362064725588 ,
2408                  0.0937301100955 , -0.0500824832657 , -0.299713548444 , -0.244162220397 , 0.0383853931293 , -0.389856984411 ,
2409                  -0.0281989366102 , 0.097392811563 , -0.458244577284 , -0.385010847162 , 0.10122766194 , -0.140052859922 ,
2410                  -0.377936358012 , 0.110875172128 , -0.176207095463 , 0.244483045556 , -0.0991073977045 , 0.0575134372934 ,
2411                 0.262605120167 , -0.100243191645 , -0.0495620806935 , 0.240306880972 , -0.136153701579 , -0.114745281696 ,
2412                  0.215763176129 , -0.0836766059189 , -0.183249640616 , 0.237870396603 , -0.132449578286 , -0.121598854639 ,
2413                  -0.0637683083097 , -0.27921020214 , -0.149112321992 , -0.0856211014977 , -0.2973233473 , -0.0446878139589 ,
2414                  0.104675342288 , -0.0625908305324 , -0.290346256534 , 0.0248264249186 , -0.247797708548 , -0.165830884019 ,
2415                  0.0719302438309 , -0.178468260473 , -0.211432157345 , 0.142871843159 , -0.208769948542 , 0.0454101128246 ,
2416                  0.167803379307 , -0.207851396623 , -0.088802726124 , 0.12868717152 , -0.230920439715 , 0.00760508389036 ,
2417                  -0.0372812069535 , -0.286740286332 , 0.00963701291166 ]
2418
2419         connN = [ #polyhedron 0
2420             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
2421             , 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
2422             , 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
2423             , 22 , 19 , 21 , 30 , 31 , -1 , 22 , 31 , 28 , 27 , 26 , 24 , 23 , -1 , 31 , 30 , 29 , 28,
2424             # polyhedron 1
2425             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
2426             , 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
2427             , 33 , 34 , 48 , 45 , -1 , 35 , 34 , 48 , 50 , 49 , 38 , -1 , 41 , 43 , 42 , 46 , 36 , 37 , -1 , 38 , 39 , 51 , 49 , -1
2428             , 39 , 40 , 42 , 46 , 47 , 52 , 51 , -1 , 45 , 47 , 52 , 50 , 48 , -1 , 52 , 51 , 49 , 50,
2429             # polyhedron 2
2430             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
2431             , 23 , 53 , 54 , 40 , 8 , -1 , 53 , 22 , 23 , -1 , 39 , 54 , 40,
2432             # polyhedron 3
2433             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
2434             , 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
2435             , 55 , 5 , 12 , 65 , -1 , 66 , 67 , 65 , 55 , 56 , 57 , -1 , 63 , 66 , 57 , 59 , 64 , -1 , 64 , 62 , 58 , 59 , -1
2436             , 60 , 63 , 66 , 67 , 68 , 61 , -1 , 61 , 68 , 20 , 21 , -1 , 67 , 68 , 20 , 12 , 65]
2437
2438         barys = [ -0.0165220465527 , -0.0190922868195 , 0.158882733414 ,
2439                   0.0287618656076 , 0.135874379934 , -0.14601588119 ,
2440                   -0.147128055553 , 0.0465995097041 , -0.049391174453 ,
2441                   -0.00142506732317 , -0.0996953090351 , -0.115159183132 ]
2442         meshN=MEDCouplingUMesh.New();
2443         meshN.setName("ForBary");
2444         meshN.setMeshDimension(3);
2445         meshN.allocateCells(4);
2446         meshN.insertNextCell(NORM_POLYHED,113,connN);
2447         meshN.insertNextCell(NORM_POLYHED,99,connN[113:]);
2448         meshN.insertNextCell(NORM_POLYHED,43,connN[212:]);
2449         meshN.insertNextCell(NORM_POLYHED,92,connN[255:]);
2450         meshN.finishInsertingCells();
2451         myCoords=DataArrayDouble.New();
2452         myCoords.setValues(coords,69,3);
2453         meshN.setCoords(myCoords);
2454         meshN.checkCoherency();
2455         res1=meshN.arePolyhedronsNotCorrectlyOriented();
2456         meshN.orientCorrectlyPolyhedrons();
2457         res1=meshN.arePolyhedronsNotCorrectlyOriented();
2458         self.assertTrue(len(res1)==0);
2459         #
2460         da=meshN.getBarycenterAndOwner();
2461         self.assertEqual(4,da.getNumberOfTuples());
2462         self.assertEqual(3,da.getNumberOfComponents());
2463         daPtr=da.getValues();
2464         for i in xrange(12):
2465             self.assertTrue(abs(barys[i]-daPtr[i])<1e-12);
2466             pass
2467         pass
2468
2469     def testRenumberCellsForFields(self):
2470         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2471         f=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2472         f.setMesh(m);
2473         arr=DataArrayDouble.New();
2474         nbOfCells=m.getNumberOfCells();
2475         values1=[7.,107.,10007.,8.,108.,10008.,9.,109.,10009.,10.,110.,10010.,11.,111.,10011.]
2476         arr.setValues(values1,nbOfCells,3);
2477         f.setArray(arr);
2478         renumber1=[3,1,0,4,2]
2479         loc=[-0.05,-0.05, 0.55,-0.25, 0.55,0.15, -0.05,0.45, 0.45,0.45]
2480         for j in xrange(5):
2481             res=f.getValueOn(loc[2*j:2*j+2]);
2482             for i in xrange(3):
2483                 self.assertTrue(abs(values1[i+3*j]-res[i])<1e-12);
2484                 pass
2485             pass
2486         f.renumberCells(renumber1,False);
2487         ptr=f.getArray().getValues();
2488         expected1=[9.,109.,10009.,8.,108.,10008.,11.,111.,10011.,7.,107.,10007.,10.,110.,10010.]
2489         for i in xrange(15):
2490             self.assertTrue(abs(expected1[i]-ptr[i])<1e-12);
2491             pass
2492         #check that fields remains the same geometrically
2493         for j in xrange(5):
2494             res=f.getValueOn(loc[2*j:2*(j+1)]);
2495             for i in xrange(3):
2496                 self.assertTrue(abs(values1[i+3*j]-res[i])<1e-12);
2497                 pass
2498             pass
2499         #On gauss
2500         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,NO_TIME);
2501         f.setMesh(m);
2502         _a=0.446948490915965;
2503         _b=0.091576213509771;
2504         _p1=0.11169079483905;
2505         _p2=0.0549758718227661;
2506         refCoo1=[ 0.,0., 1.,0., 0.,1. ]
2507         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 ];
2508         wg1=[ 4*_p2, 4*_p2, 4*_p2, 4*_p1, 4*_p1, 4*_p1 ]
2509         _refCoo1=refCoo1[0:6];
2510         _gsCoo1=gsCoo1[0:12];
2511         _wg1=wg1[0:6];
2512         f.setGaussLocalizationOnType(NORM_TRI3,_refCoo1,_gsCoo1,_wg1);
2513         refCoo2=[ 0.,0., 1.,0., 1.,1., 0.,1. ]
2514         _refCoo2=refCoo2[0:8];
2515         _gsCoo1=_gsCoo1[0:4]
2516         _wg1=_wg1[0:2]
2517         f.setGaussLocalizationOnType(NORM_QUAD4,_refCoo2,_gsCoo1,_wg1);
2518         arr=DataArrayDouble.New();
2519         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.]
2520         arr.setValues(values2,18,2);
2521         f.setArray(arr);
2522         f.checkCoherency();
2523         fCpy=f.clone(True);
2524         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2525         f.renumberCells(renumber1,False);
2526         self.assertTrue(not f.isEqual(fCpy,1e-12,1e-12));
2527         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.]
2528         ptr=f.getArray().getValues();
2529         for i in xrange(36):
2530             self.assertTrue(abs(expected2[i]-ptr[i])<1e-12);
2531             pass
2532         renumber2=[2,1,4,0,3]
2533         f.renumberCells(renumber2,False);
2534         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2535         #GaussNE
2536         f=MEDCouplingFieldDouble.New(ON_GAUSS_NE,NO_TIME);
2537         f.setMesh(m);
2538         arr=DataArrayDouble.New();
2539         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.]
2540         arr.setValues(values3,18,2);
2541         f.setArray(arr);
2542         f.checkCoherency();
2543         fCpy=f.clone(True);
2544         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2545         f.renumberCells(renumber1,False);
2546         self.assertTrue(not f.isEqual(fCpy,1e-12,1e-12));
2547         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.]
2548         ptr=f.getArray().getValues();
2549         for i in xrange(36):
2550             self.assertTrue(abs(expected3[i]-ptr[i])<1e-12);
2551             pass
2552         f.renumberCells(renumber2,False);#perform reverse operation of renumbering to check that the resulting field is equal.
2553         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2554         #
2555         pass
2556
2557     def testRenumberNodesForFields(self):
2558         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2559         f=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
2560         f.setMesh(m);
2561         self.assertEqual(9,f.getNumberOfMeshPlacesExpected());
2562         arr=DataArrayDouble.New();
2563         nbOfNodes=m.getNumberOfNodes();
2564         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.]
2565         arr.setValues(values1,nbOfNodes,3);
2566         f.setArray(arr);
2567         f.checkCoherency();
2568         renumber1=[0,4,1,3,5,2,6,7,8]
2569         loc=[0.5432,-0.2432, 0.5478,0.1528]
2570         expected1=[9.0272, 109.0272, 10009.0272, 11.4124,111.4124,10011.4124]
2571         for j in xrange(2):
2572             res=f.getValueOn(loc[2*j:2*j+2]);
2573             for i in xrange(3):
2574                 self.assertTrue(abs(expected1[i+3*j]-res[i])<1e-12);
2575                 pass
2576             pass
2577         fCpy=f.clone(True);
2578         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2579         f.renumberNodes(renumber1);
2580         self.assertTrue(not f.isEqual(fCpy,1e-12,1e-12));
2581         for j in xrange(2):
2582             res=f.getValueOn(loc[2*j:2*j+2]);
2583             for i in xrange(3):
2584                 self.assertTrue(abs(expected1[i+3*j]-res[i])<1e-12);
2585                 pass
2586             pass
2587         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.]
2588         for i in xrange(27):
2589             self.assertTrue(abs(expected2[i]-f.getArray().getValues()[i])<1e-12);
2590             pass
2591         renumber2=[0,2,5,3,1,4,6,7,8]
2592         f.renumberNodes(renumber2);
2593         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2594         pass
2595
2596     def testConvertQuadraticCellsToLinear(self):
2597         mesh=MEDCouplingDataForTest.build2DTargetMesh_3();
2598         mesh.checkCoherency();
2599         types=mesh.getAllTypes();
2600         types.sort()
2601         self.assertEqual(5,len(types));
2602         expected1=[NORM_POLYGON, NORM_TRI3, NORM_QUAD4, NORM_TRI6, NORM_QUAD8]
2603         expected1.sort()
2604         self.assertEqual(expected1,types);
2605         self.assertTrue(mesh.isPresenceOfQuadratic());
2606         self.assertEqual(62,mesh.getMeshLength());
2607         f1=mesh.getMeasureField(False);
2608         #
2609         mesh.convertQuadraticCellsToLinear();
2610         self.assertTrue(not mesh.isPresenceOfQuadratic());
2611         #
2612         mesh.checkCoherency();
2613         f2=mesh.getMeasureField(False);
2614         self.assertTrue(f1.getArray().isEqual(f2.getArray(),1e-12));
2615         self.assertEqual(48,mesh.getMeshLength());
2616         types2=mesh.getAllTypes();
2617         types2.sort()
2618         self.assertEqual(3,len(types2));
2619         expected2=[NORM_POLYGON, NORM_TRI3, NORM_QUAD4]
2620         expected2.sort()
2621         self.assertEqual(expected2,types2);
2622         pass
2623
2624     def testCheckGeoEquivalWith(self):
2625         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2626         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2627         #First test mesh1
2628         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh1,0,1e-12);#deepEqual
2629         self.assertTrue(cellCor==None);
2630         self.assertTrue(nodeCor==None);
2631         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh1,1,1e-12);#fastEqual
2632         self.assertTrue(cellCor==None);
2633         self.assertTrue(nodeCor==None);
2634         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh1,10,1e-12);#deepEqual with geo permutations
2635         self.assertTrue(cellCor==None);
2636         self.assertTrue(nodeCor==None);
2637         #Second test mesh1 and mesh2 are 2 different meshes instance
2638         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,0,1e-12);#deepEqual
2639         self.assertTrue(cellCor==None);
2640         self.assertTrue(nodeCor==None);
2641         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,1,1e-12);#fastEqual
2642         self.assertTrue(cellCor==None);
2643         self.assertTrue(nodeCor==None);
2644         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);#deepEqual with geo permutations
2645         self.assertTrue(cellCor==None);
2646         self.assertTrue(nodeCor==None);
2647         #Third test : cell permutation by keeping the first the middle and the last as it is.
2648         renum=[0,2,1,3,4,5,6,8,7,9]
2649         mesh2.renumberCells(renum,False);
2650         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12);#deepEqual fails
2651         self.assertTrue(cellCor==None);
2652         self.assertTrue(nodeCor==None);
2653         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,1,1e-12);#fastEqual do not see anything
2654         self.assertTrue(cellCor==None);
2655         self.assertTrue(nodeCor==None);
2656         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);#deepEqual with geo permutations
2657         self.assertTrue(cellCor);
2658         self.assertEqual(10,cellCor.getNumberOfTuples());
2659         self.assertEqual(1,cellCor.getNumberOfComponents());
2660         self.assertEqual(renum,list(cellCor.getValues()))
2661         self.assertTrue(nodeCor==None);
2662         cellCor=0;
2663         self.assertTrue(nodeCor==None);
2664         #4th test : cell and node permutation by keeping the first the middle and the last as it is.
2665         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2666         renum2=[0,2,1,3,4,5,6,8,7,9,10]
2667         mesh2.renumberCells(renum,False);
2668         mesh2.renumberNodes(renum2,11);
2669         cellCor=None
2670         nodeCor=None
2671         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12);#deepEqual fails
2672         self.assertTrue(cellCor==None);
2673         self.assertTrue(nodeCor==None);
2674         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,1,1e-12);#fastEqual do not see anything
2675         self.assertTrue(cellCor==None);
2676         self.assertTrue(nodeCor==None);
2677         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);#deepEqual with geo permutations
2678         self.assertTrue(cellCor);
2679         self.assertEqual(10,cellCor.getNumberOfTuples());
2680         self.assertEqual(1,cellCor.getNumberOfComponents());
2681         self.assertEqual(renum,list(cellCor.getValues()))
2682         self.assertTrue(nodeCor);
2683         self.assertEqual(11,nodeCor.getNumberOfTuples());
2684         self.assertEqual(1,nodeCor.getNumberOfComponents());
2685         self.assertEqual(renum2,list(nodeCor.getValues()))
2686         cellCor=0;
2687         nodeCor=0;
2688         #5th test : modification of the last cell to check fastCheck detection.
2689         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2690         renum3=[0,2,1,3,4,5,6,8,9,7]
2691         mesh2.renumberCells(renum3,False);
2692         mesh2.renumberNodes(renum2,11);
2693         cellCor=None
2694         nodeCor=None
2695         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12)
2696         self.assertTrue(cellCor==None);
2697         self.assertTrue(nodeCor==None);
2698         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,1,1e-12)
2699         self.assertTrue(cellCor==None);
2700         self.assertTrue(nodeCor==None);
2701         cellCor,nodeCor=mesh2.checkGeoEquivalWith(mesh1,10,1e-12);#deepEqual with geo permutations
2702         self.assertTrue(cellCor!=None);
2703         self.assertEqual(10,cellCor.getNumberOfTuples());
2704         self.assertEqual(1,cellCor.getNumberOfComponents());
2705         self.assertEqual(renum3,list(cellCor.getValues()))
2706         self.assertTrue(nodeCor!=None);
2707         self.assertEqual(11,nodeCor.getNumberOfTuples());
2708         self.assertEqual(1,nodeCor.getNumberOfComponents());
2709         self.assertEqual(renum2,list(nodeCor.getValues()));
2710         pass
2711
2712     def testCheckGeoEquivalWith2(self):
2713         mesh1=MEDCouplingDataForTest.build2DTargetMesh_4();
2714         mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
2715         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);
2716         self.assertEqual(None,cellCor);
2717         self.assertNotEqual(None,nodeCor);
2718         expected1=[0, 1, 3, 4, 5, 6, 7, 8, 9]
2719         for i in xrange(9):
2720             self.assertEqual(expected1[i],nodeCor.getIJ(i,0));
2721             pass
2722         pass
2723
2724     def testCopyTinyStringsFromOnFields(self):
2725         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2726         nbOfCells=m.getNumberOfCells();
2727         f=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
2728         f.setMesh(m);
2729         self.assertEqual(5,f.getNumberOfMeshPlacesExpected());
2730         f.setName("a");
2731         f.setDescription("b");
2732         a1=DataArrayDouble.New();
2733         a1.alloc(nbOfCells,2);
2734         a1.fillWithZero();
2735         a1.setInfoOnComponent(0,"c");
2736         a1.setInfoOnComponent(1,"d");
2737         a2=a1.deepCpy();
2738         a2.setInfoOnComponent(0,"e");
2739         a2.setInfoOnComponent(1,"f");
2740         f.setArray(a1);
2741         f.setEndArray(a2);
2742         f.setEndTime(3.,3,4);
2743         m.setName("g");
2744         m.getCoords().setInfoOnComponent(0,"h");
2745         m.getCoords().setInfoOnComponent(1,"i");
2746         m.getCoords().setInfoOnComponent(2,"j");
2747         #
2748         f.checkCoherency();
2749         f2=f.clone(True);
2750         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2751         f2.setName("smth");
2752         self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2753         f2.copyTinyStringsFrom(f);
2754         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2755         f2.setDescription("GGG");
2756         self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2757         f2.copyTinyStringsFrom(f);
2758         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2759         f2.getArray().setInfoOnComponent(0,"mmmm");
2760         self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2761         f2.copyTinyStringsFrom(f);
2762         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2763         f2.getEndArray().setInfoOnComponent(1,"mmmm");
2764         self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2765         f2.copyTinyStringsFrom(f);
2766         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2767         m2=m.clone(True);
2768         self.assertTrue(m2.isEqual(m,1e-12));
2769         m2.setName("123");
2770         self.assertTrue(not m2.isEqual(m,1e-12));
2771         m2.copyTinyStringsFrom(m);
2772         self.assertTrue(m2.isEqual(m,1e-12));
2773         m2.getCoords().setInfoOnComponent(1,"eee");
2774         self.assertTrue(not m2.isEqual(m,1e-12));
2775         m2.copyTinyStringsFrom(m);
2776         self.assertTrue(m2.isEqual(m,1e-12));
2777         pass
2778
2779     def testTryToShareSameCoordsPermute(self):
2780         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2781         m2=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2782         #self.assertTrue(m.getCoords()!=m2.getCoords());
2783         m.tryToShareSameCoordsPermute(m2,1e-12);
2784         #self.assertTrue(m.getCoords()==m2.getCoords());
2785         self.assertTrue(m2.isEqual(m,1e-12));
2786         renum1=[1,2,0,5,8,7,4,3,6]
2787         r1=DataArrayInt.New()
2788         r1.setValues(renum1,len(renum1),1)
2789         m.renumberNodes(r1,9);
2790         #self.assertTrue(m.getCoords()!=m2.getCoords());
2791         self.assertTrue(not m2.isEqual(m,1e-12));
2792         m.tryToShareSameCoordsPermute(m2,1e-12);
2793         #self.assertTrue(m.getCoords()==m2.getCoords());
2794         self.assertTrue(m2.isEqual(m,1e-12));
2795         pass
2796
2797     def testTryToShareSameCoordsPermute2(self):
2798         m1=MEDCouplingDataForTest.build2DTargetMesh_4();
2799         targetCoords=[-0.3,-0.3, 0.2,-0.3, -0.3,0.2, 0.2,0.2 ]
2800         targetConn=[0,2,3,1]
2801         m2=MEDCouplingUMesh.New();
2802         m2.setMeshDimension(2);
2803         m2.allocateCells(1);
2804         m2.insertNextCell(NORM_QUAD4,targetConn[0:4])
2805         m2.finishInsertingCells();
2806         myCoords=DataArrayDouble.New();
2807         myCoords.setValues(targetCoords,4,2);
2808         m2.setCoords(myCoords);
2809         m2.checkCoherency();
2810         m1.checkCoherency();
2811         #
2812         expected1=[0.25,0.125,0.125,0.25,0.25]
2813         f1=m1.getMeasureField(False);
2814         f2=m2.getMeasureField(False);
2815         self.assertEqual(5,f1.getArray().getNumberOfTuples());
2816         self.assertEqual(1,f2.getArray().getNumberOfTuples());
2817         for i in xrange(5):
2818             self.assertAlmostEqual(expected1[i],f1.getIJ(i,0),12);
2819             pass
2820         self.assertAlmostEqual(expected1[0],f2.getIJ(0,0),12);
2821         self.assertRaises(InterpKernelException,m1.tryToShareSameCoordsPermute,m2,1e-12);# <- here in this order the sharing is impossible.
2822         # Let's go for deeper test of tryToShareSameCoordsPermute
2823         m2.tryToShareSameCoordsPermute(m1,1e-12);
2824         f1=m1.getMeasureField(False);
2825         f2=m2.getMeasureField(False);
2826         self.assertEqual(5,f1.getArray().getNumberOfTuples());
2827         self.assertEqual(1,f2.getArray().getNumberOfTuples());
2828         for i in xrange(5):
2829             self.assertAlmostEqual(expected1[i],f1.getIJ(i,0),12);
2830             pass
2831         self.assertAlmostEqual(expected1[0],f2.getIJ(0,0),12);
2832         pass
2833
2834     def testChangeUnderlyingMesh1(self):
2835         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2836         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2837         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2838         f1.setMesh(mesh1);
2839         array=DataArrayDouble.New();
2840         arr=[7., 107., 8., 108., 9., 109., 10., 110., 11., 111., 12., 112., 13., 113., 14., 114., 15., 115., 16., 116.]
2841         array.setValues(arr,mesh1.getNumberOfCells(),2);
2842         f1.setArray(array);
2843         #
2844         renum=[0,2,1,3,4,5,6,8,7,9]
2845         mesh2.renumberCells(renum,False);
2846         #self.assertTrue(f1.getMesh()==mesh1);
2847         f1.changeUnderlyingMesh(mesh1,10,1e-12);# nothing done only to check that nothing done.
2848         #self.assertTrue(f1.getMesh()==mesh1);
2849         f1.changeUnderlyingMesh(mesh2,10,1e-12);
2850         #self.assertTrue(f1.getMesh()==mesh2);
2851         expected1=[7.,107.,9.,109.,8.,108.,10.,110.,11.,111.,12.,112.,13.,113.,15.,115.,14.,114.,16.,116.]
2852         for i in xrange(20):
2853             self.assertAlmostEqual(expected1[i],f1.getArray().getIJ(0,i),12);
2854             pass
2855         #
2856         f1=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
2857         f1.setMesh(mesh1);
2858         array=DataArrayDouble.New();
2859         arr2=[7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.,17.,117.]
2860         array.setValues(arr2,mesh1.getNumberOfNodes(),2);
2861         f1.setArray(array);
2862         #
2863         renum2=[0,2,10,3,4,5,6,8,7,9,1]
2864         mesh2.renumberNodes(renum2,11);
2865         #self.assertTrue(f1.getMesh()==mesh1);
2866         f1.changeUnderlyingMesh(mesh2,10,1e-12);
2867         #self.assertTrue(f1.getMesh()==mesh2);
2868         expected2=[7.,107.,17.,117.,8.,108.,10.,110.,11.,111.,12.,112.,13.,113.,15.,115.,14.,114.,16.,116.,9.,109.]
2869         for i in xrange(22):
2870             self.assertAlmostEqual(expected2[i],f1.getArray().getIJ(0,i),12);
2871             pass
2872         pass
2873
2874     def testGetMaxValue1(self):
2875         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2876         nbOfCells=m.getNumberOfCells();
2877         f=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
2878         f.setMesh(m);
2879         a1=DataArrayDouble.New();
2880         val1=[3.,4.,5.,6.,7.]
2881         a1.setValues(val1,nbOfCells,1);
2882         a2=DataArrayDouble.New();
2883         val2=[0.,1.,2.,8.,7.]
2884         a2.setValues(val2,nbOfCells,1);
2885         f.setArray(a1);
2886         f.setEndArray(a2);
2887         f.setEndTime(3.,3,4);
2888         f.checkCoherency();
2889         #
2890         self.assertAlmostEqual(8.,f.getMaxValue(),14);
2891         self.assertAlmostEqual(0.,f.getMinValue(),14);
2892         self.assertAlmostEqual(5.,f.getAverageValue(),14);
2893         self.assertAlmostEqual(5.125,f.getWeightedAverageValue(),14);
2894         a1.setIJ(0,2,9.5);
2895         self.assertAlmostEqual(9.5,f.getMaxValue(),14);
2896         self.assertAlmostEqual(0.,f.getMinValue(),14);
2897         a2.setIJ(0,0,9.);
2898         self.assertAlmostEqual(9.5,f.getMaxValue(),14);
2899         self.assertAlmostEqual(1.,f.getMinValue(),14);
2900         pass
2901
2902     def testSubstractInPlaceDM1(self):
2903         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2904         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2905         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2906         f1.setMesh(mesh1);
2907         array=DataArrayDouble.New();
2908         arr=[7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.]
2909         array.setValues(arr,mesh1.getNumberOfCells(),2);
2910         f1.setArray(array);
2911         #
2912         self.assertEqual(10,f1.getNumberOfTuples());
2913         self.assertEqual(2,f1.getNumberOfComponents());
2914         self.assertEqual(20,f1.getNumberOfValues());
2915         #
2916         renum=[0,2,3,1,4,5,6,8,7,9]
2917         mesh2.renumberCells(renum,False);
2918         #
2919         f2=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2920         f2.setMesh(mesh2);
2921         array=DataArrayDouble.New();
2922         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]
2923         array.setValues(arr2,mesh2.getNumberOfCells(),2);
2924         f2.setArray(array);
2925         #
2926         f1.substractInPlaceDM(f2,10,1e-12);
2927         f1.applyFunc(1,"abs(x+y+0.2)");
2928         self.assertAlmostEqual(0.,f1.getMaxValue(),13);
2929         pass
2930
2931     def testDotCrossProduct1(self):
2932         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2933         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
2934         f1.setTime(2.3,5,6);
2935         f1.setMesh(mesh1);
2936         array=DataArrayDouble.New();
2937         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.]
2938         array.setValues(arr1,mesh1.getNumberOfCells(),3);
2939         f1.setArray(array);
2940         f2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
2941         f2.setTime(7.8,4,5);
2942         f2.setMesh(mesh1);
2943         array=DataArrayDouble.New();
2944         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.]
2945         array.setValues(arr2,mesh1.getNumberOfCells(),3);
2946         f2.setArray(array);
2947         #
2948         f3=f1.dot(f2);
2949         expected1=[842.,1820.,2816.,3830.,4862.,5912.,6980.,8066.,9170.,10292.]
2950         for i in xrange(10):
2951             self.assertAlmostEqual(expected1[i],f3.getIJ(i,0),9);
2952             pass
2953         #
2954         f4=f1.crossProduct(f2);
2955         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.]
2956         for i in xrange(30):
2957             self.assertAlmostEqual(expected2[i],f4.getIJ(0,i),9);
2958             pass
2959         pass
2960
2961     def testMinMaxFields1(self):
2962         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2963         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
2964         f1.setTime(2.3,5,6);
2965         f1.setMesh(mesh1);
2966         array=DataArrayDouble.New();
2967         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.]
2968         array.setValues(arr1,mesh1.getNumberOfCells(),3);
2969         f1.setArray(array);
2970         f2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
2971         f2.setTime(7.8,4,5);
2972         f2.setMesh(mesh1);
2973         array=DataArrayDouble.New();
2974         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.]
2975         array.setValues(arr2,mesh1.getNumberOfCells(),3);
2976         f2.setArray(array);
2977         #
2978         f3=f1.max(f2);
2979         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.]
2980         for i in xrange(30):
2981             self.assertAlmostEqual(expected1[i],f3.getIJ(0,i),9);
2982             pass
2983         #
2984         f4=f1.min(f2);
2985         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.]
2986         for i in xrange(30):
2987             self.assertAlmostEqual(expected2[i],f4.getIJ(0,i),9);
2988             pass
2989         #
2990         pass
2991
2992     def testApplyLin1(self):
2993         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2994         f1=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
2995         f1.setMesh(mesh1);
2996         array=DataArrayDouble.New();
2997         arr=[7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.]
2998         array.setValues(arr,mesh1.getNumberOfCells(),2);
2999         f1.setArray(array);
3000         #
3001         f1.applyLin(2.,3.,0);
3002         expected1=[17.,107.,19.,108.,21.,109.,23.,110.,25.,111.,27.,112.,29.,113.,31.,114.,33.,115.,35.,116.]
3003         for i in xrange(20):
3004             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),9);
3005             pass
3006         #
3007         arr2=[2.,102.,3.,103.,4.,104.,5.,105.,6.,106.,7.,107.,8.,108.,9.,109.,10.,110.,11.,111.]
3008         array=DataArrayDouble.New();
3009         array.setValues(arr2,mesh1.getNumberOfCells(),2);
3010         f1.setEndArray(array);
3011         #
3012         f1.applyLin(4.,5.,1);
3013         #
3014         expected2=[17.,433.,19.,437.,21.,441.,23.,445.,25.,449.,27.,453.,29.,457.,31.,461.,33.,465.,35.,469.]
3015         for i in xrange(20):
3016             self.assertAlmostEqual(expected2[i],f1.getIJ(0,i),9);
3017             pass
3018         expected3=[2.,413.,3.,417.,4.,421.,5.,425.,6.,429.,7.,433.,8.,437.,9.,441.,10.,445.,11.,449.]
3019         for i in xrange(20):
3020             self.assertAlmostEqual(expected3[i],f1.getEndArray().getIJ(0,i),9);
3021             pass
3022         #
3023         pass
3024
3025     def testGetIdsInRange1(self):
3026         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
3027         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3028         f1.setTime(2.3,5,6);
3029         f1.setMesh(mesh1);
3030         array=DataArrayDouble.New();
3031         arr1=[2.,8.,6.,5.,11.,7.,9.,3.,10.,4.]
3032         array.setValues(arr1,mesh1.getNumberOfCells(),1);
3033         f1.setArray(array);
3034         #
3035         f1.checkCoherency();
3036         da=f1.getIdsInRange(2.9,7.1);
3037         self.failUnlessEqual(5,da.getNbOfElems());
3038         expected1=[2,3,5,7,9]
3039         self.failUnlessEqual(expected1,list(da.getValues()));
3040         da=f1.getIdsInRange(8.,12.);
3041         self.failUnlessEqual(4,da.getNbOfElems());
3042         expected2=[1,4,6,8]
3043         self.failUnlessEqual(expected2,list(da.getValues()));
3044         #
3045         pass
3046
3047     def testBuildSubPart1(self):
3048         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3049         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3050         f1.setTime(2.3,5,6);
3051         f1.setMesh(mesh1);
3052         array=DataArrayDouble.New();
3053         arr1=[3.,103.,4.,104.,5.,105.,6.,106.,7.,107.]
3054         array.setValues(arr1,mesh1.getNumberOfCells(),2);
3055         f1.setArray(array);
3056         #
3057         part1=[2,1,4]
3058         f2=f1[part1];
3059         f2.zipCoords()
3060         self.failUnlessEqual(3,f2.getNumberOfTuples());
3061         self.failUnlessEqual(2,f2.getNumberOfComponents());
3062         expected1=[5.,105.,4.,104.,7.,107.]
3063         for i in xrange(6):
3064             self.assertAlmostEqual(f2.getIJ(0,i),expected1[i],12);
3065             pass
3066         self.failUnlessEqual(3,f2.getMesh().getNumberOfCells());
3067         self.failUnlessEqual(6,f2.getMesh().getNumberOfNodes());
3068         self.failUnlessEqual(2,f2.getMesh().getSpaceDimension());
3069         self.failUnlessEqual(2,f2.getMesh().getMeshDimension());
3070         m2C=f2.getMesh();
3071         self.failUnlessEqual(13,m2C.getMeshLength());
3072         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]
3073         for i in xrange(12):
3074             self.assertAlmostEqual(expected2[i],m2C.getCoords().getIJ(0,i),12);
3075             pass
3076         expected3=[3,2,3,1,3,0,2,1,4,4,5,3,2]
3077         self.failUnlessEqual(expected3,list(m2C.getNodalConnectivity().getValues()));
3078         expected4=[0,4,8,13]
3079         self.failUnlessEqual(expected4,list(m2C.getNodalConnectivityIndex().getValues()));
3080         # Test with field on nodes.
3081         f1=MEDCouplingFieldDouble.New(ON_NODES,ONE_TIME);
3082         f1.setTime(2.3,5,6);
3083         f1.setMesh(mesh1);
3084         array=DataArrayDouble.New();
3085         arr2=[3.,103.,4.,104.,5.,105.,6.,106.,7.,107.,8.,108.,9.,109.,10.,110.,11.,111.]
3086         array.setValues(arr2,mesh1.getNumberOfNodes(),2);
3087         f1.setArray(array);
3088         part2=[1,2]
3089         f2=f1.buildSubPart(part2);
3090         self.failUnlessEqual(4,f2.getNumberOfTuples());
3091         self.failUnlessEqual(2,f2.getNumberOfComponents());
3092         expected5=[4.,104.,5.,105.,7.,107.,8.,108.]
3093         for i in xrange(8):
3094             self.assertAlmostEqual(f2.getIJ(0,i),expected5[i],12);
3095             pass
3096         self.failUnlessEqual(2,f2.getMesh().getNumberOfCells());
3097         self.failUnlessEqual(4,f2.getMesh().getNumberOfNodes());
3098         self.failUnlessEqual(2,f2.getMesh().getSpaceDimension());
3099         self.failUnlessEqual(2,f2.getMesh().getMeshDimension());
3100         m2C=f2.getMesh();
3101         self.failUnlessEqual(8,m2C.getMeshLength());
3102         for i in xrange(8):#8 is not an error
3103             self.assertAlmostEqual(expected2[i],m2C.getCoords().getIJ(0,i),12);
3104             pass
3105         self.failUnlessEqual(expected3[:4],list(m2C.getNodalConnectivity().getValues())[4:]);
3106         self.failUnlessEqual(expected3[4:8],list(m2C.getNodalConnectivity().getValues())[:4]);
3107         self.failUnlessEqual(expected4[:3],list(m2C.getNodalConnectivityIndex().getValues()));
3108         #idem previous because nodes of cell#4 are not fully present in part3
3109         part3=[1,2]
3110         arrr=DataArrayInt.New();
3111         arrr.setValues(part3,2,1);
3112         f2=f1.buildSubPart(arrr);
3113         self.failUnlessEqual(4,f2.getNumberOfTuples());
3114         self.failUnlessEqual(2,f2.getNumberOfComponents());
3115         for i in xrange(8):
3116             self.assertAlmostEqual(f2.getIJ(0,i),expected5[i],12);
3117             pass
3118         self.failUnlessEqual(2,f2.getMesh().getNumberOfCells());
3119         self.failUnlessEqual(4,f2.getMesh().getNumberOfNodes());
3120         self.failUnlessEqual(2,f2.getMesh().getSpaceDimension());
3121         self.failUnlessEqual(2,f2.getMesh().getMeshDimension());
3122         m2C=f2.getMesh();
3123         self.failUnlessEqual(8,m2C.getMeshLength());
3124         for i in xrange(8):#8 is not an error
3125             self.assertAlmostEqual(expected2[i],m2C.getCoords().getIJ(0,i),12);
3126             pass
3127         self.failUnlessEqual(expected3[:4],list(m2C.getNodalConnectivity().getValues())[4:8]);
3128         self.failUnlessEqual(expected3[4:8],list(m2C.getNodalConnectivity().getValues())[:4]);
3129         self.failUnlessEqual(expected4[:3],list(m2C.getNodalConnectivityIndex().getValues()));
3130         #
3131         part4=[1,2,4]
3132         f2=f1.buildSubPart(part4);
3133         self.failUnlessEqual(6,f2.getNumberOfTuples());
3134         self.failUnlessEqual(2,f2.getNumberOfComponents());
3135         expected6=[4.,104.,5.,105.,7.,107.,8.,108.,10.,110.,11.,111.]
3136         for i in xrange(12):
3137             self.assertAlmostEqual(f2.getIJ(0,i),expected6[i],12);
3138             pass
3139         self.failUnlessEqual(3,f2.getMesh().getNumberOfCells());
3140         self.failUnlessEqual(6,f2.getMesh().getNumberOfNodes());
3141         self.failUnlessEqual(2,f2.getMesh().getSpaceDimension());
3142         self.failUnlessEqual(2,f2.getMesh().getMeshDimension());
3143         m2C=f2.getMesh();
3144         self.failUnlessEqual(13,m2C.getMeshLength());
3145         for i in xrange(12):
3146             self.assertAlmostEqual(expected2[i],m2C.getCoords().getIJ(0,i),12);
3147             pass
3148         self.failUnlessEqual(expected3[0:4],list(m2C.getNodalConnectivity().getValues())[4:8]);
3149         self.failUnlessEqual(expected3[4:8],list(m2C.getNodalConnectivity().getValues())[0:4]);
3150         self.failUnlessEqual(expected3[8:13],list(m2C.getNodalConnectivity().getValues())[8:13]);
3151         self.failUnlessEqual(expected4,list(m2C.getNodalConnectivityIndex().getValues()));
3152         pass
3153
3154     def testDoublyContractedProduct1(self):
3155         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3156         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3157         f1.setMesh(mesh1);
3158         array=DataArrayDouble.New();
3159         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]
3160         array.setValues(arr1,mesh1.getNumberOfCells(),6);
3161         f1.setArray(array);
3162         f1.checkCoherency();
3163         #
3164         f2=f1.doublyContractedProduct();
3165         f2.checkCoherency();
3166         self.assertEqual(1,f2.getNumberOfComponents());
3167         self.assertEqual(5,f2.getNumberOfTuples());
3168         for i in xrange(5):
3169             self.assertAlmostEqual(3906.56,f2.getIJ(i,0),9);
3170             pass
3171         #
3172         pass
3173
3174     def testDeterminant1(self):
3175         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3176         f1=MEDCouplingFieldDouble.New(ON_CELLS,CONST_ON_TIME_INTERVAL);
3177         f1.setTime(2.3,5,6);
3178         f1.setEndTime(3.8,7,3);
3179         f1.setMesh(mesh1);
3180         array=DataArrayDouble.New();
3181         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]
3182         array.setValues(arr1,mesh1.getNumberOfCells(),4);
3183         f1.setArray(array);
3184         #4 components
3185         f1.checkCoherency();
3186         f2=f1.determinant();
3187         f2.checkCoherency();
3188         self.assertEqual(CONST_ON_TIME_INTERVAL,f2.getTimeDiscretization());
3189         self.assertEqual(1,f2.getNumberOfComponents());
3190         self.assertEqual(5,f2.getNumberOfValues());
3191         for i in xrange(5):
3192             self.assertAlmostEqual(-2.42,f2.getIJ(i,0),13);
3193             pass
3194         #6 components multi arrays with end array not defined
3195         f1=MEDCouplingFieldDouble.New(ON_NODES,LINEAR_TIME);
3196         f1.setTime(2.3,5,6);
3197         f1.setEndTime(3.8,7,3);
3198         f1.setMesh(mesh1);
3199         array=DataArrayDouble.New();
3200         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,
3201               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         array.setValues(arr2,mesh1.getNumberOfNodes(),6);
3203         f1.setArray(array);
3204         self.assertRaises(InterpKernelException,f1.checkCoherency);#no end array specified !
3205         #
3206         f2=f1.determinant();
3207         self.assertEqual(LINEAR_TIME,f2.getTimeDiscretization());
3208         self.assertEqual(1,f2.getArray().getNumberOfComponents());
3209         self.assertEqual(9,f2.getNumberOfTuples());
3210         for i in xrange(9):
3211             self.assertAlmostEqual(137.335,f2.getIJ(i,0),10);
3212             pass
3213         #6 components multi arrays with end array defined
3214         array=DataArrayDouble.New();
3215         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,
3216               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         array.setValues(arr3,mesh1.getNumberOfNodes(),6);
3218         f1.setEndArray(array);
3219         f1.checkCoherency();
3220         f2=f1.determinant();
3221         f2.checkCoherency();
3222         self.assertEqual(LINEAR_TIME,f2.getTimeDiscretization());
3223         self.assertEqual(1,f2.getNumberOfComponents());
3224         self.assertEqual(9,f2.getNumberOfTuples());
3225         time2,it,order=f2.getTime()
3226         self.assertAlmostEqual(2.3,time2,12);
3227         self.assertEqual(5,it);
3228         self.assertEqual(6,order);
3229         time2,it,order=f2.getEndTime()
3230         self.assertAlmostEqual(3.8,time2,12);
3231         self.assertEqual(7,it);
3232         self.assertEqual(3,order);
3233         for i in xrange(9):
3234             self.assertAlmostEqual(137.335,f2.getIJ(i,0),10);
3235             self.assertAlmostEqual(1289.685,f2.getEndArray().getIJ(i,0),9);
3236             pass
3237         #9 components
3238         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3239         f1.setTime(7.8,10,2);
3240         f1.setMesh(mesh1);
3241         array=DataArrayDouble.New();
3242         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]
3243         array.setValues(arr4,mesh1.getNumberOfCells(),9);
3244         f1.setArray(array);
3245         #
3246         f1.checkCoherency();
3247         f2=f1.determinant();
3248         f2.checkCoherency();
3249         self.assertEqual(ONE_TIME,f2.getTimeDiscretization());
3250         self.assertEqual(1,f2.getNumberOfComponents());
3251         self.assertEqual(5,f2.getNumberOfTuples());
3252         time2,it,order=f2.getTime()
3253         self.assertAlmostEqual(7.8,time2,12);
3254         self.assertEqual(10,it);
3255         self.assertEqual(2,order);
3256         for i in xrange(5):
3257             self.assertAlmostEqual(3.267,f2.getIJ(i,0),13);
3258             pass
3259         pass
3260
3261     def testEigenValues1(self):
3262         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3263         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3264         f1.setMesh(mesh1);
3265         array=DataArrayDouble.New();
3266         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]
3267         array.setValues(arr1,mesh1.getNumberOfCells(),6);
3268         f1.setArray(array);
3269         f1.checkCoherency();
3270         #
3271         f2=f1.eigenValues();
3272         f2.checkCoherency();
3273         self.assertEqual(3,f2.getNumberOfComponents());
3274         self.assertEqual(5,f2.getNumberOfTuples());
3275         expected1=[13.638813677891717,-4.502313844635971,-2.2364998332557486]
3276         for i in xrange(5):
3277             self.assertAlmostEqual(expected1[0],f2.getIJ(i,0),13);
3278             self.assertAlmostEqual(expected1[1],f2.getIJ(i,1),13);
3279             self.assertAlmostEqual(expected1[2],f2.getIJ(i,2),13);
3280             pass
3281         pass
3282
3283     def testEigenVectors1(self):
3284         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3285         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3286         f1.setMesh(mesh1);
3287         array=DataArrayDouble.New();
3288         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]
3289         array.setValues(arr1,mesh1.getNumberOfCells(),6);
3290         f1.setArray(array);
3291         f1.checkCoherency();
3292         #
3293         f2=f1.eigenVectors();
3294         f2.checkCoherency();
3295         self.assertEqual(9,f2.getNumberOfComponents());
3296         self.assertEqual(5,f2.getNumberOfTuples());
3297         expected1=[0.5424262364180696, 0.5351201064614425, 0.6476266283176001,#eigenvect 0
3298                    0.7381111277307373, 0.06458838384003074, -0.6715804522117897,#eigenvect 1
3299                    -0.4012053603397987, 0.8423032781211455, -0.3599436712889738#eigenvect 2
3300                    ]
3301         for i in xrange(5):
3302             self.assertAlmostEqual(expected1[0],f2.getIJ(i,0),13);
3303             self.assertAlmostEqual(expected1[1],f2.getIJ(i,1),13);
3304             self.assertAlmostEqual(expected1[2],f2.getIJ(i,2),13);
3305             self.assertAlmostEqual(expected1[3],f2.getIJ(i,3),13);
3306             self.assertAlmostEqual(expected1[4],f2.getIJ(i,4),13);
3307             self.assertAlmostEqual(expected1[5],f2.getIJ(i,5),13);
3308             self.assertAlmostEqual(expected1[6],f2.getIJ(i,6),13);
3309             self.assertAlmostEqual(expected1[7],f2.getIJ(i,7),13);
3310             self.assertAlmostEqual(expected1[8],f2.getIJ(i,8),13);
3311             pass
3312         #
3313         pass
3314
3315     def testInverse1(self):
3316         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3317         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3318         f1.setMesh(mesh1);
3319         array=DataArrayDouble.New();
3320         arr1=[1.2,2.3,3.4,4.5,5.6,6.7,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]
3321         array.setValues(arr1,mesh1.getNumberOfCells(),9);
3322         f1.setArray(array);
3323         f1.checkCoherency();
3324         #
3325         f2=f1.inverse();
3326         f2.checkCoherency();
3327         self.assertEqual(9,f2.getNumberOfComponents());
3328         self.assertEqual(5,f2.getNumberOfTuples());
3329         expected1=[-2.6538108356290113, 2.855831037649208, -1.1111111111111067, 3.461891643709813, -4.775022956841121, 2.2222222222222143, -1.1111111111111054, 2.222222222222214, -1.1111111111111072]
3330         for i in xrange(5):
3331             self.assertAlmostEqual(expected1[0],f2.getIJ(i,0),13);
3332             self.assertAlmostEqual(expected1[1],f2.getIJ(i,1),13);
3333             self.assertAlmostEqual(expected1[2],f2.getIJ(i,2),13);
3334             self.assertAlmostEqual(expected1[3],f2.getIJ(i,3),13);
3335             self.assertAlmostEqual(expected1[4],f2.getIJ(i,4),13);
3336             self.assertAlmostEqual(expected1[5],f2.getIJ(i,5),13);
3337             self.assertAlmostEqual(expected1[6],f2.getIJ(i,6),13);
3338             self.assertAlmostEqual(expected1[7],f2.getIJ(i,7),13);
3339             self.assertAlmostEqual(expected1[8],f2.getIJ(i,8),13);
3340             pass
3341         #
3342         array=DataArrayDouble.New();
3343         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]
3344         array.setValues(arr3,mesh1.getNumberOfCells(),6);
3345         f1.setArray(array);
3346         f1.checkCoherency();
3347         #
3348         f2=f1.inverse();
3349         f2.checkCoherency();
3350         self.assertEqual(6,f2.getNumberOfComponents());
3351         self.assertEqual(5,f2.getNumberOfTuples());
3352         expected3=[-0.3617705098531818, -0.8678630828458127, -0.026843764174972983, 0.5539957431465833, 0.13133439560823013, -0.05301294502145887]
3353         for i in xrange(5):
3354             self.assertAlmostEqual(expected3[0],f2.getIJ(i,0),13);
3355             self.assertAlmostEqual(expected3[1],f2.getIJ(i,1),13);
3356             self.assertAlmostEqual(expected3[2],f2.getIJ(i,2),13);
3357             self.assertAlmostEqual(expected3[3],f2.getIJ(i,3),13);
3358             self.assertAlmostEqual(expected3[4],f2.getIJ(i,4),13);
3359             self.assertAlmostEqual(expected3[5],f2.getIJ(i,5),13);
3360             pass
3361         #
3362         array=DataArrayDouble.New();
3363         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]
3364         array.setValues(arr2,mesh1.getNumberOfCells(),4);
3365         f1.setArray(array);
3366         f1.checkCoherency();
3367         #
3368         f2=f1.inverse();
3369         f2.checkCoherency();
3370         self.assertEqual(4,f2.getNumberOfComponents());
3371         self.assertEqual(5,f2.getNumberOfTuples());
3372         expected2=[-1.8595041322314059, 0.9504132231404963, 1.404958677685951, -0.49586776859504156]
3373         for i in xrange(5):
3374             self.assertAlmostEqual(expected2[0],f2.getIJ(i,0),13);
3375             self.assertAlmostEqual(expected2[1],f2.getIJ(i,1),13);
3376             self.assertAlmostEqual(expected2[2],f2.getIJ(i,2),13);
3377             self.assertAlmostEqual(expected2[3],f2.getIJ(i,3),13);
3378             pass
3379         #
3380         pass
3381
3382     def testTrace1(self):
3383         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3384         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3385         f1.setMesh(mesh1);
3386         array=DataArrayDouble.New();
3387         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]
3388         array.setValues(arr1,mesh1.getNumberOfCells(),9);
3389         f1.setArray(array);
3390         f1.checkCoherency();
3391         #
3392         f2=f1.trace();
3393         f2.checkCoherency();
3394         self.assertEqual(1,f2.getNumberOfComponents());
3395         self.assertEqual(5,f2.getNumberOfTuples());
3396         for i in xrange(5):
3397             self.assertAlmostEqual(15.9,f2.getIJ(i,0),13);
3398             pass
3399         #
3400         array=DataArrayDouble.New();
3401         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]
3402         array.setValues(arr3,mesh1.getNumberOfCells(),6);
3403         f1.setArray(array);
3404         f1.checkCoherency();
3405         #
3406         f2=f1.trace();
3407         f2.checkCoherency();
3408         self.assertEqual(1,f2.getNumberOfComponents());
3409         self.assertEqual(5,f2.getNumberOfTuples());
3410         for i in xrange(5):
3411             self.assertAlmostEqual(25.8,f2.getIJ(i,0),13);
3412             pass
3413         #
3414         array=DataArrayDouble.New();
3415         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]
3416         array.setValues(arr2,mesh1.getNumberOfCells(),4);
3417         f1.setArray(array);
3418         f1.checkCoherency();
3419         #
3420         f2=f1.trace();
3421         f2.checkCoherency();
3422         self.assertEqual(1,f2.getNumberOfComponents());
3423         self.assertEqual(5,f2.getNumberOfTuples());
3424         for i in xrange(5):
3425             self.assertAlmostEqual(5.7,f2.getIJ(i,0),13);
3426             pass
3427         #
3428         pass
3429
3430     def testDeviator1(self):
3431         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3432         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3433         f1.setMesh(mesh1);
3434         array=DataArrayDouble.New();
3435         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]
3436         array.setValues(arr1,mesh1.getNumberOfCells(),6);
3437         f1.setArray(array);
3438         f1.checkCoherency();
3439         #
3440         f2=f1.deviator();
3441         f2.checkCoherency();
3442         self.assertEqual(6,f2.getNumberOfComponents());
3443         self.assertEqual(5,f2.getNumberOfTuples());
3444         expected1=[-1.1,0.,1.1,4.5,5.6,6.7]
3445         for i in xrange(5):
3446             self.assertAlmostEqual(expected1[0],f2.getIJ(i,0),13);
3447             self.assertAlmostEqual(expected1[1],f2.getIJ(i,1),13);
3448             self.assertAlmostEqual(expected1[2],f2.getIJ(i,2),13);
3449             self.assertAlmostEqual(expected1[3],f2.getIJ(i,3),13);
3450             self.assertAlmostEqual(expected1[4],f2.getIJ(i,4),13);
3451             self.assertAlmostEqual(expected1[5],f2.getIJ(i,5),13);
3452             pass
3453         #
3454         pass
3455
3456     def testMagnitude1(self):
3457         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3458         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3459         f1.setMesh(mesh1);
3460         array=DataArrayDouble.New();
3461         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]
3462         array.setValues(arr1,mesh1.getNumberOfCells(),5);
3463         f1.setArray(array);
3464         f1.checkCoherency();
3465         #
3466         f2=f1.magnitude();
3467         f2.checkCoherency();
3468         self.assertEqual(1,f2.getNumberOfComponents());
3469         self.assertEqual(5,f2.getNumberOfTuples());
3470         for i in xrange(5):
3471             self.assertAlmostEqual(8.3606219864313918,f2.getIJ(i,0),13);
3472             pass
3473         #
3474         pass
3475
3476     def testMaxPerTuple1(self):
3477         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3478         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3479         f1.setMesh(mesh1);
3480         array=DataArrayDouble.New();
3481         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]
3482         array.setValues(arr1,mesh1.getNumberOfCells(),5);
3483         f1.setArray(array);
3484         f1.checkCoherency();
3485         #
3486         f2=f1.maxPerTuple();
3487         f2.checkCoherency();
3488         self.assertEqual(1,f2.getNumberOfComponents());
3489         self.assertEqual(5,f2.getNumberOfTuples());
3490         for i in xrange(5):
3491             self.assertAlmostEqual(5.6,f2.getIJ(i,0),13);
3492             pass
3493         #
3494         pass
3495
3496     def testChangeNbOfComponents(self):
3497         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3498         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3499         f1.setMesh(mesh1);
3500         array=DataArrayDouble.New();
3501         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]
3502         array.setValues(arr1,mesh1.getNumberOfCells(),5);
3503         f1.setArray(array);
3504         f1.checkCoherency();
3505         #
3506         f1.changeNbOfComponents(3,7.77);
3507         f1.checkCoherency();
3508         self.assertEqual(3,f1.getNumberOfComponents());
3509         self.assertEqual(5,f1.getNumberOfTuples());
3510         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]
3511         for i in xrange(15):
3512             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),13);
3513             pass
3514         f1.changeNbOfComponents(4,7.77);
3515         f1.checkCoherency();
3516         self.assertEqual(4,f1.getNumberOfComponents());
3517         self.assertEqual(5,f1.getNumberOfTuples());
3518         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]
3519         for i in xrange(20):
3520             self.assertAlmostEqual(expected2[i],f1.getIJ(0,i),13);
3521             pass
3522         #
3523         pass
3524
3525     def testSortPerTuple1(self):
3526         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3527         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3528         f1.setMesh(mesh1);
3529         array=DataArrayDouble.New();
3530         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]
3531         array.setValues(arr1,mesh1.getNumberOfCells(),5);
3532         f1.setArray(array);
3533         f1.checkCoherency();
3534         #
3535         f1.sortPerTuple(True);
3536         f1.checkCoherency();
3537         self.assertEqual(5,f1.getNumberOfComponents());
3538         self.assertEqual(5,f1.getNumberOfTuples());
3539         for i in xrange(5):
3540             self.assertAlmostEqual(arr1[0],f1.getIJ(i,0),13);
3541             self.assertAlmostEqual(arr1[1],f1.getIJ(i,1),13);
3542             self.assertAlmostEqual(arr1[2],f1.getIJ(i,2),13);
3543             self.assertAlmostEqual(arr1[3],f1.getIJ(i,3),13);
3544             self.assertAlmostEqual(arr1[4],f1.getIJ(i,4),13);
3545             pass
3546         #
3547         f1.sortPerTuple(False);
3548         f1.checkCoherency();
3549         self.assertEqual(5,f1.getNumberOfComponents());
3550         self.assertEqual(5,f1.getNumberOfTuples());
3551         for i in xrange(5):
3552             self.assertAlmostEqual(arr1[4],f1.getIJ(i,0),13);
3553             self.assertAlmostEqual(arr1[3],f1.getIJ(i,1),13);
3554             self.assertAlmostEqual(arr1[2],f1.getIJ(i,2),13);
3555             self.assertAlmostEqual(arr1[1],f1.getIJ(i,3),13);
3556             self.assertAlmostEqual(arr1[0],f1.getIJ(i,4),13);
3557             pass
3558         #
3559         pass
3560
3561     def testIsEqualWithoutConsideringStr1(self):
3562         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3563         mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
3564         #
3565         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3566         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3567         mesh2.setName("rr");
3568         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
3569         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3570         da1,da2=mesh1.checkGeoEquivalWith(mesh2,2,1e-12);
3571         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12);
3572         mesh2.setName("");
3573         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3574         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3575         mesh2.getCoords().setInfoOnComponent(0,"tty");
3576         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
3577         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3578         mesh2.getCoords().setInfoOnComponent(0,"");
3579         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3580         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3581         mesh2.getCoords().setInfoOnComponent(1,"tty");
3582         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
3583         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3584         mesh2.getCoords().setInfoOnComponent(1,"");
3585         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3586         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3587         tmp=mesh2.getCoords().getIJ(0,3);
3588         mesh2.getCoords().setIJ(0,3,9999.);
3589         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
3590         self.assertTrue(not mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3591         mesh2.getCoords().setIJ(0,3,tmp);
3592         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3593         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3594         tmp2=mesh2.getNodalConnectivity().getIJ(0,4);
3595         mesh2.getNodalConnectivity().setIJ(0,4,0);
3596         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
3597         self.assertTrue(not mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3598         mesh2.getNodalConnectivity().setIJ(0,4,tmp2);
3599         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3600         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3601         #
3602         f1=mesh1.getMeasureField(True);
3603         f2=mesh2.getMeasureField(True);
3604         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
3605         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3606         f2.setName("ftest");
3607         self.assertTrue(not f1.isEqual(f2,1e-12,1e-12));
3608         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3609         f1.setName("ftest");
3610         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
3611         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3612         #
3613         f2.getArray().setInfoOnComponent(0,"eee");
3614         self.assertTrue(not f1.isEqual(f2,1e-12,1e-12));
3615         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3616         f2.getArray().setInfoOnComponent(0,"");
3617         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
3618         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3619         #
3620         f2.getArray().setIJ(1,0,0.123);
3621         self.assertTrue(not f1.isEqual(f2,1e-12,1e-12));
3622         self.assertTrue(not f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3623         f2.getArray().setIJ(1,0,0.125);
3624         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
3625         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3626         #
3627         pass
3628
3629     def testGetNodeIdsOfCell1(self):
3630         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3631         li=mesh1.getNodeIdsOfCell(1)
3632         expected1=[1, 4, 2]
3633         self.assertEqual(expected1,list(li))
3634         li=mesh1.getCoordinatesOfNode(4)
3635         self.assertEqual(2,len(li))
3636         self.assertAlmostEqual(0.2,li[0],13);
3637         self.assertAlmostEqual(0.2,li[1],13);
3638         li=mesh1.getCoords().getValuesAsTuple()
3639         self.assertEqual(9,len(li))
3640         li2=mesh1.getNodalConnectivityIndex().getValuesAsTuple()
3641         self.assertEqual(6,len(li2))
3642         pass
3643
3644     def testGetEdgeRatioField1(self):
3645         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
3646         f1=m1.getEdgeRatioField();
3647         self.assertEqual(m1.getNumberOfCells(),f1.getNumberOfTuples());
3648         self.assertEqual(5,f1.getNumberOfTuples());
3649         self.assertEqual(1,f1.getNumberOfComponents());
3650         expected1=[1.,1.4142135623730951, 1.4142135623730951,1.,1.]
3651         for i in xrange(5):
3652             self.assertAlmostEqual(expected1[i],f1.getIJ(i,0),14);
3653             pass
3654         #
3655         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
3656         f1=m1.getEdgeRatioField();
3657         self.assertEqual(m1.getNumberOfCells(),f1.getNumberOfTuples());
3658         self.assertEqual(5,f1.getNumberOfTuples());
3659         self.assertEqual(1,f1.getNumberOfComponents());
3660         expected2=[1.4142135623730951, 1.7320508075688772, 1.7320508075688772, 1.4142135623730951, 1.4142135623730951]
3661         for i in xrange(5):
3662             self.assertAlmostEqual(expected2[i],f1.getIJ(i,0),14);
3663             pass
3664         pass
3665
3666     def testFillFromAnalytic3(self):
3667         m=MEDCouplingDataForTest.build2DTargetMesh_1()
3668         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME)
3669         self.assertRaises(InterpKernelException,f1.fillFromAnalytic,1,"y+x");
3670         f1.setMesh(m)
3671         f1.setName("myField");
3672         f1.fillFromAnalytic(1,"y+x");
3673         f1.checkCoherency();
3674         self.assertEqual(f1.getName(),"myField");
3675         self.assertEqual(f1.getTypeOfField(),ON_CELLS);
3676         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
3677         self.assertEqual(1,f1.getNumberOfComponents());
3678         self.assertEqual(5,f1.getNumberOfTuples());
3679         values1=[-0.1,0.23333333333333336,0.56666666666666665,0.4,0.9]
3680         tmp=f1.getArray().getValues();
3681         self.assertEqual(len(values1),len(tmp))
3682         for i in xrange(len(values1)):
3683             self.assertTrue(abs(values1[i]-tmp[i])<1.e-12);
3684             pass
3685         #
3686         f1=MEDCouplingFieldDouble.New(ON_NODES,CONST_ON_TIME_INTERVAL)
3687         f1.setMesh(m)
3688         f1.fillFromAnalytic(1,"y+2*x");
3689         f1.setEndTime(1.2,3,4);
3690         f1.checkCoherency();
3691         self.assertEqual(f1.getTypeOfField(),ON_NODES);
3692         self.assertEqual(f1.getTimeDiscretization(),CONST_ON_TIME_INTERVAL);
3693         self.assertEqual(1,f1.getNumberOfComponents());
3694         self.assertEqual(9,f1.getNumberOfTuples());
3695         values2=[-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1]
3696         tmp=f1.getArray().getValues();
3697         self.assertEqual(len(values2),len(tmp))
3698         for i in xrange(len(values2)):
3699             self.assertTrue(abs(values2[i]-tmp[i])<1.e-12);
3700             pass
3701         f1=MEDCouplingFieldDouble.New(ON_NODES,LINEAR_TIME);
3702         f1.setMesh(m)
3703         f1.fillFromAnalytic(1,"2.*x+y");
3704         f1.setEndTime(1.2,3,4);
3705         f1.checkCoherency();
3706         self.assertEqual(f1.getTypeOfField(),ON_NODES);
3707         self.assertEqual(f1.getTimeDiscretization(),LINEAR_TIME);
3708         self.assertEqual(1,f1.getNumberOfComponents());
3709         self.assertEqual(9,f1.getNumberOfTuples());
3710         tmp=f1.getArray().getValues();
3711         values2Bis=[-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1]
3712         self.assertEqual(len(values2Bis),len(tmp))
3713         for i in xrange(len(values2Bis)):
3714             self.assertTrue(abs(values2Bis[i]-tmp[i])<1.e-12);
3715             pass
3716         tmp=f1.getEndArray().getValues();
3717         self.assertEqual(len(values2Bis),len(tmp))
3718         for i in xrange(len(values2Bis)):
3719             self.assertTrue(abs(values2Bis[i]-tmp[i])<1.e-12);
3720             pass
3721         #
3722         f1=MEDCouplingFieldDouble.New(ON_NODES,ONE_TIME);
3723         f1.setMesh(m)
3724         f1.fillFromAnalytic(2,"(x+y)*IVec+2*(x+y)*JVec");
3725         f1.checkCoherency();
3726         self.assertEqual(f1.getTypeOfField(),ON_NODES);
3727         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
3728         self.assertEqual(2,f1.getNumberOfComponents());
3729         self.assertEqual(9,f1.getNumberOfTuples());
3730         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]
3731         tmp=f1.getArray().getValues();
3732         self.assertEqual(len(values3),len(tmp))
3733         for i in xrange(len(values3)):
3734             self.assertTrue(abs(values3[i]-tmp[i])<1.e-12);
3735             pass
3736         values4=f1.accumulate();
3737         self.assertTrue(abs(3.6-values4[0])<1.e-12);
3738         self.assertTrue(abs(7.2-values4[1])<1.e-12);
3739         values4=f1.integral(True);
3740         self.assertTrue(abs(0.5-values4[0])<1.e-12);
3741         self.assertTrue(abs(1.-values4[1])<1.e-12);
3742         #
3743         f1=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
3744         f1.setMesh(m);
3745         self.assertRaises(InterpKernelException,f1.fillFromAnalytic,1,"1./(x-0.2)");
3746         pass
3747
3748     def testFieldDoubleOpEqual1(self):
3749         m=MEDCouplingDataForTest.build2DTargetMesh_1();
3750         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3751         self.assertRaises(InterpKernelException,f1.assign,0.07);
3752         f1.setMesh(m);
3753         f1.assign(0.07);
3754         f1.checkCoherency();
3755         self.assertEqual(1,f1.getNumberOfComponents());
3756         self.assertEqual(5,f1.getNumberOfTuples());
3757         for i in xrange(5):
3758             self.assertAlmostEqual(0.07,f1.getIJ(i,0),16);
3759             pass
3760         f1.assign(0.09);
3761         f1.checkCoherency();
3762         self.assertEqual(1,f1.getNumberOfComponents());
3763         self.assertEqual(5,f1.getNumberOfTuples());
3764         for i in xrange(5):
3765             self.assertAlmostEqual(0.09,f1.getIJ(i,0),16);
3766             pass
3767         #
3768         f1=MEDCouplingFieldDouble.New(ON_NODES,LINEAR_TIME);
3769         f1.setEndTime(4.5,2,3);
3770         f1.setMesh(m);
3771         f1.assign(0.08);
3772         f1.checkCoherency();
3773         self.assertEqual(1,f1.getNumberOfComponents());
3774         self.assertEqual(9,f1.getNumberOfTuples());
3775         for i in xrange(9):
3776             self.assertAlmostEqual(0.08,f1.getIJ(i,0),16);
3777             pass
3778         self.assertEqual(1,f1.getEndArray().getNumberOfComponents());
3779         self.assertEqual(9,f1.getEndArray().getNumberOfTuples());
3780         for i in xrange(9):
3781             self.assertAlmostEqual(0.08,f1.getEndArray().getIJ(i,0),16);
3782             pass
3783         pass
3784
3785     def testAreaBary3D2(self):
3786         coordsForHexa8=[-75.45749305371, 180.95495078401, 39.515472018008,
3787                         -9.755591679144, 23.394927935279, 5.108794294848,
3788                         14.337630157832, 61.705351002702, 160.42422501908,
3789                         -27.273893776752, 167.567731083961, 192.830034145464,
3790                         99.857193154796,264.499264735586,-8.287335493412,
3791                         144.939882761126,156.38626563134,-31.896173894226,
3792                         161.34096835726,182.4654895809,73.832387065572,
3793                         132.680430393685,255.37973247196,96.15235602819];
3794         volHexa8=3258520.29637466;
3795         baryHexa8=[43.925705821778, 155.31893955289, 65.874418109644]
3796
3797         coordsForPenta6=[-68.199829618726,178.938498373416,62.608505919588,
3798                          8.461744647847,76.653979804423,165.00018874933,
3799                          -27.273893776752,167.567731083961,192.830034145464,
3800                          106.586501038965,262.629609408327,13.124533008813,
3801                          155.465082847275,197.414118382622,78.408350795821,
3802                          132.680430393685,255.37973247196,96.15235602819];
3803         volPenta6=944849.868507338;
3804         baryPenta6=[39.631002313543,182.692711783428,106.98540473964]
3805
3806         coordsForPyra5=[132.680430393685,255.37973247196,96.15235602819,
3807                         -27.273893776752,167.567731083961,192.830034145464,
3808                         8.461744647847,76.653979804423,165.00018874933,
3809                         155.465082847275,197.414118382622,78.408350795821,
3810                         -68.199829618726,178.938498373416,62.608505919588];
3811         volPyra5=756943.92980254;
3812         baryPyra5=[29.204294116618,172.540129749156,118.01035951483]
3813         mesh=MEDCouplingUMesh.New("Bary3D2",3);
3814         coo=DataArrayDouble.New();
3815         tmp=coordsForHexa8+coordsForPenta6+coordsForPyra5
3816         coo.setValues(tmp,19,3);
3817         mesh.setCoords(coo);
3818         #
3819         tmpConn=[0,1,2,3,4,5,6,7]
3820         mesh.allocateCells(3);
3821         self.assertRaises(InterpKernelException,mesh.insertNextCell,NORM_HEXA8,9,tmpConn[0:8])
3822         mesh.insertNextCell(NORM_HEXA8,tmpConn[0:8])
3823         mesh.insertNextCell(NORM_PENTA6,6,[i+8 for i in tmpConn])
3824         mesh.insertNextCell(NORM_PYRA5,5,[i+14 for i in tmpConn])
3825         mesh.finishInsertingCells();
3826         mesh.checkCoherency();
3827         mesh.mergeNodes(1e-7)
3828         self.assertEqual(12,mesh.getNumberOfNodes());
3829         vols=mesh.getMeasureField(True);
3830         self.assertEqual(3,vols.getNumberOfTuples());
3831         self.assertEqual(1,vols.getNumberOfComponents());
3832         self.assertAlmostEqual(volHexa8,vols.getIJ(0,0),6);
3833         self.assertAlmostEqual(volPenta6,vols.getIJ(1,0),7);
3834         self.assertAlmostEqual(volPyra5,vols.getIJ(2,0),7);
3835         bary=mesh.getBarycenterAndOwner();
3836         self.assertEqual(3,bary.getNumberOfTuples());
3837         self.assertEqual(3,bary.getNumberOfComponents());
3838         self.assertAlmostEqual(baryHexa8[0],bary.getIJ(0,0),11);
3839         self.assertAlmostEqual(baryHexa8[1],bary.getIJ(0,1),11);
3840         self.assertAlmostEqual(baryHexa8[2],bary.getIJ(0,2),11);
3841         self.assertAlmostEqual(baryPenta6[0],bary.getIJ(1,0),11);
3842         self.assertAlmostEqual(baryPenta6[1],bary.getIJ(1,1),11);
3843         self.assertAlmostEqual(baryPenta6[2],bary.getIJ(1,2),11);
3844         self.assertAlmostEqual(baryPyra5[0],bary.getIJ(2,0),11);
3845         self.assertAlmostEqual(baryPyra5[1],bary.getIJ(2,1),11);
3846         self.assertAlmostEqual(baryPyra5[2],bary.getIJ(2,2),11);
3847         pass
3848
3849     def testGetMeasureFieldCMesh1(self):
3850         m=MEDCouplingCMesh.New();
3851         da=DataArrayDouble.New();
3852         discX=[2.3,3.4,5.8,10.2]
3853         discY=[12.3,23.4,45.8]
3854         discZ=[-0.7,1.2,1.25,2.13,2.67]
3855         da.setValues(discX,4,1);
3856         m.setCoordsAt(0,da);
3857         m.checkCoherency();
3858         self.assertEqual(4,m.getNumberOfNodes());
3859         self.assertEqual(3,m.getNumberOfCells());
3860         self.assertEqual(1,m.getSpaceDimension());
3861         f=m.getMeasureField(True);
3862         self.assertEqual(3,f.getNumberOfTuples());
3863         self.assertEqual(1,f.getNumberOfComponents());
3864         expected1=[1.1,2.4,4.4]
3865         for i in xrange(3):
3866             self.assertAlmostEqual(expected1[i],f.getIJ(i,0),12);
3867             pass
3868         coords=m.getCoordinatesAndOwner();
3869         self.assertEqual(4,coords.getNumberOfTuples());
3870         self.assertEqual(1,coords.getNumberOfComponents());
3871         for i in xrange(4):
3872             self.assertAlmostEqual(discX[i],coords.getIJ(i,0),12);
3873             pass
3874         coords=m.getBarycenterAndOwner();
3875         self.assertEqual(3,coords.getNumberOfTuples());
3876         self.assertEqual(1,coords.getNumberOfComponents());
3877         expected1_3=[2.85,4.6,8.]
3878         for i in xrange(3):
3879             self.assertAlmostEqual(expected1_3[i],coords.getIJ(i,0),12);
3880             pass
3881         #
3882         da=DataArrayDouble.New();
3883         da.setValues(discY,3,1);
3884         m.setCoordsAt(1,da);
3885         m.checkCoherency();
3886         self.assertEqual(12,m.getNumberOfNodes());
3887         self.assertEqual(6,m.getNumberOfCells());
3888         self.assertEqual(2,m.getSpaceDimension());
3889         f=m.getMeasureField(True);
3890         self.assertEqual(6,f.getNumberOfTuples());
3891         self.assertEqual(1,f.getNumberOfComponents());
3892         expected2=[12.21,26.64,48.84,24.64,53.76,98.56]
3893         for i in xrange(6):
3894             self.assertAlmostEqual(expected2[i],f.getIJ(i,0),12);
3895             pass
3896         coords=m.getCoordinatesAndOwner();
3897         self.assertEqual(12,coords.getNumberOfTuples());
3898         self.assertEqual(2,coords.getNumberOfComponents());
3899         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]
3900         for i in xrange(24):
3901             self.assertAlmostEqual(expected2_2[i],coords.getIJ(0,i),12);
3902             pass
3903         coords=m.getBarycenterAndOwner();
3904         self.assertEqual(6,coords.getNumberOfTuples());
3905         self.assertEqual(2,coords.getNumberOfComponents());
3906         expected2_3=[2.85,17.85,4.6,17.85,8.,17.85, 2.85,34.6,4.6,34.6,8.,34.6]
3907         for i in xrange(12):
3908             self.assertAlmostEqual(expected2_3[i],coords.getIJ(0,i),12);
3909             pass
3910         #
3911         da=DataArrayDouble.New();
3912         da.setValues(discZ,5,1);
3913         m.setCoordsAt(2,da);
3914         m.checkCoherency();
3915         self.assertEqual(60,m.getNumberOfNodes());
3916         self.assertEqual(24,m.getNumberOfCells());
3917         self.assertEqual(3,m.getSpaceDimension());
3918         f=m.getMeasureField(True);
3919         self.assertEqual(24,f.getNumberOfTuples());
3920         self.assertEqual(1,f.getNumberOfComponents());
3921         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]
3922         for i in xrange(24):
3923             self.assertAlmostEqual(expected3[i],f.getIJ(i,0),12);
3924             pass
3925         coords=m.getCoordinatesAndOwner();
3926         self.assertEqual(60,coords.getNumberOfTuples());
3927         self.assertEqual(3,coords.getNumberOfComponents());
3928         expected3_2=[
3929             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,
3930             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,
3931             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,
3932             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,
3933             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];
3934         for i in xrange(180):
3935             self.assertAlmostEqual(expected3_2[i],coords.getIJ(0,i),12);
3936             pass
3937         coords=m.getBarycenterAndOwner();
3938         self.assertEqual(24,coords.getNumberOfTuples());
3939         self.assertEqual(3,coords.getNumberOfComponents());
3940         expected3_3=[
3941             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,
3942             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,
3943             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,
3944             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];
3945         for i in xrange(72):
3946             self.assertAlmostEqual(expected3_3[i],coords.getIJ(0,i),12);
3947             pass
3948         pass
3949
3950     def testFieldDoubleZipCoords1(self):
3951         m=MEDCouplingDataForTest.build2DTargetMeshMergeNode_1();
3952         f=m.fillFromAnalytic(ON_NODES,2,"x*2.");
3953         f.getArray().setInfoOnComponent(0,"titi");
3954         f.getArray().setInfoOnComponent(1,"tutu");
3955         f.checkCoherency();
3956         self.assertEqual(18,f.getNumberOfTuples());
3957         self.assertEqual(2,f.getNumberOfComponents());
3958         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]
3959         for i in xrange(36):
3960             self.assertAlmostEqual(expected1[i],f.getIJ(0,i),12);
3961             pass
3962         self.assertTrue(f.zipCoords());
3963         f.checkCoherency();
3964         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]
3965         for i in xrange(30):
3966             self.assertAlmostEqual(expected2[i],f.getIJ(0,i),12);
3967             pass
3968         self.assertTrue(not f.zipCoords());
3969         f.checkCoherency();
3970         for i in xrange(30):
3971             self.assertAlmostEqual(expected2[i],f.getIJ(0,i),12);
3972             pass
3973         self.assertTrue(f.getArray().getInfoOnComponent(0)=="titi");
3974         self.assertTrue(f.getArray().getInfoOnComponent(1)=="tutu");
3975         pass
3976
3977     def testFieldDoubleZipConnectivity1(self):
3978         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
3979         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
3980         cells1=[2,3,4]
3981         m3_1=m2.buildPartOfMySelf(cells1,True);
3982         m3=m3_1;
3983         m4=MEDCouplingDataForTest.build2DSourceMesh_1();
3984         m5=MEDCouplingUMesh.MergeUMeshes(m1,m3);
3985         m6=MEDCouplingUMesh.MergeUMeshes(m5,m4);
3986         #
3987         self.assertEqual(10,m6.getNumberOfCells());
3988         self.assertEqual(22,m6.getNumberOfNodes());
3989         arr,areNodesMerged,newNbOfNodes=m6.mergeNodes(1e-13);
3990         self.assertEqual(9,m6.getNumberOfNodes());
3991         f=m6.fillFromAnalytic(ON_CELLS,2,"x");
3992         f2=m6.fillFromAnalytic(ON_NODES,2,"x");
3993         self.assertEqual(10,f.getNumberOfTuples());
3994         self.assertEqual(2,f.getNumberOfComponents());
3995         expected1=[-0.05, -0.05, 0.3666666666666667, 0.3666666666666667, 0.53333333333333321, 0.53333333333333321,
3996                    -0.05, -0.05, 0.45, 0.45, 0.53333333333333321, 0.53333333333333321, -0.05, -0.05, 0.45, 0.45,
3997                    0.36666666666666659, 0.36666666666666659, 0.033333333333333326, 0.033333333333333326];
3998         for i in xrange(20):
3999             self.assertAlmostEqual(expected1[i],f.getIJ(0,i),12);
4000             pass
4001         f.getArray().setInfoOnComponent(0,"titi");
4002         f.getArray().setInfoOnComponent(1,"tutu");
4003         f.checkCoherency();
4004         self.assertTrue(f.zipConnectivity(0));
4005         expected2=[-0.05, -0.05, 0.3666666666666667, 0.3666666666666667, 0.53333333333333321, 0.53333333333333321,
4006                    -0.05, -0.05, 0.45, 0.45, 0.36666666666666659, 0.36666666666666659, 0.033333333333333326, 0.033333333333333326];
4007         self.assertEqual(7,f.getNumberOfTuples());
4008         self.assertEqual(2,f.getNumberOfComponents());
4009         for i in xrange(14):
4010             self.assertAlmostEqual(expected2[i],f.getIJ(0,i),12);
4011             pass
4012         self.assertTrue(f.getArray().getInfoOnComponent(0)=="titi");
4013         self.assertTrue(f.getArray().getInfoOnComponent(1)=="tutu");
4014         self.assertTrue(not f.zipConnectivity(0));
4015         #
4016         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,
4017                    -0.3, -0.3, 0.2, 0.2, 0.7, 0.7];
4018         self.assertEqual(9,f2.getNumberOfTuples());
4019         self.assertEqual(2,f2.getNumberOfComponents());
4020         for i in xrange(18):
4021             self.assertAlmostEqual(expected3[i],f2.getIJ(0,i),12);
4022             pass
4023         self.assertTrue(f2.zipConnectivity(0));
4024         self.assertEqual(9,f2.getNumberOfTuples());
4025         self.assertEqual(2,f2.getNumberOfComponents());
4026         for i in xrange(18):
4027             self.assertAlmostEqual(expected3[i],f2.getIJ(0,i),12);
4028             pass
4029         pass
4030
4031     def testDaDoubleRenumber1(self):
4032         a=DataArrayDouble.New();
4033         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]
4034         a.setValues(arr1,7,2);
4035         a.setInfoOnComponent(0,"toto");
4036         a.setInfoOnComponent(1,"tata");
4037         #
4038         arr2=[3,1,0,6,5,4,2]
4039         b=a.renumber(arr2);
4040         self.assertEqual(7,b.getNumberOfTuples());
4041         self.assertEqual(2,b.getNumberOfComponents());
4042         self.assertTrue(b.getInfoOnComponent(0)=="toto");
4043         self.assertTrue(b.getInfoOnComponent(1)=="tata");
4044         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]
4045         for i in xrange(14):
4046             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
4047             pass
4048         #
4049         c=DataArrayInt.New();
4050         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4051         c.setValues(arr3,7,2);
4052         c.setInfoOnComponent(0,"toto");
4053         c.setInfoOnComponent(1,"tata");
4054         d=c.renumber(arr2);
4055         self.assertEqual(7,d.getNumberOfTuples());
4056         self.assertEqual(2,d.getNumberOfComponents());
4057         self.assertTrue(d.getInfoOnComponent(0)=="toto");
4058         self.assertTrue(d.getInfoOnComponent(1)=="tata");
4059         expected2=[3, 13, 2, 12, 7, 17, 1, 11, 6, 16, 5, 15, 4, 14]
4060         for i in xrange(14):
4061             self.assertEqual(expected2[i],d.getIJ(0,i));
4062             pass
4063         pass
4064
4065     def testDaDoubleRenumberAndReduce1(self):
4066         a=DataArrayDouble.New();
4067         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]
4068         a.setValues(arr1,7,2);
4069         a.setInfoOnComponent(0,"toto");
4070         a.setInfoOnComponent(1,"tata");
4071         #
4072         arr2=[2,-1,1,-1,0,4,3]
4073         b=a.renumberAndReduce(arr2,5);
4074         self.assertEqual(5,b.getNumberOfTuples());
4075         self.assertEqual(2,b.getNumberOfComponents());
4076         self.assertTrue(b.getInfoOnComponent(0)=="toto");
4077         self.assertTrue(b.getInfoOnComponent(1)=="tata");
4078         expected1=[5.1,15.1,3.1,13.1,1.1,11.1,7.1,17.1,6.1,16.1]
4079         for i in xrange(10):
4080             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
4081             pass
4082         #
4083         c=DataArrayInt.New();
4084         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4085         c.setValues(arr3,7,2);
4086         c.setInfoOnComponent(0,"toto");
4087         c.setInfoOnComponent(1,"tata");
4088         d=c.renumberAndReduce(arr2,5);
4089         self.assertEqual(5,d.getNumberOfTuples());
4090         self.assertEqual(2,d.getNumberOfComponents());
4091         self.assertTrue(d.getInfoOnComponent(0)=="toto");
4092         self.assertTrue(d.getInfoOnComponent(1)=="tata");
4093         expected2=[5,15,3,13,1,11,7,17,6,16]
4094         for i in xrange(10):
4095             self.assertEqual(expected2[i],d.getIJ(0,i));
4096             pass
4097         pass
4098
4099     def testDaDoubleRenumberInPlace1(self):
4100         a=DataArrayDouble.New();
4101         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]
4102         a.setValues(arr1,7,2);
4103         #
4104         arr2=[3,1,0,6,5,4,2]
4105         a.renumberInPlace(arr2);
4106         self.assertEqual(7,a.getNumberOfTuples());
4107         self.assertEqual(2,a.getNumberOfComponents());
4108         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]
4109         for i in xrange(14):
4110             self.assertAlmostEqual(expected1[i],a.getIJ(0,i),14);
4111             pass
4112         #
4113         c=DataArrayInt.New();
4114         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4115         c.setValues(arr3,7,2);
4116         c.renumberInPlace(arr2);
4117         self.assertEqual(7,c.getNumberOfTuples());
4118         self.assertEqual(2,c.getNumberOfComponents());
4119         expected2=[3, 13, 2, 12, 7, 17, 1, 11, 6, 16, 5, 15, 4, 14]
4120         for i in xrange(14):
4121             self.assertEqual(expected2[i],c.getIJ(0,i));
4122             pass
4123         pass
4124
4125     def testDaDoubleRenumberR1(self):
4126         a=DataArrayDouble.New();
4127         arr1=[1.1,11.1,2.1,12.1,3.1,13.1,4.1,14.1,5.1,15.1,6.1,16.1,7.1,17.1]
4128         a.setValues(arr1,7,2);
4129         a.setInfoOnComponent(0,"toto");
4130         a.setInfoOnComponent(1,"tata");
4131         #
4132         arr2=[3,1,0,6,5,4,2]
4133         b=a.renumberR(arr2);
4134         self.assertEqual(7,b.getNumberOfTuples());
4135         self.assertEqual(2,b.getNumberOfComponents());
4136         self.assertTrue(b.getInfoOnComponent(0)=="toto");
4137         self.assertTrue(b.getInfoOnComponent(1)=="tata");
4138         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]
4139         for i in xrange(14):
4140             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
4141             pass
4142         #
4143         c=DataArrayInt.New();
4144         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4145         c.setValues(arr3,7,2);
4146         c.setInfoOnComponent(0,"toto");
4147         c.setInfoOnComponent(1,"tata");
4148         d=c.renumberR(arr2);
4149         self.assertEqual(7,d.getNumberOfTuples());
4150         self.assertEqual(2,d.getNumberOfComponents());
4151         self.assertTrue(d.getInfoOnComponent(0)=="toto");
4152         self.assertTrue(d.getInfoOnComponent(1)=="tata");
4153         expected2=[4, 14, 2, 12, 1, 11, 7, 17, 6, 16, 5, 15, 3, 13]
4154         for i in xrange(14):
4155             self.assertEqual(expected2[i],d.getIJ(0,i));
4156             pass
4157         pass
4158
4159     def testDaDoubleRenumberInPlaceR1(self):
4160         a=DataArrayDouble.New();
4161         arr1=[1.1,11.1,2.1,12.1,3.1,13.1,4.1,14.1,5.1,15.1,6.1,16.1,7.1,17.1]
4162         a.setValues(arr1,7,2);
4163         #
4164         arr2=[3,1,0,6,5,4,2]
4165         a.renumberInPlaceR(arr2);
4166         self.assertEqual(7,a.getNumberOfTuples());
4167         self.assertEqual(2,a.getNumberOfComponents());
4168         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]
4169         for i in xrange(14):
4170             self.assertAlmostEqual(expected1[i],a.getIJ(0,i),14);
4171             pass
4172         #
4173         c=DataArrayInt.New();
4174         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4175         c.setValues(arr3,7,2);
4176         c.renumberInPlaceR(arr2);
4177         self.assertEqual(7,c.getNumberOfTuples());
4178         self.assertEqual(2,c.getNumberOfComponents());
4179         expected2=[4, 14, 2, 12, 1, 11, 7, 17, 6, 16, 5, 15, 3, 13]
4180         for i in xrange(14):
4181             self.assertEqual(expected2[i],c.getIJ(0,i));
4182             pass
4183         pass
4184
4185     def testDaDoubleSelectByTupleId1(self):
4186         a=DataArrayDouble.New();
4187         arr1=[1.1,11.1,2.1,12.1,3.1,13.1,4.1,14.1,5.1,15.1,6.1,16.1,7.1,17.1]
4188         a.setValues(arr1,7,2);
4189         a.setInfoOnComponent(0,"toto");
4190         a.setInfoOnComponent(1,"tata");
4191         #
4192         arr2=[4,2,0,6,5]
4193         b=a.selectByTupleId(arr2);
4194         self.assertEqual(5,b.getNumberOfTuples());
4195         self.assertEqual(2,b.getNumberOfComponents());
4196         self.assertTrue(b.getInfoOnComponent(0)=="toto");
4197         self.assertTrue(b.getInfoOnComponent(1)=="tata");
4198         expected1=[5.1,15.1,3.1,13.1,1.1,11.1,7.1,17.1,6.1,16.1]
4199         for i in xrange(10):
4200             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
4201             pass
4202         #
4203         c=DataArrayInt.New();
4204         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4205         c.setValues(arr3,7,2);
4206         c.setInfoOnComponent(0,"toto");
4207         c.setInfoOnComponent(1,"tata");
4208         d=c.selectByTupleId(arr2);
4209         self.assertEqual(5,d.getNumberOfTuples());
4210         self.assertEqual(2,d.getNumberOfComponents());
4211         self.assertTrue(d.getInfoOnComponent(0)=="toto");
4212         self.assertTrue(d.getInfoOnComponent(1)=="tata");
4213         expected2=[5,15,3,13,1,11,7,17,6,16]
4214         for i in xrange(10):
4215             self.assertEqual(expected2[i],d.getIJ(0,i));
4216             pass
4217         pass
4218
4219     def testDaDoubleGetMinMaxValues1(self):
4220         a=DataArrayDouble.New();
4221         arr1=[2.34,4.56,-6.77,4.55,4.56,2.24,2.34,1.02,4.56]
4222         a.setValues(arr1,9,1);
4223         m,where=a.getMaxValue();
4224         self.assertEqual(1,where);
4225         self.assertAlmostEqual(4.56,m,12);
4226         m,ws=a.getMaxValue2();
4227         self.assertAlmostEqual(4.56,m,12);
4228         self.assertEqual(3,ws.getNumberOfTuples());
4229         self.assertEqual(1,ws.getNumberOfComponents());
4230         expected1=[1,4,8]
4231         for i in xrange(3):
4232             self.assertEqual(expected1[i],ws.getIJ(i,0));
4233             pass
4234         a=DataArrayDouble.New();
4235         arr2=[-2.34,-4.56,6.77,-4.55,-4.56,-2.24,-2.34,-1.02,-4.56]
4236         a.setValues(arr2,9,1);
4237         m,where=a.getMinValue();
4238         self.assertEqual(1,where);
4239         self.assertAlmostEqual(-4.56,m,12);
4240         m,ws=a.getMinValue2();
4241         self.assertAlmostEqual(-4.56,m,12);
4242         self.assertEqual(3,ws.getNumberOfTuples());
4243         self.assertEqual(1,ws.getNumberOfComponents());
4244         for i in xrange(3):
4245             self.assertEqual(expected1[i],ws.getIJ(i,0));
4246             pass
4247         pass
4248
4249     def testFieldDoubleGetMinMaxValues2(self):
4250         m2,m1=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
4251         self.assertEqual(18,m2.getNumberOfCells());
4252         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]
4253         f=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
4254         a=DataArrayDouble.New();
4255         a.setValues(arr1,18,1);
4256         f.setArray(a);
4257         f.setMesh(m2);
4258         #
4259         f.checkCoherency();
4260         m=f.getMaxValue();
4261         self.assertAlmostEqual(8.71,m,12);
4262         m,ws=f.getMaxValue2();
4263         self.assertAlmostEqual(8.71,m,12);
4264         self.assertEqual(4,ws.getNumberOfTuples());
4265         self.assertEqual(1,ws.getNumberOfComponents());
4266         expected1=[0,3,7,17]
4267         for i in xrange(4):
4268             self.assertEqual(expected1[i],ws.getIJ(i,0));
4269             pass
4270         #
4271         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]
4272         a.setValues(arr2,18,1);
4273         f.checkCoherency();
4274         m=f.getMinValue();
4275         self.assertAlmostEqual(-8.71,m,12);
4276         m,ws=f.getMinValue2();
4277         self.assertAlmostEqual(-8.71,m,12);
4278         self.assertEqual(4,ws.getNumberOfTuples());
4279         self.assertEqual(1,ws.getNumberOfComponents());
4280         for i in xrange(4):
4281             self.assertEqual(expected1[i],ws.getIJ(i,0));
4282             pass
4283         pass
4284
4285     def testBuildUnstructuredCMesh1(self):
4286         m=MEDCouplingCMesh.New();
4287         da=DataArrayDouble.New();
4288         discX=[2.3,3.4,5.8,10.2]
4289         discY=[12.3,23.4,45.8]
4290         discZ=[-0.7,1.2,1.25,2.13,2.67]
4291         da.setValues(discX,4,1);
4292         m.setCoordsAt(0,da);
4293         m.checkCoherency();
4294         self.assertEqual(0,m.getCellContainingPoint([2.4],1e-12));
4295         self.assertEqual(1,m.getCellContainingPoint([3.7],1e-12));
4296         self.assertEqual(2,m.getCellContainingPoint([5.9],1e-12));
4297         self.assertEqual(-1,m.getCellContainingPoint([10.3],1e-12));
4298         self.assertEqual(-1,m.getCellContainingPoint([1.3],1e-12));
4299         #
4300         m2=m.buildUnstructured();
4301         m2.checkCoherency();
4302         f1=m.getMeasureField(False);
4303         f2=m2.getMeasureField(False);
4304         self.assertTrue(isinstance(f1.getMesh(),MEDCouplingCMesh))
4305         self.assertEqual(f1.getNumberOfTuples(),3);
4306         self.assertEqual(f2.getNumberOfTuples(),3);
4307         self.assertEqual(1,m2.getMeshDimension());
4308         self.assertEqual(1,m2.getSpaceDimension());
4309         for i in xrange(3):
4310             self.assertAlmostEqual(f1.getIJ(i,0),f2.getIJ(i,0),10);
4311             pass
4312         da=DataArrayDouble.New();
4313         da.setValues(discY,3,1);
4314         m.setCoordsAt(1,da);
4315         #
4316         m2=m.buildUnstructured();
4317         m2.checkCoherency();
4318         f1=m.getMeasureField(False);
4319         f2=m2.getMeasureField(False);
4320         self.assertEqual(f1.getNumberOfTuples(),6);
4321         self.assertEqual(f2.getNumberOfTuples(),6);
4322         self.assertEqual(2,m2.getMeshDimension());
4323         self.assertEqual(2,m2.getSpaceDimension());
4324         for i in xrange(6):
4325             self.assertAlmostEqual(f1.getIJ(i,0),f2.getIJ(i,0),10);
4326             pass
4327         #
4328         da=DataArrayDouble.New();
4329         da.setValues(discZ,5,1);
4330         m.setCoordsAt(2,da);
4331         m2=m.buildUnstructured();
4332         m2.checkCoherency();
4333         f1=m.getMeasureField(False);
4334         f2=m2.getMeasureField(False);
4335         self.assertEqual(f1.getNumberOfTuples(),24);
4336         self.assertEqual(f2.getNumberOfTuples(),24);
4337         self.assertEqual(3,m2.getMeshDimension());
4338         self.assertEqual(3,m2.getSpaceDimension());
4339         for i in xrange(24):
4340             self.assertAlmostEqual(f1.getIJ(i,0),f2.getIJ(i,0),10);
4341             pass
4342         #
4343         pos1=[5.,30.,2.]
4344         self.assertEqual(16,m.getCellContainingPoint(pos1,1e-12));
4345         #
4346         elems=m2.getCellsInBoundingBox([3.5,6.,12.2,25.,0.,1.5],1e-7)
4347         self.assertEqual([1, 2, 4, 5, 7, 8, 10, 11, 13, 14, 16, 17],elems.getValues())
4348         #
4349         pt=[2.4,12.7,-3.4]
4350         m.scale(pt,3.7);
4351         m3=m.buildUnstructured();
4352         m2.scale(pt,3.7);
4353         self.assertTrue(m3.isEqual(m2,1e-12));
4354         pass
4355
4356     def testDataArrayIntInvertO2NNO21(self):
4357         arr1=[2,0,4,1,5,3]
4358         da=DataArrayInt.New();
4359         da.setValues(arr1,6,1);
4360         da2=da.invertArrayO2N2N2O(6);
4361         self.assertEqual(6,da2.getNumberOfTuples());
4362         self.assertEqual(1,da2.getNumberOfComponents());
4363         expected1=[1,3,0,5,2,4]
4364         for i in xrange(6):
4365             self.assertEqual(expected1[i],da2.getIJ(i,0));
4366             pass
4367         da3=da2.invertArrayN2O2O2N(6);
4368         for i in xrange(6):
4369             self.assertEqual(arr1[i],da3.getIJ(i,0));
4370             pass
4371         #
4372         arr2=[3,-1,5,4,-1,0,-1,1,2,-1]
4373         da=DataArrayInt.New();
4374         da.setValues(arr2,10,1);
4375         da2=da.invertArrayO2N2N2O(6);
4376         self.assertEqual(6,da2.getNumberOfTuples());
4377         self.assertEqual(1,da2.getNumberOfComponents());
4378         expected2=[5,7,8,0,3,2]
4379         for i in xrange(6):
4380             self.assertEqual(expected2[i],da2.getIJ(i,0));
4381             pass
4382         da3=da2.invertArrayN2O2O2N(10);
4383         for i in xrange(10):
4384             self.assertEqual(arr2[i],da3.getIJ(i,0));
4385             pass
4386         pass
4387
4388     def testKeepSetSelectedComponent1(self):
4389         arr1=[1.,2.,3.,4., 11.,12.,13.,14., 21.,22.,23.,24., 31.,32.,33.,34., 41.,42.,43.,44.]
4390         a1=DataArrayDouble.New();
4391         a1.setValues(arr1,5,4);
4392         expp=[21.,22.,23.,24.]
4393         self.assertEqual(4,len(a1.getTuple(2)));
4394         for i in xrange(4):
4395             self.assertAlmostEqual(expp[i],a1.getTuple(2)[i],12)
4396             pass
4397         a1.setInfoOnComponent(0,"aaaa");
4398         a1.setInfoOnComponent(1,"bbbb");
4399         a1.setInfoOnComponent(2,"cccc");
4400         a1.setInfoOnComponent(3,"dddd");
4401         arr2V=[1,2,1,2,0,0]
4402         a2=a1.keepSelectedComponents(arr2V);
4403         self.assertEqual(6,a2.getNumberOfComponents());
4404         self.assertEqual(5,a2.getNumberOfTuples());
4405         self.assertTrue(a2.getInfoOnComponent(0)=="bbbb");
4406         self.assertTrue(a2.getInfoOnComponent(1)=="cccc");
4407         self.assertTrue(a2.getInfoOnComponent(2)=="bbbb");
4408         self.assertTrue(a2.getInfoOnComponent(3)=="cccc");
4409         self.assertTrue(a2.getInfoOnComponent(4)=="aaaa");
4410         self.assertTrue(a2.getInfoOnComponent(5)=="aaaa");
4411         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.]
4412         for i in xrange(30):
4413             self.assertAlmostEqual(expected1[i],a2.getIJ(0,i),14);
4414             pass
4415         a3=a1.convertToIntArr();
4416         self.assertEqual([21,22,23,24],a3.getTuple(2))
4417         a4=a3.keepSelectedComponents(arr2V);
4418         self.assertEqual(6,a4.getNumberOfComponents());
4419         self.assertEqual(5,a4.getNumberOfTuples());
4420         self.assertTrue(a4.getInfoOnComponent(0)=="bbbb");
4421         self.assertTrue(a4.getInfoOnComponent(1)=="cccc");
4422         self.assertTrue(a4.getInfoOnComponent(2)=="bbbb");
4423         self.assertTrue(a4.getInfoOnComponent(3)=="cccc");
4424         self.assertTrue(a4.getInfoOnComponent(4)=="aaaa");
4425         self.assertTrue(a4.getInfoOnComponent(5)=="aaaa");
4426         for i in xrange(30):
4427             self.assertEqual(int(expected1[i]),a4.getIJ(0,i));
4428             pass
4429         # setSelectedComponents
4430         arr3V=[3,2]
4431         a5=a1.keepSelectedComponents(arr3V);
4432         a5.setInfoOnComponent(0,"eeee");
4433         a5.setInfoOnComponent(1,"ffff");
4434         arr4V=[1,2]
4435         a2.setSelectedComponents(a5,arr4V);
4436         self.assertEqual(6,a2.getNumberOfComponents());
4437         self.assertEqual(5,a2.getNumberOfTuples());
4438         self.assertTrue(a2.getInfoOnComponent(0)=="bbbb");
4439         self.assertTrue(a2.getInfoOnComponent(1)=="eeee");
4440         self.assertTrue(a2.getInfoOnComponent(2)=="ffff");
4441         self.assertTrue(a2.getInfoOnComponent(3)=="cccc");
4442         self.assertTrue(a2.getInfoOnComponent(4)=="aaaa");
4443         self.assertTrue(a2.getInfoOnComponent(5)=="aaaa");
4444         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.]
4445         for i in xrange(30):
4446             self.assertAlmostEqual(expected2[i],a2.getIJ(0,i),14);
4447             pass
4448         a6=a5.convertToIntArr();
4449         a6.setInfoOnComponent(0,"eeee");
4450         a6.setInfoOnComponent(1,"ffff");
4451         a4.setSelectedComponents(a6,arr4V);
4452         self.assertEqual(6,a4.getNumberOfComponents());
4453         self.assertEqual(5,a4.getNumberOfTuples());
4454         self.assertTrue(a4.getInfoOnComponent(0)=="bbbb");
4455         self.assertTrue(a4.getInfoOnComponent(1)=="eeee");
4456         self.assertTrue(a4.getInfoOnComponent(2)=="ffff");
4457         self.assertTrue(a4.getInfoOnComponent(3)=="cccc");
4458         self.assertTrue(a4.getInfoOnComponent(4)=="aaaa");
4459         self.assertTrue(a4.getInfoOnComponent(5)=="aaaa");
4460         for i in xrange(30):
4461             self.assertEqual(int(expected2[i]),a4.getIJ(0,i));
4462             pass
4463         # test of throw
4464         arr5V=[2,3,6]
4465         arr6V=[2,7,5]
4466         arr7V=[2,1,4,6]
4467         self.assertRaises(InterpKernelException,a2.keepSelectedComponents,arr5V);
4468         self.assertRaises(InterpKernelException,a2.keepSelectedComponents,arr6V);
4469         self.assertRaises(InterpKernelException,a2.setSelectedComponents,a1,arr7V);
4470         arr7V=arr7V[0:3]
4471         self.assertRaises(InterpKernelException,a2.setSelectedComponents,a1,arr7V);
4472         #
4473         pass
4474
4475     def testKeepSetSelectedComponent2(self):
4476         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
4477         arr1=[1.,2.,3.,4., 11.,12.,13.,14., 21.,22.,23.,24., 31.,32.,33.,34., 41.,42.,43.,44.]
4478         a1=DataArrayDouble.New();
4479         a1.setValues(arr1,5,4);
4480         a1.setInfoOnComponent(0,"aaaa");
4481         a1.setInfoOnComponent(1,"bbbb");
4482         a1.setInfoOnComponent(2,"cccc");
4483         a1.setInfoOnComponent(3,"dddd");
4484         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
4485         f1.setTime(2.3,4,5);
4486         f1.setMesh(m1);
4487         f1.setName("f1");
4488         f1.setArray(a1);
4489         f1.checkCoherency();
4490         #
4491         arr2V=[1,2,1,2,0,0]
4492         f2=f1.keepSelectedComponents(arr2V);
4493         self.assertTrue(f2.getTimeDiscretization()==ONE_TIME);
4494         t,dt,it=f2.getTime()
4495         self.assertAlmostEqual(2.3,t,13);
4496         self.assertEqual(4,dt);
4497         self.assertEqual(5,it);
4498         f2.checkCoherency();
4499         self.assertEqual(6,f2.getNumberOfComponents());
4500         self.assertEqual(5,f2.getNumberOfTuples());
4501         self.assertTrue(f2.getArray().getInfoOnComponent(0)=="bbbb");
4502         self.assertTrue(f2.getArray().getInfoOnComponent(1)=="cccc");
4503         self.assertTrue(f2.getArray().getInfoOnComponent(2)=="bbbb");
4504         self.assertTrue(f2.getArray().getInfoOnComponent(3)=="cccc");
4505         self.assertTrue(f2.getArray().getInfoOnComponent(4)=="aaaa");
4506         self.assertTrue(f2.getArray().getInfoOnComponent(5)=="aaaa");
4507         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.]
4508         for i in xrange(30):
4509             self.assertAlmostEqual(expected1[i],f2.getIJ(0,i),14);
4510             pass
4511         #setSelectedComponents
4512         arr3V=[3,2]
4513         f5=f1.keepSelectedComponents(arr3V);
4514         f5.setTime(6.7,8,9);
4515         f5.getArray().setInfoOnComponent(0,"eeee");
4516         f5.getArray().setInfoOnComponent(1,"ffff");
4517         f5.checkCoherency();
4518         arr4V=[1,2]
4519         f2.setSelectedComponents(f5,arr4V);
4520         self.assertEqual(6,f2.getNumberOfComponents());
4521         self.assertEqual(5,f2.getNumberOfTuples());
4522         f2.checkCoherency();
4523         t,dt,it=f2.getTime()
4524         self.assertAlmostEqual(2.3,t,13);
4525         self.assertEqual(4,dt);
4526         self.assertEqual(5,it);
4527         self.assertTrue(f2.getArray().getInfoOnComponent(0)=="bbbb");
4528         self.assertTrue(f2.getArray().getInfoOnComponent(1)=="eeee");
4529         self.assertTrue(f2.getArray().getInfoOnComponent(2)=="ffff");
4530         self.assertTrue(f2.getArray().getInfoOnComponent(3)=="cccc");
4531         self.assertTrue(f2.getArray().getInfoOnComponent(4)=="aaaa");
4532         self.assertTrue(f2.getArray().getInfoOnComponent(5)=="aaaa");
4533         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.]
4534         for i in xrange(30):
4535             self.assertAlmostEqual(expected2[i],f2.getIJ(0,i),14);
4536             pass
4537         #
4538         pass
4539
4540     def testElementaryDAThrowAndSpecialCases(self):
4541         da=DataArrayInt.New();
4542         self.assertRaises(InterpKernelException, da.checkAllocated);
4543         self.assertRaises(InterpKernelException, da.fillWithValue, 1);
4544         self.assertRaises(InterpKernelException, da.iota, 1);
4545         da.alloc(7,1);
4546         da.fillWithValue(11); #11,11,11,11...
4547         da.iota(10); #10,11,12,13...
4548
4549         db=DataArrayInt.New();
4550         db.alloc(7,2);
4551
4552         dbl2=DataArrayDouble.New();
4553         dbl2.alloc(7,2);
4554         self.assertRaises(InterpKernelException, dbl2.isUniform, 10., 1e-15);
4555         self.assertRaises(InterpKernelException, dbl2.sort);
4556         self.assertRaises(InterpKernelException, dbl2.reverse);
4557         self.assertRaises(InterpKernelException, dbl2.iota, 10.);
4558
4559         dbl=DataArrayDouble.New();
4560         #DataArrayDouble not allocated yet
4561         self.assertRaises(InterpKernelException, dbl.iota, 10.);
4562         self.assertRaises(InterpKernelException, dbl.isUniform, 10., 1e-15);
4563         self.assertRaises(InterpKernelException, dbl.sort);
4564         self.assertRaises(InterpKernelException, dbl.reverse);
4565         self.assertRaises(InterpKernelException, dbl.fromNoInterlace);
4566         self.assertRaises(InterpKernelException, dbl.toNoInterlace);
4567
4568         dbl.alloc(7,1);
4569         dbl.iota(10.);
4570         self.assertTrue(not dbl.isUniform(10.,1e-15));
4571         dbl.sort();
4572         self.assertTrue(dbl.isMonotonic(True, .99));
4573         self.assertTrue(dbl.isMonotonic(True, -.99));
4574         self.assertTrue(not dbl.isMonotonic(True, 1.1));
4575         self.assertTrue(not dbl.isMonotonic(True, -1.1));
4576         dbl.reverse();
4577         self.assertTrue(dbl.isMonotonic(False, .99));
4578         self.assertTrue(not dbl.isMonotonic(False, 1.1));
4579         self.assertTrue(not dbl.isMonotonic(False, -1.1));
4580
4581         dc=DataArrayInt.New();
4582         dc.alloc(14,1);
4583
4584         dd=DataArrayDouble.New();
4585         self.assertRaises(InterpKernelException, dd.checkAllocated);
4586         self.assertRaises(InterpKernelException, dd.fillWithValue, 1.);
4587         self.assertRaises(InterpKernelException, dd.iota, 1.);
4588         self.assertTrue(not ((dd.repr().find("No data"))==-1));
4589
4590         dd.alloc(0,1); #Allocated but nbOfElements==0!
4591         self.assertTrue(not ((dd.repr().find("Number of tuples : 0"))==-1));
4592         self.assertTrue(not ((dd.repr().find("Empty Data"))==-1));
4593         dd.fillWithValue(11); #?!...ok
4594         dd.iota(10); #?!...ok
4595         self.assertTrue(dd.isMonotonic(True, 1.));  #nothing is monotonic
4596         self.assertTrue(dd.isMonotonic(False, 1.));
4597
4598         self.assertRaises(InterpKernelException, db.copyStringInfoFrom, da);
4599         self.assertRaises(InterpKernelException, db.copyStringInfoFrom, da);
4600         cIds=[2,2]
4601         self.assertRaises(InterpKernelException, da.copyPartOfStringInfoFrom, db, cIds);
4602         cIds[0]=1;
4603         cIds[0]=-1;
4604         self.assertRaises(InterpKernelException, da.copyPartOfStringInfoFrom, db, cIds);
4605
4606         info=["infoOfOneComponent"]*2;
4607         self.assertRaises(InterpKernelException, da.setInfoOnComponents, info);
4608         self.assertRaises(InterpKernelException, da.setInfoOnComponent, 1, info[0]);
4609         db.setInfoOnComponents(info);
4610
4611         self.assertRaises(InterpKernelException, da.getInfoOnComponent, -1);
4612         self.assertRaises(InterpKernelException, da.getInfoOnComponent, 2);
4613         self.assertTrue(db.getInfoOnComponent(1)==db.getInfoOnComponent(0));
4614         self.assertRaises(InterpKernelException, db.getVarOnComponent, -1);
4615         self.assertRaises(InterpKernelException, db.getVarOnComponent, 2);
4616         self.assertRaises(InterpKernelException, db.getUnitOnComponent, -1);
4617         self.assertRaises(InterpKernelException, db.getUnitOnComponent, 2);
4618
4619         self.assertTrue(da.GetVarNameFromInfo("varname unit ")=="varname unit ");
4620         self.assertTrue(da.GetVarNameFromInfo("varname]unit[")=="varname]unit[");
4621         self.assertTrue(da.GetVarNameFromInfo("[unit]")=="");
4622         self.assertTrue(da.GetVarNameFromInfo("varname [unit]")=="varname");
4623
4624         self.assertTrue(da.GetUnitFromInfo("varname unit ")=="");
4625         self.assertTrue(da.GetUnitFromInfo("varname]unit[")=="");
4626         self.assertTrue(da.GetUnitFromInfo("[unit]")=="unit");
4627         self.assertTrue(da.GetUnitFromInfo("varname [unit]")=="unit");
4628
4629         self.assertRaises(InterpKernelException, da.checkNbOfTuplesAndComp, db, "theMessageInThrow");
4630         self.assertRaises(InterpKernelException, da.checkNbOfTuplesAndComp, dc, "theMessageInThrow");
4631         self.assertRaises(InterpKernelException, db.checkNbOfTuplesAndComp, dc, "theMessageInThrow");
4632
4633         self.assertRaises(InterpKernelException, da.checkNbOfTuplesAndComp, 7, 2, "theMessageInThrow");
4634         da.checkNbOfTuplesAndComp(7,1,"theMessageInThrow");
4635
4636         self.assertRaises(InterpKernelException, db.checkNbOfElems, 7*2+1, "theMessageInThrow");
4637         db.checkNbOfElems(7*2,"theMessageInThrow");
4638
4639         self.assertRaises(InterpKernelException, db.GetNumberOfItemGivenBES, 10, 9, 1, "theMessageInThrow");
4640         self.assertRaises(InterpKernelException, db.GetNumberOfItemGivenBES, 0, 1, -1, "theMessageInThrow");
4641         self.assertEqual(10,db.GetNumberOfItemGivenBES(0,10,1,"theMessageInThrow"));
4642         self.assertEqual(5,db.GetNumberOfItemGivenBES(0,10,2,"theMessageInThrow"));
4643         self.assertEqual(6,db.GetNumberOfItemGivenBES(0,11,2,"theMessageInThrow"));
4644
4645         self.assertTrue(not ((da.repr().find("Number of components : 1"))==-1));
4646         self.assertTrue(not ((dd.repr().find("Number of components : 1"))==-1));
4647         self.assertTrue(not ((dbl.repr().find("Number of components : 1"))==-1));
4648
4649         self.assertTrue(not ((da.reprZip().find("Number of components : 1"))==-1));
4650         self.assertTrue(not ((dd.reprZip().find("Number of components : 1"))==-1));
4651         self.assertTrue(not ((dbl.reprZip().find("Number of components : 1"))==-1));
4652
4653         self.assertRaises(InterpKernelException, dbl.selectByTupleId2, 0, 1, -1);
4654         self.assertRaises(InterpKernelException, dbl.substr, -1, 1);
4655         self.assertRaises(InterpKernelException, dbl.substr, 8, 1);
4656         self.assertRaises(InterpKernelException, dbl.substr, 0, 8);
4657         self.assertRaises(InterpKernelException, dbl.meldWith, dd);
4658
4659         self.assertRaises(InterpKernelException, dbl.setPartOfValuesAdv, dbl2, da); #dbl dbl2 not have the same number of components
4660         self.assertRaises(InterpKernelException, dbl.setPartOfValuesAdv, dd, da);  #da tuple selector DataArrayInt instance not have exactly 2 components
4661
4662         dbl3=DataArrayDouble.New();
4663         dbl3.alloc(6,2);
4664         dbl3.fillWithValue(11.);
4665         #bad number of components
4666         self.assertRaises(InterpKernelException, dbl3.getMaxValue);
4667         self.assertRaises(InterpKernelException, dd.getMaxValue);
4668         self.assertRaises(InterpKernelException, dbl3.getMinValue);
4669         self.assertRaises(InterpKernelException, dd.getMinValue);
4670         self.assertRaises(InterpKernelException, dbl3.getAverageValue);
4671         self.assertRaises(InterpKernelException, dd.getAverageValue);
4672         self.assertRaises(InterpKernelException, dd.accumulate, 100);
4673         self.assertRaises(InterpKernelException, dbl.fromPolarToCart);
4674         self.assertRaises(InterpKernelException, dbl3.fromCylToCart);
4675         self.assertRaises(InterpKernelException, dbl3.fromSpherToCart);
4676         self.assertRaises(InterpKernelException, dbl3.doublyContractedProduct);
4677         self.assertRaises(InterpKernelException, dbl3.determinant);
4678         self.assertRaises(InterpKernelException, dbl3.eigenValues);
4679         self.assertRaises(InterpKernelException, dbl3.eigenVectors);
4680         self.assertRaises(InterpKernelException, dbl3.inverse);
4681         self.assertRaises(InterpKernelException, dbl3.trace);
4682         self.assertRaises(InterpKernelException, dbl3.deviator);
4683
4684         dbl3.setIJ(5,1,12.);
4685         self.assertTrue(dbl3.getMaxValueInArray()==12.);
4686         self.assertTrue(dbl3.getMinValueInArray()==11.);
4687
4688         db.fillWithValue(100); #bad Ids
4689         self.assertRaises(InterpKernelException, dbl3.setPartOfValuesAdv, dbl2, db);
4690         db.fillWithValue(-1); #bad Ids
4691         self.assertRaises(InterpKernelException, dbl3.setPartOfValuesAdv, dbl2, db);
4692         db.fillWithValue(6); #bad Ids for dbl3
4693         self.assertRaises(InterpKernelException, dbl3.setPartOfValuesAdv, dbl2, db);
4694
4695         dbl3.checkNoNullValues();
4696         dbl3.setIJ(5,0,0.);
4697         self.assertRaises(InterpKernelException, dbl3.checkNoNullValues);
4698         self.assertRaises(InterpKernelException, dbl3.applyInv, 1.);  #div by zero
4699         self.assertRaises(InterpKernelException, dbl2.getIdsInRange, 1., 2.);
4700         a=[]
4701         self.assertRaises(InterpKernelException, DataArrayDouble_Aggregate, a);
4702         self.assertRaises(InterpKernelException, DataArrayDouble_Meld, a);
4703
4704         a=[dbl2,dbl]; #Nb of components mismatch
4705         self.assertRaises(InterpKernelException, DataArrayDouble_Aggregate, a);
4706
4707         self.assertRaises(InterpKernelException, DataArrayDouble_Dot, dbl2, dbl);
4708
4709         self.assertRaises(InterpKernelException, DataArrayDouble_CrossProduct, dbl2, dbl); #Nb of components mismatch
4710         self.assertRaises(InterpKernelException, DataArrayDouble_CrossProduct, dbl2, dbl2); #Nb of components must be equal to 3
4711         dbl4=DataArrayDouble.New();
4712         dbl4.alloc(6,3);
4713         dbl5=DataArrayDouble.New();
4714         dbl5.alloc(7,3);
4715         self.assertRaises(InterpKernelException, DataArrayDouble_CrossProduct, dbl4, dbl5); #Nb of tuples mismatch
4716
4717         a[0]=dbl4; #Nb of tuple mismatch
4718         a[1]=dbl5; #Nb of tuple mismatch
4719         self.assertRaises(InterpKernelException, DataArrayDouble_Meld, a);
4720         self.assertRaises(InterpKernelException, DataArrayDouble_Dot, dbl4, dbl5);
4721         pass
4722
4723     def testDAIGetIdsEqual1(self):
4724         tab1=[5,-2,-4,-2,3,2,-2];
4725         da=DataArrayInt.New();
4726         da.setValues(tab1,7,1);
4727         da2=da.getIdsEqual(-2);
4728         self.assertEqual(3,da2.getNumberOfTuples());
4729         self.assertEqual(1,da2.getNumberOfComponents());
4730         expected1=[1,3,6];
4731         self.assertEqual(expected1,da2.getValues());
4732         pass
4733
4734     def testDAIGetIdsEqualList1(self):
4735         tab1=[5,-2,-4,-2,3,2,-2];
4736         da=DataArrayInt.New();
4737         da.setValues(tab1,7,1);
4738         da2=da.getIdsEqualList([3,-2,0]);
4739         self.assertEqual(4,da2.getNumberOfTuples());
4740         self.assertEqual(1,da2.getNumberOfComponents());
4741         expected1=[1,3,4,6];
4742         self.assertEqual(expected1,da2.getValues());
4743         pass
4744
4745     def testDAFromNoInterlace1(self):
4746         tab1=[1,11,21,31,41,2,12,22,32,42,3,13,23,33,43]
4747         da=DataArrayInt.New();
4748         da.setValues(tab1,5,3);
4749         da2=da.fromNoInterlace();
4750         expected1=[1,2,3,11,12,13,21,22,23,31,32,33,41,42,43]
4751         self.assertEqual(5,da2.getNumberOfTuples());
4752         self.assertEqual(3,da2.getNumberOfComponents());# it's not a bug. Avoid to have 1 million components !
4753         self.assertEqual(expected1,da2.getValues());
4754         da3=da.convertToDblArr();
4755         da4=da3.fromNoInterlace();
4756         self.assertEqual(5,da4.getNumberOfTuples());
4757         self.assertEqual(3,da4.getNumberOfComponents());# it's not a bug. Avoid to have 1 million components !
4758         for i in xrange(15):
4759             self.assertAlmostEqual(expected1[i],da4.getIJ(0,i),14);
4760             pass
4761         pass
4762
4763     def testDAToNoInterlace1(self):
4764         tab1=[1,2,3,11,12,13,21,22,23,31,32,33,41,42,43]
4765         da=DataArrayInt.New();
4766         da.setValues(tab1,5,3);
4767         da2=da.toNoInterlace();
4768         expected1=[1,11,21,31,41,2,12,22,32,42,3,13,23,33,43]
4769         self.assertEqual(5,da2.getNumberOfTuples());
4770         self.assertEqual(3,da2.getNumberOfComponents());# it's not a bug. Avoid to have 1 million components !
4771         self.assertEqual(expected1,da2.getValues());
4772         da3=da.convertToDblArr();
4773         da4=da3.toNoInterlace();
4774         self.assertEqual(5,da4.getNumberOfTuples());
4775         self.assertEqual(3,da4.getNumberOfComponents());# it's not a bug. Avoid to have 1 million components !
4776         for i in xrange(15):
4777             self.assertAlmostEqual(expected1[i],da4.getIJ(0,i),14);
4778             pass
4779         pass
4780
4781     def testDAIsUniform1(self):
4782         tab1=[1,1,1,1,1]
4783         da=DataArrayInt.New();
4784         da.setValues(tab1,5,1);
4785         self.assertTrue(da.isUniform(1));
4786         da.setIJ(2,0,2);
4787         self.assertTrue(not da.isUniform(1));
4788         da.setIJ(2,0,1);
4789         self.assertTrue(da.isUniform(1));
4790         da2=da.convertToDblArr();
4791         self.assertTrue(da2.isUniform(1.,1.e-12));
4792         da2.setIJ(1,0,1.+1.e-13);
4793         self.assertTrue(da2.isUniform(1.,1.e-12));
4794         da2.setIJ(1,0,1.+1.e-11);
4795         self.assertTrue(not da2.isUniform(1.,1.e-12));
4796         pass
4797
4798     def testDADFromPolarToCart1(self):
4799         tab1=[2.,0.2,2.5,0.7]
4800         da=DataArrayDouble.New();
4801         da.setValues(tab1,2,2);
4802         da2=da.fromPolarToCart();
4803         expected1=[1.9601331556824833,0.39733866159012243, 1.9121054682112213,1.6105442180942275]
4804         for i in xrange(4):
4805             self.assertAlmostEqual(expected1[i],da2.getIJ(0,i),13);
4806             pass
4807         pass
4808
4809     def testDADFromCylToCart1(self):
4810         tab1=[2.,0.2,4.,2.5,0.7,9.]
4811         da=DataArrayDouble.New();
4812         da.setValues(tab1,2,3);
4813         da2=da.fromCylToCart();
4814         expected1=[1.9601331556824833,0.39733866159012243,4., 1.9121054682112213,1.6105442180942275,9.]
4815         for i in xrange(6):
4816             self.assertAlmostEqual(expected1[i],da2.getIJ(0,i),13);
4817             pass
4818         pass
4819
4820     def testDADFromSpherToCart1(self):
4821         tab1=[2.,0.2,0.3,2.5,0.7,0.8]
4822         da=DataArrayDouble.New();
4823         da.setValues(tab1,2,3);
4824         da2=da.fromSpherToCart();
4825         expected1=[0.37959212195737485,0.11742160338765303,1.9601331556824833, 1.1220769624465328,1.1553337045129035,1.9121054682112213]
4826         for i in xrange(6):
4827             self.assertAlmostEqual(expected1[i],da2.getIJ(0,i),13);
4828             pass
4829         pass
4830
4831     def testUnPolyze1(self):
4832         elts=[0,1,2,3,4,5,6,7]
4833         eltsV=elts;
4834         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
4835         mesh.convertToPolyTypes(eltsV);
4836         mesh.unPolyze();
4837         mesh2=MEDCouplingDataForTest.build3DTargetMesh_1();
4838         mesh.checkCoherency();
4839         self.assertTrue(mesh.isEqual(mesh2,1e-12));
4840         mesh.convertToPolyTypes(eltsV);
4841         self.assertTrue(not mesh.isEqual(mesh2,1e-12));
4842         mesh.getNodalConnectivity().setIJ(0,6,10);
4843         mesh.getNodalConnectivity().setIJ(0,7,9);
4844         mesh.getNodalConnectivity().setIJ(0,8,12);
4845         mesh.getNodalConnectivity().setIJ(0,9,13);
4846         mesh.unPolyze();
4847         self.assertTrue(mesh.isEqual(mesh2,1e-12));
4848         mesh.convertToPolyTypes(eltsV);
4849         mesh.getNodalConnectivity().setIJ(0,6,12);
4850         mesh.getNodalConnectivity().setIJ(0,7,13);
4851         mesh.getNodalConnectivity().setIJ(0,8,10);
4852         mesh.getNodalConnectivity().setIJ(0,9,9);
4853         mesh.unPolyze();
4854         self.assertTrue(mesh.isEqual(mesh2,1e-12));
4855         mesh.convertToPolyTypes(eltsV);
4856         mesh.getNodalConnectivity().setIJ(0,6,12);
4857         mesh.getNodalConnectivity().setIJ(0,7,10);
4858         mesh.getNodalConnectivity().setIJ(0,8,13);
4859         mesh.getNodalConnectivity().setIJ(0,9,9);
4860         mesh.unPolyze();
4861         self.assertTrue(not mesh.isEqual(mesh2,1e-12));
4862         # Test for 2D mesh
4863         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
4864         mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
4865         eltsV=eltsV[:5];
4866         mesh.convertToPolyTypes(eltsV);
4867         self.assertTrue(not mesh.isEqual(mesh2,1e-12));
4868         mesh.unPolyze();
4869         self.assertTrue(mesh.isEqual(mesh2,1e-12));
4870         pass
4871
4872     def testConvertDegeneratedCells1(self):
4873         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
4874         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]
4875         mesh.allocateCells(4);
4876         mesh.insertNextCell(NORM_HEXA8,8,conn[0:8])
4877         mesh.insertNextCell(NORM_HEXA8,8,conn[8:16])
4878         mesh.insertNextCell(NORM_HEXA8,8,conn[16:24])
4879         mesh.insertNextCell(NORM_HEXA8,8,conn[24:32])
4880         mesh.finishInsertingCells();
4881         mesh.checkCoherency();
4882         self.assertEqual(4,mesh.getNumberOfCells());
4883         self.assertEqual(NORM_HEXA8,mesh.getTypeOfCell(0));
4884         self.assertEqual(NORM_HEXA8,mesh.getTypeOfCell(1));
4885         self.assertEqual(NORM_HEXA8,mesh.getTypeOfCell(2));
4886         self.assertEqual(NORM_HEXA8,mesh.getTypeOfCell(3));
4887         f1=mesh.getMeasureField(True);
4888         mesh.convertDegeneratedCells();
4889         mesh.checkCoherency();
4890         f2=mesh.getMeasureField(True);
4891         self.assertEqual(4,mesh.getNumberOfCells());
4892         self.assertEqual(NORM_PENTA6,mesh.getTypeOfCell(0));
4893         self.assertEqual(NORM_PYRA5,mesh.getTypeOfCell(1));
4894         self.assertEqual(NORM_TETRA4,mesh.getTypeOfCell(2));
4895         self.assertEqual(NORM_PYRA5,mesh.getTypeOfCell(3));
4896         for i in xrange(4):
4897             self.assertAlmostEqual(f1.getArray().getIJ(0,i),f2.getArray().getIJ(0,i),5);
4898             pass
4899         pass
4900
4901     def testGetNodeIdsNearPoints1(self):
4902         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
4903         coords=mesh.getCoords();
4904         tmp=DataArrayDouble.New();
4905         vals=[0.2,0.2,0.1,0.2,0.2,0.2]
4906         tmp.setValues(vals,3,2);
4907         tmp2=DataArrayDouble.Aggregate(coords,tmp);
4908         mesh.setCoords(tmp2);
4909         pts=[0.2,0.2,0.1,0.3,-0.3,0.7]
4910         c=mesh.getNodeIdsNearPoint(pts[:2],1e-7);
4911         self.assertEqual([4,9,11],c.getValues());
4912         c,cI=mesh.getNodeIdsNearPoints(pts,3,1e-7);
4913         self.assertEqual([0,3,3,4],cI.getValues());
4914         self.assertEqual([4,9,11,6],c.getValues());
4915         c,cI=mesh.getNodeIdsNearPoints(pts,1e-7);
4916         self.assertEqual([0,3,3,4],cI.getValues());
4917         self.assertEqual([4,9,11,6],c.getValues());
4918         c,cI=mesh.getNodeIdsNearPoints(DataArrayDouble.New(pts,3,2),1e-7);
4919         self.assertEqual([0,3,3,4],cI.getValues());
4920         self.assertEqual([4,9,11,6],c.getValues());
4921         self.assertRaises(InterpKernelException,mesh.getNodeIdsNearPoints,DataArrayDouble.New(pts,2,3),1e-7);
4922         pass
4923
4924     def testFieldCopyTinyAttrFrom1(self):
4925         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
4926         f1.setName("f1");
4927         f1.setTimeTolerance(1.e-5);
4928         f1.setDescription("f1Desc");
4929         f1.setTime(1.23,4,5);
4930         f2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
4931         f2.setName("f2");
4932         f2.setDescription("f2Desc");
4933         f2.setTime(6.78,9,10);
4934         f2.setTimeTolerance(4.556e-12);
4935         #
4936         f1.copyTinyAttrFrom(f2);
4937         self.assertAlmostEqual(4.556e-12,f1.getTimeTolerance(),24);
4938         t,dt,it=f1.getTime()
4939         self.assertAlmostEqual(6.78,t,12);
4940         self.assertEqual(9,dt);
4941         self.assertEqual(10,it);
4942         self.assertTrue(f1.getName()=="f1");#name unchanged
4943         self.assertTrue(f1.getDescription()=="f1Desc");#description unchanged
4944         #
4945         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
4946         f1.setName("f1");
4947         f1.setTimeTolerance(1.e-5);
4948         f1.setDescription("f1Desc");
4949         f2=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
4950         f2.setName("f2");
4951         f2.setDescription("f2Desc");
4952         f2.setTimeTolerance(4.556e-12);
4953         #
4954         f1.copyTinyAttrFrom(f2);
4955         self.assertAlmostEqual(4.556e-12,f1.getTimeTolerance(),24);
4956         self.assertTrue(f1.getName()=="f1");#name unchanged
4957         self.assertTrue(f1.getDescription()=="f1Desc");#description unchanged
4958         #
4959         f1=MEDCouplingFieldDouble.New(ON_CELLS,CONST_ON_TIME_INTERVAL);
4960         f1.setName("f1");
4961         f1.setTimeTolerance(1.e-5);
4962         f1.setDescription("f1Desc");
4963         f1.setTime(1.23,4,5);
4964         f1.setEndTime(5.43,2,1);
4965         f2=MEDCouplingFieldDouble.New(ON_CELLS,CONST_ON_TIME_INTERVAL);
4966         f2.setName("f2");
4967         f2.setDescription("f2Desc");
4968         f2.setTimeTolerance(4.556e-12);
4969         f2.setTime(6.78,9,10);
4970         f2.setEndTime(10.98,7,6);
4971         #
4972         f1.copyTinyAttrFrom(f2);
4973         self.assertAlmostEqual(4.556e-12,f1.getTimeTolerance(),24);
4974         self.assertTrue(f1.getName()=="f1");#name unchanged
4975         self.assertTrue(f1.getDescription()=="f1Desc");#description unchanged
4976         t,dt,it=f1.getTime()
4977         self.assertAlmostEqual(6.78,t,12);
4978         self.assertEqual(9,dt);
4979         self.assertEqual(10,it);
4980         t,dt,it=f1.getEndTime()
4981         self.assertAlmostEqual(10.98,t,12);
4982         self.assertEqual(7,dt);
4983         self.assertEqual(6,it);
4984         #
4985         f1=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
4986         f1.setName("f1");
4987         f1.setTimeTolerance(1.e-5);
4988         f1.setDescription("f1Desc");
4989         f1.setTime(1.23,4,5);
4990         f1.setEndTime(5.43,2,1);
4991         f2=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
4992         f2.setName("f2");
4993         f2.setDescription("f2Desc");
4994         f2.setTimeTolerance(4.556e-12);
4995         f2.setTime(6.78,9,10);
4996         f2.setEndTime(10.98,7,6);
4997         #
4998         f1.copyTinyAttrFrom(f2);
4999         self.assertAlmostEqual(4.556e-12,f1.getTimeTolerance(),24);
5000         self.assertTrue(f1.getName()=="f1");#name unchanged
5001         self.assertTrue(f1.getDescription()=="f1Desc");#description unchanged
5002         t,dt,it=f1.getTime()
5003         self.assertAlmostEqual(6.78,t,12);
5004         self.assertEqual(9,dt);
5005         self.assertEqual(10,it);
5006         t,dt,it=f1.getEndTime()
5007         self.assertAlmostEqual(10.98,t,12);
5008         self.assertEqual(7,dt);
5009         self.assertEqual(6,it);
5010         pass
5011
5012     def testExtrudedMesh5(self):
5013         coo1=[0.,1.,2.,3.5]
5014         a=DataArrayDouble.New();
5015         a.setValues(coo1,4,1);
5016         b=MEDCouplingCMesh.New();
5017         b.setCoordsAt(0,a);
5018         c=b.buildUnstructured();
5019         self.assertEqual(1,c.getSpaceDimension());
5020         c.changeSpaceDimension(2);
5021         #
5022         d=DataArrayDouble.New();
5023         d.alloc(13,1);
5024         d.iota();
5025         e=MEDCouplingCMesh.New();
5026         e.setCoordsAt(0,d);
5027         f=e.buildUnstructured();
5028         g=f.getCoords().applyFunc(2,"3.5*IVec+x/6*3.14159265359*JVec");
5029         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 !
5030         h=g.fromPolarToCart();
5031         f.setCoords(h);
5032         i=c.buildExtrudedMesh(f,1);
5033         self.assertEqual(52,i.getNumberOfNodes());
5034         tmp,tmp2,tmp3=i.mergeNodes(1e-9);
5035         self.assertTrue(tmp2);
5036         self.assertEqual(37,tmp3);
5037         i.convertDegeneratedCells();
5038         i.checkCoherency();
5039         self.assertEqual(36,i.getNumberOfCells());
5040         self.assertEqual(37,i.getNumberOfNodes());
5041         self.assertEqual(12,i.getNumberOfCellsWithType(NORM_TRI3));
5042         self.assertEqual(24,i.getNumberOfCellsWithType(NORM_QUAD4));
5043         expected1=[0.25,0.75,2.0625]
5044         j=i.getMeasureField(True);
5045         for ii in xrange(12):
5046             for k in xrange(3):
5047                 self.assertAlmostEqual(expected1[k],j.getIJ(0,ii*3+k),10);
5048                 pass
5049             pass
5050         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]
5051         m=i.getBarycenterAndOwner();
5052         for i in xrange(72):
5053             self.assertAlmostEqual(expected2[i],m.getIJ(0,i),10);
5054             pass
5055         #
5056         pass
5057
5058     def testExtrudedMesh6(self):
5059         coo1=[0.,1.,2.,3.5]
5060         a=DataArrayDouble.New();
5061         a.setValues(coo1,4,1);
5062         b=MEDCouplingCMesh.New();
5063         b.setCoordsAt(0,a);
5064         c=b.buildUnstructured();
5065         self.assertEqual(1,c.getSpaceDimension());
5066         c.changeSpaceDimension(2);
5067         #
5068         d=DataArrayDouble.New();
5069         d.alloc(5,1);
5070         d.iota();
5071         e=MEDCouplingCMesh.New();
5072         e.setCoordsAt(0,d);
5073         f=e.buildUnstructured();
5074         d2=f.getCoords().applyFunc("x*x/2");
5075         f.setCoords(d2);
5076         f.changeSpaceDimension(2);
5077         #
5078         center=[0.,0.]
5079         f.rotate(center,None,pi/3);
5080         g=c.buildExtrudedMesh(f,0);
5081         g.checkCoherency();
5082         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 ]
5083         f1=g.getMeasureField(True);
5084         for i in xrange(12):
5085             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),12);
5086             pass
5087         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]
5088         f2=g.getBarycenterAndOwner();
5089         for i in xrange(24):
5090             self.assertAlmostEqual(expected2[i],f2.getIJ(0,i),12);
5091             pass
5092         pass
5093
5094     def testExtrudedMesh7(self):
5095         coo1=[0.,1.,2.,3.5]
5096         a=DataArrayDouble.New();
5097         a.setValues(coo1,4,1);
5098         b=MEDCouplingCMesh.New();
5099         b.setCoordsAt(0,a);
5100         c=b.buildUnstructured();
5101         self.assertEqual(1,c.getSpaceDimension());
5102         c.changeSpaceDimension(2);
5103         #
5104         d=DataArrayDouble.New();
5105         d.alloc(13,1);
5106         d.iota();
5107         e=MEDCouplingCMesh.New();
5108         e.setCoordsAt(0,d);
5109         f=e.buildUnstructured();
5110         g=f.getCoords().applyFunc(2,"3.5*IVec+x/6*3.14159265359*JVec");
5111         h=g.fromPolarToCart();
5112         f.setCoords(h);
5113         i=c.buildExtrudedMesh(f,1);
5114         self.assertEqual(52,i.getNumberOfNodes());
5115         tmp,tmp2,tmp3=i.mergeNodes(1e-9);
5116         self.assertTrue(tmp2);
5117         self.assertEqual(37,tmp3);
5118         i.convertDegeneratedCells();
5119         vec1=[10.,0]
5120         i.translate(vec1);
5121         g2=h.applyFunc(3,"13.5/3.5*x*IVec+0*JVec+13.5/3.5*y*KVec");
5122         f.setCoords(g2);
5123         i.changeSpaceDimension(3);
5124         i3=i.buildExtrudedMesh(f,1);
5125         f2=i3.getMeasureField(True);
5126         tmp,tmp2,tmp3=i.mergeNodes(1e-9);
5127         self.assertTrue(tmp2);
5128         self.assertEqual(444,tmp3);
5129         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]
5130         for ii in xrange(12):
5131             for jj in xrange(36):
5132                 self.assertAlmostEqual(expected1[jj],f2.getIJ(0,ii*36+jj),9);
5133                 pass
5134         #
5135         pass
5136
5137     def testSimplexize1(self):
5138         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5139         m.convertToPolyTypes([3]);
5140         da=m.simplexize(0);
5141         self.assertEqual(7,da.getNumberOfTuples());
5142         self.assertEqual(1,da.getNumberOfComponents());
5143         expected2=[0,0,1,2,3,4,4]
5144         for i in xrange(7):
5145             self.assertEqual(expected2[i],da.getIJ(i,0));
5146             pass
5147         m.checkCoherency();
5148         self.assertEqual(7,m.getNumberOfCells());
5149         self.assertEqual(NORM_TRI3,m.getTypeOfCell(0));
5150         self.assertEqual(NORM_TRI3,m.getTypeOfCell(1));
5151         self.assertEqual(NORM_TRI3,m.getTypeOfCell(2));
5152         self.assertEqual(NORM_TRI3,m.getTypeOfCell(3));
5153         self.assertEqual(NORM_POLYGON,m.getTypeOfCell(4));
5154         self.assertEqual(NORM_TRI3,m.getTypeOfCell(5));
5155         self.assertEqual(NORM_TRI3,m.getTypeOfCell(6));
5156         expected1=[0.125,0.125,0.125,0.125,0.25,0.125,0.125]
5157         f=m.getMeasureField(False);
5158         for i in xrange(7):
5159             self.assertAlmostEqual(expected1[i]*sqrt(2.),f.getIJ(i,0),10);
5160             pass
5161         types=m.getAllTypes();
5162         self.assertEqual([NORM_TRI3,NORM_POLYGON],types);
5163         #
5164         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5165         m.convertToPolyTypes([3]);
5166         da=m.simplexize(1);
5167         self.assertEqual(7,da.getNumberOfTuples());
5168         self.assertEqual(1,da.getNumberOfComponents());
5169         for i in xrange(7):
5170             self.assertEqual(expected2[i],da.getIJ(i,0));
5171             pass
5172         m.checkCoherency();
5173         types=m.getAllTypes();
5174         self.assertEqual([NORM_TRI3,NORM_POLYGON],types);
5175         self.assertEqual(7,m.getNumberOfCells());
5176         self.assertEqual(NORM_TRI3,m.getTypeOfCell(0));
5177         self.assertEqual(NORM_TRI3,m.getTypeOfCell(1));
5178         self.assertEqual(NORM_TRI3,m.getTypeOfCell(2));
5179         self.assertEqual(NORM_TRI3,m.getTypeOfCell(3));
5180         self.assertEqual(NORM_POLYGON,m.getTypeOfCell(4));
5181         self.assertEqual(NORM_TRI3,m.getTypeOfCell(5));
5182         self.assertEqual(NORM_TRI3,m.getTypeOfCell(6));
5183         f=m.getMeasureField(False);
5184         for i in xrange(7):
5185             self.assertAlmostEqual(expected1[i]*sqrt(2.),f.getIJ(i,0),10);
5186             pass
5187         pass
5188
5189     def testSimplexize2(self):
5190         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5191         m.convertToPolyTypes([3]);
5192         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
5193         f1.setMesh(m);
5194         arr=DataArrayDouble.New();
5195         arr1=[10.,110.,20.,120.,30.,130.,40.,140.,50.,150.]
5196         arr.setValues(arr1,5,2);
5197         f1.setArray(arr);
5198         #
5199         f1.checkCoherency();
5200         self.assertTrue(f1.simplexize(0));
5201         f1.checkCoherency();
5202         expected1=[10.,110.,10.,110.,20.,120.,30.,130.,40.,140.,50.,150.,50.,150.]
5203         for i in xrange(14):
5204             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),10);
5205             pass
5206         self.assertTrue(not f1.simplexize(0));
5207         for i in xrange(14):
5208             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),10);
5209             pass
5210         #
5211         pass
5212
5213     def testDAMeld1(self):
5214         da1=DataArrayDouble.New();
5215         da1.alloc(7,2);
5216         da2=DataArrayDouble.New();
5217         da2.alloc(7,1);
5218         #
5219         da1.fillWithValue(7.);
5220         da2.iota(0.);
5221         da3=da2.applyFunc(3,"10*x*IVec+100*x*JVec+1000*x*KVec");
5222         #
5223         da1.setInfoOnComponent(0,"c0da1");
5224         da1.setInfoOnComponent(1,"c1da1");
5225         da3.setInfoOnComponent(0,"c0da3");
5226         da3.setInfoOnComponent(1,"c1da3");
5227         da3.setInfoOnComponent(2,"c2da3");
5228         #
5229         da1C=da1.deepCpy();
5230         da1.meldWith(da3);
5231         self.assertEqual(5,da1.getNumberOfComponents());
5232         self.assertEqual(7,da1.getNumberOfTuples());
5233         self.assertTrue(da1.getInfoOnComponent(0)=="c0da1");
5234         self.assertTrue(da1.getInfoOnComponent(1)=="c1da1");
5235         self.assertTrue(da1.getInfoOnComponent(2)=="c0da3");
5236         self.assertTrue(da1.getInfoOnComponent(3)=="c1da3");
5237         self.assertTrue(da1.getInfoOnComponent(4)=="c2da3");
5238         #
5239         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.]
5240         for i in xrange(35):
5241             self.assertAlmostEqual(expected1[i],da1.getIJ(0,i),10);
5242             pass
5243         #
5244         dai1=da1C.convertToIntArr();
5245         dai3=da3.convertToIntArr();
5246         dai1.meldWith(dai3);
5247         self.assertEqual(5,dai1.getNumberOfComponents());
5248         self.assertEqual(7,dai1.getNumberOfTuples());
5249         self.assertTrue(dai1.getInfoOnComponent(0)=="c0da1");
5250         self.assertTrue(dai1.getInfoOnComponent(1)=="c1da1");
5251         self.assertTrue(dai1.getInfoOnComponent(2)=="c0da3");
5252         self.assertTrue(dai1.getInfoOnComponent(3)=="c1da3");
5253         self.assertTrue(dai1.getInfoOnComponent(4)=="c2da3");
5254         for i in xrange(35):
5255             self.assertEqual(int(expected1[i]),dai1.getIJ(0,i));
5256             pass
5257         # test of static method DataArrayDouble::meld
5258         da4=DataArrayDouble.Meld(da1C,da3);
5259         tmp=DataArrayDouble.Meld([da1C,da3]);
5260         self.assertTrue(da4.isEqual(tmp,1e-10))
5261         self.assertEqual(5,da4.getNumberOfComponents());
5262         self.assertEqual(7,da4.getNumberOfTuples());
5263         self.assertTrue(da4.getInfoOnComponent(0)=="c0da1");
5264         self.assertTrue(da4.getInfoOnComponent(1)=="c1da1");
5265         self.assertTrue(da4.getInfoOnComponent(2)=="c0da3");
5266         self.assertTrue(da4.getInfoOnComponent(3)=="c1da3");
5267         self.assertTrue(da4.getInfoOnComponent(4)=="c2da3");
5268         for i in xrange(35):
5269             self.assertAlmostEqual(expected1[i],da4.getIJ(0,i),10);
5270             pass
5271         # test of static method DataArrayInt::meld
5272         dai1=da1C.convertToIntArr();
5273         dai4=DataArrayInt.Meld(dai1,dai3);
5274         tmp=DataArrayInt.Meld([dai1,dai3]);
5275         self.assertTrue(dai4.isEqual(tmp))
5276         self.assertEqual(5,dai4.getNumberOfComponents());
5277         self.assertEqual(7,dai4.getNumberOfTuples());
5278         self.assertTrue(dai4.getInfoOnComponent(0)=="c0da1");
5279         self.assertTrue(dai4.getInfoOnComponent(1)=="c1da1");
5280         self.assertTrue(dai4.getInfoOnComponent(2)=="c0da3");
5281         self.assertTrue(dai4.getInfoOnComponent(3)=="c1da3");
5282         self.assertTrue(dai4.getInfoOnComponent(4)=="c2da3");
5283         for i in xrange(35):
5284             self.assertEqual(int(expected1[i]),dai4.getIJ(0,i));
5285             pass
5286         pass
5287
5288     def testFieldMeld1(self):
5289         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5290         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
5291         f1.setMesh(m);
5292         da1=DataArrayDouble.New();
5293         arr1=[12.,23.,34.,45.,56.]
5294         da1.setValues(arr1,5,1);
5295         da1.setInfoOnComponent(0,"aaa");
5296         f1.setArray(da1);
5297         f1.setTime(3.4,2,1);
5298         f1.checkCoherency();
5299         #
5300         f2=f1.deepCpy();
5301         f2.setMesh(f1.getMesh());
5302         f2.checkCoherency();
5303         f2.changeNbOfComponents(2,5.);
5304         f2.assign(5.);
5305         f2.getArray().setInfoOnComponent(0,"bbb");
5306         f2.getArray().setInfoOnComponent(1,"ccc");
5307         f2.checkCoherency();
5308         #
5309         f3=MEDCouplingFieldDouble.MeldFields(f2,f1);
5310         f3.checkCoherency();
5311         self.assertEqual(5,f3.getNumberOfTuples());
5312         self.assertEqual(3,f3.getNumberOfComponents());
5313         self.assertTrue(f3.getArray().getInfoOnComponent(0)=="bbb");
5314         self.assertTrue(f3.getArray().getInfoOnComponent(1)=="ccc");
5315         self.assertTrue(f3.getArray().getInfoOnComponent(2)=="aaa");
5316         expected1=[5.,5.,12.,5.,5.,23.,5.,5.,34.,5.,5.,45.,5.,5.,56.]
5317         for i in xrange(15):
5318             self.assertAlmostEqual(expected1[i],f3.getIJ(0,i),12);
5319             pass
5320         time,dt,it=f3.getTime();
5321         self.assertAlmostEqual(3.4,time,14);
5322         self.assertEqual(2,dt);
5323         self.assertEqual(1,it);
5324         #
5325         f4=f2.buildNewTimeReprFromThis(NO_TIME,False);
5326         f5=f1.buildNewTimeReprFromThis(NO_TIME,False);
5327         f6=MEDCouplingFieldDouble.MeldFields(f4,f5);
5328         f6.checkCoherency();
5329         self.assertEqual(5,f6.getNumberOfTuples());
5330         self.assertEqual(3,f6.getNumberOfComponents());
5331         self.assertTrue(f6.getArray().getInfoOnComponent(0)=="bbb");
5332         self.assertTrue(f6.getArray().getInfoOnComponent(1)=="ccc");
5333         self.assertTrue(f6.getArray().getInfoOnComponent(2)=="aaa");
5334         for i in xrange(15):
5335             self.assertAlmostEqual(expected1[i],f6.getIJ(0,i),12);
5336             pass
5337         #
5338         pass
5339
5340     def testMergeNodes2(self):
5341         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5342         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
5343         vec=[0.002,0.]
5344         m2.translate(vec);
5345         #
5346         m3=MEDCouplingUMesh.MergeUMeshes([m1,m2]);
5347         da,b,newNbOfNodes=m3.mergeNodes2(0.01);
5348         self.assertEqual(9,m3.getNumberOfNodes());
5349         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]
5350         for i in xrange(18):
5351             self.assertAlmostEqual(expected1[i],m3.getCoords().getIJ(0,i),13);
5352             pass
5353         #
5354         pass
5355
5356     def testMergeField2(self):
5357         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5358         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
5359         f1.setMesh(m);
5360         arr=DataArrayDouble.New();
5361         arr.alloc(5,2);
5362         arr.fillWithValue(2.);
5363         f1.setArray(arr);
5364         f2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
5365         f2.setMesh(m);
5366         arr=DataArrayDouble.New();
5367         arr.alloc(5,2);
5368         arr.fillWithValue(5.);
5369         f2.setArray(arr);
5370         f3=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
5371         f3.setMesh(m);
5372         arr=DataArrayDouble.New();
5373         arr.alloc(5,2);
5374         arr.fillWithValue(7.);
5375         f3.setArray(arr);
5376         #
5377         f4=MEDCouplingFieldDouble.MergeFields([f1,f2,f3]);
5378         self.assertEqual(15,f4.getMesh().getNumberOfCells());
5379         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.]
5380         for i in xrange(30):
5381             self.assertAlmostEqual(expected1[i],f4.getIJ(0,i),13);
5382             pass
5383         #
5384         pass
5385
5386     def testDAIBuildComplement1(self):
5387         a=DataArrayInt.New();
5388         tab=[3,1,7,8]
5389         a.setValues(tab,4,1);
5390         b=a.buildComplement(12);
5391         self.assertEqual(8,b.getNumberOfTuples());
5392         self.assertEqual(1,b.getNumberOfComponents());
5393         expected1=[0,2,4,5,6,9,10,11]
5394         for i in xrange(8):
5395             self.assertEqual(expected1[i],b.getIJ(0,i));
5396             pass
5397         pass
5398
5399     def testDAIBuildUnion1(self):
5400         a=DataArrayInt.New();
5401         tab1=[3,1,7,8]
5402         a.setValues(tab1,4,1);
5403         c=DataArrayInt.New();
5404         tab2=[5,3,0,18,8]
5405         c.setValues(tab2,5,1);
5406         b=a.buildUnion(c);
5407         self.assertEqual(7,b.getNumberOfTuples());
5408         self.assertEqual(1,b.getNumberOfComponents());
5409         expected1=[0,1,3,5,7,8,18]
5410         for i in xrange(7):
5411             self.assertEqual(expected1[i],b.getIJ(0,i));
5412             pass
5413         b=DataArrayInt.BuildUnion([a,c]);
5414         self.assertEqual(7,b.getNumberOfTuples());
5415         self.assertEqual(1,b.getNumberOfComponents());
5416         expected1=[0,1,3,5,7,8,18]
5417         for i in xrange(7):
5418             self.assertEqual(expected1[i],b.getIJ(0,i));
5419             pass
5420         pass
5421
5422     def testDAIBuildIntersection1(self):
5423         a=DataArrayInt.New();
5424         tab1=[3,1,7,8]
5425         a.setValues(tab1,4,1);
5426         c=DataArrayInt.New();
5427         tab2=[5,3,0,18,8]
5428         c.setValues(tab2,5,1);
5429         b=a.buildIntersection(c);
5430         self.assertEqual(2,b.getNumberOfTuples());
5431         self.assertEqual(1,b.getNumberOfComponents());
5432         expected1=[3,8]
5433         for i in xrange(2):
5434             self.assertEqual(expected1[i],b.getIJ(0,i));
5435             pass
5436         b=DataArrayInt.BuildIntersection([a,c]);
5437         self.assertEqual(2,b.getNumberOfTuples());
5438         self.assertEqual(1,b.getNumberOfComponents());
5439         expected1=[3,8]
5440         for i in xrange(2):
5441             self.assertEqual(expected1[i],b.getIJ(0,i));
5442             pass
5443         pass
5444
5445     def testDAIDeltaShiftIndex1(self):
5446         a=DataArrayInt.New();
5447         tab=[1,3,6,7,7,9,15]
5448         a.setValues(tab,7,1);
5449         b=a.deltaShiftIndex();
5450         self.assertEqual(6,b.getNumberOfTuples());
5451         self.assertEqual(1,b.getNumberOfComponents());
5452         expected1=[2,3,1,0,2,6]
5453         for i in xrange(6):
5454             self.assertEqual(expected1[i],b.getIJ(0,i));
5455             pass
5456         pass
5457
5458     def testDaDoubleSelectByTupleIdSafe1(self):
5459         a=DataArrayDouble.New();
5460         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]
5461         a.setValues(arr1,7,2);
5462         a.setInfoOnComponent(0,"toto");
5463         a.setInfoOnComponent(1,"tata");
5464         #
5465         arr2=[4,2,0,6,5]
5466         b=a.selectByTupleIdSafe(arr2);
5467         self.assertEqual(5,b.getNumberOfTuples());
5468         self.assertEqual(2,b.getNumberOfComponents());
5469         self.assertTrue(b.getInfoOnComponent(0)=="toto");
5470         self.assertTrue(b.getInfoOnComponent(1)=="tata");
5471         expected1=[5.1,15.1,3.1,13.1,1.1,11.1,7.1,17.1,6.1,16.1]
5472         for i in xrange(10):
5473             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
5474             pass
5475         arr4=[4,-1,0,6,5]
5476         self.assertRaises(InterpKernelException,a.selectByTupleIdSafe,arr4);
5477         arr5=[4,2,0,6,7]
5478         self.assertRaises(InterpKernelException,a.selectByTupleIdSafe,arr5);
5479         #
5480         c=DataArrayInt.New();
5481         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
5482         c.setValues(arr3,7,2);
5483         c.setInfoOnComponent(0,"toto");
5484         c.setInfoOnComponent(1,"tata");
5485         d=c.selectByTupleIdSafe(arr2);
5486         self.assertEqual(5,d.getNumberOfTuples());
5487         self.assertEqual(2,d.getNumberOfComponents());
5488         self.assertTrue(d.getInfoOnComponent(0)=="toto");
5489         self.assertTrue(d.getInfoOnComponent(1)=="tata");
5490         expected2=[5,15,3,13,1,11,7,17,6,16]
5491         for i in xrange(10):
5492             self.assertEqual(expected2[i],d.getIJ(0,i));
5493             pass
5494         self.assertRaises(InterpKernelException,c.selectByTupleIdSafe,arr4);
5495         self.assertRaises(InterpKernelException,c.selectByTupleIdSafe,arr5);
5496         pass
5497
5498     def testAreCellsIncludedIn1(self):
5499         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5500         pt=[1,3]
5501         m2=m.buildPartOfMySelf(pt,True);
5502         ret,tmp=m.areCellsIncludedIn(m2,0)
5503         self.assertTrue(ret);
5504         self.assertEqual(2,tmp.getNumberOfTuples());
5505         self.assertEqual(1,tmp.getNumberOfComponents());
5506         self.assertEqual(pt[0],tmp.getIJ(0,0));
5507         self.assertEqual(pt[1],tmp.getIJ(0,1));
5508         ret,tmp=m2.areCellsIncludedIn(m,0)
5509         self.assertTrue(not ret);
5510         pass
5511
5512     def testSwigErrorProtection1(self):
5513         m=MEDCouplingDataForTest.build3DTargetMesh_1();
5514         m.rotate([0.,0.,0.],[0.3,0.6,1.2],0.37)
5515         m.rotate([0.,0.,0.],[0.3,6,1.2],0.37)
5516         self.assertRaises(InterpKernelException,m.rotate,[0.,0.,0.],(0.3,6,"1.2"),0.37)
5517         self.assertRaises(InterpKernelException,m.rotate,[0.,"0.",0.],[0.3,0.6,1.2],0.37)
5518         self.assertRaises(InterpKernelException,m.rotate,[0.,0.,0.],[0.3,'0.6',1.2],0.37)
5519         m2=m.buildPartOfMySelf([2,5],True)
5520         m3=m.buildPartOfMySelf((2,5),True)
5521         self.assertTrue(m2.isEqual(m3,1e-12))
5522         self.assertRaises(InterpKernelException,m.buildPartOfMySelf,[2,5.],True)
5523         da1=m.getCoords().keepSelectedComponents([1])
5524         da2=m.getCoords().keepSelectedComponents((1,))
5525         self.assertTrue(da1.isEqual(da2,1e-12))
5526         self.assertRaises(InterpKernelException,m.getCoords().keepSelectedComponents,["1"])
5527         pass
5528
5529     def testDAIBuildSubstraction1(self):
5530         a=DataArrayInt.New()
5531         aa=[2,3,6,8,9]
5532         a.setValues(aa,5,1)
5533         b=DataArrayInt.New()
5534         bb=[1,3,5,9,11]
5535         b.setValues(bb,5,1)
5536         self.assertEqual([2,6,8],a.buildSubstraction(b).getValues())
5537         pass
5538
5539     def testBuildOrthogonalField2(self):
5540         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5541         d1=DataArrayInt.New();
5542         d2=DataArrayInt.New();
5543         d3=DataArrayInt.New();
5544         d4=DataArrayInt.New();
5545         m1=m.buildDescendingConnectivity(d1,d2,d3,d4);
5546         #
5547         f1=m1.buildOrthogonalField();
5548         da1=f1.getArray();
5549         self.assertEqual(2,da1.getNumberOfComponents());
5550         self.assertEqual(13,da1.getNumberOfTuples());
5551         #
5552         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.];
5553         for i in xrange(26):
5554             self.assertAlmostEqual(expected1[i],da1.getIJ(0,i),14);
5555             pass
5556         pass
5557
5558     def testSwigErrorProtection2(self):
5559         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5560         coo=m.getCoords()
5561         c=m.getNodalConnectivity()
5562         ci=m.getNodalConnectivityIndex()
5563         del m
5564         self.assertEqual(2,coo.getNumberOfComponents());
5565         self.assertEqual(6,ci.getNumberOfTuples());
5566         self.assertEqual(23,c.getNumberOfTuples());
5567         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5568         f=m.getMeasureField(True)
5569         c=f.getArray()
5570         del f
5571         self.assertEqual(1,c.getNumberOfComponents());
5572         m=MEDCouplingCMesh.New()
5573         x=DataArrayDouble.New()
5574         x.setValues([1.,2.,4.],3,1)
5575         m.setCoordsAt(0,x)
5576         del x
5577         xx=m.getCoordsAt(0)
5578         del m
5579         self.assertEqual(3,xx.getNumberOfTuples());
5580         #
5581         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5582         f=m.getMeasureField(True)
5583         m2=f.getMesh()
5584         del m
5585         del f
5586         self.assertEqual(5,m2.getNumberOfCells());
5587         pass
5588
5589     def testUMInsertNextCell1(self):
5590         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 ]
5591         targetConn=[0,3,4,1, 1,4,2, 4,5,2, 6,7,4,3, 7,8,5,4]
5592         targetMesh=MEDCouplingUMesh.New();
5593         targetMesh.allocateCells(5);
5594         self.assertRaises(InterpKernelException,targetMesh.insertNextCell,NORM_QUAD4,4,targetConn[0:4])
5595         targetMesh.setMeshDimension(2);
5596         targetMesh.insertNextCell(NORM_QUAD4,4,targetConn[0:4])
5597         self.assertRaises(InterpKernelException,targetMesh.insertNextCell,NORM_TETRA4,4,targetConn[0:4])
5598         self.assertRaises(InterpKernelException,targetMesh.insertNextCell,NORM_SEG2,2,targetConn[0:2])
5599         self.assertRaises(InterpKernelException,targetMesh.insertNextCell,NORM_POINT1,1,targetConn[0:1])
5600         targetMesh.insertNextCell(NORM_TRI3,3,targetConn[4:7])
5601         targetMesh.insertNextCell(NORM_TRI3,3,targetConn[7:10])
5602         targetMesh.insertNextCell(NORM_QUAD4,4,targetConn[10:14])
5603         targetMesh.insertNextCell(NORM_QUAD4,4,targetConn[14:18])
5604         targetMesh.finishInsertingCells();
5605         myCoords=DataArrayDouble.New();
5606         myCoords.setValues(targetCoords,9,2);
5607         targetMesh.setCoords(myCoords);
5608         targetMesh.checkCoherency();
5609         pass
5610
5611     def testFieldOperatorDivDiffComp1(self):
5612         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5613         m1,d0,d1,d2,d3=m.buildDescendingConnectivity();
5614         #
5615         f1=m1.buildOrthogonalField();
5616         arr1=[2.,3.,4.,5.,6.,7.,8.,9.,10.,11.,12.,13.,14.]
5617         arr=DataArrayDouble.New();
5618         arr.setValues(arr1,13,1);
5619         f2=MEDCouplingFieldDouble.New(ON_CELLS);
5620         f2.setArray(arr);
5621         f2.setMesh(m1);
5622         f2.checkCoherency();
5623         #
5624         f3=f1/f2;
5625         self.assertRaises(InterpKernelException,f2.__div__,f1)
5626         f3.checkCoherency();
5627         f1/=f2;
5628         #self.assertRaises(InterpKernelException,f2.__idiv__,f1) # mem leaks
5629         self.assertTrue(f1.isEqual(f3,1e-10,1e-10));
5630         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]
5631         for i in xrange(26):
5632             self.assertAlmostEqual(expected1[i],f3.getIJ(0,i),10);
5633             pass
5634         pass
5635
5636     def testDARearrange1(self):
5637         da1=DataArrayInt.New();
5638         da1.alloc(12,1);
5639         da1.iota(0);
5640         #
5641         self.assertEqual(12,da1.getNbOfElems());
5642         self.assertEqual(1,da1.getNumberOfComponents());
5643         self.assertEqual(12,da1.getNumberOfTuples());
5644         da1.rearrange(4);
5645         self.assertEqual(12,da1.getNbOfElems());
5646         self.assertEqual(4,da1.getNumberOfComponents());
5647         self.assertEqual(3,da1.getNumberOfTuples());
5648         for i in xrange(12):
5649             self.assertEqual(i,da1.getIJ(0,i));
5650         #
5651         da1.rearrange(6);
5652         self.assertEqual(12,da1.getNbOfElems());
5653         self.assertEqual(6,da1.getNumberOfComponents());
5654         self.assertEqual(2,da1.getNumberOfTuples());
5655         for i in xrange(12):
5656             self.assertEqual(i,da1.getIJ(0,i));
5657         #
5658         self.assertRaises(InterpKernelException,da1.rearrange,7);
5659         #
5660         da1.rearrange(12);
5661         self.assertEqual(12,da1.getNbOfElems());
5662         self.assertEqual(12,da1.getNumberOfComponents());
5663         self.assertEqual(1,da1.getNumberOfTuples());
5664         for i in xrange(12):
5665             self.assertEqual(i,da1.getIJ(0,i));
5666         #
5667         da1.rearrange(3);
5668         self.assertEqual(12,da1.getNbOfElems());
5669         self.assertEqual(3,da1.getNumberOfComponents());
5670         self.assertEqual(4,da1.getNumberOfTuples());
5671         for i in xrange(12):
5672             self.assertEqual(i,da1.getIJ(0,i));
5673         #double
5674         da2=da1.convertToDblArr();
5675         st=da2.getHiddenCppPointer()
5676         #
5677         self.assertEqual(12,da2.getNbOfElems());
5678         self.assertEqual(3,da2.getNumberOfComponents());
5679         self.assertEqual(4,da2.getNumberOfTuples());
5680         da2.rearrange(4);
5681         self.assertEqual(12,da2.getNbOfElems());
5682         self.assertEqual(4,da2.getNumberOfComponents());
5683         self.assertEqual(3,da2.getNumberOfTuples());
5684         for i in xrange(12):
5685             self.assertAlmostEqual(float(i),da2.getIJ(0,i),14);
5686         #
5687         da2.rearrange(6);
5688         self.assertEqual(12,da2.getNbOfElems());
5689         self.assertEqual(6,da2.getNumberOfComponents());
5690         self.assertEqual(2,da2.getNumberOfTuples());
5691         for i in xrange(12):
5692             self.assertAlmostEqual(float(i),da2.getIJ(0,i),14);
5693         #
5694         self.assertRaises(InterpKernelException,da2.rearrange,7);
5695         #
5696         da2.rearrange(1);
5697         self.assertEqual(st,da2.getHiddenCppPointer())
5698         self.assertEqual(12,da2.getNbOfElems());
5699         self.assertEqual(1,da2.getNumberOfComponents());
5700         self.assertEqual(12,da2.getNumberOfTuples());
5701         for i in xrange(12):
5702             self.assertAlmostEqual(float(i),da2.getIJ(0,i),14);
5703         #
5704         da2.rearrange(3);
5705         self.assertEqual(12,da2.getNbOfElems());
5706         self.assertEqual(3,da2.getNumberOfComponents());
5707         self.assertEqual(4,da2.getNumberOfTuples());
5708         for i in xrange(12):
5709             self.assertAlmostEqual(float(i),da2.getIJ(0,i),14);
5710         pass
5711
5712     def testDARearrange2(self):
5713         da1=DataArrayInt.New();
5714         arr=[1,2,3,2,2,3,5,1,5,5,2,2]
5715         da1.setValues(arr,4,3);
5716         s=da1.getDifferentValues();
5717         expected1=[1,2,3,5]
5718         self.assertEqual(expected1,s);
5719         pass
5720
5721     def testSwigErrorProtection3(self):
5722         da=DataArrayInt.New()
5723         da.setValues([1,2,3,4],4,3)
5724         self.assertEqual([1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0],da.getValues())
5725         self.assertEqual(3,da.getNumberOfComponents());
5726         self.assertEqual(4,da.getNumberOfTuples());
5727         da=DataArrayInt.New()
5728         da.setValues((1,2,3,4,4,3),4,3)
5729         self.assertEqual([1, 2, 3, 4, 4, 3, 0, 0, 0, 0, 0, 0],da.getValues())
5730         self.assertEqual(3,da.getNumberOfComponents());
5731         self.assertEqual(4,da.getNumberOfTuples());
5732         da.setValues(10*[1]+290*[2],4,3)
5733         self.assertEqual(10*[1]+[2,2],da.getValues())
5734         self.assertEqual(3,da.getNumberOfComponents());
5735         self.assertEqual(4,da.getNumberOfTuples());
5736         #
5737         da=DataArrayDouble.New()
5738         da.setValues([1,2,3.,4],4,3)
5739         self.assertEqual([1., 2., 3., 4., 0., 0., 0., 0., 0., 0., 0., 0.],da.getValues())
5740         self.assertEqual(3,da.getNumberOfComponents());
5741         self.assertEqual(4,da.getNumberOfTuples());
5742         da=DataArrayDouble.New()
5743         da.setValues((1,2,3,4.,4,3),4,3)
5744         self.assertEqual([1., 2., 3., 4., 4., 3., 0., 0., 0., 0., 0., 0.],da.getValues())
5745         self.assertEqual(3,da.getNumberOfComponents());
5746         self.assertEqual(4,da.getNumberOfTuples());
5747         da.setValues(10*[1]+290*[2],4,3)
5748         self.assertEqual(10*[1.]+[2.,2.],da.getValues())
5749         self.assertEqual(3,da.getNumberOfComponents());
5750         self.assertEqual(4,da.getNumberOfTuples());
5751         pass
5752
5753     def testDAIBuildPermutationArr1(self):
5754         a=DataArrayInt.New()
5755         a.setValues([4,5,6,7,8],5,1)
5756         b=DataArrayInt.New()
5757         b.setValues([5,4,8,6,7],5,1)
5758         c=a.buildPermutationArr(b)
5759         self.assertEqual([1,0,4,2,3],c.getValues())
5760         self.assertTrue(a.isEqualWithoutConsideringStrAndOrder(b))
5761         b.setIJ(0,0,9)
5762         self.assertTrue(not a.isEqualWithoutConsideringStrAndOrder(b))
5763         self.assertRaises(InterpKernelException,a.buildPermutationArr,b)
5764         a.setIJ(3,0,4)
5765         b.setIJ(0,0,5)
5766         b.setIJ(4,0,4)#a==[4,5,6,4,8] and b==[5,4,8,6,4]
5767         self.assertTrue(a.isEqualWithoutConsideringStrAndOrder(b))
5768         c=a.buildPermutationArr(b)
5769         self.assertEqual([1,3,4,2,3],c.getValues())
5770         d=b.convertToDblArr()
5771         expect3=[4,4,5,6,8]
5772         b.sort()
5773         self.assertEqual(expect3,b.getValues())
5774         d.sort()
5775         self.assertEqual(5,d.getNumberOfTuples());
5776         self.assertEqual(1,d.getNumberOfComponents());
5777         for i in xrange(5):
5778             self.assertAlmostEqual(float(expect3[i]),d.getIJ(i,0),14);
5779             pass
5780         pass
5781
5782     def testAreCellsIncludedIn2(self):
5783         myName="Vitoo";
5784         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5785         m2=m.buildPartOfMySelf([],True);
5786         self.assertEqual(0,m2.getNumberOfCells());
5787         self.assertEqual(3,m2.getSpaceDimension());
5788         self.assertEqual(2,m2.getMeshDimension());
5789         m2.setName(myName);
5790         test,tmp=m.areCellsIncludedIn(m2,0)
5791         self.assertTrue(test);
5792         self.assertEqual(myName,tmp.getName());
5793         self.assertEqual(0,tmp.getNumberOfTuples())
5794         self.assertEqual(1,tmp.getNumberOfComponents())
5795         pass
5796
5797     def testUMeshGetPartBarycenterAndOwner1(self):
5798         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5799         part1=[1,0,4];
5800         part=DataArrayInt.New();
5801         part.setValues(part1,3,1);
5802         b=m1.getPartBarycenterAndOwner(part);
5803         self.assertEqual(2,b.getNumberOfComponents());
5804         self.assertEqual(3,b.getNumberOfTuples());
5805         expected1=[0.36666666666666665,-0.13333333333333333,-0.05,-0.05,0.45,0.45];
5806         for i in xrange(6):
5807             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
5808             pass
5809         pass
5810
5811     def testUMeshGetPartMeasureField1(self):
5812         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5813         part1=[1,0,4];
5814         part=DataArrayInt.New();
5815         part.setValues(part1,3,1);
5816         b=m1.getPartMeasureField(True,part);
5817         self.assertEqual(1,b.getNumberOfComponents());
5818         self.assertEqual(3,b.getNumberOfTuples());
5819         expected1=[0.125,0.25,0.25];
5820         for i in xrange(3):
5821             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
5822             pass
5823         pass
5824
5825     def testUMeshBuildPartOrthogonalField1(self):
5826         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5827         m1.changeSpaceDimension(3);
5828         part1=[1,0,4];
5829         part=DataArrayInt.New();
5830         part.setValues(part1,3,1);
5831         b=m1.buildPartOrthogonalField(part);
5832         self.assertEqual(3,b.getArray().getNumberOfComponents());
5833         self.assertEqual(3,b.getArray().getNumberOfTuples());
5834         expected1=[0.,0.,-1.,0.,0.,-1.,0.,0.,-1.];
5835         for i in xrange(9):
5836             self.assertAlmostEqual(expected1[i],b.getArray().getIJ(0,i),14);
5837             pass
5838         pass
5839
5840     def testUMeshGetTypesOfPart1(self):
5841         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5842         part1=[0,3,4];
5843         p1=DataArrayInt.New()
5844         p1.setValues(part1,3,1)
5845         s=m1.getTypesOfPart(p1);
5846         self.assertEqual([NORM_QUAD4],s);
5847         part2=[2,2,2,1];
5848         p2=DataArrayInt.New()
5849         p2.setValues(part2,4,1)
5850         s=m1.getTypesOfPart(p2);
5851         self.assertEqual([NORM_TRI3],s);
5852         part3=[3,2,1];
5853         p3=DataArrayInt.New()
5854         p3.setValues(part3,3,1)
5855         s=m1.getTypesOfPart(p3);
5856         self.assertEqual(s,[NORM_TRI3,NORM_QUAD4]);
5857         pass
5858
5859     def testUMeshKeepCellIdsByType1(self):
5860         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5861         part1=[0,3,4]
5862         p1=DataArrayInt.New()
5863         p1.setValues(part1,3,1)
5864         p1.setName("p1")
5865         a=m1.keepCellIdsByType(NORM_TRI3,p1);
5866         self.assertEqual("p1",a.getName())
5867         self.assertEqual(1,a.getNumberOfComponents());
5868         self.assertEqual(0,a.getNumberOfTuples());
5869         #
5870         part2=[3,2,0,2,4]
5871         p2=DataArrayInt.New()
5872         p2.setValues(part2,5,1)
5873         p2.setName("p2")
5874         a=m1.keepCellIdsByType(NORM_TRI3,p2);
5875         self.assertEqual("p2",a.getName())
5876         self.assertEqual(1,a.getNumberOfComponents());
5877         self.assertEqual(2,a.getNumberOfTuples());
5878         self.assertEqual(2,a.getIJ(0,0));
5879         self.assertEqual(2,a.getIJ(1,0));
5880         #
5881         a=m1.keepCellIdsByType(NORM_QUAD4,p2);
5882         self.assertEqual("p2",a.getName())
5883         self.assertEqual(1,a.getNumberOfComponents());
5884         self.assertEqual(3,a.getNumberOfTuples());
5885         self.assertEqual(3,a.getIJ(0,0));
5886         self.assertEqual(0,a.getIJ(1,0));
5887         self.assertEqual(4,a.getIJ(2,0));
5888         pass
5889
5890     def testSwigErrorDaIntSelectByTupleId1(self):
5891         a=DataArrayInt.New();
5892         arr1=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
5893         a.setValues(arr1,7,2);
5894         a.setInfoOnComponent(0,"toto");
5895         a.setInfoOnComponent(1,"tata");
5896         #
5897         arr2=[4,2,0,6,5]
5898         b=a.selectByTupleId(arr2);
5899         self.assertEqual(5,b.getNumberOfTuples());
5900         self.assertEqual(2,b.getNumberOfComponents());
5901         self.assertTrue(b.getInfoOnComponent(0)=="toto");
5902         self.assertTrue(b.getInfoOnComponent(1)=="tata");
5903         expected1=[5,15,3,13,1,11,7,17,6,16]
5904         self.assertEqual(expected1,b.getValues())
5905         #
5906         a2=DataArrayInt.New()
5907         a2.setValues(arr2,5,1)
5908         b=a.selectByTupleId(a2);
5909         self.assertEqual(5,b.getNumberOfTuples());
5910         self.assertEqual(2,b.getNumberOfComponents());
5911         self.assertTrue(b.getInfoOnComponent(0)=="toto");
5912         self.assertTrue(b.getInfoOnComponent(1)=="tata");
5913         expected1=[5,15,3,13,1,11,7,17,6,16]
5914         self.assertEqual(expected1,b.getValues())
5915         pass
5916
5917     def testSwigErrorRenum(self):
5918         da=DataArrayDouble.New()
5919         da.setValues([7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.],10,2)
5920         d=DataArrayInt.New()
5921         d.setValues([0,2,3,1,4,5,6,8,7,9],10,1)
5922         da.renumberInPlace(d)
5923         da.renumber(d)
5924         pass
5925
5926     def testSwigGetItem1(self):
5927         da=DataArrayInt.New()
5928         da.alloc(16,3)
5929         da.rearrange(1)
5930         da.iota(7)
5931         da.rearrange(3)
5932         da.setInfoOnComponent(0,"X [m]")
5933         da.setInfoOnComponent(1,"Y [m]")
5934         da.setInfoOnComponent(2,"Z [km]")
5935         da2=da[5:-1]
5936         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())
5937         da2=da[4]
5938         self.assertEqual([19, 20, 21],da2.getValues())
5939         try:
5940             da2=da[4:17]
5941         except InterpKernelException as e:
5942             self.assertTrue(True)
5943         else:
5944             self.assertTrue(False)
5945             pass
5946         da2=da[5:-2,2]
5947         self.assertEqual([24, 27, 30, 33, 36, 39, 42, 45, 48],da2.getValues())
5948         da2=da[5:8,:]
5949         self.assertEqual([22, 23, 24, 25, 26, 27, 28, 29, 30],da2.getValues())
5950         da2=da[:]
5951         self.assertTrue(da2.isEqual(da))
5952         da2=da[:,:]
5953         self.assertTrue(da2.isEqual(da))
5954         try:
5955             da2=da[:,:,:]
5956         except InterpKernelException as e:
5957             self.assertTrue(True)
5958         else:
5959             self.assertTrue(False)
5960             pass
5961         try:
5962             da2=da[5:8,-2]
5963         except InterpKernelException as e:
5964             self.assertTrue(True)
5965         else:
5966             self.assertTrue(False)
5967             pass
5968         da2=da[5:8,:-2]
5969         self.assertEqual([22, 25, 28],da2.getValues())
5970         try:
5971             da2=da[5:-18,2]
5972         except InterpKernelException as e:
5973             self.assertTrue(True)
5974         else:
5975             self.assertTrue(False)
5976             pass
5977         da2=da[5:5,2]
5978         self.assertEqual([],da2.getValues())
5979         pass
5980
5981     def testSwigGetItem2(self):
5982         da=DataArrayDouble.New()
5983         da.alloc(16,3)
5984         da.rearrange(1)
5985         da.iota(7)
5986         da.rearrange(3)
5987         da.setInfoOnComponent(0,"X [m]")
5988         da.setInfoOnComponent(1,"Y [m]")
5989         da.setInfoOnComponent(2,"Z [km]")
5990         da2=da[5:-1]
5991         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())
5992         da2=da[4]
5993         self.assertEqual([19., 20., 21],da2.getValues())
5994         try:
5995             da2=da[4:17]
5996         except InterpKernelException as e:
5997             self.assertTrue(True)
5998         else:
5999             self.assertTrue(False)
6000             pass
6001         da2=da[5:-2,2]
6002         self.assertEqual([24., 27., 30., 33., 36., 39., 42., 45., 48.],da2.getValues())
6003         da2=da[5:8,:]
6004         self.assertEqual([22., 23., 24., 25., 26., 27., 28., 29., 30.],da2.getValues())
6005         da2=da[:]
6006         self.assertTrue(da2.isEqual(da,1e-12))
6007         da2=da[:,:]
6008         self.assertTrue(da2.isEqual(da,1e-12))
6009         try:
6010             da2=da[:,:,:]
6011         except InterpKernelException as e:
6012             self.assertTrue(True)
6013         else:
6014             self.assertTrue(False)
6015             pass
6016         try:
6017             da2=da[5:8,-2]
6018         except InterpKernelException as e:
6019             self.assertTrue(True)
6020         else:
6021             self.assertTrue(False)
6022             pass
6023         da2=da[5:8,:-2]
6024         self.assertEqual([22., 25., 28.],da2.getValues())
6025         try:
6026             da2=da[5:-18,2]
6027         except InterpKernelException as e:
6028             self.assertTrue(True)
6029         else:
6030             self.assertTrue(False)
6031             pass
6032         da2=da[5:5,2]
6033         self.assertEqual([],da2.getValues())
6034         pass
6035
6036     def testSwigSetItem1(self):
6037         da=DataArrayInt.New()
6038         da.alloc(20,1)
6039         da.iota(7)
6040         da.rearrange(5)
6041         da.setInfoOnComponent(0,"X [m]") ; da.setInfoOnComponent(1,"Y [km]") ; da.setInfoOnComponent(2,"Y [m]")
6042         da.setInfoOnComponent(3,"Z [W]") ; da.setInfoOnComponent(4,"ZZ [km]") ;
6043         da[:,2]=3
6044         self.assertEqual([7, 8, 3, 10, 11, 12, 13, 3, 15, 16, 17, 18, 3, 20, 21, 22, 23, 3, 25, 26],da.getValues())
6045         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6046         da[2]=3
6047         self.assertEqual([7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 3, 3, 3, 3, 3, 22, 23, 24, 25, 26],da.getValues())
6048         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6049         da[[0,3]]=-1
6050         self.assertEqual([-1, -1, -1, -1, -1, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, -1, -1, -1, -1, -1],da.getValues())
6051         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6052         da[:,[1,3,4]]=-3
6053         self.assertEqual([7, -3, 9, -3, -3, 12, -3, 14, -3, -3, 17, -3, 19, -3, -3, 22, -3, 24, -3, -3],da.getValues())
6054         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6055         da2=DataArrayInt.New() ; da2.setValues([0,2,3],3,1)
6056         da[da2]=-7
6057         self.assertEqual([-7, -7, -7, -7, -7, 12, 13, 14, 15, 16, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7],da.getValues())
6058         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6059         da[da2,-2:]=-7
6060         self.assertEqual([7, 8, 9, -7, -7, 12, 13, 14, 15, 16, 17, 18, 19, -7, -7, 22, 23, 24, -7, -7],da.getValues())
6061         # Let's test with DAI right hand side
6062         da1=DataArrayInt.New()
6063         da1.setValues([25,26,27,125,126,127],2,3)
6064         #
6065         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6066         da[-2:,1:4]=da1
6067         self.assertEqual([7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 25, 26, 27, 21, 22, 125, 126, 127, 26],da.getValues())
6068         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6069         da[1:,3]=[225,226,227]
6070         self.assertEqual([7, 8, 9, 10, 11, 12, 13, 14, 225, 16, 17, 18, 19, 226, 21, 22, 23, 24, 227, 26],da.getValues())
6071         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6072         da[1,2:]=[225,226,227]
6073         self.assertEqual([7, 8, 9, 10, 11, 12, 13, 225, 226, 227, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26],da.getValues())
6074         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6075         da[da2,-2:]=[88,99,1010,1111,1212,1313]
6076         self.assertEqual([7, 8, 9, 88, 99, 12, 13, 14, 15, 16, 17, 18, 19, 1010, 1111, 22, 23, 24, 1212, 1313],da.getValues())
6077         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6078         da3=DataArrayInt.New(); da3.setValues([88,99,1010,1111,1212,1313],3,2)
6079         da[da2,-2:]=da3
6080         self.assertEqual([7, 8, 9, 88, 99, 12, 13, 14, 15, 16, 17, 18, 19, 1010, 1111, 22, 23, 24, 1212, 1313],da.getValues())
6081         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6082         da[da2,[0,2]]=da3
6083         self.assertEqual([88, 8, 99, 10, 11, 12, 13, 14, 15, 16, 1010, 18, 1111, 20, 21, 1212, 23, 1313, 25, 26],da.getValues())
6084         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6085         da[da2,0:3:2]=da3
6086         self.assertEqual([88, 8, 99, 10, 11, 12, 13, 14, 15, 16, 1010, 18, 1111, 20, 21, 1212, 23, 1313, 25, 26],da.getValues())
6087         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6088         da[da2,0:3:2]=-8
6089         self.assertEqual([-8, 8, -8, 10, 11, 12, 13, 14, 15, 16, -8, 18, -8, 20, 21, -8, 23, -8, 25, 26],da.getValues())
6090         pass
6091
6092     def testSwigSetItem2(self):
6093         da=DataArrayDouble.New()
6094         da.alloc(20,1)
6095         da.iota(7)
6096         da.rearrange(5)
6097         da.setInfoOnComponent(0,"X [m]") ; da.setInfoOnComponent(1,"Y [km]") ; da.setInfoOnComponent(2,"Y [m]")
6098         da.setInfoOnComponent(3,"Z [W]") ; da.setInfoOnComponent(4,"ZZ [km]") ;
6099         da[:,2]=3.
6100         self.assertEqual([7., 8., 3., 10., 11., 12., 13., 3., 15., 16., 17., 18., 3., 20., 21., 22., 23., 3., 25., 26.],da.getValues())
6101         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6102         da[2]=3.
6103         self.assertEqual([7., 8., 9., 10., 11., 12., 13., 14., 15., 16., 3., 3., 3., 3., 3., 22., 23., 24., 25., 26.],da.getValues())
6104         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6105         da[[0,3]]=-1.
6106         self.assertEqual([-1., -1., -1., -1., -1., 12., 13., 14., 15., 16., 17., 18., 19., 20., 21., -1., -1., -1., -1., -1.],da.getValues())
6107         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6108         da[:,[1,3,4]]=-3.
6109         self.assertEqual([7., -3., 9., -3., -3., 12., -3., 14., -3., -3., 17., -3., 19., -3., -3., 22., -3., 24., -3., -3.],da.getValues())
6110         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6111         da2=DataArrayInt.New() ; da2.setValues([0,2,3],3,1)
6112         da[da2]=-7.
6113         self.assertEqual([-7., -7., -7., -7., -7., 12., 13., 14., 15., 16., -7., -7., -7., -7., -7., -7., -7., -7., -7., -7.],da.getValues())
6114         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6115         da[da2,-2:]=-7
6116         self.assertEqual([7., 8., 9., -7., -7., 12., 13., 14., 15., 16., 17., 18., 19., -7., -7., 22., 23., 24., -7., -7.],da.getValues())
6117         # Let's test with DAI right hand side
6118         da1=DataArrayDouble.New()
6119         da1.setValues([25,26,27,125,126,127],2,3)
6120         #
6121         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6122         da[-2:,1:4]=da1
6123         self.assertEqual([7., 8., 9., 10., 11., 12., 13., 14., 15., 16., 17., 25., 26., 27., 21., 22., 125., 126., 127., 26.],da.getValues())
6124         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6125         da[1:,3]=[225.,226.,227.]
6126         self.assertEqual([7., 8., 9., 10., 11., 12., 13., 14., 225., 16., 17., 18., 19., 226., 21., 22., 23., 24., 227., 26.],da.getValues())
6127         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6128         da[1,2:]=[225,226,227]
6129         self.assertEqual([7., 8., 9., 10., 11., 12., 13., 225., 226., 227., 17., 18., 19., 20., 21., 22., 23., 24., 25., 26.],da.getValues())
6130         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6131         da[da2,-2:]=[88,99,1010,1111,1212,1313]
6132         self.assertEqual([7., 8., 9., 88., 99., 12., 13., 14., 15., 16., 17., 18., 19., 1010., 1111., 22., 23., 24., 1212., 1313.],da.getValues())
6133         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6134         da3=DataArrayDouble.New(); da3.setValues([88,99,1010,1111,1212,1313],3,2)
6135         da[da2,-2:]=da3
6136         self.assertEqual([7., 8., 9., 88., 99., 12., 13., 14., 15., 16., 17., 18., 19., 1010., 1111., 22., 23., 24., 1212., 1313.],da.getValues())
6137         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6138         da[da2,[0,2]]=da3
6139         self.assertEqual([88., 8., 99., 10., 11., 12., 13., 14., 15., 16., 1010., 18., 1111., 20., 21., 1212., 23., 1313., 25., 26.],da.getValues())
6140         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6141         da[da2,0:3:2]=da3
6142         self.assertEqual([88., 8., 99., 10., 11., 12., 13., 14., 15., 16., 1010., 18., 1111., 20., 21., 1212., 23., 1313., 25., 26.],da.getValues())
6143         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6144         da[da2,0:3:2]=-8.
6145         self.assertEqual([-8., 8., -8., 10., 11., 12., 13., 14., 15., 16., -8., 18., -8., 20., 21., -8., 23., -8., 25., 26.],da.getValues())
6146         pass
6147
6148     def testSwigDADOp(self):
6149         da=DataArrayDouble.New()
6150         da.alloc(12,1)
6151         da.iota(7.)
6152         da1=DataArrayDouble.New()
6153         da1.alloc(12,1)
6154         da1.iota(8.)
6155         da2=da+da1
6156         self.assertEqual([15., 17., 19., 21., 23., 25., 27., 29., 31., 33., 35., 37.],da2.getValues())
6157         da2=da+3
6158         da3=3+da
6159         self.assertTrue(da2.isEqual(da3,1e-12))
6160         da2=da-1.
6161         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())
6162         da2=1-da
6163         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())
6164         da2=da*3
6165         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())
6166         da2=3.*da
6167         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())
6168         da2=da*da1
6169         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())
6170         da2=da/4.
6171         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())
6172         da3=4./da
6173         da4=da3*da2
6174         self.assertTrue(da4.isUniform(1.,1e-12))
6175         st1=da.getHiddenCppPointer()
6176         da+=1
6177         st2=da.getHiddenCppPointer()
6178         self.assertEqual(st1,st2)
6179         self.assertTrue(da.isEqual(da1,1e-12))
6180         da-=8
6181         st2=da.getHiddenCppPointer()
6182         self.assertEqual(st1,st2)
6183         self.assertEqual(range(12),da.getValues())
6184         da+=da1
6185         st2=da.getHiddenCppPointer()
6186         self.assertEqual(st1,st2)
6187         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())
6188         da*=0.5
6189         st2=da.getHiddenCppPointer()
6190         self.assertEqual(st1,st2)
6191         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())
6192         da*=da1
6193         st2=da.getHiddenCppPointer()
6194         self.assertEqual(st1,st2)
6195         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())
6196         da/=da1
6197         self.assertEqual(st1,st2)
6198         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())
6199         da/=2
6200         st2=da.getHiddenCppPointer()
6201         self.assertEqual(st1,st2)
6202         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())
6203         da.rearrange(3)
6204         da5=DataArrayDouble.New()
6205         da5.setValues([5.,4.,3.,2.],4,1)
6206         da*=da5 # it works with unmathing number of compo
6207         st2=da.getHiddenCppPointer()
6208         self.assertEqual(st1,st2)
6209         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())
6210         #
6211         da.alloc(30,1)
6212         da.iota(7.)
6213         da.rearrange(3)
6214         ids=DataArrayInt.New()
6215         ids.setValues([3,4,7],3,1)
6216         da[ids,:]=[5.,8.,9.]
6217         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())
6218         #
6219         da.rearrange(1) ; da.iota(7) ; da.rearrange(3)
6220         da[ids,[1,2]]=[5,8]
6221         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())
6222         pass
6223
6224     def testSwigDAIOp(self):
6225         da=DataArrayInt.New()
6226         da.alloc(12,1)
6227         da.iota(7)
6228         da1=DataArrayInt.New()
6229         da1.alloc(12,1)
6230         da1.iota(8)
6231         da2=da+da1
6232         self.assertEqual([15,17,19,21,23,25,27,29,31,33,35,37],da2.getValues())
6233         da2=da+3
6234         da3=3+da
6235         self.assertTrue(da2.isEqual(da3))
6236         da2=da-1
6237         self.assertEqual([6,7,8,9,10,11,12,13,14,15,16,17],da2.getValues())
6238         da2=1-da
6239         self.assertEqual([-6,-7,-8,-9,-10,-11,-12,-13,-14,-15,-16,-17],da2.getValues())
6240         da2=da*3
6241         self.assertEqual([21,24,27,30,33,36,39,42,45,48,51,54.0],da2.getValues())
6242         da2=3*da
6243         self.assertEqual([21,24,27,30,33,36,39,42,45,48,51,54.0],da2.getValues())
6244         da2=da*da1
6245         self.assertEqual([56,72,90,110,132,156,182,210,240,272,306,342.0],da2.getValues())
6246         da2=da/4
6247         self.assertEqual([1,2,2,2,2,3,3,3,3,4,4,4],da2.getValues())
6248         da3=4/da
6249         da4=da3*da2
6250         self.assertTrue(da4.isUniform(0))
6251         st1=da.getHiddenCppPointer()
6252         da+=1
6253         st2=da.getHiddenCppPointer()
6254         self.assertEqual(st1,st2)
6255         self.assertTrue(da.isEqual(da1))
6256         da-=8
6257         st2=da.getHiddenCppPointer()
6258         self.assertEqual(st1,st2)
6259         self.assertEqual(range(12),da.getValues())
6260         da+=da1
6261         st2=da.getHiddenCppPointer()
6262         self.assertEqual(st1,st2)
6263         self.assertEqual([8,10,12,14,16,18,20,22,24,26,28,30],da.getValues())
6264         da/=2
6265         st2=da.getHiddenCppPointer()
6266         self.assertEqual(st1,st2)
6267         self.assertEqual([4,5,6,7,8,9,10,11,12,13,14,15],da.getValues())
6268         da*=da1
6269         st2=da.getHiddenCppPointer()
6270         self.assertEqual(st1,st2)
6271         self.assertEqual([32,45,60,77,96,117,140,165,192,221,252,285],da.getValues())
6272         da/=da1
6273         self.assertEqual(st1,st2)
6274         self.assertEqual([4,5,6,7,8,9,10,11,12,13,14,15],da.getValues())
6275         da/=2
6276         st2=da.getHiddenCppPointer()
6277         self.assertEqual(st1,st2)
6278         self.assertEqual([2,2, 3,3, 4,4, 5,5, 6,6, 7,7],da.getValues())
6279         da.rearrange(3)
6280         da5=DataArrayInt.New()
6281         da5.setValues([5,4,3,2],4,1)
6282         da*=da5 # it works with unmathing number of compo
6283         st2=da.getHiddenCppPointer()
6284         self.assertEqual(st1,st2)
6285         self.assertEqual([10,10, 15,12,16,16,15,15, 18,12,14,14],da.getValues())
6286         da%=6
6287         st2=da.getHiddenCppPointer()
6288         self.assertEqual(st1,st2)
6289         self.assertEqual([4,4,3,0,4,4,3,3,0,0,2,2],da.getValues())
6290         #
6291         da.alloc(30,1)
6292         da.iota(7)
6293         da.rearrange(3)
6294         ids=DataArrayInt.New()
6295         ids.setValues([3,4,7],3,1)
6296         da[ids,:]=[5,8,9]
6297         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())
6298         #
6299         da.rearrange(1) ; da.iota(7) ; da.rearrange(3)
6300         da[ids,[1,2]]=[5,8]
6301         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())
6302         pass
6303
6304     def testSwigDAIOp2(self):
6305         da=DataArrayInt.New()
6306         st=da.getHiddenCppPointer()
6307         da.alloc(10,3)
6308         da.rearrange(1)
6309         da.iota(0)
6310         da.rearrange(3)
6311         da[:,1]+=4
6312         da[-2:,2]+=10
6313         da[-2:,2]+=10
6314         da[:,2]+=da[:,0]
6315         da[da[0],:]=7
6316         self.assertEqual(st,da.getHiddenCppPointer())
6317         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])
6318         pass
6319
6320     def testSwigDAIOp3(self):
6321         da=DataArrayInt.New()
6322         self.assertRaises(InterpKernelException,da.__len__)
6323         self.assertRaises(InterpKernelException,da.__int__)
6324         for elt in da:
6325             self.assertTrue(False)
6326             pass
6327         da.alloc(12,3)
6328         da.rearrange(1) ; da.fillWithZero()
6329         l1=list(da)
6330         self.assertEqual(36,len(da));
6331         da.rearrange(3)
6332         tmp=da[0]
6333         self.assertRaises(InterpKernelException,tmp.__int__)
6334         self.assertEqual(12,len(da));
6335         l=list(da)
6336         for elt in enumerate(l):
6337             elt[1][2]=elt[0]
6338             pass
6339         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]
6340         self.assertEqual(ref,da.getValues());
6341         da.rearrange(1)
6342         l=[int(elt) for elt in l1]
6343         self.assertEqual(ref,da.getValues());
6344         self.assertEqual(11,int(da[-1:]))
6345         pass
6346
6347     def testSwigDADOp3(self):
6348         da=DataArrayDouble.New()
6349         self.assertRaises(InterpKernelException,da.__len__)
6350         self.assertRaises(InterpKernelException,da.__float__)
6351         for elt in da:
6352             self.assertTrue(False)
6353             pass
6354         da.alloc(12,3)
6355         da.rearrange(1) ; da.fillWithZero()
6356         l1=list(da)
6357         self.assertEqual(36,len(da));
6358         da.rearrange(3)
6359         tmp=da[0]
6360         self.assertRaises(InterpKernelException,tmp.__float__)
6361         self.assertEqual(12,len(da));
6362         l=list(da)
6363         for elt in enumerate(l):
6364             elt[1][2]=elt[0]
6365             pass
6366         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.]
6367         self.assertEqual(ref,da.getValues());
6368         da.rearrange(1)
6369         l=[float(elt) for elt in l1]
6370         self.assertEqual(ref,da.getValues());
6371         self.assertEqual(11.,float(da[-1:]))
6372         pass
6373
6374     def testSwigDataArrayIntIterator1(self):
6375         da=DataArrayInt.New()
6376         da.alloc(12,1)
6377         da.iota(2)
6378         da.rearrange(3)
6379         # __getitem__ testing
6380         li=[]
6381         for it in da:
6382             li+=it[1:]
6383             pass
6384         self.assertEqual([3, 4, 6, 7, 9, 10, 12, 13],li)
6385         li=[]
6386         for it in da:
6387             li+=[it[-1]]
6388             pass
6389         self.assertEqual([4, 7, 10, 13],li)
6390         li=[]
6391         for it in da:
6392             li+=it[[2,1,0]]
6393             pass
6394         self.assertEqual([4, 3, 2, 7, 6, 5, 10, 9, 8, 13, 12, 11],li)
6395         # __setitem__ testing
6396         da3=da.deepCpy()
6397         da2=DataArrayInt.New()
6398         da2.alloc(12,1)
6399         da2.iota(2002)
6400         da2.rearrange(3)
6401         it2=da2.__iter__()
6402         i=0
6403         for it in da:
6404             pt=it2.next()
6405             it[:]=pt
6406             pass
6407         self.assertTrue(da.isEqual(da2))
6408         da=da3
6409         da3=da.deepCpy()
6410         #
6411         for it in da:
6412             it[:]=5
6413             pass
6414         da.rearrange(1)
6415         self.assertTrue(da.isUniform(5))
6416         da=da3
6417         da3=da.deepCpy()
6418         #
6419         for it in da:
6420             it[:]=[8,9,12]
6421             pass
6422         self.assertEqual([8, 9, 12, 8, 9, 12, 8, 9, 12, 8, 9, 12],da.getValues())
6423         da=da3
6424         da3=da.deepCpy()
6425         #
6426         for it in da:
6427             it[2]=[7]
6428             pass
6429         self.assertEqual([2, 3, 7, 5, 6, 7, 8, 9, 7, 11, 12, 7],da.getValues())
6430         pass
6431
6432     def testSwigDataArrayDoubleIterator1(self):
6433         da=DataArrayDouble.New()
6434         da.alloc(12,1)
6435         da.iota(2)
6436         da.rearrange(3)
6437         # __getitem__ testing
6438         li=[]
6439         for it in da:
6440             li+=it[1:]
6441             pass
6442         self.assertEqual([3, 4, 6, 7, 9, 10, 12, 13],li)
6443         li=[]
6444         for it in da:
6445             li+=[it[-1]]
6446             pass
6447         self.assertEqual([4, 7, 10, 13],li)
6448         li=[]
6449         for it in da:
6450             li+=it[[2,1,0]]
6451             pass
6452         self.assertEqual([4, 3, 2, 7, 6, 5, 10, 9, 8, 13, 12, 11],li)
6453         # __setitem__ testing
6454         da3=da.deepCpy()
6455         da2=DataArrayDouble.New()
6456         da2.alloc(12,1)
6457         da2.iota(2002)
6458         da2.rearrange(3)
6459         it2=da2.__iter__()
6460         i=0
6461         for it in da:
6462             pt=it2.next()
6463             it[:]=pt
6464             pass
6465         self.assertTrue(da.isEqual(da2,1e-12))
6466         da=da3
6467         da3=da.deepCpy()
6468         #
6469         for it in da:
6470             it[:]=5
6471             pass
6472         da.rearrange(1)
6473         self.assertTrue(da.isUniform(5,1e-12))
6474         da=da3
6475         da3=da.deepCpy()
6476         #
6477         for it in da:
6478             it[:]=[8,9,12]
6479             pass
6480         self.assertEqual([8, 9, 12, 8, 9, 12, 8, 9, 12, 8, 9, 12],da.getValues())
6481         da=da3
6482         da3=da.deepCpy()
6483         #
6484         for it in da:
6485             it[2]=[7]
6486             pass
6487         self.assertEqual([2, 3, 7, 5, 6, 7, 8, 9, 7, 11, 12, 7],da.getValues())
6488         pass
6489
6490     def testSwigUMeshIterator1(self):
6491         m=MEDCouplingDataForTest.build2DTargetMesh_1()
6492         li1=[]
6493         li2=[]
6494         for cell in m:
6495             li1+=cell.getAllConn()[1:]
6496             li2+=[cell.getType()]
6497             pass
6498         self.assertEqual(li1,[0, 3, 4, 1, 1, 4, 2, 4, 5, 2, 6, 7, 4, 3, 7, 8, 5, 4])
6499         self.assertEqual(li2,[4, 3, 3, 4, 4])
6500         pass
6501
6502     def testSwigUMeshIterator2(self):
6503         m=MEDCouplingDataForTest.build2DTargetMesh_1()
6504         self.assertRaises(InterpKernelException,m.cellsByType);
6505         m.rearrange2ConsecutiveCellTypes()
6506         li1=[]
6507         li2=[]
6508         li3=[]
6509         for cellsByType in m.cellsByType():
6510             li1.append(cellsByType.getType())
6511             li2.append(cellsByType.getNumberOfElems())
6512             temp=[]
6513             for cell in cellsByType:
6514                 t=[None,None]
6515                 t[0]=cell.getType()
6516                 t[1]=cell.getAllConn()[1:]
6517                 temp.append(t)
6518                 pass
6519             li3.append(temp)
6520             pass
6521         self.assertEqual(li1,[4, 3])
6522         self.assertEqual(li2,[3, 2])
6523         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)]]])
6524         pass
6525
6526     def testDAIAggregateMulti1(self):
6527         a=DataArrayInt.New()
6528         a.setValues(range(4),2,2)
6529         a.setName("aa")
6530         b=DataArrayInt.New()
6531         b.setValues(range(6),3,2)
6532         c=DataArrayInt.Aggregate([a,b])
6533         self.assertEqual(range(4)+range(6),c.getValues())
6534         self.assertEqual("aa",c.getName())
6535         self.assertEqual(5,c.getNumberOfTuples())
6536         self.assertEqual(2,c.getNumberOfComponents())
6537         pass
6538
6539     def testMergeUMeshes2(self):
6540         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6541         m2=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6542         m3=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6543         #
6544         vec1=[0,2,3]
6545         m2_2=m2.buildPartOfMySelf(vec1,False);
6546         vec2=[1,1]
6547         m3_2=m3.buildPartOfMySelf(vec2,False);
6548         #
6549         ms=[m1,m2_2,m3_2];
6550         #
6551         self.assertRaises(InterpKernelException,MEDCouplingUMesh.MergeUMeshes,ms+[None]);
6552         self.assertRaises(InterpKernelException,MEDCouplingUMesh.MergeUMeshes,ms+[3.4])
6553         m4=MEDCouplingUMesh.MergeUMeshes(ms);
6554         m4.checkCoherency();
6555         self.assertEqual(10,m4.getNumberOfCells());
6556         self.assertEqual(20,m4.getNumberOfNodes());
6557         self.assertEqual(45,m4.getMeshLength());
6558         m4bis=MEDCouplingMesh.MergeMeshes(ms);
6559         self.assertTrue(m4.isEqual(m4bis,1e-12))
6560         del m4bis
6561         #
6562         vec3=[0,1,2,3,4]
6563         m4_1=m4.buildPartOfMySelf(vec3,False);
6564         m4_1.setName(m1.getName());
6565         self.assertTrue(m4_1.isEqual(m1,1e-12));
6566         #
6567         vec4=[5,6,7]
6568         m4_2=m4.buildPartOfMySelf(vec4,False);
6569         cellCor,nodeCor=m4_2.checkGeoEquivalWith(m2_2,10,1e-12);
6570         #
6571         vec5=[8,9]
6572         m4_3=m4.buildPartOfMySelf(vec5,False);
6573         self.assertEqual(2,m4_3.getNumberOfCells());
6574         self.assertEqual(3,m4_3.getNumberOfNodes());
6575         m3_2.zipCoords();
6576         m4_3.setName(m3_2.getName());
6577         self.assertTrue(m4_3.isEqual(m3_2,1e-12));
6578         #
6579         pass
6580
6581     def testBuild0DMeshFromCoords1(self):
6582         sourceCoords=[-0.3,-0.3,0., 0.7,-0.3,0., -0.3,0.7,0., 0.7,0.7,0.]
6583         coo=DataArrayDouble.New();
6584         coo.setValues(sourceCoords,4,3);
6585         coo.setName("My0D");
6586         m=MEDCouplingUMesh.Build0DMeshFromCoords(coo);
6587         m.checkCoherency();
6588         self.assertEqual(4,m.getNumberOfNodes());
6589         self.assertEqual(4,m.getNumberOfCells());
6590         self.assertEqual(3,m.getSpaceDimension());
6591         self.assertEqual(0,m.getMeshDimension());
6592         types1=m.getAllTypes();
6593         self.assertEqual([NORM_POINT1],types1);
6594         for i in xrange(4):
6595             conn=m.getNodeIdsOfCell(i);
6596             self.assertEqual([i],conn);
6597             self.assertTrue(NORM_POINT1==m.getTypeOfCell(i));
6598             pass
6599         self.assertEqual(m.getName(),"My0D");
6600         pass
6601
6602     def testDescriptionInMeshTimeUnit1(self):
6603         text1="totoTTEDD";
6604         m=MEDCouplingDataForTest.build2DTargetMesh_1();
6605         m.setDescription(text1);
6606         self.assertEqual(m.getDescription(),text1);
6607         m2=m.deepCpy();
6608         self.assertTrue(m.isEqual(m2,1e-12));
6609         self.assertEqual(m2.getDescription(),text1);
6610         m2.setDescription("ggg");
6611         self.assertTrue(not m.isEqual(m2,1e-12));
6612         #
6613         f=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
6614         f.setTimeUnit(text1);
6615         self.assertEqual(f.getTimeUnit(),text1);
6616         f2=f.deepCpy();
6617         self.assertEqual(f2.getTimeUnit(),text1);
6618         #
6619         pass
6620
6621     def testMultiFields1(self):
6622         mfs=MEDCouplingDataForTest.buildMultiFields_1();
6623         ms=mfs.getMeshes();
6624         dms,refs=mfs.getDifferentMeshes()
6625         das=mfs.getArrays();
6626         das2,refs2=mfs.getDifferentArrays()
6627         self.assertEqual(5,len(mfs.getFields()))
6628         self.assertEqual(1,len(mfs.getFields()[0].getArrays()));
6629         self.assertEqual(2,len(mfs.getFields()[1].getArrays()));
6630         self.assertEqual(1,len(mfs.getFields()[2].getArrays()));
6631         self.assertEqual(1,len(mfs.getFields()[3].getArrays()));
6632         self.assertEqual(1,len(mfs.getFields()[4].getArrays()));
6633         self.assertEqual(5,len(ms));
6634         self.assertEqual(2,len(dms));
6635         self.assertEqual(6,len(das));
6636         self.assertEqual(5,len(das2));
6637         mfs2=mfs.deepCpy();
6638         self.assertTrue(mfs.isEqual(mfs2,1e-12,1e-12))
6639         pass
6640
6641     def testFieldOverTime1(self):
6642         fs=MEDCouplingDataForTest.buildMultiFields_2();
6643         self.assertRaises(InterpKernelException,MEDCouplingFieldOverTime.New,fs);
6644         f4bis=fs[4].buildNewTimeReprFromThis(ONE_TIME,False);
6645         fs[4]=f4bis;
6646         self.assertRaises(InterpKernelException,MEDCouplingFieldOverTime.New,fs);
6647         f4bis.setTime(2.7,20,21);
6648         fot=MEDCouplingFieldOverTime.New(fs);
6649         dt=fot.getDefinitionTimeZone();
6650         hs=dt.getHotSpotsTime();
6651         self.assertEqual(6,len(hs));
6652         expected1=[0.2,0.7,1.2,1.35,1.7,2.7]
6653         for i in xrange(6):
6654             self.assertAlmostEqual(expected1[i],hs[i],12);
6655             pass
6656         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(0.2);
6657         self.assertEqual(0,meshId);
6658         self.assertEqual(0,arrId);
6659         self.assertEqual(0,arrIdInField);
6660         self.assertEqual(0,fieldId);
6661         #
6662         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(0.7);
6663         self.assertEqual(0,meshId);
6664         self.assertEqual(1,arrId);
6665         self.assertEqual(0,arrIdInField);
6666         self.assertEqual(1,fieldId);
6667         #
6668         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeLeft(1.2);#**** WARNING left here
6669         self.assertEqual(0,meshId);
6670         self.assertEqual(2,arrId);
6671         self.assertEqual(1,arrIdInField);
6672         self.assertEqual(1,fieldId);
6673         #
6674         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(1.2);#**** WARNING right again here
6675         self.assertEqual(1,meshId);
6676         self.assertEqual(3,arrId);
6677         self.assertEqual(0,arrIdInField);
6678         self.assertEqual(2,fieldId);
6679         #
6680         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(1.35);
6681         self.assertEqual(1,meshId);
6682         self.assertEqual(3,arrId);
6683         self.assertEqual(0,arrIdInField);
6684         self.assertEqual(2,fieldId);
6685         #
6686         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(1.7);
6687         self.assertEqual(0,meshId);
6688         self.assertEqual(3,arrId);
6689         self.assertEqual(0,arrIdInField);
6690         self.assertEqual(3,fieldId);
6691         #
6692         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(2.7);
6693         self.assertEqual(1,meshId);
6694         self.assertEqual(4,arrId);
6695         self.assertEqual(0,arrIdInField);
6696         self.assertEqual(4,fieldId);
6697         #
6698         dt2=MEDCouplingDefinitionTime();
6699         self.assertTrue(not dt2.isEqual(dt));
6700         dt2.assign(dt);
6701         dt2.assign(dt);#to check memory management
6702         self.assertTrue(dt2.isEqual(dt));
6703         #
6704         dt3=MEDCouplingDefinitionTime();
6705         #
6706         pass
6707
6708     def testDAICheckAndPreparePermutation1(self):
6709         vals1=[9,10,0,6,4,11,3,7];
6710         expect1=[5,6,0,3,2,7,1,4];
6711         vals2=[9,10,0,6,10,11,3,7];
6712         da=DataArrayInt.New();
6713         da.setValues(vals1,8,1);
6714         da2=da.checkAndPreparePermutation();
6715         self.assertEqual(8,da2.getNumberOfTuples());
6716         self.assertEqual(1,da2.getNumberOfComponents());
6717         for i in xrange(8):
6718             self.assertEqual(expect1[i],da2.getIJ(i,0));
6719             pass
6720         #
6721         da=DataArrayInt.New();
6722         da.alloc(8,1);
6723         da.iota(0);
6724         da2=da.checkAndPreparePermutation();
6725         self.assertEqual(8,da2.getNumberOfTuples());
6726         self.assertEqual(1,da2.getNumberOfComponents());
6727         self.assertTrue(da2.isIdentity());
6728         #
6729         da=DataArrayInt.New();
6730         da.alloc(8,1);
6731         da.setValues(vals2,8,1);
6732         self.assertRaises(InterpKernelException,da.checkAndPreparePermutation);
6733         pass
6734
6735     def testDAIChangeSurjectiveFormat1(self):
6736         vals1=[0,3,2,3,2,2,1,2]
6737         expected1=[0,1,2,6,8]
6738         expected2=[0,  6,  2,4,5,7,  1,3]
6739         da=DataArrayInt.New();
6740         da.setValues(vals1,8,1);
6741         #
6742         da2,da2I=da.changeSurjectiveFormat(4);
6743         self.assertEqual(5,da2I.getNumberOfTuples());
6744         self.assertEqual(8,da2.getNumberOfTuples());
6745         self.assertEqual(expected1,da2I.getValues());
6746         self.assertEqual(expected2,da2.getValues());
6747         #
6748         self.assertRaises(InterpKernelException,da.changeSurjectiveFormat,3);
6749         #
6750         pass
6751
6752     def testUMeshGetCellIdsLyingOnNodes1(self):
6753         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6754         nodeIds1=[1,2,3,4,6]
6755         nodeIds2=[6,7]
6756         da=m.getCellIdsLyingOnNodes(nodeIds1,True);
6757         self.assertEqual(1,da.getNumberOfTuples());
6758         self.assertEqual(1,da.getNumberOfComponents());
6759         self.assertEqual(1,da.getIJ(0,0));
6760         da2=DataArrayInt.New()
6761         da2.setValues(nodeIds2,2,1)
6762         da=m.getCellIdsLyingOnNodes(da2,False);
6763         self.assertEqual(2,da.getNumberOfTuples());
6764         self.assertEqual(1,da.getNumberOfComponents());
6765         self.assertEqual(3,da.getIJ(0,0));
6766         self.assertEqual(4,da.getIJ(1,0));
6767         pass
6768
6769     def testUMeshFindCellIdsOnBoundary1(self):
6770         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6771         da5=m.findCellIdsOnBoundary();
6772         self.assertEqual(5,da5.getNumberOfTuples());
6773         self.assertTrue(da5.isIdentity());
6774         pass
6775
6776     def testMeshSetTime1(self):
6777         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6778         m2=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6779         #
6780         self.assertTrue(m1.isEqual(m2,1e-12));
6781         m1.setTime(3.14,6,7);
6782         tmp3,tmp1,tmp2=m1.getTime();
6783         self.assertEqual(6,tmp1);
6784         self.assertEqual(7,tmp2);
6785         self.assertAlmostEqual(3.14,tmp3,12);
6786         self.assertTrue(not m1.isEqual(m2,1e-12));
6787         m2.setTime(3.14,6,7);
6788         self.assertTrue(m1.isEqual(m2,1e-12));
6789         m1.setTimeUnit("ms");
6790         self.assertTrue(m1.getTimeUnit()=="ms");
6791         m1.setTimeUnit("us");
6792         self.assertTrue(m1.getTimeUnit()=="us");
6793         self.assertTrue(not m1.isEqual(m2,1e-12));
6794         m2.setTimeUnit("us");
6795         self.assertTrue(m1.isEqual(m2,1e-12));
6796         m2.setTime(3.14,6,8);
6797         self.assertTrue(not m1.isEqual(m2,1e-12));
6798         m2.setTime(3.14,7,7);
6799         self.assertTrue(not m1.isEqual(m2,1e-12));
6800         m2.setTime(3.15,6,7);
6801         self.assertTrue(not m1.isEqual(m2,1e-12));
6802         #
6803         m1.setTime(10.34,55,12);
6804         m3=m1.deepCpy();
6805         self.assertTrue(m1.isEqual(m3,1e-12));
6806         tmp3,tmp1,tmp2=m3.getTime();
6807         self.assertEqual(55,tmp1);
6808         self.assertEqual(12,tmp2);
6809         self.assertAlmostEqual(10.34,tmp3,12);
6810         #
6811         # testing CMesh
6812         coo1=[0.,1.,2.,3.5]
6813         a=DataArrayDouble.New();
6814         a.setValues(coo1,4,1);
6815         b=MEDCouplingCMesh.New();
6816         b.setCoordsAt(0,a);
6817         #
6818         b.setTime(5.67,8,100);
6819         tmp3,tmp1,tmp2=b.getTime();
6820         self.assertEqual(8,tmp1);
6821         self.assertEqual(100,tmp2);
6822         self.assertAlmostEqual(5.67,tmp3,12);
6823         c=b.deepCpy();
6824         self.assertTrue(c.isEqual(b,1e-12));
6825         tmp3,tmp1,tmp2=c.getTime();
6826         self.assertEqual(8,tmp1);
6827         self.assertEqual(100,tmp2);
6828         self.assertAlmostEqual(5.67,tmp3,12);
6829         pass
6830
6831     def testApplyFuncTwo1(self):
6832         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6833         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
6834         f1.setMesh(m1);
6835         #
6836         vals=[1.,11.,21.,2.,12.,22.,3.,13.,23.,4.,14.,24.,5.,15.,25.]
6837         da=DataArrayDouble.New();
6838         da.setValues(vals,5,3);
6839         f1.setArray(da);
6840         #
6841         self.assertRaises(InterpKernelException,da.applyFunc2,1,"y+z");
6842         da.setInfoOnComponent(0,"x [m]");
6843         da.setInfoOnComponent(1,"y [mm]");
6844         da.setInfoOnComponent(2,"z [km]");
6845
6846         self.assertRaises(InterpKernelException, da.applyFunc2, 1, "x+y+zz+zzz");
6847         self.assertRaises(InterpKernelException, da.applyFunc2, 1, "toto(x+y)");
6848         self.assertRaises(InterpKernelException, da.applyFunc2, 1, "x/0");
6849
6850         da2=da.applyFunc2(1,"y+z");
6851         self.assertEqual(1,da2.getNumberOfComponents());
6852         self.assertEqual(5,da2.getNumberOfTuples());
6853         expected1=[32.,34.,36.,38.,40.]
6854         for i in xrange(5):
6855             self.assertAlmostEqual(expected1[i],da2.getIJ(0,i),12);
6856             pass
6857         da2=da.applyFunc(1,"y+z");
6858         expected2=[12.,14.,16.,18.,20.]
6859         for i in xrange(5):
6860             self.assertAlmostEqual(expected2[i],da2.getIJ(0,i),12);
6861             pass
6862         #
6863         self.assertEqual(3,f1.getNumberOfComponents());
6864         self.assertEqual(5,f1.getNumberOfTuples());
6865         f1.applyFunc2(1,"y+z");
6866         self.assertEqual(1,f1.getNumberOfComponents());
6867         self.assertEqual(5,f1.getNumberOfTuples());
6868         for i in xrange(5):
6869             self.assertAlmostEqual(expected1[i],f1.getArray().getIJ(0,i),12);
6870             pass
6871         #
6872         pass
6873
6874     def testApplyFuncThree1(self):
6875         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6876         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
6877         f1.setMesh(m1);
6878         #
6879         vals=[1.,11.,21.,2.,12.,22.,3.,13.,23.,4.,14.,24.,5.,15.,25.]
6880         da=DataArrayDouble.New();
6881         da.setValues(vals,5,3);
6882         f1.setArray(da);
6883         #
6884         vs=3*[None];
6885         vs[0]="x"; vs[1]="Y"; vs[2]="z";
6886         self.assertRaises(InterpKernelException, da.applyFunc3, 1, vs, "y+z");
6887         self.assertRaises(InterpKernelException, da.applyFunc3, 1, vs, "x+Y+z+zz+zzz");
6888         self.assertRaises(InterpKernelException, da.applyFunc3, 1, vs, "x/0");
6889         vs[1]="y";
6890         da2=da.applyFunc3(1,vs,"y+z");
6891         expected1=[32.,34.,36.,38.,40.]
6892         for i in xrange(5):
6893             self.assertAlmostEqual(expected1[i],da2.getIJ(0,i),12);
6894             pass
6895         self.assertRaises(InterpKernelException, da.applyFunc3, 1, ["x","y","z","a"],"x+a")
6896         f1.setArray(da);
6897         self.assertEqual(3,f1.getNumberOfComponents());
6898         self.assertEqual(5,f1.getNumberOfTuples());
6899         f1.applyFunc3(1,vs,"y+z");
6900         self.assertEqual(1,f1.getNumberOfComponents());
6901         self.assertEqual(5,f1.getNumberOfTuples());
6902         for i in xrange(5):
6903             self.assertAlmostEqual(expected1[i],f1.getArray().getIJ(0,i),12);
6904             pass
6905         pass
6906
6907     def testFillFromAnalyticTwo1(self):
6908         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6909         self.assertRaises(InterpKernelException,m1.fillFromAnalytic2,ON_NODES,1,"y+z");
6910         m1.getCoords().setInfoOnComponent(0,"x [m]");
6911         m1.getCoords().setInfoOnComponent(1,"y");
6912         m1.getCoords().setInfoOnComponent(2,"z");
6913         f1=m1.fillFromAnalytic2(ON_NODES,1,"y+z");
6914         self.assertEqual(1,f1.getNumberOfComponents());
6915         self.assertEqual(9,f1.getNumberOfTuples());
6916         expected1=[0.2, 0.7, 1.2, 0.7, 1.2, 1.7, 1.2, 1.7, 2.2]
6917         for i in xrange(9):
6918             self.assertAlmostEqual(expected1[i],f1.getArray().getIJ(0,i),12);
6919             pass
6920         pass
6921
6922     def testFillFromAnalyticThree1(self):
6923         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6924         vs=3*[None];
6925         vs[0]="x"; vs[1]="Y"; vs[2]="z";
6926         self.assertRaises(InterpKernelException,m1.fillFromAnalytic3,ON_NODES,1,vs,"y+z");
6927         vs[1]="y";
6928         f1=m1.fillFromAnalytic3(ON_NODES,1,vs,"y+z");
6929         self.assertEqual(1,f1.getNumberOfComponents());
6930         self.assertEqual(9,f1.getNumberOfTuples());
6931         expected1=[0.2, 0.7, 1.2, 0.7, 1.2, 1.7, 1.2, 1.7, 2.2]
6932         for i in xrange(9):
6933             self.assertAlmostEqual(expected1[i],f1.getArray().getIJ(0,i),12);
6934             pass
6935         pass
6936
6937     def testDAUnitVar1(self):
6938         da=DataArrayDouble.New();
6939         da.alloc(1,3);
6940         da.setInfoOnComponent(0,"XPS [m]");
6941         st1=da.getVarOnComponent(0);
6942         self.assertTrue(st1=="XPS");
6943         st2=da.getUnitOnComponent(0);
6944         self.assertTrue(st2=="m");
6945         #
6946         da.setInfoOnComponent(0,"XPS         [m]");
6947         st1=da.getVarOnComponent(0);
6948         self.assertTrue(st1=="XPS");
6949         st2=da.getUnitOnComponent(0);
6950         self.assertTrue(st2=="m");
6951         #
6952         da.setInfoOnComponent(0,"XPP         [m]");
6953         st1=da.getVarOnComponent(0);
6954         self.assertTrue(st1=="XPP");
6955         st2=da.getUnitOnComponent(0);
6956         self.assertTrue(st2=="m");
6957         #
6958         da.setInfoOnComponent(0,"XPP kdep  kefer   [ m  ]");
6959         st1=da.getVarOnComponent(0);
6960         self.assertTrue(st1=="XPP kdep  kefer");
6961         st2=da.getUnitOnComponent(0);
6962         self.assertTrue(st2==" m  ");
6963         #
6964         da.setInfoOnComponent(0,"     XPP k[  dep  k]efer   [ m^ 2/s^3*kJ  ]");
6965         st1=da.getVarOnComponent(0);
6966         self.assertTrue(st1=="     XPP k[  dep  k]efer");
6967         st2=da.getUnitOnComponent(0);
6968         self.assertTrue(st2==" m^ 2/s^3*kJ  ");
6969         #
6970         da.setInfoOnComponent(0,"     XPP kefer   ");
6971         st1=da.getVarOnComponent(0);
6972         self.assertTrue(st1=="     XPP kefer   ");
6973         st2=da.getUnitOnComponent(0);
6974         self.assertTrue(st2=="");
6975         #
6976         da.setInfoOnComponent(0,"temperature( bof)");
6977         st1=da.getVarOnComponent(0);
6978         self.assertTrue(st1=="temperature( bof)");
6979         st2=da.getUnitOnComponent(0);
6980         self.assertTrue(st2=="");
6981         #
6982         da.setInfoOnComponent(0,"kkk [m]");
6983         da.setInfoOnComponent(1,"ppp   [m^2/kJ]");
6984         da.setInfoOnComponent(2,"abcde   [MW/s]");
6985         #
6986         vs=da.getVarsOnComponent();
6987         self.assertEqual(3,len(vs));
6988         self.assertTrue(vs[0]=="kkk");
6989         self.assertTrue(vs[1]=="ppp");
6990         self.assertTrue(vs[2]=="abcde");
6991         vs=da.getUnitsOnComponent();
6992         self.assertEqual(3,len(vs));
6993         self.assertTrue(vs[0]=="m");
6994         self.assertTrue(vs[1]=="m^2/kJ");
6995         self.assertTrue(vs[2]=="MW/s");
6996         pass
6997
6998     def testGaussCoordinates1(self):
6999         #Testing 1D cell types
7000         m1=MEDCouplingDataForTest.build1DMultiTypes_1();
7001         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,ONE_TIME);
7002         f.setMesh(m1);
7003         wg1=[0.3];
7004         gsCoo1=[0.2];
7005         refCoo1=[-1.0,1.0];
7006         f.setGaussLocalizationOnType(NORM_SEG2,refCoo1,gsCoo1,wg1);
7007         wg2=wg1;
7008         gsCoo2=[0.2];
7009         refCoo2=[-1.0,1.0,0.0];
7010         f.setGaussLocalizationOnType(NORM_SEG3,refCoo2,gsCoo2,wg2);
7011         #
7012         resToTest=f.getLocalizationOfDiscr();
7013         self.assertEqual(3,resToTest.getNumberOfComponents());
7014         self.assertEqual(2,resToTest.getNumberOfTuples());
7015         expected1=[0.6,0.6,0.6, 0.6,0.6,0.6]
7016         for i in xrange(6):
7017             self.assertAlmostEqual(expected1[i],resToTest.getIJ(0,i),14);
7018             pass
7019         #
7020         #Testing 2D cell types
7021         m2=MEDCouplingDataForTest.build2DMultiTypes_1();
7022         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,ONE_TIME);
7023         f.setMesh(m2);
7024         wg3=[0.3,0.3];
7025         tria3CooGauss=[ 0.1, 0.8, 0.2, 0.7 ]
7026         gsCoo3=tria3CooGauss
7027         tria3CooRef=[ 0.0, 0.0, 1.0 , 0.0, 0.0, 1.0 ]
7028         refCoo3=tria3CooRef;
7029         f.setGaussLocalizationOnType(NORM_TRI3,refCoo3,gsCoo3,wg3);
7030         wg4=[0.3,0.3,0.3];
7031         tria6CooGauss=[ 0.3, 0.2, 0.2, 0.1, 0.2, 0.4 ]
7032         gsCoo4=tria6CooGauss;
7033         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]
7034         refCoo4=tria6CooRef;
7035         f.setGaussLocalizationOnType(NORM_TRI6,refCoo4,gsCoo4,wg4);
7036         wg5=[0.3,0.3,0.3,0.3];
7037         quad4CooGauss=[ 0.3, 0.2, 0.2, 0.1, 0.2, 0.4, 0.15, 0.27 ]
7038         gsCoo5=quad4CooGauss;
7039         quad4CooRef=[-1.0, 1.0, -1.0, -1.0, 1.0, -1.0, 1.0, 1.0]
7040         refCoo5=quad4CooRef;
7041         f.setGaussLocalizationOnType(NORM_QUAD4,refCoo5,gsCoo5,wg5);
7042         wg6=[0.3,0.3,0.3,0.3];
7043         quad8CooGauss=[ 0.34, 0.16, 0.21, 0.3, 0.23, 0.4, 0.14, 0.37 ]
7044         gsCoo6=quad8CooGauss;
7045         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]
7046         refCoo6=quad8CooRef;
7047         f.setGaussLocalizationOnType(NORM_QUAD8,refCoo6,gsCoo6,wg6);
7048         #
7049         resToTest=f.getLocalizationOfDiscr();
7050         self.assertEqual(3,resToTest.getNumberOfComponents());
7051         self.assertEqual(13,resToTest.getNumberOfTuples());#2+3+4+4 gauss points for resp TRI3,TRI6,QUAD4,QUAD8
7052         expected2=[5.1,1.55,0.0, 4.7,1.65,0.0,
7053                    2.32,1.52,0.0, 1.6,1.32,0.0, 3.52,1.26,0.0,#TRI6
7054                    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
7055                    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
7056         for i in xrange(39):
7057             self.assertAlmostEqual(expected2[i],resToTest.getIJ(0,i),14);
7058             pass
7059         #
7060         #Testing 3D cell types
7061         m3=MEDCouplingDataForTest.build3DMultiTypes_1();
7062         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,ONE_TIME);
7063         f.setMesh(m3);
7064         #
7065         wg7=[0.3];
7066         tetra4CooGauss=[0.34, 0.16, 0.21]
7067         gsCoo7=tetra4CooGauss;
7068         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]
7069         refCoo7=tetra4CooRef;
7070         f.setGaussLocalizationOnType(NORM_TETRA4,refCoo7,gsCoo7,wg7);
7071         wg8=[0.3];
7072         tetra10CooGauss=[0.2, 0.3, 0.1]
7073         gsCoo8=tetra10CooGauss;
7074         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]
7075         refCoo8=tetra10CooRef;
7076         f.setGaussLocalizationOnType(NORM_TETRA10,refCoo8,gsCoo8,wg8);
7077         wg9=[0.3];
7078         pyra5CooGauss=[0.2, 0.3, 0.1]
7079         gsCoo9=pyra5CooGauss;
7080         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]
7081         refCoo9=pyra5CooRef;
7082         f.setGaussLocalizationOnType(NORM_PYRA5,refCoo9,gsCoo9,wg9);
7083         wg10=[0.3];
7084         pyra13CooGauss=[0.1, 0.2, 0.7]
7085         gsCoo10=pyra13CooGauss;
7086         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]
7087         refCoo10=pyra13CooRef;
7088         f.setGaussLocalizationOnType(NORM_PYRA13,refCoo10,gsCoo10,wg10);
7089         wg11=[0.3];
7090         penta6CooGauss=[0.2, 0.3, 0.1]
7091         gsCoo11=penta6CooGauss;
7092         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]
7093         refCoo11=penta6CooRef;
7094         f.setGaussLocalizationOnType(NORM_PENTA6,refCoo11,gsCoo11,wg11);
7095         wg12=[0.3];
7096         penta15CooGauss=[0.2, 0.3,0.15]
7097         gsCoo12=penta15CooGauss;
7098         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]
7099         refCoo12=penta15CooRef;
7100         f.setGaussLocalizationOnType(NORM_PENTA15,refCoo12,gsCoo12,wg12);
7101         wg13=[0.3];
7102         hexa8CooGauss=[0.2,0.3,0.15]
7103         gsCoo13=hexa8CooGauss;
7104         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]
7105         refCoo13=hexa8CooRef;
7106         f.setGaussLocalizationOnType(NORM_HEXA8,refCoo13,gsCoo13,wg13);
7107         wg14=[0.3];
7108         hexa20CooGauss=[0.11,0.3,0.55]
7109         gsCoo14=hexa20CooGauss;
7110         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]
7111         refCoo14=hexa20CooRef;
7112         f.setGaussLocalizationOnType(NORM_HEXA20,refCoo14,gsCoo14,wg14);
7113         #
7114         resToTest=f.getLocalizationOfDiscr();
7115         self.assertEqual(3,resToTest.getNumberOfComponents());
7116         self.assertEqual(8,resToTest.getNumberOfTuples());#2+3+4+4 gauss points for resp TRI3,TRI6,QUAD4,QUAD8
7117         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]
7118         for i in xrange(24):
7119             self.assertAlmostEqual(expected3[i],resToTest.getIJ(0,i),14);
7120             pass
7121         #
7122         pass
7123
7124     def testP2Localization1(self):
7125         m=MEDCouplingUMesh.New("testP2",2);
7126         coords=[0.,2.,3.5,0.,4.5,1.5,1.2,0.32,3.4,1.,2.1,2.4]
7127         conn=[0,1,2,3,4,5]
7128         coo=DataArrayDouble.New();
7129         coo.setValues(coords,6,2);
7130         m.setCoords(coo);
7131         m.allocateCells(1);
7132         m.insertNextCell(NORM_TRI6,6,conn[0:6])
7133         m.finishInsertingCells();
7134         #
7135         f=MEDCouplingFieldDouble.New(ON_NODES,ONE_TIME);
7136         f.setMesh(m);
7137         da=DataArrayDouble.New();
7138         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]
7139         da.setValues(vals1,6,3);
7140         f.setArray(da);
7141         #
7142         loc=[2.27,1.3]
7143         locs=f.getValueOnMulti(loc);
7144         expected1=[6.0921164547752236, 7.1921164547752232, 8.2921164547752255]
7145         for i in xrange(3):
7146             self.assertAlmostEqual(expected1[i],locs.getIJ(0,i),12);
7147             pass
7148         pass
7149
7150     def testP2Localization2(self):
7151         m=MEDCouplingUMesh.New("testP2_2",3);
7152         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]
7153         conn=[0,1,2,3,4,5,6,7,8,9]
7154         coo=DataArrayDouble.New();
7155         coo.setValues(coords,10,3);
7156         m.setCoords(coo);
7157         m.allocateCells(1);
7158         m.insertNextCell(NORM_TETRA10,10,conn[0:10])
7159         m.finishInsertingCells();
7160         #
7161         f=MEDCouplingFieldDouble.New(ON_NODES,ONE_TIME);
7162         f.setMesh(m);
7163         da=DataArrayDouble.New();
7164         vals1=[1.1,2.1,3.1,4.1,5.2,6.2,7.2,8.2,9.2,10.2]
7165         da.setValues(vals1,10,1);
7166         f.setArray(da);
7167         #
7168         loc=[0.64637931739890486, -0.16185896817550552, 0.22678966365273748]
7169         locs=f.getValueOnMulti(loc);
7170         expected1=[10.0844021968047]
7171         for i in xrange(1):
7172             self.assertAlmostEqual(expected1[i],locs.getIJ(0,i),12);
7173             pass
7174         pass
7175
7176     def testGetValueOn2(self):
7177         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7178         f=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
7179         f.setMesh(m);
7180         arr=DataArrayDouble.New();
7181         nbOfCells=m.getNumberOfCells();
7182         f.setArray(arr);
7183         values1=[7.,107.,10007.,8.,108.,10008.,9.,109.,10009.,10.,110.,10010.,11.,111.,10011.]
7184         arr.setValues(values1,nbOfCells,3);
7185         loc=[-0.05,-0.05, 0.55,-0.25, 0.55,0.15, -0.05,0.45, 0.45,0.45]
7186         f.checkCoherency();
7187         locs=f.getValueOnMulti(loc);
7188         self.assertEqual(5,locs.getNumberOfTuples());
7189         self.assertEqual(3,locs.getNumberOfComponents());
7190         for j in xrange(15):
7191             self.assertAlmostEqual(values1[j],locs.getIJ(0,j),12);
7192             pass
7193         # Testing ON_NODES
7194         f=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
7195         f.setMesh(m);
7196         arr=DataArrayDouble.New();
7197         nbOfNodes=m.getNumberOfNodes();
7198         f.setArray(arr);
7199         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.]
7200         arr.setValues(values2,nbOfNodes,3);
7201         loc2=[0.5432,-0.2432, 0.5478,0.1528, 0.5432,-0.2432, 0.5432,-0.2432]
7202         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]
7203         f.checkCoherency();
7204         loc3=DataArrayDouble.New()
7205         loc3.setValues(loc2,4,2);
7206         locs=f.getValueOnMulti(loc3);
7207         self.assertEqual(4,locs.getNumberOfTuples());
7208         self.assertEqual(3,locs.getNumberOfComponents());
7209         for i in xrange(12):
7210             self.assertAlmostEqual(expected2[i],locs.getIJ(0,i),12);
7211             pass
7212         #
7213         pass
7214
7215     def testDAIGetIdsNotEqual1(self):
7216         d=DataArrayInt.New();
7217         vals1=[2,3,5,6,8,5,5,6,1,-5]
7218         d.setValues(vals1,10,1);
7219         d2=d.getIdsNotEqual(5);
7220         self.assertEqual(7,d2.getNumberOfTuples());
7221         self.assertEqual(1,d2.getNumberOfComponents());
7222         expected1=[0,1,3,4,7,8,9]
7223         for i in xrange(7):
7224             self.assertEqual(expected1[i],d2.getIJ(0,i));
7225             pass
7226         d.rearrange(2);
7227         self.assertRaises(InterpKernelException,d.getIdsNotEqual,5);
7228         vals2=[-4,5,6]
7229         vals3=vals2;
7230         d.rearrange(1);
7231         d3=d.getIdsNotEqualList(vals3);
7232         self.assertEqual(5,d3.getNumberOfTuples());
7233         self.assertEqual(1,d3.getNumberOfComponents());
7234         expected2=[0,1,4,8,9]
7235         for i in xrange(5):
7236             self.assertEqual(expected2[i],d3.getIJ(0,i));
7237             pass
7238         pass
7239
7240     def testDAIComputeOffsets1(self):
7241         d=DataArrayInt.New();
7242         vals1=[3,5,1,2,0,8]
7243         expected1=[0,3,8,9,11,11]
7244         d.setValues(vals1,6,1);
7245         d.computeOffsets();
7246         self.assertEqual(6,d.getNumberOfTuples());
7247         self.assertEqual(1,d.getNumberOfComponents());
7248         for i in xrange(6):
7249             self.assertEqual(expected1[i],d.getIJ(0,i));
7250             pass
7251         pass
7252
7253     def testUMeshHexagonPrism1(self):
7254         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,
7255                 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];
7256         conn=[1,2,3,4,5,0,7,8,9,10,11,6]
7257         mesh=MEDCouplingUMesh.New("MyFirstHexagonalPrism",3);
7258         coo=DataArrayDouble.New();
7259         coo.setValues(coords,12,3);
7260         mesh.setCoords(coo);
7261         mesh.allocateCells(1);
7262         mesh.insertNextCell(NORM_HEXGP12,12,conn[0:12])
7263         mesh.finishInsertingCells();
7264         #
7265         mesh.checkCoherency();
7266         vols=mesh.getMeasureField(False);
7267         self.assertEqual(1,vols.getNumberOfTuples());
7268         self.assertEqual(1,vols.getNumberOfComponents());
7269         self.assertAlmostEqual(-5.196152422706632,vols.getIJ(0,0),12);
7270         bary=mesh.getBarycenterAndOwner();
7271         self.assertEqual(1,bary.getNumberOfTuples());
7272         self.assertEqual(3,bary.getNumberOfComponents());
7273         expected1=[0.,0.,1.]
7274         for i in xrange(3):
7275             self.assertAlmostEqual(expected1[i],bary.getIJ(0,i),12);
7276             pass
7277         d1=DataArrayInt.New();
7278         d2=DataArrayInt.New();
7279         d3=DataArrayInt.New();
7280         d4=DataArrayInt.New();
7281         m2=mesh.buildDescendingConnectivity(d1,d2,d3,d4);
7282         self.assertEqual(8,m2.getNumberOfCells());
7283         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]];
7284         expected2=[NORM_POLYGON, NORM_POLYGON, NORM_QUAD4, NORM_QUAD4, NORM_QUAD4, NORM_QUAD4, NORM_QUAD4, NORM_QUAD4];
7285         expected3=[6,6,4,4,4,4,4,4]
7286         for i in xrange(8):
7287             self.assertTrue(m2.getTypeOfCell(i)==expected2[i]);
7288             v=m2.getNodeIdsOfCell(i);
7289             self.assertTrue(len(v)==expected3[i]);
7290             self.assertEqual(expected4[i],v);
7291         #
7292         mesh.convertAllToPoly();
7293         self.assertTrue(NORM_POLYHED==mesh.getTypeOfCell(0));
7294         mesh.unPolyze();
7295         self.assertTrue(NORM_HEXGP12==mesh.getTypeOfCell(0));
7296         self.assertEqual(13,mesh.getMeshLength());
7297         #
7298         pass
7299
7300     def testDADCheckIsMonotonic(self):
7301         da=DataArrayDouble.New();
7302         da.setValues([-1.,1.01,2.03,6.],2,2);
7303         self.assertRaises(InterpKernelException,da.isMonotonic,True,1e-12);
7304         da.rearrange(1);
7305         self.assertTrue(da.isMonotonic(True,1e-12));
7306         da.checkMonotonic(True,1e-12);
7307         da.setIJ(2,0,6.1);
7308         self.assertTrue(not da.isMonotonic(True,1e-12));
7309         self.assertRaises(InterpKernelException,da.checkMonotonic,True,1e-12);
7310         da.setIJ(2,0,5.99);
7311         self.assertTrue(da.isMonotonic(True,1e-12));
7312         self.assertTrue(not da.isMonotonic(True,1e-1));
7313         pass
7314
7315     def testCheckCoherencyDeeper1(self):
7316         m=MEDCouplingDataForTest.build3DSourceMesh_1();
7317         m.checkCoherency();
7318         m.checkCoherency1();
7319         m.getNodalConnectivity().setIJ(8,0,-1);
7320         m.checkCoherency();
7321         self.assertRaises(InterpKernelException,m.checkCoherency1);
7322         m.getNodalConnectivity().setIJ(8,0,-6);
7323         m.checkCoherency();
7324         self.assertRaises(InterpKernelException,m.checkCoherency1);
7325         m.getNodalConnectivity().setIJ(8,0,9);#9>=NbOfNodes
7326         m.checkCoherency();
7327         self.assertRaises(InterpKernelException,m.checkCoherency1);
7328         m.getNodalConnectivity().setIJ(8,0,8);#OK
7329         m.checkCoherency();
7330         m.checkCoherency1();
7331         elts=[1,5]
7332         m.convertToPolyTypes(elts);
7333         m.checkCoherency();
7334         m.checkCoherency1();
7335         m.getNodalConnectivity().setIJ(2,0,9);#9>=NbOfNodes
7336         m.checkCoherency();
7337         self.assertRaises(InterpKernelException,m.checkCoherency1);
7338         m.getNodalConnectivity().setIJ(2,0,-3);
7339         m.checkCoherency();
7340         self.assertRaises(InterpKernelException,m.checkCoherency1);
7341         m.getNodalConnectivity().setIJ(2,0,-1);
7342         m.checkCoherency();
7343         self.assertRaises(InterpKernelException,m.checkCoherency1);#Throw because cell#0 is not a polyhedron
7344         m.getNodalConnectivity().setIJ(2,0,4);
7345         m.checkCoherency();
7346         m.checkCoherency1();
7347         m.getNodalConnectivity().setIJ(7,0,-1);
7348         m.checkCoherency();
7349         m.checkCoherency1();#OK because we are in polyhedron connec
7350         m.getNodalConnectivity().setIJ(36,0,14);
7351         m.checkCoherency();
7352         self.assertRaises(InterpKernelException,m.checkCoherency1);#Throw beacause now cell 5 is a TETRA4 (14) so mimatch of number index and static type.
7353         pass
7354
7355     def testUnPolyze2(self):
7356         m=MEDCouplingUMesh.New("jjj",3);
7357         coo=DataArrayDouble.New();
7358         coo.alloc(4,3);
7359         coo.rearrange(1);
7360         coo.iota(0);
7361         coo.rearrange(3);
7362         m.setCoords(coo);
7363         m.allocateCells(2);
7364         m.insertNextCell(NORM_TETRA4,4,[0,1,2,3]);
7365         m.insertNextCell(NORM_TETRA4,4,[0,1,2,3]);
7366         m.finishInsertingCells();
7367         m2=MEDCouplingUMesh.MergeUMeshesOnSameCoords(4*[m]);
7368         m2.convertToPolyTypes([2]);
7369         m2.unPolyze();
7370         self.assertEqual(NORM_TETRA4,m2.getTypeOfCell(2));
7371         self.assertEqual(40,m2.getMeshLength());
7372         temp2=m2.getNodeIdsOfCell(2);
7373         self.assertEqual(temp2,[0,1,2,3]);
7374         m2.checkCoherency1();
7375         m3=m2.deepCpy();
7376         m2.unPolyze();
7377         self.assertTrue(m3.isEqual(m2,1e-12));
7378         pass
7379
7380     def testDACpyFrom1(self):
7381         d=DataArrayDouble.New();
7382         d.alloc(12,1);
7383         d.iota(14.);
7384         d.rearrange(3);
7385         d.setName("Toto");
7386         d.setInfoOnComponent(0,"X [m]");
7387         d.setInfoOnComponent(1,"Y [m]");
7388         d.setInfoOnComponent(2,"Z [m]");
7389         #
7390         d1=DataArrayDouble.New();
7391         self.assertTrue(not d.isEqual(d1,1e-12));
7392         d1.cpyFrom(d);
7393         self.assertTrue(d.isEqual(d1,1e-12));
7394         d1.cpyFrom(d);
7395         self.assertTrue(d.isEqual(d1,1e-12));
7396         d1.rearrange(2);
7397         self.assertTrue(not d.isEqual(d1,1e-12));
7398         d1.cpyFrom(d);
7399         self.assertTrue(d.isEqual(d1,1e-12));
7400         #
7401         d2=d.convertToIntArr();
7402         d4=DataArrayInt.New();
7403         self.assertTrue(not d2.isEqual(d4));
7404         d4.cpyFrom(d2);
7405         self.assertTrue(d2.isEqual(d4));
7406         d4.cpyFrom(d2);
7407         self.assertTrue(d2.isEqual(d4));
7408         d4.rearrange(2);
7409         self.assertTrue(not d2.isEqual(d4));
7410         d4.cpyFrom(d2);
7411         self.assertTrue(d2.isEqual(d4));
7412         pass
7413
7414     def testDAITransformWithIndArr1(self):
7415         tab1=[17,18,22,19]
7416         tab2=[0,1,1,3,3,0,1,3,2,2,3,0]
7417         expected=[17,18,18,19,19,17,18,19,22,22,19,17]
7418         d=DataArrayInt.New();
7419         d.setValues(tab1,4,1);
7420         d1=DataArrayInt.New();
7421         d1.setValues(tab2,12,1);
7422         d2=d1[:]
7423         #
7424         d1.transformWithIndArr(d);
7425         self.assertEqual(12,d1.getNumberOfTuples());
7426         self.assertEqual(1,d1.getNumberOfComponents());
7427         for i in xrange(12):
7428             self.assertEqual(expected[i],d1.getIJ(i,0));
7429             pass
7430         #
7431         d1=d2
7432         d1.transformWithIndArr(tab1)
7433         self.assertEqual(12,d1.getNumberOfTuples());
7434         self.assertEqual(1,d1.getNumberOfComponents());
7435         for i in xrange(12):
7436             self.assertEqual(expected[i],d1.getIJ(i,0));
7437             pass
7438         pass
7439
7440     def testDAIBuildPermArrPerLevel1(self):
7441         arr=[2,0,1,1,0,1,2,0,1,1,0,0]
7442         expected1=[10,0,5,6,1,7,11,2,8,9,3,4]
7443         da=DataArrayInt.New();
7444         da.setValues(arr,12,1);
7445         da2=da.buildPermArrPerLevel();
7446         self.assertEqual(12,da2.getNumberOfTuples());
7447         self.assertEqual(1,da2.getNumberOfComponents());
7448         for i in xrange(12):
7449             self.assertEqual(expected1[i],da2.getIJ(i,0));
7450             pass
7451         pass
7452
7453     def testDAIOperations1(self):
7454         arr1=[-1,-2,4,7,3,2,6,6,4,3,0,1]
7455         da=DataArrayInt.New();
7456         da.setValues(arr1,4,3);
7457         da1=DataArrayInt.New();
7458         da1.alloc(12,1);
7459         da1.iota(2);
7460         self.assertRaises(InterpKernelException,DataArrayInt.Add,da,da1);#not same number of tuples/Components
7461         da1.rearrange(3);
7462         da2=DataArrayInt.Add(da,da1);
7463         self.assertEqual(4,da2.getNumberOfTuples());
7464         self.assertEqual(3,da2.getNumberOfComponents());
7465         expected1=[1,1,8,12,9,9,14,15,14,14,12,14]
7466         for i in xrange(12):
7467             self.assertEqual(expected1[i],da2.getIJ(0,i));
7468             pass
7469         da1.substractEqual(da);
7470         expected2=[3,5,0,-2,3,5,2,3,6,8,12,12]
7471         for i in xrange(12):
7472             self.assertEqual(expected2[i],da1.getIJ(0,i));
7473             pass
7474         da1.rearrange(1); da1.iota(2); da1.rearrange(3);
7475         da1.addEqual(da);
7476         for i in xrange(12):
7477             self.assertEqual(expected1[i],da1.getIJ(0,i));
7478             pass
7479         da1.rearrange(1); da1.iota(2); da1.rearrange(3);
7480         da2=DataArrayInt.Multiply(da,da1);
7481         self.assertEqual(4,da2.getNumberOfTuples());
7482         self.assertEqual(3,da2.getNumberOfComponents());
7483         expected3=[-2,-6,16,35,18,14,48,54,40,33,0,13]
7484         for i in xrange(12):
7485             self.assertEqual(expected3[i],da2.getIJ(0,i));
7486             pass
7487         da.divideEqual(da1);
7488         self.assertEqual(4,da.getNumberOfTuples());
7489         self.assertEqual(3,da.getNumberOfComponents());
7490         expected4=[0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0]
7491         for i in xrange(12):
7492             self.assertEqual(expected4[i],da.getIJ(0,i));
7493             pass
7494         da.setValues(arr1,4,3);
7495         da1.multiplyEqual(da);
7496         self.assertEqual(4,da1.getNumberOfTuples());
7497         self.assertEqual(3,da1.getNumberOfComponents());
7498         for i in xrange(12):
7499             self.assertEqual(expected3[i],da1.getIJ(0,i));
7500             pass
7501         da1.rearrange(1); da1.iota(2); da1.rearrange(3);
7502         da2=DataArrayInt.Divide(da,da1);
7503         self.assertEqual(4,da2.getNumberOfTuples());
7504         self.assertEqual(3,da2.getNumberOfComponents());
7505         for i in xrange(12):
7506             self.assertEqual(expected4[i],da2.getIJ(0,i));
7507             pass
7508         da1.applyInv(321);
7509         self.assertEqual(4,da1.getNumberOfTuples());
7510         self.assertEqual(3,da1.getNumberOfComponents());
7511         expected5=[160,107,80,64,53,45,40,35,32,29,26,24]
7512         for i in xrange(12):
7513             self.assertEqual(expected5[i],da1.getIJ(0,i));
7514             pass
7515         da1.applyDivideBy(2);
7516         self.assertEqual(4,da1.getNumberOfTuples());
7517         self.assertEqual(3,da1.getNumberOfComponents());
7518         expected6=[80,53,40,32,26,22,20,17,16,14,13,12]
7519         for i in xrange(12):
7520             self.assertEqual(expected6[i],da1.getIJ(0,i));
7521             pass
7522         expected7=[3,4,5,4,5,1,6,3,2,0,6,5]
7523         da1.applyModulus(7);
7524         for i in xrange(12):
7525             self.assertEqual(expected7[i],da1.getIJ(0,i));
7526             pass
7527         da1.applyLin(1,1);
7528         expected8=[3,3,3,3,3,1,3,3,0,0,3,3]
7529         da1.applyRModulus(3);
7530         for i in xrange(12):
7531             self.assertEqual(expected8[i],da1.getIJ(0,i));
7532             pass
7533         pass
7534
7535     def testEmulateMEDMEMBDC1(self):
7536         m,m1=MEDCouplingDataForTest.buildPointe_1();
7537         m2,da1,da2,da3,da4,da5,da0=m.emulateMEDMEMBDC(m1)
7538         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]
7539         expected1=[1,32,29,23,41,36]
7540         self.assertEqual(47,da0.getNumberOfTuples());
7541         self.assertEqual(1,da0.getNumberOfComponents());
7542         for i in xrange(47):
7543             self.assertEqual(expected0[i],da0.getIJ(0,i));
7544             pass
7545         self.assertEqual(6,da5.getNumberOfTuples());
7546         self.assertEqual(1,da5.getNumberOfComponents());
7547         for i in xrange(6):
7548             self.assertEqual(expected1[i],da5.getIJ(0,i));
7549             pass
7550         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]
7551         self.assertEqual(70,da1.getNumberOfTuples());
7552         self.assertEqual(1,da1.getNumberOfComponents());
7553         for i in xrange(70):
7554             self.assertEqual(expected2[i],da1.getIJ(0,i));
7555             pass
7556         expected3=[0,4,8,12,16,20,24,28,32,36,40,44,48,53,58,64,70]
7557         self.assertEqual(17,da2.getNumberOfTuples());
7558         self.assertEqual(1,da2.getNumberOfComponents());
7559         for i in xrange(17):
7560             self.assertEqual(expected3[i],da2.getIJ(0,i));
7561             pass
7562         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]
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,54,56,57,58,59,60,62,63,64,65,66,67,68,69,70];
7564         self.assertEqual(48,da4.getNumberOfTuples());
7565         self.assertEqual(1,da4.getNumberOfComponents());
7566         for i in xrange(48):
7567             self.assertEqual(expected4[i],da4.getIJ(0,i));
7568             pass
7569         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]
7570         self.assertEqual(70,da3.getNumberOfTuples());
7571         self.assertEqual(1,da3.getNumberOfComponents());
7572         for i in xrange(70):
7573             self.assertEqual(expected5[i],da3.getIJ(0,i));
7574             pass
7575         pass
7576
7577     def testGetLevArrPerCellTypes1(self):
7578         m,m1=MEDCouplingDataForTest.buildPointe_1();
7579         m1,d0,d1,d2,d3=m.buildDescendingConnectivity();
7580         order=[NORM_TRI3,NORM_QUAD4];
7581         da0,da1=m1.getLevArrPerCellTypes(order);
7582         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]
7583         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]
7584         self.assertEqual(47,da0.getNumberOfTuples());
7585         self.assertEqual(1,da0.getNumberOfComponents());
7586         for i in xrange(47):
7587             self.assertEqual(expected0[i],da0.getIJ(0,i));
7588             pass
7589         self.assertEqual(2,da1.getNumberOfTuples());
7590         self.assertEqual(1,da1.getNumberOfComponents());
7591         self.assertEqual(36,da1.getIJ(0,0));#36 TRI3
7592         self.assertEqual(11,da1.getIJ(1,0));#11 QUAD4
7593         #
7594         da2=da0.buildPermArrPerLevel();
7595         #
7596         self.assertEqual(47,da2.getNumberOfTuples());
7597         self.assertEqual(1,da2.getNumberOfComponents());
7598         for i in xrange(47):
7599             self.assertEqual(expected1[i],da2.getIJ(0,i));
7600             pass
7601         pass
7602
7603     def testSortCellsInMEDFileFrmt1(self):
7604         m,m1=MEDCouplingDataForTest.buildPointe_1();
7605         m2=m.deepCpy()
7606         da=DataArrayInt.New()
7607         da.setValues([0,1,2,14,3,12,4,5,15,6,7,8,9,10,11,13],16,1)
7608         daa=da.invertArrayN2O2O2N(16)
7609         m.renumberCells(daa,False)
7610         da2=m.sortCellsInMEDFileFrmt()
7611         self.assertEqual(da2.getValues(),[0,1,2,14,3,12,4,5,15,6,7,8,9,10,11,13])
7612         self.assertTrue(m.isEqual(m2,1e-12))
7613         self.assertTrue(da.isEqual(da2))
7614         pass
7615
7616     def testBuildPartAndReduceNodes1(self):
7617         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7618         arr=[1,0]
7619         m2,da=m.buildPartAndReduceNodes(arr);
7620         self.assertEqual(5,m2.getNumberOfNodes());
7621         self.assertEqual(2,m2.getNumberOfCells());
7622         f=m2.getMeasureField(True);
7623         self.assertAlmostEqual(0.125,f.getArray().getIJ(0,0),12);
7624         self.assertAlmostEqual(0.25,f.getArray().getIJ(1,0),12);
7625         #
7626         arr2=DataArrayInt.New()
7627         arr2.setValues(arr,2,1)
7628         m2,da=m.buildPartAndReduceNodes(arr2);
7629         self.assertEqual(5,m2.getNumberOfNodes());
7630         self.assertEqual(2,m2.getNumberOfCells());
7631         f=m2.getMeasureField(True);
7632         self.assertAlmostEqual(0.125,f.getArray().getIJ(0,0),12);
7633         self.assertAlmostEqual(0.25,f.getArray().getIJ(1,0),12);
7634         pass
7635
7636     def testDAITransformWithIndArrR1(self):
7637         tab1=[2,4,5,3,6,7]
7638         tab2=[-1,-1,0,1,2,3,4,5,-1,-1,-1,-1]
7639         expected=[0,3,1,2,4,5]
7640         d=DataArrayInt.New();
7641         d.setValues(tab1,6,1);
7642         d1=DataArrayInt.New();
7643         d1.setValues(tab2,12,1);
7644         d2=d1[:]
7645         #
7646         d3=d.transformWithIndArrR(d1);
7647         self.assertEqual(6,d3.getNumberOfTuples());
7648         self.assertEqual(1,d3.getNumberOfComponents());
7649         for i in xrange(6):
7650             self.assertEqual(expected[i],d3.getIJ(i,0));
7651             pass
7652         #
7653         d1=d2
7654         d3=d.transformWithIndArrR(tab2)
7655         self.assertEqual(6,d3.getNumberOfTuples());
7656         self.assertEqual(1,d3.getNumberOfComponents());
7657         for i in xrange(6):
7658             self.assertEqual(expected[i],d3.getIJ(i,0));
7659             pass
7660         pass
7661
7662     def testDAISplitByValueRange1(self):
7663         val1=[6,5,0,3,2,7,8,1,4]
7664         val2=[0,4,9]
7665         d=DataArrayInt.New();
7666         d.setValues(val1,9,1);
7667         e,f,g=d.splitByValueRange(val2);
7668         self.assertEqual(9,e.getNumberOfTuples());
7669         self.assertEqual(1,e.getNumberOfComponents());
7670         self.assertEqual(9,f.getNumberOfTuples());
7671         self.assertEqual(1,f.getNumberOfComponents());
7672         self.assertEqual(2,g.getNumberOfTuples());
7673         self.assertEqual(1,g.getNumberOfComponents());
7674         #
7675         expected1=[1,1,0,0,0,1,1,0,1]
7676         expected2=[2,1,0,3,2,3,4,1,0]
7677         for i in xrange(9):
7678             self.assertEqual(expected1[i],e.getIJ(i,0));
7679             self.assertEqual(expected2[i],f.getIJ(i,0));
7680             pass
7681         self.assertEqual(0,g.getIJ(0,0));
7682         self.assertEqual(1,g.getIJ(1,0));
7683         #
7684         d.setIJ(6,0,9);
7685         self.assertRaises(InterpKernelException,d.splitByValueRange,val2);
7686         pass
7687
7688     def testUMeshSplitProfilePerType1(self):
7689         val0=[2,0,1,3,4]
7690         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7691         m.renumberCells(val0,False);
7692         #
7693         val1=[0,2,3]
7694         d=DataArrayInt.New();
7695         d.setValues(val1,3,1);
7696         d.setName("sup")
7697         code,idsInPflPerType,pfls=m.splitProfilePerType(d);
7698         self.assertEqual(6,len(code));
7699         self.assertEqual(2,len(idsInPflPerType));
7700         expected1=[3,1,0, 4,2,1]
7701         for i in xrange(6):
7702             self.assertEqual(expected1[i],code[i]);
7703             pass
7704         self.assertEqual(2,len(idsInPflPerType));
7705         self.assertEqual(1,idsInPflPerType[0].getNumberOfTuples());
7706         self.assertEqual(0,idsInPflPerType[0].getIJ(0,0));
7707         self.assertEqual(2,idsInPflPerType[1].getNumberOfTuples());
7708         self.assertEqual(1,idsInPflPerType[1].getIJ(0,0));
7709         self.assertEqual(2,idsInPflPerType[1].getIJ(1,0));
7710         #
7711         self.assertEqual(2,len(pfls));
7712         self.assertEqual("sup",pfls[0].getName())
7713         self.assertEqual(1,pfls[0].getNumberOfTuples());
7714         self.assertEqual(0,pfls[0].getIJ(0,0));
7715         self.assertEqual("sup",pfls[1].getName())
7716         self.assertEqual(2,pfls[1].getNumberOfTuples());
7717         self.assertEqual(0,pfls[1].getIJ(0,0));
7718         self.assertEqual(1,pfls[1].getIJ(1,0));
7719         #
7720         val2=[0,2,3,4]
7721         d=DataArrayInt.New();
7722         d.setValues(val2,4,1);
7723         code,idsInPflPerType,pfls=m.splitProfilePerType(d);
7724         self.assertEqual(6,len(code));
7725         self.assertEqual(2,len(idsInPflPerType));
7726         expected2=[3,1,0, 4,3,-1]
7727         for i in xrange(6):
7728             self.assertEqual(expected2[i],code[i]);
7729             pass
7730         self.assertEqual(2,len(idsInPflPerType));
7731         self.assertEqual(1,idsInPflPerType[0].getNumberOfTuples());
7732         self.assertEqual(0,idsInPflPerType[0].getIJ(0,0));
7733         self.assertEqual(3,idsInPflPerType[1].getNumberOfTuples());
7734         self.assertEqual(1,idsInPflPerType[1].getIJ(0,0));
7735         self.assertEqual(2,idsInPflPerType[1].getIJ(1,0));
7736         self.assertEqual(3,idsInPflPerType[1].getIJ(2,0));
7737         #
7738         self.assertEqual(1,len(pfls));
7739         self.assertEqual(1,pfls[0].getNumberOfTuples());
7740         self.assertEqual(0,pfls[0].getIJ(0,0));
7741         #
7742         val3=[1,0,2]
7743         d=DataArrayInt.New();
7744         d.setValues(val3,3,1);
7745         code,idsInPflPerType,pfls=m.splitProfilePerType(d);
7746         self.assertEqual(6,len(code));
7747         self.assertEqual(2,len(idsInPflPerType));
7748         expected3=[3,2,0, 4,1,1]
7749         for i in xrange(6):
7750             self.assertEqual(expected3[i],code[i]);
7751             pass
7752         self.assertEqual(2,len(idsInPflPerType));
7753         self.assertEqual(2,idsInPflPerType[0].getNumberOfTuples());
7754         self.assertEqual(0,idsInPflPerType[0].getIJ(0,0));
7755         self.assertEqual(1,idsInPflPerType[0].getIJ(1,0));
7756         self.assertEqual(1,idsInPflPerType[1].getNumberOfTuples());
7757         self.assertEqual(2,idsInPflPerType[1].getIJ(0,0));
7758         #
7759         self.assertEqual(2,len(pfls));
7760         self.assertEqual(2,pfls[0].getNumberOfTuples());
7761         self.assertEqual(1,pfls[0].getIJ(0,0));
7762         self.assertEqual(0,pfls[0].getIJ(1,0));
7763         self.assertEqual(0,pfls[1].getIJ(0,0));
7764         #
7765         val4=[3,4]
7766         d=DataArrayInt.New();
7767         d.setValues(val4,2,1);
7768         code,idsInPflPerType,pfls=m.splitProfilePerType(d);
7769         self.assertEqual(3,len(code));
7770         self.assertEqual(1,len(idsInPflPerType));
7771         expected4=[4,2,0]
7772         for i in xrange(3):
7773             self.assertEqual(expected4[i],code[i]);
7774             pass
7775         self.assertEqual(1,len(idsInPflPerType));
7776         self.assertEqual(2,idsInPflPerType[0].getNumberOfTuples());
7777         self.assertEqual(0,idsInPflPerType[0].getIJ(0,0));
7778         self.assertEqual(1,idsInPflPerType[0].getIJ(1,0));
7779         #
7780         self.assertEqual(1,len(pfls));
7781         self.assertEqual(2,pfls[0].getNumberOfTuples());
7782         self.assertEqual(1,pfls[0].getIJ(0,0));
7783         self.assertEqual(2,pfls[0].getIJ(1,0));
7784         pass
7785
7786     def testDAIBuildExplicitArrByRanges1(self):
7787         d=DataArrayInt.New();
7788         vals1=[0,2,3]
7789         d.setValues(vals1,3,1);
7790         e=DataArrayInt.New();
7791         vals2=[0,3,6,10,14,20]
7792         e.setValues(vals2,6,1);
7793         #
7794         f=d.buildExplicitArrByRanges(e);
7795         self.assertEqual(11,f.getNumberOfTuples());
7796         self.assertEqual(1,f.getNumberOfComponents());
7797         expected1=[0,1,2,6,7,8,9,10,11,12,13]
7798         for i in xrange(11):
7799             self.assertEqual(expected1[i],f.getIJ(i,0));
7800             pass
7801         pass
7802
7803     def testDAIComputeOffsets2(self):
7804         d=DataArrayInt.New();
7805         vals1=[3,5,1,2,0,8]
7806         expected1=[0,3,8,9,11,11,19]
7807         d.setValues(vals1,6,1);
7808         d.computeOffsets2();
7809         self.assertEqual(7,d.getNumberOfTuples());
7810         self.assertEqual(1,d.getNumberOfComponents());
7811         for i in xrange(7):
7812             self.assertEqual(expected1[i],d.getIJ(0,i));
7813             pass
7814         pass
7815
7816     def testMergeField3(self):
7817         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7818         m.getCoords().setInfoOnComponent(0,"x [m]");
7819         m.getCoords().setInfoOnComponent(1,"z [km]");
7820         m.setName("m");
7821         m.setDescription("desc");
7822         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
7823         f1.setName("f1");
7824         f1.setMesh(m);
7825         arr=DataArrayDouble.New();
7826         arr.alloc(5,2);
7827         arr.setInfoOnComponent(0,"X [m]");
7828         arr.setInfoOnComponent(1,"YY [mm]");
7829         arr.fillWithValue(2.);
7830         f1.setArray(arr);
7831         #
7832         f2=MEDCouplingFieldDouble.MergeFields([f1]);
7833         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
7834         #
7835         pass
7836
7837     def testGetDistributionOfTypes1(self):
7838         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7839         tab1=[2,0,1,3,4]
7840         self.assertRaises(InterpKernelException,m.getDistributionOfTypes);
7841         m.renumberCells(tab1,False);
7842         code=m.getDistributionOfTypes();
7843         self.assertEqual(2,len(code));
7844         self.assertEqual(3,code[0][0]);
7845         self.assertEqual(2,code[0][1]);
7846         self.assertEqual(0,code[0][2]);
7847         self.assertEqual(4,code[1][0]);
7848         self.assertEqual(3,code[1][1]);
7849         self.assertEqual(0,code[1][2]);
7850         pass
7851
7852     def testNorm2_1(self):
7853         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7854         f=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
7855         f.setMesh(m);
7856         #
7857         d=DataArrayDouble.New();
7858         tab=[1.2,1.3,2.2,2.3,3.2,3.3,4.2,4.3,5.2,5.3]
7859         d.setValues(tab,5,2);
7860         f.setArray(d);
7861         f.checkCoherency();
7862         #
7863         self.assertAlmostEqual(11.209371079592289,f.norm2(),14);
7864         #
7865         pass
7866
7867     def testNormMax1(self):
7868         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7869         f=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
7870         f.setMesh(m);
7871         #
7872         d=DataArrayDouble.New();
7873         tab=[2.3,-1.2,6.3,-7.8,2.9,7.7,2.1,0.,3.6,-7.6]
7874         d.setValues(tab,5,2);
7875         f.setArray(d);
7876         f.checkCoherency();
7877         #
7878         self.assertAlmostEqual(7.8,f.normMax(),14);
7879         #
7880         pass
7881
7882     def testFindAndCorrectBadOriented3DExtrudedCells1(self):
7883         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];
7884         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]
7885         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]
7886         invalidCells=[2,3,6,7]
7887         m=MEDCouplingUMesh.New("Example",3);
7888         coo=DataArrayDouble.New();
7889         coo.setValues(coords,38,3);
7890         m.setCoords(coo);
7891         m.allocateCells(8);
7892         m.insertNextCell(NORM_PENTA6,6,conn[0:6])
7893         m.insertNextCell(NORM_PENTA6,6,conn[6:12])
7894         m.insertNextCell(NORM_PENTA6,6,conn[12:18])
7895         m.insertNextCell(NORM_PENTA6,6,conn[18:24])
7896         m.insertNextCell(NORM_HEXA8,8,conn[24:32])
7897         m.insertNextCell(NORM_HEXA8,8,conn[32:40])
7898         m.insertNextCell(NORM_HEXA8,8,conn[40:48])
7899         m.insertNextCell(NORM_HEXA8,8,conn[48:56])
7900         m.finishInsertingCells();
7901         #
7902         v=m.findAndCorrectBadOriented3DExtrudedCells();
7903         self.assertEqual(4,len(v));
7904         self.assertEqual(v.getValues(),invalidCells);
7905         self.assertEqual(connExp,m.getNodalConnectivity().getValues());
7906         #
7907         pass
7908
7909     def testConvertExtrudedPolyhedra1(self):
7910         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]
7911         m=MEDCouplingUMesh.New("Example",3);
7912         coo=DataArrayDouble.New();
7913         coo.alloc(73,3);
7914         coo.rearrange(1); coo.iota(0); coo.rearrange(3);
7915         m.setCoords(coo);
7916         m.allocateCells(9);
7917         m.insertNextCell(NORM_TETRA4,4,conn[0:4])
7918         m.insertNextCell(NORM_HEXA8,8,conn[4:12])
7919         m.insertNextCell(NORM_TETRA4,4,conn[12:16])
7920         m.insertNextCell(NORM_POLYHED,6,conn[16:22])
7921         m.insertNextCell(NORM_PENTA6,6,conn[22:28])
7922         m.insertNextCell(NORM_POLYHED,10,conn[28:38])
7923         m.insertNextCell(NORM_HEXA8,8,conn[38:46])
7924         m.insertNextCell(NORM_HEXGP12,12,conn[46:58])
7925         m.insertNextCell(NORM_POLYHED,14,conn[58:72])
7926         m.finishInsertingCells();
7927         #
7928         m.convertExtrudedPolyhedra();
7929         da=m.getNodalConnectivity();
7930         dai=m.getNodalConnectivityIndex();
7931         self.assertEqual(10,dai.getNbOfElems());
7932         self.assertEqual(159,da.getNbOfElems());
7933         #
7934         expected1=[14, 1, 2, 3, 4,
7935                    18, 5, 6, 7, 8, 9, 10, 11, 12,
7936                    14, 13, 14, 15, 16,
7937                    31, 17, 18, 19, -1, 20, 22, 21, -1, 17, 18, 21, 20, -1, 18, 19, 22, 21, -1, 19, 17, 20, 22,
7938                    16, 23, 24, 25, 26, 27, 28,
7939                    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,
7940                    18, 39, 40, 41, 42, 43, 44, 45, 46,
7941                    22, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
7942                    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];
7943         expected2=[0,5,14,19,42,49,86,95,108,159]
7944         self.assertEqual(expected1,da.getValues());
7945         self.assertEqual(expected2,dai.getValues());
7946         m.checkCoherency2()
7947         pass
7948
7949     def testNonRegressionCopyTinyStrings(self):
7950         m=MEDCouplingDataForTest.build2DTargetMesh_1()
7951         f1=m.getMeasureField(True)
7952         f1.getArray().setInfoOnComponent(0,"P [N/m^2]")
7953         bary=m.getBarycenterAndOwner()
7954         f2=f1.buildNewTimeReprFromThis(ONE_TIME,False)
7955         f2.setArray(bary)
7956         self.assertRaises(InterpKernelException,f2.copyTinyAttrFrom,f1)
7957         pass
7958
7959     def testDaDSetPartOfValuesAdv1(self):
7960         tab1=[3.,4.,5., 13.,14.,15., 23.,24.,25., 33.,34.,35., 43.,44.,45., 53.,54.,55.]
7961         tab2=[6.,7.,8., 16.,17.,18., 26.,27.,28.]
7962         tab3=[4,1, 2,2, 3,0]
7963         a=DataArrayDouble.New();
7964         a.setValues(tab1,6,3);
7965         b=DataArrayDouble.New();
7966         b.setValues(tab2,3,3);
7967         c=DataArrayInt.New();
7968         c.setValues(tab3,3,2);
7969         #
7970         a.setPartOfValuesAdv(b,c);
7971         expected1=[3.,4.,5., 13.,14.,15., 26.,27.,28., 6.,7.,8., 16.,17.,18., 53.,54.,55.]
7972         self.assertEqual(expected1,a.getValues());
7973         pass
7974
7975     def testUMeshBuildSetInstanceFromThis1(self):
7976         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
7977         m2=m.buildSetInstanceFromThis(3);
7978         self.assertTrue(m.isEqual(m2,1e-12));
7979         #
7980         m=MEDCouplingUMesh.New("toto",2);
7981         m2=m.buildSetInstanceFromThis(3);
7982         self.assertEqual(0,m2.getNumberOfNodes());
7983         self.assertEqual(0,m2.getNumberOfCells());
7984         pass
7985
7986     def testUMeshMergeMeshesCVW1(self):
7987         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
7988         m2=MEDCouplingUMesh.New("toto",2);
7989         m3=MEDCouplingUMesh.MergeUMeshes([m,m2]);
7990         m3.setName(m.getName());
7991         self.assertTrue(m.isEqual(m3,1e-12));
7992         pass
7993
7994     def testChangeUnderlyingMeshWithCMesh1(self):
7995         mesh=MEDCouplingCMesh.New();
7996         coordsX=DataArrayDouble.New();
7997         arrX=[ -1., 1., 2., 4. ]
7998         coordsX.setValues(arrX,4,1);
7999         coordsY=DataArrayDouble.New();
8000         arrY=[ -2., 2., 4., 8. ]
8001         coordsY.setValues(arrY,4,1);
8002         coordsZ=DataArrayDouble.New();
8003         arrZ=[ -3., 3., 6., 12. ]
8004         coordsZ.setValues(arrZ,4,1);
8005         mesh.setCoords(coordsX,coordsY,coordsZ);
8006         f=mesh.getMeasureField(True)
8007         mesh2=mesh.deepCpy()
8008         for myId in [0,1,2,10,11,12,20,21,22]:
8009             f=mesh.getMeasureField(True)
8010             f.changeUnderlyingMesh(mesh2,myId,1e-12);
8011             pass
8012         mesh2.setName("uuuu")
8013         for myId in [1,2,10,11,12,20,21,22]:
8014             f=mesh.getMeasureField(True)
8015             f.changeUnderlyingMesh(mesh2,myId,1e-12);
8016             pass
8017         pass
8018
8019     def testDADFindCommonTuples1(self):
8020         da=DataArrayDouble.New();
8021         # nbOftuples=1
8022         array1=[2.3,1.2,1.3,2.3,2.301,0.8]
8023         da.setValues(array1,6,1)
8024         c,cI=da.findCommonTuples(1e-2);
8025         expected1=[0,3,4]
8026         expected2=[0,3]
8027         self.assertEqual(3,c.getNbOfElems());
8028         self.assertEqual(2,cI.getNbOfElems());
8029         self.assertEqual(expected1,c.getValues())
8030         self.assertEqual(expected2,cI.getValues())
8031         c,cI=da.findCommonTuples(2e-1)
8032         expected3=[0,3,4,1,2]
8033         expected4=[0,3,5]
8034         self.assertEqual(5,c.getNbOfElems());
8035         self.assertEqual(3,cI.getNbOfElems());
8036         self.assertEqual(expected3,c.getValues())
8037         self.assertEqual(expected4,cI.getValues())
8038         # nbOftuples=2
8039         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]
8040         da.setValues(array2,6,2)
8041         c,cI=da.findCommonTuples(1e-2);
8042         self.assertEqual(3,c.getNbOfElems());
8043         self.assertEqual(2,cI.getNbOfElems());
8044         self.assertEqual(expected1,c.getValues())
8045         self.assertEqual(expected2,cI.getValues())
8046         c,cI=da.findCommonTuples(2e-1)
8047         self.assertEqual(5,c.getNbOfElems());
8048         self.assertEqual(3,cI.getNbOfElems());
8049         self.assertEqual(expected3,c.getValues())
8050         self.assertEqual(expected4,cI.getValues())
8051         # nbOftuples=3
8052         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]
8053         da.setValues(array3,6,3)
8054         c,cI=da.findCommonTuples(1e-2);
8055         self.assertEqual(3,c.getNbOfElems());
8056         self.assertEqual(2,cI.getNbOfElems());
8057         self.assertEqual(expected1,c.getValues())
8058         self.assertEqual(expected2,cI.getValues())
8059         c,cI=da.findCommonTuples(2e-1)
8060         self.assertEqual(5,c.getNbOfElems());
8061         self.assertEqual(3,cI.getNbOfElems());
8062         self.assertEqual(expected3,c.getValues())
8063         self.assertEqual(expected4,cI.getValues())
8064         # nbOftuples=1, no common groups
8065         array11=[2.3,1.2,1.3,2.4,2.5,0.8]
8066         da.setValues(array11,6,1)
8067         c,cI=da.findCommonTuples(1e-2);
8068         self.assertEqual(0,c.getNbOfElems());
8069         self.assertEqual(1,cI.getNbOfElems());
8070         self.assertEqual([0],cI.getValues())
8071
8072         array12=[0.]*(6*4)
8073         da.setValues(array12,6,4) #bad NumberOfComponents
8074         self.assertRaises(InterpKernelException, da.findCommonTuples, 1e-2);
8075         pass
8076
8077     def testDABack1(self):
8078         da=DataArrayDouble.New();
8079         array1=[2.3,1.2,1.3,2.3,2.301,0.8]
8080         da.setValues(array1,6,1);
8081         self.assertAlmostEqual(0.8,da.back(),14);
8082         da.rearrange(2);
8083         self.assertRaises(InterpKernelException,da.back);
8084         da.alloc(0,1);
8085         self.assertRaises(InterpKernelException,da.back);
8086         #
8087         da=DataArrayInt.New();
8088         array2=[4,7,8,2]
8089         da.setValues(array2,4,1);
8090         self.assertEqual(2,da.back());
8091         da.rearrange(2);
8092         self.assertRaises(InterpKernelException,da.back);
8093         da.alloc(0,1);
8094         self.assertRaises(InterpKernelException,da.back);
8095         pass
8096
8097     def testDADGetDifferentValues1(self):
8098         da=DataArrayDouble.New();
8099         array1=[2.3,1.2,1.3,2.3,2.301,0.8]
8100         da.setValues(array1,6,1)
8101         #
8102         expected1=[2.301,1.2,1.3,0.8]
8103         dv=da.getDifferentValues(1e-2);
8104         self.assertEqual(4,dv.getNbOfElems());
8105         for i in xrange(4):
8106             self.assertAlmostEqual(expected1[i],dv.getIJ(i,0),14);
8107             pass
8108         #
8109         dv=da.getDifferentValues(2e-1);
8110         expected2=[2.301,1.3,0.8]
8111         self.assertEqual(3,dv.getNbOfElems());
8112         for i in xrange(3):
8113             self.assertAlmostEqual(expected2[i],dv.getIJ(i,0),14);
8114             pass
8115         pass
8116
8117     def testDAIBuildOld2NewArrayFromSurjectiveFormat2(self):
8118         arr=[0,3, 5,7,9]
8119         arrI=[0,2,5]
8120         a=DataArrayInt.New();
8121         a.setValues(arr,5,1);
8122         b=DataArrayInt.New();
8123         b.setValues(arrI,3,1);
8124         ret,newNbTuple=DataArrayInt.BuildOld2NewArrayFromSurjectiveFormat2(10,a,b);
8125         expected=[0,1,2,0,3,4,5,4,6,4]
8126         self.assertEqual(10,ret.getNbOfElems());
8127         self.assertEqual(7,newNbTuple);
8128         self.assertEqual(1,ret.getNumberOfComponents());
8129         self.assertEqual(expected,ret.getValues());
8130         pass
8131
8132     def testDADIReverse1(self):
8133         arr=[0,3,5,7,9,2]
8134         a=DataArrayInt.New();
8135         a.setValues(arr,6,1);
8136         self.assertEqual(2,a.back());
8137         a.reverse();
8138         for i in xrange(6):
8139             self.assertEqual(arr[5-i],a.getIJ(i,0));
8140             pass
8141         a.setValues(arr[:-1],5,1);
8142         a.reverse();
8143         for i in xrange(5):
8144             self.assertEqual(arr[4-i],a.getIJ(i,0));
8145             pass
8146         #
8147         arr2=[0.,3.,5.,7.,9.,2.]
8148         b=DataArrayDouble.New();
8149         b.setValues(arr2,6,1);
8150         b.reverse();
8151         for i in xrange(6):
8152             self.assertAlmostEqual(arr2[5-i],b.getIJ(i,0),14);
8153             pass
8154         b.setValues(arr2,5,1);
8155         self.assertAlmostEqual(9.,b.back(),14)
8156         b.reverse();
8157         for i in xrange(5):
8158             self.assertAlmostEqual(arr2[4-i],b.getIJ(i,0),14);
8159             pass
8160         pass
8161
8162     def testGetNodeIdsInUse1(self):
8163         m0=MEDCouplingDataForTest.build2DTargetMesh_1();
8164         CellIds=[1,2]
8165         m1=m0.buildPartOfMySelf(CellIds,True);
8166         arr,newNbOfNodes=m1.getNodeIdsInUse();
8167         expected=[-1,0,1,-1,2,3,-1,-1,-1]
8168         self.assertEqual(4,newNbOfNodes);
8169         self.assertEqual(9,arr.getNbOfElems());
8170         self.assertEqual(expected,arr.getValues());
8171         arr2=arr.invertArrayO2N2N2O(newNbOfNodes);
8172         self.assertEqual(4,arr2.getNbOfElems());
8173         expected2=[1,2,4,5]
8174         self.assertEqual(expected2,arr2.getValues());
8175         pass
8176
8177     def testBuildDescendingConnec2(self):
8178         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
8179         #
8180         mesh2,desc,descIndx,revDesc,revDescIndx=mesh.buildDescendingConnectivity2();
8181         mesh2.checkCoherency();
8182         self.assertEqual(1,mesh2.getMeshDimension());
8183         self.assertEqual(13,mesh2.getNumberOfCells());
8184         self.assertEqual(14,revDescIndx.getNbOfElems()); self.assertEqual(14,revDescIndx.getNumberOfTuples());
8185         self.assertEqual(6,descIndx.getNbOfElems()); self.assertEqual(6,descIndx.getNumberOfTuples());
8186         self.assertEqual(18,desc.getNbOfElems()); self.assertEqual(18,desc.getNumberOfTuples());
8187         self.assertEqual(18,revDesc.getNbOfElems()); self.assertEqual(18,revDesc.getNumberOfTuples());
8188         expected1=[1,2,3,4,-3,5,6, 7,8,-5,9,10,-2,11, 12,13,-7,-10]
8189         self.assertEqual(expected1,desc.getValues());
8190         expected2=[0,4,7,10,14,18]
8191         self.assertEqual(expected2,descIndx.getValues());
8192         expected3=[0,1,3,5,6,8,9,11,12,13,15,16,17,18]
8193         self.assertEqual(expected3,revDescIndx.getValues());
8194         expected4=[0, 0,3, 0,1, 0, 1,2, 1, 2,4, 2, 3, 3,4, 3, 4, 4]
8195         self.assertEqual(expected4,revDesc.getValues());
8196         conn=mesh2.getNodalConnectivity();
8197         connIndex=mesh2.getNodalConnectivityIndex();
8198         expected5=[0,3,6,9,12,15,18,21,24,27,30,33,36,39]
8199         self.assertEqual(expected5,connIndex.getValues());
8200         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]
8201         self.assertEqual(expected6,conn.getValues());
8202         pass
8203
8204     def testIntersect2DMeshesTmp1(self):
8205         m1c=MEDCouplingCMesh.New();
8206         coordsX=DataArrayDouble.New();
8207         arrX=[ -1., 1., 2., 4. ]
8208         coordsX.setValues(arrX,4,1);
8209         m1c.setCoordsAt(0,coordsX);
8210         coordsY=DataArrayDouble.New();
8211         arrY=[ -2., 2., 4., 8. ]
8212         coordsY.setValues(arrY,4,1);
8213         m1c.setCoordsAt(1,coordsY);
8214         m1=m1c.buildUnstructured()
8215         m1bis=m1.buildPartOfMySelf([3,4,5],False)
8216         m2=m1.deepCpy()
8217         m2=m2.buildPartOfMySelf([0,1,2],False)
8218         m2.translate([0.5,0.5])
8219         #
8220         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m1bis,m2,1e-10)
8221         expected1=[0,1,1,2,2]
8222         expected2=[0,0,1,1,2]
8223         self.assertEqual(5,d1.getNumberOfTuples());
8224         self.assertEqual(5,d2.getNumberOfTuples());
8225         self.assertEqual(5,m3.getNumberOfCells());
8226         self.assertEqual(22,m3.getNumberOfNodes());
8227         self.assertEqual(2,m3.getSpaceDimension());
8228         self.assertEqual(expected1,d1.getValues());
8229         self.assertEqual(expected2,d2.getValues());
8230         expected3=[5,17,1,16,12,5,18,1,17,13,5,19,2,18,13,5,20,2,19,14,5,21,3,20,14]
8231         expected4=[0,5,10,15,20,25]
8232         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]
8233         self.assertEqual(25,m3.getNodalConnectivity().getNumberOfTuples());
8234         self.assertEqual(6,m3.getNodalConnectivityIndex().getNumberOfTuples());
8235         self.assertEqual(expected3,m3.getNodalConnectivity().getValues());
8236         self.assertEqual(expected4,m3.getNodalConnectivityIndex().getValues());
8237         for i in xrange(44):
8238             self.assertAlmostEqual(expected5[i],m3.getCoords().getIJ(0,i),12);
8239             pass
8240         pass
8241
8242     def testFindNodesOnLine1(self):
8243         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
8244         pt=[-0.3,-0.3]
8245         pt2=[0.,0.,0.]
8246         pt3=[-0.3,0.,0.]
8247         vec=[0.,1.]
8248         vec2=[1.,0.,0.]
8249         vec3=[0.,1.,1.]
8250         expected1=[0,3,6]
8251         res=mesh.findNodesOnLine(pt,vec,1e-12);
8252         self.assertEqual(3,len(res));
8253         self.assertEqual(expected1,res.getValues());
8254         #
8255         mesh.changeSpaceDimension(3);
8256         mesh.rotate(pt2,vec2,pi/4.);
8257         res=mesh.findNodesOnLine(pt3,vec3,1e-12);
8258         self.assertEqual(3,len(res));
8259         self.assertEqual(expected1,res.getValues());
8260         pass
8261
8262     def testIntersect2DMeshesTmp2(self):
8263         m1c=MEDCouplingCMesh.New();
8264         coordsX1=DataArrayDouble.New();
8265         arrX1=[ 0., 1., 1.5, 2. ]
8266         coordsX1.setValues(arrX1,4,1);
8267         m1c.setCoordsAt(0,coordsX1);
8268         coordsY1=DataArrayDouble.New();
8269         arrY1=[ 0., 1.5, 3.]
8270         coordsY1.setValues(arrY1,3,1);
8271         m1c.setCoordsAt(1,coordsY1);
8272         m1=m1c.buildUnstructured();
8273         m2c=MEDCouplingCMesh.New();
8274         coordsX2=DataArrayDouble.New();
8275         arrX2=[ 0., 1., 2. ]
8276         coordsX2.setValues(arrX2,3,1);
8277         m2c.setCoordsAt(0,coordsX2);
8278         coordsY2=DataArrayDouble.New();
8279         arrY2=[ 0., 1., 3.]
8280         coordsY2.setValues(arrY2,3,1);
8281         m2c.setCoordsAt(1,coordsY2);
8282         m2=m2c.buildUnstructured();
8283         #
8284         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m1,m2,1e-10)
8285         #
8286         expected1=[0,0,1,1,2,2,3,4,5]
8287         expected2=[0,2,1,3,1,3,2,3,3]
8288         self.assertEqual(9,d1.getNumberOfTuples());
8289         self.assertEqual(9,d2.getNumberOfTuples());
8290         self.assertEqual(9,m3.getNumberOfCells());
8291         self.assertEqual(22,m3.getNumberOfNodes());
8292         self.assertEqual(2,m3.getSpaceDimension());
8293         self.assertEqual(expected1,d1.getValues());
8294         self.assertEqual(expected2,d2.getValues());
8295         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]
8296         expected4=[0,5,10,15,20,25,30,35,40,45]
8297         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]
8298         self.assertEqual(45,m3.getNodalConnectivity().getNumberOfTuples());
8299         self.assertEqual(10,m3.getNodalConnectivityIndex().getNumberOfTuples());
8300         self.assertEqual(expected3,m3.getNodalConnectivity().getValues());
8301         self.assertEqual(expected4,m3.getNodalConnectivityIndex().getValues());
8302         for i in xrange(44):
8303             self.assertAlmostEqual(expected5[i],m3.getCoords().getIJ(0,i),12);
8304             pass
8305         pass
8306
8307     def testBuildPartOfMySelfSafe1(self):
8308         mesh=MEDCouplingDataForTest.build2DTargetMesh_1()
8309         self.assertRaises(InterpKernelException,mesh.buildPartOfMySelf,[0,-1,4,2],True)
8310         self.assertRaises(InterpKernelException,mesh.buildPartOfMySelf,[0,4,5,4],True)
8311         pass
8312
8313     def testIntersect2DMeshesTmp3(self):
8314         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];
8315         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];
8316         m1=MEDCouplingUMesh.New();
8317         m1.setMeshDimension(2);
8318         m1.allocateCells(8);
8319         m1.insertNextCell(NORM_TRI6,6,m1Conn[0:6]);
8320         m1.insertNextCell(NORM_QUAD8,8,m1Conn[6:14]);
8321         m1.insertNextCell(NORM_TRI6,6,m1Conn[14:20]);
8322         m1.insertNextCell(NORM_QUAD8,8,m1Conn[20:28]);
8323         m1.insertNextCell(NORM_TRI6,6,m1Conn[28:34]);
8324         m1.insertNextCell(NORM_QUAD8,8,m1Conn[34:42]);
8325         m1.insertNextCell(NORM_TRI6,6,m1Conn[42:48]);
8326         m1.insertNextCell(NORM_QUAD8,8,m1Conn[48:56]);
8327         m1.finishInsertingCells();
8328         myCoords1=DataArrayDouble.New();
8329         myCoords1.setValues(m1Coords,25,2);
8330         m1.setCoords(myCoords1);
8331         #
8332         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.]
8333         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]
8334         m2=MEDCouplingUMesh.New();
8335         m2.setMeshDimension(2);
8336         m2.allocateCells(8);
8337         for i in xrange(8):
8338             m2.insertNextCell(NORM_QUAD4,4,m2Conn[4*i:4*(i+1)])
8339             pass
8340         m2.finishInsertingCells();
8341         myCoords2=DataArrayDouble.New();
8342         myCoords2.setValues(m2Coords,15,2);
8343         m2.setCoords(myCoords2);
8344         #
8345         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m1,m2,1e-10)
8346         m3.unPolyze()
8347         #
8348         expected1=[0,1,1,2,3,3,4,5,5,6,7,7]
8349         expected2=[0,0,1,2,2,3,4,4,5,6,6,7]
8350         self.assertEqual(12,d1.getNumberOfTuples());
8351         self.assertEqual(12,d2.getNumberOfTuples());
8352         self.assertEqual(12,m3.getNumberOfCells());
8353         self.assertEqual(88,m3.getNumberOfNodes());
8354         self.assertEqual(2,m3.getSpaceDimension());
8355         self.assertEqual(expected1,d1.getValues());
8356         self.assertEqual(expected2,d2.getValues());
8357         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,6,28,25,5,55,56,57,8,28,5,32,31,58,59,60,61,8,32,6,41,31,62,63,64,65,6,25,37,5,66,67,68,8,32,5,37,36,69,70,71,72,8,42,6,32,36,73,74,75,76,6,1,37,25,77,78,79,8,37,1,26,38,80,81,82,83,8,26,2,43,38,84,85,86,87]
8358         expected4=[0,7,16,25,32,41,50,57,66,75,82,91,100]
8359         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.,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.,-0.5,-0.7071067811865475,-0.7071067811865477,-0.5,0.,-1.05,0.,-0.7071067811865478,-0.7071067811865475,-0.55,-1.,-1.1,-0.5,-1.4012585384440732,-0.5352331346596354,-1.3,0.,-1.1,-0.5,-1.1090169943749475,-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]
8360         self.assertEqual(100,m3.getNodalConnectivity().getNumberOfTuples());
8361         self.assertEqual(13,m3.getNodalConnectivityIndex().getNumberOfTuples());
8362         self.assertEqual(expected3,m3.getNodalConnectivity().getValues());
8363         self.assertEqual(expected4,m3.getNodalConnectivityIndex().getValues());
8364         for i in xrange(176):
8365             self.assertAlmostEqual(expected5[i],m3.getCoords().getIJ(0,i),12);
8366             pass
8367         pass
8368
8369     def testUMeshTessellate2D1(self):
8370         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];
8371         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];
8372         m1=MEDCouplingUMesh.New();
8373         m1.setMeshDimension(2);
8374         m1.allocateCells(8);
8375         m1.insertNextCell(NORM_TRI6,6,m1Conn[0:6]);
8376         m1.insertNextCell(NORM_QUAD8,8,m1Conn[6:14]);
8377         m1.insertNextCell(NORM_TRI6,6,m1Conn[14:20]);
8378         m1.insertNextCell(NORM_QUAD8,8,m1Conn[20:28]);
8379         m1.insertNextCell(NORM_TRI6,6,m1Conn[28:34]);
8380         m1.insertNextCell(NORM_QUAD8,8,m1Conn[34:42]);
8381         m1.insertNextCell(NORM_TRI6,6,m1Conn[42:48]);
8382         m1.insertNextCell(NORM_QUAD8,8,m1Conn[48:56]);
8383         m1.finishInsertingCells();
8384         myCoords1=DataArrayDouble.New();
8385         myCoords1.setValues(m1Coords,25,2);
8386         m1.setCoords(myCoords1);
8387         #
8388         m11=m1.deepCpy();
8389         m11.tessellate2D(1.);
8390         self.assertTrue(m11.getCoords().isEqual(m11.getCoords(),1e-12));
8391         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]
8392         expected2=[0,5,12,17,24,29,36,41,48]
8393         self.assertEqual(48,m11.getNodalConnectivity().getNumberOfTuples());
8394         self.assertEqual(9,m11.getNodalConnectivityIndex().getNumberOfTuples());
8395         self.assertEqual(expected1,m11.getNodalConnectivity().getValues());
8396         self.assertEqual(expected2,m11.getNodalConnectivityIndex().getValues());
8397         #
8398         m12=m1.deepCpy();
8399         m12.tessellate2D(0.5);
8400         self.assertEqual(41,m12.getNumberOfNodes());
8401         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]
8402         expected4=[0,6,15,21,30,36,45,51,60]
8403         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]
8404         for i in xrange(82):
8405             self.assertAlmostEqual(expected5[i],m12.getCoords().getIJ(0,i),12);
8406             pass
8407         self.assertEqual(60,m12.getNodalConnectivity().getNumberOfTuples());
8408         self.assertEqual(9,m12.getNodalConnectivityIndex().getNumberOfTuples());
8409         self.assertEqual(expected3,m12.getNodalConnectivity().getValues());
8410         self.assertEqual(expected4,m12.getNodalConnectivityIndex().getValues());
8411         pass
8412
8413     def testIntersect2DMeshesTmp4(self):
8414         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];
8415         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];
8416         m1=MEDCouplingUMesh.New();
8417         m1.setMeshDimension(2);
8418         m1.allocateCells(8);
8419         m1.insertNextCell(NORM_TRI6,6,m1Conn[0:6]);
8420         m1.insertNextCell(NORM_QUAD8,8,m1Conn[6:14]);
8421         m1.insertNextCell(NORM_TRI6,6,m1Conn[14:20]);
8422         m1.insertNextCell(NORM_QUAD8,8,m1Conn[20:28]);
8423         m1.insertNextCell(NORM_TRI6,6,m1Conn[28:34]);
8424         m1.insertNextCell(NORM_QUAD8,8,m1Conn[34:42]);
8425         m1.insertNextCell(NORM_TRI6,6,m1Conn[42:48]);
8426         m1.insertNextCell(NORM_QUAD8,8,m1Conn[48:56]);
8427         m1.finishInsertingCells();
8428         myCoords1=DataArrayDouble.New();
8429         myCoords1.setValues(m1Coords,25,2);
8430         m1.setCoords(myCoords1);
8431         #
8432         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.]
8433         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]
8434         m2=MEDCouplingUMesh.New();
8435         m2.setMeshDimension(2);
8436         m2.allocateCells(8);
8437         for i in xrange(8):
8438             m2.insertNextCell(NORM_QUAD4,4,m2Conn[4*i:4*(i+1)])
8439             pass
8440         m2.finishInsertingCells();
8441         myCoords2=DataArrayDouble.New();
8442         myCoords2.setValues(m2Coords,15,2);
8443         m2.setCoords(myCoords2);
8444         #
8445         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m2,m1,1e-10)
8446         m3.unPolyze()
8447         #
8448         expected1=[0,0,1,2,2,3,4,4,5,6,6,7]
8449         expected2=[0,1,1,2,3,3,4,5,5,6,7,7]
8450         self.assertEqual(12,d1.getNumberOfTuples());
8451         self.assertEqual(12,d2.getNumberOfTuples());
8452         self.assertEqual(12,m3.getNumberOfCells());
8453         self.assertEqual(88,m3.getNumberOfNodes());
8454         self.assertEqual(2,m3.getSpaceDimension());
8455         self.assertEqual(expected1,d1.getValues());
8456         self.assertEqual(expected2,d2.getValues());
8457         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,6,18,15,20,55,56,57,8,20,7,6,18,58,59,60,61,8,41,6,7,21,62,63,64,65,6,20,15,22,66,67,68,8,22,11,7,20,69,70,71,72,8,21,7,11,42,73,74,75,76,6,22,15,16,77,78,79,8,16,1,13,22,80,81,82,83,8,43,13,1,17,84,85,86,87]
8458         expected4=[0,7,16,25,32,41,50,57,66,75,82,91,100]
8459         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.7071067811865477,1.3,0.,1.1,0.5,1.1090169943749475,1.,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.7071067811865477,0.7071067811865477,-1.1090169943749475,1.,-1.1,0.5,-1.3,0.,-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.7071067811865479,-0.7071067811865476,-1.3,0.,-1.1,-0.5,-1.1090169943749475,-1.,-1.4012585384440734,-0.5352331346596354,0.,-0.5,0.5,0.,0.7071067811865475,-0.7071067811865477,1.05,0.,1.1,-0.5,0.55,-1.,0.7071067811865477,-0.7071067811865476,1.1090169943749475,-1.,1.1,-0.5,1.3,0.,1.4012585384440737,-0.535233134659635]
8460         self.assertEqual(100,m3.getNodalConnectivity().getNumberOfTuples());
8461         self.assertEqual(13,m3.getNodalConnectivityIndex().getNumberOfTuples());
8462         self.assertEqual(expected3,m3.getNodalConnectivity().getValues());
8463         self.assertEqual(expected4,m3.getNodalConnectivityIndex().getValues());
8464         for i in xrange(176):
8465             self.assertAlmostEqual(expected5[i],m3.getCoords().getIJ(0,i),12);
8466             pass
8467         pass
8468
8469     def testGetCellIdsCrossingPlane1(self):
8470         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
8471         vec=[-0.07,1.,0.07]
8472         origin=[1.524,1.4552,1.74768]
8473         ids1=mesh3D.getCellIdsCrossingPlane(origin,vec,1e-10)
8474         self.assertEqual([1,3,4,7,9,10,13,15,16],ids1.getValues())
8475         vec2=[0.,0.,1.]
8476         ids2=mesh3D.getCellIdsCrossingPlane(origin,vec2,1e-10)
8477         self.assertEqual([6,7,8,9,10,11],ids2.getValues())
8478         pass
8479
8480     def testBuildSlice3D1(self):
8481         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
8482         vec1=[-0.07,1.,0.07]
8483         origin1=[1.524,1.4552,1.74768]
8484         slice1,ids=mesh3D.buildSlice3D(origin1,vec1,1e-10);
8485         expected1=[1,3,4,7,9,10,13,15,16]
8486         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]
8487         expected3=[0,6,11,17,22,27,32,37,42,47]
8488         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.]
8489         self.assertEqual(2,slice1.getMeshDimension());
8490         self.assertEqual(3,slice1.getSpaceDimension());
8491         self.assertEqual(57,slice1.getNumberOfNodes());
8492         self.assertEqual(9,slice1.getNumberOfCells());
8493         self.assertEqual(9,ids.getNumberOfTuples());
8494         self.assertEqual(47,slice1.getNodalConnectivity().getNumberOfTuples());
8495         self.assertEqual(10,slice1.getNodalConnectivityIndex().getNumberOfTuples());
8496         self.assertEqual(expected1,ids.getValues());
8497         self.assertEqual(expected2,slice1.getNodalConnectivity().getValues());
8498         self.assertEqual(expected3,slice1.getNodalConnectivityIndex().getValues());
8499         for i in xrange(171):
8500             self.assertAlmostEqual(expected4[i],slice1.getCoords().getIJ(0,i),12);
8501             pass
8502         # 2nd slice based on already existing nodes of mesh3D.
8503         vec2=[0.,3.,1.]
8504         origin2=[2.5,1.,3.]
8505         slice1,ids=mesh3D.buildSlice3D(origin2,vec2,1e-10);
8506         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]
8507         expected6=[0,5,10,15,21,26,32,38,43,49]
8508         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]
8509         self.assertEqual(2,slice1.getMeshDimension());
8510         self.assertEqual(3,slice1.getSpaceDimension());
8511         self.assertEqual(60,slice1.getNumberOfNodes());
8512         self.assertEqual(9,slice1.getNumberOfCells());
8513         self.assertEqual(9,ids.getNumberOfTuples());
8514         self.assertEqual(49,slice1.getNodalConnectivity().getNumberOfTuples());
8515         self.assertEqual(10,slice1.getNodalConnectivityIndex().getNumberOfTuples());
8516         self.assertEqual(expected1,ids.getValues());
8517         self.assertEqual(expected5,slice1.getNodalConnectivity().getValues());
8518         self.assertEqual(expected6,slice1.getNodalConnectivityIndex().getValues());
8519         for i in xrange(180):
8520             self.assertAlmostEqual(expected7[i],slice1.getCoords().getIJ(0,i),12);
8521             pass
8522         # 3rd slice based on shared face of mesh3D.
8523         vec3=[0.,0.,1.]
8524         origin3=[2.5,1.,2.]
8525         slice1,ids=mesh3D.buildSlice3D(origin3,vec3,1e-10);
8526         expected8=[6,7,8,9,10,11,12,13,14,15,16,17]
8527         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]
8528         expected10=[0,5,12,17,22,29,34,39,46,51,56,63,68]
8529         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.]
8530         self.assertEqual(2,slice1.getMeshDimension());
8531         self.assertEqual(3,slice1.getSpaceDimension());
8532         self.assertEqual(45,slice1.getNumberOfNodes());
8533         self.assertEqual(12,slice1.getNumberOfCells());
8534         self.assertEqual(12,ids.getNumberOfTuples());
8535         self.assertEqual(68,slice1.getNodalConnectivity().getNumberOfTuples());
8536         self.assertEqual(13,slice1.getNodalConnectivityIndex().getNumberOfTuples());
8537         self.assertEqual(expected8,ids.getValues());
8538         self.assertEqual(expected9,slice1.getNodalConnectivity().getValues());
8539         self.assertEqual(expected10,slice1.getNodalConnectivityIndex().getValues());
8540         for i in xrange(135):
8541             self.assertAlmostEqual(expected11[i],slice1.getCoords().getIJ(0,i),12);
8542             pass
8543         pass
8544
8545     def testBuildSlice3DSurf1(self):
8546         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
8547         mesh2D=mesh3D.buildDescendingConnectivity()[0];
8548         vec1=[-0.07,1.,0.07]
8549         origin1=[1.524,1.4552,1.74768]
8550         slice1,ids=mesh2D.buildSlice3DSurf(origin1,vec1,1e-10);
8551         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]
8552         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]
8553         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];
8554         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.]
8555         self.assertEqual(1,slice1.getMeshDimension());
8556         self.assertEqual(3,slice1.getSpaceDimension());
8557         self.assertEqual(57,slice1.getNumberOfNodes());
8558         self.assertEqual(25,slice1.getNumberOfCells());
8559         self.assertEqual(25,ids.getNumberOfTuples());
8560         self.assertEqual(75,slice1.getNodalConnectivity().getNumberOfTuples());
8561         self.assertEqual(26,slice1.getNodalConnectivityIndex().getNumberOfTuples());
8562         self.assertEqual(expected1,ids.getValues());
8563         self.assertEqual(expected2,slice1.getNodalConnectivity().getValues());
8564         self.assertEqual(expected3,slice1.getNodalConnectivityIndex().getValues());
8565         for i in xrange(171):
8566             self.assertAlmostEqual(expected4[i],slice1.getCoords().getIJ(0,i),12);
8567             pass
8568         #
8569         vec2=[0.,0.,1.]
8570         origin2=[2.5,1.,2.]
8571         slice1,ids=mesh2D.buildSlice3DSurf(origin2,vec2,1e-10);
8572         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]
8573         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]
8574         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];
8575         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.]
8576         self.assertEqual(1,slice1.getMeshDimension());
8577         self.assertEqual(3,slice1.getSpaceDimension());
8578         self.assertEqual(45,slice1.getNumberOfNodes());
8579         self.assertEqual(68,slice1.getNumberOfCells());
8580         self.assertEqual(68,ids.getNumberOfTuples());
8581         self.assertEqual(204,slice1.getNodalConnectivity().getNumberOfTuples());
8582         self.assertEqual(69,slice1.getNodalConnectivityIndex().getNumberOfTuples());
8583         self.assertEqual(expected5,ids.getValues());
8584         self.assertEqual(expected6,slice1.getNodalConnectivity().getValues());
8585         self.assertEqual(expected7,slice1.getNodalConnectivityIndex().getValues());
8586         for i in xrange(135):
8587             self.assertAlmostEqual(expected8[i],slice1.getCoords().getIJ(0,i),12);
8588             pass
8589         pass
8590
8591     def testDataArrayDoubleAdvSetting1(self):
8592         data1=[1.,11.,2.,12.,3.,13.,4.,14.,5.,15.,6.,16.,7.,17.]
8593         data2=[8.,38.,9.,39.,0.,30.,11.,41.,12.,42.]
8594         compsCpp=["comp1","comp2"]
8595         da=DataArrayDouble.New();
8596         da.setInfoAndChangeNbOfCompo(compsCpp);
8597         da.setName("da");
8598         da.alloc(7,2);
8599         compsCpp=compsCpp[:-1]
8600         self.assertRaises(InterpKernelException,da.setInfoAndChangeNbOfCompo,compsCpp);
8601         da.setValues(data1,7,2)
8602         #
8603         p=[(0,3),(3,5),(5,7)]
8604         tmp=da.selectByTupleRanges(p);
8605         self.assertTrue(tmp.isEqual(da,1e-14));
8606         p=[(0,2),(3,4),(5,7)]
8607         tmp=da.selectByTupleRanges(p);
8608         expected1=[1.,11.,2.,12.,4.,14.,6.,16.,7.,17.]
8609         self.assertEqual(5,tmp.getNumberOfTuples());
8610         self.assertEqual(2,tmp.getNumberOfComponents());
8611         for i in xrange(10):
8612             self.assertAlmostEqual(expected1[i],tmp.getIJ(0,i),14);
8613             pass
8614         p=[(0,2),(0,2),(5,6)]
8615         tmp=da.selectByTupleRanges(p);
8616         expected2=[1.,11.,2.,12.,1.,11.,2.,12.,6.,16.]
8617         self.assertEqual(5,tmp.getNumberOfTuples());
8618         self.assertEqual(2,tmp.getNumberOfComponents());
8619         for i in xrange(10):
8620             self.assertAlmostEqual(expected2[i],tmp.getIJ(0,i),14);
8621             pass
8622         p=[(0,2),(-1,2),(5,6)]
8623         self.assertRaises(InterpKernelException,da.selectByTupleRanges,p);
8624         p=[(0,2),(0,2),(5,8)]
8625         self.assertRaises(InterpKernelException,da.selectByTupleRanges,p);
8626         #
8627         da2=DataArrayDouble.New();
8628         da2.setValues(data2,5,2);
8629         #
8630         dac=da.deepCpy();
8631         dac.setContigPartOfSelectedValues2(1,da2,2,4,1);
8632         expected3=[1.,11.,0.,30.,11.,41.,4.,14.,5.,15.,6.,16.,7.,17.]
8633         for i in xrange(14):
8634             self.assertAlmostEqual(expected3[i],dac.getIJ(0,i),14);
8635             pass
8636         #
8637         dac=da.deepCpy();
8638         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,3,da2,0,5,1);
8639         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,0,da2,4,6,1);
8640         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,3,da2,5,0,1);
8641         dac.setContigPartOfSelectedValues2(3,da2,1,5,1);
8642         expected4=[1.,11.,2.,12.,3.,13.,9.,39.,0.,30.,11.,41.,12.,42.]
8643         for i in xrange(14):
8644             self.assertAlmostEqual(expected4[i],dac.getIJ(0,i),14);
8645             pass
8646         #
8647         ids=DataArrayInt.New();
8648         ids.alloc(3,1);
8649         dac=da.deepCpy();
8650         ids.setIJ(0,0,2); ids.setIJ(1,0,0); ids.setIJ(2,0,4);
8651         dac.setContigPartOfSelectedValues(2,da2,ids);
8652         expected5=[1.,11.,2.,12.,0.,30.,8.,38.,12.,42.,6.,16.,7.,17.]
8653         for i in xrange(14):
8654             self.assertAlmostEqual(expected5[i],dac.getIJ(0,i),14);
8655             pass
8656         #
8657         dac=da.deepCpy();
8658         ids.setIJ(0,0,2); ids.setIJ(1,0,5); ids.setIJ(2,0,4);
8659         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,1,da2,ids);
8660         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,-1);
8661         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,1,da2,ids);
8662         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,1);
8663         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,5,da2,ids);
8664         #
8665         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,1);
8666         dac=da.deepCpy();
8667         dac.setContigPartOfSelectedValues(4,da2,ids);
8668         expected6=[1.,11.,2.,12.,3.,13.,4.,14.,0.,30.,0.,30.,9.,39.]
8669         for i in xrange(14):
8670             self.assertAlmostEqual(expected6[i],dac.getIJ(0,i),14);
8671             pass
8672         pass
8673
8674     def testDataArrayIntAdvSetting1(self):
8675         data1=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
8676         data2=[8,38,9,39,0,30,11,41,12,42]
8677         compsCpp=["comp1","comp2"]
8678         da=DataArrayInt.New();
8679         da.setInfoAndChangeNbOfCompo(compsCpp);
8680         da.setName("da");
8681         da.alloc(7,2);
8682         compsCpp=compsCpp[:-1]
8683         self.assertRaises(InterpKernelException,da.setInfoAndChangeNbOfCompo,compsCpp);
8684         da.setValues(data1,7,2)
8685         #
8686         p=[(0,3),(3,5),(5,7)]
8687         tmp=da.selectByTupleRanges(p);
8688         self.assertTrue(tmp.isEqual(da));
8689         p=[(0,2),(3,4),(5,7)]
8690         tmp=da.selectByTupleRanges(p);
8691         expected1=[1,11,2,12,4,14,6,16,7,17]
8692         self.assertEqual(5,tmp.getNumberOfTuples());
8693         self.assertEqual(2,tmp.getNumberOfComponents());
8694         for i in xrange(10):
8695             self.assertEqual(expected1[i],tmp.getIJ(0,i));
8696             pass
8697         p=[(0,2),(0,2),(5,6)]
8698         tmp=da.selectByTupleRanges(p);
8699         expected2=[1,11,2,12,1,11,2,12,6,16]
8700         self.assertEqual(5,tmp.getNumberOfTuples());
8701         self.assertEqual(2,tmp.getNumberOfComponents());
8702         for i in xrange(10):
8703             self.assertEqual(expected2[i],tmp.getIJ(0,i));
8704             pass
8705         p=[(0,2),(-1,2),(5,6)]
8706         self.assertRaises(InterpKernelException,da.selectByTupleRanges,p);
8707         p=[(0,2),(0,2),(5,8)]
8708         self.assertRaises(InterpKernelException,da.selectByTupleRanges,p);
8709         #
8710         da2=DataArrayInt.New();
8711         da2.setValues(data2,5,2);
8712         #
8713         dac=da.deepCpy();
8714         dac.setContigPartOfSelectedValues2(1,da2,2,4,1);
8715         expected3=[1,11,0,30,11,41,4,14,5,15,6,16,7,17]
8716         for i in xrange(14):
8717             self.assertEqual(expected3[i],dac.getIJ(0,i));
8718             pass
8719         #
8720         dac=da.deepCpy();
8721         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,3,da2,0,5,1);
8722         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,0,da2,4,6,1);
8723         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,3,da2,5,0,1);
8724         dac.setContigPartOfSelectedValues2(3,da2,1,5,1);
8725         expected4=[1,11,2,12,3,13,9,39,0,30,11,41,12,42]
8726         for i in xrange(14):
8727             self.assertEqual(expected4[i],dac.getIJ(0,i));
8728             pass
8729         #
8730         ids=DataArrayInt.New();
8731         ids.alloc(3,1);
8732         dac=da.deepCpy();
8733         ids.setIJ(0,0,2); ids.setIJ(1,0,0); ids.setIJ(2,0,4);
8734         dac.setContigPartOfSelectedValues(2,da2,ids);
8735         expected5=[1,11,2,12,0,30,8,38,12,42,6,16,7,17]
8736         for i in xrange(14):
8737             self.assertEqual(expected5[i],dac.getIJ(0,i));
8738             pass
8739         #
8740         dac=da.deepCpy();
8741         ids.setIJ(0,0,2); ids.setIJ(1,0,5); ids.setIJ(2,0,4);
8742         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,1,da2,ids);
8743         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,-1);
8744         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,1,da2,ids);
8745         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,1);
8746         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,5,da2,ids);
8747         #
8748         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,1);
8749         dac=da.deepCpy();
8750         dac.setContigPartOfSelectedValues(4,da2,ids);
8751         expected6=[1,11,2,12,3,13,4,14,0,30,0,30,9,39]
8752         for i in xrange(14):
8753             self.assertEqual(expected6[i],dac.getIJ(0,i));
8754             pass
8755         pass
8756
8757     def testBuildDescendingConnec2Of3DMesh1(self):
8758         mesh=MEDCouplingDataForTest.build3DSourceMesh_1();
8759         #
8760         mesh2,desc,descIndx,revDesc,revDescIndx=mesh.buildDescendingConnectivity2();
8761         mesh2.checkCoherency();
8762         self.assertEqual(2,mesh2.getMeshDimension());
8763         self.assertEqual(30,mesh2.getNumberOfCells());
8764         self.assertEqual(31,revDescIndx.getNbOfElems()); self.assertEqual(31,revDescIndx.getNumberOfTuples());
8765         self.assertEqual(13,descIndx.getNbOfElems()); self.assertEqual(13,descIndx.getNumberOfTuples());
8766         self.assertEqual(48,desc.getNbOfElems()); self.assertEqual(48,desc.getNumberOfTuples());
8767         self.assertEqual(48,revDesc.getNbOfElems()); self.assertEqual(48,revDesc.getNumberOfTuples());
8768         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]
8769         self.assertEqual(expected1,desc.getValues());
8770         expected2=[0,4,8,12,16,20,24,28,32,36,40,44,48]
8771         self.assertEqual(expected2,descIndx.getValues());
8772         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]
8773         self.assertEqual(expected3,revDescIndx.getValues());
8774         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]
8775         self.assertEqual(expected4,revDesc.getValues());
8776         conn=mesh2.getNodalConnectivity();
8777         connIndex=mesh2.getNodalConnectivityIndex();
8778         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]
8779         self.assertEqual(expected5,connIndex.getValues());
8780         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]
8781         self.assertEqual(expected6,conn.getValues());
8782         pass
8783
8784     def testAre2DCellsNotCorrectlyOriented1(self):
8785         m1Coords=[1.,1.,-1.,-1.,-1.,-1.,1.,-1.]
8786         m1Conn=[0,3,1,2]
8787         m1=MEDCouplingUMesh.New();
8788         m1.setMeshDimension(2);
8789         m1.allocateCells(1);
8790         m1.insertNextCell(NORM_QUAD4,4,m1Conn[0:4])
8791         m1.finishInsertingCells();
8792         myCoords1=DataArrayDouble.New();
8793         myCoords1.setValues(m1Coords,4,2);
8794         m1.setCoords(myCoords1);
8795         #
8796         vec1=[0.,0.,1.]
8797         for i in xrange(18):
8798             vec2=[3.*cos(pi/9.*i),3.*sin(pi/9.*i)];
8799             m1Cpy=m1.deepCpy();
8800             m1Cpy.translate(vec2);
8801             self.assertRaises(InterpKernelException,m1Cpy.are2DCellsNotCorrectlyOriented,vec1,False);
8802             m1Cpy.changeSpaceDimension(3);
8803             res=m1Cpy.are2DCellsNotCorrectlyOriented(vec1,False)
8804             self.assertEqual([0],res.getValues());
8805             pass
8806         pass
8807
8808     def testDataArrayAbs1(self):
8809         d1=DataArrayDouble.New();
8810         val1=[2.,-3.,-5.,6.,-7.,-8.,9.,10.,-11.,-12.,-13.,-15.]
8811         expected1=[2.,3.,5.,6.,7.,8.,9.,10.,11.,12.,13.,15.]
8812         d1.setValues(val1,6,2);
8813         d2=d1.convertToIntArr();
8814         #
8815         d1.abs();
8816         for i in xrange(12):
8817             self.assertAlmostEqual(expected1[i],d1.getIJ(0,i),14);
8818             pass
8819         #
8820         expected2=[2,3,5,6,7,8,9,10,11,12,13,15]
8821         d2.abs();
8822         for i in xrange(12):
8823             self.assertEqual(expected2[i],d2.getIJ(0,i));
8824             pass
8825         #
8826         pass
8827
8828     # test on 1D
8829     def testGetValueOn3(self):
8830         v=[0.,1.,1.5,2.]
8831         v2=[0.7,1.25,0.,2.,1.5]
8832         disp=[5.,50.,500.,6.,60.,600.,7.,70.,700.,8.,80.,800.]
8833         m=MEDCouplingUMesh.New("myMesh",1)
8834         nbNodes=len(v)
8835         nbCells=nbNodes-1
8836         m.allocateCells(nbCells)
8837         coords=DataArrayDouble.New() ; coords.setValues(v,nbNodes,1)
8838         m.setCoords(coords)
8839         m.insertNextCell(NORM_SEG2,2,[0,1])
8840         m.insertNextCell(NORM_SEG2,2,[2,1])
8841         m.insertNextCell(NORM_SEG2,2,[2,3])
8842         m.finishInsertingCells()
8843         f=MEDCouplingFieldDouble.New(ON_NODES)
8844         f.setMesh(m)
8845         array=DataArrayDouble.New(); array.setValues(disp,m.getNumberOfNodes(),3)
8846         f.setArray(array)
8847         arr1=f.getValueOnMulti(v2)
8848         self.assertEqual(5,arr1.getNumberOfTuples());
8849         self.assertEqual(3,arr1.getNumberOfComponents());
8850         expected1=[5.7,57.,570.,6.5,65.,650.,5.,50.,500.,8.,80.,800.,7.,70.,700.]
8851         for i in xrange(15):
8852             self.assertAlmostEqual(expected1[i],arr1.getIJ(0,i),14);
8853             pass
8854         pass
8855
8856     def testGetNodeIdsOfCell2(self):
8857         m1c=MEDCouplingCMesh.New();
8858         coordsX=DataArrayDouble.New();
8859         arrX=[ -1., 1., 2., 4., 4.5 ]
8860         coordsX.setValues(arrX,5,1);
8861         coordsY=DataArrayDouble.New();
8862         arrY=[ -2., 2., 4., 8.]
8863         coordsY.setValues(arrY,4,1);
8864         coordsZ=DataArrayDouble.New();
8865         arrZ=[ -2., 2., 4.]
8866         coordsZ.setValues(arrZ,3,1);
8867         # test in 1D
8868         m1c.setCoordsAt(0,coordsX);
8869         expected1=[[0,1],[1,2],[2,3],[3,4]]
8870         self.assertEqual(4,m1c.getNumberOfCells())
8871         for i in xrange(m1c.getNumberOfCells()):
8872             self.assertEqual(expected1[i],m1c.getNodeIdsOfCell(i))
8873             pass
8874         # test in 2D
8875         m1c.setCoordsAt(1,coordsY);
8876         self.assertEqual(12,m1c.getNumberOfCells())
8877         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]]
8878         for i in xrange(m1c.getNumberOfCells()):
8879             self.assertEqual(expected2[i],m1c.getNodeIdsOfCell(i))
8880             pass
8881         # test in 3D
8882         m1c.setCoordsAt(2,coordsZ);
8883         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]]
8884         self.assertEqual(24,m1c.getNumberOfCells())
8885         for i in xrange(m1c.getNumberOfCells()):
8886             self.assertEqual(expected3[i],m1c.getNodeIdsOfCell(i))
8887             pass
8888         pass
8889
8890     def testSwigDADOp4(self):
8891         da=DataArrayDouble.New(range(6,30),12,2)
8892         self.assertEqual(12,da.getNumberOfTuples());
8893         self.assertEqual(2,da.getNumberOfComponents());
8894         for i in xrange(24):
8895             self.assertAlmostEqual(da.getIJ(0,i),float(i+6),13)
8896             pass
8897         # operator transpose
8898         da.transpose()
8899         self.assertEqual(2,da.getNumberOfTuples());
8900         self.assertEqual(12,da.getNumberOfComponents());
8901         for i in xrange(24):
8902             self.assertAlmostEqual(da.getIJ(0,i),float(i+6),13)
8903             pass
8904         da.transpose()
8905         # operator __neg__
8906         da2=DataArrayDouble.New(12,1)
8907         da2.iota(0.)
8908         dabis=-da
8909         for i in xrange(24):
8910             self.assertAlmostEqual(dabis.getIJ(0,i),-float(i+6),13)
8911             pass
8912         # operator+=
8913         da+=da2
8914         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.]
8915         for i in xrange(24):
8916             self.assertAlmostEqual(da.getIJ(0,i),expected1[i],13)
8917             pass
8918         da=-dabis
8919         da+=[100.,101.]
8920         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.]
8921         self.assertEqual(12,da.getNumberOfTuples());
8922         self.assertEqual(2,da.getNumberOfComponents());
8923         for i in xrange(24):
8924             self.assertAlmostEqual(da.getIJ(0,i),expected2[i],13)
8925             pass
8926         for pos,elt in enumerate(dabis):
8927             da[pos]+=elt
8928             pass
8929         self.assertEqual(12,da.getNumberOfTuples());
8930         self.assertEqual(2,da.getNumberOfComponents());
8931         for elt in da:
8932             li=elt[:]
8933             self.assertAlmostEqual(li[0],100.,13) ; self.assertAlmostEqual(li[1],101.,13)
8934             pass
8935         # operator-=
8936         da=DataArrayDouble.New(range(6,30),12,2)
8937         da2=DataArrayDouble.New(range(12),12,1)
8938         dabis=-da
8939         da-=da2
8940         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.]
8941         for i in xrange(24):
8942             self.assertAlmostEqual(da.getIJ(0,i),expected1[i],13)
8943             pass
8944         da=-dabis
8945         da-=[100.,101.]
8946         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.]
8947         self.assertEqual(12,da.getNumberOfTuples());
8948         self.assertEqual(2,da.getNumberOfComponents());
8949         for i in xrange(24):
8950             self.assertAlmostEqual(da.getIJ(0,i),expected2[i],13)
8951             pass
8952         for pos,elt in enumerate(dabis):
8953             da[pos]-=elt
8954             pass
8955         self.assertEqual(12,da.getNumberOfTuples());
8956         self.assertEqual(2,da.getNumberOfComponents());
8957         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.]
8958         for i in xrange(24):
8959             self.assertAlmostEqual(da.getIJ(0,i),expected3[i],13)
8960             pass
8961         # operator*=
8962         da=DataArrayDouble.New(range(6,30),12,2)
8963         da2=DataArrayDouble.New(range(12),12,1)
8964         dabis=-da
8965         da*=da2
8966         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.]
8967         for i in xrange(24):
8968             self.assertAlmostEqual(da.getIJ(0,i),expected1[i],13)
8969             pass
8970         da=-dabis
8971         da*=[100.,101.]
8972         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.]
8973         self.assertEqual(12,da.getNumberOfTuples());
8974         self.assertEqual(2,da.getNumberOfComponents());
8975         for i in xrange(24):
8976             self.assertAlmostEqual(da.getIJ(0,i),expected2[i],13)
8977             pass
8978         for pos,elt in enumerate(dabis):
8979             da[pos]*=elt
8980             pass
8981         self.assertEqual(12,da.getNumberOfTuples());
8982         self.assertEqual(2,da.getNumberOfComponents());
8983         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]
8984         for i in xrange(24):
8985             self.assertAlmostEqual(da.getIJ(0,i),expected3[i],13)
8986             pass
8987         # operator/=
8988         da=DataArrayDouble.New(range(6,30),12,2)
8989         da2=DataArrayDouble.New(range(1,13),12,1)
8990         dabis=-da
8991         da/=da2
8992         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]
8993         for i in xrange(24):
8994             self.assertAlmostEqual(da.getIJ(0,i),expected1[i],13)
8995             pass
8996         da=-dabis
8997         da/=[100.,101.]
8998         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]
8999         self.assertEqual(12,da.getNumberOfTuples());
9000         self.assertEqual(2,da.getNumberOfComponents());
9001         for i in xrange(24):
9002             self.assertAlmostEqual(da.getIJ(0,i),expected2[i],13)
9003             pass
9004         for pos,elt in enumerate(dabis):
9005             da[pos]/=elt
9006             pass
9007         self.assertEqual(12,da.getNumberOfTuples());
9008         self.assertEqual(2,da.getNumberOfComponents());
9009         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]
9010         for i in xrange(24):
9011             self.assertAlmostEqual(da.getIJ(0,i),expected3[i],13)
9012             pass
9013         pass
9014
9015     def testSwigDAIOp4(self):
9016         da=DataArrayInt.New(range(6,30),12,2)
9017         self.assertEqual(12,da.getNumberOfTuples());
9018         self.assertEqual(2,da.getNumberOfComponents());
9019         for i in xrange(24):
9020             self.assertEqual(da.getIJ(0,i),i+6)
9021             pass
9022         # operator transpose
9023         da.transpose()
9024         self.assertEqual(2,da.getNumberOfTuples());
9025         self.assertEqual(12,da.getNumberOfComponents());
9026         for i in xrange(24):
9027             self.assertEqual(da.getIJ(0,i),i+6)
9028             pass
9029         da.transpose()
9030         # operator __neg__
9031         da2=DataArrayInt.New(12,1)
9032         da2.iota(0)
9033         dabis=-da
9034         for i in xrange(24):
9035             self.assertEqual(dabis.getIJ(0,i),-(i+6))
9036             pass
9037         # operator+=
9038         da+=da2
9039         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]
9040         for i in xrange(24):
9041             self.assertEqual(da.getIJ(0,i),expected1[i])
9042             pass
9043         da=-dabis
9044         da+=[100,101]
9045         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]
9046         self.assertEqual(12,da.getNumberOfTuples());
9047         self.assertEqual(2,da.getNumberOfComponents());
9048         for i in xrange(24):
9049             self.assertEqual(da.getIJ(0,i),expected2[i])
9050             pass
9051         for pos,elt in enumerate(dabis):
9052             da[pos]+=elt
9053             pass
9054         self.assertEqual(12,da.getNumberOfTuples());
9055         self.assertEqual(2,da.getNumberOfComponents());
9056         for elt in da:
9057             li=elt[:]
9058             self.assertEqual(li[0],100) ; self.assertEqual(li[1],101)
9059             pass
9060         # operator-=
9061         da=DataArrayInt.New(range(6,30),12,2)
9062         da2=DataArrayInt.New(range(12),12,1)
9063         dabis=-da
9064         da-=da2
9065         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]
9066         for i in xrange(24):
9067             self.assertEqual(da.getIJ(0,i),expected1[i])
9068             pass
9069         da=-dabis
9070         da-=[100,101]
9071         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]
9072         self.assertEqual(12,da.getNumberOfTuples());
9073         self.assertEqual(2,da.getNumberOfComponents());
9074         for i in xrange(24):
9075             self.assertEqual(da.getIJ(0,i),expected2[i])
9076             pass
9077         for pos,elt in enumerate(dabis):
9078             da[pos]-=elt
9079             pass
9080         self.assertEqual(12,da.getNumberOfTuples());
9081         self.assertEqual(2,da.getNumberOfComponents());
9082         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]
9083         for i in xrange(24):
9084             self.assertEqual(da.getIJ(0,i),expected3[i])
9085             pass
9086         # operator*=
9087         da=DataArrayInt.New(range(6,30),12,2)
9088         da2=DataArrayInt.New(range(12),12,1)
9089         dabis=-da
9090         da*=da2
9091         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]
9092         for i in xrange(24):
9093             self.assertEqual(da.getIJ(0,i),expected1[i])
9094             pass
9095         da=-dabis
9096         da*=[100,101]
9097         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]
9098         self.assertEqual(12,da.getNumberOfTuples());
9099         self.assertEqual(2,da.getNumberOfComponents());
9100         for i in xrange(24):
9101             self.assertEqual(da.getIJ(0,i),expected2[i])
9102             pass
9103         for pos,elt in enumerate(dabis):
9104             da[pos]*=elt
9105             pass
9106         self.assertEqual(12,da.getNumberOfTuples());
9107         self.assertEqual(2,da.getNumberOfComponents());
9108         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]
9109         for i in xrange(24):
9110             self.assertEqual(da.getIJ(0,i),expected3[i])
9111             pass
9112         # operator/=
9113         da=DataArrayInt.New(range(6,30),12,2)
9114         da2=DataArrayInt.New(range(1,13),12,1)
9115         dabis=-da
9116         da/=da2
9117         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]
9118         for i in xrange(24):
9119             self.assertEqual(da.getIJ(0,i),expected1[i])
9120             pass
9121         da=-dabis
9122         da/=DataArrayInt.New([2,3],1,2)
9123         self.assertEqual(12,da.getNumberOfTuples());
9124         self.assertEqual(2,da.getNumberOfComponents());
9125         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]
9126         for i in xrange(24):
9127             self.assertEqual(da.getIJ(0,i),expected2[i])
9128             pass
9129         pass
9130
9131     def testSwigDADOp5(self):
9132         da=DataArrayDouble.New([5,6,7,8,9,6,7,-2,3,9,8,10])
9133         da.rearrange(3)
9134         da2=DataArrayDouble.New([5.,8.,10.,12])
9135         self.assertEqual(4,da2.getNumberOfTuples());
9136         self.assertEqual(1,da2.getNumberOfComponents());
9137         da3=da+da2
9138         self.assertEqual(4,da3.getNumberOfTuples());
9139         self.assertEqual(3,da3.getNumberOfComponents());
9140         expected1=[10.,11.,12.,16.,17.,14.,17.,8.,13.,21.,20.,22.]
9141         for i in xrange(12):
9142             self.assertAlmostEqual(da3.getIJ(0,i),expected1[i],13)
9143             pass
9144         da3=da2+da
9145         self.assertEqual(4,da3.getNumberOfTuples());
9146         self.assertEqual(3,da3.getNumberOfComponents());
9147         for i in xrange(12):
9148             self.assertAlmostEqual(da3.getIJ(0,i),expected1[i],13)
9149             pass
9150         # Test new API of classmethod DataArrayDouble.New
9151         vals=[5,6,7,8,9,6,7,-2,3,9,8,10]
9152         da=DataArrayDouble.New(vals)
9153         self.assertEqual(12,da.getNumberOfTuples());
9154         self.assertEqual(1,da.getNumberOfComponents());
9155         for i in xrange(12):
9156             self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
9157             pass
9158         da=DataArrayDouble.New(vals,12)
9159         self.assertEqual(12,da.getNumberOfTuples());
9160         self.assertEqual(1,da.getNumberOfComponents());
9161         for i in xrange(12):
9162             self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
9163             pass
9164         da=DataArrayDouble.New(vals,1,12)
9165         self.assertEqual(1,da.getNumberOfTuples());
9166         self.assertEqual(12,da.getNumberOfComponents());
9167         for i in xrange(12):
9168             self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
9169             pass
9170         da=DataArrayDouble.New(vals,6,2)
9171         self.assertEqual(6,da.getNumberOfTuples());
9172         self.assertEqual(2,da.getNumberOfComponents());
9173         for i in xrange(12):
9174             self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
9175             pass
9176         da=DataArrayDouble.New(vals,4,3)
9177         self.assertEqual(4,da.getNumberOfTuples());
9178         self.assertEqual(3,da.getNumberOfComponents());
9179         for i in xrange(12):
9180             self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
9181             pass
9182         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,11);
9183         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,13);
9184         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,5,2);
9185         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,7,2);
9186         pass
9187
9188     def testSwigDADOp6(self):
9189         da=DataArrayInt.New([5,6,7,8,9,6,7,-2,3,9,8,10])
9190         da.rearrange(3)
9191         da2=DataArrayInt.New([5,8,10,12])
9192         self.assertEqual(4,da2.getNumberOfTuples());
9193         self.assertEqual(1,da2.getNumberOfComponents());
9194         da3=da+da2
9195         self.assertEqual(4,da3.getNumberOfTuples());
9196         self.assertEqual(3,da3.getNumberOfComponents());
9197         expected1=[10,11,12,16,17,14,17,8,13,21,20,22]
9198         for i in xrange(12):
9199             self.assertEqual(da3.getIJ(0,i),expected1[i])
9200             pass
9201         da3=da2+da
9202         self.assertEqual(4,da3.getNumberOfTuples());
9203         self.assertEqual(3,da3.getNumberOfComponents());
9204         for i in xrange(12):
9205             self.assertEqual(da3.getIJ(0,i),expected1[i])
9206             pass
9207         da3=da+DataArrayInt.New(da2.getValues())
9208         # Test new API of classmethod DataArrayInt.New
9209         vals=[5,6,7,8,9,6,7,-2,3,9,8,10]
9210         da=DataArrayDouble.New(vals)
9211         self.assertEqual(12,da.getNumberOfTuples());
9212         self.assertEqual(1,da.getNumberOfComponents());
9213         for i in xrange(12):
9214             self.assertEqual(da.getIJ(0,i),vals[i])
9215             pass
9216         da=DataArrayDouble.New(vals,12)
9217         self.assertEqual(12,da.getNumberOfTuples());
9218         self.assertEqual(1,da.getNumberOfComponents());
9219         for i in xrange(12):
9220             self.assertEqual(da.getIJ(0,i),vals[i])
9221             pass
9222         da=DataArrayDouble.New(vals,1,12)
9223         self.assertEqual(1,da.getNumberOfTuples());
9224         self.assertEqual(12,da.getNumberOfComponents());
9225         for i in xrange(12):
9226             self.assertEqual(da.getIJ(0,i),vals[i])
9227             pass
9228         da=DataArrayDouble.New(vals,6,2)
9229         self.assertEqual(6,da.getNumberOfTuples());
9230         self.assertEqual(2,da.getNumberOfComponents());
9231         for i in xrange(12):
9232             self.assertEqual(da.getIJ(0,i),vals[i])
9233             pass
9234         da=DataArrayDouble.New(vals,4,3)
9235         self.assertEqual(4,da.getNumberOfTuples());
9236         self.assertEqual(3,da.getNumberOfComponents());
9237         for i in xrange(12):
9238             self.assertEqual(da.getIJ(0,i),vals[i])
9239             pass
9240         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,11);
9241         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,13);
9242         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,5,2);
9243         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,7,2);
9244         pass
9245
9246     def testRenumberNodesInConn1(self):
9247         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. ]
9248         mesh2DConn=[1,4,2, 4,5,2, 0,3,4,1, 6,7,4,3, 7,8,5,4]
9249         mesh2D=MEDCouplingUMesh.New("mesh",2);
9250         mesh2D.allocateCells(5);
9251         mesh2D.insertNextCell(NORM_TRI3,3,mesh2DConn[0:3])
9252         mesh2D.insertNextCell(NORM_TRI3,3,mesh2DConn[3:6])
9253         mesh2D.insertNextCell(NORM_QUAD4,4,mesh2DConn[6:10])
9254         mesh2D.insertNextCell(NORM_QUAD4,4,mesh2DConn[10:14])
9255         mesh2D.insertNextCell(NORM_QUAD4,4,mesh2DConn[14:18])
9256         mesh2D.finishInsertingCells();
9257         myCoords=DataArrayDouble.New(mesh2DCoords,9,3);
9258         mesh2D.setCoords(myCoords);
9259         mesh2D.checkCoherency();
9260         #
9261         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. ]
9262         mesh3DConn=[0,1,2,3,4,5,6,7]
9263         mesh3D=MEDCouplingUMesh.New("mesh",3);
9264         mesh3D.allocateCells(1);
9265         mesh3D.insertNextCell(NORM_HEXA8,8,mesh3DConn[:])
9266         mesh3D.finishInsertingCells();
9267         myCoords3D=DataArrayDouble.New(mesh3DCoords,8,3);
9268         mesh3D.setCoords(myCoords3D);
9269         mesh3D.checkCoherency();
9270         #
9271         mesh3D_2=mesh3D.deepCpy();
9272         mesh2D_2=mesh2D.deepCpy();
9273         mesh3D_4=mesh3D.deepCpy();
9274         mesh2D_4=mesh2D.deepCpy();
9275         oldNbOf3DNodes=mesh3D.getNumberOfNodes();
9276         renumNodes=DataArrayInt.New();
9277         renumNodes.alloc(mesh2D.getNumberOfNodes(),1);
9278         renumNodes.iota(oldNbOf3DNodes);
9279         coo=DataArrayDouble.Aggregate(mesh3D.getCoords(),mesh2D.getCoords());
9280         mesh3D.setCoords(coo);
9281         mesh2D.setCoords(coo);
9282         mesh2DCpy=mesh2D.deepCpy()
9283         mesh2D_3=mesh2D.deepCpy();
9284         mesh2D_3.shiftNodeNumbersInConn(oldNbOf3DNodes);
9285         mesh2D.renumberNodesInConn(renumNodes);
9286         mesh2DCpy.renumberNodesInConn(renumNodes.getValues());
9287         self.assertTrue(mesh2D.isEqual(mesh2DCpy,1e-12))
9288         self.assertTrue(mesh2D.isEqual(mesh2D_3,1e-12))
9289         #
9290         da1,da2=mesh3D.checkGeoEquivalWith(mesh3D_2,10,1e-12);
9291         self.assertTrue(da1==None);
9292         self.assertEqual(8,da2.getNumberOfTuples());
9293         self.assertEqual(1,da2.getNumberOfComponents());
9294         expected1=[8,11,12,9,4,5,6,7]
9295         for i in xrange(8):
9296             self.assertEqual(expected1[i],da2.getIJ(i,0));
9297             pass
9298         #
9299         da1,da2=mesh2D.checkGeoEquivalWith(mesh2D_2,10,1e-12);
9300         self.assertTrue(da1==None);
9301         self.assertEqual(9,da2.getNumberOfTuples());
9302         self.assertEqual(1,da2.getNumberOfComponents());
9303         for i in xrange(9):
9304             self.assertEqual(8+i,da2.getIJ(i,0));
9305             pass
9306         #
9307         mesh2D_5=mesh2D_4.deepCpy();
9308         mesh2D_5.translate([1.,0.,0.]);
9309         meshes=[mesh3D_4,mesh2D_4,mesh2D_5];
9310         MEDCouplingUMesh.PutUMeshesOnSameAggregatedCoords(meshes);
9311         self.assertTrue(mesh3D_4.getCoords().getHiddenCppPointer()==mesh2D_4.getCoords().getHiddenCppPointer());
9312         self.assertTrue(mesh2D_4.getCoords().getHiddenCppPointer()==mesh2D_5.getCoords().getHiddenCppPointer());
9313         mesh3D_4.checkCoherency(); mesh2D_4.checkCoherency(); mesh2D_5.checkCoherency();
9314         self.assertEqual(26,mesh3D_4.getNumberOfNodes());
9315         self.assertEqual(3,mesh3D_4.getSpaceDimension());
9316         self.assertEqual(9,mesh3D_4.getNodalConnectivity().getNumberOfTuples());
9317         self.assertEqual(23,mesh2D_4.getNodalConnectivity().getNumberOfTuples());
9318         self.assertEqual(23,mesh2D_5.getNodalConnectivity().getNumberOfTuples());
9319         expected2=[18,0,1,2,3,4,5,6,7]
9320         expected3=[3,9,12,10, 3,12,13,10, 4,8,11,12,9, 4,14,15,12,11, 4,15,16,13,12]
9321         expected4=[3,18,21,19, 3,21,22,19, 4,17,20,21,18, 4,23,24,21,20, 4,24,25,22,21]
9322         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]
9323         self.assertEqual(expected2,mesh3D_4.getNodalConnectivity().getValues());
9324         self.assertEqual(expected3,mesh2D_4.getNodalConnectivity().getValues());
9325         self.assertEqual(expected4,mesh2D_5.getNodalConnectivity().getValues());
9326         for i in xrange(78):
9327             self.assertAlmostEqual(expected5[i],mesh3D_4.getCoords().getIJ(0,i),12);
9328             pass
9329         #
9330         MEDCouplingUMesh.MergeNodesOnUMeshesSharingSameCoords(meshes,1e-12);
9331         mesh3D_4.checkCoherency(); mesh2D_4.checkCoherency(); mesh2D_5.checkCoherency();
9332         self.assertTrue(mesh3D_4.getCoords().getHiddenCppPointer()==mesh2D_4.getCoords().getHiddenCppPointer());
9333         self.assertTrue(mesh2D_4.getCoords().getHiddenCppPointer()==mesh2D_5.getCoords().getHiddenCppPointer());
9334         self.assertEqual(19,mesh3D_4.getNumberOfNodes());
9335         self.assertEqual(3,mesh3D_4.getSpaceDimension());
9336         self.assertEqual(9,mesh3D_4.getNodalConnectivity().getNumberOfTuples());
9337         self.assertEqual(23,mesh2D_4.getNodalConnectivity().getNumberOfTuples());
9338         self.assertEqual(23,mesh2D_5.getNodalConnectivity().getNumberOfTuples());
9339         expected6=[18,0,1,2,3,4,5,6,7]
9340         expected7=[3,3,2,8, 3,2,9,8, 4,0,1,2,3, 4,10,11,2,1, 4,11,12,9,2]
9341         expected8=[3,13,15,14, 3,15,16,14, 4,8,9,15,13, 4,12,17,15,9, 4,17,18,16,15]
9342         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.,
9343                     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.,
9344                     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.]
9345         self.assertEqual(expected6,mesh3D_4.getNodalConnectivity().getValues());
9346         self.assertEqual(expected7,mesh2D_4.getNodalConnectivity().getValues());
9347         self.assertEqual(expected8,mesh2D_5.getNodalConnectivity().getValues());
9348         for i in xrange(57):
9349             self.assertAlmostEqual(expected9[i],mesh3D_4.getCoords().getIJ(0,i),12);
9350             pass
9351         #
9352         pass
9353
9354     def testComputeNeighborsOfCells1(self):
9355         m=MEDCouplingDataForTest.build2DTargetMesh_1();
9356         d1,d2=m.computeNeighborsOfCells();
9357         self.assertEqual(6,d2.getNumberOfTuples());
9358         self.assertEqual(10,d1.getNumberOfTuples());
9359         expected1=[0,2,4,6,8,10]
9360         expected2=[3,1,0,2,4,1,4,0,2,3]
9361         self.assertEqual(expected1,d2.getValues());
9362         self.assertEqual(expected2,d1.getValues());
9363         pass
9364
9365     def testCheckButterflyCellsBug1(self):
9366         mesh2DCoords=[323.85,120.983748908684,317.5,131.982271536747,336.55,120.983748908686,330.2,131.982271536751,323.85,142.98079416481]
9367         mesh2DConn=[4,1,0,2,3]
9368         mesh2D=MEDCouplingUMesh.New("mesh",2);
9369         mesh2D.allocateCells(1);
9370         mesh2D.insertNextCell(NORM_POLYGON,5,mesh2DConn[0:5])
9371         mesh2D.finishInsertingCells();
9372         myCoords=DataArrayDouble.New(mesh2DCoords,5,2);
9373         mesh2D.setCoords(myCoords);
9374         mesh2D.checkCoherency();
9375         #
9376         v=mesh2D.checkButterflyCells();
9377         self.assertTrue(v.empty());
9378         pass
9379
9380     def testDataArrayIntRange1(self):
9381         d=DataArrayInt.Range(2,17,7);
9382         expected1=[2,9,16]
9383         self.assertEqual(3,d.getNumberOfTuples());
9384         self.assertEqual(1,d.getNumberOfComponents());
9385         self.assertEqual(expected1,d.getValues());
9386         #
9387         d=DataArrayInt.Range(2,23,7);
9388         self.assertEqual(3,d.getNumberOfTuples());
9389         self.assertEqual(1,d.getNumberOfComponents());
9390         self.assertEqual(expected1,d.getValues());
9391         #
9392         d=DataArrayInt.Range(2,24,7);
9393         expected2=[2,9,16,23]
9394         self.assertEqual(4,d.getNumberOfTuples());
9395         self.assertEqual(1,d.getNumberOfComponents());
9396         self.assertEqual(expected2,d.getValues());
9397         #
9398         d=DataArrayInt.Range(24,2,-7);
9399         expected3=[24,17,10,3]
9400         self.assertEqual(4,d.getNumberOfTuples());
9401         self.assertEqual(1,d.getNumberOfComponents());
9402         self.assertEqual(expected3,d.getValues());
9403         #
9404         d=DataArrayInt.Range(23,2,-7);
9405         expected4=[23,16,9]
9406         self.assertEqual(3,d.getNumberOfTuples());
9407         self.assertEqual(1,d.getNumberOfComponents());
9408         self.assertEqual(expected4,d.getValues());
9409         #
9410         d=DataArrayInt.Range(23,22,-7);
9411         self.assertEqual(1,d.getNumberOfTuples());
9412         self.assertEqual(1,d.getNumberOfComponents());
9413         self.assertEqual(23,d.getIJ(0,0));
9414         #
9415         d=DataArrayInt.Range(22,23,7);
9416         self.assertEqual(1,d.getNumberOfTuples());
9417         self.assertEqual(1,d.getNumberOfComponents());
9418         self.assertEqual(22,d.getIJ(0,0));
9419         #
9420         d=DataArrayInt.Range(22,22,7);
9421         self.assertEqual(0,d.getNumberOfTuples());
9422         self.assertEqual(1,d.getNumberOfComponents());
9423         #
9424         d=DataArrayInt.Range(22,22,-7);
9425         self.assertEqual(0,d.getNumberOfTuples());
9426         self.assertEqual(1,d.getNumberOfComponents());
9427         #
9428         self.assertRaises(InterpKernelException,DataArrayInt.Range,22,23,-7);
9429         self.assertRaises(InterpKernelException,DataArrayInt.Range,23,22,7);
9430         self.assertRaises(InterpKernelException,DataArrayInt.Range,23,22,0);
9431         self.assertRaises(InterpKernelException,DataArrayInt.Range,22,23,0);
9432         pass
9433
9434     def testSwigUMeshGetItem1(self):
9435         m=MEDCouplingDataForTest.build2DTargetMesh_1();
9436         subMesh=m.buildPartOfMySelf([1,3],True);
9437         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
9438         m1=m[[1,3]]
9439         self.assertTrue(isinstance(m1,MEDCouplingUMesh))
9440         m2=m[(1,3)]
9441         self.assertTrue(isinstance(m2,MEDCouplingUMesh))
9442         m3=m[1::2]
9443         self.assertTrue(isinstance(m3,MEDCouplingUMesh))
9444         m4=m[DataArrayInt.New([1,3])]
9445         m5_1=m[1]
9446         self.assertTrue(isinstance(m5_1,MEDCouplingUMesh))
9447         m5_2=m[3]
9448         self.assertTrue(isinstance(m5_2,MEDCouplingUMesh))
9449         m5=MEDCouplingUMesh.MergeUMeshesOnSameCoords([m5_1,m5_2]);
9450         m5.setName(subMesh.getName())
9451         self.assertTrue(isinstance(m4,MEDCouplingUMesh))
9452         self.assertTrue(subMesh.isEqual(m1,1e-12))
9453         self.assertTrue(subMesh.isEqual(m2,1e-12))
9454         self.assertTrue(subMesh.isEqual(m3,1e-12))
9455         self.assertTrue(subMesh.isEqual(m4,1e-12))
9456         self.assertTrue(subMesh.isEqual(m5,1e-12))
9457         self.assertRaises(InterpKernelException,m.buildPartOfMySelf,[1,5],True);
9458         pass
9459
9460     def testSwigGetItem3(self):
9461         da=DataArrayInt.New([4,5,6])
9462         self.assertEqual(5,da[1])
9463         self.assertRaises(InterpKernelException,da.__getitem__,-1)
9464         self.assertRaises(InterpKernelException,da.__getitem__,3)
9465         da=DataArrayInt.New([4,5,6,7,8,9],2,3)
9466         self.assertEqual(9,da[1,2])
9467         da=DataArrayDouble.New([4.1,5.2,6.3])
9468         self.assertAlmostEqual(5.2,da[1],12)
9469         self.assertRaises(InterpKernelException,da.__getitem__,-1)
9470         self.assertRaises(InterpKernelException,da.__getitem__,3)
9471         da=DataArrayDouble.New([4.12,5.12,6.12,7.12,8.12,9.12],2,3)
9472         self.assertAlmostEqual(9.12,da[1,2],12)
9473         pass
9474
9475     def testSwigDADISub1(self):
9476         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
9477         bary=mesh3D.getBarycenterAndOwner()
9478         bary=bary[:,:2]
9479         pts=bary.getDifferentValues(1e-12)
9480         expected=[[0,6,12],[1,7,13],[2,8,14],[3,9,15],[4,10,16],[5,11,17]]
9481         for pos,pt in enumerate(pts):
9482             bary2=bary[:,:2]
9483             bary2[:]-=pt
9484             norm=bary2.magnitude()
9485             self.assertEqual(expected[pos],norm.getIdsInRange(-1.,1e-5).getValues())
9486             pass
9487         expected2=[[3.,54.],[-141.,180.],[21.,54.],[39.,72.],[-15.,90.],[21.,90.]]
9488         for pos,pt in enumerate(pts):
9489             bary2=bary[:,:2]
9490             bary2[:]+=pt
9491             self.assertAlmostEqual(expected2[pos][0],bary2.accumulate()[0],12);
9492             self.assertAlmostEqual(expected2[pos][1],bary2.accumulate()[1],12);
9493             pass
9494         expected3=[[-3.,22.5],[45.,337.5],[-9., 22.5],[-15.,67.5],[3.,112.5],[-9.,112.5]]
9495         for pos,pt in enumerate(pts):
9496             bary2=bary[:,:2]
9497             bary2[:]*=pt
9498             self.assertAlmostEqual(expected3[pos][0],bary2.accumulate()[0],12);
9499             self.assertAlmostEqual(expected3[pos][1],bary2.accumulate()[1],12);
9500             pass
9501         expected4=[[-12.,90.],[0.8,6.],[-4,90.],[-2.4,30.],[12.,18],[-4,18.]]
9502         for pos,pt in enumerate(pts):
9503             bary2=bary[:,:2]
9504             bary2[:]/=pt
9505             self.assertAlmostEqual(expected4[pos][0],bary2.accumulate()[0],12);
9506             self.assertAlmostEqual(expected4[pos][1],bary2.accumulate()[1],12);
9507             pass
9508         #
9509         d=DataArrayInt.New([1,2,0,1,0,2],3,2)
9510         e=DataArrayInt.New([1,11,101,2,12,102,3,13,103,4,14,104],4,3)
9511         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]]
9512         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]]
9513         for pos,tup in enumerate(d):
9514             f=e[:]
9515             self.assertTrue(isinstance(f,DataArrayInt))
9516             f[tup]=77
9517             self.assertEqual(expected5[pos],f.getValues())
9518             self.assertEqual(6*[77],f[tup].getValues())
9519             f=e[:]
9520             f[:,tup]=77
9521             self.assertEqual(expected6[pos],f.getValues())
9522             self.assertEqual(8*[77],f[:,tup].getValues())
9523             pass
9524         #
9525         e=e.convertToDblArr()
9526         for pos,tup in enumerate(d):
9527             f=e[:]
9528             self.assertTrue(isinstance(f,DataArrayDouble))
9529             f[tup]=77.
9530             self.assertEqual(expected5[pos],f.convertToIntArr().getValues())
9531             self.assertEqual(6*[77],f[tup].convertToIntArr().getValues())
9532             f=e[:]
9533             f[:,tup]=77.
9534             self.assertEqual(expected6[pos],f.convertToIntArr().getValues())
9535             self.assertEqual(8*[77],f[:,tup].convertToIntArr().getValues())
9536             pass
9537         pass
9538
9539     def testDataArrayDoubleGetMinMaxPerComponent1(self):
9540         values1=[1.,2.,3.,-0.9,2.1,3.,1.3,1.7,3.,1.,1.8,3.]
9541         d1=DataArrayDouble.New();
9542         self.assertRaises(InterpKernelException,d1.getMinMaxPerComponent)
9543         d1=DataArrayDouble.New(values1,4,3);
9544         res=d1.getMinMaxPerComponent();
9545         self.assertTrue(isinstance(res,list))
9546         self.assertEqual(3,len(res))
9547         for i in xrange(3):
9548             self.assertTrue(isinstance(res[i],tuple))
9549             self.assertEqual(2,len(res[i]))
9550             pass
9551         expected1=[-0.9,1.3,1.7,2.1,3.,3.]
9552         for i in xrange(6):
9553             self.assertAlmostEqual(expected1[i],res[i/2][i%2],14)
9554             pass
9555         #
9556         d1.rearrange(2);
9557         res=d1.getMinMaxPerComponent();
9558         self.assertTrue(isinstance(res,list))
9559         self.assertEqual(2,len(res))
9560         for i in xrange(2):
9561             self.assertTrue(isinstance(res[i],tuple))
9562             self.assertEqual(2,len(res[i]))
9563             pass
9564         expected2=[1.,3.,-0.9,3.]
9565         for i in xrange(4):
9566             self.assertAlmostEqual(expected2[i],res[i/2][i%2],14)
9567             pass
9568         #
9569         d1.rearrange(1);
9570         res=d1.getMinMaxPerComponent();
9571         self.assertTrue(isinstance(res,list))
9572         self.assertEqual(1,len(res))
9573         for i in xrange(1):
9574             self.assertTrue(isinstance(res[i],tuple))
9575             self.assertEqual(2,len(res[i]))
9576             pass
9577         expected3=[-0.9,3.]
9578         for i in xrange(2):
9579             self.assertAlmostEqual(expected3[i],res[i/2][i%2],14)
9580             pass
9581         pass
9582
9583     def testDataArrayIntGetHashCode1(self):
9584         d1=DataArrayInt.New(range(3545))
9585         d2=DataArrayInt.New(range(3545))
9586         self.assertEqual(d2.getHashCode(),d1.getHashCode())
9587         self.assertEqual(232341068,d1.getHashCode())
9588         d1[886]=6
9589         self.assertEqual(232340188,d1.getHashCode())
9590         pass
9591
9592     def testZipConnectivityPol1(self):
9593         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
9594         cells1=[2,3,4]
9595         m2_1=m1.buildPartOfMySelf(cells1,True);
9596         m2=m2_1
9597         self.assertTrue(isinstance(m2,MEDCouplingUMesh))
9598         # no permutation policy 0
9599         isOk,arr=m1.areCellsIncludedIn(m2,0)
9600         self.assertTrue(isOk);
9601         self.assertEqual(3,arr.getNumberOfTuples());
9602         self.assertEqual(1,arr.getNumberOfComponents());
9603         self.assertEqual(cells1,arr.getValues())
9604         # no permutation policy 1
9605         isOk,arr=m1.areCellsIncludedIn(m2,1)
9606         self.assertTrue(isOk);
9607         self.assertEqual(3,arr.getNumberOfTuples());
9608         self.assertEqual(1,arr.getNumberOfComponents());
9609         self.assertEqual(cells1,arr.getValues())
9610         # no permutation policy 2
9611         isOk,arr=m1.areCellsIncludedIn(m2,2)
9612         self.assertTrue(isOk);
9613         self.assertEqual(3,arr.getNumberOfTuples());
9614         self.assertEqual(1,arr.getNumberOfComponents());
9615         self.assertEqual(cells1,arr.getValues())
9616         # some modification into m2
9617         modif1=[2,4,5]
9618         m2.getNodalConnectivity()[1:4]=modif1
9619         #policy 0 fails because cell0 in m2 has same orientation be not same connectivity
9620         expected1=[5,3,4]
9621         isOk,arr=m1.areCellsIncludedIn(m2,0)
9622         self.assertTrue(not isOk);
9623         self.assertEqual(3,arr.getNumberOfTuples());
9624         self.assertEqual(1,arr.getNumberOfComponents());
9625         self.assertEqual(expected1,arr.getValues())
9626         #policy 1 succeeds because cell0 in m2 has not exactly the same conn
9627         isOk,arr=m1.areCellsIncludedIn(m2,1)
9628         self.assertTrue(isOk);
9629         self.assertEqual(3,arr.getNumberOfTuples());
9630         self.assertEqual(1,arr.getNumberOfComponents());
9631         self.assertEqual(cells1,arr.getValues())
9632         #policy 2 succeeds because cell0 in m2 has same nodes in connectivity
9633         isOk,arr=m1.areCellsIncludedIn(m2,2)
9634         self.assertTrue(isOk);
9635         self.assertEqual(3,arr.getNumberOfTuples());
9636         self.assertEqual(1,arr.getNumberOfComponents());
9637         self.assertEqual(cells1,arr.getValues())
9638         #some new modification into m2
9639         modif2=[2,5,4]
9640         m2.getNodalConnectivity()[1:4]=modif2
9641         #policy 0 fails because cell0 in m2 has not exactly the same conn
9642         isOk,arr=m1.areCellsIncludedIn(m2,0)
9643         self.assertTrue(not isOk);
9644         self.assertEqual(3,arr.getNumberOfTuples());
9645         self.assertEqual(1,arr.getNumberOfComponents());
9646         self.assertEqual(expected1,arr.getValues())
9647         #policy 1 fails too because cell0 in m2 has not same orientation
9648         isOk,arr=m1.areCellsIncludedIn(m2,1)
9649         self.assertTrue(not isOk);
9650         self.assertEqual(3,arr.getNumberOfTuples());
9651         self.assertEqual(1,arr.getNumberOfComponents());
9652         self.assertEqual(expected1,arr.getValues())
9653         #policy 2 succeeds because cell0 in m2 has same nodes in connectivity
9654         isOk,arr=m1.areCellsIncludedIn(m2,2)
9655         self.assertTrue(isOk);
9656         self.assertEqual(3,arr.getNumberOfTuples());
9657         self.assertEqual(1,arr.getNumberOfComponents());
9658         self.assertEqual(cells1,arr.getValues())
9659         # Now 1D
9660         cells2=[3,2]
9661         m1=MEDCouplingDataForTest.build1DSourceMesh_2();
9662         m2_1=m1.buildPartOfMySelf(cells2,True);
9663         m2=m2_1
9664         self.assertTrue(isinstance(m2,MEDCouplingUMesh))
9665         # no permutation policy 0
9666         isOk,arr=m1.areCellsIncludedIn(m2,0)
9667         self.assertTrue(isOk);
9668         self.assertEqual(2,arr.getNumberOfTuples());
9669         self.assertEqual(1,arr.getNumberOfComponents());
9670         self.assertEqual(cells2,arr.getValues())
9671         # no permutation policy 1
9672         isOk,arr=m1.areCellsIncludedIn(m2,1)
9673         self.assertTrue(isOk);
9674         self.assertEqual(2,arr.getNumberOfTuples());
9675         self.assertEqual(1,arr.getNumberOfComponents());
9676         self.assertEqual(cells2,arr.getValues())
9677         # no permutation policy 2
9678         isOk,arr=m1.areCellsIncludedIn(m2,2)
9679         self.assertTrue(isOk);
9680         self.assertEqual(2,arr.getNumberOfTuples());
9681         self.assertEqual(1,arr.getNumberOfComponents());
9682         self.assertEqual(cells2,arr.getValues())
9683         # some modification into m2
9684         modif3=[4,3]
9685         m2.getNodalConnectivity()[1:3]=modif3
9686         #policy 0 fails because cell0 in m2 has not exactly the same conn
9687         expected2=[4,2]
9688         isOk,arr=m1.areCellsIncludedIn(m2,0)
9689         self.assertTrue(not isOk);
9690         self.assertEqual(2,arr.getNumberOfTuples());
9691         self.assertEqual(1,arr.getNumberOfComponents());
9692         self.assertEqual(expected2,arr.getValues())
9693         #policy 1 fails too because cell0 in m2 has not same orientation
9694         isOk,arr=m1.areCellsIncludedIn(m2,1)
9695         self.assertTrue(not isOk);
9696         self.assertEqual(2,arr.getNumberOfTuples());
9697         self.assertEqual(1,arr.getNumberOfComponents());
9698         self.assertEqual(expected2,arr.getValues())
9699         #policy 2 succeeds because cell0 in m2 has same nodes in connectivity
9700         isOk,arr=m1.areCellsIncludedIn(m2,2)
9701         self.assertTrue(isOk);
9702         self.assertEqual(2,arr.getNumberOfTuples());
9703         self.assertEqual(1,arr.getNumberOfComponents());
9704         self.assertEqual(cells2,arr.getValues())
9705         pass
9706
9707     def toSeeIfDaIIopsAreOK(self,d):
9708         d+=5
9709         d*=6
9710         d/=3
9711         d-=2
9712         d%=7
9713         pass
9714
9715     def testSwigDAIOp5(self):
9716         d=DataArrayInt.New([4,5,6,10,3,-1],2,3)
9717         self.toSeeIfDaIIopsAreOK(d)
9718         dExp=DataArrayInt.New([2,4,6,0,0,6],2,3)
9719         self.assertTrue(d.isEqual(dExp));
9720         pass
9721
9722     def toSeeIfDaDIopsAreOK(self,d):
9723         d+=5
9724         d*=6
9725         d/=3
9726         d-=2
9727         pass
9728
9729     def testSwigDADOp7(self):
9730         d=DataArrayDouble.New([4.,5.,6.,10.,3.,-1.],2,3)
9731         self.toSeeIfDaDIopsAreOK(d)
9732         dExp=DataArrayDouble.New([16.,18.,20.,28.,14.,6.],2,3)
9733         self.assertTrue(d.isEqual(dExp,1e-14));
9734         pass
9735
9736     def testConvexEnvelop2D1(self):
9737         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]
9738         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]
9739         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]
9740         #
9741         m=MEDCouplingUMesh.New("convexhull",2);
9742         m.allocateCells(331);
9743         for i in xrange(331):
9744             m.insertNextCell(NORM_POLYGON,conn[connI[i]:connI[i+1]]);
9745             pass
9746         m.finishInsertingCells();
9747         coordsDa=DataArrayDouble.New(coords,331,2);
9748         m.setCoords(coordsDa);
9749         m.checkCoherency();
9750         #
9751         da=m.convexEnvelop2D();
9752         m.checkCoherency()
9753         self.assertEqual(coordsDa.getHiddenCppPointer(),m.getCoords().getHiddenCppPointer())
9754         daC=da.buildComplement(m.getNumberOfCells());
9755         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]);
9756         self.assertTrue(expected2.isEqual(daC));
9757         #
9758         vals=m.getMeasureField(ON_CELLS).getArray()
9759         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]
9760         vals-=DataArrayDouble.New(ref)
9761         vals.abs()
9762         theTest=vals.getIdsInRange(-1.,1e-7)
9763         self.assertTrue(theTest.isIdentity())
9764         self.assertEqual(331,len(theTest))
9765         pass
9766
9767     def testSwigDAIOp8(self):
9768         da=DataArrayInt.New([7,5,6,7,8,9,9,10,12,13,47,15])
9769         self.assertTrue(7 in da)
9770         self.assertTrue(47 in da)
9771         self.assertTrue(15 in da)
9772         self.assertEqual(0,da.index(7))
9773         self.assertEqual(10,da.index(47))
9774         self.assertTrue(14 not in da)
9775         self.assertEqual(5,da.search([9,9]))
9776         self.assertEqual(-1,da.search([5,8]))
9777         da.rearrange(2)
9778         self.assertTrue([47,16] not in da)
9779         self.assertTrue([5,6] not in da)
9780         self.assertTrue([6,7] in da)
9781         self.assertEqual(4,da.index([12,13]))
9782         pass
9783
9784     def testDataArraySort1(self):
9785         arr=DataArrayInt.New();
9786         self.assertRaises(InterpKernelException,arr.sort,True)
9787         self.assertRaises(InterpKernelException,arr.sort,False)
9788         values=[2,1,6,5,4,7]
9789         arr.alloc(3,2);
9790         self.assertRaises(InterpKernelException,arr.sort,True)
9791         self.assertRaises(InterpKernelException,arr.sort,False)
9792         arr.rearrange(1);
9793         arr.setValues(values,6,1)
9794         arr1=arr.deepCpy();
9795         arr2=arr.deepCpy();
9796         arr1.sort(True);
9797         expected1=[1,2,4,5,6,7]
9798         self.assertEqual(6,arr1.getNumberOfTuples());
9799         self.assertEqual(1,arr1.getNumberOfComponents());
9800         self.assertEqual(expected1,arr1.getValues());
9801         arr2.sort(False);
9802         expected2=[7,6,5,4,2,1]
9803         self.assertEqual(6,arr2.getNumberOfTuples());
9804         self.assertEqual(1,arr2.getNumberOfComponents());
9805         self.assertTrue(expected2,arr2.getValues());
9806         #
9807         ard=DataArrayDouble.New();
9808         self.assertRaises(InterpKernelException,ard.sort,True)
9809         self.assertRaises(InterpKernelException,ard.sort,False)
9810         valuesD=[2.,1.,6.,5.,4.,7.]
9811         ard.alloc(3,2);
9812         self.assertRaises(InterpKernelException,ard.sort,True)
9813         self.assertRaises(InterpKernelException,ard.sort,False)
9814         ard.rearrange(1);
9815         ard.setValues(valuesD,6,1)
9816         ard1=ard.deepCpy();
9817         ard2=ard.deepCpy();
9818         ard1.sort(True);
9819         expected3=[1.,2.,4.,5.,6.,7.]
9820         self.assertEqual(6,ard1.getNumberOfTuples());
9821         self.assertEqual(1,ard1.getNumberOfComponents());
9822         for i in xrange(6):
9823             self.assertAlmostEqual(expected3[i],ard1.getIJ(i,0),12)
9824             pass
9825         ard2.sort(False);
9826         expected4=[7.,6.,5.,4.,2.,1.]
9827         self.assertEqual(6,ard2.getNumberOfTuples());
9828         self.assertEqual(1,ard2.getNumberOfComponents());
9829         for i in xrange(6):
9830             self.assertAlmostEqual(expected4[i],ard2.getIJ(i,0),12)
9831             pass
9832         pass
9833
9834     def testPartitionBySpreadZone1(self):
9835         m=MEDCouplingDataForTest.build2DTargetMesh_1();
9836         m4=MEDCouplingUMesh.MergeUMeshes([m,m[-3:],m[0:2]]);
9837         m4.renumberCells([5,2,9,6,4,7,0,1,3,8]);
9838         #
9839         v2=m4.partitionBySpreadZone();
9840         self.assertTrue(3,len(v2));
9841         self.assertTrue(v2[0].isEqual(DataArrayInt.New([0,1,7])))
9842         self.assertTrue(v2[1].isEqual(DataArrayInt.New([2,4,5,6,9])))
9843         self.assertTrue(v2[2].isEqual(DataArrayInt.New([3,8])))
9844         #
9845         m5=m4.buildSpreadZonesWithPoly();
9846         self.assertEqual(3,m5.getNumberOfCells());
9847         self.assertTrue(m5.getCoords().getHiddenCppPointer()==m4.getCoords().getHiddenCppPointer());
9848         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())
9849         self.assertEqual([0,8,17,23],m5.getNodalConnectivityIndex().getValues())
9850         #
9851         pass
9852
9853     def testGiveCellsWithType1(self):
9854         expected0=[1,2]
9855         expected1=[0,3,4]
9856         m=MEDCouplingDataForTest.build2DTargetMesh_1();
9857         da=m.giveCellsWithType(NORM_TRI3);
9858         self.assertEqual(2,da.getNumberOfTuples());
9859         self.assertEqual(1,da.getNumberOfComponents());
9860         self.assertEqual(expected0,da.getValues())
9861         #
9862         da=m.giveCellsWithType(NORM_QUAD4);
9863         self.assertEqual(3,da.getNumberOfTuples());
9864         self.assertEqual(1,da.getNumberOfComponents());
9865         self.assertEqual(expected1,da.getValues())
9866         #
9867         da=m.giveCellsWithType(NORM_TRI6);
9868         self.assertEqual(0,da.getNumberOfTuples());
9869         self.assertEqual(1,da.getNumberOfComponents());
9870         #
9871         self.assertRaises(InterpKernelException,m.giveCellsWithType,NORM_SEG2)
9872         self.assertRaises(InterpKernelException,m.giveCellsWithType,NORM_HEXA8)
9873         pass
9874
9875     def testSwigDAOp1(self):
9876         d=DataArrayDouble.New(5,2)
9877         d.rearrange(1) ; d.iota(2.) ; d.rearrange(2)
9878         d.setInfoOnComponents(["X [m]","Y [m]"])
9879         d.setName("AName")
9880         #
9881         d1=d+[8,9]
9882         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))
9883         d1bis=DataArrayDouble.New([8,9],1,2)+d
9884         self.assertTrue(d1bis.isEqual(d1,1e-12))
9885         d1ter=[8,9]+d
9886         self.assertTrue(d1ter.isEqual(d1,1e-12))
9887         #
9888         d2=d1-[8,9]
9889         self.assertTrue(d2.isEqual(d,1e-12))
9890         self.assertRaises(InterpKernelException,d1.__rsub__,[8,9])#[8,9]-d1
9891         #
9892         d3=d*[8,9]
9893         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))
9894         d3bis=DataArrayDouble.New([8,9],1,2)*d
9895         self.assertTrue(d3bis.isEqual(d3,1e-12))
9896         d3ter=[8,9]*d
9897         self.assertTrue(d3ter.isEqual(d3,1e-12))
9898         #
9899         d4=d3/[8,9]
9900         self.assertTrue(d4.isEqual(d,1e-12))
9901         #
9902         d=DataArrayInt.New(5,2)
9903         d.rearrange(1) ; d.iota(2) ; d.rearrange(2)
9904         d.setInfoOnComponents(["X [m]","Y [m]"])
9905         d.setName("AName")
9906         #
9907         d1=d+[8,9]
9908         self.assertEqual(d1.getValues(),[10,12,12,14,14,16,16,18,18,20])
9909         d1bis=DataArrayInt.New([8,9],1,2)+d
9910         self.assertTrue(d1bis.isEqual(d1))
9911         d1ter=[8,9]+d
9912         self.assertTrue(d1ter.isEqual(d1))
9913         #
9914         d2=d1-[8,9]
9915         self.assertTrue(d2.isEqual(d))
9916         self.assertRaises(InterpKernelException,d1.__rsub__,[8,9])
9917         #
9918         d3=d*[8,9]
9919         self.assertEqual(d3.getValues(),[16,27,32,45,48,63,64,81,80,99])
9920         d3bis=DataArrayInt.New([8,9],1,2)*d
9921         self.assertTrue(d3bis.isEqual(d3))
9922         d3ter=[8,9]*d
9923         self.assertTrue(d3ter.isEqual(d3))
9924         #
9925         d4=d3/[8,9]
9926         self.assertTrue(d4.isEqual(d))
9927         #
9928         d5=d%[4,5]
9929         self.assertEqual(d5.getValues(),[2,3,0,0,2,2,0,4,2,1])
9930         pass
9931
9932     def testSwigSelectTupleId2DAIBug1(self):
9933         da=DataArrayInt.New([0,1,2,3,12,13,4,5,6,7,14,15,8,9,10,11,16,17])
9934         self.assertEqual([2,6,10],da[2::6].getValues())
9935         self.assertEqual([0,4,8],da[::6].getValues())
9936         self.assertEqual([5,9],da[7::6].getValues())
9937         self.assertEqual([5],da[7:-5:6].getValues())
9938         pass
9939
9940     def testSwigCpp5Safe1(self):
9941         m=MEDCouplingUMesh.New("toto",2)
9942         coords=DataArrayDouble.New([0.,0.,1.,0.,1.,1.,0.,1.],4,2)
9943         m.setCoords(coords)
9944         vecs=DataArrayDouble.New([2.,3.,4.,5.,6.,7.],3,2)
9945         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]]
9946         for pos,vec in enumerate(vecs):
9947             m2=m.deepCpy()
9948             m2.translate(vec)
9949             self.assertTrue(m2.getCoords().isEqual(DataArrayDouble.New(expected1[pos],4,2),1e-12))
9950             pass
9951         for pos,vec in enumerate(vecs):
9952             m2=m.deepCpy()
9953             m2.translate(vec.buildDADouble())
9954             self.assertTrue(m2.getCoords().isEqual(DataArrayDouble.New(expected1[pos],4,2),1e-12))
9955             pass
9956         pass
9957
9958     def testSwigBugNonRegressionZipDA(self):
9959         angles=map(lambda x:pi/3*x,xrange(6))
9960         radius=3
9961         #
9962         dad=DataArrayDouble.New(6, 2)
9963         dad[:,0]=radius
9964         dad[:,1]=angles
9965         #
9966         dad2=dad.fromPolarToCart()
9967         dads=[dad2.deepCpy() for elt in 7*[None]]
9968         #
9969         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.)]]
9970         for d,t in zip(dads,translationToPerform):
9971             d+=t
9972             pass
9973         for elt in dads:
9974             self.assertTrue(not dad2.isEqual(elt,1e-12))
9975             pass
9976         for d,t in zip(dads,translationToPerform):
9977             d-=t
9978             pass
9979         for elt in dads:
9980             self.assertTrue(dad2.isEqual(elt,1e-12))
9981             pass
9982         pass
9983
9984     def testBuildSlice3D2(self):
9985         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
9986         vec1=[-0.07,1.,0.07]
9987         origin1=[1.524,1.4552,1.74768]
9988         slice1,ids=mesh3D.buildSlice3D(origin1,vec1,1e-10);
9989         f=MEDCouplingFieldDouble(ON_CELLS,ONE_TIME)
9990         f.setTime(4.5,6,7) ; f.setMesh(mesh3D)
9991         arr=DataArrayDouble(mesh3D.getNumberOfCells(),2)
9992         arr.rearrange(1) ; arr.iota(2.) ; arr.rearrange(2)
9993         f.setArray(arr)
9994         f.checkCoherency()
9995         expected1=DataArrayInt([1,3,4,7,9,10,13,15,16])
9996         self.assertTrue(expected1.isEqual(ids))
9997         arr2=arr[expected1]
9998         #
9999         f2=f.extractSlice3D(origin1,vec1,1e-10)
10000         self.assertTrue(f2.getArray().isEqual(arr2,1e-12));
10001         self.assertTrue(slice1.isEqual(f2.getMesh(),1e-12))
10002         self.assertEqual(6,f2.getTime()[1]) ; self.assertEqual(7,f2.getTime()[2])
10003         self.assertAlmostEqual(4.5,f2.getTime()[0],12);
10004         pass
10005
10006     def testComputeTupleIdsToSelectFromCellIds1(self):
10007         m=MEDCouplingDataForTest.build2DTargetMesh_3()
10008         f=MEDCouplingFieldDouble.New(ON_GAUSS_NE,NO_TIME);
10009         f.setMesh(m);
10010         arr=DataArrayDouble(52,2) ; arr.rearrange(1) ; arr.iota(7.) ; arr.rearrange(2)
10011         f.setArray(arr)
10012         #
10013         f2=f.buildSubPart([1,5,9])
10014         f2.checkCoherency()
10015         cI=m.computeNbOfNodesPerCell()
10016         cI.computeOffsets2()
10017         sel=DataArrayInt([1,5,9])
10018         res=sel.buildExplicitArrByRanges(cI)
10019         arr2=arr[res]
10020         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))
10021         self.assertTrue(arr2.isEqual(f2.getArray(),1e-12))
10022         pass
10023
10024     def testComputeSkin1(self):
10025         arrX=DataArrayDouble([2.,3.4,5.6,7.7,8.0]) ; arrY=DataArrayDouble([2.,3.4,5.6,7.7,9.0,14.2])
10026         cmesh=MEDCouplingCMesh() ; cmesh.setCoordsAt(0,arrX) ; cmesh.setCoordsAt(1,arrY)
10027         umesh=cmesh.buildUnstructured()
10028         #
10029         skin=umesh.computeSkin()
10030         self.assertEqual(18,skin.getNumberOfCells())
10031         self.assertEqual(1,skin.getMeshDimension())
10032         self.assertTrue(skin.getCoords().getHiddenCppPointer()==umesh.getCoords().getHiddenCppPointer())
10033         self.assertEqual([0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48,51,54],skin.getNodalConnectivityIndex().getValues())
10034         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())
10035         ids=skin.computeFetchedNodeIds()
10036         self.assertEqual([0,1,2,3,4,5,9,10,14,15,19,20,24,25,26,27,28,29],ids.getValues())
10037         part=umesh.buildFacePartOfMySelfNode(ids,True)
10038         part.setName(skin.getName());
10039         self.assertTrue(part.isEqual(skin,1e-12))
10040         part2=part[1::2]
10041         part[::2]=part2
10042         self.assertTrue(not part.isEqual(skin,1e-12))
10043         trad=part.zipConnectivityTraducer(0)
10044         self.assertEqual(9,part.getNumberOfCells())
10045         self.assertEqual([0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8],trad.getValues())
10046         pass
10047
10048     def testUMeshSetPartOfMySelf2(self):
10049         # resize with explicit ids list
10050         m=MEDCouplingDataForTest.build2DTargetMesh_1()
10051         self.assertEqual([3,4],m.getAllTypes())
10052         part=m[[0,3,4]]
10053         part.simplexize(0)
10054         part2=part[[1,2,5]]
10055         m[[0,3,4]]=part2
10056         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())
10057         self.assertEqual([0,4,8,12,16,20],m.getNodalConnectivityIndex().getValues())
10058         self.assertEqual([3],m.getAllTypes())
10059         # no resize with explicit ids list
10060         m=MEDCouplingDataForTest.build2DTargetMesh_1()
10061         part=m[[0,3]]
10062         part.convertAllToPoly()
10063         m[[3,4]]=part
10064         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())
10065         self.assertEqual([0,5,9,13,18,23],m.getNodalConnectivityIndex().getValues())
10066         self.assertEqual([3,4,5],m.getAllTypes())
10067         # resize with range ids
10068         m=MEDCouplingDataForTest.build2DTargetMesh_1()
10069         part=m[3:]
10070         m[1:3]=part
10071         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())
10072         self.assertEqual([0,5,10,15,20,25],m.getNodalConnectivityIndex().getValues())
10073         self.assertEqual([4],m.getAllTypes())
10074         # no resize with range ids
10075         m=MEDCouplingDataForTest.build2DTargetMesh_1()
10076         part=m[0::3]
10077         part.convertAllToPoly()
10078         m[3:]=part
10079         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())
10080         self.assertEqual([0,5,9,13,18,23],m.getNodalConnectivityIndex().getValues())
10081         self.assertEqual([3,4,5],m.getAllTypes())
10082         # no resize with range ids negative direction
10083         m=MEDCouplingDataForTest.build2DTargetMesh_1()
10084         part=m[3::-3]
10085         part.convertAllToPoly()
10086         m[:-3:-1]=part
10087         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())
10088         self.assertEqual([0,5,9,13,18,23],m.getNodalConnectivityIndex().getValues())
10089         self.assertEqual([3,4,5],m.getAllTypes())
10090         pass
10091
10092     def testUnPolyze3(self):
10093         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]
10094         conn=[1,2,5,4,-1,4,3,0,1,-1,2,0,3,5,-1,0,2,1,-1,4,5,3]
10095         m=MEDCouplingUMesh.New("a mesh",3);
10096         m.allocateCells(1);
10097         m.insertNextCell(NORM_POLYHED,22,conn[0:22])
10098         m.finishInsertingCells();
10099         coords=DataArrayDouble(coord,6,3);
10100         m.setCoords(coords);
10101         m.checkCoherency();
10102         #
10103         vol=m.getMeasureField(ON_CELLS);
10104         self.assertEqual(1,vol.getArray().getNumberOfTuples());
10105         self.assertAlmostEqual(0.5,vol.getArray().getIJ(0,0),12)
10106         #
10107         m.unPolyze();
10108         #
10109         self.assertEqual([NORM_PENTA6],m.getAllTypes())
10110         self.assertTrue(DataArrayInt([0,7]).isEqual(m.getNodalConnectivityIndex()))
10111         self.assertTrue(DataArrayInt([16,0,2,1,3,5,4]).isEqual(m.getNodalConnectivity()))
10112         #
10113         vol=m.getMeasureField(ON_CELLS);
10114         self.assertEqual(1,vol.getArray().getNumberOfTuples());
10115         self.assertAlmostEqual(0.5,vol.getArray().getIJ(0,0),12)
10116         pass
10117
10118     def testKrSpatialDiscretization1(self):
10119         srcPointCoordsX=[0.8401877171547095, 0.7830992237586059, 0.9116473579367843, 0.335222755714889, 0.2777747108031878, 0.4773970518621602, 0.3647844727918433, 0.9522297251747128, 0.6357117279599009, 0.1416025553558034]
10120         srcFieldValsOnPoints=[2.129892434968836, 2.295320474540621, 1.931948594981134, 2.728013590937196, 2.715603240418478, 2.661778472822935, 2.695696990104364, 1.893710234970982, 2.529628016549284, 2.728432341300668]
10121         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]
10122         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]
10123         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])
10124         #
10125         nbOfInputPoints=10;
10126         f=MEDCouplingFieldDouble.New(ON_NODES_KR,ONE_TIME);
10127         srcArrX=DataArrayDouble.New(srcPointCoordsX,nbOfInputPoints,1);
10128         cmesh=MEDCouplingCMesh.New("aMesh");
10129         cmesh.setCoordsAt(0,srcArrX);
10130         umesh=cmesh.buildUnstructured();
10131         f.setMesh(umesh);
10132         srcVals=DataArrayDouble.New(srcFieldValsOnPoints,nbOfInputPoints,1);
10133         f.setArray(srcVals);
10134         f.checkCoherency();
10135         #
10136         res0=f.getValueOn(targetPointCoordsX[:1]);
10137         self.assertAlmostEqual(targetFieldValsExpected[0],res0[0],10)
10138         #
10139         valuesToTest=f.getValueOnMulti(targetPointCoordsX);
10140         self.assertEqual(40,valuesToTest.getNumberOfTuples());
10141         self.assertEqual(1,valuesToTest.getNumberOfComponents());
10142         for i in xrange(40):
10143             self.assertAlmostEqual(targetFieldValsExpected[i],valuesToTest.getIJ(i,0),10)
10144             pass
10145         fd=f.getDiscretization()
10146         del f
10147         self.assertTrue(isinstance(fd,MEDCouplingFieldDiscretizationKriging))
10148         coeffs,isDrift=fd.computeVectorOfCoefficients(umesh,srcVals)
10149         self.assertEqual(2,isDrift)
10150         self.assertTrue(coeffsExpected.isEqual(coeffs,1e-8))
10151         #
10152         pass
10153
10154     def testDuplicateEachTupleNTimes1(self):
10155         d=DataArrayDouble.New([9.,8.,7.,6.],4,1) ; d.setInfoOnComponents(["mass [kg]"]) ; d.setName("aname")
10156         d2=d.duplicateEachTupleNTimes(3)
10157         self.assertTrue(d2.isEqualWithoutConsideringStr(DataArrayDouble.New([9.,9.,9.,8.,8.,8.,7.,7.,7.,6.,6.,6.],4*3,1),1e-14))
10158         self.assertEqual("aname",d2.getName())
10159         self.assertEqual(["mass [kg]"],d2.getInfoOnComponents())
10160         #
10161         d=DataArrayInt.New([9,8,7,6],4,1) ; d.setInfoOnComponents(["mass [kg]"]) ; d.setName("aname")
10162         d2=d.duplicateEachTupleNTimes(3)
10163         self.assertTrue(d2.isEqualWithoutConsideringStr(DataArrayInt.New([9,9,9,8,8,8,7,7,7,6,6,6],4*3,1)))
10164         self.assertEqual("aname",d2.getName())
10165         self.assertEqual(["mass [kg]"],d2.getInfoOnComponents())
10166         pass
10167
10168     def testSwigComputeTupleIdsNearTuples1(self):
10169         da=DataArrayDouble([5.,6.,-5.,-6.,5.,-6.,-5.,6.,5.,6.],5,2)
10170         arr,arrI=da.computeTupleIdsNearTuples(DataArrayDouble([5.,-6.,5.,6.,-5.,-6.],3,2),1e-10)
10171         self.assertEqual([2,0,4,1],arr.getValues())
10172         self.assertEqual([0,1,3,4],arrI.getValues())
10173         arr,arrI=da.computeTupleIdsNearTuples([5.,-6.,5.,6.,-5.,-6.],1e-10)
10174         self.assertEqual([2,0,4,1],arr.getValues())
10175         self.assertEqual([0,1,3,4],arrI.getValues())
10176         expected0=[[2],[0,4],[1]]
10177         expected1=[[0,1],[0,2],[0,1]]
10178         for pos,it in enumerate(DataArrayDouble([5.,-6.,5.,6.,-5.,-6.],3,2)):
10179             arr,arrI=da.computeTupleIdsNearTuples(it,1e-10)
10180             self.assertEqual(expected0[pos],arr.getValues())
10181             self.assertEqual(expected1[pos],arrI.getValues())
10182             pass
10183         pass
10184
10185     def testSwigDataTupleIOp1(self):
10186         d=DataArrayDouble(10,1)
10187         d.iota(7.)
10188         for elt in d:
10189             elt+=2.
10190             pass
10191         toTest=DataArrayDouble([9.0,10.0,11.0,12.0,13.0,14.0,15.0,16.0,17.0,18.0])
10192         self.assertTrue(toTest.isEqual(d,1e-12))
10193         for elt in d:
10194             elt-=2.
10195             pass
10196         toTest=DataArrayDouble([7.0,8.0,9.0,10.0,11.0,12.0,13.0,14.0,15.0,16.0])
10197         self.assertTrue(toTest.isEqual(d,1e-12))
10198         for elt in d:
10199             elt*=2.
10200             pass
10201         toTest=DataArrayDouble([14.0,16.0,18.0,20.0,22.0,24.0,26.0,28.0,30.0,32.0])
10202         self.assertTrue(toTest.isEqual(d,1e-12))
10203         for elt in d:
10204             elt/=2.
10205             pass
10206         toTest=DataArrayDouble([7.0,8.0,9.0,10.0,11.0,12.0,13.0,14.0,15.0,16.0])
10207         self.assertTrue(toTest.isEqual(d,1e-12))
10208         #
10209         d=DataArrayInt(10,1)
10210         d.iota(7)
10211         for elt in d:
10212             elt+=2
10213             pass
10214         self.assertEqual(d.getValues(),[9,10,11,12,13,14,15,16,17,18])
10215         for elt in d:
10216             elt-=2
10217             pass
10218         self.assertEqual(d.getValues(),[7,8,9,10,11,12,13,14,15,16])
10219         for elt in d:
10220             elt*=2
10221             pass
10222         self.assertEqual(d.getValues(),[14,16,18,20,22,24,26,28,30,32])
10223         for elt in d:
10224             elt/=2
10225             pass
10226         self.assertEqual(d.getValues(),[7,8,9,10,11,12,13,14,15,16])
10227         for elt in d:
10228             elt%=3
10229             pass
10230         self.assertEqual(d.getValues(),[1,2,0,1,2,0,1,2,0,1])
10231         pass
10232
10233     def setUp(self):
10234         pass
10235     pass
10236
10237 unittest.main()