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         self.assertRaises(InterpKernelException,targetMesh.checkCoherency);
 153         myCoords=DataArrayDouble.New();
 154         myCoords.setValues(targetCoords,9,3);
 155         targetMesh.setCoords(myCoords);
 156         self.assertEqual(targetMesh.getSpaceDimension(),3)
 157         self.assertEqual(targetMesh.getNumberOfCells(),8)
 158         self.assertEqual(targetMesh.getNumberOfNodes(),9)
 159         self.assertEqual(targetMesh.getMeshDimension(),0)
 160         pass
 161
 162     def testMeshM1D(self):
 163         meshM1D=MEDCouplingUMesh.New();
 164         self.assertRaises(InterpKernelException,meshM1D.getMeshDimension);
 165         self.assertRaises(InterpKernelException,meshM1D.getNumberOfNodes);
 166         self.assertRaises(InterpKernelException,meshM1D.getNumberOfCells);
 167         self.assertRaises(InterpKernelException,meshM1D.setMeshDimension,-2)
 168         self.assertRaises(InterpKernelException,meshM1D.setMeshDimension,-10)
 169         meshM1D.setMeshDimension(-1);
 170         meshM1D.checkCoherency();
 171         self.assertEqual(meshM1D.getMeshDimension(),-1);
 172         self.assertEqual(meshM1D.getNumberOfCells(),1);
 173         self.assertRaises(InterpKernelException,meshM1D.getNumberOfNodes);
 174         self.assertRaises(InterpKernelException,meshM1D.getSpaceDimension);
 175         cpy=meshM1D.clone(True);
 176         self.assertTrue(cpy.isEqual(meshM1D,1e-12));
 177         fieldOnCells=MEDCouplingFieldDouble.New(ON_CELLS);
 178         fieldOnCells.setMesh(meshM1D);
 179         array=DataArrayDouble.New();
 180         array.setValues(6*[7.],1,6);
 181         fieldOnCells.setArray(array);
 182         fieldOnCells.checkCoherency();
 183         pass
 184
 185     def testDeepCopy(self):
 186         array=DataArrayDouble.New();
 187         array.setValues(5*3*[7.],5,3);
 188         self.assertEqual(array.getIJ(3,2),7.);
 189         array2=array.deepCpy();
 190         self.assertEqual(array2.getIJ(3,2),7.)
 191         #
 192         array3=DataArrayInt.New();
 193         array3.setValues(5*3*[17],5,3);
 194         self.assertEqual(array3.getIJ(3,2),17);
 195         array4=array3.deepCpy();
 196         self.assertEqual(array4.getIJ(3,2),17);
 197         pass
 198
 199     def testRevNodal(self):
 200         mesh=MEDCouplingDataForTest.build2DTargetMesh_1()
 201         revNodal,revNodalIndx=mesh.getReverseNodalConnectivity();
 202         revNodalExpected=[0,0,1,1,2,0,3,0,1,2,3,4,2,4,3,3,4,4];
 203         revNodalIndexExpected=[0,1,3,5,7,12,14,15,17,18];
 204         self.assertEqual(revNodal.getNbOfElems(),18)
 205         self.assertEqual(revNodalIndx.getNbOfElems(),10)
 206         self.assertEqual(list(revNodal.getValues()),revNodalExpected)
 207         self.assertEqual(list(revNodalIndx.getValues()),revNodalIndexExpected)
 208         pass
 209
 210     def testConvertToPolyTypes(self):
 211         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
 212         elts=[1,3];
 213         mesh.convertToPolyTypes(elts);
 214         mesh.checkCoherency();
 215         self.assertEqual(5,mesh.getNumberOfCells());
 216         self.assertEqual(23,mesh.getNodalConnectivity().getNumberOfTuples());
 217         expected1=[4, 0, 3, 4, 1, 5, 1, 4, 2, 3, 4, 5, 2, 5, 6, 7, 4, 3, 4, 7, 8, 5, 4]
 218         self.assertEqual(expected1,list(mesh.getNodalConnectivity().getValues()));
 219         #
 220         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
 221         mesh.convertToPolyTypes(elts);
 222         mesh.checkCoherency();
 223         self.assertEqual(8,mesh.getNumberOfCells());
 224         self.assertEqual(114,mesh.getNodalConnectivity().getNumberOfTuples());
 225         mesh.convertToPolyTypes(elts);
 226         mesh.checkCoherency();
 227         self.assertEqual(8,mesh.getNumberOfCells());
 228         self.assertEqual(114,mesh.getNodalConnectivity().getNumberOfTuples());
 229         pass
 230
 231     def testDescConn2D(self):
 232         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
 233         desc=DataArrayInt.New();
 234         descIndx=DataArrayInt.New();
 235         revDesc=DataArrayInt.New();
 236         revDescIndx=DataArrayInt.New();
 237         mesh2=mesh.buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
 238         mesh2.checkCoherency();
 239         self.assertEqual(1,mesh2.getMeshDimension());
 240         self.assertEqual(13,mesh2.getNumberOfCells());
 241         self.assertEqual(14,revDescIndx.getNbOfElems()); self.assertEqual(14,revDescIndx.getNumberOfTuples());
 242         self.assertEqual(6,descIndx.getNbOfElems()); self.assertEqual(6,descIndx.getNumberOfTuples());
 243         self.assertEqual(18,desc.getNbOfElems()); self.assertEqual(18,desc.getNumberOfTuples());
 244         self.assertEqual(18,revDesc.getNbOfElems()); self.assertEqual(18,revDesc.getNumberOfTuples());
 245         expected1=[0,1,2,3, 2,4,5, 6,7,4, 8,9,1,10, 11,12,6,9];
 246         self.assertEqual(expected1,list(desc.getValues()));
 247         expected2=[0,4,7,10,14,18];
 248         self.assertEqual(expected2,list(descIndx.getValues()));
 249         expected3=[0,1,3,5,6,8,9,11,12,13,15,16,17,18];
 250         self.assertEqual(expected3,list(revDescIndx.getValues()));
 251         expected4=[0, 0,3, 0,1, 0, 1,2, 1, 2,4, 2, 3, 3,4, 3, 4, 4];
 252         self.assertEqual(expected4,list(revDesc.getValues()));
 253         conn=mesh2.getNodalConnectivity();
 254         connIndex=mesh2.getNodalConnectivityIndex();
 255         expected5=[0,3,6,9,12,15,18,21,24,27,30,33,36,39];
 256         self.assertEqual(expected5,list(connIndex.getValues()));
 257         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];
 258         self.assertEqual(expected6,list(conn.getValues()));
 259         #
 260         eltsV=[1,3];
 261         mesh.convertToPolyTypes(eltsV);
 262         mesh.checkCoherency();
 263         #
 264         desc=DataArrayInt.New();
 265         descIndx=DataArrayInt.New();
 266         revDesc=DataArrayInt.New();
 267         revDescIndx=DataArrayInt.New();
 268         #
 269         mesh2=mesh.buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
 270         mesh2.checkCoherency();
 271         self.assertEqual(1,mesh2.getMeshDimension());
 272         self.assertEqual(13,mesh2.getNumberOfCells());
 273         self.assertEqual(14,revDescIndx.getNbOfElems()); self.assertEqual(14,revDescIndx.getNumberOfTuples());
 274         self.assertEqual(6,descIndx.getNbOfElems()); self.assertEqual(6,descIndx.getNumberOfTuples());
 275         self.assertEqual(18,desc.getNbOfElems()); self.assertEqual(18,desc.getNumberOfTuples());
 276         self.assertEqual(18,revDesc.getNbOfElems()); self.assertEqual(18,revDesc.getNumberOfTuples());
 277         self.assertEqual(expected1,list(desc.getValues()));
 278         self.assertEqual(expected2,list(descIndx.getValues()));
 279         self.assertEqual(expected3,list(revDescIndx.getValues()));
 280         self.assertEqual(expected4,list(revDesc.getValues()));
 281         conn=mesh2.getNodalConnectivity();
 282         connIndex=mesh2.getNodalConnectivityIndex();
 283         self.assertEqual(expected5,list(connIndex.getValues()));
 284         self.assertEqual(expected6,list(conn.getValues()));
 285         pass
 286
 287     def testDescConn3D(self):
 288         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
 289         desc=DataArrayInt.New();
 290         descIndx=DataArrayInt.New();
 291         revDesc=DataArrayInt.New();
 292         revDescIndx=DataArrayInt.New();
 293         #
 294         mesh2=mesh.buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
 295         mesh2.checkCoherency();
 296         self.assertEqual(2,mesh2.getMeshDimension());
 297         self.assertEqual(36,mesh2.getNumberOfCells());
 298         self.assertEqual(37,revDescIndx.getNbOfElems()); self.assertEqual(37,revDescIndx.getNumberOfTuples());
 299         self.assertEqual(9,descIndx.getNbOfElems()); self.assertEqual(9,descIndx.getNumberOfTuples());
 300         self.assertEqual(48,desc.getNbOfElems()); self.assertEqual(48,desc.getNumberOfTuples());
 301         self.assertEqual(48,revDesc.getNbOfElems()); self.assertEqual(48,revDesc.getNumberOfTuples());
 302         expected1=[0, 6, 12, 18, 24, 30, 36, 42, 48]
 303         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]
 304         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]
 305         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]
 306         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]
 307         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,
 308                    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,
 309                    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,
 310                    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]
 311         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,
 312                    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,
 313                    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,
 314                    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]
 315
 316         self.assertEqual(expected1,list(descIndx.getValues()));
 317         self.assertEqual(expected2,list(desc.getValues()));
 318         self.assertEqual(expected3,list(revDescIndx.getValues()));
 319         self.assertEqual(expected4,list(revDesc.getValues()));
 320         self.assertEqual(expected5,list(mesh2.getNodalConnectivityIndex().getValues()));
 321         self.assertEqual(expected6,list(mesh2.getNodalConnectivity().getValues()));
 322         #
 323         eltsV=[1,3]
 324         mesh.convertToPolyTypes(eltsV);
 325         mesh.checkCoherency();
 326         desc=DataArrayInt.New();
 327         descIndx=DataArrayInt.New();
 328         revDesc=DataArrayInt.New();
 329         revDescIndx=DataArrayInt.New();
 330         mesh2=mesh.buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
 331         mesh2.checkCoherency();
 332         self.assertEqual(2,mesh2.getMeshDimension());
 333         self.assertEqual(36,mesh2.getNumberOfCells());
 334         self.assertEqual(37,revDescIndx.getNbOfElems()); self.assertEqual(37,revDescIndx.getNumberOfTuples());
 335         self.assertEqual(9,descIndx.getNbOfElems()); self.assertEqual(9,descIndx.getNumberOfTuples());
 336         self.assertEqual(48,desc.getNbOfElems()); self.assertEqual(48,desc.getNumberOfTuples());
 337         self.assertEqual(48,revDesc.getNbOfElems()); self.assertEqual(48,revDesc.getNumberOfTuples());
 338         self.assertEqual(expected1,list(descIndx.getValues()));
 339         self.assertEqual(expected2,list(desc.getValues()));
 340         self.assertEqual(expected3,list(revDescIndx.getValues()));
 341         self.assertEqual(expected4,list(revDesc.getValues()));
 342         self.assertEqual(expected5,list(mesh2.getNodalConnectivityIndex().getValues()));
 343         self.assertEqual(expected7,list(mesh2.getNodalConnectivity().getValues()));
 344         pass
 345
 346     def testFindBoundaryNodes(self):
 347         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
 348         boundaryNodes=mesh.findBoundaryNodes();
 349         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];
 350         self.assertEqual(expected1,boundaryNodes.getValues());
 351         pass
 352
 353     def testBoundaryMesh(self):
 354         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
 355         mesh2=mesh.buildBoundaryMesh(False);
 356         self.assertEqual(24,mesh2.getNumberOfCells());
 357         self.assertEqual(26,mesh2.getNumberOfNodes());
 358         pass
 359
 360     def testBuildPartOfMySelf(self):
 361         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
 362         mesh.setName("Toto");
 363         tab1=[0,4]
 364         tab2=[0,2,3]
 365         #
 366         subMesh=mesh.buildPart(tab1)
 367         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
 368         subMesh=mesh.buildPartOfMySelf(tab1,True);
 369         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
 370         name=subMesh.getName();
 371         self.assertEqual(2,len(mesh.getAllTypes()));
 372         self.assertEqual(NORM_TRI3,mesh.getAllTypes()[0]);
 373         self.assertEqual(NORM_QUAD4,mesh.getAllTypes()[1]);
 374         self.assertEqual(1,len(subMesh.getAllTypes()));
 375         self.assertEqual(NORM_QUAD4,subMesh.getAllTypes()[0]);
 376         self.assertEqual(name,"Toto");
 377         self.assertEqual(2,subMesh.getNumberOfCells());
 378         subConn=[4,0,3,4,1,4,7,8,5,4];
 379         subConnIndex=[0,5,10];
 380         self.assertEqual(10,subMesh.getNodalConnectivity().getNbOfElems());
 381         self.assertEqual(3,subMesh.getNodalConnectivityIndex().getNbOfElems());
 382         self.assertEqual(subConn[0:10],list(subMesh.getNodalConnectivity().getValues()));
 383         self.assertEqual(subConnIndex[0:3],list(subMesh.getNodalConnectivityIndex().getValues()));
 384         #
 385         subMesh=mesh.buildPartOfMySelf(tab2[0:3],True);
 386         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh));
 387         name=subMesh.getName();
 388         self.assertEqual(2,len(subMesh.getAllTypes()));
 389         self.assertEqual(NORM_TRI3,subMesh.getAllTypes()[0]);
 390         self.assertEqual(NORM_QUAD4,subMesh.getAllTypes()[1]);
 391         self.assertEqual(name,"Toto");
 392         self.assertEqual(3,subMesh.getNumberOfCells());
 393         subConn2=[4,0,3,4,1,3,4,5,2,4,6,7,4,3]
 394         subConnIndex2=[0,5,9,14]
 395         self.assertEqual(14,subMesh.getNodalConnectivity().getNbOfElems());
 396         self.assertEqual(4,subMesh.getNodalConnectivityIndex().getNbOfElems());
 397         self.assertEqual(subConn2[0:14],list(subMesh.getNodalConnectivity().getValues()));
 398         self.assertEqual(subConnIndex2[0:4],list(subMesh.getNodalConnectivityIndex().getValues()));
 399         dd=DataArrayInt.New()
 400         dd.alloc(3,1)
 401         dd.iota(0)
 402         dd.setName("coucou")
 403         subMesh=subMesh.buildPartOfMySelf(dd,True);
 404         self.assertEqual("coucou",subMesh.getName());
 405         pass
 406
 407     def testBuildPartOfMySelfNode(self):
 408         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
 409         tab1=[5,7,8,4]
 410         subMesh=mesh.buildPartOfMySelfNode(tab1[0:4],True);
 411         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
 412         self.assertEqual(1,len(subMesh.getAllTypes()));
 413         self.assertEqual(NORM_QUAD4,subMesh.getAllTypes()[0]);
 414         self.assertEqual(1,subMesh.getNumberOfCells());
 415         self.assertEqual(5,subMesh.getNodalConnectivity().getNbOfElems());
 416         self.assertEqual(2,subMesh.getNodalConnectivityIndex().getNbOfElems());
 417         subConn=[4,7,8,5,4]
 418         subConnIndex=[0,5]
 419         self.assertEqual(subConn[0:5],list(subMesh.getNodalConnectivity().getValues()));
 420         self.assertEqual(subConnIndex[0:2],list(subMesh.getNodalConnectivityIndex().getValues()));
 421         #
 422         ddd=DataArrayInt.New()
 423         ddd.setValues(tab1[0:2],2,1)
 424         ddd.setName("ddd")
 425         subMesh=mesh.buildPartOfMySelfNode(ddd,False);
 426         self.assertEqual("ddd",subMesh.getName())
 427         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
 428         self.assertEqual(2,len(subMesh.getAllTypes()));
 429         self.assertEqual(NORM_TRI3,subMesh.getAllTypes()[0]);
 430         self.assertEqual(NORM_QUAD4,subMesh.getAllTypes()[1]);
 431         self.assertEqual(3,subMesh.getNumberOfCells());
 432         self.assertEqual(14,subMesh.getNodalConnectivity().getNbOfElems());
 433         self.assertEqual(4,subMesh.getNodalConnectivityIndex().getNbOfElems());
 434         subConn2=[3,4,5,2,4,6,7,4,3,4,7,8,5,4]
 435         subConnIndex2=[0,4,9,14]
 436         self.assertEqual(subConn2[0:14],list(subMesh.getNodalConnectivity().getValues()));
 437         self.assertEqual(subConnIndex2[0:4],list(subMesh.getNodalConnectivityIndex().getValues()));
 438         #testing the case where length of tab2 is greater than max number of node per cell.
 439         tab2=[0,3,2,1,4,5,6]
 440         subMesh=mesh.buildPartOfMySelfNode(tab2[0:7],True);
 441         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
 442         self.assertEqual(2,len(subMesh.getAllTypes()));
 443         self.assertEqual(NORM_TRI3,subMesh.getAllTypes()[0]);
 444         self.assertEqual(NORM_QUAD4,subMesh.getAllTypes()[1]);
 445         self.assertEqual(3,subMesh.getNumberOfCells());
 446         pass
 447
 448     def testZipCoords(self):
 449         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
 450         self.assertEqual(2,len(mesh.getAllTypes()));
 451         self.assertEqual(2,mesh.getSpaceDimension());
 452         self.assertEqual(9,mesh.getNumberOfNodes());
 453         self.assertEqual(5,mesh.getNumberOfCells());
 454         oldConn=mesh.getNodalConnectivity().getValues()[0:mesh.getNodalConnectivity().getNbOfElems()];
 455         oldConnIndex=mesh.getNodalConnectivityIndex().getValues()[0:mesh.getNumberOfCells()+1]
 456         oldCoords=mesh.getCoords();
 457         mesh.zipCoords();
 458         self.assertEqual(2,len(mesh.getAllTypes()));
 459         self.assertEqual(2,mesh.getSpaceDimension());
 460         self.assertEqual(9,mesh.getNumberOfNodes());
 461         self.assertEqual(5,mesh.getNumberOfCells());
 462         self.assertEqual(mesh.getCoords().getValues()[0:2*9],oldCoords.getValues());
 463         self.assertEqual(list(oldConn),list(mesh.getNodalConnectivity().getValues()));
 464         self.assertEqual(list(oldConnIndex),list(mesh.getNodalConnectivityIndex().getValues()));
 465         #
 466         tab1=[0,4]
 467         subMesh=mesh.buildPartOfMySelf(tab1,True);
 468         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
 469         traducer=subMesh.zipCoordsTraducer();
 470         expectedTraducer=[0, 1, -1, 2, 3, 4, -1, 5, 6]
 471         self.assertEqual(expectedTraducer,list(traducer.getValues()));
 472         self.assertEqual(NORM_QUAD4,subMesh.getAllTypes()[0]);
 473         self.assertEqual(2,subMesh.getNumberOfCells());
 474         subConn=[4,0,2,3,1,4,5,6,4,3]
 475         subConnIndex=[0,5,10]
 476         self.assertEqual(7,subMesh.getNumberOfNodes());
 477         self.assertEqual(10,subMesh.getNodalConnectivity().getNbOfElems());
 478         self.assertEqual(3,subMesh.getNodalConnectivityIndex().getNbOfElems());
 479         self.assertEqual(subConn,list(subMesh.getNodalConnectivity().getValues()));
 480         self.assertEqual(subConnIndex,list(subMesh.getNodalConnectivityIndex().getValues()));
 481         #
 482         subMesh=mesh.buildPartOfMySelf(tab1,False);
 483         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
 484         self.assertEqual(NORM_QUAD4,subMesh.getAllTypes()[0]);
 485         self.assertEqual(2,subMesh.getNumberOfCells());
 486         self.assertEqual(7,subMesh.getNumberOfNodes());
 487         self.assertEqual(10,subMesh.getNodalConnectivity().getNbOfElems());
 488         self.assertEqual(3,subMesh.getNodalConnectivityIndex().getNbOfElems());
 489         self.assertEqual(subConn,list(subMesh.getNodalConnectivity().getValues()));
 490         self.assertEqual(subConnIndex,list(subMesh.getNodalConnectivityIndex().getValues()));
 491         pass
 492
 493     def testZipConnectivity(self):
 494         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
 495         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
 496         cells1=[2,3,4]
 497         m3=m2.buildPartOfMySelf(cells1,True);
 498         self.assertTrue(isinstance(m3,MEDCouplingUMesh))
 499         m4=MEDCouplingDataForTest.build2DSourceMesh_1();
 500         m5=MEDCouplingUMesh.MergeUMeshes(m1,m3);
 501         m6=MEDCouplingUMesh.MergeUMeshes(m5,m4);
 502         #
 503         self.assertEqual(10,m6.getNumberOfCells());
 504         self.assertEqual(22,m6.getNumberOfNodes());
 505         (arr,areNodesMerged,newNbOfNodes)=m6.mergeNodes(1e-13);
 506         self.assertTrue(areNodesMerged);
 507         self.assertEqual(10,m6.getNumberOfCells());
 508         self.assertEqual(9,m6.getNumberOfNodes());
 509         #
 510         arr=m6.zipConnectivityTraducer(0);
 511         self.assertEqual(7,m6.getNumberOfCells());
 512         m7=m6.clone(True);
 513         arr=m6.zipConnectivityTraducer(0);
 514         self.assertTrue(m7.isEqual(m6,1e-12));
 515         self.assertEqual(7,m6.getNumberOfCells());
 516         pass
 517
 518     def testEqualMesh(self):
 519         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
 520         mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
 521         #
 522         self.assertTrue(mesh1.isEqual(mesh1,1e-12));
 523         #
 524         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
 525         self.assertTrue(mesh2.isEqual(mesh1,1e-12));
 526         pt=mesh2.getCoords().getValues();
 527         tmp=pt[1]
 528         mesh2.getCoords().setIJ(0,1,5.999);
 529         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
 530         self.assertTrue(not mesh2.isEqual(mesh1,1e-12));
 531         mesh2.getCoords().setIJ(0,1,tmp);
 532         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
 533         self.assertTrue(mesh2.isEqual(mesh1,1e-12));
 534         #
 535         pt2=mesh1.getNodalConnectivity().getValues();
 536         mesh1.getNodalConnectivity().setIJ(5,0,int(pt2[5])+1);
 537         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
 538         self.assertTrue(not mesh2.isEqual(mesh1,1e-12));
 539         mesh1.getNodalConnectivity().setIJ(5,0,int(pt2[5]));
 540         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
 541         self.assertTrue(mesh2.isEqual(mesh1,1e-12));
 542         #
 543         pt2=mesh1.getNodalConnectivityIndex().getValues();
 544         mesh1.getNodalConnectivityIndex().setIJ(1,0,int(pt2[1]+1));
 545         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
 546         self.assertTrue(not mesh2.isEqual(mesh1,1e-12));
 547         mesh1.getNodalConnectivityIndex().setIJ(1,0,int(pt2[1]));
 548         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
 549         self.assertTrue(mesh2.isEqual(mesh1,1e-12));
 550         #
 551         tmp3=mesh1.getName();
 552         mesh1.setName("lllll");
 553         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
 554         self.assertTrue(not mesh2.isEqual(mesh1,1e-12));
 555         mesh1.setName(tmp3);
 556         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
 557         self.assertTrue(mesh2.isEqual(mesh1,1e-12));
 558         #
 559         tmp3=mesh2.getCoords().getInfoOnComponent(1);
 560         mesh2.getCoords().setInfoOnComponent(1,"kkkkkk");
 561         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
 562         self.assertTrue(not mesh2.isEqual(mesh1,1e-12));
 563         mesh2.getCoords().setInfoOnComponent(1,tmp3);
 564         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
 565         self.assertTrue(mesh2.isEqual(mesh1,1e-12));
 566         pass
 567
 568     def testEqualFieldDouble(self):
 569         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
 570         mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
 571         #
 572         fieldOnCells1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
 573         fieldOnCells1.setMesh(mesh1);
 574         fieldOnCells2=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
 575         fieldOnCells2.setMesh(mesh2);
 576         #
 577         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 578         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 579         #
 580         fieldOnNodes1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
 581         self.assertTrue(not fieldOnCells1.isEqual(fieldOnNodes1,1e-12,1e-15));
 582         self.assertTrue(not fieldOnNodes1.isEqual(fieldOnCells1,1e-12,1e-15));
 583         #
 584         fieldOnCells2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
 585         self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 586         self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 587         fieldOnCells1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
 588         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 589         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 590         fieldOnCells1.setTime(4.,6,7);
 591         self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 592         self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 593         fieldOnCells2.setTime(4.,6,7);
 594         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 595         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 596         fieldOnCells1.setName("Power");
 597         self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 598         self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 599         fieldOnCells2.setName("Power");
 600         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 601         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 602         #
 603         fieldOnCells1.setMesh(mesh1);
 604         self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 605         self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 606         fieldOnCells2.setMesh(mesh1);
 607         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 608         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 609         arr=DataArrayDouble.New();
 610         arr.setName("popo");
 611         arr.setValues(mesh1.getNumberOfCells()*3*[6.],mesh1.getNumberOfCells(),3);
 612         fieldOnCells1.setArray(arr);
 613         self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 614         self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 615         fieldOnCells2.setArray(arr);
 616         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 617         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 618         #
 619         arr2=arr.deepCpy();
 620         fieldOnCells2.setArray(arr2);
 621         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 622         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 623         arr.setIJ(1,2,6.1);
 624         self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 625         self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 626         arr.setIJ(1,2,6.);
 627         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 628         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 629         arr2.setName("popo2");
 630         self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 631         self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 632         #
 633         arr2.setName("popo");
 634         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 635         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 636         #
 637         arr2.setInfoOnComponent(2,"jjj");
 638         self.assertTrue(not fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 639         self.assertTrue(not fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 640         arr.setInfoOnComponent(2,"jjj");
 641         self.assertTrue(fieldOnCells1.isEqual(fieldOnCells2,1e-12,1e-15));
 642         self.assertTrue(fieldOnCells2.isEqual(fieldOnCells1,1e-12,1e-15));
 643         pass
 644
 645     def testNatureChecking(self):
 646         field=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
 647         field.setNature(Integral);
 648         field.setNature(ConservativeVolumic);
 649         field.setNature(IntegralGlobConstraint);
 650         field=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
 651         field.setNature(ConservativeVolumic);
 652         self.assertRaises(InterpKernelException,field.setNature,Integral);
 653         self.assertRaises(InterpKernelException,field.setNature,IntegralGlobConstraint);
 654         pass
 655
 656     def testBuildSubMeshData(self):
 657         targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1()
 658         #check buildSubMesh on field on cells
 659         fieldCells=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
 660         fieldCells.setMesh(targetMesh);
 661         elts=[1,2,4]
 662         ret1,di=fieldCells.buildSubMeshData(elts);
 663         self.assertTrue(isinstance(ret1,MEDCouplingUMesh))
 664         self.assertEqual(3,ret1.getNumberOfCells());
 665         self.assertEqual(9,ret1.getNumberOfNodes());
 666         self.assertEqual(3,di.getNumberOfTuples());
 667         self.assertEqual(1,di.getNumberOfComponents());
 668         toCheck=di.getValues();
 669         self.assertTrue(elts,toCheck);
 670         #check buildSubMesh on field on nodes
 671         fieldNodes=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
 672         fieldNodes.setMesh(targetMesh);
 673         ret2,di=fieldNodes.buildSubMeshData(elts);
 674         self.assertTrue(isinstance(ret2,MEDCouplingUMesh))
 675         self.assertEqual(3,ret2.getNumberOfCells());
 676         self.assertEqual(6,ret2.getNumberOfNodes());
 677         self.assertEqual(6,di.getNumberOfTuples());
 678         self.assertEqual(1,di.getNumberOfComponents());
 679         toCheck=di.getValues();
 680         expected=[1,2,4,5,7,8]
 681         self.assertEqual(expected,list(toCheck));
 682         pass
 683
 684     def testExtrudedMesh1(self):
 685         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
 686         ext=MEDCouplingExtrudedMesh.New(mesh3D,mesh2D,1);
 687         self.assertEqual(18,ext.getNumberOfCells());
 688         self.assertEqual(60,ext.getNumberOfNodes());
 689         ids3D=ext.getMesh3DIds();
 690         ids3DExpected=[5,4,3,2,1,0, 11,10,9,8,7,6, 17,16,15,14,13,12]
 691         self.assertEqual(18,ids3D.getNumberOfTuples());
 692         self.assertEqual(1,ids3D.getNumberOfComponents());
 693         self.assertEqual(ids3DExpected,list(ids3D.getValues()));
 694         mesh1D=ext.getMesh1D();
 695         self.assertEqual(4,mesh1D.getNumberOfNodes());
 696         self.assertEqual(3,mesh1D.getNumberOfCells());
 697         mesh1DExpected=[0.66666666666666663, 1.4583333333333333, 0, 0.66666666666666663,
 698                         1.4583333333333333, 1, 0.66666666666666663, 1.4583333333333333,
 699                         2, 0.66666666666666663, 1.4583333333333333, 3]
 700         mesh1DCoords=mesh1D.getCoords();
 701         self.assertEqual(4,mesh1DCoords.getNumberOfTuples());
 702         self.assertEqual(3,mesh1DCoords.getNumberOfComponents());
 703         self.assertEqual(mesh1DExpected,mesh1DCoords.getValues());
 704         conn1D=mesh1D.getNodalConnectivity();
 705         self.assertEqual(9,conn1D.getNumberOfTuples());
 706         self.assertEqual(1,conn1D.getNumberOfComponents());
 707         conn1DExpected=[1,0,1,1,1,2,1,2,3]
 708         self.assertEqual(conn1DExpected,list(conn1D.getValues()));
 709         pass
 710
 711     def testExtrudedMesh3(self):
 712         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
 713         m1.changeSpaceDimension(3);
 714         m2=MEDCouplingDataForTest.buildCU1DMesh_U();
 715         m2.changeSpaceDimension(3);
 716         center=[0.,0.,0.]
 717         vector=[0.,1.,0.]
 718         m2.rotate(center,vector,-pi/2.);
 719         m3=m1.buildExtrudedMesh(m2,0);
 720         #
 721         m4=MEDCouplingExtrudedMesh.New(m3,m1,0);
 722         self.assertEqual(15,m4.getNumberOfCells());
 723         self.assertEqual(5,m4.getMesh2D().getNumberOfCells());
 724         self.assertEqual(3,m4.getMesh1D().getNumberOfCells());
 725         m3DIds=m4.getMesh3DIds().getValues();
 726         self.assertEqual(range(15),list(m3DIds));
 727         #some random in cells to check that extrusion alg find it correctly
 728         expected1=[1,3,2,0,6,5,7,10,11,8,12,9,14,13,4]
 729         m3.renumberCells(expected1,False);
 730         m4=MEDCouplingExtrudedMesh.New(m3,m1,0);
 731         self.assertEqual(15,m4.getNumberOfCells());
 732         self.assertEqual(5,m4.getMesh2D().getNumberOfCells());
 733         self.assertEqual(3,m4.getMesh1D().getNumberOfCells());
 734         m3DIds=m4.getMesh3DIds().getValues();
 735         self.assertEqual(expected1,list(m3DIds));
 736         #play with polygons and polyedrons
 737         cells=[2,3]
 738         m1.convertToPolyTypes(cells);
 739         m3=m1.buildExtrudedMesh(m2,0);
 740         self.assertEqual(NORM_HEXA8,m3.getTypeOfCell(0));
 741         self.assertEqual(NORM_PENTA6,m3.getTypeOfCell(1));
 742         self.assertEqual(NORM_POLYHED,m3.getTypeOfCell(2));
 743         self.assertEqual(NORM_POLYHED,m3.getTypeOfCell(3));
 744         self.assertEqual(NORM_HEXA8,m3.getTypeOfCell(4));
 745         m3.renumberCells(expected1,False);
 746         m4=MEDCouplingExtrudedMesh.New(m3,m1,0);
 747         self.assertEqual(15,m4.getNumberOfCells());
 748         self.assertEqual(5,m4.getMesh2D().getNumberOfCells());
 749         self.assertEqual(3,m4.getMesh1D().getNumberOfCells());
 750         m3DIds=m4.getMesh3DIds().getValues();
 751         self.assertEqual(expected1,list(m3DIds));
 752         pass
 753
 754     def testExtrudedMesh4(self):
 755         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
 756         cells=[2,4];
 757         m1.convertToPolyTypes(cells);
 758         m1.changeSpaceDimension(3);
 759         m2=MEDCouplingDataForTest.buildCU1DMesh_U();
 760         m2.changeSpaceDimension(3);
 761         center=[0.,0.,0.]
 762         vector=[0.,1.,0.]
 763         m2.rotate(center,vector,-pi/2.);
 764         m3=m1.buildExtrudedMesh(m2,0);
 765         expected1=[1,3,2,0,6,5,7,10,11,8,12,9,14,13,4]
 766         rexpected1=[3, 0, 2, 1, 14, 5, 4, 6, 9, 11, 7, 8, 10, 13, 12]
 767         m3.renumberCells(expected1,False);
 768         m4=MEDCouplingExtrudedMesh.New(m3,m1,0);
 769         self.assertEqual(NORM_HEXA8,m4.getTypeOfCell(0));
 770         self.assertEqual(NORM_HEXA8,m4.getTypeOfCell(1));
 771         self.assertEqual(NORM_POLYHED,m4.getTypeOfCell(2));
 772         self.assertEqual(NORM_PENTA6,m4.getTypeOfCell(7));
 773         f=m4.getMeasureField(True);
 774         arr=f.getArray();
 775         self.assertEqual(15,arr.getNumberOfTuples());
 776         self.assertEqual(1,arr.getNumberOfComponents());
 777         arrPtr=arr.getValues();
 778         expected2=[0.075,0.0375,0.0375,0.075,0.075,
 779                    0.1125,0.05625,0.05625,0.1125,0.1125,
 780                    0.0625,0.03125,0.03125,0.0625,0.0625]
 781         for i in xrange(15):
 782             self.assertAlmostEqual(expected2[rexpected1[i]],arrPtr[i],16);
 783             pass
 784         m5=m4.build3DUnstructuredMesh();
 785         self.assertTrue(m5.isEqual(m3,1e-12));
 786         f=m5.getMeasureField(True);
 787         f.setMesh(m4)
 788         self.assertTrue(isinstance(f.getMesh(),MEDCouplingExtrudedMesh))
 789         arr=f.getArray();
 790         arrPtr=arr.getValues();
 791         for i in xrange(15):
 792             self.assertAlmostEqual(expected2[rexpected1[i]],arrPtr[i],15);
 793             pass
 794         pass
 795
 796     def testFindCommonNodes(self):
 797         targetMesh=MEDCouplingDataForTest.build3DTargetMesh_1();
 798         comm,commI=targetMesh.findCommonNodes(1e-10,-1);
 799         self.assertEqual(1,commI.getNumberOfTuples());
 800         self.assertEqual(0,comm.getNumberOfTuples());
 801         o2n,newNbOfNodes=targetMesh.buildNewNumberingFromCommonNodesFormat(comm,commI);
 802         self.assertEqual(27,newNbOfNodes);
 803         self.assertEqual(27,o2n.getNumberOfTuples());
 804         o2nExp1=range(27)
 805         self.assertEqual(o2nExp1,list(o2n.getValues()));
 806         #
 807         targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
 808         self.assertEqual(31,targetMesh.getNumberOfNodes());
 809         comm,commI=targetMesh.findCommonNodes(1e-10);# testing default parameter
 810         self.assertEqual(3,commI.getNumberOfTuples());
 811         self.assertEqual(6,comm.getNumberOfTuples());
 812         commExpected=[1,27,28,29,23,30]
 813         commIExpected=[0,4,6]
 814         self.assertEqual(commExpected,list(comm.getValues()));
 815         self.assertEqual(commIExpected,list(commI.getValues()));
 816         o2n,newNbOfNodes=targetMesh.buildNewNumberingFromCommonNodesFormat(comm,commI);
 817         self.assertEqual(31,o2n.getNumberOfTuples());
 818         self.assertEqual(27,newNbOfNodes);
 819         o2nExp2=[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,
 820                  21,22,23,24,25,26,1,1,1,23]
 821         self.assertEqual(o2nExp2,list(o2n.getValues()));
 822         #
 823         targetMesh=MEDCouplingDataForTest.build3DTargetMesh_1();
 824         time=targetMesh.getTimeOfThis();
 825         o2n,areNodesMerged,newNbOfNodes=targetMesh.mergeNodes(1e-10);
 826         targetMesh.updateTime();
 827         self.assertEqual(time,targetMesh.getTimeOfThis());
 828         self.assertTrue(not areNodesMerged);
 829         #
 830         targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
 831         time=targetMesh.getTimeOfThis();
 832         o2n,areNodesMerged,newNbOfNodes=targetMesh.mergeNodes(1e-10);
 833         targetMesh.updateTime();
 834         self.assertTrue(time!=targetMesh.getTimeOfThis());
 835         self.assertTrue(areNodesMerged);
 836         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,
 837                  18,4,5,8,7,13,14,17,16,
 838                  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,
 839                  18,13,14,17,16,22,23,26,25]
 840         self.assertEqual(72,targetMesh.getNodalConnectivity().getNumberOfTuples());
 841         self.assertEqual(connExp,list(targetMesh.getNodalConnectivity().getValues()));
 842         self.assertEqual(27,targetMesh.getCoords().getNumberOfTuples());
 843         coordsExp=[ 0., 0., 0., 50., 0., 0. , 200., 0., 0.  , 0., 50., 0., 50., 50., 0. ,
 844                     200., 50., 0.,   0., 200., 0., 50., 200., 0. , 200., 200., 0. ,
 845                     0., 0., 50., 50., 0., 50. , 200., 0., 50.  , 0., 50., 50., 50.,
 846                     50., 50. , 200., 50., 50.,   0., 200., 50., 50., 200., 50. ,
 847                     200., 200., 50. , 0., 0., 200., 50., 0., 200. , 200., 0., 200.
 848                     , 0., 50., 200., 50., 50., 200. , 200., 50., 200.,
 849                     0., 200., 200., 50., 200., 200. , 200., 200., 200. ]
 850         self.assertEqual(coordsExp,targetMesh.getCoords().getValues());
 851         # 2D
 852         targetMesh=MEDCouplingDataForTest.build2DTargetMeshMergeNode_1();
 853         self.assertEqual(18,targetMesh.getNumberOfNodes());
 854         time=targetMesh.getTimeOfThis();
 855         o2n,areNodesMerged,newNbOfNodes=targetMesh.mergeNodes(1e-10);
 856         self.assertTrue(time!=targetMesh.getTimeOfThis());
 857         self.assertTrue(areNodesMerged);
 858         self.assertEqual(9,targetMesh.getNumberOfNodes());
 859         connExp2=[4,0,4,3,1, 3,1,3,2, 3,3,5,2, 4,4,6,7,3, 4,7,8,5,3]
 860         self.assertEqual(23,targetMesh.getNodalConnectivity().getNumberOfTuples());
 861         self.assertEqual(connExp2,list(targetMesh.getNodalConnectivity().getValues()));
 862         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]
 863         self.assertEqual(9,targetMesh.getCoords().getNumberOfTuples());
 864         self.assertEqual(coordsExp2,targetMesh.getCoords().getValues());
 865         pass
 866
 867     def testCheckButterflyCells(self):
 868         sourceMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
 869         cells=sourceMesh.checkButterflyCells();
 870         self.assertEqual(0,len(cells));
 871         conn=sourceMesh.getNodalConnectivity()
 872         tmp=conn.getIJ(15,0)
 873         conn.setIJ(15,0,conn.getIJ(16,0))
 874         conn.setIJ(16,0,tmp)
 875         cells=sourceMesh.checkButterflyCells();
 876         self.assertEqual(1,len(cells));
 877         self.assertEqual([3],cells.getValues());
 878         tmp=conn.getIJ(15,0)
 879         conn.setIJ(15,0,conn.getIJ(16,0))
 880         conn.setIJ(16,0,tmp)
 881         cells=sourceMesh.checkButterflyCells();
 882         self.assertEqual(0,len(cells));
 883         # 3D surf
 884         sourceMesh=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
 885         cells=sourceMesh.checkButterflyCells();
 886         self.assertEqual(0,len(cells));
 887         conn=sourceMesh.getNodalConnectivity()
 888         tmp=conn.getIJ(15,0)
 889         conn.setIJ(15,0,conn.getIJ(16,0))
 890         conn.setIJ(16,0,tmp)
 891         cells=sourceMesh.checkButterflyCells();
 892         self.assertEqual(1,len(cells));
 893         self.assertEqual([3],cells.getValues());
 894         tmp=conn.getIJ(15,0)
 895         conn.setIJ(15,0,conn.getIJ(16,0))
 896         conn.setIJ(16,0,tmp)
 897         cells=sourceMesh.checkButterflyCells();
 898         self.assertEqual(0,len(cells));
 899         pass
 900
 901     def testMergeMesh1(self):
 902         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
 903         m2=MEDCouplingDataForTest.build2DSourceMesh_1();
 904         vec=[1.,0.]
 905         m2.translate(vec);
 906         m3=m1.mergeMyselfWith(m2);
 907         self.assertTrue(isinstance(m3,MEDCouplingUMesh));
 908         m3.checkCoherency();
 909         m4=MEDCouplingDataForTest.build2DTargetMeshMerged_1();
 910         self.assertTrue(m3.isEqual(m4,1.e-12));
 911         da,isMerged,newNbOfNodes=m3.mergeNodes(1.e-12);
 912         self.assertEqual(11,m3.getNumberOfNodes());
 913         self.assertTrue(isMerged);
 914         pass
 915
 916     def testMergeMeshOnSameCoords1(self):
 917         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
 918         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
 919         cells=range(5);
 920         m2.convertToPolyTypes(cells);
 921         m1.tryToShareSameCoords(m2,1e-12);
 922         m3=MEDCouplingDataForTest.build2DTargetMesh_1();
 923         m3.tryToShareSameCoords(m2,1e-12);
 924         meshes=[m1,m2,m3]
 925         m4=MEDCouplingUMesh.MergeUMeshesOnSameCoords(meshes);
 926         m4.checkCoherency();
 927         self.assertEqual(15,m4.getNumberOfCells());
 928         cells1=[0,1,2,3,4]
 929         m1_1=m4.buildPartOfMySelf(cells1,True);
 930         m1_1.setName(m1.getName());
 931         self.assertTrue(m1.isEqual(m1_1,1e-12));
 932         cells2=[5,6,7,8,9]
 933         m2_1=m4.buildPartOfMySelf(cells2,True);
 934         m2_1.setName(m2.getName());
 935         self.assertTrue(m2.isEqual(m2_1,1e-12));
 936         cells3=[10,11,12,13,14]
 937         m3_1=m4.buildPartOfMySelf(cells3,True);
 938         m3_1.setName(m3.getName());
 939         self.assertTrue(m3.isEqual(m3_1,1e-12));
 940         pass
 941
 942     def testMergeField1(self):
 943         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
 944         m2=MEDCouplingDataForTest.build2DSourceMesh_1();
 945         vec=[1.,0.]
 946         m2.translate(vec);
 947         f1=m1.getMeasureField(True);
 948         f2=m2.getMeasureField(True);
 949         f3=MEDCouplingFieldDouble.MergeFields(f1,f2);
 950         f3.checkCoherency();
 951         m4=MEDCouplingDataForTest.build2DTargetMeshMerged_1();
 952         self.assertTrue(f3.getMesh().isEqual(m4,1.e-12));
 953         name=f3.getName();
 954         self.assertEqual(name,"MeasureOfMesh_");
 955         self.assertEqual(f3.getTypeOfField(),ON_CELLS);
 956         self.assertEqual(f3.getTimeDiscretization(),ONE_TIME);
 957         self.assertEqual(1,f3.getNumberOfComponents());
 958         self.assertEqual(7,f3.getNumberOfTuples());
 959         values=[0.25,0.125,0.125,0.25,0.25,0.5,0.5]
 960         tmp=f3.getArray().getValues();
 961         self.assertEqual(len(values),len(tmp))
 962         for i in xrange(7):
 963             self.assertTrue(abs(values[i]-tmp[i])<1e-12)
 964             pass
 965         pass
 966
 967     def testFillFromAnalytic(self):
 968         m=MEDCouplingDataForTest.build2DTargetMesh_1();
 969         m.setTime(3.4,5,6); m.setTimeUnit("us");
 970         f1=m.fillFromAnalytic(ON_CELLS,1,"x+y");
 971         self.assertAlmostEqual(3.4,f1.getTime()[0],12) ; self.assertEqual(5,f1.getTime()[1]) ; self.assertEqual(6,f1.getTime()[2])
 972         self.assertEqual("us",f1.getTimeUnit())
 973         f1.checkCoherency();
 974         self.assertEqual(f1.getTypeOfField(),ON_CELLS);
 975         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
 976         self.assertEqual(1,f1.getNumberOfComponents());
 977         self.assertEqual(5,f1.getNumberOfTuples());
 978         values1=[-0.1,0.23333333333333336,0.56666666666666665,0.4,0.9]
 979         tmp=f1.getArray().getValues();
 980         self.assertEqual(len(values1),len(tmp))
 981         for i in xrange(len(tmp)):
 982             self.assertTrue(abs(tmp[i]-values1[i])<1.e-12)
 983             pass
 984         #
 985         f1=m.fillFromAnalytic(ON_NODES,1,"x+y");
 986         f1.checkCoherency();
 987         self.assertEqual(f1.getTypeOfField(),ON_NODES);
 988         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
 989         self.assertEqual(1,f1.getNumberOfComponents());
 990         self.assertEqual(9,f1.getNumberOfTuples());
 991         values2=[-0.6,-0.1,0.4,-0.1,0.4,0.9,0.4,0.9,1.4]
 992         tmp=f1.getArray().getValues();
 993         self.assertEqual(len(values2),len(tmp))
 994         for i in xrange(len(tmp)):
 995             self.assertTrue(abs(tmp[i]-values2[i])<1.e-12)
 996             pass
 997         #
 998         f1=m.fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+(2*(x+y))*JVec");
 999         f1.checkCoherency();
1000         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1001         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1002         self.assertEqual(2,f1.getNumberOfComponents());
1003         self.assertEqual(9,f1.getNumberOfTuples());
1004         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]
1005         tmp=f1.getArray().getValues();
1006         self.assertEqual(len(values3),len(tmp))
1007         for i in xrange(len(tmp)):
1008             self.assertTrue(abs(tmp[i]-values3[i])<1.e-12)
1009             pass
1010         values4=f1.accumulate();
1011         self.assertEqual(2,len(values4))
1012         self.assertTrue(abs(3.6-values4[0])<1.e-12);
1013         self.assertTrue(abs(7.2-values4[1])<1.e-12);
1014         values4=f1.integral(True);
1015         self.assertEqual(2,len(values4))
1016         self.assertTrue(abs(0.5-values4[0])<1.e-12);
1017         self.assertTrue(abs(1.-values4[1])<1.e-12);
1018         #
1019         self.assertRaises(InterpKernelException,m.fillFromAnalytic,ON_NODES,1,"1./(x-0.2)");
1020         pass
1021
1022     def testFillFromAnalytic2(self):
1023         m=MEDCouplingDataForTest.build2DTargetMesh_1();
1024         f1=m.fillFromAnalytic(ON_CELLS,1,"y+x");
1025         f1.checkCoherency();
1026         self.assertEqual(f1.getTypeOfField(),ON_CELLS);
1027         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1028         self.assertEqual(1,f1.getNumberOfComponents());
1029         self.assertEqual(5,f1.getNumberOfTuples());
1030         values1=[-0.1,0.23333333333333336,0.56666666666666665,0.4,0.9]
1031         tmp=f1.getArray().getValues();
1032         self.assertEqual(len(values1),len(tmp))
1033         for i in xrange(len(values1)):
1034             self.assertTrue(abs(values1[i]-tmp[i])<1.e-12);
1035             pass
1036         #
1037         f1=m.fillFromAnalytic(ON_NODES,1,"y+2*x");
1038         f1.checkCoherency();
1039         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1040         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1041         self.assertEqual(1,f1.getNumberOfComponents());
1042         self.assertEqual(9,f1.getNumberOfTuples());
1043         values2=[-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1]
1044         tmp=f1.getArray().getValues();
1045         self.assertEqual(len(values2),len(tmp))
1046         for i in xrange(len(values2)):
1047             self.assertTrue(abs(values2[i]-tmp[i])<1.e-12);
1048             pass
1049         f1=m.fillFromAnalytic(ON_NODES,1,"2.*x+y");
1050         f1.checkCoherency();
1051         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1052         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1053         self.assertEqual(1,f1.getNumberOfComponents());
1054         self.assertEqual(9,f1.getNumberOfTuples());
1055         tmp=f1.getArray().getValues();
1056         values2Bis=[-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1]
1057         self.assertEqual(len(values2Bis),len(tmp))
1058         for i in xrange(len(values2Bis)):
1059             self.assertTrue(abs(values2Bis[i]-tmp[i])<1.e-12);
1060             pass
1061         #
1062         f1=m.fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+2*(x+y)*JVec");
1063         f1.checkCoherency();
1064         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1065         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1066         self.assertEqual(2,f1.getNumberOfComponents());
1067         self.assertEqual(9,f1.getNumberOfTuples());
1068         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]
1069         tmp=f1.getArray().getValues();
1070         self.assertEqual(len(values3),len(tmp))
1071         for i in xrange(len(values3)):
1072             self.assertTrue(abs(values3[i]-tmp[i])<1.e-12);
1073             pass
1074         values4=f1.accumulate();
1075         self.assertTrue(abs(3.6-values4[0])<1.e-12);
1076         self.assertTrue(abs(7.2-values4[1])<1.e-12);
1077         values4=f1.integral(True);
1078         self.assertTrue(abs(0.5-values4[0])<1.e-12);
1079         self.assertTrue(abs(1.-values4[1])<1.e-12);
1080         pass
1081
1082     def testApplyFunc(self):
1083         m=MEDCouplingDataForTest.build2DTargetMesh_1();
1084         f1=m.fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+(2*(x+y))*JVec");
1085         f1.checkCoherency();
1086         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1087         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1088         self.assertEqual(2,f1.getNumberOfComponents());
1089         self.assertEqual(9,f1.getNumberOfTuples());
1090         f1.applyFunc(1,"x+y");
1091         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1092         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1093         self.assertEqual(1,f1.getNumberOfComponents());
1094         self.assertEqual(9,f1.getNumberOfTuples());
1095         values1=[-1.8,-0.3,1.2,-0.3,1.2,2.7,1.2,2.7,4.2]
1096         tmp=f1.getArray().getValues();
1097         self.assertEqual(len(values1),len(tmp))
1098         for i in xrange(len(tmp)):
1099             self.assertTrue(abs(tmp[i]-values1[i])<1.e-12)
1100             pass
1101         pass
1102
1103     def testApplyFunc2(self):
1104         m=MEDCouplingDataForTest.build2DTargetMesh_1();
1105         f1=m.fillFromAnalytic(ON_NODES,2,"(x+y)*IVec+2*(x+y)*JVec");
1106         f1.checkCoherency();
1107         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1108         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1109         self.assertEqual(2,f1.getNumberOfComponents());
1110         self.assertEqual(9,f1.getNumberOfTuples());
1111         #
1112         f2=f1.clone(True);
1113         self.assertRaises(InterpKernelException, f2.applyFunc, 1, "a+b+c+d");
1114         self.assertRaises(InterpKernelException, f2.applyFunc, 1, "a/0");
1115         self.assertRaises(InterpKernelException, f2.applyFunc, "a/0");
1116         f2.applyFunc("abs(u)^2.4+2*u");
1117         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1118         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1119         self.assertEqual(2,f1.getNumberOfComponents());
1120         self.assertEqual(9,f1.getNumberOfTuples());
1121         values2=[-0.9065304805418678, -0.85105859001709905, -0.19601892829446504, -0.37898777756476987,
1122                  0.91090317490482353, 2.1853504664669781, -0.19601892829446504, -0.37898777756476987,
1123                  0.91090317490482353, 2.1853504664669781, 2.5765725275664879, 7.6987743736515295,
1124                  0.91090317490482353, 2.1853504664669781, 2.5765725275664879, 7.6987743736515295,
1125                  5.0423700574830965, 17.435300118916864]
1126         tmp=f2.getArray().getValues();
1127         self.assertEqual(len(tmp),len(values2))
1128         for i in xrange(len(tmp)):
1129             self.assertTrue(abs(tmp[i]-values2[i])<1.e-12)
1130             pass
1131         #
1132         f1.applyFunc(1,"x+y");
1133         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1134         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1135         self.assertEqual(1,f1.getNumberOfComponents());
1136         self.assertEqual(9,f1.getNumberOfTuples());
1137         values1=[-1.8,-0.3,1.2,-0.3,1.2,2.7,1.2,2.7,4.2]
1138         tmp=f1.getArray().getValues();
1139         self.assertEqual(len(tmp),len(values1))
1140         for i in xrange(len(tmp)):
1141             self.assertTrue(abs(tmp[i]-values1[i])<1.e-12)
1142             pass
1143         pass
1144
1145     def testOperationsOnFields(self):
1146         m=MEDCouplingDataForTest.build2DTargetMesh_1();
1147         f1=m.fillFromAnalytic(ON_NODES,1,"x+y");
1148         f2=m.fillFromAnalytic(ON_NODES,1,"x+y");
1149         f1.checkCoherency();
1150         f2.checkCoherency();
1151         f3=f1+f2;
1152         f3.checkCoherency();
1153         self.assertEqual(f3.getTypeOfField(),ON_NODES);
1154         self.assertEqual(f3.getTimeDiscretization(),ONE_TIME);
1155         values1=[-1.2,-0.2,0.8,-0.2,0.8,1.8,0.8,1.8,2.8]
1156         tmp=f3.getArray().getValues();
1157         self.assertEqual(len(values1),len(tmp))
1158         for i in xrange(len(tmp)):
1159             self.assertTrue(abs(tmp[i]-values1[i])<1.e-12)
1160             pass
1161         #
1162         f3=f1*f2;
1163         f3.checkCoherency();
1164         self.assertEqual(f3.getTypeOfField(),ON_NODES);
1165         self.assertEqual(f3.getTimeDiscretization(),ONE_TIME);
1166         values2=[0.36,0.01,0.16,0.01,0.16,0.81,0.16,0.81,1.96]
1167         tmp=f3.getArray().getValues();
1168         self.assertEqual(len(values2),len(tmp))
1169         for i in xrange(len(tmp)):
1170             self.assertTrue(abs(tmp[i]-values2[i])<1.e-12)
1171             pass
1172         #
1173         f3=f1+f2;
1174         f4=f1-f3;
1175         f4.checkCoherency();
1176         self.assertEqual(f4.getTypeOfField(),ON_NODES);
1177         self.assertEqual(f4.getTimeDiscretization(),ONE_TIME);
1178         values3=[0.6,0.1,-0.4,0.1,-0.4,-0.9,-0.4,-0.9,-1.4]
1179         tmp=f4.getArray().getValues();
1180         self.assertEqual(len(values3),len(tmp))
1181         for i in xrange(len(tmp)):
1182             self.assertTrue(abs(tmp[i]-values3[i])<1.e-12)
1183             pass
1184         #
1185         f3=f1+f2;
1186         f4=f3/f2;
1187         f4.checkCoherency();
1188         self.assertEqual(f4.getTypeOfField(),ON_NODES);
1189         self.assertEqual(f4.getTimeDiscretization(),ONE_TIME);
1190         tmp=f4.getArray().getValues();
1191         for i in xrange(len(tmp)):
1192             self.assertTrue(abs(tmp[i]-2.)<1.e-12)
1193             pass
1194         #
1195         f4=f2.buildNewTimeReprFromThis(NO_TIME,False);
1196         f4.checkCoherency();
1197         self.assertEqual(f4.getTypeOfField(),ON_NODES);
1198         self.assertEqual(f4.getTimeDiscretization(),NO_TIME);
1199         self.assertRaises(InterpKernelException,f1.__add__,f4);
1200         f5=f4.buildNewTimeReprFromThis(ONE_TIME,False);
1201         self.assertEqual(f5.getTypeOfField(),ON_NODES);
1202         self.assertEqual(f5.getTimeDiscretization(),ONE_TIME);
1203         f3=f1+f5;
1204         tmp=f3.getArray().getValues();
1205         values4=[-1.2,-0.2,0.8,-0.2,0.8,1.8,0.8,1.8,2.8]
1206         self.assertEqual(len(values3),len(tmp))
1207         for i in xrange(len(tmp)):
1208             self.assertTrue(abs(tmp[i]-values4[i])<1.e-12)
1209             pass
1210         #
1211         f4=f2.buildNewTimeReprFromThis(NO_TIME,True);
1212         f4.checkCoherency();
1213         self.assertEqual(f4.getTypeOfField(),ON_NODES);
1214         self.assertEqual(f4.getTimeDiscretization(),NO_TIME);
1215         self.assertRaises(InterpKernelException,f1.__add__,f4);
1216         f5=f4.buildNewTimeReprFromThis(ONE_TIME,True);
1217         self.assertEqual(f5.getTypeOfField(),ON_NODES);
1218         self.assertEqual(f5.getTimeDiscretization(),ONE_TIME);
1219         f3=f1+f5;
1220         tmp=f3.getArray().getValues();
1221         values5=[-1.2,-0.2,0.8,-0.2,0.8,1.8,0.8,1.8,2.8]
1222         self.assertEqual(len(values5),len(tmp))
1223         for i in xrange(len(tmp)):
1224             self.assertTrue(abs(tmp[i]-values5[i])<1.e-12)
1225             pass
1226         pass
1227
1228     def testOperationsOnFields2(self):
1229         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1230         m.setTime(3.4,5,6); m.setTimeUnit("us");
1231         f1=m.fillFromAnalytic(ON_NODES,1,"x+y+z");
1232         f2=m.fillFromAnalytic(ON_NODES,1,"a*a+b+c*c");
1233         f3=f1/f2;
1234         f3.checkCoherency();
1235         self.assertEqual(f3.getTypeOfField(),ON_NODES);
1236         self.assertEqual(f3.getTimeDiscretization(),ONE_TIME);
1237         expected1=[-2.4999999999999991, 1.2162162162162162, 0.77868852459016391,
1238                    0.7407407407407407, 1.129032258064516, 0.81632653061224492,
1239                    0.86538461538461531, 1.0919540229885056, 0.84302325581395343]
1240         self.assertEqual(1,f3.getNumberOfComponents());
1241         self.assertEqual(9,f3.getNumberOfTuples());
1242         val=f3.getArray().getValues();
1243         for i in xrange(9):
1244             self.assertTrue(abs(expected1[i]-val[i])<1.e-12);
1245         #
1246         f1=m.buildOrthogonalField();
1247         self.assertAlmostEqual(3.4,f1.getTime()[0],12) ; self.assertEqual(5,f1.getTime()[1]) ; self.assertEqual(6,f1.getTime()[2])
1248         self.assertEqual("us",f1.getTimeUnit())
1249         f2=m.fillFromAnalytic(ON_CELLS,1,"x");
1250         f3=f1*f2;
1251         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]
1252         val=f3.getArray().getValues();
1253         for i in xrange(15):
1254             self.assertTrue(abs(expected2[i]-val[i])<1.e-12);
1255             pass
1256         #
1257         f3=f2*f1;
1258         val=f3.getArray().getValues();
1259         for i in xrange(15):
1260             self.assertTrue(abs(expected2[i]-val[i])<1.e-12);
1261             pass
1262         pass
1263
1264     def testOperationsOnFields3(self):
1265         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1266         f1=m.fillFromAnalytic(ON_NODES,1,"x+y+z");
1267         f2=m.fillFromAnalytic(ON_NODES,1,"a*a+b+c*c");
1268         f1/=f2
1269         f1.checkCoherency();
1270         self.assertEqual(f1.getTypeOfField(),ON_NODES);
1271         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
1272         expected1=[-2.4999999999999991, 1.2162162162162162, 0.77868852459016391,
1273                    0.7407407407407407, 1.129032258064516, 0.81632653061224492,
1274                    0.86538461538461531, 1.0919540229885056, 0.84302325581395343]
1275         self.assertEqual(1,f1.getNumberOfComponents());
1276         self.assertEqual(9,f1.getNumberOfTuples());
1277         val=f1.getArray().getValues();
1278         for i in xrange(9):
1279             self.assertTrue(abs(expected1[i]-val[i])<1.e-12);
1280             pass
1281         #
1282         f1=m.buildOrthogonalField();
1283         f2=m.fillFromAnalytic(ON_CELLS,1,"x");
1284         f1*=f2
1285         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]
1286         val=f1.getArray().getValues();
1287         for i in xrange(15):
1288             self.assertTrue(abs(expected2[i]-val[i])<1.e-12);
1289             pass
1290         #
1291         f1=m.buildOrthogonalField();
1292         # to avoid valgrind leaks
1293         # self.assertRaises(InterpKernelException,f2.__imul__,f1);
1294         pass
1295
1296     def testOperationsOnFields4(self):
1297         m=MEDCouplingDataForTest.build2DTargetMesh_1();
1298         nbOfCells=m.getNumberOfCells();
1299         f1=MEDCouplingFieldDouble.New(ON_CELLS,CONST_ON_TIME_INTERVAL);
1300         f1.setMesh(m);
1301         array=DataArrayDouble.New();
1302         f1.setArray(array);
1303         self.assertRaises(InterpKernelException,f1.setEndArray,array);
1304         self.assertRaises(InterpKernelException,f1.getEndArray);
1305         arr1=[0.,10.,20.,1.,11.,21.,2.,12.,22.,3.,13.,23.,4.,14.,24.]
1306         arr2=[5.,15.,25.,6.,16.,26.,7.,17.,27.,8.,18.,28.,9.,19.,29.]
1307         array.setValues(arr1,nbOfCells,3);
1308         f1.setStartTime(2.,0,0);
1309         f1.setEndTime(3.,0,0);
1310         f1.checkCoherency();
1311         pos=[0.3,-0.2]
1312         res=f1.getValueOn(pos);
1313         self.assertTrue(abs(arr1[3]-res[0])<1.e-12);
1314         self.assertTrue(abs(arr1[4]-res[1])<1.e-12);
1315         self.assertTrue(abs(arr1[5]-res[2])<1.e-12);
1316         res=None
1317         res=f1.getValueOn(pos,2.2);
1318         self.assertTrue(abs(arr1[3]-res[0])<1.e-12);
1319         self.assertTrue(abs(arr1[4]-res[1])<1.e-12);
1320         self.assertTrue(abs(arr1[5]-res[2])<1.e-12);
1321         res=None
1322         self.assertRaises(InterpKernelException,f1.getValueOn,pos,3.2)
1323         f2=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
1324         f2.setMesh(m);
1325         f2.setArray(f1.getArray());
1326         f2.setStartTime(2.,3,0);
1327         f2.setEndTime(4.,13,0);
1328         self.assertRaises(InterpKernelException,f2.checkCoherency)
1329         array2=DataArrayDouble.New();
1330         array2.setValues(arr2,nbOfCells,3);
1331         f2.setEndArray(array2);
1332         f2.checkCoherency();
1333         #
1334         res=None
1335         res=f2.getValueOn(pos,3.21);
1336         self.assertTrue(abs(4.025-res[0])<1.e-12);
1337         self.assertTrue(abs(14.025-res[1])<1.e-12);
1338         self.assertTrue(abs(24.025-res[2])<1.e-12);
1339         f3=f2.clone(True);
1340         self.assertTrue(f2.isEqual(f3,1e-12,1e-12));
1341         f3.getEndArray().setIJ(0,0,5.001);
1342         self.assertTrue(not f2.isEqual(f3,1e-12,1e-12));
1343         self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1344         f3.setStartTime(2.1,3,0);
1345         self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1346         f3.setStartTime(2.,3,0);
1347         self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1348         f3.setStartTime(2.,4,0);
1349         self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1350         f3.setStartTime(2.,3,1);
1351         self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1352         f3.setStartTime(2.,3,0);
1353         self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1354         f3.setEndTime(4.1,13,0);
1355         self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1356         f3.setEndTime(4.,13,0);
1357         self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1358         f3.setEndTime(4.,14,0);
1359         self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1360         f3.setEndTime(4.,13,1);
1361         self.assertTrue(not f2.isEqual(f3,1e-12,1e-2));
1362         f3.setEndTime(4.,13,0);
1363         self.assertTrue(f2.isEqual(f3,1e-12,1e-2));
1364         f4=f2+f2
1365         res=None
1366         res=f4.getValueOn(pos,3.21);
1367         self.assertTrue(abs(8.05-res[0])<1.e-12);
1368         self.assertTrue(abs(28.05-res[1])<1.e-12);
1369         self.assertTrue(abs(48.05-res[2])<1.e-12);
1370         f4+=f2;
1371         res=None
1372         res=f4.getValueOn(pos,3.21);
1373         self.assertTrue(abs(12.075-res[0])<1.e-12);
1374         self.assertTrue(abs(42.075-res[1])<1.e-12);
1375         self.assertTrue(abs(72.075-res[2])<1.e-12);
1376         pass
1377
1378     def testMergeNodesOnField(self):
1379         targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
1380         f1=targetMesh.fillFromAnalytic(ON_NODES,1,"x+y+z");
1381         f1.mergeNodes(1e-10);
1382         #
1383         targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
1384         f1=targetMesh.fillFromAnalytic(ON_NODES,1,"x+y+z");
1385         tmp=f1.getArray()
1386         tmp.setIJ(0,0,1000.);
1387         f1.mergeNodes(1e-10);
1388         #
1389         targetMesh=MEDCouplingDataForTest.build3DTargetMeshMergeNode_1();
1390         f1=targetMesh.fillFromAnalytic(ON_NODES,1,"x+y+z");
1391         tmp=f1.getArray()
1392         tmp.setIJ(1,0,1000.);
1393         self.assertRaises(InterpKernelException,f1.mergeNodes,1.e-10)
1394         pass
1395
1396     def testCheckConsecutiveCellTypes(self):
1397         sourceMesh=MEDCouplingDataForTest.build2DSourceMesh_1();
1398         targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1399         self.assertTrue(sourceMesh.checkConsecutiveCellTypes());
1400         order1=[NORM_TRI3,NORM_QUAD4]
1401         order2=[NORM_QUAD4,NORM_TRI3]
1402         self.assertTrue(not targetMesh.checkConsecutiveCellTypes());
1403         self.assertTrue(not targetMesh.checkConsecutiveCellTypesAndOrder(order1));
1404         self.assertTrue(not targetMesh.checkConsecutiveCellTypesAndOrder(order2));
1405         da=targetMesh.getRenumArrForConsecutiveCellTypesSpec(order1);
1406         self.assertEqual(5,da.getNumberOfTuples());
1407         self.assertEqual(1,da.getNumberOfComponents());
1408         expected1=[2,0,1,3,4]
1409         self.assertTrue(expected1==list(da.getValues()));
1410         da=targetMesh.getRenumArrForConsecutiveCellTypesSpec(order2);
1411         self.assertEqual(5,da.getNumberOfTuples());
1412         self.assertEqual(1,da.getNumberOfComponents());
1413         expected2=[0,3,4,1,2]
1414         self.assertTrue(expected2==list(da.getValues()));
1415         renumber1=[4,0,1,2,3]
1416         targetMesh.renumberCells(renumber1,False);
1417         self.assertTrue(targetMesh.checkConsecutiveCellTypes());
1418         self.assertTrue(targetMesh.checkConsecutiveCellTypesAndOrder(order1));
1419         self.assertTrue(not targetMesh.checkConsecutiveCellTypesAndOrder(order2));
1420         pass
1421
1422     def testRearrange2ConsecutiveCellTypes(self):
1423         m1_1=MEDCouplingDataForTest.build2DSourceMesh_1();
1424         m2_1=MEDCouplingDataForTest.build2DTargetMesh_1();
1425         arr1=m1_1.rearrange2ConsecutiveCellTypes();
1426         m1_2=MEDCouplingDataForTest.build2DSourceMesh_1();
1427         self.assertTrue(m1_2.isEqual(m1_1,1e-12));
1428         expected1=[0,1]
1429         self.assertEqual(2,arr1.getNumberOfTuples());
1430         self.assertEqual(1,arr1.getNumberOfComponents());
1431         self.assertEqual(expected1,arr1.getValues());
1432         expected2=[0,3,4,1,2]
1433         arr1=m2_1.rearrange2ConsecutiveCellTypes();
1434         self.assertEqual(5,arr1.getNumberOfTuples());
1435         self.assertEqual(1,arr1.getNumberOfComponents());
1436         self.assertEqual(expected2,list(arr1.getValues()));
1437         m2_2=MEDCouplingDataForTest.build2DTargetMesh_1();
1438         self.assertEqual(5,arr1.getNumberOfTuples());
1439         self.assertEqual(1,arr1.getNumberOfComponents());
1440         self.assertEqual(expected2,list(arr1.getValues()));
1441         self.assertTrue(not m2_2.isEqual(m2_1,1e-12));
1442         m2_2.renumberCells(expected2,False);
1443         self.assertTrue(m2_2.isEqual(m2_1,1e-12));
1444         pass
1445
1446     def testSplitByType(self):
1447         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1448         v=m1.splitByType();
1449         self.assertEqual(3,len(v));
1450         m2=MEDCouplingUMesh.MergeUMeshesOnSameCoords(v);
1451         m2.setName(m1.getName());
1452         self.assertTrue(m1.isEqual(m2,1.e-12));
1453         pass
1454
1455     def testFuseUMeshesOnSameCoords(self):
1456         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
1457         cells1=[2,3,4]
1458         m3=m2.buildPartOfMySelf(cells1,True);
1459         self.assertTrue(isinstance(m3,MEDCouplingUMesh))
1460         cells2=[1,2,4]
1461         m4=m2.buildPartOfMySelf(cells2,True);
1462         self.assertTrue(isinstance(m4,MEDCouplingUMesh))
1463         cells3=[1,2]
1464         m5=m2.buildPartOfMySelf(cells3,True);
1465         self.assertTrue(isinstance(m5,MEDCouplingUMesh))
1466         meshes=[m3,m4,m5]
1467         #
1468         m7,corr=MEDCouplingUMesh.FuseUMeshesOnSameCoords(meshes,0);
1469         self.assertEqual(4,m7.getNumberOfCells());
1470         self.assertEqual(3,len(corr));
1471         expectedVals1=[3,3,2]
1472         expectedVals2=[[0,1,2],[3,0,2],[3,0]]
1473         for i in xrange(3):
1474             arr=corr[i];
1475             self.assertEqual(1,arr.getNumberOfComponents());
1476             nbOfVals=expectedVals1[i];
1477             self.assertEqual(nbOfVals,arr.getNumberOfTuples());
1478             vals=arr.getValues();
1479             self.assertEqual(expectedVals2[i],list(vals));
1480             pass
1481         arr2,fidsOfGroups=DataArrayInt.MakePartition(corr,m7.getNumberOfCells());
1482         fidExp=[5,1,3,4]
1483         fidsGrp=[[1,3,5],[3,4,5],[4,5]]
1484         self.assertEqual(3,len(fidsOfGroups));
1485         self.assertEqual(1,arr2.getNumberOfComponents());
1486         self.assertEqual(4,arr2.getNumberOfTuples());
1487         self.assertEqual(fidExp,list(arr2.getValues()));
1488         for i in xrange(3):
1489             nbOfVals=expectedVals1[i];
1490             self.assertEqual(list(fidsOfGroups[i]),fidsGrp[i]);
1491             pass
1492         pass
1493
1494     def testFuseUMeshesOnSameCoords2(self):
1495         m1,m2=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
1496         part1=[2,3,6,4,10]
1497         m3=m1.buildPartOfMySelf(part1,True);
1498         part2=[5,6,4,7]
1499         m4=m1.buildPartOfMySelf(part2,True);
1500         meshes=[m1,m3,m3,m4]
1501         m5,corr=MEDCouplingUMesh.FuseUMeshesOnSameCoords(meshes,0);
1502         self.assertEqual(18,m5.getNumberOfCells());
1503         exp2=[
1504             [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17],
1505             [2,3,6,4,10],
1506             [2,3,6,4,10],
1507             [5,6,4,7]]
1508         i=0;
1509         for it in corr:
1510             self.assertEqual(exp2[i],list(it.getValues()));
1511             i+=1
1512             pass
1513         pass
1514
1515     def testBuildOrthogonalField(self):
1516         targetMesh=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1517         field=targetMesh.buildOrthogonalField();
1518         expected=[0.70710678118654746,0.,-0.70710678118654746]
1519         self.assertEqual(5,field.getNumberOfTuples());
1520         self.assertEqual(3,field.getNumberOfComponents());
1521         vals=field.getArray().getValues();
1522         for i in xrange(15):
1523             self.assertTrue(abs(expected[i%3]-vals[i])<1e-12);
1524         # testing
1525         targetCoords=[0.,0.,0.,0.5,0.,0.5,1.,0.,1.,0.,1.,0.]
1526         targetConn=[0,1,2,3]
1527         targetMesh=MEDCouplingUMesh.New();
1528         targetMesh.setMeshDimension(2);
1529         targetMesh.allocateCells(1);
1530         targetMesh.insertNextCell(NORM_QUAD4,targetConn[0:4])
1531         targetMesh.finishInsertingCells();
1532         myCoords=DataArrayDouble.New();
1533         myCoords.setValues(targetCoords,4,3);
1534         targetMesh.setCoords(myCoords);
1535         field=targetMesh.buildOrthogonalField();
1536         self.assertEqual(1,field.getNumberOfTuples());
1537         self.assertEqual(3,field.getNumberOfComponents());
1538         vals=field.getArray().getValues();
1539         self.assertTrue(abs(-0.70710678118654746-vals[0])<1e-12);
1540         self.assertTrue(abs(0.-vals[1])<1e-12);
1541         self.assertTrue(abs(0.70710678118654746-vals[2])<1e-12);
1542         pass
1543
1544     def testGetCellsContainingPoint(self):
1545         targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1546         pos=[0.,0.,0.4,0.4,0.,0.4,0.1,0.1,0.25,0.,0.65,0.]
1547         #2D basic
1548         t1,t2=targetMesh.getCellsContainingPoints(pos,6,1e-12);
1549         self.assertEqual(6,t1.getNumberOfTuples());
1550         self.assertEqual(1,t1.getNumberOfComponents());
1551         self.assertEqual(7,t2.getNumberOfTuples());
1552         self.assertEqual(1,t2.getNumberOfComponents());
1553         expectedValues1=[0,4,3,0,1,2]
1554         expectedValues2=[0,1,2,3,4,5,6]
1555         self.assertEqual(list(t1.getValues()),expectedValues1);
1556         self.assertEqual(list(t2.getValues()),expectedValues2);
1557         #2D with no help of bounding box.
1558         center=[0.2,0.2]
1559         MEDCouplingPointSet.Rotate2DAlg(center,0.78539816339744830962,6,pos);
1560         targetMesh.rotate(center,0.78539816339744830962);
1561         t1=None
1562         t2=None
1563         t1,t2=targetMesh.getCellsContainingPoints(pos,1e-12);
1564         self.assertEqual(6,t1.getNumberOfTuples());
1565         self.assertEqual(7,t2.getNumberOfTuples());
1566         self.assertEqual(list(t1.getValues()),expectedValues1);
1567         self.assertEqual(list(t2.getValues()),expectedValues2);
1568         t1,t2=targetMesh.getCellsContainingPoints(DataArrayDouble.New(pos,6,2),1e-12);
1569         self.assertEqual(6,t1.getNumberOfTuples());
1570         self.assertEqual(7,t2.getNumberOfTuples());
1571         self.assertEqual(list(t1.getValues()),expectedValues1);
1572         self.assertEqual(list(t2.getValues()),expectedValues2);
1573         self.assertRaises(InterpKernelException,targetMesh.getCellsContainingPoints,DataArrayDouble.New(pos,4,3),1e-12);
1574         #2D outside
1575         pos1bis=[-0.3303300858899107,-0.11819805153394641]
1576         self.assertEqual(-1,targetMesh.getCellContainingPoint(pos1bis,1e-12));
1577         #test limits 2D
1578         targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1579         pos2=[0.2,-0.05]
1580         t1=None
1581         t1=targetMesh.getCellsContainingPoint(pos2,1e-12)
1582         self.assertEqual(2,len(t1));
1583         expectedValues3=[0,1]
1584         self.assertEqual(list(t1.getValues()),expectedValues3);
1585         pos3=[0.2,0.2]
1586         t1=None
1587         t1=targetMesh.getCellsContainingPoint(pos3,1e-12);
1588         self.assertEqual(5,len(t1));
1589         expectedValues4=[0,1,2,3,4]
1590         self.assertEqual(list(t1.getValues()),expectedValues4);
1591         self.assertEqual(0,targetMesh.getCellContainingPoint(pos3,1e-12));
1592         #3D
1593         targetMesh=MEDCouplingDataForTest.build3DTargetMesh_1();
1594         pos4=[25.,25.,25.]
1595         self.assertEqual(0,targetMesh.getCellContainingPoint(pos4,1e-12));
1596         pos5=[50.,50.,50.]
1597         t1=None
1598         t1=targetMesh.getCellsContainingPoint(pos5,1e-12);
1599         self.assertEqual(8,len(t1));
1600         expectedValues5=[0,1,2,3,4,5,6,7]
1601         self.assertEqual(list(t1.getValues()),expectedValues5);
1602         pos6=[0., 50., 0.]
1603         t1=None
1604         t1=targetMesh.getCellsContainingPoint(pos6,1e-12);
1605         self.assertEqual(2,len(t1));
1606         expectedValues6=[0,2]
1607         self.assertEqual(list(t1.getValues()),expectedValues6);
1608         #3D outside
1609         pos7=[-1.0,-1.0,0.]
1610         self.assertEqual(-1,targetMesh.getCellContainingPoint(pos7,1e-12));
1611         #3D outside 2
1612         center2=[0.,0.,0.]
1613         vec2=[0.,-1.,0.]
1614         targetMesh.rotate(center2,vec2,0.78539816339744830962);
1615         pos8=[-25.,25.,12.]
1616         self.assertEqual(-1,targetMesh.getCellContainingPoint(pos8,1e-12));
1617         pass
1618
1619     def testGetValueOn1(self):
1620         targetMesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1621         fieldOnCells=MEDCouplingFieldDouble.New(ON_CELLS);
1622         nbOfCells=targetMesh.getNumberOfCells();
1623         fieldOnCells.setMesh(targetMesh);
1624         array=DataArrayDouble.New();
1625         tmp=2*nbOfCells*[None]
1626         for i in xrange(nbOfCells):
1627             tmp[2*i]=7.+float(i);
1628             tmp[2*i+1]=17.+float(i)
1629             pass
1630         array.setValues(tmp,nbOfCells,2);
1631         fieldOnCells.setArray(array);
1632         #
1633         pos1=[0.25,0.]
1634         res=fieldOnCells.getValueOn(pos1);
1635         self.assertEqual(2,len(res))
1636         self.assertTrue(abs(8.-res[0])<1e-12);
1637         self.assertTrue(abs(18.-res[1])<1e-12);
1638         #
1639         #
1640         targetMesh=MEDCouplingDataForTest.build2DSourceMesh_1();
1641         fieldOnNodes=MEDCouplingFieldDouble.New(ON_NODES);
1642         nbOfNodes=targetMesh.getNumberOfNodes();
1643         fieldOnNodes.setMesh(targetMesh);
1644         array=DataArrayDouble.New();
1645         tmp=2*nbOfNodes*[None]
1646         for i in xrange(nbOfNodes):
1647             tmp[2*i]=17.+float(i);
1648             tmp[2*i+1]=27.+float(i)
1649             pass
1650         array.setValues(tmp,nbOfNodes,2);
1651         fieldOnNodes.setArray(array);
1652         #
1653         pos2=[-0.13333333333333333,-0.13333333333333333]
1654         res=None
1655         res=fieldOnNodes.getValueOn(pos2);
1656         self.assertEqual(2,len(res))
1657         self.assertTrue(abs(17.5-res[0])<1e-12);
1658         self.assertTrue(abs(27.5-res[1])<1e-12);
1659         pos3=[0.033333333333333326,0.36666666666666664]
1660         res=None
1661         res=fieldOnNodes.getValueOn(pos3);
1662         self.assertEqual(2,len(res))
1663         self.assertTrue(abs(18.666666666666667-res[0])<1e-12);
1664         self.assertTrue(abs(28.666666666666667-res[1])<1e-12);
1665         pass
1666
1667     def testCMesh0(self):
1668         mesh=MEDCouplingCMesh.New();
1669         meshEmpty=mesh.clone(True);
1670         self.assertTrue(meshEmpty.isEqual(mesh, 1e-12));
1671
1672         coordsX=DataArrayDouble.New();
1673         arrX=[ -1., 1., 2., 4. ]
1674         coordsX.setValues(arrX, 4, 1);
1675         coordsY=DataArrayDouble.New();
1676         arrY=[ -2., 2., 4., 8. ]
1677         coordsY.setValues(arrY, 4, 1);
1678         coordsZ=DataArrayDouble.New();
1679         arrZ=[ -3., 3., 6., 12. ]
1680         coordsZ.setValues(arrZ, 4, 1);
1681         mesh.setCoords(coordsX, coordsY, coordsZ);
1682         #
1683         fieldOnNodes=mesh.fillFromAnalytic(ON_NODES, 1, "x+y/2.+z/3.");
1684         self.assertEqual(1, fieldOnNodes.getNumberOfComponents());
1685         self.assertEqual(64, fieldOnNodes.getNumberOfTuples());
1686         expected1=[-3., -1., 0., 2., -1., 1., 2., 4., 0., 2., 3., 5., 2., 4., 5., 7., -1., 1., 2.,
1687                     4., 1., 3., 4., 6., 2., 4., 5., 7., 4., 6., 7., 9., 0., 2., 3., 5., 2., 4., 5.,
1688                     7., 3., 5., 6., 8., 5., 7., 8., 10., 2., 4., 5.,
1689                     7., 4., 6., 7., 9., 5., 7., 8., 10., 7., 9., 10., 12.];
1690
1691         val=fieldOnNodes.getArray().getValues();
1692         for i in xrange(64):
1693           self.assertAlmostEqual(expected1[i], val[i], 12)
1694         res=fieldOnNodes.getValueOnPos(1, 3, 2);
1695         self.assertAlmostEqual(7., res[0], 12);
1696         #
1697         fieldOnCells=mesh.fillFromAnalytic(ON_CELLS, 1, "x+y/2.+z/3.");
1698         self.assertEqual(1, fieldOnCells.getNumberOfComponents());
1699         self.assertEqual(27, fieldOnCells.getNumberOfTuples());
1700         val=fieldOnCells.getArray().getValues();
1701         expected2=[0, 1.5, 3, 1.5, 3, 4.5, 3, 4.5, 6, 1.5, 3, 4.5, 3, 4.5,
1702                     6, 4.5, 6, 7.5, 3, 4.5, 6, 4.5, 6, 7.5, 6, 7.5, 9];
1703         for i in xrange(27):
1704           self.assertAlmostEqual(expected2[i], val[i], 12);
1705         #res=fieldOnCells.getValueOnPos(1,2,1);
1706         #self.assertAlmostEqual(6.,res,12);
1707         #
1708         meshDeepCopy=mesh.deepCpy();
1709         meshClone=mesh.clone(False);
1710
1711         meshEmpty.copyTinyStringsFrom(mesh);
1712         #no data in meshEmpty, expected False
1713         self.assertTrue(not meshEmpty.isEqual(mesh, 1e-12));
1714
1715         self.assertTrue(meshDeepCopy.isEqual(mesh, 1e-12));
1716         meshDeepCopy.copyTinyStringsFrom(mesh);
1717         self.assertTrue(meshDeepCopy.isEqual(mesh, 1e-12));
1718         self.assertTrue(meshClone.isEqual(mesh, 1e-12));
1719
1720         self.assertEqual(CARTESIAN, mesh.getType());
1721         self.assertEqual(CARTESIAN, meshEmpty.getType());
1722         self.assertEqual(CARTESIAN, meshDeepCopy.getType());
1723         self.assertEqual(CARTESIAN, meshClone.getType());
1724         pass
1725
1726     def testCMesh1(self):
1727         mesh1=MEDCouplingCMesh.New();
1728         coordsX1=DataArrayDouble.New();
1729         arrX1=[ -1., 1., 2., 4. ]
1730         coordsX1.setValues(arrX1, 4, 1);
1731         coordsY1=DataArrayDouble.New();
1732         arrY1=[ -2., 2., 4., 8. ]
1733         coordsY1.setValues(arrY1, 4, 1);
1734         coordsZ1=DataArrayDouble.New();
1735         arrZ1=[ -3., 3., 6., 12. ]
1736         coordsZ1.setValues(arrZ1, 4, 1);
1737         mesh1.setCoords(coordsX1, coordsY1, coordsZ1);
1738
1739         mesh2=MEDCouplingCMesh.New();
1740         coordsX2=DataArrayDouble.New();
1741         arrX2=[ -1., 1., 2., 4. ]
1742         coordsX2.setValues(arrX2, 4, 1);
1743         coordsY2=DataArrayDouble.New();
1744         arrY2=[ -2., 2., 4., 8. ]
1745         coordsY2.setValues(arrY2, 4, 1);
1746         coordsZ2=DataArrayDouble.New();
1747         arrZ2=[ -3., 3., 6., 12.+1e-6 ]
1748         coordsZ2.setValues(arrZ2, 4, 1);
1749         mesh2.setCoords(coordsX2, coordsY2, coordsZ2);
1750
1751         mesh3=MEDCouplingCMesh.New();
1752         coordsX3=DataArrayDouble.New();
1753         arrX3=[-1.]
1754         coordsX3.setValues(arrX3, 1, 1);
1755         coordsY3=DataArrayDouble.New();
1756         arrY3=[-2.]
1757         coordsY3.setValues(arrY3, 1, 1);
1758         coordsZ3=DataArrayDouble.New();
1759         arrZ3=[-3.]
1760         coordsZ3.setValues(arrZ3, 1, 1);
1761         mesh3.setCoords(coordsX3, coordsY3, coordsZ3);
1762
1763         self.assertEqual(3, mesh1.getSpaceDimension());
1764         self.assertEqual(3, mesh1.getMeshDimension());
1765
1766         self.assertTrue(not mesh1.isEqual(mesh2, 1e-12));
1767         self.assertTrue(not mesh2.isEqual(mesh1, 1e-12));
1768         self.assertTrue(not mesh2.isEqualWithoutConsideringStr(mesh1, 1e-12));
1769         self.assertTrue(mesh1.isEqual(mesh2, 1e-5));
1770         self.assertTrue(not mesh1.isEqual(mesh2, 1e-7));
1771
1772         self.assertRaises(InterpKernelException, mesh3.checkCoherency1, 1e-12);
1773         mesh1.checkCoherency2(1e-12);
1774         self.assertEqual(NORM_HEXA8, mesh1.getTypeOfCell(1));
1775
1776         self.assertEqual(NORM_HEXA8, mesh1.getAllGeoTypes()[0]);
1777         self.assertEqual(27, mesh1.getNumberOfCellsWithType(NORM_HEXA8));
1778         self.assertRaises(InterpKernelException, mesh1.getNumberOfCellsWithType, NORM_QUAD4);
1779
1780         coo=mesh1.getCoordinatesOfNode(0);
1781         self.assertEqual(3, len(coo));
1782         self.assertAlmostEqual(-1., coo[0], 14);
1783         self.assertAlmostEqual(-2., coo[1], 14);
1784         self.assertAlmostEqual(-3., coo[2], 14);
1785         coo=mesh1.getCoordinatesOfNode(63);
1786         self.assertEqual(3, len(coo));
1787         self.assertAlmostEqual(4., coo[0], 14);
1788         self.assertAlmostEqual(8., coo[1], 14);
1789         self.assertAlmostEqual(12., coo[2], 14);
1790
1791         a=str(mesh1)
1792         repr=mesh1.simpleRepr();
1793         repr=mesh1.advancedRepr();
1794         self.assertTrue("Cartesian" in repr);
1795         self.assertTrue("Number of components : 1" in repr);
1796         self.assertTrue("Number of tuples : 4" in repr);
1797         self.assertTrue("Z Array :" in repr);
1798         pass
1799
1800     def testCMesh2(self):
1801         mesh1=MEDCouplingCMesh.New();
1802         coordsX1=DataArrayDouble.New();
1803         arrX1=[ -1., 1., 2., 4. ]
1804         coordsX1.setValues(arrX1, 4, 1);
1805         coordsY1=DataArrayDouble.New();
1806         arrY1=[ -2., 2., 4., 8. ]
1807         coordsY1.setValues(arrY1, 4, 1);
1808         coordsZ1=DataArrayDouble.New();
1809         arrZ1=[ -3., 3., 6., 12. ]
1810         coordsZ1.setValues(arrZ1, 4, 1);
1811         mesh1.setCoords(coordsX1, coordsY1, coordsZ1);
1812
1813         dis=mesh1.getDistributionOfTypes();
1814         self.assertEqual(1, len(dis));
1815         self.assertEqual(NORM_HEXA8, dis[0][0]);
1816         self.assertEqual(27, dis[0][1]);
1817         self.assertEqual(0, dis[0][2]);
1818
1819         idsPerType=[]
1820         self.assertRaises(InterpKernelException, mesh1.checkTypeConsistencyAndContig, dis, idsPerType);
1821         dis[0][2]=-1;
1822         idsPerType=[]
1823         self.assertTrue(not mesh1.checkTypeConsistencyAndContig(dis, idsPerType));
1824         dis[0][0]=NORM_QUAD4;
1825         self.assertRaises(InterpKernelException, mesh1.checkTypeConsistencyAndContig, dis, idsPerType);
1826         dis[0][0]=NORM_HEXA8;
1827         dis[0][2]=0;
1828         ids=DataArrayInt.New();
1829         ids.alloc(10, 1);
1830         ids.fillWithValue(111);
1831         idsPerType=[ids];
1832         check=mesh1.checkTypeConsistencyAndContig(dis, idsPerType);
1833         self.assertTrue(check);
1834         self.assertTrue(check.isEqual(ids));
1835
1836         code, idsInPflPerType, pfls=mesh1.splitProfilePerType(ids);
1837         self.assertEqual(3, len(code));
1838         self.assertEqual(NORM_HEXA8, code[0]);
1839         self.assertEqual(27, code[1]);
1840         self.assertEqual(0, code[2]);
1841         self.assertEqual(1, len(idsInPflPerType));
1842         self.assertEqual(1, len(pfls));
1843         self.assertTrue(idsInPflPerType[0].isEqual(ids));
1844         self.assertTrue(pfls[0].isEqual(ids));
1845
1846         cells1=[0, 1, 25, 26]
1847         partMesh1=mesh1.buildPart(cells1)
1848         self.assertTrue(isinstance(partMesh1,MEDCouplingMesh))
1849         self.assertEqual(4, partMesh1.getNumberOfCellsWithType(NORM_HEXA8));
1850         self.assertEqual(64, mesh1.getNumberOfNodes());
1851         self.assertEqual(64, partMesh1.getNumberOfNodes());
1852
1853         cells2=[25, 26]
1854         partMesh2, arr1=mesh1.buildPartAndReduceNodes(cells2)
1855         self.assertTrue(isinstance(partMesh2,MEDCouplingUMesh))
1856         self.assertEqual(2,partMesh2.getNumberOfCellsWithType(NORM_HEXA8));
1857         self.assertEqual(12,partMesh2.getNumberOfNodes());
1858
1859         cells3=[2, 3]
1860         partMesh3, arr2=partMesh1.buildPartAndReduceNodes(cells3)
1861         self.assertTrue(isinstance(partMesh3,MEDCouplingUMesh))
1862         self.assertEqual(2, partMesh3.getNumberOfCellsWithType(NORM_HEXA8));
1863         self.assertEqual(12, partMesh3.getNumberOfNodes());
1864
1865         self.assertRaises(InterpKernelException, mesh1.simplexize, 0);
1866         self.assertRaises(InterpKernelException, mesh1.getMeasureFieldOnNode, True);
1867
1868         #double bbox1[6];
1869         #double bbox2[6];
1870         bbox1=mesh1.getBoundingBox(); #[(-1.0, 4.0), (-2.0, 8.0), (-3.0, 12.0)]
1871         bbox2=partMesh1.getBoundingBox();
1872         self.assertTrue(bbox1==bbox2);
1873         bbox1=partMesh3.getBoundingBox();
1874         bbox2=partMesh2.getBoundingBox();
1875         self.assertTrue(bbox1==bbox2);
1876
1877         self.assertRaises(InterpKernelException, mesh1.buildOrthogonalField);
1878         mesh2d=MEDCouplingCMesh.New();
1879         mesh2d.setCoords(coordsX1, coordsY1);
1880         f1=mesh2d.buildOrthogonalField();
1881
1882         pass
1883
1884     def testScale(self):
1885         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
1886         pos=[0.2,0.2]
1887         mesh.scale(pos,0.5);
1888         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,
1889                    -0.05,0.45, 0.2,0.45, 0.45,0.45]
1890         val=mesh.getCoords().getValues();
1891         self.assertEqual(18,len(val))
1892         for i in xrange(18):
1893             self.assertTrue(abs(expected1[i]-val[i])<1e-12);
1894             pass
1895         pass
1896
1897     def testTryToShareSameCoords(self):
1898         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
1899         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
1900         self.assertTrue(m1.getCoords().getHiddenCppPointer()!=m2.getCoords().getHiddenCppPointer());
1901         m1.tryToShareSameCoords(m2,1e-12);
1902         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1903         m1.tryToShareSameCoords(m2,1e-12);
1904         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1905         m2.tryToShareSameCoords(m1,1e-12);
1906         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1907         #
1908         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
1909         m2=MEDCouplingDataForTest.build2DTargetMesh_2();
1910         self.assertTrue(m1.getCoords().getHiddenCppPointer()!=m2.getCoords().getHiddenCppPointer());
1911         m1.tryToShareSameCoords(m2,1e-12);
1912         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1913         m1.tryToShareSameCoords(m2,1e-12);
1914         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1915         m2.tryToShareSameCoords(m1,1e-12);
1916         self.assertTrue(m1.getCoords().getHiddenCppPointer()==m2.getCoords().getHiddenCppPointer());
1917         #
1918         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
1919         m2=MEDCouplingDataForTest.build2DSourceMesh_1();
1920         self.assertTrue(m1.getCoords().getHiddenCppPointer()!=m2.getCoords().getHiddenCppPointer());
1921         self.assertRaises(InterpKernelException,m1.tryToShareSameCoords,m2,1e-12)
1922         pass
1923
1924     def testFindNodeOnPlane(self):
1925         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
1926         pt=[300.,300.,0.]
1927         v=[0.,0.,2.]
1928         n=mesh.findNodesOnPlane(pt,v,1e-12);
1929         self.assertEqual(9,len(n));
1930         m3dSurf=mesh.buildFacePartOfMySelfNode(n,True);
1931         self.assertTrue(isinstance(m3dSurf,MEDCouplingUMesh))
1932         me=MEDCouplingExtrudedMesh.New(mesh,m3dSurf,0);
1933         da=me.getMesh3DIds();
1934         self.assertEqual(8,me.getNumberOfCells());
1935         expected=[0,1,2,3,4,5,6,7]
1936         val=da.getValues();
1937         self.assertEqual(expected,list(val));
1938         #
1939         m3dSurf=mesh.buildFacePartOfMySelfNode(n,True);
1940         self.assertTrue(isinstance(m3dSurf,MEDCouplingUMesh))
1941         me=MEDCouplingExtrudedMesh.New(mesh,m3dSurf,0);
1942         da=me.getMesh3DIds();
1943         self.assertEqual(8,me.getNumberOfCells());
1944         expected=[0,1,2,3,4,5,6,7]
1945         val=da.getValues();
1946         self.assertEqual(expected,list(val));
1947         pass
1948
1949     def testRenumberCells(self):
1950         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1951         m2=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1952         self.assertTrue(m.isEqual(m2,0));
1953         arr=[12,3,25,2,26]
1954         m.renumberCells(arr,True);
1955         self.assertTrue(not m.isEqual(m2,0));
1956         self.assertEqual(NORM_QUAD4,m.getTypeOfCell(0));
1957         self.assertEqual(NORM_TRI3,m.getTypeOfCell(1));
1958         self.assertEqual(NORM_QUAD4,m.getTypeOfCell(2));
1959         self.assertEqual(NORM_TRI3,m.getTypeOfCell(3));
1960         self.assertEqual(NORM_QUAD4,m.getTypeOfCell(4));
1961         arr2=[5,-1,-5,4,8]
1962         m.renumberCells(arr2,True);
1963         self.assertTrue(m.isEqual(m2,0));
1964         pass
1965
1966     def testChangeSpaceDimension(self):
1967         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
1968         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
1969         #
1970         self.assertEqual(3,m1.getSpaceDimension());
1971         m1.changeSpaceDimension(2);
1972         self.assertEqual(2,m1.getSpaceDimension());
1973         m1.setName(m2.getName());
1974         self.assertTrue(m1.isEqual(m2,1e-12));
1975         m1.changeSpaceDimension(3);
1976         self.assertEqual(3,m1.getSpaceDimension());
1977         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.]
1978         val=m1.getCoords().getValues();
1979         for i in xrange(27):
1980             self.assertTrue(abs(expected[i]-val[i])<1e-14);
1981             pass
1982         pass
1983
1984     def testGaussPointField1(self):
1985         _a=0.446948490915965;
1986         _b=0.091576213509771;
1987         _p1=0.11169079483905;
1988         _p2=0.0549758718227661;
1989         refCoo1=[ 0.,0., 1.,0., 0.,1. ]
1990         gsCoo1=[ 2*_b-1, 1-4*_b, 2*_b-1, 2.07*_b-1, 1-4*_b,
1991                  2*_b-1, 1-4*_a, 2*_a-1, 2*_a-1, 1-4*_a, 2*_a-1, 2*_a-1 ]
1992         wg1=[ 4*_p2, 4*_p2, 4*_p2, 4*_p1, 4*_p1, 4*_p1 ]
1993         _refCoo1=refCoo1
1994         _gsCoo1=gsCoo1
1995         _wg1=wg1
1996         #
1997         m=MEDCouplingDataForTest.build2DTargetMesh_1();
1998         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,NO_TIME);
1999         f.setMesh(m);
2000         self.assertEqual(5,f.getNumberOfMeshPlacesExpected());
2001         self.assertEqual(0,f.getNbOfGaussLocalization());
2002         f.setGaussLocalizationOnType(NORM_TRI3,_refCoo1,_gsCoo1,_wg1);
2003         f.setGaussLocalizationOnType(NORM_TRI3,_refCoo1,_gsCoo1,_wg1); # not a bug only to check that it works well
2004         self.assertRaises(InterpKernelException,f.setGaussLocalizationOnType,NORM_QUAD4,_refCoo1,_gsCoo1,_wg1)
2005         self.assertEqual(1,f.getNbOfGaussLocalization());
2006         refCoo2=[ 0.,0., 1.,0., 1.,1., 0.,1. ]
2007         _refCoo2=refCoo2
2008         _gsCoo1=_gsCoo1[0:4]
2009         _wg1=_wg1[0:2]
2010         f.setGaussLocalizationOnType(NORM_QUAD4,_refCoo2,_gsCoo1,_wg1);
2011         self.assertEqual(2,f.getNbOfGaussLocalization());
2012         array=DataArrayDouble.New();
2013         ptr=18*2*[None]
2014         for i in xrange(18*2):
2015             ptr[i]=float(i+1)
2016         array.setValues(ptr,18,2);
2017         ptr=array.getPointer();
2018         f.setArray(array);
2019         f.setName("MyFirstFieldOnGaussPoint");
2020         f.checkCoherency();
2021         self.assertAlmostEqual(27.,f.getIJK(2,5,0),14);
2022         self.assertAlmostEqual(16.,f.getIJK(1,5,1),14);
2023         #
2024         f.clearGaussLocalizations();
2025         self.assertEqual(0,f.getNbOfGaussLocalization());
2026         self.assertRaises(InterpKernelException,f.checkCoherency);
2027         ids1=[0,1,3,4]
2028         self.assertRaises(InterpKernelException,f.setGaussLocalizationOnCells,ids1,_refCoo2,_gsCoo1,_wg1);
2029         self.assertEqual(0,f.getNbOfGaussLocalization());
2030         ids2=[0,4]
2031         f.setGaussLocalizationOnCells(ids2,_refCoo2,_gsCoo1,_wg1);
2032         self.assertEqual(1,f.getNbOfGaussLocalization());
2033         self.assertEqual(0,f.getGaussLocalizationIdOfOneCell(0));
2034         self.assertRaises(InterpKernelException,f.getGaussLocalizationIdOfOneCell,1);
2035         ids3=[1,2]
2036         f.setGaussLocalizationOnCells(ids3,_refCoo1,_gsCoo1,_wg1);
2037         self.assertEqual(2,f.getNbOfGaussLocalization());
2038         self.assertEqual(0,f.getGaussLocalizationIdOfOneCell(0));
2039         self.assertEqual(1,f.getGaussLocalizationIdOfOneCell(1));
2040         self.assertEqual(1,f.getGaussLocalizationIdOfOneCell(2));
2041         self.assertRaises(InterpKernelException,f.checkCoherency);#<- cell 3 has no localization
2042         ids4=[3]
2043         _gsCoo2=_gsCoo1;
2044         _wg2=_wg1;
2045         _gsCoo2[0]=0.8888777776666;
2046         _wg2[0]=0.1234567892377;
2047         f.setGaussLocalizationOnCells(ids4,_refCoo2,_gsCoo2,_wg2);
2048         self.assertEqual(3,f.getNbOfGaussLocalization());
2049         tmpIds=f.getCellIdsHavingGaussLocalization(0);
2050         self.assertEqual(ids2,list(tmpIds.getValues()));
2051         self.assertRaises(InterpKernelException,f.checkCoherency);#<- it's always not ok because undelying array not with the good size.
2052         array2=f.getArray().substr(0,10);
2053         f.setArray(array2);
2054         f.checkCoherency();#<- here it is OK
2055         f2=f.clone(True);
2056         self.assertTrue(f.isEqual(f2,1e-14,1e-14));
2057         gl1=f2.getGaussLocalization(0);
2058         tmp=gl1.getGaussCoord(1,1);
2059         self.assertAlmostEqual(2.07*_b-1,tmp,14);
2060         gl1.setGaussCoord(1,1,0.07);
2061         self.assertTrue(not f.isEqual(f2,1e-14,1e-14));
2062         gl1.setGaussCoord(1,1,tmp);
2063         self.assertTrue(f.isEqual(f2,1e-14,1e-14));
2064         f2.checkCoherency();
2065         pass
2066
2067     def testGaussPointNEField1(self):
2068         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2069         f=MEDCouplingFieldDouble.New(ON_GAUSS_NE,NO_TIME);
2070         f.setMesh(m);
2071         self.assertEqual(5,f.getNumberOfMeshPlacesExpected());
2072         f.setName("MyFirstFieldOnNE");
2073         f.setDescription("MyDescriptionNE");
2074         array=DataArrayDouble.New();
2075         tmp=18*2*[None]
2076         for i in xrange(18*2):
2077             tmp[i]=float(i+7)
2078             pass
2079         array.setValues(tmp,18,2);
2080         ptr=array.getPointer();
2081         f.setArray(array);
2082         #
2083         f.checkCoherency();
2084         f2=f.clone(True);
2085         self.assertTrue(f.isEqual(f2,1e-14,1e-14));
2086         self.assertAlmostEqual(21.,f.getIJK(2,0,0),14);
2087         self.assertAlmostEqual(18.,f.getIJK(1,1,1),14);
2088         pass
2089
2090     def testCellOrientation1(self):
2091         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2092         vec=[0.,0.,-1.]
2093         self.assertRaises(InterpKernelException,m.are2DCellsNotCorrectlyOriented,vec,False);
2094         m.changeSpaceDimension(3);
2095         res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2096         self.assertTrue(len(res1)==0);
2097         vec[2]=1.;
2098         res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2099         self.assertEqual(5,len(res1));
2100         #
2101         vec[2]=-1.;
2102         # connectivity inversion
2103         conn=m.getNodalConnectivity().getValues();
2104         tmp=conn[11];
2105         conn[11]=conn[12];
2106         conn[12]=tmp;
2107         m.getNodalConnectivity().setValues(conn,len(conn),1)
2108         res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2109         self.assertEqual(1,len(res1));
2110         self.assertEqual(2,res1.getValues()[0]);
2111         m.orientCorrectly2DCells(vec,False);
2112         res1=m.are2DCellsNotCorrectlyOriented(vec,False);
2113         self.assertTrue(len(res1)==0);
2114         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
2115         m2.changeSpaceDimension(3);
2116         self.assertTrue(m.isEqual(m2,1e-12));
2117         pass
2118
2119     def testCellOrientation2(self):
2120         m2,m1=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
2121         res1=m2.arePolyhedronsNotCorrectlyOriented();
2122         self.assertEqual(6,len(res1));
2123         m2.orientCorrectlyPolyhedrons();
2124         res1=m2.arePolyhedronsNotCorrectlyOriented();
2125         self.assertTrue(len(res1)==0);
2126         m2.checkCoherency();
2127         self.assertEqual(18,m2.getNumberOfCells());
2128         cellIds2=[0,6,12]
2129         m2.convertToPolyTypes(cellIds2);
2130         m2.orientCorrectlyPolyhedrons();
2131         res1=m2.arePolyhedronsNotCorrectlyOriented();
2132         self.assertTrue(len(res1)==0);
2133         f2=m2.getMeasureField(False);
2134         f2Ptr=f2.getArray().getValues();
2135         #Test to check global reverse in MEDCouplingUMesh::tryToCorrectPolyhedronOrientation
2136         m3=MEDCouplingDataForTest.build2DTargetMesh_1();
2137         vec=[0.,0.,1.]
2138         m3.changeSpaceDimension(3);
2139         ids2=[0,1,2,3,4]
2140         m3.convertToPolyTypes(ids2);
2141         m3.orientCorrectly2DCells(vec,False);
2142         m4=MEDCouplingDataForTest.buildCU1DMesh_U();
2143         m4.changeSpaceDimension(3);
2144         center=[0.,0.,0.]
2145         vector=[0.,1.,0.]
2146         m4.rotate(center,vector,-pi/2.);
2147         m5=m3.buildExtrudedMesh(m4,0);
2148         res1=m5.arePolyhedronsNotCorrectlyOriented();
2149         self.assertEqual(15,len(res1));
2150         m5.orientCorrectlyPolyhedrons();
2151         res1=m5.arePolyhedronsNotCorrectlyOriented();
2152         self.assertTrue(len(res1)==0);
2153         f3=m5.getMeasureField(False);
2154         self.assertEqual(15,f3.getArray().getNumberOfTuples());
2155         self.assertEqual(1,f3.getNumberOfComponents());
2156         f3Ptr=f3.getArray().getValues();
2157         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];
2158         for i in xrange(15):
2159             self.assertTrue(abs(expected1[i]-f3Ptr[i])<1e-12);
2160             pass
2161         f4=m5.getBarycenterAndOwner();
2162         self.assertEqual(15,f4.getNumberOfTuples());
2163         self.assertEqual(3,f4.getNumberOfComponents());
2164         f4Ptr=f4.getValues();
2165         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];
2166         for i in xrange(45):
2167             self.assertTrue(abs(expected2[i]-f4Ptr[i])<1e-12);
2168             pass
2169         pass
2170
2171     def testPolyhedronBarycenter(self):
2172         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];
2173         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];
2174         meshN=MEDCouplingUMesh.New();
2175         meshN.setName("ForBary");
2176         meshN.setMeshDimension(3);
2177         meshN.allocateCells(4);
2178         meshN.insertNextCell(NORM_POLYHED,29,connN[0:29])
2179         meshN.finishInsertingCells();
2180         myCoords=DataArrayDouble.New();
2181         myCoords.setValues(coords,9,3);
2182         meshN.setCoords(myCoords);
2183         meshN.checkCoherency();
2184         #
2185         res1=meshN.arePolyhedronsNotCorrectlyOriented();
2186         meshN.orientCorrectlyPolyhedrons();
2187         self.assertTrue(len(res1)==0);
2188         da=meshN.getBarycenterAndOwner();
2189         self.assertEqual(1,da.getNumberOfTuples());
2190         self.assertEqual(3,da.getNumberOfComponents());
2191         daPtr=da.getValues();
2192         ref=meshN.getCoords().getValues()[24:];
2193         for i in xrange(3):
2194             self.assertTrue(abs(ref[i]-daPtr[i])<1e-12);
2195             pass
2196         #
2197         center=[0.,0.,0.]
2198         vec=[0.,2.78,0.]
2199         da=meshN.getBarycenterAndOwner();
2200         daPtr=da.getValues();
2201         ref=meshN.getCoords().getValues()[24:];
2202         for i in xrange(3):
2203             self.assertTrue(abs(ref[i]-daPtr[i])<1e-12);
2204             pass
2205         #
2206         meshN.rotate(center,vec,pi/7.);
2207         meshN.translate(vec);
2208         da=meshN.getBarycenterAndOwner();
2209         daPtr=da.getValues();
2210         ref=meshN.getCoords().getValues()[24:];
2211         for i in xrange(3):
2212             self.assertTrue(abs(ref[i]-daPtr[i])<1e-12);
2213             pass
2214         #
2215         center2=[1.12,3.45,6.78]
2216         vec2=[4.5,9.3,2.8]
2217         meshN.rotate(center2,vec2,e);
2218         meshN.translate(vec2);
2219         da=meshN.getBarycenterAndOwner();
2220         daPtr=da.getValues();
2221         ref=meshN.getCoords().getValues()[24:];
2222         for i in xrange(3):
2223             self.assertTrue(abs(ref[i]-daPtr[i])<1e-10);
2224             pass
2225         pass
2226
2227     def testNormL12Integ1D(self):
2228         m1=MEDCouplingDataForTest.build1DTargetMesh_3();
2229         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2230         f1.setMesh(m1);
2231         array=DataArrayDouble.New();
2232         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]
2233         array.setValues(arr,m1.getNumberOfCells(),3);
2234         f1.setArray(array);
2235         #
2236         f3=m1.getBarycenterAndOwner();
2237         self.assertEqual(4,f3.getNumberOfTuples());
2238         self.assertEqual(1,f3.getNumberOfComponents());
2239         expected9=[0.75,5.105,0.8,5.155]
2240         ptr=f3.getValues();
2241         for i in xrange(4):
2242             self.assertTrue(abs(expected9[i]-ptr[i])<1e-12);
2243             pass
2244         #
2245         f2=m1.getMeasureField(False);
2246         self.assertEqual(4,f2.getArray().getNumberOfTuples());
2247         self.assertEqual(1,f2.getNumberOfComponents());
2248         expected1=[0.5,0.21,-0.6,-0.31]
2249         ptr=f2.getArray().getValues();
2250         for i in xrange(4):
2251             self.assertTrue(abs(expected1[i]-ptr[i])<1e-12);
2252             pass
2253         expected2=[0.5,0.21,0.6,0.31]
2254         f2=m1.getMeasureField(True);
2255         ptr=f2.getArray().getValues();
2256         for i in xrange(4):
2257             self.assertTrue(abs(expected2[i]-ptr[i])<1e-12);
2258             pass
2259         #integral
2260         self.assertTrue(4,f1.getNumberOfTuples())
2261         res=f1.integral(False);
2262         self.assertTrue(3,len(res))
2263         expected3=[0.9866,-0.3615,0.4217]
2264         for i in xrange(3):
2265             self.assertTrue(abs(expected3[i]-res[i])<1e-12);
2266             pass
2267         self.assertTrue(abs(expected3[0]-f1.integral(0,False))<1e-12);
2268         self.assertTrue(abs(expected3[1]-f1.integral(1,False))<1e-12);
2269         self.assertTrue(abs(expected3[2]-f1.integral(2,False))<1e-12);
2270         res=f1.integral(True);
2271         expected4=[-3.4152,8.7639,-14.6879]
2272         for i in xrange(3):
2273             self.assertTrue(abs(expected4[i]-res[i])<1e-12);
2274             pass
2275         #normL1
2276         res=f1.normL1();
2277         self.assertTrue(3,len(res))
2278         expected5=[6.979506172839505, 16.89018518518518, 27.02969135802469]
2279         for i in xrange(3):
2280             self.assertTrue(abs(expected5[i]-res[i])<1e-12);
2281             pass
2282         self.assertTrue(abs(expected5[0]-f1.normL1(0))<1e-12);
2283         self.assertTrue(abs(expected5[1]-f1.normL1(1))<1e-12);
2284         self.assertTrue(abs(expected5[2]-f1.normL1(2))<1e-12);
2285         #normL2
2286         res=f1.normL2();
2287         self.assertTrue(3,len(res))
2288         expected7=[7.090910979452395, 16.9275542960123, 27.053271464160858]
2289         for i in xrange(3):
2290             self.assertTrue(abs(expected7[i]-res[i])<1e-9);
2291             pass
2292         self.assertTrue(abs(expected7[0]-f1.normL2(0))<1e-9);
2293         self.assertTrue(abs(expected7[1]-f1.normL2(1))<1e-9);
2294         self.assertTrue(abs(expected7[2]-f1.normL2(2))<1e-9);
2295         #buildMeasureField
2296         f4=f1.buildMeasureField(False);
2297         self.assertTrue(abs(-0.2-f4.accumulate(0))<1e-12);
2298         f4=f1.buildMeasureField(True);
2299         self.assertTrue(abs(1.62-f4.accumulate(0))<1e-12);
2300         # Testing with 2D Curve
2301         m1=MEDCouplingDataForTest.build2DCurveTargetMesh_3();
2302         f2=m1.getMeasureField(False);
2303         self.assertEqual(4,f2.getArray().getNumberOfTuples());
2304         self.assertEqual(1,f2.getNumberOfComponents());
2305         ptr=f2.getArray().getValues();
2306         for i in xrange(4):
2307             self.assertTrue(abs(sqrt(2.)*expected2[i]-ptr[i])<1e-12);
2308             pass
2309         f2=m1.getMeasureField(True);
2310         self.assertEqual(4,f2.getArray().getNumberOfTuples());
2311         self.assertEqual(1,f2.getNumberOfComponents());
2312         ptr=f2.getArray().getValues();
2313         for i in xrange(4):
2314             self.assertTrue(abs(expected2[i]*sqrt(2.)-ptr[i])<1e-12);
2315             pass
2316         #bary
2317         f3=m1.getBarycenterAndOwner();
2318         self.assertEqual(4,f3.getNumberOfTuples());
2319         self.assertEqual(2,f3.getNumberOfComponents());
2320         expected10=[0.75,0.75,5.105,5.105,0.8,0.8,5.155,5.155]
2321         ptr=f3.getValues();
2322         for i in xrange(8):
2323             self.assertTrue(abs(expected10[i]-ptr[i])<1e-12);
2324             pass
2325         #
2326         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2327         f1.setMesh(m1);
2328         array=DataArrayDouble.New();
2329         array.setValues(arr,m1.getNumberOfCells(),3);
2330         f1.setArray(array);
2331         res=f1.integral(False);
2332         for i in xrange(3):
2333             self.assertTrue(abs(sqrt(2.)*expected4[i]-res[i])<1e-12);
2334             pass
2335         res=f1.integral(True);
2336         for i in xrange(3):
2337             self.assertTrue(abs(sqrt(2.)*expected4[i]-res[i])<1e-12);
2338             pass
2339         res=f1.normL1();
2340         for i in xrange(3):
2341             self.assertTrue(abs(expected5[i]-res[i])<1e-12);
2342             pass
2343         res=f1.normL2();
2344         for i in xrange(3):
2345             self.assertTrue(abs(expected7[i]-res[i])<1e-12);
2346             pass
2347         pass
2348
2349     def testAreaBary2D(self):
2350         m1=MEDCouplingDataForTest.build2DTargetMesh_3();
2351         f1=m1.getMeasureField(False);
2352         self.assertEqual(10,f1.getArray().getNumberOfTuples());
2353         self.assertEqual(1,f1.getNumberOfComponents());
2354         expected1=[-0.5,-1,-1.5,-0.5,-1,  0.5,1,1.5,0.5,1]
2355         ptr=f1.getArray().getValues();
2356         for i in xrange(10):
2357             self.assertTrue(abs(expected1[i]-ptr[i])<1e-12);
2358             pass
2359         f1=m1.getMeasureField(True);
2360         ptr=f1.getArray().getValues();
2361         for i in xrange(10):
2362             self.assertTrue(abs(abs(expected1[i])-ptr[i])<1e-12);
2363             pass
2364         f2=m1.getBarycenterAndOwner();
2365         self.assertEqual(10,f2.getNumberOfTuples());
2366         self.assertEqual(2,f2.getNumberOfComponents());
2367         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]
2368         ptr=f2.getValues();
2369         for i in xrange(20):
2370             self.assertTrue(abs(expected2[i]-ptr[i])<1e-12);
2371             pass
2372         m1.changeSpaceDimension(3);
2373         f1=m1.getMeasureField(False);
2374         self.assertEqual(10,f1.getArray().getNumberOfTuples());
2375         self.assertEqual(1,f1.getNumberOfComponents());
2376         ptr=f1.getArray().getValues();
2377         for i in xrange(10):
2378             self.assertTrue(abs(abs(expected1[i])-ptr[i])<1e-12);
2379             pass
2380         f2=m1.getBarycenterAndOwner();
2381         self.assertEqual(10,f2.getNumberOfTuples());
2382         self.assertEqual(3,f2.getNumberOfComponents());
2383         ptr=f2.getValues();
2384         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.]
2385         for i in xrange(30):
2386             self.assertTrue(abs(expected3[i]-ptr[i])<1e-12);
2387             pass
2388         pass
2389
2390     def testAreaBary3D(self):
2391         coords=[ 0.241310763507 , 0.0504777305619 , 0.0682283524903 , 0.252501053866 , -0.0625176732937 , 0.137272639894 ,
2392                  0.152262663601 , 0.241816569527 , 0.133812556197 , 0.18047750211 , -0.0789949051358 , 0.339098173401 ,
2393                  0.151741971857 , 0.238885278571 , 0.137715037333 , 0.242532155481 , -0.0928169086456 , 0.0678043417367 ,
2394                  0.240941965335 , -0.015461491464 , 0.0617186345825 , 0.24127650112 , 0.0499427876717 , 0.0679634099148 ,
2395                  -0.145828917428 , 0.206291632565 , 0.0310071927543 , 0.0125651775307 , 0.266262085828 , 0.105228430543 ,
2396                  -0.0994066533286 , 0.233224271238 , 0.0572213839567 , -0.0951345338317 , 0.234819509426 , 0.0592126284538 ,
2397                  0.136580574205 , -0.205486212579 , 0.0572866072014 , 0.0637270784978 , -0.168886355238 , 0.446614057077 ,
2398                  0.041337157151 , -0.213402568198 , 0.372407095999 , 0.0411601970268 , -0.202387875756 , 0.411334979491 ,
2399                  -0.108355701857 , 0.193636239335 , 0.204886756738 , 0.00639779029829 , 0.155296981517 , 0.252585892979 ,
2400                  0.0262473111702 , -0.112919732543 , 0.424286639249 ,-0.224103052733 , -0.139430015438 , -0.0122352295701 ,
2401                 -0.0312760589481 , -0.274272003594 , 0.0323959636568 , -0.166663422532 , -0.217754445175 , 0.00392109070364 ,
2402                  -0.30586619777 , -0.0475168041091 , -0.0144585228182 , -0.280881480586 , 0.135571293538 , 0.00623923647986 ,
2403                  -0.25548538234 , 0.156819217766 , 0.0645277879769 , -0.131567009284 , 0.184133752309 , 0.206021802753 ,
2404                  -0.196204010965 , 0.151602971681 , 0.212974777736 , -0.183713879463 , 0.0802946639531 , 0.260115662599 ,
2405                  -0.244241178767 , -0.0738873389604 , 0.144590565817 , -0.155804057829 , -0.164892720025 , 0.210613950558 ,
2406                  -0.170950800428 , -0.215099334026 , 0.00610122860092 , -0.30552634869 , -0.0490020791904 , -0.0132786533145 ,
2407                  0.271831011884 , 0.15105657296 , 0.0230534827908 , 0.281919192283 , 0.0898544306288 , -0.0625201489143 ,
2408                  0.260240727276 , -0.0120688706637 , -0.0532316588626 , 0.244947737722 , 0.0197984684293 , 0.0309341209233 ,
2409                  0.23439631578 , 0.229825279875 , 0.0508520585381 , 0.160921316875 , 0.265078502128 , 0.121716560626 ,
2410                  -0.315088694175 , 0.0747700471918 , -0.245836615071 , -0.327728781776 , 0.0857114674649 , -0.239431905957 ,
2411                  -0.308385460634 , 0.145142997084 , -0.149886828433 , 0.0488236045164 , 0.309462801914 , 0.0849169148265 ,
2412                 -0.0244964803395 , 0.33145611751 , -0.0476415818061 , 0.0060567994229 , 0.32418412014 , 0.0367779543812 ,
2413                  -0.0950221448063 , 0.236675326003 , 0.0572594453983 , 0.248723023186 , 0.0886648784791 , -0.176629430538 ,
2414                  0.116796984 , 0.256596599567 , -0.292863523603 , 0.118024552914 , 0.229154257843 , -0.34233232501 ,
2415                  0.217507892549 , -0.0417822335742 , -0.176771782888 , -0.224429321304 , 0.0125595300114 , -0.362064725588 ,
2416                  0.0937301100955 , -0.0500824832657 , -0.299713548444 , -0.244162220397 , 0.0383853931293 , -0.389856984411 ,
2417                  -0.0281989366102 , 0.097392811563 , -0.458244577284 , -0.385010847162 , 0.10122766194 , -0.140052859922 ,
2418                  -0.377936358012 , 0.110875172128 , -0.176207095463 , 0.244483045556 , -0.0991073977045 , 0.0575134372934 ,
2419                 0.262605120167 , -0.100243191645 , -0.0495620806935 , 0.240306880972 , -0.136153701579 , -0.114745281696 ,
2420                  0.215763176129 , -0.0836766059189 , -0.183249640616 , 0.237870396603 , -0.132449578286 , -0.121598854639 ,
2421                  -0.0637683083097 , -0.27921020214 , -0.149112321992 , -0.0856211014977 , -0.2973233473 , -0.0446878139589 ,
2422                  0.104675342288 , -0.0625908305324 , -0.290346256534 , 0.0248264249186 , -0.247797708548 , -0.165830884019 ,
2423                  0.0719302438309 , -0.178468260473 , -0.211432157345 , 0.142871843159 , -0.208769948542 , 0.0454101128246 ,
2424                  0.167803379307 , -0.207851396623 , -0.088802726124 , 0.12868717152 , -0.230920439715 , 0.00760508389036 ,
2425                  -0.0372812069535 , -0.286740286332 , 0.00963701291166 ]
2426
2427         connN = [ #polyhedron 0
2428             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
2429             , 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
2430             , 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
2431             , 22 , 19 , 21 , 30 , 31 , -1 , 22 , 31 , 28 , 27 , 26 , 24 , 23 , -1 , 31 , 30 , 29 , 28,
2432             # polyhedron 1
2433             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
2434             , 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
2435             , 33 , 34 , 48 , 45 , -1 , 35 , 34 , 48 , 50 , 49 , 38 , -1 , 41 , 43 , 42 , 46 , 36 , 37 , -1 , 38 , 39 , 51 , 49 , -1
2436             , 39 , 40 , 42 , 46 , 47 , 52 , 51 , -1 , 45 , 47 , 52 , 50 , 48 , -1 , 52 , 51 , 49 , 50,
2437             # polyhedron 2
2438             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
2439             , 23 , 53 , 54 , 40 , 8 , -1 , 53 , 22 , 23 , -1 , 39 , 54 , 40,
2440             # polyhedron 3
2441             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
2442             , 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
2443             , 55 , 5 , 12 , 65 , -1 , 66 , 67 , 65 , 55 , 56 , 57 , -1 , 63 , 66 , 57 , 59 , 64 , -1 , 64 , 62 , 58 , 59 , -1
2444             , 60 , 63 , 66 , 67 , 68 , 61 , -1 , 61 , 68 , 20 , 21 , -1 , 67 , 68 , 20 , 12 , 65]
2445
2446         barys = [ -0.0165220465527 , -0.0190922868195 , 0.158882733414 ,
2447                   0.0287618656076 , 0.135874379934 , -0.14601588119 ,
2448                   -0.147128055553 , 0.0465995097041 , -0.049391174453 ,
2449                   -0.00142506732317 , -0.0996953090351 , -0.115159183132 ]
2450         meshN=MEDCouplingUMesh.New();
2451         meshN.setName("ForBary");
2452         meshN.setMeshDimension(3);
2453         meshN.allocateCells(4);
2454         meshN.insertNextCell(NORM_POLYHED,113,connN);
2455         meshN.insertNextCell(NORM_POLYHED,99,connN[113:]);
2456         meshN.insertNextCell(NORM_POLYHED,43,connN[212:]);
2457         meshN.insertNextCell(NORM_POLYHED,92,connN[255:]);
2458         meshN.finishInsertingCells();
2459         myCoords=DataArrayDouble.New();
2460         myCoords.setValues(coords,69,3);
2461         meshN.setCoords(myCoords);
2462         meshN.checkCoherency();
2463         res1=meshN.arePolyhedronsNotCorrectlyOriented();
2464         meshN.orientCorrectlyPolyhedrons();
2465         res1=meshN.arePolyhedronsNotCorrectlyOriented();
2466         self.assertTrue(len(res1)==0);
2467         #
2468         da=meshN.getBarycenterAndOwner();
2469         self.assertEqual(4,da.getNumberOfTuples());
2470         self.assertEqual(3,da.getNumberOfComponents());
2471         daPtr=da.getValues();
2472         for i in xrange(12):
2473             self.assertTrue(abs(barys[i]-daPtr[i])<1e-12);
2474             pass
2475         pass
2476
2477     def testRenumberCellsForFields(self):
2478         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2479         f=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2480         f.setMesh(m);
2481         arr=DataArrayDouble.New();
2482         nbOfCells=m.getNumberOfCells();
2483         values1=[7.,107.,10007.,8.,108.,10008.,9.,109.,10009.,10.,110.,10010.,11.,111.,10011.]
2484         arr.setValues(values1,nbOfCells,3);
2485         f.setArray(arr);
2486         renumber1=[3,1,0,4,2]
2487         loc=[-0.05,-0.05, 0.55,-0.25, 0.55,0.15, -0.05,0.45, 0.45,0.45]
2488         for j in xrange(5):
2489             res=f.getValueOn(loc[2*j:2*j+2]);
2490             for i in xrange(3):
2491                 self.assertTrue(abs(values1[i+3*j]-res[i])<1e-12);
2492                 pass
2493             pass
2494         f.renumberCells(renumber1,False);
2495         ptr=f.getArray().getValues();
2496         expected1=[9.,109.,10009.,8.,108.,10008.,11.,111.,10011.,7.,107.,10007.,10.,110.,10010.]
2497         for i in xrange(15):
2498             self.assertTrue(abs(expected1[i]-ptr[i])<1e-12);
2499             pass
2500         #check that fields remains the same geometrically
2501         for j in xrange(5):
2502             res=f.getValueOn(loc[2*j:2*(j+1)]);
2503             for i in xrange(3):
2504                 self.assertTrue(abs(values1[i+3*j]-res[i])<1e-12);
2505                 pass
2506             pass
2507         #On gauss
2508         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,NO_TIME);
2509         f.setMesh(m);
2510         _a=0.446948490915965;
2511         _b=0.091576213509771;
2512         _p1=0.11169079483905;
2513         _p2=0.0549758718227661;
2514         refCoo1=[ 0.,0., 1.,0., 0.,1. ]
2515         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 ];
2516         wg1=[ 4*_p2, 4*_p2, 4*_p2, 4*_p1, 4*_p1, 4*_p1 ]
2517         _refCoo1=refCoo1[0:6];
2518         _gsCoo1=gsCoo1[0:12];
2519         _wg1=wg1[0:6];
2520         f.setGaussLocalizationOnType(NORM_TRI3,_refCoo1,_gsCoo1,_wg1);
2521         refCoo2=[ 0.,0., 1.,0., 1.,1., 0.,1. ]
2522         _refCoo2=refCoo2[0:8];
2523         _gsCoo1=_gsCoo1[0:4]
2524         _wg1=_wg1[0:2]
2525         f.setGaussLocalizationOnType(NORM_QUAD4,_refCoo2,_gsCoo1,_wg1);
2526         arr=DataArrayDouble.New();
2527         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.]
2528         arr.setValues(values2,18,2);
2529         f.setArray(arr);
2530         f.checkCoherency();
2531         fCpy=f.clone(True);
2532         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2533         f.renumberCells(renumber1,False);
2534         self.assertTrue(not f.isEqual(fCpy,1e-12,1e-12));
2535         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.]
2536         ptr=f.getArray().getValues();
2537         for i in xrange(36):
2538             self.assertTrue(abs(expected2[i]-ptr[i])<1e-12);
2539             pass
2540         renumber2=[2,1,4,0,3]
2541         f.renumberCells(renumber2,False);
2542         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2543         #GaussNE
2544         f=MEDCouplingFieldDouble.New(ON_GAUSS_NE,NO_TIME);
2545         f.setMesh(m);
2546         arr=DataArrayDouble.New();
2547         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.]
2548         arr.setValues(values3,18,2);
2549         f.setArray(arr);
2550         f.checkCoherency();
2551         fCpy=f.clone(True);
2552         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2553         f.renumberCells(renumber1,False);
2554         self.assertTrue(not f.isEqual(fCpy,1e-12,1e-12));
2555         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.]
2556         ptr=f.getArray().getValues();
2557         for i in xrange(36):
2558             self.assertTrue(abs(expected3[i]-ptr[i])<1e-12);
2559             pass
2560         f.renumberCells(renumber2,False);#perform reverse operation of renumbering to check that the resulting field is equal.
2561         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2562         #
2563         pass
2564
2565     def testRenumberNodesForFields(self):
2566         m=MEDCouplingDataForTest.build2DTargetMesh_1();
2567         f=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
2568         f.setMesh(m);
2569         self.assertEqual(9,f.getNumberOfMeshPlacesExpected());
2570         arr=DataArrayDouble.New();
2571         nbOfNodes=m.getNumberOfNodes();
2572         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.]
2573         arr.setValues(values1,nbOfNodes,3);
2574         f.setArray(arr);
2575         f.checkCoherency();
2576         renumber1=[0,4,1,3,5,2,6,7,8]
2577         loc=[0.5432,-0.2432, 0.5478,0.1528]
2578         expected1=[9.0272, 109.0272, 10009.0272, 11.4124,111.4124,10011.4124]
2579         for j in xrange(2):
2580             res=f.getValueOn(loc[2*j:2*j+2]);
2581             for i in xrange(3):
2582                 self.assertTrue(abs(expected1[i+3*j]-res[i])<1e-12);
2583                 pass
2584             pass
2585         fCpy=f.clone(True);
2586         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2587         f.renumberNodes(renumber1);
2588         self.assertTrue(not f.isEqual(fCpy,1e-12,1e-12));
2589         for j in xrange(2):
2590             res=f.getValueOn(loc[2*j:2*j+2]);
2591             for i in xrange(3):
2592                 self.assertTrue(abs(expected1[i+3*j]-res[i])<1e-12);
2593                 pass
2594             pass
2595         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.]
2596         for i in xrange(27):
2597             self.assertTrue(abs(expected2[i]-f.getArray().getValues()[i])<1e-12);
2598             pass
2599         renumber2=[0,2,5,3,1,4,6,7,8]
2600         f.renumberNodes(renumber2);
2601         self.assertTrue(f.isEqual(fCpy,1e-12,1e-12));
2602         pass
2603
2604     def testConvertQuadraticCellsToLinear(self):
2605         mesh=MEDCouplingDataForTest.build2DTargetMesh_3();
2606         mesh.checkCoherency();
2607         types=mesh.getAllTypes();
2608         types.sort()
2609         self.assertEqual(5,len(types));
2610         expected1=[NORM_POLYGON, NORM_TRI3, NORM_QUAD4, NORM_TRI6, NORM_QUAD8]
2611         expected1.sort()
2612         self.assertEqual(expected1,types);
2613         self.assertTrue(mesh.isPresenceOfQuadratic());
2614         self.assertEqual(62,mesh.getMeshLength());
2615         f1=mesh.getMeasureField(False);
2616         #
2617         mesh.convertQuadraticCellsToLinear();
2618         self.assertTrue(not mesh.isPresenceOfQuadratic());
2619         #
2620         mesh.checkCoherency();
2621         f2=mesh.getMeasureField(False);
2622         self.assertTrue(f1.getArray().isEqual(f2.getArray(),1e-12));
2623         self.assertEqual(48,mesh.getMeshLength());
2624         types2=mesh.getAllTypes();
2625         types2.sort()
2626         self.assertEqual(3,len(types2));
2627         expected2=[NORM_POLYGON, NORM_TRI3, NORM_QUAD4]
2628         expected2.sort()
2629         self.assertEqual(expected2,types2);
2630         pass
2631
2632     def testCheckGeoEquivalWith(self):
2633         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2634         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2635         #First test mesh1
2636         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh1,0,1e-12);#deepEqual
2637         self.assertTrue(cellCor==None);
2638         self.assertTrue(nodeCor==None);
2639         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh1,1,1e-12);#fastEqual
2640         self.assertTrue(cellCor==None);
2641         self.assertTrue(nodeCor==None);
2642         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh1,10,1e-12);#deepEqual with geo permutations
2643         self.assertTrue(cellCor==None);
2644         self.assertTrue(nodeCor==None);
2645         #Second test mesh1 and mesh2 are 2 different meshes instance
2646         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,0,1e-12);#deepEqual
2647         self.assertTrue(cellCor==None);
2648         self.assertTrue(nodeCor==None);
2649         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,1,1e-12);#fastEqual
2650         self.assertTrue(cellCor==None);
2651         self.assertTrue(nodeCor==None);
2652         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);#deepEqual with geo permutations
2653         self.assertTrue(cellCor==None);
2654         self.assertTrue(nodeCor==None);
2655         #Third test : cell permutation by keeping the first the middle and the last as it is.
2656         renum=[0,2,1,3,4,5,6,8,7,9]
2657         mesh2.renumberCells(renum,False);
2658         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12);#deepEqual fails
2659         self.assertTrue(cellCor==None);
2660         self.assertTrue(nodeCor==None);
2661         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,1,1e-12);#fastEqual do not see anything
2662         self.assertTrue(cellCor==None);
2663         self.assertTrue(nodeCor==None);
2664         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);#deepEqual with geo permutations
2665         self.assertTrue(cellCor);
2666         self.assertEqual(10,cellCor.getNumberOfTuples());
2667         self.assertEqual(1,cellCor.getNumberOfComponents());
2668         self.assertEqual(renum,list(cellCor.getValues()))
2669         self.assertTrue(nodeCor==None);
2670         cellCor=0;
2671         self.assertTrue(nodeCor==None);
2672         #4th test : cell and node permutation by keeping the first the middle and the last as it is.
2673         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2674         renum2=[0,2,1,3,4,5,6,8,7,9,10]
2675         mesh2.renumberCells(renum,False);
2676         mesh2.renumberNodes(renum2,11);
2677         cellCor=None
2678         nodeCor=None
2679         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12);#deepEqual fails
2680         self.assertTrue(cellCor==None);
2681         self.assertTrue(nodeCor==None);
2682         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,1,1e-12);#fastEqual do not see anything
2683         self.assertTrue(cellCor==None);
2684         self.assertTrue(nodeCor==None);
2685         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);#deepEqual with geo permutations
2686         self.assertTrue(cellCor);
2687         self.assertEqual(10,cellCor.getNumberOfTuples());
2688         self.assertEqual(1,cellCor.getNumberOfComponents());
2689         self.assertEqual(renum,list(cellCor.getValues()))
2690         self.assertTrue(nodeCor);
2691         self.assertEqual(11,nodeCor.getNumberOfTuples());
2692         self.assertEqual(1,nodeCor.getNumberOfComponents());
2693         self.assertEqual(renum2,list(nodeCor.getValues()))
2694         cellCor=0;
2695         nodeCor=0;
2696         #5th test : modification of the last cell to check fastCheck detection.
2697         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2698         renum3=[0,2,1,3,4,5,6,8,9,7]
2699         mesh2.renumberCells(renum3,False);
2700         mesh2.renumberNodes(renum2,11);
2701         cellCor=None
2702         nodeCor=None
2703         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12)
2704         self.assertTrue(cellCor==None);
2705         self.assertTrue(nodeCor==None);
2706         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,1,1e-12)
2707         self.assertTrue(cellCor==None);
2708         self.assertTrue(nodeCor==None);
2709         cellCor,nodeCor=mesh2.checkGeoEquivalWith(mesh1,10,1e-12);#deepEqual with geo permutations
2710         self.assertTrue(cellCor!=None);
2711         self.assertEqual(10,cellCor.getNumberOfTuples());
2712         self.assertEqual(1,cellCor.getNumberOfComponents());
2713         self.assertEqual(renum3,list(cellCor.getValues()))
2714         self.assertTrue(nodeCor!=None);
2715         self.assertEqual(11,nodeCor.getNumberOfTuples());
2716         self.assertEqual(1,nodeCor.getNumberOfComponents());
2717         self.assertEqual(renum2,list(nodeCor.getValues()));
2718         pass
2719
2720     def testCheckGeoEquivalWith2(self):
2721         mesh1=MEDCouplingDataForTest.build2DTargetMesh_4();
2722         mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
2723         cellCor,nodeCor=mesh1.checkGeoEquivalWith(mesh2,10,1e-12);
2724         self.assertEqual(None,cellCor);
2725         self.assertNotEqual(None,nodeCor);
2726         expected1=[0, 1, 3, 4, 5, 6, 7, 8, 9]
2727         for i in xrange(9):
2728             self.assertEqual(expected1[i],nodeCor.getIJ(i,0));
2729             pass
2730         pass
2731
2732     def testCopyTinyStringsFromOnFields(self):
2733         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2734         nbOfCells=m.getNumberOfCells();
2735         f=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
2736         f.setMesh(m);
2737         self.assertEqual(5,f.getNumberOfMeshPlacesExpected());
2738         f.setName("a");
2739         f.setDescription("b");
2740         a1=DataArrayDouble.New();
2741         a1.alloc(nbOfCells,2);
2742         a1.fillWithZero();
2743         a1.setInfoOnComponent(0,"c");
2744         a1.setInfoOnComponent(1,"d");
2745         a2=a1.deepCpy();
2746         a2.setInfoOnComponent(0,"e");
2747         a2.setInfoOnComponent(1,"f");
2748         f.setArray(a1);
2749         f.setEndArray(a2);
2750         f.setEndTime(3.,3,4);
2751         m.setName("g");
2752         m.getCoords().setInfoOnComponent(0,"h");
2753         m.getCoords().setInfoOnComponent(1,"i");
2754         m.getCoords().setInfoOnComponent(2,"j");
2755         #
2756         f.checkCoherency();
2757         f2=f.clone(True);
2758         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2759         f2.setName("smth");
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.setDescription("GGG");
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         f2.getArray().setInfoOnComponent(0,"mmmm");
2768         self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2769         f2.copyTinyStringsFrom(f);
2770         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2771         f2.getEndArray().setInfoOnComponent(1,"mmmm");
2772         self.assertTrue(not f2.isEqual(f,1e-12,1e-12));
2773         f2.copyTinyStringsFrom(f);
2774         self.assertTrue(f2.isEqual(f,1e-12,1e-12));
2775         m2=m.clone(True);
2776         self.assertTrue(m2.isEqual(m,1e-12));
2777         m2.setName("123");
2778         self.assertTrue(not m2.isEqual(m,1e-12));
2779         m2.copyTinyStringsFrom(m);
2780         self.assertTrue(m2.isEqual(m,1e-12));
2781         m2.getCoords().setInfoOnComponent(1,"eee");
2782         self.assertTrue(not m2.isEqual(m,1e-12));
2783         m2.copyTinyStringsFrom(m);
2784         self.assertTrue(m2.isEqual(m,1e-12));
2785         pass
2786
2787     def testTryToShareSameCoordsPermute(self):
2788         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2789         m2=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2790         #self.assertTrue(m.getCoords()!=m2.getCoords());
2791         m.tryToShareSameCoordsPermute(m2,1e-12);
2792         #self.assertTrue(m.getCoords()==m2.getCoords());
2793         self.assertTrue(m2.isEqual(m,1e-12));
2794         renum1=[1,2,0,5,8,7,4,3,6]
2795         r1=DataArrayInt.New()
2796         r1.setValues(renum1,len(renum1),1)
2797         m.renumberNodes(r1,9);
2798         #self.assertTrue(m.getCoords()!=m2.getCoords());
2799         self.assertTrue(not m2.isEqual(m,1e-12));
2800         m.tryToShareSameCoordsPermute(m2,1e-12);
2801         #self.assertTrue(m.getCoords()==m2.getCoords());
2802         self.assertTrue(m2.isEqual(m,1e-12));
2803         pass
2804
2805     def testTryToShareSameCoordsPermute2(self):
2806         m1=MEDCouplingDataForTest.build2DTargetMesh_4();
2807         targetCoords=[-0.3,-0.3, 0.2,-0.3, -0.3,0.2, 0.2,0.2 ]
2808         targetConn=[0,2,3,1]
2809         m2=MEDCouplingUMesh.New();
2810         m2.setMeshDimension(2);
2811         m2.allocateCells(1);
2812         m2.insertNextCell(NORM_QUAD4,targetConn[0:4])
2813         m2.finishInsertingCells();
2814         myCoords=DataArrayDouble.New();
2815         myCoords.setValues(targetCoords,4,2);
2816         m2.setCoords(myCoords);
2817         m2.checkCoherency();
2818         m1.checkCoherency();
2819         #
2820         expected1=[0.25,0.125,0.125,0.25,0.25]
2821         f1=m1.getMeasureField(False);
2822         f2=m2.getMeasureField(False);
2823         self.assertEqual(5,f1.getArray().getNumberOfTuples());
2824         self.assertEqual(1,f2.getArray().getNumberOfTuples());
2825         for i in xrange(5):
2826             self.assertAlmostEqual(expected1[i],f1.getIJ(i,0),12);
2827             pass
2828         self.assertAlmostEqual(expected1[0],f2.getIJ(0,0),12);
2829         self.assertRaises(InterpKernelException,m1.tryToShareSameCoordsPermute,m2,1e-12);# <- here in this order the sharing is impossible.
2830         # Let's go for deeper test of tryToShareSameCoordsPermute
2831         m2.tryToShareSameCoordsPermute(m1,1e-12);
2832         f1=m1.getMeasureField(False);
2833         f2=m2.getMeasureField(False);
2834         self.assertEqual(5,f1.getArray().getNumberOfTuples());
2835         self.assertEqual(1,f2.getArray().getNumberOfTuples());
2836         for i in xrange(5):
2837             self.assertAlmostEqual(expected1[i],f1.getIJ(i,0),12);
2838             pass
2839         self.assertAlmostEqual(expected1[0],f2.getIJ(0,0),12);
2840         pass
2841
2842     def testChangeUnderlyingMesh1(self):
2843         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2844         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2845         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2846         f1.setMesh(mesh1);
2847         array=DataArrayDouble.New();
2848         arr=[7., 107., 8., 108., 9., 109., 10., 110., 11., 111., 12., 112., 13., 113., 14., 114., 15., 115., 16., 116.]
2849         array.setValues(arr,mesh1.getNumberOfCells(),2);
2850         f1.setArray(array);
2851         #
2852         renum=[0,2,1,3,4,5,6,8,7,9]
2853         mesh2.renumberCells(renum,False);
2854         #self.assertTrue(f1.getMesh()==mesh1);
2855         f1.changeUnderlyingMesh(mesh1,10,1e-12);# nothing done only to check that nothing done.
2856         #self.assertTrue(f1.getMesh()==mesh1);
2857         f1.changeUnderlyingMesh(mesh2,10,1e-12);
2858         #self.assertTrue(f1.getMesh()==mesh2);
2859         expected1=[7.,107.,9.,109.,8.,108.,10.,110.,11.,111.,12.,112.,13.,113.,15.,115.,14.,114.,16.,116.]
2860         for i in xrange(20):
2861             self.assertAlmostEqual(expected1[i],f1.getArray().getIJ(0,i),12);
2862             pass
2863         #
2864         f1=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
2865         f1.setMesh(mesh1);
2866         array=DataArrayDouble.New();
2867         arr2=[7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.,17.,117.]
2868         array.setValues(arr2,mesh1.getNumberOfNodes(),2);
2869         f1.setArray(array);
2870         #
2871         renum2=[0,2,10,3,4,5,6,8,7,9,1]
2872         mesh2.renumberNodes(renum2,11);
2873         #self.assertTrue(f1.getMesh()==mesh1);
2874         f1.changeUnderlyingMesh(mesh2,10,1e-12);
2875         #self.assertTrue(f1.getMesh()==mesh2);
2876         expected2=[7.,107.,17.,117.,8.,108.,10.,110.,11.,111.,12.,112.,13.,113.,15.,115.,14.,114.,16.,116.,9.,109.]
2877         for i in xrange(22):
2878             self.assertAlmostEqual(expected2[i],f1.getArray().getIJ(0,i),12);
2879             pass
2880         pass
2881
2882     def testGetMaxValue1(self):
2883         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
2884         nbOfCells=m.getNumberOfCells();
2885         f=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
2886         f.setMesh(m);
2887         a1=DataArrayDouble.New();
2888         val1=[3.,4.,5.,6.,7.]
2889         a1.setValues(val1,nbOfCells,1);
2890         a2=DataArrayDouble.New();
2891         val2=[0.,1.,2.,8.,7.]
2892         a2.setValues(val2,nbOfCells,1);
2893         f.setArray(a1);
2894         f.setEndArray(a2);
2895         f.setEndTime(3.,3,4);
2896         f.checkCoherency();
2897         #
2898         self.assertAlmostEqual(8.,f.getMaxValue(),14);
2899         self.assertAlmostEqual(0.,f.getMinValue(),14);
2900         self.assertAlmostEqual(5.,f.getAverageValue(),14);
2901         self.assertAlmostEqual(5.125,f.getWeightedAverageValue(),14);
2902         a1.setIJ(0,2,9.5);
2903         self.assertAlmostEqual(9.5,f.getMaxValue(),14);
2904         self.assertAlmostEqual(0.,f.getMinValue(),14);
2905         a2.setIJ(0,0,9.);
2906         self.assertAlmostEqual(9.5,f.getMaxValue(),14);
2907         self.assertAlmostEqual(1.,f.getMinValue(),14);
2908         pass
2909
2910     def testSubstractInPlaceDM1(self):
2911         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2912         mesh2=MEDCouplingDataForTest.build2DTargetMesh_3();
2913         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2914         f1.setMesh(mesh1);
2915         array=DataArrayDouble.New();
2916         arr=[7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.]
2917         array.setValues(arr,mesh1.getNumberOfCells(),2);
2918         f1.setArray(array);
2919         #
2920         self.assertEqual(10,f1.getNumberOfTuples());
2921         self.assertEqual(2,f1.getNumberOfComponents());
2922         self.assertEqual(20,f1.getNumberOfValues());
2923         #
2924         renum=[0,2,3,1,4,5,6,8,7,9]
2925         mesh2.renumberCells(renum,False);
2926         #
2927         f2=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
2928         f2.setMesh(mesh2);
2929         array=DataArrayDouble.New();
2930         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]
2931         array.setValues(arr2,mesh2.getNumberOfCells(),2);
2932         f2.setArray(array);
2933         #
2934         f1.substractInPlaceDM(f2,10,1e-12);
2935         f1.applyFunc(1,"abs(x+y+0.2)");
2936         self.assertAlmostEqual(0.,f1.getMaxValue(),13);
2937         pass
2938
2939     def testDotCrossProduct1(self):
2940         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2941         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
2942         f1.setTime(2.3,5,6);
2943         f1.setMesh(mesh1);
2944         array=DataArrayDouble.New();
2945         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.]
2946         array.setValues(arr1,mesh1.getNumberOfCells(),3);
2947         f1.setArray(array);
2948         f2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
2949         f2.setTime(7.8,4,5);
2950         f2.setMesh(mesh1);
2951         array=DataArrayDouble.New();
2952         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.]
2953         array.setValues(arr2,mesh1.getNumberOfCells(),3);
2954         f2.setArray(array);
2955         #
2956         f3=f1.dot(f2);
2957         expected1=[842.,1820.,2816.,3830.,4862.,5912.,6980.,8066.,9170.,10292.]
2958         for i in xrange(10):
2959             self.assertAlmostEqual(expected1[i],f3.getIJ(i,0),9);
2960             pass
2961         #
2962         f4=f1.crossProduct(f2);
2963         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.]
2964         for i in xrange(30):
2965             self.assertAlmostEqual(expected2[i],f4.getIJ(0,i),9);
2966             pass
2967         pass
2968
2969     def testMinMaxFields1(self):
2970         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
2971         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
2972         f1.setTime(2.3,5,6);
2973         f1.setMesh(mesh1);
2974         array=DataArrayDouble.New();
2975         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.]
2976         array.setValues(arr1,mesh1.getNumberOfCells(),3);
2977         f1.setArray(array);
2978         f2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
2979         f2.setTime(7.8,4,5);
2980         f2.setMesh(mesh1);
2981         array=DataArrayDouble.New();
2982         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.]
2983         array.setValues(arr2,mesh1.getNumberOfCells(),3);
2984         f2.setArray(array);
2985         #
2986         f3=f1.max(f2);
2987         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.]
2988         for i in xrange(30):
2989             self.assertAlmostEqual(expected1[i],f3.getIJ(0,i),9);
2990             pass
2991         #
2992         f4=f1.min(f2);
2993         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.]
2994         for i in xrange(30):
2995             self.assertAlmostEqual(expected2[i],f4.getIJ(0,i),9);
2996             pass
2997         #
2998         pass
2999
3000     def testApplyLin1(self):
3001         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
3002         f1=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
3003         f1.setMesh(mesh1);
3004         array=DataArrayDouble.New();
3005         arr=[7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.]
3006         array.setValues(arr,mesh1.getNumberOfCells(),2);
3007         f1.setArray(array);
3008         #
3009         f1.applyLin(2.,3.,0);
3010         expected1=[17.,107.,19.,108.,21.,109.,23.,110.,25.,111.,27.,112.,29.,113.,31.,114.,33.,115.,35.,116.]
3011         for i in xrange(20):
3012             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),9);
3013             pass
3014         #
3015         arr2=[2.,102.,3.,103.,4.,104.,5.,105.,6.,106.,7.,107.,8.,108.,9.,109.,10.,110.,11.,111.]
3016         array=DataArrayDouble.New();
3017         array.setValues(arr2,mesh1.getNumberOfCells(),2);
3018         f1.setEndArray(array);
3019         #
3020         f1.applyLin(4.,5.,1);
3021         #
3022         expected2=[17.,433.,19.,437.,21.,441.,23.,445.,25.,449.,27.,453.,29.,457.,31.,461.,33.,465.,35.,469.]
3023         for i in xrange(20):
3024             self.assertAlmostEqual(expected2[i],f1.getIJ(0,i),9);
3025             pass
3026         expected3=[2.,413.,3.,417.,4.,421.,5.,425.,6.,429.,7.,433.,8.,437.,9.,441.,10.,445.,11.,449.]
3027         for i in xrange(20):
3028             self.assertAlmostEqual(expected3[i],f1.getEndArray().getIJ(0,i),9);
3029             pass
3030         #
3031         pass
3032
3033     def testGetIdsInRange1(self):
3034         mesh1=MEDCouplingDataForTest.build2DTargetMesh_3();
3035         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3036         f1.setTime(2.3,5,6);
3037         f1.setMesh(mesh1);
3038         array=DataArrayDouble.New();
3039         arr1=[2.,8.,6.,5.,11.,7.,9.,3.,10.,4.]
3040         array.setValues(arr1,mesh1.getNumberOfCells(),1);
3041         f1.setArray(array);
3042         #
3043         f1.checkCoherency();
3044         da=f1.getIdsInRange(2.9,7.1);
3045         self.failUnlessEqual(5,da.getNbOfElems());
3046         expected1=[2,3,5,7,9]
3047         self.failUnlessEqual(expected1,list(da.getValues()));
3048         da=f1.getIdsInRange(8.,12.);
3049         self.failUnlessEqual(4,da.getNbOfElems());
3050         expected2=[1,4,6,8]
3051         self.failUnlessEqual(expected2,list(da.getValues()));
3052         #
3053         pass
3054
3055     def testBuildSubPart1(self):
3056         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3057         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3058         f1.setTime(2.3,5,6);
3059         f1.setMesh(mesh1);
3060         array=DataArrayDouble.New();
3061         arr1=[3.,103.,4.,104.,5.,105.,6.,106.,7.,107.]
3062         array.setValues(arr1,mesh1.getNumberOfCells(),2);
3063         f1.setArray(array);
3064         #
3065         part1=[2,1,4]
3066         f2=f1[part1];
3067         f2.zipCoords()
3068         self.failUnlessEqual(3,f2.getNumberOfTuples());
3069         self.failUnlessEqual(2,f2.getNumberOfComponents());
3070         expected1=[5.,105.,4.,104.,7.,107.]
3071         for i in xrange(6):
3072             self.assertAlmostEqual(f2.getIJ(0,i),expected1[i],12);
3073             pass
3074         self.failUnlessEqual(3,f2.getMesh().getNumberOfCells());
3075         self.failUnlessEqual(6,f2.getMesh().getNumberOfNodes());
3076         self.failUnlessEqual(2,f2.getMesh().getSpaceDimension());
3077         self.failUnlessEqual(2,f2.getMesh().getMeshDimension());
3078         m2C=f2.getMesh();
3079         self.failUnlessEqual(13,m2C.getMeshLength());
3080         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]
3081         for i in xrange(12):
3082             self.assertAlmostEqual(expected2[i],m2C.getCoords().getIJ(0,i),12);
3083             pass
3084         expected3=[3,2,3,1,3,0,2,1,4,4,5,3,2]
3085         self.failUnlessEqual(expected3,list(m2C.getNodalConnectivity().getValues()));
3086         expected4=[0,4,8,13]
3087         self.failUnlessEqual(expected4,list(m2C.getNodalConnectivityIndex().getValues()));
3088         # Test with field on nodes.
3089         f1=MEDCouplingFieldDouble.New(ON_NODES,ONE_TIME);
3090         f1.setTime(2.3,5,6);
3091         f1.setMesh(mesh1);
3092         array=DataArrayDouble.New();
3093         arr2=[3.,103.,4.,104.,5.,105.,6.,106.,7.,107.,8.,108.,9.,109.,10.,110.,11.,111.]
3094         array.setValues(arr2,mesh1.getNumberOfNodes(),2);
3095         f1.setArray(array);
3096         part2=[1,2]
3097         f2=f1.buildSubPart(part2);
3098         self.failUnlessEqual(4,f2.getNumberOfTuples());
3099         self.failUnlessEqual(2,f2.getNumberOfComponents());
3100         expected5=[4.,104.,5.,105.,7.,107.,8.,108.]
3101         for i in xrange(8):
3102             self.assertAlmostEqual(f2.getIJ(0,i),expected5[i],12);
3103             pass
3104         self.failUnlessEqual(2,f2.getMesh().getNumberOfCells());
3105         self.failUnlessEqual(4,f2.getMesh().getNumberOfNodes());
3106         self.failUnlessEqual(2,f2.getMesh().getSpaceDimension());
3107         self.failUnlessEqual(2,f2.getMesh().getMeshDimension());
3108         m2C=f2.getMesh();
3109         self.failUnlessEqual(8,m2C.getMeshLength());
3110         for i in xrange(8):#8 is not an error
3111             self.assertAlmostEqual(expected2[i],m2C.getCoords().getIJ(0,i),12);
3112             pass
3113         self.failUnlessEqual(expected3[:4],list(m2C.getNodalConnectivity().getValues())[4:]);
3114         self.failUnlessEqual(expected3[4:8],list(m2C.getNodalConnectivity().getValues())[:4]);
3115         self.failUnlessEqual(expected4[:3],list(m2C.getNodalConnectivityIndex().getValues()));
3116         #idem previous because nodes of cell#4 are not fully present in part3
3117         part3=[1,2]
3118         arrr=DataArrayInt.New();
3119         arrr.setValues(part3,2,1);
3120         f2=f1.buildSubPart(arrr);
3121         self.failUnlessEqual(4,f2.getNumberOfTuples());
3122         self.failUnlessEqual(2,f2.getNumberOfComponents());
3123         for i in xrange(8):
3124             self.assertAlmostEqual(f2.getIJ(0,i),expected5[i],12);
3125             pass
3126         self.failUnlessEqual(2,f2.getMesh().getNumberOfCells());
3127         self.failUnlessEqual(4,f2.getMesh().getNumberOfNodes());
3128         self.failUnlessEqual(2,f2.getMesh().getSpaceDimension());
3129         self.failUnlessEqual(2,f2.getMesh().getMeshDimension());
3130         m2C=f2.getMesh();
3131         self.failUnlessEqual(8,m2C.getMeshLength());
3132         for i in xrange(8):#8 is not an error
3133             self.assertAlmostEqual(expected2[i],m2C.getCoords().getIJ(0,i),12);
3134             pass
3135         self.failUnlessEqual(expected3[:4],list(m2C.getNodalConnectivity().getValues())[4:8]);
3136         self.failUnlessEqual(expected3[4:8],list(m2C.getNodalConnectivity().getValues())[:4]);
3137         self.failUnlessEqual(expected4[:3],list(m2C.getNodalConnectivityIndex().getValues()));
3138         #
3139         part4=[1,2,4]
3140         f2=f1.buildSubPart(part4);
3141         self.failUnlessEqual(6,f2.getNumberOfTuples());
3142         self.failUnlessEqual(2,f2.getNumberOfComponents());
3143         expected6=[4.,104.,5.,105.,7.,107.,8.,108.,10.,110.,11.,111.]
3144         for i in xrange(12):
3145             self.assertAlmostEqual(f2.getIJ(0,i),expected6[i],12);
3146             pass
3147         self.failUnlessEqual(3,f2.getMesh().getNumberOfCells());
3148         self.failUnlessEqual(6,f2.getMesh().getNumberOfNodes());
3149         self.failUnlessEqual(2,f2.getMesh().getSpaceDimension());
3150         self.failUnlessEqual(2,f2.getMesh().getMeshDimension());
3151         m2C=f2.getMesh();
3152         self.failUnlessEqual(13,m2C.getMeshLength());
3153         for i in xrange(12):
3154             self.assertAlmostEqual(expected2[i],m2C.getCoords().getIJ(0,i),12);
3155             pass
3156         self.failUnlessEqual(expected3[0:4],list(m2C.getNodalConnectivity().getValues())[4:8]);
3157         self.failUnlessEqual(expected3[4:8],list(m2C.getNodalConnectivity().getValues())[0:4]);
3158         self.failUnlessEqual(expected3[8:13],list(m2C.getNodalConnectivity().getValues())[8:13]);
3159         self.failUnlessEqual(expected4,list(m2C.getNodalConnectivityIndex().getValues()));
3160         pass
3161
3162     def testDoublyContractedProduct1(self):
3163         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3164         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3165         f1.setMesh(mesh1);
3166         array=DataArrayDouble.New();
3167         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]
3168         array.setValues(arr1,mesh1.getNumberOfCells(),6);
3169         f1.setArray(array);
3170         f1.checkCoherency();
3171         #
3172         f2=f1.doublyContractedProduct();
3173         f2.checkCoherency();
3174         self.assertEqual(1,f2.getNumberOfComponents());
3175         self.assertEqual(5,f2.getNumberOfTuples());
3176         for i in xrange(5):
3177             self.assertAlmostEqual(3906.56,f2.getIJ(i,0),9);
3178             pass
3179         #
3180         pass
3181
3182     def testDeterminant1(self):
3183         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3184         f1=MEDCouplingFieldDouble.New(ON_CELLS,CONST_ON_TIME_INTERVAL);
3185         f1.setTime(2.3,5,6);
3186         f1.setEndTime(3.8,7,3);
3187         f1.setMesh(mesh1);
3188         array=DataArrayDouble.New();
3189         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]
3190         array.setValues(arr1,mesh1.getNumberOfCells(),4);
3191         f1.setArray(array);
3192         #4 components
3193         f1.checkCoherency();
3194         f2=f1.determinant();
3195         f2.checkCoherency();
3196         self.assertEqual(CONST_ON_TIME_INTERVAL,f2.getTimeDiscretization());
3197         self.assertEqual(1,f2.getNumberOfComponents());
3198         self.assertEqual(5,f2.getNumberOfValues());
3199         for i in xrange(5):
3200             self.assertAlmostEqual(-2.42,f2.getIJ(i,0),13);
3201             pass
3202         #6 components multi arrays with end array not defined
3203         f1=MEDCouplingFieldDouble.New(ON_NODES,LINEAR_TIME);
3204         f1.setTime(2.3,5,6);
3205         f1.setEndTime(3.8,7,3);
3206         f1.setMesh(mesh1);
3207         array=DataArrayDouble.New();
3208         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,
3209               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]
3210         array.setValues(arr2,mesh1.getNumberOfNodes(),6);
3211         f1.setArray(array);
3212         self.assertRaises(InterpKernelException,f1.checkCoherency);#no end array specified !
3213         #
3214         f2=f1.determinant();
3215         self.assertEqual(LINEAR_TIME,f2.getTimeDiscretization());
3216         self.assertEqual(1,f2.getArray().getNumberOfComponents());
3217         self.assertEqual(9,f2.getNumberOfTuples());
3218         for i in xrange(9):
3219             self.assertAlmostEqual(137.335,f2.getIJ(i,0),10);
3220             pass
3221         #6 components multi arrays with end array defined
3222         array=DataArrayDouble.New();
3223         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,
3224               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]
3225         array.setValues(arr3,mesh1.getNumberOfNodes(),6);
3226         f1.setEndArray(array);
3227         f1.checkCoherency();
3228         f2=f1.determinant();
3229         f2.checkCoherency();
3230         self.assertEqual(LINEAR_TIME,f2.getTimeDiscretization());
3231         self.assertEqual(1,f2.getNumberOfComponents());
3232         self.assertEqual(9,f2.getNumberOfTuples());
3233         time2,it,order=f2.getTime()
3234         self.assertAlmostEqual(2.3,time2,12);
3235         self.assertEqual(5,it);
3236         self.assertEqual(6,order);
3237         time2,it,order=f2.getEndTime()
3238         self.assertAlmostEqual(3.8,time2,12);
3239         self.assertEqual(7,it);
3240         self.assertEqual(3,order);
3241         for i in xrange(9):
3242             self.assertAlmostEqual(137.335,f2.getIJ(i,0),10);
3243             self.assertAlmostEqual(1289.685,f2.getEndArray().getIJ(i,0),9);
3244             pass
3245         #9 components
3246         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3247         f1.setTime(7.8,10,2);
3248         f1.setMesh(mesh1);
3249         array=DataArrayDouble.New();
3250         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]
3251         array.setValues(arr4,mesh1.getNumberOfCells(),9);
3252         f1.setArray(array);
3253         #
3254         f1.checkCoherency();
3255         f2=f1.determinant();
3256         f2.checkCoherency();
3257         self.assertEqual(ONE_TIME,f2.getTimeDiscretization());
3258         self.assertEqual(1,f2.getNumberOfComponents());
3259         self.assertEqual(5,f2.getNumberOfTuples());
3260         time2,it,order=f2.getTime()
3261         self.assertAlmostEqual(7.8,time2,12);
3262         self.assertEqual(10,it);
3263         self.assertEqual(2,order);
3264         for i in xrange(5):
3265             self.assertAlmostEqual(3.267,f2.getIJ(i,0),13);
3266             pass
3267         pass
3268
3269     def testEigenValues1(self):
3270         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3271         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3272         f1.setMesh(mesh1);
3273         array=DataArrayDouble.New();
3274         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]
3275         array.setValues(arr1,mesh1.getNumberOfCells(),6);
3276         f1.setArray(array);
3277         f1.checkCoherency();
3278         #
3279         f2=f1.eigenValues();
3280         f2.checkCoherency();
3281         self.assertEqual(3,f2.getNumberOfComponents());
3282         self.assertEqual(5,f2.getNumberOfTuples());
3283         expected1=[13.638813677891717,-4.502313844635971,-2.2364998332557486]
3284         for i in xrange(5):
3285             self.assertAlmostEqual(expected1[0],f2.getIJ(i,0),13);
3286             self.assertAlmostEqual(expected1[1],f2.getIJ(i,1),13);
3287             self.assertAlmostEqual(expected1[2],f2.getIJ(i,2),13);
3288             pass
3289         pass
3290
3291     def testEigenVectors1(self):
3292         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3293         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3294         f1.setMesh(mesh1);
3295         array=DataArrayDouble.New();
3296         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]
3297         array.setValues(arr1,mesh1.getNumberOfCells(),6);
3298         f1.setArray(array);
3299         f1.checkCoherency();
3300         #
3301         f2=f1.eigenVectors();
3302         f2.checkCoherency();
3303         self.assertEqual(9,f2.getNumberOfComponents());
3304         self.assertEqual(5,f2.getNumberOfTuples());
3305         expected1=[0.5424262364180696, 0.5351201064614425, 0.6476266283176001,#eigenvect 0
3306                    0.7381111277307373, 0.06458838384003074, -0.6715804522117897,#eigenvect 1
3307                    -0.4012053603397987, 0.8423032781211455, -0.3599436712889738#eigenvect 2
3308                    ]
3309         for i in xrange(5):
3310             self.assertAlmostEqual(expected1[0],f2.getIJ(i,0),13);
3311             self.assertAlmostEqual(expected1[1],f2.getIJ(i,1),13);
3312             self.assertAlmostEqual(expected1[2],f2.getIJ(i,2),13);
3313             self.assertAlmostEqual(expected1[3],f2.getIJ(i,3),13);
3314             self.assertAlmostEqual(expected1[4],f2.getIJ(i,4),13);
3315             self.assertAlmostEqual(expected1[5],f2.getIJ(i,5),13);
3316             self.assertAlmostEqual(expected1[6],f2.getIJ(i,6),13);
3317             self.assertAlmostEqual(expected1[7],f2.getIJ(i,7),13);
3318             self.assertAlmostEqual(expected1[8],f2.getIJ(i,8),13);
3319             pass
3320         #
3321         pass
3322
3323     def testInverse1(self):
3324         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3325         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3326         f1.setMesh(mesh1);
3327         array=DataArrayDouble.New();
3328         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]
3329         array.setValues(arr1,mesh1.getNumberOfCells(),9);
3330         f1.setArray(array);
3331         f1.checkCoherency();
3332         #
3333         f2=f1.inverse();
3334         f2.checkCoherency();
3335         self.assertEqual(9,f2.getNumberOfComponents());
3336         self.assertEqual(5,f2.getNumberOfTuples());
3337         expected1=[-2.6538108356290113, 2.855831037649208, -1.1111111111111067, 3.461891643709813, -4.775022956841121, 2.2222222222222143, -1.1111111111111054, 2.222222222222214, -1.1111111111111072]
3338         for i in xrange(5):
3339             self.assertAlmostEqual(expected1[0],f2.getIJ(i,0),13);
3340             self.assertAlmostEqual(expected1[1],f2.getIJ(i,1),13);
3341             self.assertAlmostEqual(expected1[2],f2.getIJ(i,2),13);
3342             self.assertAlmostEqual(expected1[3],f2.getIJ(i,3),13);
3343             self.assertAlmostEqual(expected1[4],f2.getIJ(i,4),13);
3344             self.assertAlmostEqual(expected1[5],f2.getIJ(i,5),13);
3345             self.assertAlmostEqual(expected1[6],f2.getIJ(i,6),13);
3346             self.assertAlmostEqual(expected1[7],f2.getIJ(i,7),13);
3347             self.assertAlmostEqual(expected1[8],f2.getIJ(i,8),13);
3348             pass
3349         #
3350         array=DataArrayDouble.New();
3351         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]
3352         array.setValues(arr3,mesh1.getNumberOfCells(),6);
3353         f1.setArray(array);
3354         f1.checkCoherency();
3355         #
3356         f2=f1.inverse();
3357         f2.checkCoherency();
3358         self.assertEqual(6,f2.getNumberOfComponents());
3359         self.assertEqual(5,f2.getNumberOfTuples());
3360         expected3=[-0.3617705098531818, -0.8678630828458127, -0.026843764174972983, 0.5539957431465833, 0.13133439560823013, -0.05301294502145887]
3361         for i in xrange(5):
3362             self.assertAlmostEqual(expected3[0],f2.getIJ(i,0),13);
3363             self.assertAlmostEqual(expected3[1],f2.getIJ(i,1),13);
3364             self.assertAlmostEqual(expected3[2],f2.getIJ(i,2),13);
3365             self.assertAlmostEqual(expected3[3],f2.getIJ(i,3),13);
3366             self.assertAlmostEqual(expected3[4],f2.getIJ(i,4),13);
3367             self.assertAlmostEqual(expected3[5],f2.getIJ(i,5),13);
3368             pass
3369         #
3370         array=DataArrayDouble.New();
3371         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]
3372         array.setValues(arr2,mesh1.getNumberOfCells(),4);
3373         f1.setArray(array);
3374         f1.checkCoherency();
3375         #
3376         f2=f1.inverse();
3377         f2.checkCoherency();
3378         self.assertEqual(4,f2.getNumberOfComponents());
3379         self.assertEqual(5,f2.getNumberOfTuples());
3380         expected2=[-1.8595041322314059, 0.9504132231404963, 1.404958677685951, -0.49586776859504156]
3381         for i in xrange(5):
3382             self.assertAlmostEqual(expected2[0],f2.getIJ(i,0),13);
3383             self.assertAlmostEqual(expected2[1],f2.getIJ(i,1),13);
3384             self.assertAlmostEqual(expected2[2],f2.getIJ(i,2),13);
3385             self.assertAlmostEqual(expected2[3],f2.getIJ(i,3),13);
3386             pass
3387         #
3388         pass
3389
3390     def testTrace1(self):
3391         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3392         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3393         f1.setMesh(mesh1);
3394         array=DataArrayDouble.New();
3395         arr1=[1.2,2.3,3.4,4.5,5.6,6.7,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]
3396         array.setValues(arr1,mesh1.getNumberOfCells(),9);
3397         f1.setArray(array);
3398         f1.checkCoherency();
3399         #
3400         f2=f1.trace();
3401         f2.checkCoherency();
3402         self.assertEqual(1,f2.getNumberOfComponents());
3403         self.assertEqual(5,f2.getNumberOfTuples());
3404         for i in xrange(5):
3405             self.assertAlmostEqual(15.9,f2.getIJ(i,0),13);
3406             pass
3407         #
3408         array=DataArrayDouble.New();
3409         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]
3410         array.setValues(arr3,mesh1.getNumberOfCells(),6);
3411         f1.setArray(array);
3412         f1.checkCoherency();
3413         #
3414         f2=f1.trace();
3415         f2.checkCoherency();
3416         self.assertEqual(1,f2.getNumberOfComponents());
3417         self.assertEqual(5,f2.getNumberOfTuples());
3418         for i in xrange(5):
3419             self.assertAlmostEqual(25.8,f2.getIJ(i,0),13);
3420             pass
3421         #
3422         array=DataArrayDouble.New();
3423         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]
3424         array.setValues(arr2,mesh1.getNumberOfCells(),4);
3425         f1.setArray(array);
3426         f1.checkCoherency();
3427         #
3428         f2=f1.trace();
3429         f2.checkCoherency();
3430         self.assertEqual(1,f2.getNumberOfComponents());
3431         self.assertEqual(5,f2.getNumberOfTuples());
3432         for i in xrange(5):
3433             self.assertAlmostEqual(5.7,f2.getIJ(i,0),13);
3434             pass
3435         #
3436         pass
3437
3438     def testDeviator1(self):
3439         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3440         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3441         f1.setMesh(mesh1);
3442         array=DataArrayDouble.New();
3443         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]
3444         array.setValues(arr1,mesh1.getNumberOfCells(),6);
3445         f1.setArray(array);
3446         f1.checkCoherency();
3447         #
3448         f2=f1.deviator();
3449         f2.checkCoherency();
3450         self.assertEqual(6,f2.getNumberOfComponents());
3451         self.assertEqual(5,f2.getNumberOfTuples());
3452         expected1=[-1.1,0.,1.1,4.5,5.6,6.7]
3453         for i in xrange(5):
3454             self.assertAlmostEqual(expected1[0],f2.getIJ(i,0),13);
3455             self.assertAlmostEqual(expected1[1],f2.getIJ(i,1),13);
3456             self.assertAlmostEqual(expected1[2],f2.getIJ(i,2),13);
3457             self.assertAlmostEqual(expected1[3],f2.getIJ(i,3),13);
3458             self.assertAlmostEqual(expected1[4],f2.getIJ(i,4),13);
3459             self.assertAlmostEqual(expected1[5],f2.getIJ(i,5),13);
3460             pass
3461         #
3462         pass
3463
3464     def testMagnitude1(self):
3465         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3466         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3467         f1.setMesh(mesh1);
3468         array=DataArrayDouble.New();
3469         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]
3470         array.setValues(arr1,mesh1.getNumberOfCells(),5);
3471         f1.setArray(array);
3472         f1.checkCoherency();
3473         #
3474         f2=f1.magnitude();
3475         f2.checkCoherency();
3476         self.assertEqual(1,f2.getNumberOfComponents());
3477         self.assertEqual(5,f2.getNumberOfTuples());
3478         for i in xrange(5):
3479             self.assertAlmostEqual(8.3606219864313918,f2.getIJ(i,0),13);
3480             pass
3481         #
3482         pass
3483
3484     def testMaxPerTuple1(self):
3485         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3486         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3487         f1.setMesh(mesh1);
3488         array=DataArrayDouble.New();
3489         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]
3490         array.setValues(arr1,mesh1.getNumberOfCells(),5);
3491         f1.setArray(array);
3492         f1.checkCoherency();
3493         #
3494         f2=f1.maxPerTuple();
3495         f2.checkCoherency();
3496         self.assertEqual(1,f2.getNumberOfComponents());
3497         self.assertEqual(5,f2.getNumberOfTuples());
3498         for i in xrange(5):
3499             self.assertAlmostEqual(5.6,f2.getIJ(i,0),13);
3500             pass
3501         #
3502         pass
3503
3504     def testChangeNbOfComponents(self):
3505         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3506         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3507         f1.setMesh(mesh1);
3508         array=DataArrayDouble.New();
3509         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]
3510         array.setValues(arr1,mesh1.getNumberOfCells(),5);
3511         f1.setArray(array);
3512         f1.checkCoherency();
3513         #
3514         f1.changeNbOfComponents(3,7.77);
3515         f1.checkCoherency();
3516         self.assertEqual(3,f1.getNumberOfComponents());
3517         self.assertEqual(5,f1.getNumberOfTuples());
3518         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]
3519         for i in xrange(15):
3520             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),13);
3521             pass
3522         f1.changeNbOfComponents(4,7.77);
3523         f1.checkCoherency();
3524         self.assertEqual(4,f1.getNumberOfComponents());
3525         self.assertEqual(5,f1.getNumberOfTuples());
3526         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]
3527         for i in xrange(20):
3528             self.assertAlmostEqual(expected2[i],f1.getIJ(0,i),13);
3529             pass
3530         #
3531         pass
3532
3533     def testSortPerTuple1(self):
3534         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3535         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
3536         f1.setMesh(mesh1);
3537         array=DataArrayDouble.New();
3538         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]
3539         array.setValues(arr1,mesh1.getNumberOfCells(),5);
3540         f1.setArray(array);
3541         f1.checkCoherency();
3542         #
3543         f1.sortPerTuple(True);
3544         f1.checkCoherency();
3545         self.assertEqual(5,f1.getNumberOfComponents());
3546         self.assertEqual(5,f1.getNumberOfTuples());
3547         for i in xrange(5):
3548             self.assertAlmostEqual(arr1[0],f1.getIJ(i,0),13);
3549             self.assertAlmostEqual(arr1[1],f1.getIJ(i,1),13);
3550             self.assertAlmostEqual(arr1[2],f1.getIJ(i,2),13);
3551             self.assertAlmostEqual(arr1[3],f1.getIJ(i,3),13);
3552             self.assertAlmostEqual(arr1[4],f1.getIJ(i,4),13);
3553             pass
3554         #
3555         f1.sortPerTuple(False);
3556         f1.checkCoherency();
3557         self.assertEqual(5,f1.getNumberOfComponents());
3558         self.assertEqual(5,f1.getNumberOfTuples());
3559         for i in xrange(5):
3560             self.assertAlmostEqual(arr1[4],f1.getIJ(i,0),13);
3561             self.assertAlmostEqual(arr1[3],f1.getIJ(i,1),13);
3562             self.assertAlmostEqual(arr1[2],f1.getIJ(i,2),13);
3563             self.assertAlmostEqual(arr1[1],f1.getIJ(i,3),13);
3564             self.assertAlmostEqual(arr1[0],f1.getIJ(i,4),13);
3565             pass
3566         #
3567         pass
3568
3569     def testIsEqualWithoutConsideringStr1(self):
3570         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3571         mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
3572         #
3573         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3574         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3575         mesh2.setName("rr");
3576         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
3577         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3578         da1,da2=mesh1.checkGeoEquivalWith(mesh2,2,1e-12);
3579         self.assertRaises(InterpKernelException,mesh1.checkGeoEquivalWith,mesh2,0,1e-12);
3580         mesh2.setName("");
3581         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3582         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3583         mesh2.getCoords().setInfoOnComponent(0,"tty");
3584         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
3585         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3586         mesh2.getCoords().setInfoOnComponent(0,"");
3587         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3588         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3589         mesh2.getCoords().setInfoOnComponent(1,"tty");
3590         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
3591         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3592         mesh2.getCoords().setInfoOnComponent(1,"");
3593         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3594         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3595         tmp=mesh2.getCoords().getIJ(0,3);
3596         mesh2.getCoords().setIJ(0,3,9999.);
3597         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
3598         self.assertTrue(not mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3599         mesh2.getCoords().setIJ(0,3,tmp);
3600         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3601         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3602         tmp2=mesh2.getNodalConnectivity().getIJ(0,4);
3603         mesh2.getNodalConnectivity().setIJ(0,4,0);
3604         self.assertTrue(not mesh1.isEqual(mesh2,1e-12));
3605         self.assertTrue(not mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3606         mesh2.getNodalConnectivity().setIJ(0,4,tmp2);
3607         self.assertTrue(mesh1.isEqual(mesh2,1e-12));
3608         self.assertTrue(mesh1.isEqualWithoutConsideringStr(mesh2,1e-12));
3609         #
3610         f1=mesh1.getMeasureField(True);
3611         f2=mesh2.getMeasureField(True);
3612         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
3613         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3614         f2.setName("ftest");
3615         self.assertTrue(not f1.isEqual(f2,1e-12,1e-12));
3616         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3617         f1.setName("ftest");
3618         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
3619         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3620         #
3621         f2.getArray().setInfoOnComponent(0,"eee");
3622         self.assertTrue(not f1.isEqual(f2,1e-12,1e-12));
3623         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3624         f2.getArray().setInfoOnComponent(0,"");
3625         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
3626         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3627         #
3628         f2.getArray().setIJ(1,0,0.123);
3629         self.assertTrue(not f1.isEqual(f2,1e-12,1e-12));
3630         self.assertTrue(not f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3631         f2.getArray().setIJ(1,0,0.125);
3632         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
3633         self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,1e-12));
3634         #
3635         pass
3636
3637     def testGetNodeIdsOfCell1(self):
3638         mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
3639         li=mesh1.getNodeIdsOfCell(1)
3640         expected1=[1, 4, 2]
3641         self.assertEqual(expected1,list(li))
3642         li=mesh1.getCoordinatesOfNode(4)
3643         self.assertEqual(2,len(li))
3644         self.assertAlmostEqual(0.2,li[0],13);
3645         self.assertAlmostEqual(0.2,li[1],13);
3646         li=mesh1.getCoords().getValuesAsTuple()
3647         self.assertEqual(9,len(li))
3648         li2=mesh1.getNodalConnectivityIndex().getValuesAsTuple()
3649         self.assertEqual(6,len(li2))
3650         pass
3651
3652     def testGetEdgeRatioField1(self):
3653         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
3654         m1.setTime(3.4,5,6); m1.setTimeUnit("us");
3655         f1=m1.getEdgeRatioField();
3656         self.assertAlmostEqual(3.4,f1.getTime()[0],12) ; self.assertEqual(5,f1.getTime()[1]) ; self.assertEqual(6,f1.getTime()[2])
3657         self.assertEqual("us",f1.getTimeUnit())
3658         self.assertEqual(m1.getNumberOfCells(),f1.getNumberOfTuples());
3659         self.assertEqual(5,f1.getNumberOfTuples());
3660         self.assertEqual(1,f1.getNumberOfComponents());
3661         expected1=[1.,1.4142135623730951, 1.4142135623730951,1.,1.]
3662         for i in xrange(5):
3663             self.assertAlmostEqual(expected1[i],f1.getIJ(i,0),14);
3664             pass
3665         #
3666         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
3667         f1=m1.getEdgeRatioField();
3668         self.assertEqual(m1.getNumberOfCells(),f1.getNumberOfTuples());
3669         self.assertEqual(5,f1.getNumberOfTuples());
3670         self.assertEqual(1,f1.getNumberOfComponents());
3671         expected2=[1.4142135623730951, 1.7320508075688772, 1.7320508075688772, 1.4142135623730951, 1.4142135623730951]
3672         for i in xrange(5):
3673             self.assertAlmostEqual(expected2[i],f1.getIJ(i,0),14);
3674             pass
3675         pass
3676
3677     def testFillFromAnalytic3(self):
3678         m=MEDCouplingDataForTest.build2DTargetMesh_1()
3679         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME)
3680         self.assertRaises(InterpKernelException,f1.fillFromAnalytic,1,"y+x");
3681         f1.setMesh(m)
3682         f1.setName("myField");
3683         f1.fillFromAnalytic(1,"y+x");
3684         f1.checkCoherency();
3685         self.assertEqual(f1.getName(),"myField");
3686         self.assertEqual(f1.getTypeOfField(),ON_CELLS);
3687         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
3688         self.assertEqual(1,f1.getNumberOfComponents());
3689         self.assertEqual(5,f1.getNumberOfTuples());
3690         values1=[-0.1,0.23333333333333336,0.56666666666666665,0.4,0.9]
3691         tmp=f1.getArray().getValues();
3692         self.assertEqual(len(values1),len(tmp))
3693         for i in xrange(len(values1)):
3694             self.assertTrue(abs(values1[i]-tmp[i])<1.e-12);
3695             pass
3696         #
3697         f1=MEDCouplingFieldDouble.New(ON_NODES,CONST_ON_TIME_INTERVAL)
3698         f1.setMesh(m)
3699         f1.fillFromAnalytic(1,"y+2*x");
3700         f1.setEndTime(1.2,3,4);
3701         f1.checkCoherency();
3702         self.assertEqual(f1.getTypeOfField(),ON_NODES);
3703         self.assertEqual(f1.getTimeDiscretization(),CONST_ON_TIME_INTERVAL);
3704         self.assertEqual(1,f1.getNumberOfComponents());
3705         self.assertEqual(9,f1.getNumberOfTuples());
3706         values2=[-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1]
3707         tmp=f1.getArray().getValues();
3708         self.assertEqual(len(values2),len(tmp))
3709         for i in xrange(len(values2)):
3710             self.assertTrue(abs(values2[i]-tmp[i])<1.e-12);
3711             pass
3712         f1=MEDCouplingFieldDouble.New(ON_NODES,LINEAR_TIME);
3713         f1.setMesh(m)
3714         f1.fillFromAnalytic(1,"2.*x+y");
3715         f1.setEndTime(1.2,3,4);
3716         f1.checkCoherency();
3717         self.assertEqual(f1.getTypeOfField(),ON_NODES);
3718         self.assertEqual(f1.getTimeDiscretization(),LINEAR_TIME);
3719         self.assertEqual(1,f1.getNumberOfComponents());
3720         self.assertEqual(9,f1.getNumberOfTuples());
3721         tmp=f1.getArray().getValues();
3722         values2Bis=[-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1]
3723         self.assertEqual(len(values2Bis),len(tmp))
3724         for i in xrange(len(values2Bis)):
3725             self.assertTrue(abs(values2Bis[i]-tmp[i])<1.e-12);
3726             pass
3727         tmp=f1.getEndArray().getValues();
3728         self.assertEqual(len(values2Bis),len(tmp))
3729         for i in xrange(len(values2Bis)):
3730             self.assertTrue(abs(values2Bis[i]-tmp[i])<1.e-12);
3731             pass
3732         #
3733         f1=MEDCouplingFieldDouble.New(ON_NODES,ONE_TIME);
3734         f1.setMesh(m)
3735         f1.fillFromAnalytic(2,"(x+y)*IVec+2*(x+y)*JVec");
3736         f1.checkCoherency();
3737         self.assertEqual(f1.getTypeOfField(),ON_NODES);
3738         self.assertEqual(f1.getTimeDiscretization(),ONE_TIME);
3739         self.assertEqual(2,f1.getNumberOfComponents());
3740         self.assertEqual(9,f1.getNumberOfTuples());
3741         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]
3742         tmp=f1.getArray().getValues();
3743         self.assertEqual(len(values3),len(tmp))
3744         for i in xrange(len(values3)):
3745             self.assertTrue(abs(values3[i]-tmp[i])<1.e-12);
3746             pass
3747         values4=f1.accumulate();
3748         self.assertTrue(abs(3.6-values4[0])<1.e-12);
3749         self.assertTrue(abs(7.2-values4[1])<1.e-12);
3750         values4=f1.integral(True);
3751         self.assertTrue(abs(0.5-values4[0])<1.e-12);
3752         self.assertTrue(abs(1.-values4[1])<1.e-12);
3753         #
3754         f1=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
3755         f1.setMesh(m);
3756         self.assertRaises(InterpKernelException,f1.fillFromAnalytic,1,"1./(x-0.2)");
3757         pass
3758
3759     def testFieldDoubleOpEqual1(self):
3760         m=MEDCouplingDataForTest.build2DTargetMesh_1();
3761         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
3762         self.assertRaises(InterpKernelException,f1.assign,0.07);
3763         f1.setMesh(m);
3764         f1.assign(0.07);
3765         f1.checkCoherency();
3766         self.assertEqual(1,f1.getNumberOfComponents());
3767         self.assertEqual(5,f1.getNumberOfTuples());
3768         for i in xrange(5):
3769             self.assertAlmostEqual(0.07,f1.getIJ(i,0),16);
3770             pass
3771         f1.assign(0.09);
3772         f1.checkCoherency();
3773         self.assertEqual(1,f1.getNumberOfComponents());
3774         self.assertEqual(5,f1.getNumberOfTuples());
3775         for i in xrange(5):
3776             self.assertAlmostEqual(0.09,f1.getIJ(i,0),16);
3777             pass
3778         #
3779         f1=MEDCouplingFieldDouble.New(ON_NODES,LINEAR_TIME);
3780         f1.setEndTime(4.5,2,3);
3781         f1.setMesh(m);
3782         f1.assign(0.08);
3783         f1.checkCoherency();
3784         self.assertEqual(1,f1.getNumberOfComponents());
3785         self.assertEqual(9,f1.getNumberOfTuples());
3786         for i in xrange(9):
3787             self.assertAlmostEqual(0.08,f1.getIJ(i,0),16);
3788             pass
3789         self.assertEqual(1,f1.getEndArray().getNumberOfComponents());
3790         self.assertEqual(9,f1.getEndArray().getNumberOfTuples());
3791         for i in xrange(9):
3792             self.assertAlmostEqual(0.08,f1.getEndArray().getIJ(i,0),16);
3793             pass
3794         pass
3795
3796     def testAreaBary3D2(self):
3797         coordsForHexa8=[-75.45749305371, 180.95495078401, 39.515472018008,
3798                         -9.755591679144, 23.394927935279, 5.108794294848,
3799                         14.337630157832, 61.705351002702, 160.42422501908,
3800                         -27.273893776752, 167.567731083961, 192.830034145464,
3801                         99.857193154796,264.499264735586,-8.287335493412,
3802                         144.939882761126,156.38626563134,-31.896173894226,
3803                         161.34096835726,182.4654895809,73.832387065572,
3804                         132.680430393685,255.37973247196,96.15235602819];
3805         volHexa8=3258520.29637466;
3806         baryHexa8=[43.925705821778, 155.31893955289, 65.874418109644]
3807
3808         coordsForPenta6=[-68.199829618726,178.938498373416,62.608505919588,
3809                          8.461744647847,76.653979804423,165.00018874933,
3810                          -27.273893776752,167.567731083961,192.830034145464,
3811                          106.586501038965,262.629609408327,13.124533008813,
3812                          155.465082847275,197.414118382622,78.408350795821,
3813                          132.680430393685,255.37973247196,96.15235602819];
3814         volPenta6=944849.868507338;
3815         baryPenta6=[39.631002313543,182.692711783428,106.98540473964]
3816
3817         coordsForPyra5=[132.680430393685,255.37973247196,96.15235602819,
3818                         -27.273893776752,167.567731083961,192.830034145464,
3819                         8.461744647847,76.653979804423,165.00018874933,
3820                         155.465082847275,197.414118382622,78.408350795821,
3821                         -68.199829618726,178.938498373416,62.608505919588];
3822         volPyra5=756943.92980254;
3823         baryPyra5=[29.204294116618,172.540129749156,118.01035951483]
3824         mesh=MEDCouplingUMesh.New("Bary3D2",3);
3825         coo=DataArrayDouble.New();
3826         tmp=coordsForHexa8+coordsForPenta6+coordsForPyra5
3827         coo.setValues(tmp,19,3);
3828         mesh.setCoords(coo);
3829         #
3830         tmpConn=[0,1,2,3,4,5,6,7]
3831         mesh.allocateCells(3);
3832         self.assertRaises(InterpKernelException,mesh.insertNextCell,NORM_HEXA8,9,tmpConn[0:8])
3833         mesh.insertNextCell(NORM_HEXA8,tmpConn[0:8])
3834         mesh.insertNextCell(NORM_PENTA6,6,[i+8 for i in tmpConn])
3835         mesh.insertNextCell(NORM_PYRA5,5,[i+14 for i in tmpConn])
3836         mesh.finishInsertingCells();
3837         mesh.checkCoherency();
3838         mesh.mergeNodes(1e-7)
3839         self.assertEqual(12,mesh.getNumberOfNodes());
3840         vols=mesh.getMeasureField(True);
3841         self.assertEqual(3,vols.getNumberOfTuples());
3842         self.assertEqual(1,vols.getNumberOfComponents());
3843         self.assertAlmostEqual(volHexa8,vols.getIJ(0,0),6);
3844         self.assertAlmostEqual(volPenta6,vols.getIJ(1,0),7);
3845         self.assertAlmostEqual(volPyra5,vols.getIJ(2,0),7);
3846         bary=mesh.getBarycenterAndOwner();
3847         self.assertEqual(3,bary.getNumberOfTuples());
3848         self.assertEqual(3,bary.getNumberOfComponents());
3849         self.assertAlmostEqual(baryHexa8[0],bary.getIJ(0,0),11);
3850         self.assertAlmostEqual(baryHexa8[1],bary.getIJ(0,1),11);
3851         self.assertAlmostEqual(baryHexa8[2],bary.getIJ(0,2),11);
3852         self.assertAlmostEqual(baryPenta6[0],bary.getIJ(1,0),11);
3853         self.assertAlmostEqual(baryPenta6[1],bary.getIJ(1,1),11);
3854         self.assertAlmostEqual(baryPenta6[2],bary.getIJ(1,2),11);
3855         self.assertAlmostEqual(baryPyra5[0],bary.getIJ(2,0),11);
3856         self.assertAlmostEqual(baryPyra5[1],bary.getIJ(2,1),11);
3857         self.assertAlmostEqual(baryPyra5[2],bary.getIJ(2,2),11);
3858         pass
3859
3860     def testGetMeasureFieldCMesh1(self):
3861         m=MEDCouplingCMesh.New();
3862         da=DataArrayDouble.New();
3863         discX=[2.3,3.4,5.8,10.2]
3864         discY=[12.3,23.4,45.8]
3865         discZ=[-0.7,1.2,1.25,2.13,2.67]
3866         da.setValues(discX,4,1);
3867         m.setCoordsAt(0,da);
3868         m.checkCoherency();
3869         self.assertEqual(4,m.getNumberOfNodes());
3870         self.assertEqual(3,m.getNumberOfCells());
3871         self.assertEqual(1,m.getSpaceDimension());
3872         f=m.getMeasureField(True);
3873         self.assertEqual(3,f.getNumberOfTuples());
3874         self.assertEqual(1,f.getNumberOfComponents());
3875         expected1=[1.1,2.4,4.4]
3876         for i in xrange(3):
3877             self.assertAlmostEqual(expected1[i],f.getIJ(i,0),12);
3878             pass
3879         coords=m.getCoordinatesAndOwner();
3880         self.assertEqual(4,coords.getNumberOfTuples());
3881         self.assertEqual(1,coords.getNumberOfComponents());
3882         for i in xrange(4):
3883             self.assertAlmostEqual(discX[i],coords.getIJ(i,0),12);
3884             pass
3885         coords=m.getBarycenterAndOwner();
3886         self.assertEqual(3,coords.getNumberOfTuples());
3887         self.assertEqual(1,coords.getNumberOfComponents());
3888         expected1_3=[2.85,4.6,8.]
3889         for i in xrange(3):
3890             self.assertAlmostEqual(expected1_3[i],coords.getIJ(i,0),12);
3891             pass
3892         #
3893         da=DataArrayDouble.New();
3894         da.setValues(discY,3,1);
3895         m.setCoordsAt(1,da);
3896         m.checkCoherency();
3897         self.assertEqual(12,m.getNumberOfNodes());
3898         self.assertEqual(6,m.getNumberOfCells());
3899         self.assertEqual(2,m.getSpaceDimension());
3900         f=m.getMeasureField(True);
3901         self.assertEqual(6,f.getNumberOfTuples());
3902         self.assertEqual(1,f.getNumberOfComponents());
3903         expected2=[12.21,26.64,48.84,24.64,53.76,98.56]
3904         for i in xrange(6):
3905             self.assertAlmostEqual(expected2[i],f.getIJ(i,0),12);
3906             pass
3907         coords=m.getCoordinatesAndOwner();
3908         self.assertEqual(12,coords.getNumberOfTuples());
3909         self.assertEqual(2,coords.getNumberOfComponents());
3910         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]
3911         for i in xrange(24):
3912             self.assertAlmostEqual(expected2_2[i],coords.getIJ(0,i),12);
3913             pass
3914         coords=m.getBarycenterAndOwner();
3915         self.assertEqual(6,coords.getNumberOfTuples());
3916         self.assertEqual(2,coords.getNumberOfComponents());
3917         expected2_3=[2.85,17.85,4.6,17.85,8.,17.85, 2.85,34.6,4.6,34.6,8.,34.6]
3918         for i in xrange(12):
3919             self.assertAlmostEqual(expected2_3[i],coords.getIJ(0,i),12);
3920             pass
3921         #
3922         da=DataArrayDouble.New();
3923         da.setValues(discZ,5,1);
3924         m.setCoordsAt(2,da);
3925         m.checkCoherency();
3926         self.assertEqual(60,m.getNumberOfNodes());
3927         self.assertEqual(24,m.getNumberOfCells());
3928         self.assertEqual(3,m.getSpaceDimension());
3929         f=m.getMeasureField(True);
3930         self.assertEqual(24,f.getNumberOfTuples());
3931         self.assertEqual(1,f.getNumberOfComponents());
3932         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]
3933         for i in xrange(24):
3934             self.assertAlmostEqual(expected3[i],f.getIJ(i,0),12);
3935             pass
3936         coords=m.getCoordinatesAndOwner();
3937         self.assertEqual(60,coords.getNumberOfTuples());
3938         self.assertEqual(3,coords.getNumberOfComponents());
3939         expected3_2=[
3940             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,
3941             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,
3942             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,
3943             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,
3944             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];
3945         for i in xrange(180):
3946             self.assertAlmostEqual(expected3_2[i],coords.getIJ(0,i),12);
3947             pass
3948         coords=m.getBarycenterAndOwner();
3949         self.assertEqual(24,coords.getNumberOfTuples());
3950         self.assertEqual(3,coords.getNumberOfComponents());
3951         expected3_3=[
3952             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,
3953             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,
3954             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,
3955             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];
3956         for i in xrange(72):
3957             self.assertAlmostEqual(expected3_3[i],coords.getIJ(0,i),12);
3958             pass
3959         pass
3960
3961     def testFieldDoubleZipCoords1(self):
3962         m=MEDCouplingDataForTest.build2DTargetMeshMergeNode_1();
3963         f=m.fillFromAnalytic(ON_NODES,2,"x*2.");
3964         f.getArray().setInfoOnComponent(0,"titi");
3965         f.getArray().setInfoOnComponent(1,"tutu");
3966         f.checkCoherency();
3967         self.assertEqual(18,f.getNumberOfTuples());
3968         self.assertEqual(2,f.getNumberOfComponents());
3969         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]
3970         for i in xrange(36):
3971             self.assertAlmostEqual(expected1[i],f.getIJ(0,i),12);
3972             pass
3973         self.assertTrue(f.zipCoords());
3974         f.checkCoherency();
3975         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]
3976         for i in xrange(30):
3977             self.assertAlmostEqual(expected2[i],f.getIJ(0,i),12);
3978             pass
3979         self.assertTrue(not f.zipCoords());
3980         f.checkCoherency();
3981         for i in xrange(30):
3982             self.assertAlmostEqual(expected2[i],f.getIJ(0,i),12);
3983             pass
3984         self.assertTrue(f.getArray().getInfoOnComponent(0)=="titi");
3985         self.assertTrue(f.getArray().getInfoOnComponent(1)=="tutu");
3986         pass
3987
3988     def testFieldDoubleZipConnectivity1(self):
3989         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
3990         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
3991         cells1=[2,3,4]
3992         m3_1=m2.buildPartOfMySelf(cells1,True);
3993         m3=m3_1;
3994         m4=MEDCouplingDataForTest.build2DSourceMesh_1();
3995         m5=MEDCouplingUMesh.MergeUMeshes(m1,m3);
3996         m6=MEDCouplingUMesh.MergeUMeshes(m5,m4);
3997         #
3998         self.assertEqual(10,m6.getNumberOfCells());
3999         self.assertEqual(22,m6.getNumberOfNodes());
4000         arr,areNodesMerged,newNbOfNodes=m6.mergeNodes(1e-13);
4001         self.assertEqual(9,m6.getNumberOfNodes());
4002         f=m6.fillFromAnalytic(ON_CELLS,2,"x");
4003         f2=m6.fillFromAnalytic(ON_NODES,2,"x");
4004         self.assertEqual(10,f.getNumberOfTuples());
4005         self.assertEqual(2,f.getNumberOfComponents());
4006         expected1=[-0.05, -0.05, 0.3666666666666667, 0.3666666666666667, 0.53333333333333321, 0.53333333333333321,
4007                    -0.05, -0.05, 0.45, 0.45, 0.53333333333333321, 0.53333333333333321, -0.05, -0.05, 0.45, 0.45,
4008                    0.36666666666666659, 0.36666666666666659, 0.033333333333333326, 0.033333333333333326];
4009         for i in xrange(20):
4010             self.assertAlmostEqual(expected1[i],f.getIJ(0,i),12);
4011             pass
4012         f.getArray().setInfoOnComponent(0,"titi");
4013         f.getArray().setInfoOnComponent(1,"tutu");
4014         f.checkCoherency();
4015         self.assertTrue(f.zipConnectivity(0));
4016         expected2=[-0.05, -0.05, 0.3666666666666667, 0.3666666666666667, 0.53333333333333321, 0.53333333333333321,
4017                    -0.05, -0.05, 0.45, 0.45, 0.36666666666666659, 0.36666666666666659, 0.033333333333333326, 0.033333333333333326];
4018         self.assertEqual(7,f.getNumberOfTuples());
4019         self.assertEqual(2,f.getNumberOfComponents());
4020         for i in xrange(14):
4021             self.assertAlmostEqual(expected2[i],f.getIJ(0,i),12);
4022             pass
4023         self.assertTrue(f.getArray().getInfoOnComponent(0)=="titi");
4024         self.assertTrue(f.getArray().getInfoOnComponent(1)=="tutu");
4025         self.assertTrue(not f.zipConnectivity(0));
4026         #
4027         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,
4028                    -0.3, -0.3, 0.2, 0.2, 0.7, 0.7];
4029         self.assertEqual(9,f2.getNumberOfTuples());
4030         self.assertEqual(2,f2.getNumberOfComponents());
4031         for i in xrange(18):
4032             self.assertAlmostEqual(expected3[i],f2.getIJ(0,i),12);
4033             pass
4034         self.assertTrue(f2.zipConnectivity(0));
4035         self.assertEqual(9,f2.getNumberOfTuples());
4036         self.assertEqual(2,f2.getNumberOfComponents());
4037         for i in xrange(18):
4038             self.assertAlmostEqual(expected3[i],f2.getIJ(0,i),12);
4039             pass
4040         pass
4041
4042     def testDaDoubleRenumber1(self):
4043         a=DataArrayDouble.New();
4044         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]
4045         a.setValues(arr1,7,2);
4046         a.setInfoOnComponent(0,"toto");
4047         a.setInfoOnComponent(1,"tata");
4048         #
4049         arr2=[3,1,0,6,5,4,2]
4050         b=a.renumber(arr2);
4051         self.assertEqual(7,b.getNumberOfTuples());
4052         self.assertEqual(2,b.getNumberOfComponents());
4053         self.assertTrue(b.getInfoOnComponent(0)=="toto");
4054         self.assertTrue(b.getInfoOnComponent(1)=="tata");
4055         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]
4056         for i in xrange(14):
4057             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
4058             pass
4059         #
4060         c=DataArrayInt.New();
4061         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4062         c.setValues(arr3,7,2);
4063         c.setInfoOnComponent(0,"toto");
4064         c.setInfoOnComponent(1,"tata");
4065         d=c.renumber(arr2);
4066         self.assertEqual(7,d.getNumberOfTuples());
4067         self.assertEqual(2,d.getNumberOfComponents());
4068         self.assertTrue(d.getInfoOnComponent(0)=="toto");
4069         self.assertTrue(d.getInfoOnComponent(1)=="tata");
4070         expected2=[3, 13, 2, 12, 7, 17, 1, 11, 6, 16, 5, 15, 4, 14]
4071         for i in xrange(14):
4072             self.assertEqual(expected2[i],d.getIJ(0,i));
4073             pass
4074         pass
4075
4076     def testDaDoubleRenumberAndReduce1(self):
4077         a=DataArrayDouble.New();
4078         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]
4079         a.setValues(arr1,7,2);
4080         a.setInfoOnComponent(0,"toto");
4081         a.setInfoOnComponent(1,"tata");
4082         #
4083         arr2=[2,-1,1,-1,0,4,3]
4084         b=a.renumberAndReduce(arr2,5);
4085         self.assertEqual(5,b.getNumberOfTuples());
4086         self.assertEqual(2,b.getNumberOfComponents());
4087         self.assertTrue(b.getInfoOnComponent(0)=="toto");
4088         self.assertTrue(b.getInfoOnComponent(1)=="tata");
4089         expected1=[5.1,15.1,3.1,13.1,1.1,11.1,7.1,17.1,6.1,16.1]
4090         for i in xrange(10):
4091             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
4092             pass
4093         #
4094         c=DataArrayInt.New();
4095         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4096         c.setValues(arr3,7,2);
4097         c.setInfoOnComponent(0,"toto");
4098         c.setInfoOnComponent(1,"tata");
4099         d=c.renumberAndReduce(arr2,5);
4100         self.assertEqual(5,d.getNumberOfTuples());
4101         self.assertEqual(2,d.getNumberOfComponents());
4102         self.assertTrue(d.getInfoOnComponent(0)=="toto");
4103         self.assertTrue(d.getInfoOnComponent(1)=="tata");
4104         expected2=[5,15,3,13,1,11,7,17,6,16]
4105         for i in xrange(10):
4106             self.assertEqual(expected2[i],d.getIJ(0,i));
4107             pass
4108         pass
4109
4110     def testDaDoubleRenumberInPlace1(self):
4111         a=DataArrayDouble.New();
4112         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]
4113         a.setValues(arr1,7,2);
4114         #
4115         arr2=[3,1,0,6,5,4,2]
4116         a.renumberInPlace(arr2);
4117         self.assertEqual(7,a.getNumberOfTuples());
4118         self.assertEqual(2,a.getNumberOfComponents());
4119         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]
4120         for i in xrange(14):
4121             self.assertAlmostEqual(expected1[i],a.getIJ(0,i),14);
4122             pass
4123         #
4124         c=DataArrayInt.New();
4125         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4126         c.setValues(arr3,7,2);
4127         c.renumberInPlace(arr2);
4128         self.assertEqual(7,c.getNumberOfTuples());
4129         self.assertEqual(2,c.getNumberOfComponents());
4130         expected2=[3, 13, 2, 12, 7, 17, 1, 11, 6, 16, 5, 15, 4, 14]
4131         for i in xrange(14):
4132             self.assertEqual(expected2[i],c.getIJ(0,i));
4133             pass
4134         pass
4135
4136     def testDaDoubleRenumberR1(self):
4137         a=DataArrayDouble.New();
4138         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]
4139         a.setValues(arr1,7,2);
4140         a.setInfoOnComponent(0,"toto");
4141         a.setInfoOnComponent(1,"tata");
4142         #
4143         arr2=[3,1,0,6,5,4,2]
4144         b=a.renumberR(arr2);
4145         self.assertEqual(7,b.getNumberOfTuples());
4146         self.assertEqual(2,b.getNumberOfComponents());
4147         self.assertTrue(b.getInfoOnComponent(0)=="toto");
4148         self.assertTrue(b.getInfoOnComponent(1)=="tata");
4149         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]
4150         for i in xrange(14):
4151             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
4152             pass
4153         #
4154         c=DataArrayInt.New();
4155         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4156         c.setValues(arr3,7,2);
4157         c.setInfoOnComponent(0,"toto");
4158         c.setInfoOnComponent(1,"tata");
4159         d=c.renumberR(arr2);
4160         self.assertEqual(7,d.getNumberOfTuples());
4161         self.assertEqual(2,d.getNumberOfComponents());
4162         self.assertTrue(d.getInfoOnComponent(0)=="toto");
4163         self.assertTrue(d.getInfoOnComponent(1)=="tata");
4164         expected2=[4, 14, 2, 12, 1, 11, 7, 17, 6, 16, 5, 15, 3, 13]
4165         for i in xrange(14):
4166             self.assertEqual(expected2[i],d.getIJ(0,i));
4167             pass
4168         pass
4169
4170     def testDaDoubleRenumberInPlaceR1(self):
4171         a=DataArrayDouble.New();
4172         arr1=[1.1,11.1,2.1,12.1,3.1,13.1,4.1,14.1,5.1,15.1,6.1,16.1,7.1,17.1]
4173         a.setValues(arr1,7,2);
4174         #
4175         arr2=[3,1,0,6,5,4,2]
4176         a.renumberInPlaceR(arr2);
4177         self.assertEqual(7,a.getNumberOfTuples());
4178         self.assertEqual(2,a.getNumberOfComponents());
4179         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]
4180         for i in xrange(14):
4181             self.assertAlmostEqual(expected1[i],a.getIJ(0,i),14);
4182             pass
4183         #
4184         c=DataArrayInt.New();
4185         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4186         c.setValues(arr3,7,2);
4187         c.renumberInPlaceR(arr2);
4188         self.assertEqual(7,c.getNumberOfTuples());
4189         self.assertEqual(2,c.getNumberOfComponents());
4190         expected2=[4, 14, 2, 12, 1, 11, 7, 17, 6, 16, 5, 15, 3, 13]
4191         for i in xrange(14):
4192             self.assertEqual(expected2[i],c.getIJ(0,i));
4193             pass
4194         pass
4195
4196     def testDaDoubleSelectByTupleId1(self):
4197         a=DataArrayDouble.New();
4198         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]
4199         a.setValues(arr1,7,2);
4200         a.setInfoOnComponent(0,"toto");
4201         a.setInfoOnComponent(1,"tata");
4202         #
4203         arr2=[4,2,0,6,5]
4204         b=a.selectByTupleId(arr2);
4205         self.assertEqual(5,b.getNumberOfTuples());
4206         self.assertEqual(2,b.getNumberOfComponents());
4207         self.assertTrue(b.getInfoOnComponent(0)=="toto");
4208         self.assertTrue(b.getInfoOnComponent(1)=="tata");
4209         expected1=[5.1,15.1,3.1,13.1,1.1,11.1,7.1,17.1,6.1,16.1]
4210         for i in xrange(10):
4211             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
4212             pass
4213         #
4214         c=DataArrayInt.New();
4215         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
4216         c.setValues(arr3,7,2);
4217         c.setInfoOnComponent(0,"toto");
4218         c.setInfoOnComponent(1,"tata");
4219         d=c.selectByTupleId(arr2);
4220         self.assertEqual(5,d.getNumberOfTuples());
4221         self.assertEqual(2,d.getNumberOfComponents());
4222         self.assertTrue(d.getInfoOnComponent(0)=="toto");
4223         self.assertTrue(d.getInfoOnComponent(1)=="tata");
4224         expected2=[5,15,3,13,1,11,7,17,6,16]
4225         for i in xrange(10):
4226             self.assertEqual(expected2[i],d.getIJ(0,i));
4227             pass
4228         pass
4229
4230     def testDaDoubleGetMinMaxValues1(self):
4231         a=DataArrayDouble.New();
4232         arr1=[2.34,4.56,-6.77,4.55,4.56,2.24,2.34,1.02,4.56]
4233         a.setValues(arr1,9,1);
4234         m,where=a.getMaxValue();
4235         self.assertEqual(1,where);
4236         self.assertAlmostEqual(4.56,m,12);
4237         m,ws=a.getMaxValue2();
4238         self.assertAlmostEqual(4.56,m,12);
4239         self.assertEqual(3,ws.getNumberOfTuples());
4240         self.assertEqual(1,ws.getNumberOfComponents());
4241         expected1=[1,4,8]
4242         for i in xrange(3):
4243             self.assertEqual(expected1[i],ws.getIJ(i,0));
4244             pass
4245         a=DataArrayDouble.New();
4246         arr2=[-2.34,-4.56,6.77,-4.55,-4.56,-2.24,-2.34,-1.02,-4.56]
4247         a.setValues(arr2,9,1);
4248         m,where=a.getMinValue();
4249         self.assertEqual(1,where);
4250         self.assertAlmostEqual(-4.56,m,12);
4251         m,ws=a.getMinValue2();
4252         self.assertAlmostEqual(-4.56,m,12);
4253         self.assertEqual(3,ws.getNumberOfTuples());
4254         self.assertEqual(1,ws.getNumberOfComponents());
4255         for i in xrange(3):
4256             self.assertEqual(expected1[i],ws.getIJ(i,0));
4257             pass
4258         pass
4259
4260     def testFieldDoubleGetMinMaxValues2(self):
4261         m2,m1=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
4262         self.assertEqual(18,m2.getNumberOfCells());
4263         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]
4264         f=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
4265         a=DataArrayDouble.New();
4266         a.setValues(arr1,18,1);
4267         f.setArray(a);
4268         f.setMesh(m2);
4269         #
4270         f.checkCoherency();
4271         m=f.getMaxValue();
4272         self.assertAlmostEqual(8.71,m,12);
4273         m,ws=f.getMaxValue2();
4274         self.assertAlmostEqual(8.71,m,12);
4275         self.assertEqual(4,ws.getNumberOfTuples());
4276         self.assertEqual(1,ws.getNumberOfComponents());
4277         expected1=[0,3,7,17]
4278         for i in xrange(4):
4279             self.assertEqual(expected1[i],ws.getIJ(i,0));
4280             pass
4281         #
4282         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]
4283         a.setValues(arr2,18,1);
4284         f.checkCoherency();
4285         m=f.getMinValue();
4286         self.assertAlmostEqual(-8.71,m,12);
4287         m,ws=f.getMinValue2();
4288         self.assertAlmostEqual(-8.71,m,12);
4289         self.assertEqual(4,ws.getNumberOfTuples());
4290         self.assertEqual(1,ws.getNumberOfComponents());
4291         for i in xrange(4):
4292             self.assertEqual(expected1[i],ws.getIJ(i,0));
4293             pass
4294         pass
4295
4296     def testBuildUnstructuredCMesh1(self):
4297         m=MEDCouplingCMesh.New();
4298         da=DataArrayDouble.New();
4299         discX=[2.3,3.4,5.8,10.2]
4300         discY=[12.3,23.4,45.8]
4301         discZ=[-0.7,1.2,1.25,2.13,2.67]
4302         da.setValues(discX,4,1);
4303         m.setCoordsAt(0,da);
4304         m.checkCoherency();
4305         self.assertEqual(0,m.getCellContainingPoint([2.4],1e-12));
4306         self.assertEqual(1,m.getCellContainingPoint([3.7],1e-12));
4307         self.assertEqual(2,m.getCellContainingPoint([5.9],1e-12));
4308         self.assertEqual(-1,m.getCellContainingPoint([10.3],1e-12));
4309         self.assertEqual(-1,m.getCellContainingPoint([1.3],1e-12));
4310         #
4311         m2=m.buildUnstructured();
4312         m2.checkCoherency();
4313         f1=m.getMeasureField(False);
4314         f2=m2.getMeasureField(False);
4315         self.assertTrue(isinstance(f1.getMesh(),MEDCouplingCMesh))
4316         self.assertEqual(f1.getNumberOfTuples(),3);
4317         self.assertEqual(f2.getNumberOfTuples(),3);
4318         self.assertEqual(1,m2.getMeshDimension());
4319         self.assertEqual(1,m2.getSpaceDimension());
4320         for i in xrange(3):
4321             self.assertAlmostEqual(f1.getIJ(i,0),f2.getIJ(i,0),10);
4322             pass
4323         da=DataArrayDouble.New();
4324         da.setValues(discY,3,1);
4325         m.setCoordsAt(1,da);
4326         #
4327         m2=m.buildUnstructured();
4328         m2.checkCoherency();
4329         f1=m.getMeasureField(False);
4330         f2=m2.getMeasureField(False);
4331         self.assertEqual(f1.getNumberOfTuples(),6);
4332         self.assertEqual(f2.getNumberOfTuples(),6);
4333         self.assertEqual(2,m2.getMeshDimension());
4334         self.assertEqual(2,m2.getSpaceDimension());
4335         for i in xrange(6):
4336             self.assertAlmostEqual(f1.getIJ(i,0),f2.getIJ(i,0),10);
4337             pass
4338         #
4339         da=DataArrayDouble.New();
4340         da.setValues(discZ,5,1);
4341         m.setCoordsAt(2,da);
4342         m2=m.buildUnstructured();
4343         m2.checkCoherency();
4344         f1=m.getMeasureField(False);
4345         f2=m2.getMeasureField(False);
4346         self.assertEqual(f1.getNumberOfTuples(),24);
4347         self.assertEqual(f2.getNumberOfTuples(),24);
4348         self.assertEqual(3,m2.getMeshDimension());
4349         self.assertEqual(3,m2.getSpaceDimension());
4350         for i in xrange(24):
4351             self.assertAlmostEqual(f1.getIJ(i,0),f2.getIJ(i,0),10);
4352             pass
4353         #
4354         pos1=[5.,30.,2.]
4355         self.assertEqual(16,m.getCellContainingPoint(pos1,1e-12));
4356         #
4357         elems=m2.getCellsInBoundingBox([3.5,6.,12.2,25.,0.,1.5],1e-7)
4358         self.assertEqual([1, 2, 4, 5, 7, 8, 10, 11, 13, 14, 16, 17],elems.getValues())
4359         #
4360         pt=[2.4,12.7,-3.4]
4361         m.scale(pt,3.7);
4362         m3=m.buildUnstructured();
4363         m2.scale(pt,3.7);
4364         self.assertTrue(m3.isEqual(m2,1e-12));
4365         pass
4366
4367     def testDataArrayIntInvertO2NNO21(self):
4368         arr1=[2,0,4,1,5,3]
4369         da=DataArrayInt.New();
4370         da.setValues(arr1,6,1);
4371         da2=da.invertArrayO2N2N2O(6);
4372         self.assertEqual(6,da2.getNumberOfTuples());
4373         self.assertEqual(1,da2.getNumberOfComponents());
4374         expected1=[1,3,0,5,2,4]
4375         for i in xrange(6):
4376             self.assertEqual(expected1[i],da2.getIJ(i,0));
4377             pass
4378         da3=da2.invertArrayN2O2O2N(6);
4379         for i in xrange(6):
4380             self.assertEqual(arr1[i],da3.getIJ(i,0));
4381             pass
4382         #
4383         arr2=[3,-1,5,4,-1,0,-1,1,2,-1]
4384         da=DataArrayInt.New();
4385         da.setValues(arr2,10,1);
4386         da2=da.invertArrayO2N2N2O(6);
4387         self.assertEqual(6,da2.getNumberOfTuples());
4388         self.assertEqual(1,da2.getNumberOfComponents());
4389         expected2=[5,7,8,0,3,2]
4390         for i in xrange(6):
4391             self.assertEqual(expected2[i],da2.getIJ(i,0));
4392             pass
4393         da3=da2.invertArrayN2O2O2N(10);
4394         for i in xrange(10):
4395             self.assertEqual(arr2[i],da3.getIJ(i,0));
4396             pass
4397         pass
4398
4399     def testKeepSetSelectedComponent1(self):
4400         arr1=[1.,2.,3.,4., 11.,12.,13.,14., 21.,22.,23.,24., 31.,32.,33.,34., 41.,42.,43.,44.]
4401         a1=DataArrayDouble.New();
4402         a1.setValues(arr1,5,4);
4403         expp=[21.,22.,23.,24.]
4404         self.assertEqual(4,len(a1.getTuple(2)));
4405         for i in xrange(4):
4406             self.assertAlmostEqual(expp[i],a1.getTuple(2)[i],12)
4407             pass
4408         a1.setInfoOnComponent(0,"aaaa");
4409         a1.setInfoOnComponent(1,"bbbb");
4410         a1.setInfoOnComponent(2,"cccc");
4411         a1.setInfoOnComponent(3,"dddd");
4412         arr2V=[1,2,1,2,0,0]
4413         a2=a1.keepSelectedComponents(arr2V);
4414         self.assertEqual(6,a2.getNumberOfComponents());
4415         self.assertEqual(5,a2.getNumberOfTuples());
4416         self.assertTrue(a2.getInfoOnComponent(0)=="bbbb");
4417         self.assertTrue(a2.getInfoOnComponent(1)=="cccc");
4418         self.assertTrue(a2.getInfoOnComponent(2)=="bbbb");
4419         self.assertTrue(a2.getInfoOnComponent(3)=="cccc");
4420         self.assertTrue(a2.getInfoOnComponent(4)=="aaaa");
4421         self.assertTrue(a2.getInfoOnComponent(5)=="aaaa");
4422         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.]
4423         for i in xrange(30):
4424             self.assertAlmostEqual(expected1[i],a2.getIJ(0,i),14);
4425             pass
4426         a3=a1.convertToIntArr();
4427         self.assertEqual([21,22,23,24],a3.getTuple(2))
4428         a4=a3.keepSelectedComponents(arr2V);
4429         self.assertEqual(6,a4.getNumberOfComponents());
4430         self.assertEqual(5,a4.getNumberOfTuples());
4431         self.assertTrue(a4.getInfoOnComponent(0)=="bbbb");
4432         self.assertTrue(a4.getInfoOnComponent(1)=="cccc");
4433         self.assertTrue(a4.getInfoOnComponent(2)=="bbbb");
4434         self.assertTrue(a4.getInfoOnComponent(3)=="cccc");
4435         self.assertTrue(a4.getInfoOnComponent(4)=="aaaa");
4436         self.assertTrue(a4.getInfoOnComponent(5)=="aaaa");
4437         for i in xrange(30):
4438             self.assertEqual(int(expected1[i]),a4.getIJ(0,i));
4439             pass
4440         # setSelectedComponents
4441         arr3V=[3,2]
4442         a5=a1.keepSelectedComponents(arr3V);
4443         a5.setInfoOnComponent(0,"eeee");
4444         a5.setInfoOnComponent(1,"ffff");
4445         arr4V=[1,2]
4446         a2.setSelectedComponents(a5,arr4V);
4447         self.assertEqual(6,a2.getNumberOfComponents());
4448         self.assertEqual(5,a2.getNumberOfTuples());
4449         self.assertTrue(a2.getInfoOnComponent(0)=="bbbb");
4450         self.assertTrue(a2.getInfoOnComponent(1)=="eeee");
4451         self.assertTrue(a2.getInfoOnComponent(2)=="ffff");
4452         self.assertTrue(a2.getInfoOnComponent(3)=="cccc");
4453         self.assertTrue(a2.getInfoOnComponent(4)=="aaaa");
4454         self.assertTrue(a2.getInfoOnComponent(5)=="aaaa");
4455         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.]
4456         for i in xrange(30):
4457             self.assertAlmostEqual(expected2[i],a2.getIJ(0,i),14);
4458             pass
4459         a6=a5.convertToIntArr();
4460         a6.setInfoOnComponent(0,"eeee");
4461         a6.setInfoOnComponent(1,"ffff");
4462         a4.setSelectedComponents(a6,arr4V);
4463         self.assertEqual(6,a4.getNumberOfComponents());
4464         self.assertEqual(5,a4.getNumberOfTuples());
4465         self.assertTrue(a4.getInfoOnComponent(0)=="bbbb");
4466         self.assertTrue(a4.getInfoOnComponent(1)=="eeee");
4467         self.assertTrue(a4.getInfoOnComponent(2)=="ffff");
4468         self.assertTrue(a4.getInfoOnComponent(3)=="cccc");
4469         self.assertTrue(a4.getInfoOnComponent(4)=="aaaa");
4470         self.assertTrue(a4.getInfoOnComponent(5)=="aaaa");
4471         for i in xrange(30):
4472             self.assertEqual(int(expected2[i]),a4.getIJ(0,i));
4473             pass
4474         # test of throw
4475         arr5V=[2,3,6]
4476         arr6V=[2,7,5]
4477         arr7V=[2,1,4,6]
4478         self.assertRaises(InterpKernelException,a2.keepSelectedComponents,arr5V);
4479         self.assertRaises(InterpKernelException,a2.keepSelectedComponents,arr6V);
4480         self.assertRaises(InterpKernelException,a2.setSelectedComponents,a1,arr7V);
4481         arr7V=arr7V[0:3]
4482         self.assertRaises(InterpKernelException,a2.setSelectedComponents,a1,arr7V);
4483         #
4484         pass
4485
4486     def testKeepSetSelectedComponent2(self):
4487         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
4488         arr1=[1.,2.,3.,4., 11.,12.,13.,14., 21.,22.,23.,24., 31.,32.,33.,34., 41.,42.,43.,44.]
4489         a1=DataArrayDouble.New();
4490         a1.setValues(arr1,5,4);
4491         a1.setInfoOnComponent(0,"aaaa");
4492         a1.setInfoOnComponent(1,"bbbb");
4493         a1.setInfoOnComponent(2,"cccc");
4494         a1.setInfoOnComponent(3,"dddd");
4495         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
4496         f1.setTime(2.3,4,5);
4497         f1.setMesh(m1);
4498         f1.setName("f1");
4499         f1.setArray(a1);
4500         f1.checkCoherency();
4501         #
4502         arr2V=[1,2,1,2,0,0]
4503         f2=f1.keepSelectedComponents(arr2V);
4504         self.assertTrue(f2.getTimeDiscretization()==ONE_TIME);
4505         t,dt,it=f2.getTime()
4506         self.assertAlmostEqual(2.3,t,13);
4507         self.assertEqual(4,dt);
4508         self.assertEqual(5,it);
4509         f2.checkCoherency();
4510         self.assertEqual(6,f2.getNumberOfComponents());
4511         self.assertEqual(5,f2.getNumberOfTuples());
4512         self.assertTrue(f2.getArray().getInfoOnComponent(0)=="bbbb");
4513         self.assertTrue(f2.getArray().getInfoOnComponent(1)=="cccc");
4514         self.assertTrue(f2.getArray().getInfoOnComponent(2)=="bbbb");
4515         self.assertTrue(f2.getArray().getInfoOnComponent(3)=="cccc");
4516         self.assertTrue(f2.getArray().getInfoOnComponent(4)=="aaaa");
4517         self.assertTrue(f2.getArray().getInfoOnComponent(5)=="aaaa");
4518         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.]
4519         for i in xrange(30):
4520             self.assertAlmostEqual(expected1[i],f2.getIJ(0,i),14);
4521             pass
4522         #setSelectedComponents
4523         arr3V=[3,2]
4524         f5=f1.keepSelectedComponents(arr3V);
4525         f5.setTime(6.7,8,9);
4526         f5.getArray().setInfoOnComponent(0,"eeee");
4527         f5.getArray().setInfoOnComponent(1,"ffff");
4528         f5.checkCoherency();
4529         arr4V=[1,2]
4530         f2.setSelectedComponents(f5,arr4V);
4531         self.assertEqual(6,f2.getNumberOfComponents());
4532         self.assertEqual(5,f2.getNumberOfTuples());
4533         f2.checkCoherency();
4534         t,dt,it=f2.getTime()
4535         self.assertAlmostEqual(2.3,t,13);
4536         self.assertEqual(4,dt);
4537         self.assertEqual(5,it);
4538         self.assertTrue(f2.getArray().getInfoOnComponent(0)=="bbbb");
4539         self.assertTrue(f2.getArray().getInfoOnComponent(1)=="eeee");
4540         self.assertTrue(f2.getArray().getInfoOnComponent(2)=="ffff");
4541         self.assertTrue(f2.getArray().getInfoOnComponent(3)=="cccc");
4542         self.assertTrue(f2.getArray().getInfoOnComponent(4)=="aaaa");
4543         self.assertTrue(f2.getArray().getInfoOnComponent(5)=="aaaa");
4544         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.]
4545         for i in xrange(30):
4546             self.assertAlmostEqual(expected2[i],f2.getIJ(0,i),14);
4547             pass
4548         #
4549         pass
4550
4551     def testElementaryDAThrowAndSpecialCases(self):
4552         da=DataArrayInt.New();
4553         self.assertRaises(InterpKernelException, da.checkAllocated);
4554         self.assertRaises(InterpKernelException, da.fillWithValue, 1);
4555         self.assertRaises(InterpKernelException, da.iota, 1);
4556         da.alloc(7,1);
4557         da.fillWithValue(11); #11,11,11,11...
4558         da.iota(10); #10,11,12,13...
4559
4560         db=DataArrayInt.New();
4561         db.alloc(7,2);
4562
4563         dbl2=DataArrayDouble.New();
4564         dbl2.alloc(7,2);
4565         self.assertRaises(InterpKernelException, dbl2.isUniform, 10., 1e-15);
4566         self.assertRaises(InterpKernelException, dbl2.sort);
4567         self.assertRaises(InterpKernelException, dbl2.reverse);
4568         self.assertRaises(InterpKernelException, dbl2.iota, 10.);
4569
4570         dbl=DataArrayDouble.New();
4571         #DataArrayDouble not allocated yet
4572         self.assertRaises(InterpKernelException, dbl.iota, 10.);
4573         self.assertRaises(InterpKernelException, dbl.isUniform, 10., 1e-15);
4574         self.assertRaises(InterpKernelException, dbl.sort);
4575         self.assertRaises(InterpKernelException, dbl.reverse);
4576         self.assertRaises(InterpKernelException, dbl.fromNoInterlace);
4577         self.assertRaises(InterpKernelException, dbl.toNoInterlace);
4578
4579         dbl.alloc(7,1);
4580         dbl.iota(10.);
4581         self.assertTrue(not dbl.isUniform(10.,1e-15));
4582         dbl.sort();
4583         self.assertTrue(dbl.isMonotonic(True, .99));
4584         self.assertTrue(dbl.isMonotonic(True, -.99));
4585         self.assertTrue(not dbl.isMonotonic(True, 1.1));
4586         self.assertTrue(not dbl.isMonotonic(True, -1.1));
4587         dbl.reverse();
4588         self.assertTrue(dbl.isMonotonic(False, .99));
4589         self.assertTrue(not dbl.isMonotonic(False, 1.1));
4590         self.assertTrue(not dbl.isMonotonic(False, -1.1));
4591
4592         dc=DataArrayInt.New();
4593         dc.alloc(14,1);
4594
4595         dd=DataArrayDouble.New();
4596         self.assertRaises(InterpKernelException, dd.checkAllocated);
4597         self.assertRaises(InterpKernelException, dd.fillWithValue, 1.);
4598         self.assertRaises(InterpKernelException, dd.iota, 1.);
4599         self.assertTrue(not ((dd.repr().find("No data"))==-1));
4600
4601         dd.alloc(0,1); #Allocated but nbOfElements==0!
4602         self.assertTrue(not ((dd.repr().find("Number of tuples : 0"))==-1));
4603         self.assertTrue(not ((dd.repr().find("Empty Data"))==-1));
4604         dd.fillWithValue(11); #?!...ok
4605         dd.iota(10); #?!...ok
4606         self.assertTrue(dd.isMonotonic(True, 1.));  #nothing is monotonic
4607         self.assertTrue(dd.isMonotonic(False, 1.));
4608
4609         self.assertRaises(InterpKernelException, db.copyStringInfoFrom, da);
4610         self.assertRaises(InterpKernelException, db.copyStringInfoFrom, da);
4611         cIds=[2,2]
4612         self.assertRaises(InterpKernelException, da.copyPartOfStringInfoFrom, db, cIds);
4613         cIds[0]=1;
4614         cIds[0]=-1;
4615         self.assertRaises(InterpKernelException, da.copyPartOfStringInfoFrom, db, cIds);
4616
4617         info=["infoOfOneComponent"]*2;
4618         self.assertRaises(InterpKernelException, da.setInfoOnComponents, info);
4619         self.assertRaises(InterpKernelException, da.setInfoOnComponent, 1, info[0]);
4620         db.setInfoOnComponents(info);
4621
4622         self.assertRaises(InterpKernelException, da.getInfoOnComponent, -1);
4623         self.assertRaises(InterpKernelException, da.getInfoOnComponent, 2);
4624         self.assertTrue(db.getInfoOnComponent(1)==db.getInfoOnComponent(0));
4625         self.assertRaises(InterpKernelException, db.getVarOnComponent, -1);
4626         self.assertRaises(InterpKernelException, db.getVarOnComponent, 2);
4627         self.assertRaises(InterpKernelException, db.getUnitOnComponent, -1);
4628         self.assertRaises(InterpKernelException, db.getUnitOnComponent, 2);
4629
4630         self.assertTrue(da.GetVarNameFromInfo("varname unit ")=="varname unit ");
4631         self.assertTrue(da.GetVarNameFromInfo("varname]unit[")=="varname]unit[");
4632         self.assertTrue(da.GetVarNameFromInfo("[unit]")=="");
4633         self.assertTrue(da.GetVarNameFromInfo("varname [unit]")=="varname");
4634
4635         self.assertTrue(da.GetUnitFromInfo("varname unit ")=="");
4636         self.assertTrue(da.GetUnitFromInfo("varname]unit[")=="");
4637         self.assertTrue(da.GetUnitFromInfo("[unit]")=="unit");
4638         self.assertTrue(da.GetUnitFromInfo("varname [unit]")=="unit");
4639
4640         self.assertRaises(InterpKernelException, da.checkNbOfTuplesAndComp, db, "theMessageInThrow");
4641         self.assertRaises(InterpKernelException, da.checkNbOfTuplesAndComp, dc, "theMessageInThrow");
4642         self.assertRaises(InterpKernelException, db.checkNbOfTuplesAndComp, dc, "theMessageInThrow");
4643
4644         self.assertRaises(InterpKernelException, da.checkNbOfTuplesAndComp, 7, 2, "theMessageInThrow");
4645         da.checkNbOfTuplesAndComp(7,1,"theMessageInThrow");
4646
4647         self.assertRaises(InterpKernelException, db.checkNbOfElems, 7*2+1, "theMessageInThrow");
4648         db.checkNbOfElems(7*2,"theMessageInThrow");
4649
4650         self.assertRaises(InterpKernelException, db.GetNumberOfItemGivenBES, 10, 9, 1, "theMessageInThrow");
4651         self.assertRaises(InterpKernelException, db.GetNumberOfItemGivenBES, 0, 1, -1, "theMessageInThrow");
4652         self.assertEqual(10,db.GetNumberOfItemGivenBES(0,10,1,"theMessageInThrow"));
4653         self.assertEqual(5,db.GetNumberOfItemGivenBES(0,10,2,"theMessageInThrow"));
4654         self.assertEqual(6,db.GetNumberOfItemGivenBES(0,11,2,"theMessageInThrow"));
4655
4656         self.assertTrue(not ((da.repr().find("Number of components : 1"))==-1));
4657         self.assertTrue(not ((dd.repr().find("Number of components : 1"))==-1));
4658         self.assertTrue(not ((dbl.repr().find("Number of components : 1"))==-1));
4659
4660         self.assertTrue(not ((da.reprZip().find("Number of components : 1"))==-1));
4661         self.assertTrue(not ((dd.reprZip().find("Number of components : 1"))==-1));
4662         self.assertTrue(not ((dbl.reprZip().find("Number of components : 1"))==-1));
4663
4664         self.assertRaises(InterpKernelException, dbl.selectByTupleId2, 0, 1, -1);
4665         self.assertRaises(InterpKernelException, dbl.substr, -1, 1);
4666         self.assertRaises(InterpKernelException, dbl.substr, 8, 1);
4667         self.assertRaises(InterpKernelException, dbl.substr, 0, 8);
4668         self.assertRaises(InterpKernelException, dbl.meldWith, dd);
4669
4670         self.assertRaises(InterpKernelException, dbl.setPartOfValuesAdv, dbl2, da); #dbl dbl2 not have the same number of components
4671         self.assertRaises(InterpKernelException, dbl.setPartOfValuesAdv, dd, da);  #da tuple selector DataArrayInt instance not have exactly 2 components
4672
4673         dbl3=DataArrayDouble.New();
4674         dbl3.alloc(6,2);
4675         dbl3.fillWithValue(11.);
4676         #bad number of components
4677         self.assertRaises(InterpKernelException, dbl3.getMaxValue);
4678         self.assertRaises(InterpKernelException, dd.getMaxValue);
4679         self.assertRaises(InterpKernelException, dbl3.getMinValue);
4680         self.assertRaises(InterpKernelException, dd.getMinValue);
4681         self.assertRaises(InterpKernelException, dbl3.getAverageValue);
4682         self.assertRaises(InterpKernelException, dd.getAverageValue);
4683         self.assertRaises(InterpKernelException, dd.accumulate, 100);
4684         self.assertRaises(InterpKernelException, dbl.fromPolarToCart);
4685         self.assertRaises(InterpKernelException, dbl3.fromCylToCart);
4686         self.assertRaises(InterpKernelException, dbl3.fromSpherToCart);
4687         self.assertRaises(InterpKernelException, dbl3.doublyContractedProduct);
4688         self.assertRaises(InterpKernelException, dbl3.determinant);
4689         self.assertRaises(InterpKernelException, dbl3.eigenValues);
4690         self.assertRaises(InterpKernelException, dbl3.eigenVectors);
4691         self.assertRaises(InterpKernelException, dbl3.inverse);
4692         self.assertRaises(InterpKernelException, dbl3.trace);
4693         self.assertRaises(InterpKernelException, dbl3.deviator);
4694
4695         dbl3.setIJ(5,1,12.);
4696         self.assertTrue(dbl3.getMaxValueInArray()==12.);
4697         self.assertTrue(dbl3.getMinValueInArray()==11.);
4698
4699         db.fillWithValue(100); #bad Ids
4700         self.assertRaises(InterpKernelException, dbl3.setPartOfValuesAdv, dbl2, db);
4701         db.fillWithValue(-1); #bad Ids
4702         self.assertRaises(InterpKernelException, dbl3.setPartOfValuesAdv, dbl2, db);
4703         db.fillWithValue(6); #bad Ids for dbl3
4704         self.assertRaises(InterpKernelException, dbl3.setPartOfValuesAdv, dbl2, db);
4705
4706         dbl3.checkNoNullValues();
4707         dbl3.setIJ(5,0,0.);
4708         self.assertRaises(InterpKernelException, dbl3.checkNoNullValues);
4709         self.assertRaises(InterpKernelException, dbl3.applyInv, 1.);  #div by zero
4710         self.assertRaises(InterpKernelException, dbl2.getIdsInRange, 1., 2.);
4711         a=[]
4712         self.assertRaises(InterpKernelException, DataArrayDouble_Aggregate, a);
4713         self.assertRaises(InterpKernelException, DataArrayDouble_Meld, a);
4714
4715         a=[dbl2,dbl]; #Nb of components mismatch
4716         self.assertRaises(InterpKernelException, DataArrayDouble_Aggregate, a);
4717
4718         self.assertRaises(InterpKernelException, DataArrayDouble_Dot, dbl2, dbl);
4719
4720         self.assertRaises(InterpKernelException, DataArrayDouble_CrossProduct, dbl2, dbl); #Nb of components mismatch
4721         self.assertRaises(InterpKernelException, DataArrayDouble_CrossProduct, dbl2, dbl2); #Nb of components must be equal to 3
4722         dbl4=DataArrayDouble.New();
4723         dbl4.alloc(6,3);
4724         dbl5=DataArrayDouble.New();
4725         dbl5.alloc(7,3);
4726         self.assertRaises(InterpKernelException, DataArrayDouble_CrossProduct, dbl4, dbl5); #Nb of tuples mismatch
4727
4728         a[0]=dbl4; #Nb of tuple mismatch
4729         a[1]=dbl5; #Nb of tuple mismatch
4730         self.assertRaises(InterpKernelException, DataArrayDouble_Meld, a);
4731         self.assertRaises(InterpKernelException, DataArrayDouble_Dot, dbl4, dbl5);
4732         pass
4733
4734     def testDAIGetIdsEqual1(self):
4735         tab1=[5,-2,-4,-2,3,2,-2];
4736         da=DataArrayInt.New();
4737         da.setValues(tab1,7,1);
4738         da2=da.getIdsEqual(-2);
4739         self.assertEqual(3,da2.getNumberOfTuples());
4740         self.assertEqual(1,da2.getNumberOfComponents());
4741         expected1=[1,3,6];
4742         self.assertEqual(expected1,da2.getValues());
4743         pass
4744
4745     def testDAIGetIdsEqualList1(self):
4746         tab1=[5,-2,-4,-2,3,2,-2];
4747         da=DataArrayInt.New();
4748         da.setValues(tab1,7,1);
4749         da2=da.getIdsEqualList([3,-2,0]);
4750         self.assertEqual(4,da2.getNumberOfTuples());
4751         self.assertEqual(1,da2.getNumberOfComponents());
4752         expected1=[1,3,4,6];
4753         self.assertEqual(expected1,da2.getValues());
4754         pass
4755
4756     def testDAFromNoInterlace1(self):
4757         tab1=[1,11,21,31,41,2,12,22,32,42,3,13,23,33,43]
4758         da=DataArrayInt.New();
4759         da.setValues(tab1,5,3);
4760         da2=da.fromNoInterlace();
4761         expected1=[1,2,3,11,12,13,21,22,23,31,32,33,41,42,43]
4762         self.assertEqual(5,da2.getNumberOfTuples());
4763         self.assertEqual(3,da2.getNumberOfComponents());# it's not a bug. Avoid to have 1 million components !
4764         self.assertEqual(expected1,da2.getValues());
4765         da3=da.convertToDblArr();
4766         da4=da3.fromNoInterlace();
4767         self.assertEqual(5,da4.getNumberOfTuples());
4768         self.assertEqual(3,da4.getNumberOfComponents());# it's not a bug. Avoid to have 1 million components !
4769         for i in xrange(15):
4770             self.assertAlmostEqual(expected1[i],da4.getIJ(0,i),14);
4771             pass
4772         pass
4773
4774     def testDAToNoInterlace1(self):
4775         tab1=[1,2,3,11,12,13,21,22,23,31,32,33,41,42,43]
4776         da=DataArrayInt.New();
4777         da.setValues(tab1,5,3);
4778         da2=da.toNoInterlace();
4779         expected1=[1,11,21,31,41,2,12,22,32,42,3,13,23,33,43]
4780         self.assertEqual(5,da2.getNumberOfTuples());
4781         self.assertEqual(3,da2.getNumberOfComponents());# it's not a bug. Avoid to have 1 million components !
4782         self.assertEqual(expected1,da2.getValues());
4783         da3=da.convertToDblArr();
4784         da4=da3.toNoInterlace();
4785         self.assertEqual(5,da4.getNumberOfTuples());
4786         self.assertEqual(3,da4.getNumberOfComponents());# it's not a bug. Avoid to have 1 million components !
4787         for i in xrange(15):
4788             self.assertAlmostEqual(expected1[i],da4.getIJ(0,i),14);
4789             pass
4790         pass
4791
4792     def testDAIsUniform1(self):
4793         tab1=[1,1,1,1,1]
4794         da=DataArrayInt.New();
4795         da.setValues(tab1,5,1);
4796         self.assertTrue(da.isUniform(1));
4797         da.setIJ(2,0,2);
4798         self.assertTrue(not da.isUniform(1));
4799         da.setIJ(2,0,1);
4800         self.assertTrue(da.isUniform(1));
4801         da2=da.convertToDblArr();
4802         self.assertTrue(da2.isUniform(1.,1.e-12));
4803         da2.setIJ(1,0,1.+1.e-13);
4804         self.assertTrue(da2.isUniform(1.,1.e-12));
4805         da2.setIJ(1,0,1.+1.e-11);
4806         self.assertTrue(not da2.isUniform(1.,1.e-12));
4807         pass
4808
4809     def testDADFromPolarToCart1(self):
4810         tab1=[2.,0.2,2.5,0.7]
4811         da=DataArrayDouble.New();
4812         da.setValues(tab1,2,2);
4813         da2=da.fromPolarToCart();
4814         expected1=[1.9601331556824833,0.39733866159012243, 1.9121054682112213,1.6105442180942275]
4815         for i in xrange(4):
4816             self.assertAlmostEqual(expected1[i],da2.getIJ(0,i),13);
4817             pass
4818         pass
4819
4820     def testDADFromCylToCart1(self):
4821         tab1=[2.,0.2,4.,2.5,0.7,9.]
4822         da=DataArrayDouble.New();
4823         da.setValues(tab1,2,3);
4824         da2=da.fromCylToCart();
4825         expected1=[1.9601331556824833,0.39733866159012243,4., 1.9121054682112213,1.6105442180942275,9.]
4826         for i in xrange(6):
4827             self.assertAlmostEqual(expected1[i],da2.getIJ(0,i),13);
4828             pass
4829         pass
4830
4831     def testDADFromSpherToCart1(self):
4832         tab1=[2.,0.2,0.3,2.5,0.7,0.8]
4833         da=DataArrayDouble.New();
4834         da.setValues(tab1,2,3);
4835         da2=da.fromSpherToCart();
4836         expected1=[0.37959212195737485,0.11742160338765303,1.9601331556824833, 1.1220769624465328,1.1553337045129035,1.9121054682112213]
4837         for i in xrange(6):
4838             self.assertAlmostEqual(expected1[i],da2.getIJ(0,i),13);
4839             pass
4840         pass
4841
4842     def testUnPolyze1(self):
4843         elts=[0,1,2,3,4,5,6,7]
4844         eltsV=elts;
4845         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
4846         mesh.convertToPolyTypes(eltsV);
4847         mesh.unPolyze();
4848         mesh2=MEDCouplingDataForTest.build3DTargetMesh_1();
4849         mesh.checkCoherency();
4850         self.assertTrue(mesh.isEqual(mesh2,1e-12));
4851         mesh.convertToPolyTypes(eltsV);
4852         self.assertTrue(not mesh.isEqual(mesh2,1e-12));
4853         mesh.getNodalConnectivity().setIJ(0,6,10);
4854         mesh.getNodalConnectivity().setIJ(0,7,9);
4855         mesh.getNodalConnectivity().setIJ(0,8,12);
4856         mesh.getNodalConnectivity().setIJ(0,9,13);
4857         mesh.unPolyze();
4858         self.assertTrue(mesh.isEqual(mesh2,1e-12));
4859         mesh.convertToPolyTypes(eltsV);
4860         mesh.getNodalConnectivity().setIJ(0,6,12);
4861         mesh.getNodalConnectivity().setIJ(0,7,13);
4862         mesh.getNodalConnectivity().setIJ(0,8,10);
4863         mesh.getNodalConnectivity().setIJ(0,9,9);
4864         mesh.unPolyze();
4865         self.assertTrue(mesh.isEqual(mesh2,1e-12));
4866         mesh.convertToPolyTypes(eltsV);
4867         mesh.getNodalConnectivity().setIJ(0,6,12);
4868         mesh.getNodalConnectivity().setIJ(0,7,10);
4869         mesh.getNodalConnectivity().setIJ(0,8,13);
4870         mesh.getNodalConnectivity().setIJ(0,9,9);
4871         mesh.unPolyze();
4872         self.assertTrue(not mesh.isEqual(mesh2,1e-12));
4873         # Test for 2D mesh
4874         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
4875         mesh2=MEDCouplingDataForTest.build2DTargetMesh_1();
4876         eltsV=eltsV[:5];
4877         mesh.convertToPolyTypes(eltsV);
4878         self.assertTrue(not mesh.isEqual(mesh2,1e-12));
4879         mesh.unPolyze();
4880         self.assertTrue(mesh.isEqual(mesh2,1e-12));
4881         pass
4882
4883     def testConvertDegeneratedCells1(self):
4884         mesh=MEDCouplingDataForTest.build3DTargetMesh_1();
4885         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]
4886         mesh.allocateCells(4);
4887         mesh.insertNextCell(NORM_HEXA8,8,conn[0:8])
4888         mesh.insertNextCell(NORM_HEXA8,8,conn[8:16])
4889         mesh.insertNextCell(NORM_HEXA8,8,conn[16:24])
4890         mesh.insertNextCell(NORM_HEXA8,8,conn[24:32])
4891         mesh.finishInsertingCells();
4892         mesh.checkCoherency();
4893         self.assertEqual(4,mesh.getNumberOfCells());
4894         self.assertEqual(NORM_HEXA8,mesh.getTypeOfCell(0));
4895         self.assertEqual(NORM_HEXA8,mesh.getTypeOfCell(1));
4896         self.assertEqual(NORM_HEXA8,mesh.getTypeOfCell(2));
4897         self.assertEqual(NORM_HEXA8,mesh.getTypeOfCell(3));
4898         f1=mesh.getMeasureField(True);
4899         mesh.convertDegeneratedCells();
4900         mesh.checkCoherency();
4901         f2=mesh.getMeasureField(True);
4902         self.assertEqual(4,mesh.getNumberOfCells());
4903         self.assertEqual(NORM_PENTA6,mesh.getTypeOfCell(0));
4904         self.assertEqual(NORM_PYRA5,mesh.getTypeOfCell(1));
4905         self.assertEqual(NORM_TETRA4,mesh.getTypeOfCell(2));
4906         self.assertEqual(NORM_PYRA5,mesh.getTypeOfCell(3));
4907         for i in xrange(4):
4908             self.assertAlmostEqual(f1.getArray().getIJ(0,i),f2.getArray().getIJ(0,i),5);
4909             pass
4910         pass
4911
4912     def testGetNodeIdsNearPoints1(self):
4913         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
4914         coords=mesh.getCoords();
4915         tmp=DataArrayDouble.New();
4916         vals=[0.2,0.2,0.1,0.2,0.2,0.2]
4917         tmp.setValues(vals,3,2);
4918         tmp2=DataArrayDouble.Aggregate(coords,tmp);
4919         mesh.setCoords(tmp2);
4920         pts=[0.2,0.2,0.1,0.3,-0.3,0.7]
4921         c=mesh.getNodeIdsNearPoint(pts[:2],1e-7);
4922         self.assertEqual([4,9,11],c.getValues());
4923         c,cI=mesh.getNodeIdsNearPoints(pts,3,1e-7);
4924         self.assertEqual([0,3,3,4],cI.getValues());
4925         self.assertEqual([4,9,11,6],c.getValues());
4926         c,cI=mesh.getNodeIdsNearPoints(pts,1e-7);
4927         self.assertEqual([0,3,3,4],cI.getValues());
4928         self.assertEqual([4,9,11,6],c.getValues());
4929         c,cI=mesh.getNodeIdsNearPoints(DataArrayDouble.New(pts,3,2),1e-7);
4930         self.assertEqual([0,3,3,4],cI.getValues());
4931         self.assertEqual([4,9,11,6],c.getValues());
4932         self.assertRaises(InterpKernelException,mesh.getNodeIdsNearPoints,DataArrayDouble.New(pts,2,3),1e-7);
4933         pass
4934
4935     def testFieldCopyTinyAttrFrom1(self):
4936         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
4937         f1.setName("f1");
4938         f1.setTimeTolerance(1.e-5);
4939         f1.setDescription("f1Desc");
4940         f1.setTime(1.23,4,5);
4941         f2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
4942         f2.setName("f2");
4943         f2.setDescription("f2Desc");
4944         f2.setTime(6.78,9,10);
4945         f2.setTimeTolerance(4.556e-12);
4946         #
4947         f1.copyTinyAttrFrom(f2);
4948         self.assertAlmostEqual(4.556e-12,f1.getTimeTolerance(),24);
4949         t,dt,it=f1.getTime()
4950         self.assertAlmostEqual(6.78,t,12);
4951         self.assertEqual(9,dt);
4952         self.assertEqual(10,it);
4953         self.assertTrue(f1.getName()=="f1");#name unchanged
4954         self.assertTrue(f1.getDescription()=="f1Desc");#description unchanged
4955         #
4956         f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
4957         f1.setName("f1");
4958         f1.setTimeTolerance(1.e-5);
4959         f1.setDescription("f1Desc");
4960         f2=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
4961         f2.setName("f2");
4962         f2.setDescription("f2Desc");
4963         f2.setTimeTolerance(4.556e-12);
4964         #
4965         f1.copyTinyAttrFrom(f2);
4966         self.assertAlmostEqual(4.556e-12,f1.getTimeTolerance(),24);
4967         self.assertTrue(f1.getName()=="f1");#name unchanged
4968         self.assertTrue(f1.getDescription()=="f1Desc");#description unchanged
4969         #
4970         f1=MEDCouplingFieldDouble.New(ON_CELLS,CONST_ON_TIME_INTERVAL);
4971         f1.setName("f1");
4972         f1.setTimeTolerance(1.e-5);
4973         f1.setDescription("f1Desc");
4974         f1.setTime(1.23,4,5);
4975         f1.setEndTime(5.43,2,1);
4976         f2=MEDCouplingFieldDouble.New(ON_CELLS,CONST_ON_TIME_INTERVAL);
4977         f2.setName("f2");
4978         f2.setDescription("f2Desc");
4979         f2.setTimeTolerance(4.556e-12);
4980         f2.setTime(6.78,9,10);
4981         f2.setEndTime(10.98,7,6);
4982         #
4983         f1.copyTinyAttrFrom(f2);
4984         self.assertAlmostEqual(4.556e-12,f1.getTimeTolerance(),24);
4985         self.assertTrue(f1.getName()=="f1");#name unchanged
4986         self.assertTrue(f1.getDescription()=="f1Desc");#description unchanged
4987         t,dt,it=f1.getTime()
4988         self.assertAlmostEqual(6.78,t,12);
4989         self.assertEqual(9,dt);
4990         self.assertEqual(10,it);
4991         t,dt,it=f1.getEndTime()
4992         self.assertAlmostEqual(10.98,t,12);
4993         self.assertEqual(7,dt);
4994         self.assertEqual(6,it);
4995         #
4996         f1=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
4997         f1.setName("f1");
4998         f1.setTimeTolerance(1.e-5);
4999         f1.setDescription("f1Desc");
5000         f1.setTime(1.23,4,5);
5001         f1.setEndTime(5.43,2,1);
5002         f2=MEDCouplingFieldDouble.New(ON_CELLS,LINEAR_TIME);
5003         f2.setName("f2");
5004         f2.setDescription("f2Desc");
5005         f2.setTimeTolerance(4.556e-12);
5006         f2.setTime(6.78,9,10);
5007         f2.setEndTime(10.98,7,6);
5008         #
5009         f1.copyTinyAttrFrom(f2);
5010         self.assertAlmostEqual(4.556e-12,f1.getTimeTolerance(),24);
5011         self.assertTrue(f1.getName()=="f1");#name unchanged
5012         self.assertTrue(f1.getDescription()=="f1Desc");#description unchanged
5013         t,dt,it=f1.getTime()
5014         self.assertAlmostEqual(6.78,t,12);
5015         self.assertEqual(9,dt);
5016         self.assertEqual(10,it);
5017         t,dt,it=f1.getEndTime()
5018         self.assertAlmostEqual(10.98,t,12);
5019         self.assertEqual(7,dt);
5020         self.assertEqual(6,it);
5021         pass
5022
5023     def testExtrudedMesh5(self):
5024         coo1=[0.,1.,2.,3.5]
5025         a=DataArrayDouble.New();
5026         a.setValues(coo1,4,1);
5027         b=MEDCouplingCMesh.New();
5028         b.setCoordsAt(0,a);
5029         c=b.buildUnstructured();
5030         self.assertEqual(1,c.getSpaceDimension());
5031         c.changeSpaceDimension(2);
5032         #
5033         d=DataArrayDouble.New();
5034         d.alloc(13,1);
5035         d.iota();
5036         e=MEDCouplingCMesh.New();
5037         e.setCoordsAt(0,d);
5038         f=e.buildUnstructured();
5039         g=f.getCoords().applyFunc(2,"3.5*IVec+x/6*3.14159265359*JVec");
5040         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 !
5041         h=g.fromPolarToCart();
5042         f.setCoords(h);
5043         i=c.buildExtrudedMesh(f,1);
5044         self.assertEqual(52,i.getNumberOfNodes());
5045         tmp,tmp2,tmp3=i.mergeNodes(1e-9);
5046         self.assertTrue(tmp2);
5047         self.assertEqual(37,tmp3);
5048         i.convertDegeneratedCells();
5049         i.checkCoherency();
5050         self.assertEqual(36,i.getNumberOfCells());
5051         self.assertEqual(37,i.getNumberOfNodes());
5052         self.assertEqual(12,i.getNumberOfCellsWithType(NORM_TRI3));
5053         self.assertEqual(24,i.getNumberOfCellsWithType(NORM_QUAD4));
5054         expected1=[0.25,0.75,2.0625]
5055         j=i.getMeasureField(True);
5056         for ii in xrange(12):
5057             for k in xrange(3):
5058                 self.assertAlmostEqual(expected1[k],j.getIJ(0,ii*3+k),10);
5059                 pass
5060             pass
5061         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]
5062         m=i.getBarycenterAndOwner();
5063         for i in xrange(72):
5064             self.assertAlmostEqual(expected2[i],m.getIJ(0,i),10);
5065             pass
5066         #
5067         pass
5068
5069     def testExtrudedMesh6(self):
5070         coo1=[0.,1.,2.,3.5]
5071         a=DataArrayDouble.New();
5072         a.setValues(coo1,4,1);
5073         b=MEDCouplingCMesh.New();
5074         b.setCoordsAt(0,a);
5075         c=b.buildUnstructured();
5076         self.assertEqual(1,c.getSpaceDimension());
5077         c.changeSpaceDimension(2);
5078         #
5079         d=DataArrayDouble.New();
5080         d.alloc(5,1);
5081         d.iota();
5082         e=MEDCouplingCMesh.New();
5083         e.setCoordsAt(0,d);
5084         f=e.buildUnstructured();
5085         d2=f.getCoords().applyFunc("x*x/2");
5086         f.setCoords(d2);
5087         f.changeSpaceDimension(2);
5088         #
5089         center=[0.,0.]
5090         f.rotate(center,None,pi/3);
5091         g=c.buildExtrudedMesh(f,0);
5092         g.checkCoherency();
5093         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 ]
5094         f1=g.getMeasureField(True);
5095         for i in xrange(12):
5096             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),12);
5097             pass
5098         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]
5099         f2=g.getBarycenterAndOwner();
5100         for i in xrange(24):
5101             self.assertAlmostEqual(expected2[i],f2.getIJ(0,i),12);
5102             pass
5103         pass
5104
5105     def testExtrudedMesh7(self):
5106         coo1=[0.,1.,2.,3.5]
5107         a=DataArrayDouble.New();
5108         a.setValues(coo1,4,1);
5109         b=MEDCouplingCMesh.New();
5110         b.setCoordsAt(0,a);
5111         c=b.buildUnstructured();
5112         self.assertEqual(1,c.getSpaceDimension());
5113         c.changeSpaceDimension(2);
5114         #
5115         d=DataArrayDouble.New();
5116         d.alloc(13,1);
5117         d.iota();
5118         e=MEDCouplingCMesh.New();
5119         e.setCoordsAt(0,d);
5120         f=e.buildUnstructured();
5121         g=f.getCoords().applyFunc(2,"3.5*IVec+x/6*3.14159265359*JVec");
5122         h=g.fromPolarToCart();
5123         f.setCoords(h);
5124         i=c.buildExtrudedMesh(f,1);
5125         self.assertEqual(52,i.getNumberOfNodes());
5126         tmp,tmp2,tmp3=i.mergeNodes(1e-9);
5127         self.assertTrue(tmp2);
5128         self.assertEqual(37,tmp3);
5129         i.convertDegeneratedCells();
5130         vec1=[10.,0]
5131         i.translate(vec1);
5132         g2=h.applyFunc(3,"13.5/3.5*x*IVec+0*JVec+13.5/3.5*y*KVec");
5133         f.setCoords(g2);
5134         i.changeSpaceDimension(3);
5135         i3=i.buildExtrudedMesh(f,1);
5136         f2=i3.getMeasureField(True);
5137         tmp,tmp2,tmp3=i.mergeNodes(1e-9);
5138         self.assertTrue(tmp2);
5139         self.assertEqual(444,tmp3);
5140         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]
5141         for ii in xrange(12):
5142             for jj in xrange(36):
5143                 self.assertAlmostEqual(expected1[jj],f2.getIJ(0,ii*36+jj),9);
5144                 pass
5145         #
5146         pass
5147
5148     def testSimplexize1(self):
5149         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5150         m.convertToPolyTypes([3]);
5151         da=m.simplexize(0);
5152         self.assertEqual(7,da.getNumberOfTuples());
5153         self.assertEqual(1,da.getNumberOfComponents());
5154         expected2=[0,0,1,2,3,4,4]
5155         for i in xrange(7):
5156             self.assertEqual(expected2[i],da.getIJ(i,0));
5157             pass
5158         m.checkCoherency();
5159         self.assertEqual(7,m.getNumberOfCells());
5160         self.assertEqual(NORM_TRI3,m.getTypeOfCell(0));
5161         self.assertEqual(NORM_TRI3,m.getTypeOfCell(1));
5162         self.assertEqual(NORM_TRI3,m.getTypeOfCell(2));
5163         self.assertEqual(NORM_TRI3,m.getTypeOfCell(3));
5164         self.assertEqual(NORM_POLYGON,m.getTypeOfCell(4));
5165         self.assertEqual(NORM_TRI3,m.getTypeOfCell(5));
5166         self.assertEqual(NORM_TRI3,m.getTypeOfCell(6));
5167         expected1=[0.125,0.125,0.125,0.125,0.25,0.125,0.125]
5168         f=m.getMeasureField(False);
5169         for i in xrange(7):
5170             self.assertAlmostEqual(expected1[i]*sqrt(2.),f.getIJ(i,0),10);
5171             pass
5172         types=m.getAllTypes();
5173         self.assertEqual([NORM_TRI3,NORM_POLYGON],types);
5174         #
5175         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5176         m.convertToPolyTypes([3]);
5177         da=m.simplexize(1);
5178         self.assertEqual(7,da.getNumberOfTuples());
5179         self.assertEqual(1,da.getNumberOfComponents());
5180         for i in xrange(7):
5181             self.assertEqual(expected2[i],da.getIJ(i,0));
5182             pass
5183         m.checkCoherency();
5184         types=m.getAllTypes();
5185         self.assertEqual([NORM_TRI3,NORM_POLYGON],types);
5186         self.assertEqual(7,m.getNumberOfCells());
5187         self.assertEqual(NORM_TRI3,m.getTypeOfCell(0));
5188         self.assertEqual(NORM_TRI3,m.getTypeOfCell(1));
5189         self.assertEqual(NORM_TRI3,m.getTypeOfCell(2));
5190         self.assertEqual(NORM_TRI3,m.getTypeOfCell(3));
5191         self.assertEqual(NORM_POLYGON,m.getTypeOfCell(4));
5192         self.assertEqual(NORM_TRI3,m.getTypeOfCell(5));
5193         self.assertEqual(NORM_TRI3,m.getTypeOfCell(6));
5194         f=m.getMeasureField(False);
5195         for i in xrange(7):
5196             self.assertAlmostEqual(expected1[i]*sqrt(2.),f.getIJ(i,0),10);
5197             pass
5198         pass
5199
5200     def testSimplexize2(self):
5201         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5202         m.convertToPolyTypes([3]);
5203         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
5204         f1.setMesh(m);
5205         arr=DataArrayDouble.New();
5206         arr1=[10.,110.,20.,120.,30.,130.,40.,140.,50.,150.]
5207         arr.setValues(arr1,5,2);
5208         f1.setArray(arr);
5209         #
5210         f1.checkCoherency();
5211         self.assertTrue(f1.simplexize(0));
5212         f1.checkCoherency();
5213         expected1=[10.,110.,10.,110.,20.,120.,30.,130.,40.,140.,50.,150.,50.,150.]
5214         for i in xrange(14):
5215             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),10);
5216             pass
5217         self.assertTrue(not f1.simplexize(0));
5218         for i in xrange(14):
5219             self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),10);
5220             pass
5221         #
5222         pass
5223
5224     def testDAMeld1(self):
5225         da1=DataArrayDouble.New();
5226         da1.alloc(7,2);
5227         da2=DataArrayDouble.New();
5228         da2.alloc(7,1);
5229         #
5230         da1.fillWithValue(7.);
5231         da2.iota(0.);
5232         da3=da2.applyFunc(3,"10*x*IVec+100*x*JVec+1000*x*KVec");
5233         #
5234         da1.setInfoOnComponent(0,"c0da1");
5235         da1.setInfoOnComponent(1,"c1da1");
5236         da3.setInfoOnComponent(0,"c0da3");
5237         da3.setInfoOnComponent(1,"c1da3");
5238         da3.setInfoOnComponent(2,"c2da3");
5239         #
5240         da1C=da1.deepCpy();
5241         da1.meldWith(da3);
5242         self.assertEqual(5,da1.getNumberOfComponents());
5243         self.assertEqual(7,da1.getNumberOfTuples());
5244         self.assertTrue(da1.getInfoOnComponent(0)=="c0da1");
5245         self.assertTrue(da1.getInfoOnComponent(1)=="c1da1");
5246         self.assertTrue(da1.getInfoOnComponent(2)=="c0da3");
5247         self.assertTrue(da1.getInfoOnComponent(3)=="c1da3");
5248         self.assertTrue(da1.getInfoOnComponent(4)=="c2da3");
5249         #
5250         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.]
5251         for i in xrange(35):
5252             self.assertAlmostEqual(expected1[i],da1.getIJ(0,i),10);
5253             pass
5254         #
5255         dai1=da1C.convertToIntArr();
5256         dai3=da3.convertToIntArr();
5257         dai1.meldWith(dai3);
5258         self.assertEqual(5,dai1.getNumberOfComponents());
5259         self.assertEqual(7,dai1.getNumberOfTuples());
5260         self.assertTrue(dai1.getInfoOnComponent(0)=="c0da1");
5261         self.assertTrue(dai1.getInfoOnComponent(1)=="c1da1");
5262         self.assertTrue(dai1.getInfoOnComponent(2)=="c0da3");
5263         self.assertTrue(dai1.getInfoOnComponent(3)=="c1da3");
5264         self.assertTrue(dai1.getInfoOnComponent(4)=="c2da3");
5265         for i in xrange(35):
5266             self.assertEqual(int(expected1[i]),dai1.getIJ(0,i));
5267             pass
5268         # test of static method DataArrayDouble::meld
5269         da4=DataArrayDouble.Meld(da1C,da3);
5270         tmp=DataArrayDouble.Meld([da1C,da3]);
5271         self.assertTrue(da4.isEqual(tmp,1e-10))
5272         self.assertEqual(5,da4.getNumberOfComponents());
5273         self.assertEqual(7,da4.getNumberOfTuples());
5274         self.assertTrue(da4.getInfoOnComponent(0)=="c0da1");
5275         self.assertTrue(da4.getInfoOnComponent(1)=="c1da1");
5276         self.assertTrue(da4.getInfoOnComponent(2)=="c0da3");
5277         self.assertTrue(da4.getInfoOnComponent(3)=="c1da3");
5278         self.assertTrue(da4.getInfoOnComponent(4)=="c2da3");
5279         for i in xrange(35):
5280             self.assertAlmostEqual(expected1[i],da4.getIJ(0,i),10);
5281             pass
5282         # test of static method DataArrayInt::meld
5283         dai1=da1C.convertToIntArr();
5284         dai4=DataArrayInt.Meld(dai1,dai3);
5285         tmp=DataArrayInt.Meld([dai1,dai3]);
5286         self.assertTrue(dai4.isEqual(tmp))
5287         self.assertEqual(5,dai4.getNumberOfComponents());
5288         self.assertEqual(7,dai4.getNumberOfTuples());
5289         self.assertTrue(dai4.getInfoOnComponent(0)=="c0da1");
5290         self.assertTrue(dai4.getInfoOnComponent(1)=="c1da1");
5291         self.assertTrue(dai4.getInfoOnComponent(2)=="c0da3");
5292         self.assertTrue(dai4.getInfoOnComponent(3)=="c1da3");
5293         self.assertTrue(dai4.getInfoOnComponent(4)=="c2da3");
5294         for i in xrange(35):
5295             self.assertEqual(int(expected1[i]),dai4.getIJ(0,i));
5296             pass
5297         pass
5298
5299     def testFieldMeld1(self):
5300         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5301         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
5302         f1.setMesh(m);
5303         da1=DataArrayDouble.New();
5304         arr1=[12.,23.,34.,45.,56.]
5305         da1.setValues(arr1,5,1);
5306         da1.setInfoOnComponent(0,"aaa");
5307         f1.setArray(da1);
5308         f1.setTime(3.4,2,1);
5309         f1.checkCoherency();
5310         #
5311         f2=f1.deepCpy();
5312         f2.setMesh(f1.getMesh());
5313         f2.checkCoherency();
5314         f2.changeNbOfComponents(2,5.);
5315         f2.assign(5.);
5316         f2.getArray().setInfoOnComponent(0,"bbb");
5317         f2.getArray().setInfoOnComponent(1,"ccc");
5318         f2.checkCoherency();
5319         #
5320         f3=MEDCouplingFieldDouble.MeldFields(f2,f1);
5321         f3.checkCoherency();
5322         self.assertEqual(5,f3.getNumberOfTuples());
5323         self.assertEqual(3,f3.getNumberOfComponents());
5324         self.assertTrue(f3.getArray().getInfoOnComponent(0)=="bbb");
5325         self.assertTrue(f3.getArray().getInfoOnComponent(1)=="ccc");
5326         self.assertTrue(f3.getArray().getInfoOnComponent(2)=="aaa");
5327         expected1=[5.,5.,12.,5.,5.,23.,5.,5.,34.,5.,5.,45.,5.,5.,56.]
5328         for i in xrange(15):
5329             self.assertAlmostEqual(expected1[i],f3.getIJ(0,i),12);
5330             pass
5331         time,dt,it=f3.getTime();
5332         self.assertAlmostEqual(3.4,time,14);
5333         self.assertEqual(2,dt);
5334         self.assertEqual(1,it);
5335         #
5336         f4=f2.buildNewTimeReprFromThis(NO_TIME,False);
5337         f5=f1.buildNewTimeReprFromThis(NO_TIME,False);
5338         f6=MEDCouplingFieldDouble.MeldFields(f4,f5);
5339         f6.checkCoherency();
5340         self.assertEqual(5,f6.getNumberOfTuples());
5341         self.assertEqual(3,f6.getNumberOfComponents());
5342         self.assertTrue(f6.getArray().getInfoOnComponent(0)=="bbb");
5343         self.assertTrue(f6.getArray().getInfoOnComponent(1)=="ccc");
5344         self.assertTrue(f6.getArray().getInfoOnComponent(2)=="aaa");
5345         for i in xrange(15):
5346             self.assertAlmostEqual(expected1[i],f6.getIJ(0,i),12);
5347             pass
5348         #
5349         pass
5350
5351     def testMergeNodes2(self):
5352         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5353         m2=MEDCouplingDataForTest.build2DTargetMesh_1();
5354         vec=[0.002,0.]
5355         m2.translate(vec);
5356         #
5357         m3=MEDCouplingUMesh.MergeUMeshes([m1,m2]);
5358         da,b,newNbOfNodes=m3.mergeNodes2(0.01);
5359         self.assertEqual(9,m3.getNumberOfNodes());
5360         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]
5361         for i in xrange(18):
5362             self.assertAlmostEqual(expected1[i],m3.getCoords().getIJ(0,i),13);
5363             pass
5364         #
5365         pass
5366
5367     def testMergeField2(self):
5368         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5369         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
5370         f1.setMesh(m);
5371         arr=DataArrayDouble.New();
5372         arr.alloc(5,2);
5373         arr.fillWithValue(2.);
5374         f1.setArray(arr);
5375         f2=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
5376         f2.setMesh(m);
5377         arr=DataArrayDouble.New();
5378         arr.alloc(5,2);
5379         arr.fillWithValue(5.);
5380         f2.setArray(arr);
5381         f3=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
5382         f3.setMesh(m);
5383         arr=DataArrayDouble.New();
5384         arr.alloc(5,2);
5385         arr.fillWithValue(7.);
5386         f3.setArray(arr);
5387         #
5388         f4=MEDCouplingFieldDouble.MergeFields([f1,f2,f3]);
5389         self.assertEqual(15,f4.getMesh().getNumberOfCells());
5390         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.]
5391         for i in xrange(30):
5392             self.assertAlmostEqual(expected1[i],f4.getIJ(0,i),13);
5393             pass
5394         #
5395         pass
5396
5397     def testDAIBuildComplement1(self):
5398         a=DataArrayInt.New();
5399         tab=[3,1,7,8]
5400         a.setValues(tab,4,1);
5401         b=a.buildComplement(12);
5402         self.assertEqual(8,b.getNumberOfTuples());
5403         self.assertEqual(1,b.getNumberOfComponents());
5404         expected1=[0,2,4,5,6,9,10,11]
5405         for i in xrange(8):
5406             self.assertEqual(expected1[i],b.getIJ(0,i));
5407             pass
5408         pass
5409
5410     def testDAIBuildUnion1(self):
5411         a=DataArrayInt.New();
5412         tab1=[3,1,7,8]
5413         a.setValues(tab1,4,1);
5414         c=DataArrayInt.New();
5415         tab2=[5,3,0,18,8]
5416         c.setValues(tab2,5,1);
5417         b=a.buildUnion(c);
5418         self.assertEqual(7,b.getNumberOfTuples());
5419         self.assertEqual(1,b.getNumberOfComponents());
5420         expected1=[0,1,3,5,7,8,18]
5421         for i in xrange(7):
5422             self.assertEqual(expected1[i],b.getIJ(0,i));
5423             pass
5424         b=DataArrayInt.BuildUnion([a,c]);
5425         self.assertEqual(7,b.getNumberOfTuples());
5426         self.assertEqual(1,b.getNumberOfComponents());
5427         expected1=[0,1,3,5,7,8,18]
5428         for i in xrange(7):
5429             self.assertEqual(expected1[i],b.getIJ(0,i));
5430             pass
5431         pass
5432
5433     def testDAIBuildIntersection1(self):
5434         a=DataArrayInt.New();
5435         tab1=[3,1,7,8]
5436         a.setValues(tab1,4,1);
5437         c=DataArrayInt.New();
5438         tab2=[5,3,0,18,8]
5439         c.setValues(tab2,5,1);
5440         b=a.buildIntersection(c);
5441         self.assertEqual(2,b.getNumberOfTuples());
5442         self.assertEqual(1,b.getNumberOfComponents());
5443         expected1=[3,8]
5444         for i in xrange(2):
5445             self.assertEqual(expected1[i],b.getIJ(0,i));
5446             pass
5447         b=DataArrayInt.BuildIntersection([a,c]);
5448         self.assertEqual(2,b.getNumberOfTuples());
5449         self.assertEqual(1,b.getNumberOfComponents());
5450         expected1=[3,8]
5451         for i in xrange(2):
5452             self.assertEqual(expected1[i],b.getIJ(0,i));
5453             pass
5454         pass
5455
5456     def testDAIDeltaShiftIndex1(self):
5457         a=DataArrayInt.New();
5458         tab=[1,3,6,7,7,9,15]
5459         a.setValues(tab,7,1);
5460         b=a.deltaShiftIndex();
5461         self.assertEqual(6,b.getNumberOfTuples());
5462         self.assertEqual(1,b.getNumberOfComponents());
5463         expected1=[2,3,1,0,2,6]
5464         for i in xrange(6):
5465             self.assertEqual(expected1[i],b.getIJ(0,i));
5466             pass
5467         pass
5468
5469     def testDaDoubleSelectByTupleIdSafe1(self):
5470         a=DataArrayDouble.New();
5471         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]
5472         a.setValues(arr1,7,2);
5473         a.setInfoOnComponent(0,"toto");
5474         a.setInfoOnComponent(1,"tata");
5475         #
5476         arr2=[4,2,0,6,5]
5477         b=a.selectByTupleIdSafe(arr2);
5478         self.assertEqual(5,b.getNumberOfTuples());
5479         self.assertEqual(2,b.getNumberOfComponents());
5480         self.assertTrue(b.getInfoOnComponent(0)=="toto");
5481         self.assertTrue(b.getInfoOnComponent(1)=="tata");
5482         expected1=[5.1,15.1,3.1,13.1,1.1,11.1,7.1,17.1,6.1,16.1]
5483         for i in xrange(10):
5484             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
5485             pass
5486         arr4=[4,-1,0,6,5]
5487         self.assertRaises(InterpKernelException,a.selectByTupleIdSafe,arr4);
5488         arr5=[4,2,0,6,7]
5489         self.assertRaises(InterpKernelException,a.selectByTupleIdSafe,arr5);
5490         #
5491         c=DataArrayInt.New();
5492         arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
5493         c.setValues(arr3,7,2);
5494         c.setInfoOnComponent(0,"toto");
5495         c.setInfoOnComponent(1,"tata");
5496         d=c.selectByTupleIdSafe(arr2);
5497         self.assertEqual(5,d.getNumberOfTuples());
5498         self.assertEqual(2,d.getNumberOfComponents());
5499         self.assertTrue(d.getInfoOnComponent(0)=="toto");
5500         self.assertTrue(d.getInfoOnComponent(1)=="tata");
5501         expected2=[5,15,3,13,1,11,7,17,6,16]
5502         for i in xrange(10):
5503             self.assertEqual(expected2[i],d.getIJ(0,i));
5504             pass
5505         self.assertRaises(InterpKernelException,c.selectByTupleIdSafe,arr4);
5506         self.assertRaises(InterpKernelException,c.selectByTupleIdSafe,arr5);
5507         pass
5508
5509     def testAreCellsIncludedIn1(self):
5510         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5511         pt=[1,3]
5512         m2=m.buildPartOfMySelf(pt,True);
5513         ret,tmp=m.areCellsIncludedIn(m2,0)
5514         self.assertTrue(ret);
5515         self.assertEqual(2,tmp.getNumberOfTuples());
5516         self.assertEqual(1,tmp.getNumberOfComponents());
5517         self.assertEqual(pt[0],tmp.getIJ(0,0));
5518         self.assertEqual(pt[1],tmp.getIJ(0,1));
5519         ret,tmp=m2.areCellsIncludedIn(m,0)
5520         self.assertTrue(not ret);
5521         m3=MEDCouplingUMesh.MergeUMeshesOnSameCoords(m,m2)
5522         c,cI=m3.findCommonCells(2,m.getNumberOfCells())
5523         self.assertTrue(c.isEqual(DataArrayInt([1,5,3,6])))
5524         self.assertTrue(cI.isEqual(DataArrayInt([0,2,4])))
5525         pass
5526
5527     def testSwigErrorProtection1(self):
5528         m=MEDCouplingDataForTest.build3DTargetMesh_1();
5529         m.rotate([0.,0.,0.],[0.3,0.6,1.2],0.37)
5530         m.rotate([0.,0.,0.],[0.3,6,1.2],0.37)
5531         self.assertRaises(InterpKernelException,m.rotate,[0.,0.,0.],(0.3,6,"1.2"),0.37)
5532         self.assertRaises(InterpKernelException,m.rotate,[0.,"0.",0.],[0.3,0.6,1.2],0.37)
5533         self.assertRaises(InterpKernelException,m.rotate,[0.,0.,0.],[0.3,'0.6',1.2],0.37)
5534         m2=m.buildPartOfMySelf([2,5],True)
5535         m3=m.buildPartOfMySelf((2,5),True)
5536         self.assertTrue(m2.isEqual(m3,1e-12))
5537         self.assertRaises(InterpKernelException,m.buildPartOfMySelf,[2,5.],True)
5538         da1=m.getCoords().keepSelectedComponents([1])
5539         da2=m.getCoords().keepSelectedComponents((1,))
5540         self.assertTrue(da1.isEqual(da2,1e-12))
5541         self.assertRaises(InterpKernelException,m.getCoords().keepSelectedComponents,["1"])
5542         pass
5543
5544     def testDAIBuildSubstraction1(self):
5545         a=DataArrayInt.New()
5546         aa=[2,3,6,8,9]
5547         a.setValues(aa,5,1)
5548         b=DataArrayInt.New()
5549         bb=[1,3,5,9,11]
5550         b.setValues(bb,5,1)
5551         self.assertEqual([2,6,8],a.buildSubstraction(b).getValues())
5552         pass
5553
5554     def testBuildOrthogonalField2(self):
5555         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5556         d1=DataArrayInt.New();
5557         d2=DataArrayInt.New();
5558         d3=DataArrayInt.New();
5559         d4=DataArrayInt.New();
5560         m1=m.buildDescendingConnectivity(d1,d2,d3,d4);
5561         #
5562         f1=m1.buildOrthogonalField();
5563         da1=f1.getArray();
5564         self.assertEqual(2,da1.getNumberOfComponents());
5565         self.assertEqual(13,da1.getNumberOfTuples());
5566         #
5567         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.];
5568         for i in xrange(26):
5569             self.assertAlmostEqual(expected1[i],da1.getIJ(0,i),14);
5570             pass
5571         pass
5572
5573     def testSwigErrorProtection2(self):
5574         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5575         coo=m.getCoords()
5576         c=m.getNodalConnectivity()
5577         ci=m.getNodalConnectivityIndex()
5578         del m
5579         self.assertEqual(2,coo.getNumberOfComponents());
5580         self.assertEqual(6,ci.getNumberOfTuples());
5581         self.assertEqual(23,c.getNumberOfTuples());
5582         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5583         f=m.getMeasureField(True)
5584         c=f.getArray()
5585         del f
5586         self.assertEqual(1,c.getNumberOfComponents());
5587         m=MEDCouplingCMesh.New()
5588         x=DataArrayDouble.New()
5589         x.setValues([1.,2.,4.],3,1)
5590         m.setCoordsAt(0,x)
5591         del x
5592         xx=m.getCoordsAt(0)
5593         del m
5594         self.assertEqual(3,xx.getNumberOfTuples());
5595         #
5596         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5597         f=m.getMeasureField(True)
5598         m2=f.getMesh()
5599         del m
5600         del f
5601         self.assertEqual(5,m2.getNumberOfCells());
5602         pass
5603
5604     def testUMInsertNextCell1(self):
5605         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 ]
5606         targetConn=[0,3,4,1, 1,4,2, 4,5,2, 6,7,4,3, 7,8,5,4]
5607         targetMesh=MEDCouplingUMesh.New();
5608         targetMesh.allocateCells(5);
5609         self.assertRaises(InterpKernelException,targetMesh.insertNextCell,NORM_QUAD4,4,targetConn[0:4])
5610         targetMesh.setMeshDimension(2);
5611         targetMesh.insertNextCell(NORM_QUAD4,4,targetConn[0:4])
5612         self.assertRaises(InterpKernelException,targetMesh.insertNextCell,NORM_TETRA4,4,targetConn[0:4])
5613         self.assertRaises(InterpKernelException,targetMesh.insertNextCell,NORM_SEG2,2,targetConn[0:2])
5614         self.assertRaises(InterpKernelException,targetMesh.insertNextCell,NORM_POINT1,1,targetConn[0:1])
5615         targetMesh.insertNextCell(NORM_TRI3,3,targetConn[4:7])
5616         targetMesh.insertNextCell(NORM_TRI3,3,targetConn[7:10])
5617         targetMesh.insertNextCell(NORM_QUAD4,4,targetConn[10:14])
5618         targetMesh.insertNextCell(NORM_QUAD4,4,targetConn[14:18])
5619         targetMesh.finishInsertingCells();
5620         myCoords=DataArrayDouble.New();
5621         myCoords.setValues(targetCoords,9,2);
5622         targetMesh.setCoords(myCoords);
5623         targetMesh.checkCoherency();
5624         pass
5625
5626     def testFieldOperatorDivDiffComp1(self):
5627         m=MEDCouplingDataForTest.build2DTargetMesh_1();
5628         m1,d0,d1,d2,d3=m.buildDescendingConnectivity();
5629         #
5630         f1=m1.buildOrthogonalField();
5631         arr1=[2.,3.,4.,5.,6.,7.,8.,9.,10.,11.,12.,13.,14.]
5632         arr=DataArrayDouble.New();
5633         arr.setValues(arr1,13,1);
5634         f2=MEDCouplingFieldDouble.New(ON_CELLS);
5635         f2.setArray(arr);
5636         f2.setMesh(m1);
5637         f2.checkCoherency();
5638         #
5639         f3=f1/f2;
5640         self.assertRaises(InterpKernelException,f2.__div__,f1)
5641         f3.checkCoherency();
5642         f1/=f2;
5643         #self.assertRaises(InterpKernelException,f2.__idiv__,f1) # mem leaks
5644         self.assertTrue(f1.isEqual(f3,1e-10,1e-10));
5645         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]
5646         for i in xrange(26):
5647             self.assertAlmostEqual(expected1[i],f3.getIJ(0,i),10);
5648             pass
5649         pass
5650
5651     def testDARearrange1(self):
5652         da1=DataArrayInt.New();
5653         da1.alloc(12,1);
5654         da1.iota(0);
5655         #
5656         self.assertEqual(12,da1.getNbOfElems());
5657         self.assertEqual(1,da1.getNumberOfComponents());
5658         self.assertEqual(12,da1.getNumberOfTuples());
5659         da1.rearrange(4);
5660         self.assertEqual(12,da1.getNbOfElems());
5661         self.assertEqual(4,da1.getNumberOfComponents());
5662         self.assertEqual(3,da1.getNumberOfTuples());
5663         for i in xrange(12):
5664             self.assertEqual(i,da1.getIJ(0,i));
5665         #
5666         da1.rearrange(6);
5667         self.assertEqual(12,da1.getNbOfElems());
5668         self.assertEqual(6,da1.getNumberOfComponents());
5669         self.assertEqual(2,da1.getNumberOfTuples());
5670         for i in xrange(12):
5671             self.assertEqual(i,da1.getIJ(0,i));
5672         #
5673         self.assertRaises(InterpKernelException,da1.rearrange,7);
5674         #
5675         da1.rearrange(12);
5676         self.assertEqual(12,da1.getNbOfElems());
5677         self.assertEqual(12,da1.getNumberOfComponents());
5678         self.assertEqual(1,da1.getNumberOfTuples());
5679         for i in xrange(12):
5680             self.assertEqual(i,da1.getIJ(0,i));
5681         #
5682         da1.rearrange(3);
5683         self.assertEqual(12,da1.getNbOfElems());
5684         self.assertEqual(3,da1.getNumberOfComponents());
5685         self.assertEqual(4,da1.getNumberOfTuples());
5686         for i in xrange(12):
5687             self.assertEqual(i,da1.getIJ(0,i));
5688         #double
5689         da2=da1.convertToDblArr();
5690         st=da2.getHiddenCppPointer()
5691         #
5692         self.assertEqual(12,da2.getNbOfElems());
5693         self.assertEqual(3,da2.getNumberOfComponents());
5694         self.assertEqual(4,da2.getNumberOfTuples());
5695         da2.rearrange(4);
5696         self.assertEqual(12,da2.getNbOfElems());
5697         self.assertEqual(4,da2.getNumberOfComponents());
5698         self.assertEqual(3,da2.getNumberOfTuples());
5699         for i in xrange(12):
5700             self.assertAlmostEqual(float(i),da2.getIJ(0,i),14);
5701         #
5702         da2.rearrange(6);
5703         self.assertEqual(12,da2.getNbOfElems());
5704         self.assertEqual(6,da2.getNumberOfComponents());
5705         self.assertEqual(2,da2.getNumberOfTuples());
5706         for i in xrange(12):
5707             self.assertAlmostEqual(float(i),da2.getIJ(0,i),14);
5708         #
5709         self.assertRaises(InterpKernelException,da2.rearrange,7);
5710         #
5711         da2.rearrange(1);
5712         self.assertEqual(st,da2.getHiddenCppPointer())
5713         self.assertEqual(12,da2.getNbOfElems());
5714         self.assertEqual(1,da2.getNumberOfComponents());
5715         self.assertEqual(12,da2.getNumberOfTuples());
5716         for i in xrange(12):
5717             self.assertAlmostEqual(float(i),da2.getIJ(0,i),14);
5718         #
5719         da2.rearrange(3);
5720         self.assertEqual(12,da2.getNbOfElems());
5721         self.assertEqual(3,da2.getNumberOfComponents());
5722         self.assertEqual(4,da2.getNumberOfTuples());
5723         for i in xrange(12):
5724             self.assertAlmostEqual(float(i),da2.getIJ(0,i),14);
5725         pass
5726
5727     def testDARearrange2(self):
5728         da1=DataArrayInt.New();
5729         arr=[1,2,3,2,2,3,5,1,5,5,2,2]
5730         da1.setValues(arr,4,3);
5731         s=da1.getDifferentValues();
5732         expected1=[1,2,3,5]
5733         self.assertEqual(expected1,s);
5734         pass
5735
5736     def testSwigErrorProtection3(self):
5737         da=DataArrayInt.New()
5738         da.setValues([1,2,3,4,0,0,0,0,0,0,0,0],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=DataArrayInt.New()
5743         da.setValues(((1,2,3),(4,4,3),(0,0,0),(0,0,0)),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])[:12],4,3)
5748         self.assertEqual(10*[1]+[2,2],da.getValues())
5749         self.assertEqual(3,da.getNumberOfComponents());
5750         self.assertEqual(4,da.getNumberOfTuples());
5751         #
5752         da=DataArrayDouble.New()
5753         da.setValues([1,2,3.,4,0,0,0,0,0,0,0,0],4,3)
5754         self.assertEqual([1., 2., 3., 4., 0., 0., 0., 0., 0., 0., 0., 0.],da.getValues())
5755         self.assertEqual(3,da.getNumberOfComponents());
5756         self.assertEqual(4,da.getNumberOfTuples());
5757         da=DataArrayDouble.New()
5758         da.setValues(((1,2,3),(4.,4,3),(0,0,0),(0,0,0)),4,3)
5759         self.assertEqual([1., 2., 3., 4., 4., 3., 0., 0., 0., 0., 0., 0.],da.getValues())
5760         self.assertEqual(3,da.getNumberOfComponents());
5761         self.assertEqual(4,da.getNumberOfTuples());
5762         da.setValues((10*[1]+290*[2])[:12],4,3)
5763         self.assertEqual(10*[1.]+[2.,2.],da.getValues())
5764         self.assertEqual(3,da.getNumberOfComponents());
5765         self.assertEqual(4,da.getNumberOfTuples());
5766         pass
5767
5768     def testDAIBuildPermutationArr1(self):
5769         a=DataArrayInt.New()
5770         a.setValues([4,5,6,7,8],5,1)
5771         b=DataArrayInt.New()
5772         b.setValues([5,4,8,6,7],5,1)
5773         c=a.buildPermutationArr(b)
5774         self.assertEqual([1,0,4,2,3],c.getValues())
5775         self.assertTrue(a.isEqualWithoutConsideringStrAndOrder(b))
5776         b.setIJ(0,0,9)
5777         self.assertTrue(not a.isEqualWithoutConsideringStrAndOrder(b))
5778         self.assertRaises(InterpKernelException,a.buildPermutationArr,b)
5779         a.setIJ(3,0,4)
5780         b.setIJ(0,0,5)
5781         b.setIJ(4,0,4)#a==[4,5,6,4,8] and b==[5,4,8,6,4]
5782         self.assertTrue(a.isEqualWithoutConsideringStrAndOrder(b))
5783         c=a.buildPermutationArr(b)
5784         self.assertEqual([1,3,4,2,3],c.getValues())
5785         d=b.convertToDblArr()
5786         expect3=[4,4,5,6,8]
5787         b.sort()
5788         self.assertEqual(expect3,b.getValues())
5789         d.sort()
5790         self.assertEqual(5,d.getNumberOfTuples());
5791         self.assertEqual(1,d.getNumberOfComponents());
5792         for i in xrange(5):
5793             self.assertAlmostEqual(float(expect3[i]),d.getIJ(i,0),14);
5794             pass
5795         pass
5796
5797     def testAreCellsIncludedIn2(self):
5798         myName="Vitoo";
5799         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
5800         m2=m.buildPartOfMySelf([],True);
5801         self.assertEqual(0,m2.getNumberOfCells());
5802         self.assertEqual(3,m2.getSpaceDimension());
5803         self.assertEqual(2,m2.getMeshDimension());
5804         m2.setName(myName);
5805         test,tmp=m.areCellsIncludedIn(m2,0)
5806         self.assertTrue(test);
5807         self.assertEqual(myName,tmp.getName());
5808         self.assertEqual(0,tmp.getNumberOfTuples())
5809         self.assertEqual(1,tmp.getNumberOfComponents())
5810         pass
5811
5812     def testUMeshGetPartBarycenterAndOwner1(self):
5813         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5814         part1=[1,0,4];
5815         part=DataArrayInt.New();
5816         part.setValues(part1,3,1);
5817         b=m1.getPartBarycenterAndOwner(part);
5818         self.assertEqual(2,b.getNumberOfComponents());
5819         self.assertEqual(3,b.getNumberOfTuples());
5820         expected1=[0.36666666666666665,-0.13333333333333333,-0.05,-0.05,0.45,0.45];
5821         for i in xrange(6):
5822             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
5823             pass
5824         pass
5825
5826     def testUMeshGetPartMeasureField1(self):
5827         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5828         part1=[1,0,4];
5829         part=DataArrayInt.New();
5830         part.setValues(part1,3,1);
5831         b=m1.getPartMeasureField(True,part);
5832         self.assertEqual(1,b.getNumberOfComponents());
5833         self.assertEqual(3,b.getNumberOfTuples());
5834         expected1=[0.125,0.25,0.25];
5835         for i in xrange(3):
5836             self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14);
5837             pass
5838         pass
5839
5840     def testUMeshBuildPartOrthogonalField1(self):
5841         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5842         m1.changeSpaceDimension(3);
5843         part1=[1,0,4];
5844         part=DataArrayInt.New();
5845         part.setValues(part1,3,1);
5846         b=m1.buildPartOrthogonalField(part);
5847         self.assertEqual(3,b.getArray().getNumberOfComponents());
5848         self.assertEqual(3,b.getArray().getNumberOfTuples());
5849         expected1=[0.,0.,-1.,0.,0.,-1.,0.,0.,-1.];
5850         for i in xrange(9):
5851             self.assertAlmostEqual(expected1[i],b.getArray().getIJ(0,i),14);
5852             pass
5853         pass
5854
5855     def testUMeshGetTypesOfPart1(self):
5856         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5857         part1=[0,3,4];
5858         p1=DataArrayInt.New()
5859         p1.setValues(part1,3,1)
5860         s=m1.getTypesOfPart(p1);
5861         self.assertEqual([NORM_QUAD4],s);
5862         part2=[2,2,2,1];
5863         p2=DataArrayInt.New()
5864         p2.setValues(part2,4,1)
5865         s=m1.getTypesOfPart(p2);
5866         self.assertEqual([NORM_TRI3],s);
5867         part3=[3,2,1];
5868         p3=DataArrayInt.New()
5869         p3.setValues(part3,3,1)
5870         s=m1.getTypesOfPart(p3);
5871         self.assertEqual(s,[NORM_TRI3,NORM_QUAD4]);
5872         pass
5873
5874     def testUMeshKeepCellIdsByType1(self):
5875         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
5876         part1=[0,3,4]
5877         p1=DataArrayInt.New()
5878         p1.setValues(part1,3,1)
5879         p1.setName("p1")
5880         a=m1.keepCellIdsByType(NORM_TRI3,p1);
5881         self.assertEqual("p1",a.getName())
5882         self.assertEqual(1,a.getNumberOfComponents());
5883         self.assertEqual(0,a.getNumberOfTuples());
5884         #
5885         part2=[3,2,0,2,4]
5886         p2=DataArrayInt.New()
5887         p2.setValues(part2,5,1)
5888         p2.setName("p2")
5889         a=m1.keepCellIdsByType(NORM_TRI3,p2);
5890         self.assertEqual("p2",a.getName())
5891         self.assertEqual(1,a.getNumberOfComponents());
5892         self.assertEqual(2,a.getNumberOfTuples());
5893         self.assertEqual(2,a.getIJ(0,0));
5894         self.assertEqual(2,a.getIJ(1,0));
5895         #
5896         a=m1.keepCellIdsByType(NORM_QUAD4,p2);
5897         self.assertEqual("p2",a.getName())
5898         self.assertEqual(1,a.getNumberOfComponents());
5899         self.assertEqual(3,a.getNumberOfTuples());
5900         self.assertEqual(3,a.getIJ(0,0));
5901         self.assertEqual(0,a.getIJ(1,0));
5902         self.assertEqual(4,a.getIJ(2,0));
5903         pass
5904
5905     def testSwigErrorDaIntSelectByTupleId1(self):
5906         a=DataArrayInt.New();
5907         arr1=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
5908         a.setValues(arr1,7,2);
5909         a.setInfoOnComponent(0,"toto");
5910         a.setInfoOnComponent(1,"tata");
5911         #
5912         arr2=[4,2,0,6,5]
5913         b=a.selectByTupleId(arr2);
5914         self.assertEqual(5,b.getNumberOfTuples());
5915         self.assertEqual(2,b.getNumberOfComponents());
5916         self.assertTrue(b.getInfoOnComponent(0)=="toto");
5917         self.assertTrue(b.getInfoOnComponent(1)=="tata");
5918         expected1=[5,15,3,13,1,11,7,17,6,16]
5919         self.assertEqual(expected1,b.getValues())
5920         #
5921         a2=DataArrayInt.New()
5922         a2.setValues(arr2,5,1)
5923         b=a.selectByTupleId(a2);
5924         self.assertEqual(5,b.getNumberOfTuples());
5925         self.assertEqual(2,b.getNumberOfComponents());
5926         self.assertTrue(b.getInfoOnComponent(0)=="toto");
5927         self.assertTrue(b.getInfoOnComponent(1)=="tata");
5928         expected1=[5,15,3,13,1,11,7,17,6,16]
5929         self.assertEqual(expected1,b.getValues())
5930         pass
5931
5932     def testSwigErrorRenum(self):
5933         da=DataArrayDouble.New()
5934         da.setValues([7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.,13.,113.,14.,114.,15.,115.,16.,116.],10,2)
5935         d=DataArrayInt.New()
5936         d.setValues([0,2,3,1,4,5,6,8,7,9],10,1)
5937         da.renumberInPlace(d)
5938         da.renumber(d)
5939         pass
5940
5941     def testSwigGetItem1(self):
5942         da=DataArrayInt.New()
5943         da.alloc(16,3)
5944         da.rearrange(1)
5945         da.iota(7)
5946         da.rearrange(3)
5947         da.setInfoOnComponent(0,"X [m]")
5948         da.setInfoOnComponent(1,"Y [m]")
5949         da.setInfoOnComponent(2,"Z [km]")
5950         da2=da[5:-1]
5951         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())
5952         da2=da[4]
5953         self.assertEqual([19, 20, 21],da2.getValues())
5954         try:
5955             da2=da[4:17]
5956         except InterpKernelException as e:
5957             self.assertTrue(True)
5958         else:
5959             self.assertTrue(False)
5960             pass
5961         da2=da[5:-2,2]
5962         self.assertEqual([24, 27, 30, 33, 36, 39, 42, 45, 48],da2.getValues())
5963         da2=da[5:8,:]
5964         self.assertEqual([22, 23, 24, 25, 26, 27, 28, 29, 30],da2.getValues())
5965         da2=da[:]
5966         self.assertTrue(da2.isEqual(da))
5967         da2=da[:,:]
5968         self.assertTrue(da2.isEqual(da))
5969         try:
5970             da2=da[:,:,:]
5971         except InterpKernelException as e:
5972             self.assertTrue(True)
5973         else:
5974             self.assertTrue(False)
5975             pass
5976         try:
5977             da2=da[5:8,-2]
5978         except InterpKernelException as e:
5979             self.assertTrue(True)
5980         else:
5981             self.assertTrue(False)
5982             pass
5983         da2=da[5:8,:-2]
5984         self.assertEqual([22, 25, 28],da2.getValues())
5985         try:
5986             da2=da[5:-18,2]
5987         except InterpKernelException as e:
5988             self.assertTrue(True)
5989         else:
5990             self.assertTrue(False)
5991             pass
5992         da2=da[5:5,2]
5993         self.assertEqual([],da2.getValues())
5994         pass
5995
5996     def testSwigGetItem2(self):
5997         da=DataArrayDouble.New()
5998         da.alloc(16,3)
5999         da.rearrange(1)
6000         da.iota(7)
6001         da.rearrange(3)
6002         da.setInfoOnComponent(0,"X [m]")
6003         da.setInfoOnComponent(1,"Y [m]")
6004         da.setInfoOnComponent(2,"Z [km]")
6005         da2=da[5:-1]
6006         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())
6007         da2=da[4]
6008         self.assertEqual([19., 20., 21],da2.getValues())
6009         try:
6010             da2=da[4:17]
6011         except InterpKernelException as e:
6012             self.assertTrue(True)
6013         else:
6014             self.assertTrue(False)
6015             pass
6016         da2=da[5:-2,2]
6017         self.assertEqual([24., 27., 30., 33., 36., 39., 42., 45., 48.],da2.getValues())
6018         da2=da[5:8,:]
6019         self.assertEqual([22., 23., 24., 25., 26., 27., 28., 29., 30.],da2.getValues())
6020         da2=da[:]
6021         self.assertTrue(da2.isEqual(da,1e-12))
6022         da2=da[:,:]
6023         self.assertTrue(da2.isEqual(da,1e-12))
6024         try:
6025             da2=da[:,:,:]
6026         except InterpKernelException as e:
6027             self.assertTrue(True)
6028         else:
6029             self.assertTrue(False)
6030             pass
6031         try:
6032             da2=da[5:8,-2]
6033         except InterpKernelException as e:
6034             self.assertTrue(True)
6035         else:
6036             self.assertTrue(False)
6037             pass
6038         da2=da[5:8,:-2]
6039         self.assertEqual([22., 25., 28.],da2.getValues())
6040         try:
6041             da2=da[5:-18,2]
6042         except InterpKernelException as e:
6043             self.assertTrue(True)
6044         else:
6045             self.assertTrue(False)
6046             pass
6047         da2=da[5:5,2]
6048         self.assertEqual([],da2.getValues())
6049         pass
6050
6051     def testSwigSetItem1(self):
6052         da=DataArrayInt.New()
6053         da.alloc(20,1)
6054         da.iota(7)
6055         da.rearrange(5)
6056         da.setInfoOnComponent(0,"X [m]") ; da.setInfoOnComponent(1,"Y [km]") ; da.setInfoOnComponent(2,"Y [m]")
6057         da.setInfoOnComponent(3,"Z [W]") ; da.setInfoOnComponent(4,"ZZ [km]") ;
6058         da[:,2]=3
6059         self.assertEqual([7, 8, 3, 10, 11, 12, 13, 3, 15, 16, 17, 18, 3, 20, 21, 22, 23, 3, 25, 26],da.getValues())
6060         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6061         da[2]=3
6062         self.assertEqual([7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 3, 3, 3, 3, 3, 22, 23, 24, 25, 26],da.getValues())
6063         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6064         da[[0,3]]=-1
6065         self.assertEqual([-1, -1, -1, -1, -1, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, -1, -1, -1, -1, -1],da.getValues())
6066         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6067         da[:,[1,3,4]]=-3
6068         self.assertEqual([7, -3, 9, -3, -3, 12, -3, 14, -3, -3, 17, -3, 19, -3, -3, 22, -3, 24, -3, -3],da.getValues())
6069         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6070         da2=DataArrayInt.New() ; da2.setValues([0,2,3],3,1)
6071         da[da2]=-7
6072         self.assertEqual([-7, -7, -7, -7, -7, 12, 13, 14, 15, 16, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7],da.getValues())
6073         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6074         da[da2,-2:]=-7
6075         self.assertEqual([7, 8, 9, -7, -7, 12, 13, 14, 15, 16, 17, 18, 19, -7, -7, 22, 23, 24, -7, -7],da.getValues())
6076         # Let's test with DAI right hand side
6077         da1=DataArrayInt.New()
6078         da1.setValues([25,26,27,125,126,127],2,3)
6079         #
6080         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6081         da[-2:,1:4]=da1
6082         self.assertEqual([7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 25, 26, 27, 21, 22, 125, 126, 127, 26],da.getValues())
6083         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6084         da[1:,3]=[225,226,227]
6085         self.assertEqual([7, 8, 9, 10, 11, 12, 13, 14, 225, 16, 17, 18, 19, 226, 21, 22, 23, 24, 227, 26],da.getValues())
6086         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6087         da[1,2:]=[225,226,227]
6088         self.assertEqual([7, 8, 9, 10, 11, 12, 13, 225, 226, 227, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26],da.getValues())
6089         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6090         da[da2,-2:]=[88,99,1010,1111,1212,1313]
6091         self.assertEqual([7, 8, 9, 88, 99, 12, 13, 14, 15, 16, 17, 18, 19, 1010, 1111, 22, 23, 24, 1212, 1313],da.getValues())
6092         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6093         da3=DataArrayInt.New(); da3.setValues([88,99,1010,1111,1212,1313],3,2)
6094         da[da2,-2:]=da3
6095         self.assertEqual([7, 8, 9, 88, 99, 12, 13, 14, 15, 16, 17, 18, 19, 1010, 1111, 22, 23, 24, 1212, 1313],da.getValues())
6096         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6097         da[da2,[0,2]]=da3
6098         self.assertEqual([88, 8, 99, 10, 11, 12, 13, 14, 15, 16, 1010, 18, 1111, 20, 21, 1212, 23, 1313, 25, 26],da.getValues())
6099         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6100         da[da2,0:3:2]=da3
6101         self.assertEqual([88, 8, 99, 10, 11, 12, 13, 14, 15, 16, 1010, 18, 1111, 20, 21, 1212, 23, 1313, 25, 26],da.getValues())
6102         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6103         da[da2,0:3:2]=-8
6104         self.assertEqual([-8, 8, -8, 10, 11, 12, 13, 14, 15, 16, -8, 18, -8, 20, 21, -8, 23, -8, 25, 26],da.getValues())
6105         pass
6106
6107     def testSwigSetItem2(self):
6108         da=DataArrayDouble.New()
6109         da.alloc(20,1)
6110         da.iota(7)
6111         da.rearrange(5)
6112         da.setInfoOnComponent(0,"X [m]") ; da.setInfoOnComponent(1,"Y [km]") ; da.setInfoOnComponent(2,"Y [m]")
6113         da.setInfoOnComponent(3,"Z [W]") ; da.setInfoOnComponent(4,"ZZ [km]") ;
6114         da[:,2]=3.
6115         self.assertEqual([7., 8., 3., 10., 11., 12., 13., 3., 15., 16., 17., 18., 3., 20., 21., 22., 23., 3., 25., 26.],da.getValues())
6116         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6117         da[2]=3.
6118         self.assertEqual([7., 8., 9., 10., 11., 12., 13., 14., 15., 16., 3., 3., 3., 3., 3., 22., 23., 24., 25., 26.],da.getValues())
6119         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6120         da[[0,3]]=-1.
6121         self.assertEqual([-1., -1., -1., -1., -1., 12., 13., 14., 15., 16., 17., 18., 19., 20., 21., -1., -1., -1., -1., -1.],da.getValues())
6122         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6123         da[:,[1,3,4]]=-3.
6124         self.assertEqual([7., -3., 9., -3., -3., 12., -3., 14., -3., -3., 17., -3., 19., -3., -3., 22., -3., 24., -3., -3.],da.getValues())
6125         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6126         da2=DataArrayInt.New() ; da2.setValues([0,2,3],3,1)
6127         da[da2]=-7.
6128         self.assertEqual([-7., -7., -7., -7., -7., 12., 13., 14., 15., 16., -7., -7., -7., -7., -7., -7., -7., -7., -7., -7.],da.getValues())
6129         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6130         da[da2,-2:]=-7
6131         self.assertEqual([7., 8., 9., -7., -7., 12., 13., 14., 15., 16., 17., 18., 19., -7., -7., 22., 23., 24., -7., -7.],da.getValues())
6132         # Let's test with DAI right hand side
6133         da1=DataArrayDouble.New()
6134         da1.setValues([25,26,27,125,126,127],2,3)
6135         #
6136         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6137         da[-2:,1:4]=da1
6138         self.assertEqual([7., 8., 9., 10., 11., 12., 13., 14., 15., 16., 17., 25., 26., 27., 21., 22., 125., 126., 127., 26.],da.getValues())
6139         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6140         da[1:,3]=[225.,226.,227.]
6141         self.assertEqual([7., 8., 9., 10., 11., 12., 13., 14., 225., 16., 17., 18., 19., 226., 21., 22., 23., 24., 227., 26.],da.getValues())
6142         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6143         da[1,2:]=[225,226,227]
6144         self.assertEqual([7., 8., 9., 10., 11., 12., 13., 225., 226., 227., 17., 18., 19., 20., 21., 22., 23., 24., 25., 26.],da.getValues())
6145         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6146         da[da2,-2:]=[88,99,1010,1111,1212,1313]
6147         self.assertEqual([7., 8., 9., 88., 99., 12., 13., 14., 15., 16., 17., 18., 19., 1010., 1111., 22., 23., 24., 1212., 1313.],da.getValues())
6148         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6149         da3=DataArrayDouble.New(); da3.setValues([88,99,1010,1111,1212,1313],3,2)
6150         da[da2,-2:]=da3
6151         self.assertEqual([7., 8., 9., 88., 99., 12., 13., 14., 15., 16., 17., 18., 19., 1010., 1111., 22., 23., 24., 1212., 1313.],da.getValues())
6152         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6153         da[da2,[0,2]]=da3
6154         self.assertEqual([88., 8., 99., 10., 11., 12., 13., 14., 15., 16., 1010., 18., 1111., 20., 21., 1212., 23., 1313., 25., 26.],da.getValues())
6155         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6156         da[da2,0:3:2]=da3
6157         self.assertEqual([88., 8., 99., 10., 11., 12., 13., 14., 15., 16., 1010., 18., 1111., 20., 21., 1212., 23., 1313., 25., 26.],da.getValues())
6158         da.rearrange(1) ; da.iota(7) ; da.rearrange(5)
6159         da[da2,0:3:2]=-8.
6160         self.assertEqual([-8., 8., -8., 10., 11., 12., 13., 14., 15., 16., -8., 18., -8., 20., 21., -8., 23., -8., 25., 26.],da.getValues())
6161         pass
6162
6163     def testSwigDADOp(self):
6164         da=DataArrayDouble.New()
6165         da.alloc(12,1)
6166         da.iota(7.)
6167         da1=DataArrayDouble.New()
6168         da1.alloc(12,1)
6169         da1.iota(8.)
6170         da2=da+da1
6171         self.assertEqual([15., 17., 19., 21., 23., 25., 27., 29., 31., 33., 35., 37.],da2.getValues())
6172         da2=da+3
6173         da3=3+da
6174         self.assertTrue(da2.isEqual(da3,1e-12))
6175         da2=da-1.
6176         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())
6177         da2=1-da
6178         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())
6179         da2=da*3
6180         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())
6181         da2=3.*da
6182         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())
6183         da2=da*da1
6184         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())
6185         da2=da/4.
6186         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())
6187         da3=4./da
6188         da4=da3*da2
6189         self.assertTrue(da4.isUniform(1.,1e-12))
6190         st1=da.getHiddenCppPointer()
6191         da+=1
6192         st2=da.getHiddenCppPointer()
6193         self.assertEqual(st1,st2)
6194         self.assertTrue(da.isEqual(da1,1e-12))
6195         da-=8
6196         st2=da.getHiddenCppPointer()
6197         self.assertEqual(st1,st2)
6198         self.assertEqual(range(12),da.getValues())
6199         da+=da1
6200         st2=da.getHiddenCppPointer()
6201         self.assertEqual(st1,st2)
6202         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())
6203         da*=0.5
6204         st2=da.getHiddenCppPointer()
6205         self.assertEqual(st1,st2)
6206         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())
6207         da*=da1
6208         st2=da.getHiddenCppPointer()
6209         self.assertEqual(st1,st2)
6210         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())
6211         da/=da1
6212         self.assertEqual(st1,st2)
6213         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())
6214         da/=2
6215         st2=da.getHiddenCppPointer()
6216         self.assertEqual(st1,st2)
6217         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())
6218         da.rearrange(3)
6219         da5=DataArrayDouble.New()
6220         da5.setValues([5.,4.,3.,2.],4,1)
6221         da*=da5 # it works with unmathing number of compo
6222         st2=da.getHiddenCppPointer()
6223         self.assertEqual(st1,st2)
6224         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())
6225         #
6226         da.alloc(30,1)
6227         da.iota(7.)
6228         da.rearrange(3)
6229         ids=DataArrayInt.New()
6230         ids.setValues([3,4,7],3,1)
6231         da[ids,:]=[5.,8.,9.]
6232         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())
6233         #
6234         da.rearrange(1) ; da.iota(7) ; da.rearrange(3)
6235         da[ids,[1,2]]=[5,8]
6236         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())
6237         pass
6238
6239     def testSwigDAIOp(self):
6240         da=DataArrayInt.New()
6241         da.alloc(12,1)
6242         da.iota(7)
6243         da1=DataArrayInt.New()
6244         da1.alloc(12,1)
6245         da1.iota(8)
6246         da2=da+da1
6247         self.assertEqual([15,17,19,21,23,25,27,29,31,33,35,37],da2.getValues())
6248         da2=da+3
6249         da3=3+da
6250         self.assertTrue(da2.isEqual(da3))
6251         da2=da-1
6252         self.assertEqual([6,7,8,9,10,11,12,13,14,15,16,17],da2.getValues())
6253         da2=1-da
6254         self.assertEqual([-6,-7,-8,-9,-10,-11,-12,-13,-14,-15,-16,-17],da2.getValues())
6255         da2=da*3
6256         self.assertEqual([21,24,27,30,33,36,39,42,45,48,51,54.0],da2.getValues())
6257         da2=3*da
6258         self.assertEqual([21,24,27,30,33,36,39,42,45,48,51,54.0],da2.getValues())
6259         da2=da*da1
6260         self.assertEqual([56,72,90,110,132,156,182,210,240,272,306,342.0],da2.getValues())
6261         da2=da/4
6262         self.assertEqual([1,2,2,2,2,3,3,3,3,4,4,4],da2.getValues())
6263         da3=4/da
6264         da4=da3*da2
6265         self.assertTrue(da4.isUniform(0))
6266         st1=da.getHiddenCppPointer()
6267         da+=1
6268         st2=da.getHiddenCppPointer()
6269         self.assertEqual(st1,st2)
6270         self.assertTrue(da.isEqual(da1))
6271         da-=8
6272         st2=da.getHiddenCppPointer()
6273         self.assertEqual(st1,st2)
6274         self.assertEqual(range(12),da.getValues())
6275         da+=da1
6276         st2=da.getHiddenCppPointer()
6277         self.assertEqual(st1,st2)
6278         self.assertEqual([8,10,12,14,16,18,20,22,24,26,28,30],da.getValues())
6279         da/=2
6280         st2=da.getHiddenCppPointer()
6281         self.assertEqual(st1,st2)
6282         self.assertEqual([4,5,6,7,8,9,10,11,12,13,14,15],da.getValues())
6283         da*=da1
6284         st2=da.getHiddenCppPointer()
6285         self.assertEqual(st1,st2)
6286         self.assertEqual([32,45,60,77,96,117,140,165,192,221,252,285],da.getValues())
6287         da/=da1
6288         self.assertEqual(st1,st2)
6289         self.assertEqual([4,5,6,7,8,9,10,11,12,13,14,15],da.getValues())
6290         da/=2
6291         st2=da.getHiddenCppPointer()
6292         self.assertEqual(st1,st2)
6293         self.assertEqual([2,2, 3,3, 4,4, 5,5, 6,6, 7,7],da.getValues())
6294         da.rearrange(3)
6295         da5=DataArrayInt.New()
6296         da5.setValues([5,4,3,2],4,1)
6297         da*=da5 # it works with unmathing number of compo
6298         st2=da.getHiddenCppPointer()
6299         self.assertEqual(st1,st2)
6300         self.assertEqual([10,10, 15,12,16,16,15,15, 18,12,14,14],da.getValues())
6301         da%=6
6302         st2=da.getHiddenCppPointer()
6303         self.assertEqual(st1,st2)
6304         self.assertEqual([4,4,3,0,4,4,3,3,0,0,2,2],da.getValues())
6305         #
6306         da.alloc(30,1)
6307         da.iota(7)
6308         da.rearrange(3)
6309         ids=DataArrayInt.New()
6310         ids.setValues([3,4,7],3,1)
6311         da[ids,:]=[5,8,9]
6312         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())
6313         #
6314         da.rearrange(1) ; da.iota(7) ; da.rearrange(3)
6315         da[ids,[1,2]]=[5,8]
6316         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())
6317         pass
6318
6319     def testSwigDAIOp2(self):
6320         da=DataArrayInt.New()
6321         st=da.getHiddenCppPointer()
6322         da.alloc(10,3)
6323         da.rearrange(1)
6324         da.iota(0)
6325         da.rearrange(3)
6326         da[:,1]+=4
6327         da[-2:,2]+=10
6328         da[-2:,2]+=10
6329         da[:,2]+=da[:,0]
6330         da[da[0],:]=7
6331         self.assertEqual(st,da.getHiddenCppPointer())
6332         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])
6333         pass
6334
6335     def testSwigDAIOp3(self):
6336         da=DataArrayInt.New()
6337         self.assertRaises(InterpKernelException,da.__len__)
6338         self.assertRaises(InterpKernelException,da.__int__)
6339         for elt in da:
6340             self.assertTrue(False)
6341             pass
6342         da.alloc(12,3)
6343         da.rearrange(1) ; da.fillWithZero()
6344         l1=list(da)
6345         self.assertEqual(36,len(da));
6346         da.rearrange(3)
6347         tmp=da[0]
6348         self.assertRaises(InterpKernelException,tmp.__int__)
6349         self.assertEqual(12,len(da));
6350         l=list(da)
6351         for elt in enumerate(l):
6352             elt[1][2]=elt[0]
6353             pass
6354         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]
6355         self.assertEqual(ref,da.getValues());
6356         da.rearrange(1)
6357         l=[int(elt) for elt in l1]
6358         self.assertEqual(ref,da.getValues());
6359         self.assertEqual(11,int(da[-1:]))
6360         pass
6361
6362     def testSwigDADOp3(self):
6363         da=DataArrayDouble.New()
6364         self.assertRaises(InterpKernelException,da.__len__)
6365         self.assertRaises(InterpKernelException,da.__float__)
6366         for elt in da:
6367             self.assertTrue(False)
6368             pass
6369         da.alloc(12,3)
6370         da.rearrange(1) ; da.fillWithZero()
6371         l1=list(da)
6372         self.assertEqual(36,len(da));
6373         da.rearrange(3)
6374         tmp=da[0]
6375         self.assertRaises(InterpKernelException,tmp.__float__)
6376         self.assertEqual(12,len(da));
6377         l=list(da)
6378         for elt in enumerate(l):
6379             elt[1][2]=elt[0]
6380             pass
6381         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.]
6382         self.assertEqual(ref,da.getValues());
6383         da.rearrange(1)
6384         l=[float(elt) for elt in l1]
6385         self.assertEqual(ref,da.getValues());
6386         self.assertEqual(11.,float(da[-1:]))
6387         pass
6388
6389     def testSwigDataArrayIntIterator1(self):
6390         da=DataArrayInt.New()
6391         da.alloc(12,1)
6392         da.iota(2)
6393         da.rearrange(3)
6394         # __getitem__ testing
6395         li=[]
6396         for it in da:
6397             li+=it[1:]
6398             pass
6399         self.assertEqual([3, 4, 6, 7, 9, 10, 12, 13],li)
6400         li=[]
6401         for it in da:
6402             li+=[it[-1]]
6403             pass
6404         self.assertEqual([4, 7, 10, 13],li)
6405         li=[]
6406         for it in da:
6407             li+=it[[2,1,0]]
6408             pass
6409         self.assertEqual([4, 3, 2, 7, 6, 5, 10, 9, 8, 13, 12, 11],li)
6410         # __setitem__ testing
6411         da3=da.deepCpy()
6412         da2=DataArrayInt.New()
6413         da2.alloc(12,1)
6414         da2.iota(2002)
6415         da2.rearrange(3)
6416         it2=da2.__iter__()
6417         i=0
6418         for it in da:
6419             pt=it2.next()
6420             it[:]=pt
6421             pass
6422         self.assertTrue(da.isEqual(da2))
6423         da=da3
6424         da3=da.deepCpy()
6425         #
6426         for it in da:
6427             it[:]=5
6428             pass
6429         da.rearrange(1)
6430         self.assertTrue(da.isUniform(5))
6431         da=da3
6432         da3=da.deepCpy()
6433         #
6434         for it in da:
6435             it[:]=[8,9,12]
6436             pass
6437         self.assertEqual([8, 9, 12, 8, 9, 12, 8, 9, 12, 8, 9, 12],da.getValues())
6438         da=da3
6439         da3=da.deepCpy()
6440         #
6441         for it in da:
6442             it[2]=[7]
6443             pass
6444         self.assertEqual([2, 3, 7, 5, 6, 7, 8, 9, 7, 11, 12, 7],da.getValues())
6445         pass
6446
6447     def testSwigDataArrayDoubleIterator1(self):
6448         da=DataArrayDouble.New()
6449         da.alloc(12,1)
6450         da.iota(2)
6451         da.rearrange(3)
6452         # __getitem__ testing
6453         li=[]
6454         for it in da:
6455             li+=it[1:]
6456             pass
6457         self.assertEqual([3, 4, 6, 7, 9, 10, 12, 13],li)
6458         li=[]
6459         for it in da:
6460             li+=[it[-1]]
6461             pass
6462         self.assertEqual([4, 7, 10, 13],li)
6463         li=[]
6464         for it in da:
6465             li+=it[[2,1,0]]
6466             pass
6467         self.assertEqual([4, 3, 2, 7, 6, 5, 10, 9, 8, 13, 12, 11],li)
6468         # __setitem__ testing
6469         da3=da.deepCpy()
6470         da2=DataArrayDouble.New()
6471         da2.alloc(12,1)
6472         da2.iota(2002)
6473         da2.rearrange(3)
6474         it2=da2.__iter__()
6475         i=0
6476         for it in da:
6477             pt=it2.next()
6478             it[:]=pt
6479             pass
6480         self.assertTrue(da.isEqual(da2,1e-12))
6481         da=da3
6482         da3=da.deepCpy()
6483         #
6484         for it in da:
6485             it[:]=5
6486             pass
6487         da.rearrange(1)
6488         self.assertTrue(da.isUniform(5,1e-12))
6489         da=da3
6490         da3=da.deepCpy()
6491         #
6492         for it in da:
6493             it[:]=[8,9,12]
6494             pass
6495         self.assertEqual([8, 9, 12, 8, 9, 12, 8, 9, 12, 8, 9, 12],da.getValues())
6496         da=da3
6497         da3=da.deepCpy()
6498         #
6499         for it in da:
6500             it[2]=[7]
6501             pass
6502         self.assertEqual([2, 3, 7, 5, 6, 7, 8, 9, 7, 11, 12, 7],da.getValues())
6503         pass
6504
6505     def testSwigUMeshIterator1(self):
6506         m=MEDCouplingDataForTest.build2DTargetMesh_1()
6507         li1=[]
6508         li2=[]
6509         for cell in m:
6510             li1+=cell.getAllConn()[1:]
6511             li2+=[cell.getType()]
6512             pass
6513         self.assertEqual(li1,[0, 3, 4, 1, 1, 4, 2, 4, 5, 2, 6, 7, 4, 3, 7, 8, 5, 4])
6514         self.assertEqual(li2,[4, 3, 3, 4, 4])
6515         pass
6516
6517     def testSwigUMeshIterator2(self):
6518         m=MEDCouplingDataForTest.build2DTargetMesh_1()
6519         self.assertRaises(InterpKernelException,m.cellsByType);
6520         m.rearrange2ConsecutiveCellTypes()
6521         li1=[]
6522         li2=[]
6523         li3=[]
6524         for cellsByType in m.cellsByType():
6525             li1.append(cellsByType.getType())
6526             li2.append(cellsByType.getNumberOfElems())
6527             temp=[]
6528             for cell in cellsByType:
6529                 t=[None,None]
6530                 t[0]=cell.getType()
6531                 t[1]=cell.getAllConn()[1:]
6532                 temp.append(t)
6533                 pass
6534             li3.append(temp)
6535             pass
6536         self.assertEqual(li1,[4, 3])
6537         self.assertEqual(li2,[3, 2])
6538         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)]]])
6539         pass
6540
6541     def testDAIAggregateMulti1(self):
6542         a=DataArrayInt.New()
6543         a.setValues(range(4),2,2)
6544         a.setName("aa")
6545         b=DataArrayInt.New()
6546         b.setValues(range(6),3,2)
6547         c=DataArrayInt.Aggregate([a,b])
6548         self.assertEqual(range(4)+range(6),c.getValues())
6549         self.assertEqual("aa",c.getName())
6550         self.assertEqual(5,c.getNumberOfTuples())
6551         self.assertEqual(2,c.getNumberOfComponents())
6552         pass
6553
6554     def testMergeUMeshes2(self):
6555         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6556         m2=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6557         m3=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6558         #
6559         vec1=[0,2,3]
6560         m2_2=m2.buildPartOfMySelf(vec1,False);
6561         vec2=[1,1]
6562         m3_2=m3.buildPartOfMySelf(vec2,False);
6563         #
6564         ms=[m1,m2_2,m3_2];
6565         #
6566         self.assertRaises(InterpKernelException,MEDCouplingUMesh.MergeUMeshes,ms+[None]);
6567         self.assertRaises(InterpKernelException,MEDCouplingUMesh.MergeUMeshes,ms+[3.4])
6568         m4=MEDCouplingUMesh.MergeUMeshes(ms);
6569         m4.checkCoherency();
6570         self.assertEqual(10,m4.getNumberOfCells());
6571         self.assertEqual(20,m4.getNumberOfNodes());
6572         self.assertEqual(45,m4.getMeshLength());
6573         m4bis=MEDCouplingMesh.MergeMeshes(ms);
6574         self.assertTrue(m4.isEqual(m4bis,1e-12))
6575         del m4bis
6576         #
6577         vec3=[0,1,2,3,4]
6578         m4_1=m4.buildPartOfMySelf(vec3,False);
6579         m4_1.setName(m1.getName());
6580         self.assertTrue(m4_1.isEqual(m1,1e-12));
6581         #
6582         vec4=[5,6,7]
6583         m4_2=m4.buildPartOfMySelf(vec4,False);
6584         cellCor,nodeCor=m4_2.checkGeoEquivalWith(m2_2,10,1e-12);
6585         #
6586         vec5=[8,9]
6587         m4_3=m4.buildPartOfMySelf(vec5,False);
6588         self.assertEqual(2,m4_3.getNumberOfCells());
6589         self.assertEqual(3,m4_3.getNumberOfNodes());
6590         m3_2.zipCoords();
6591         m4_3.setName(m3_2.getName());
6592         self.assertTrue(m4_3.isEqual(m3_2,1e-12));
6593         #
6594         pass
6595
6596     def testBuild0DMeshFromCoords1(self):
6597         sourceCoords=[-0.3,-0.3,0., 0.7,-0.3,0., -0.3,0.7,0., 0.7,0.7,0.]
6598         coo=DataArrayDouble.New();
6599         coo.setValues(sourceCoords,4,3);
6600         coo.setName("My0D");
6601         m=MEDCouplingUMesh.Build0DMeshFromCoords(coo);
6602         m.checkCoherency();
6603         self.assertEqual(4,m.getNumberOfNodes());
6604         self.assertEqual(4,m.getNumberOfCells());
6605         self.assertEqual(3,m.getSpaceDimension());
6606         self.assertEqual(0,m.getMeshDimension());
6607         types1=m.getAllTypes();
6608         self.assertEqual([NORM_POINT1],types1);
6609         for i in xrange(4):
6610             conn=m.getNodeIdsOfCell(i);
6611             self.assertEqual([i],conn);
6612             self.assertTrue(NORM_POINT1==m.getTypeOfCell(i));
6613             pass
6614         self.assertEqual(m.getName(),"My0D");
6615         pass
6616
6617     def testDescriptionInMeshTimeUnit1(self):
6618         text1="totoTTEDD";
6619         m=MEDCouplingDataForTest.build2DTargetMesh_1();
6620         m.setDescription(text1);
6621         self.assertEqual(m.getDescription(),text1);
6622         m2=m.deepCpy();
6623         self.assertTrue(m.isEqual(m2,1e-12));
6624         self.assertEqual(m2.getDescription(),text1);
6625         m2.setDescription("ggg");
6626         self.assertTrue(not m.isEqual(m2,1e-12));
6627         #
6628         f=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
6629         f.setTimeUnit(text1);
6630         self.assertEqual(f.getTimeUnit(),text1);
6631         f2=f.deepCpy();
6632         self.assertEqual(f2.getTimeUnit(),text1);
6633         #
6634         pass
6635
6636     def testMultiFields1(self):
6637         mfs=MEDCouplingDataForTest.buildMultiFields_1();
6638         ms=mfs.getMeshes();
6639         dms,refs=mfs.getDifferentMeshes()
6640         das=mfs.getArrays();
6641         das2,refs2=mfs.getDifferentArrays()
6642         self.assertEqual(5,len(mfs.getFields()))
6643         self.assertEqual(1,len(mfs.getFields()[0].getArrays()));
6644         self.assertEqual(2,len(mfs.getFields()[1].getArrays()));
6645         self.assertEqual(1,len(mfs.getFields()[2].getArrays()));
6646         self.assertEqual(1,len(mfs.getFields()[3].getArrays()));
6647         self.assertEqual(1,len(mfs.getFields()[4].getArrays()));
6648         self.assertEqual(5,len(ms));
6649         self.assertEqual(2,len(dms));
6650         self.assertEqual(6,len(das));
6651         self.assertEqual(5,len(das2));
6652         mfs2=mfs.deepCpy();
6653         self.assertTrue(mfs.isEqual(mfs2,1e-12,1e-12))
6654         pass
6655
6656     def testFieldOverTime1(self):
6657         fs=MEDCouplingDataForTest.buildMultiFields_2();
6658         self.assertRaises(InterpKernelException,MEDCouplingFieldOverTime.New,fs);
6659         f4bis=fs[4].buildNewTimeReprFromThis(ONE_TIME,False);
6660         fs[4]=f4bis;
6661         self.assertRaises(InterpKernelException,MEDCouplingFieldOverTime.New,fs);
6662         f4bis.setTime(2.7,20,21);
6663         fot=MEDCouplingFieldOverTime.New(fs);
6664         dt=fot.getDefinitionTimeZone();
6665         hs=dt.getHotSpotsTime();
6666         self.assertEqual(6,len(hs));
6667         expected1=[0.2,0.7,1.2,1.35,1.7,2.7]
6668         for i in xrange(6):
6669             self.assertAlmostEqual(expected1[i],hs[i],12);
6670             pass
6671         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(0.2);
6672         self.assertEqual(0,meshId);
6673         self.assertEqual(0,arrId);
6674         self.assertEqual(0,arrIdInField);
6675         self.assertEqual(0,fieldId);
6676         #
6677         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(0.7);
6678         self.assertEqual(0,meshId);
6679         self.assertEqual(1,arrId);
6680         self.assertEqual(0,arrIdInField);
6681         self.assertEqual(1,fieldId);
6682         #
6683         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeLeft(1.2);#**** WARNING left here
6684         self.assertEqual(0,meshId);
6685         self.assertEqual(2,arrId);
6686         self.assertEqual(1,arrIdInField);
6687         self.assertEqual(1,fieldId);
6688         #
6689         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(1.2);#**** WARNING right again here
6690         self.assertEqual(1,meshId);
6691         self.assertEqual(3,arrId);
6692         self.assertEqual(0,arrIdInField);
6693         self.assertEqual(2,fieldId);
6694         #
6695         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(1.35);
6696         self.assertEqual(1,meshId);
6697         self.assertEqual(3,arrId);
6698         self.assertEqual(0,arrIdInField);
6699         self.assertEqual(2,fieldId);
6700         #
6701         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(1.7);
6702         self.assertEqual(0,meshId);
6703         self.assertEqual(3,arrId);
6704         self.assertEqual(0,arrIdInField);
6705         self.assertEqual(3,fieldId);
6706         #
6707         meshId,arrId,arrIdInField,fieldId=dt.getIdsOnTimeRight(2.7);
6708         self.assertEqual(1,meshId);
6709         self.assertEqual(4,arrId);
6710         self.assertEqual(0,arrIdInField);
6711         self.assertEqual(4,fieldId);
6712         #
6713         dt2=MEDCouplingDefinitionTime();
6714         self.assertTrue(not dt2.isEqual(dt));
6715         dt2.assign(dt);
6716         dt2.assign(dt);#to check memory management
6717         self.assertTrue(dt2.isEqual(dt));
6718         #
6719         dt3=MEDCouplingDefinitionTime();
6720         #
6721         pass
6722
6723     def testDAICheckAndPreparePermutation1(self):
6724         vals1=[9,10,0,6,4,11,3,7];
6725         expect1=[5,6,0,3,2,7,1,4];
6726         vals2=[9,10,0,6,10,11,3,7];
6727         da=DataArrayInt.New();
6728         da.setValues(vals1,8,1);
6729         da2=da.checkAndPreparePermutation();
6730         self.assertEqual(8,da2.getNumberOfTuples());
6731         self.assertEqual(1,da2.getNumberOfComponents());
6732         for i in xrange(8):
6733             self.assertEqual(expect1[i],da2.getIJ(i,0));
6734             pass
6735         #
6736         da=DataArrayInt.New();
6737         da.alloc(8,1);
6738         da.iota(0);
6739         da2=da.checkAndPreparePermutation();
6740         self.assertEqual(8,da2.getNumberOfTuples());
6741         self.assertEqual(1,da2.getNumberOfComponents());
6742         self.assertTrue(da2.isIdentity());
6743         #
6744         da=DataArrayInt.New();
6745         da.alloc(8,1);
6746         da.setValues(vals2,8,1);
6747         self.assertRaises(InterpKernelException,da.checkAndPreparePermutation);
6748         pass
6749
6750     def testDAIChangeSurjectiveFormat1(self):
6751         vals1=[0,3,2,3,2,2,1,2]
6752         expected1=[0,1,2,6,8]
6753         expected2=[0,  6,  2,4,5,7,  1,3]
6754         da=DataArrayInt.New();
6755         da.setValues(vals1,8,1);
6756         #
6757         da2,da2I=da.changeSurjectiveFormat(4);
6758         self.assertEqual(5,da2I.getNumberOfTuples());
6759         self.assertEqual(8,da2.getNumberOfTuples());
6760         self.assertEqual(expected1,da2I.getValues());
6761         self.assertEqual(expected2,da2.getValues());
6762         #
6763         self.assertRaises(InterpKernelException,da.changeSurjectiveFormat,3);
6764         #
6765         pass
6766
6767     def testUMeshGetCellIdsLyingOnNodes1(self):
6768         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6769         nodeIds1=[1,2,3,4,6]
6770         nodeIds2=[6,7]
6771         da=m.getCellIdsLyingOnNodes(nodeIds1,True);
6772         self.assertEqual(1,da.getNumberOfTuples());
6773         self.assertEqual(1,da.getNumberOfComponents());
6774         self.assertEqual(1,da.getIJ(0,0));
6775         da2=DataArrayInt.New()
6776         da2.setValues(nodeIds2,2,1)
6777         da=m.getCellIdsLyingOnNodes(da2,False);
6778         self.assertEqual(2,da.getNumberOfTuples());
6779         self.assertEqual(1,da.getNumberOfComponents());
6780         self.assertEqual(3,da.getIJ(0,0));
6781         self.assertEqual(4,da.getIJ(1,0));
6782         pass
6783
6784     def testUMeshFindCellIdsOnBoundary1(self):
6785         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6786         da5=m.findCellIdsOnBoundary();
6787         self.assertEqual(5,da5.getNumberOfTuples());
6788         self.assertTrue(da5.isIdentity());
6789         pass
6790
6791     def testMeshSetTime1(self):
6792         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6793         m2=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6794         #
6795         self.assertTrue(m1.isEqual(m2,1e-12));
6796         m1.setTime(3.14,6,7);
6797         tmp3,tmp1,tmp2=m1.getTime();
6798         self.assertEqual(6,tmp1);
6799         self.assertEqual(7,tmp2);
6800         self.assertAlmostEqual(3.14,tmp3,12);
6801         self.assertTrue(not m1.isEqual(m2,1e-12));
6802         m2.setTime(3.14,6,7);
6803         self.assertTrue(m1.isEqual(m2,1e-12));
6804         m1.setTimeUnit("ms");
6805         self.assertTrue(m1.getTimeUnit()=="ms");
6806         m1.setTimeUnit("us");
6807         self.assertTrue(m1.getTimeUnit()=="us");
6808         self.assertTrue(not m1.isEqual(m2,1e-12));
6809         m2.setTimeUnit("us");
6810         self.assertTrue(m1.isEqual(m2,1e-12));
6811         m2.setTime(3.14,6,8);
6812         self.assertTrue(not m1.isEqual(m2,1e-12));
6813         m2.setTime(3.14,7,7);
6814         self.assertTrue(not m1.isEqual(m2,1e-12));
6815         m2.setTime(3.15,6,7);
6816         self.assertTrue(not m1.isEqual(m2,1e-12));
6817         #
6818         m1.setTime(10.34,55,12);
6819         m3=m1.deepCpy();
6820         self.assertTrue(m1.isEqual(m3,1e-12));
6821         tmp3,tmp1,tmp2=m3.getTime();
6822         self.assertEqual(55,tmp1);
6823         self.assertEqual(12,tmp2);
6824         self.assertAlmostEqual(10.34,tmp3,12);
6825         #
6826         # testing CMesh
6827         coo1=[0.,1.,2.,3.5]
6828         a=DataArrayDouble.New();
6829         a.setValues(coo1,4,1);
6830         b=MEDCouplingCMesh.New();
6831         b.setCoordsAt(0,a);
6832         #
6833         b.setTime(5.67,8,100);
6834         tmp3,tmp1,tmp2=b.getTime();
6835         self.assertEqual(8,tmp1);
6836         self.assertEqual(100,tmp2);
6837         self.assertAlmostEqual(5.67,tmp3,12);
6838         c=b.deepCpy();
6839         self.assertTrue(c.isEqual(b,1e-12));
6840         tmp3,tmp1,tmp2=c.getTime();
6841         self.assertEqual(8,tmp1);
6842         self.assertEqual(100,tmp2);
6843         self.assertAlmostEqual(5.67,tmp3,12);
6844         pass
6845
6846     def testApplyFuncTwo1(self):
6847         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6848         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
6849         f1.setMesh(m1);
6850         #
6851         vals=[1.,11.,21.,2.,12.,22.,3.,13.,23.,4.,14.,24.,5.,15.,25.]
6852         da=DataArrayDouble.New();
6853         da.setValues(vals,5,3);
6854         f1.setArray(da);
6855         #
6856         self.assertRaises(InterpKernelException,da.applyFunc2,1,"y+z");
6857         da.setInfoOnComponent(0,"x [m]");
6858         da.setInfoOnComponent(1,"y [mm]");
6859         da.setInfoOnComponent(2,"z [km]");
6860
6861         self.assertRaises(InterpKernelException, da.applyFunc2, 1, "x+y+zz+zzz");
6862         self.assertRaises(InterpKernelException, da.applyFunc2, 1, "toto(x+y)");
6863         self.assertRaises(InterpKernelException, da.applyFunc2, 1, "x/0");
6864
6865         da2=da.applyFunc2(1,"y+z");
6866         self.assertEqual(1,da2.getNumberOfComponents());
6867         self.assertEqual(5,da2.getNumberOfTuples());
6868         expected1=[32.,34.,36.,38.,40.]
6869         for i in xrange(5):
6870             self.assertAlmostEqual(expected1[i],da2.getIJ(0,i),12);
6871             pass
6872         da2=da.applyFunc(1,"y+z");
6873         expected2=[12.,14.,16.,18.,20.]
6874         for i in xrange(5):
6875             self.assertAlmostEqual(expected2[i],da2.getIJ(0,i),12);
6876             pass
6877         #
6878         self.assertEqual(3,f1.getNumberOfComponents());
6879         self.assertEqual(5,f1.getNumberOfTuples());
6880         f1.applyFunc2(1,"y+z");
6881         self.assertEqual(1,f1.getNumberOfComponents());
6882         self.assertEqual(5,f1.getNumberOfTuples());
6883         for i in xrange(5):
6884             self.assertAlmostEqual(expected1[i],f1.getArray().getIJ(0,i),12);
6885             pass
6886         #
6887         pass
6888
6889     def testApplyFuncThree1(self):
6890         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6891         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
6892         f1.setMesh(m1);
6893         #
6894         vals=[1.,11.,21.,2.,12.,22.,3.,13.,23.,4.,14.,24.,5.,15.,25.]
6895         da=DataArrayDouble.New();
6896         da.setValues(vals,5,3);
6897         f1.setArray(da);
6898         #
6899         vs=3*[None];
6900         vs[0]="x"; vs[1]="Y"; vs[2]="z";
6901         self.assertRaises(InterpKernelException, da.applyFunc3, 1, vs, "y+z");
6902         self.assertRaises(InterpKernelException, da.applyFunc3, 1, vs, "x+Y+z+zz+zzz");
6903         self.assertRaises(InterpKernelException, da.applyFunc3, 1, vs, "x/0");
6904         vs[1]="y";
6905         da2=da.applyFunc3(1,vs,"y+z");
6906         expected1=[32.,34.,36.,38.,40.]
6907         for i in xrange(5):
6908             self.assertAlmostEqual(expected1[i],da2.getIJ(0,i),12);
6909             pass
6910         self.assertRaises(InterpKernelException, da.applyFunc3, 1, ["x","y","z","a"],"x+a")
6911         f1.setArray(da);
6912         self.assertEqual(3,f1.getNumberOfComponents());
6913         self.assertEqual(5,f1.getNumberOfTuples());
6914         f1.applyFunc3(1,vs,"y+z");
6915         self.assertEqual(1,f1.getNumberOfComponents());
6916         self.assertEqual(5,f1.getNumberOfTuples());
6917         for i in xrange(5):
6918             self.assertAlmostEqual(expected1[i],f1.getArray().getIJ(0,i),12);
6919             pass
6920         pass
6921
6922     def testFillFromAnalyticTwo1(self):
6923         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6924         m1.setTime(3.4,5,6); m1.setTimeUnit("us");
6925         self.assertRaises(InterpKernelException,m1.fillFromAnalytic2,ON_NODES,1,"y+z");
6926         m1.getCoords().setInfoOnComponent(0,"x [m]");
6927         m1.getCoords().setInfoOnComponent(1,"y");
6928         m1.getCoords().setInfoOnComponent(2,"z");
6929         f1=m1.fillFromAnalytic2(ON_NODES,1,"y+z");
6930         self.assertAlmostEqual(3.4,f1.getTime()[0],12) ; self.assertEqual(5,f1.getTime()[1]) ; self.assertEqual(6,f1.getTime()[2])
6931         self.assertEqual("us",f1.getTimeUnit())
6932         self.assertEqual(1,f1.getNumberOfComponents());
6933         self.assertEqual(9,f1.getNumberOfTuples());
6934         expected1=[0.2, 0.7, 1.2, 0.7, 1.2, 1.7, 1.2, 1.7, 2.2]
6935         for i in xrange(9):
6936             self.assertAlmostEqual(expected1[i],f1.getArray().getIJ(0,i),12);
6937             pass
6938         pass
6939
6940     def testFillFromAnalyticThree1(self):
6941         m1=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
6942         m1.setTime(3.4,5,6); m1.setTimeUnit("us");
6943         vs=3*[None];
6944         vs[0]="x"; vs[1]="Y"; vs[2]="z";
6945         self.assertRaises(InterpKernelException,m1.fillFromAnalytic3,ON_NODES,1,vs,"y+z");
6946         vs[1]="y";
6947         f1=m1.fillFromAnalytic3(ON_NODES,1,vs,"y+z");
6948         self.assertAlmostEqual(3.4,f1.getTime()[0],12) ; self.assertEqual(5,f1.getTime()[1]) ; self.assertEqual(6,f1.getTime()[2])
6949         self.assertEqual("us",f1.getTimeUnit())
6950         self.assertEqual(1,f1.getNumberOfComponents());
6951         self.assertEqual(9,f1.getNumberOfTuples());
6952         expected1=[0.2, 0.7, 1.2, 0.7, 1.2, 1.7, 1.2, 1.7, 2.2]
6953         for i in xrange(9):
6954             self.assertAlmostEqual(expected1[i],f1.getArray().getIJ(0,i),12);
6955             pass
6956         pass
6957
6958     def testDAUnitVar1(self):
6959         da=DataArrayDouble.New();
6960         da.alloc(1,3);
6961         da.setInfoOnComponent(0,"XPS [m]");
6962         st1=da.getVarOnComponent(0);
6963         self.assertTrue(st1=="XPS");
6964         st2=da.getUnitOnComponent(0);
6965         self.assertTrue(st2=="m");
6966         #
6967         da.setInfoOnComponent(0,"XPS         [m]");
6968         st1=da.getVarOnComponent(0);
6969         self.assertTrue(st1=="XPS");
6970         st2=da.getUnitOnComponent(0);
6971         self.assertTrue(st2=="m");
6972         #
6973         da.setInfoOnComponent(0,"XPP         [m]");
6974         st1=da.getVarOnComponent(0);
6975         self.assertTrue(st1=="XPP");
6976         st2=da.getUnitOnComponent(0);
6977         self.assertTrue(st2=="m");
6978         #
6979         da.setInfoOnComponent(0,"XPP kdep  kefer   [ m  ]");
6980         st1=da.getVarOnComponent(0);
6981         self.assertTrue(st1=="XPP kdep  kefer");
6982         st2=da.getUnitOnComponent(0);
6983         self.assertTrue(st2==" m  ");
6984         #
6985         da.setInfoOnComponent(0,"     XPP k[  dep  k]efer   [ m^ 2/s^3*kJ  ]");
6986         st1=da.getVarOnComponent(0);
6987         self.assertTrue(st1=="     XPP k[  dep  k]efer");
6988         st2=da.getUnitOnComponent(0);
6989         self.assertTrue(st2==" m^ 2/s^3*kJ  ");
6990         #
6991         da.setInfoOnComponent(0,"     XPP kefer   ");
6992         st1=da.getVarOnComponent(0);
6993         self.assertTrue(st1=="     XPP kefer   ");
6994         st2=da.getUnitOnComponent(0);
6995         self.assertTrue(st2=="");
6996         #
6997         da.setInfoOnComponent(0,"temperature( bof)");
6998         st1=da.getVarOnComponent(0);
6999         self.assertTrue(st1=="temperature( bof)");
7000         st2=da.getUnitOnComponent(0);
7001         self.assertTrue(st2=="");
7002         #
7003         da.setInfoOnComponent(0,"kkk [m]");
7004         da.setInfoOnComponent(1,"ppp   [m^2/kJ]");
7005         da.setInfoOnComponent(2,"abcde   [MW/s]");
7006         #
7007         vs=da.getVarsOnComponent();
7008         self.assertEqual(3,len(vs));
7009         self.assertTrue(vs[0]=="kkk");
7010         self.assertTrue(vs[1]=="ppp");
7011         self.assertTrue(vs[2]=="abcde");
7012         vs=da.getUnitsOnComponent();
7013         self.assertEqual(3,len(vs));
7014         self.assertTrue(vs[0]=="m");
7015         self.assertTrue(vs[1]=="m^2/kJ");
7016         self.assertTrue(vs[2]=="MW/s");
7017         pass
7018
7019     def testGaussCoordinates1(self):
7020         #Testing 1D cell types
7021         m1=MEDCouplingDataForTest.build1DMultiTypes_1();
7022         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,ONE_TIME);
7023         f.setMesh(m1);
7024         wg1=[0.3];
7025         gsCoo1=[0.2];
7026         refCoo1=[-1.0,1.0];
7027         f.setGaussLocalizationOnType(NORM_SEG2,refCoo1,gsCoo1,wg1);
7028         wg2=wg1;
7029         gsCoo2=[0.2];
7030         refCoo2=[-1.0,1.0,0.0];
7031         f.setGaussLocalizationOnType(NORM_SEG3,refCoo2,gsCoo2,wg2);
7032         #
7033         resToTest=f.getLocalizationOfDiscr();
7034         self.assertEqual(3,resToTest.getNumberOfComponents());
7035         self.assertEqual(2,resToTest.getNumberOfTuples());
7036         expected1=[0.6,0.6,0.6, 0.6,0.6,0.6]
7037         for i in xrange(6):
7038             self.assertAlmostEqual(expected1[i],resToTest.getIJ(0,i),14);
7039             pass
7040         #
7041         #Testing 2D cell types
7042         m2=MEDCouplingDataForTest.build2DMultiTypes_1();
7043         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,ONE_TIME);
7044         f.setMesh(m2);
7045         wg3=[0.3,0.3];
7046         tria3CooGauss=[ 0.1, 0.8, 0.2, 0.7 ]
7047         gsCoo3=tria3CooGauss
7048         tria3CooRef=[ 0.0, 0.0, 1.0 , 0.0, 0.0, 1.0 ]
7049         refCoo3=tria3CooRef;
7050         f.setGaussLocalizationOnType(NORM_TRI3,refCoo3,gsCoo3,wg3);
7051         wg4=[0.3,0.3,0.3];
7052         tria6CooGauss=[ 0.3, 0.2, 0.2, 0.1, 0.2, 0.4 ]
7053         gsCoo4=tria6CooGauss;
7054         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]
7055         refCoo4=tria6CooRef;
7056         f.setGaussLocalizationOnType(NORM_TRI6,refCoo4,gsCoo4,wg4);
7057         wg5=[0.3,0.3,0.3,0.3];
7058         quad4CooGauss=[ 0.3, 0.2, 0.2, 0.1, 0.2, 0.4, 0.15, 0.27 ]
7059         gsCoo5=quad4CooGauss;
7060         quad4CooRef=[-1.0, 1.0, -1.0, -1.0, 1.0, -1.0, 1.0, 1.0]
7061         refCoo5=quad4CooRef;
7062         f.setGaussLocalizationOnType(NORM_QUAD4,refCoo5,gsCoo5,wg5);
7063         wg6=[0.3,0.3,0.3,0.3];
7064         quad8CooGauss=[ 0.34, 0.16, 0.21, 0.3, 0.23, 0.4, 0.14, 0.37 ]
7065         gsCoo6=quad8CooGauss;
7066         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]
7067         refCoo6=quad8CooRef;
7068         f.setGaussLocalizationOnType(NORM_QUAD8,refCoo6,gsCoo6,wg6);
7069         #
7070         resToTest=f.getLocalizationOfDiscr();
7071         self.assertEqual(3,resToTest.getNumberOfComponents());
7072         self.assertEqual(13,resToTest.getNumberOfTuples());#2+3+4+4 gauss points for resp TRI3,TRI6,QUAD4,QUAD8
7073         expected2=[5.1,1.55,0.0, 4.7,1.65,0.0,
7074                    2.32,1.52,0.0, 1.6,1.32,0.0, 3.52,1.26,0.0,#TRI6
7075                    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
7076                    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
7077         for i in xrange(39):
7078             self.assertAlmostEqual(expected2[i],resToTest.getIJ(0,i),14);
7079             pass
7080         #
7081         #Testing 3D cell types
7082         m3=MEDCouplingDataForTest.build3DMultiTypes_1();
7083         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,ONE_TIME);
7084         f.setMesh(m3);
7085         #
7086         wg7=[0.3];
7087         tetra4CooGauss=[0.34, 0.16, 0.21]
7088         gsCoo7=tetra4CooGauss;
7089         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]
7090         refCoo7=tetra4CooRef;
7091         f.setGaussLocalizationOnType(NORM_TETRA4,refCoo7,gsCoo7,wg7);
7092         wg8=[0.3];
7093         tetra10CooGauss=[0.2, 0.3, 0.1]
7094         gsCoo8=tetra10CooGauss;
7095         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]
7096         refCoo8=tetra10CooRef;
7097         f.setGaussLocalizationOnType(NORM_TETRA10,refCoo8,gsCoo8,wg8);
7098         wg9=[0.3];
7099         pyra5CooGauss=[0.2, 0.3, 0.1]
7100         gsCoo9=pyra5CooGauss;
7101         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]
7102         refCoo9=pyra5CooRef;
7103         f.setGaussLocalizationOnType(NORM_PYRA5,refCoo9,gsCoo9,wg9);
7104         wg10=[0.3];
7105         pyra13CooGauss=[0.1, 0.2, 0.7]
7106         gsCoo10=pyra13CooGauss;
7107         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]
7108         refCoo10=pyra13CooRef;
7109         f.setGaussLocalizationOnType(NORM_PYRA13,refCoo10,gsCoo10,wg10);
7110         wg11=[0.3];
7111         penta6CooGauss=[0.2, 0.3, 0.1]
7112         gsCoo11=penta6CooGauss;
7113         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]
7114         refCoo11=penta6CooRef;
7115         f.setGaussLocalizationOnType(NORM_PENTA6,refCoo11,gsCoo11,wg11);
7116         wg12=[0.3];
7117         penta15CooGauss=[0.2, 0.3,0.15]
7118         gsCoo12=penta15CooGauss;
7119         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]
7120         refCoo12=penta15CooRef;
7121         f.setGaussLocalizationOnType(NORM_PENTA15,refCoo12,gsCoo12,wg12);
7122         wg13=[0.3];
7123         hexa8CooGauss=[0.2,0.3,0.15]
7124         gsCoo13=hexa8CooGauss;
7125         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]
7126         refCoo13=hexa8CooRef;
7127         f.setGaussLocalizationOnType(NORM_HEXA8,refCoo13,gsCoo13,wg13);
7128         wg14=[0.3];
7129         hexa20CooGauss=[0.11,0.3,0.55]
7130         gsCoo14=hexa20CooGauss;
7131         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]
7132         refCoo14=hexa20CooRef;
7133         f.setGaussLocalizationOnType(NORM_HEXA20,refCoo14,gsCoo14,wg14);
7134         #
7135         resToTest=f.getLocalizationOfDiscr();
7136         self.assertEqual(3,resToTest.getNumberOfComponents());
7137         self.assertEqual(8,resToTest.getNumberOfTuples());#2+3+4+4 gauss points for resp TRI3,TRI6,QUAD4,QUAD8
7138         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]
7139         for i in xrange(24):
7140             self.assertAlmostEqual(expected3[i],resToTest.getIJ(0,i),14);
7141             pass
7142         #
7143         pass
7144
7145     def testP2Localization1(self):
7146         m=MEDCouplingUMesh.New("testP2",2);
7147         coords=[0.,2.,3.5,0.,4.5,1.5,1.2,0.32,3.4,1.,2.1,2.4]
7148         conn=[0,1,2,3,4,5]
7149         coo=DataArrayDouble.New();
7150         coo.setValues(coords,6,2);
7151         m.setCoords(coo);
7152         m.allocateCells(1);
7153         m.insertNextCell(NORM_TRI6,6,conn[0:6])
7154         m.finishInsertingCells();
7155         #
7156         f=MEDCouplingFieldDouble.New(ON_NODES,ONE_TIME);
7157         f.setMesh(m);
7158         da=DataArrayDouble.New();
7159         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]
7160         da.setValues(vals1,6,3);
7161         f.setArray(da);
7162         #
7163         loc=[2.27,1.3]
7164         locs=f.getValueOnMulti(loc);
7165         expected1=[6.0921164547752236, 7.1921164547752232, 8.2921164547752255]
7166         for i in xrange(3):
7167             self.assertAlmostEqual(expected1[i],locs.getIJ(0,i),12);
7168             pass
7169         pass
7170
7171     def testP2Localization2(self):
7172         m=MEDCouplingUMesh.New("testP2_2",3);
7173         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]
7174         conn=[0,1,2,3,4,5,6,7,8,9]
7175         coo=DataArrayDouble.New();
7176         coo.setValues(coords,10,3);
7177         m.setCoords(coo);
7178         m.allocateCells(1);
7179         m.insertNextCell(NORM_TETRA10,10,conn[0:10])
7180         m.finishInsertingCells();
7181         #
7182         f=MEDCouplingFieldDouble.New(ON_NODES,ONE_TIME);
7183         f.setMesh(m);
7184         da=DataArrayDouble.New();
7185         vals1=[1.1,2.1,3.1,4.1,5.2,6.2,7.2,8.2,9.2,10.2]
7186         da.setValues(vals1,10,1);
7187         f.setArray(da);
7188         #
7189         loc=[0.64637931739890486, -0.16185896817550552, 0.22678966365273748]
7190         locs=f.getValueOnMulti(loc);
7191         expected1=[10.0844021968047]
7192         for i in xrange(1):
7193             self.assertAlmostEqual(expected1[i],locs.getIJ(0,i),12);
7194             pass
7195         pass
7196
7197     def testGetValueOn2(self):
7198         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7199         f=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
7200         f.setMesh(m);
7201         arr=DataArrayDouble.New();
7202         nbOfCells=m.getNumberOfCells();
7203         f.setArray(arr);
7204         values1=[7.,107.,10007.,8.,108.,10008.,9.,109.,10009.,10.,110.,10010.,11.,111.,10011.]
7205         arr.setValues(values1,nbOfCells,3);
7206         loc=[-0.05,-0.05, 0.55,-0.25, 0.55,0.15, -0.05,0.45, 0.45,0.45]
7207         f.checkCoherency();
7208         locs=f.getValueOnMulti(loc);
7209         self.assertEqual(5,locs.getNumberOfTuples());
7210         self.assertEqual(3,locs.getNumberOfComponents());
7211         for j in xrange(15):
7212             self.assertAlmostEqual(values1[j],locs.getIJ(0,j),12);
7213             pass
7214         # Testing ON_NODES
7215         f=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME);
7216         f.setMesh(m);
7217         arr=DataArrayDouble.New();
7218         nbOfNodes=m.getNumberOfNodes();
7219         f.setArray(arr);
7220         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.]
7221         arr.setValues(values2,nbOfNodes,3);
7222         loc2=[0.5432,-0.2432, 0.5478,0.1528, 0.5432,-0.2432, 0.5432,-0.2432]
7223         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]
7224         f.checkCoherency();
7225         loc3=DataArrayDouble.New()
7226         loc3.setValues(loc2,4,2);
7227         locs=f.getValueOnMulti(loc3);
7228         self.assertEqual(4,locs.getNumberOfTuples());
7229         self.assertEqual(3,locs.getNumberOfComponents());
7230         for i in xrange(12):
7231             self.assertAlmostEqual(expected2[i],locs.getIJ(0,i),12);
7232             pass
7233         #
7234         pass
7235
7236     def testDAIGetIdsNotEqual1(self):
7237         d=DataArrayInt.New();
7238         vals1=[2,3,5,6,8,5,5,6,1,-5]
7239         d.setValues(vals1,10,1);
7240         d2=d.getIdsNotEqual(5);
7241         self.assertEqual(7,d2.getNumberOfTuples());
7242         self.assertEqual(1,d2.getNumberOfComponents());
7243         expected1=[0,1,3,4,7,8,9]
7244         for i in xrange(7):
7245             self.assertEqual(expected1[i],d2.getIJ(0,i));
7246             pass
7247         d.rearrange(2);
7248         self.assertRaises(InterpKernelException,d.getIdsNotEqual,5);
7249         vals2=[-4,5,6]
7250         vals3=vals2;
7251         d.rearrange(1);
7252         d3=d.getIdsNotEqualList(vals3);
7253         self.assertEqual(5,d3.getNumberOfTuples());
7254         self.assertEqual(1,d3.getNumberOfComponents());
7255         expected2=[0,1,4,8,9]
7256         for i in xrange(5):
7257             self.assertEqual(expected2[i],d3.getIJ(0,i));
7258             pass
7259         pass
7260
7261     def testDAIComputeOffsets1(self):
7262         d=DataArrayInt.New();
7263         vals1=[3,5,1,2,0,8]
7264         expected1=[0,3,8,9,11,11]
7265         d.setValues(vals1,6,1);
7266         d.computeOffsets();
7267         self.assertEqual(6,d.getNumberOfTuples());
7268         self.assertEqual(1,d.getNumberOfComponents());
7269         for i in xrange(6):
7270             self.assertEqual(expected1[i],d.getIJ(0,i));
7271             pass
7272         pass
7273
7274     def testUMeshHexagonPrism1(self):
7275         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,
7276                 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];
7277         conn=[1,2,3,4,5,0,7,8,9,10,11,6]
7278         mesh=MEDCouplingUMesh.New("MyFirstHexagonalPrism",3);
7279         coo=DataArrayDouble.New();
7280         coo.setValues(coords,12,3);
7281         mesh.setCoords(coo);
7282         mesh.allocateCells(1);
7283         mesh.insertNextCell(NORM_HEXGP12,12,conn[0:12])
7284         mesh.finishInsertingCells();
7285         #
7286         mesh.checkCoherency();
7287         vols=mesh.getMeasureField(False);
7288         self.assertEqual(1,vols.getNumberOfTuples());
7289         self.assertEqual(1,vols.getNumberOfComponents());
7290         self.assertAlmostEqual(-5.196152422706632,vols.getIJ(0,0),12);
7291         bary=mesh.getBarycenterAndOwner();
7292         self.assertEqual(1,bary.getNumberOfTuples());
7293         self.assertEqual(3,bary.getNumberOfComponents());
7294         expected1=[0.,0.,1.]
7295         for i in xrange(3):
7296             self.assertAlmostEqual(expected1[i],bary.getIJ(0,i),12);
7297             pass
7298         d1=DataArrayInt.New();
7299         d2=DataArrayInt.New();
7300         d3=DataArrayInt.New();
7301         d4=DataArrayInt.New();
7302         m2=mesh.buildDescendingConnectivity(d1,d2,d3,d4);
7303         self.assertEqual(8,m2.getNumberOfCells());
7304         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]];
7305         expected2=[NORM_POLYGON, NORM_POLYGON, NORM_QUAD4, NORM_QUAD4, NORM_QUAD4, NORM_QUAD4, NORM_QUAD4, NORM_QUAD4];
7306         expected3=[6,6,4,4,4,4,4,4]
7307         for i in xrange(8):
7308             self.assertTrue(m2.getTypeOfCell(i)==expected2[i]);
7309             v=m2.getNodeIdsOfCell(i);
7310             self.assertTrue(len(v)==expected3[i]);
7311             self.assertEqual(expected4[i],v);
7312         #
7313         mesh.convertAllToPoly();
7314         self.assertTrue(NORM_POLYHED==mesh.getTypeOfCell(0));
7315         mesh.unPolyze();
7316         self.assertTrue(NORM_HEXGP12==mesh.getTypeOfCell(0));
7317         self.assertEqual(13,mesh.getMeshLength());
7318         #
7319         pass
7320
7321     def testDADCheckIsMonotonic(self):
7322         da=DataArrayDouble.New();
7323         da.setValues([-1.,1.01,2.03,6.],2,2);
7324         self.assertRaises(InterpKernelException,da.isMonotonic,True,1e-12);
7325         da.rearrange(1);
7326         self.assertTrue(da.isMonotonic(True,1e-12));
7327         da.checkMonotonic(True,1e-12);
7328         da.setIJ(2,0,6.1);
7329         self.assertTrue(not da.isMonotonic(True,1e-12));
7330         self.assertRaises(InterpKernelException,da.checkMonotonic,True,1e-12);
7331         da.setIJ(2,0,5.99);
7332         self.assertTrue(da.isMonotonic(True,1e-12));
7333         self.assertTrue(not da.isMonotonic(True,1e-1));
7334         pass
7335
7336     def testCheckCoherencyDeeper1(self):
7337         m=MEDCouplingDataForTest.build3DSourceMesh_1();
7338         m.checkCoherency();
7339         m.checkCoherency1();
7340         m.getNodalConnectivity().setIJ(8,0,-1);
7341         m.checkCoherency();
7342         self.assertRaises(InterpKernelException,m.checkCoherency1);
7343         m.getNodalConnectivity().setIJ(8,0,-6);
7344         m.checkCoherency();
7345         self.assertRaises(InterpKernelException,m.checkCoherency1);
7346         m.getNodalConnectivity().setIJ(8,0,9);#9>=NbOfNodes
7347         m.checkCoherency();
7348         self.assertRaises(InterpKernelException,m.checkCoherency1);
7349         m.getNodalConnectivity().setIJ(8,0,8);#OK
7350         m.checkCoherency();
7351         m.checkCoherency1();
7352         elts=[1,5]
7353         m.convertToPolyTypes(elts);
7354         m.checkCoherency();
7355         m.checkCoherency1();
7356         m.getNodalConnectivity().setIJ(2,0,9);#9>=NbOfNodes
7357         m.checkCoherency();
7358         self.assertRaises(InterpKernelException,m.checkCoherency1);
7359         m.getNodalConnectivity().setIJ(2,0,-3);
7360         m.checkCoherency();
7361         self.assertRaises(InterpKernelException,m.checkCoherency1);
7362         m.getNodalConnectivity().setIJ(2,0,-1);
7363         m.checkCoherency();
7364         self.assertRaises(InterpKernelException,m.checkCoherency1);#Throw because cell#0 is not a polyhedron
7365         m.getNodalConnectivity().setIJ(2,0,4);
7366         m.checkCoherency();
7367         m.checkCoherency1();
7368         m.getNodalConnectivity().setIJ(7,0,-1);
7369         m.checkCoherency();
7370         m.checkCoherency1();#OK because we are in polyhedron connec
7371         m.getNodalConnectivity().setIJ(36,0,14);
7372         m.checkCoherency();
7373         self.assertRaises(InterpKernelException,m.checkCoherency1);#Throw beacause now cell 5 is a TETRA4 (14) so mimatch of number index and static type.
7374         pass
7375
7376     def testUnPolyze2(self):
7377         m=MEDCouplingUMesh.New("jjj",3);
7378         coo=DataArrayDouble.New();
7379         coo.alloc(4,3);
7380         coo.rearrange(1);
7381         coo.iota(0);
7382         coo.rearrange(3);
7383         m.setCoords(coo);
7384         m.allocateCells(2);
7385         m.insertNextCell(NORM_TETRA4,4,[0,1,2,3]);
7386         m.insertNextCell(NORM_TETRA4,4,[0,1,2,3]);
7387         m.finishInsertingCells();
7388         m2=MEDCouplingUMesh.MergeUMeshesOnSameCoords(4*[m]);
7389         m2.convertToPolyTypes([2]);
7390         m2.unPolyze();
7391         self.assertEqual(NORM_TETRA4,m2.getTypeOfCell(2));
7392         self.assertEqual(40,m2.getMeshLength());
7393         temp2=m2.getNodeIdsOfCell(2);
7394         self.assertEqual(temp2,[0,1,2,3]);
7395         m2.checkCoherency1();
7396         m3=m2.deepCpy();
7397         m2.unPolyze();
7398         self.assertTrue(m3.isEqual(m2,1e-12));
7399         pass
7400
7401     def testDACpyFrom1(self):
7402         d=DataArrayDouble.New();
7403         d.alloc(12,1);
7404         d.iota(14.);
7405         d.rearrange(3);
7406         d.setName("Toto");
7407         d.setInfoOnComponent(0,"X [m]");
7408         d.setInfoOnComponent(1,"Y [m]");
7409         d.setInfoOnComponent(2,"Z [m]");
7410         #
7411         d1=DataArrayDouble.New();
7412         self.assertTrue(not d.isEqual(d1,1e-12));
7413         d1.cpyFrom(d);
7414         self.assertTrue(d.isEqual(d1,1e-12));
7415         d1.cpyFrom(d);
7416         self.assertTrue(d.isEqual(d1,1e-12));
7417         d1.rearrange(2);
7418         self.assertTrue(not d.isEqual(d1,1e-12));
7419         d1.cpyFrom(d);
7420         self.assertTrue(d.isEqual(d1,1e-12));
7421         #
7422         d2=d.convertToIntArr();
7423         d4=DataArrayInt.New();
7424         self.assertTrue(not d2.isEqual(d4));
7425         d4.cpyFrom(d2);
7426         self.assertTrue(d2.isEqual(d4));
7427         d4.cpyFrom(d2);
7428         self.assertTrue(d2.isEqual(d4));
7429         d4.rearrange(2);
7430         self.assertTrue(not d2.isEqual(d4));
7431         d4.cpyFrom(d2);
7432         self.assertTrue(d2.isEqual(d4));
7433         pass
7434
7435     def testDAITransformWithIndArr1(self):
7436         tab1=[17,18,22,19]
7437         tab2=[0,1,1,3,3,0,1,3,2,2,3,0]
7438         expected=[17,18,18,19,19,17,18,19,22,22,19,17]
7439         d=DataArrayInt.New();
7440         d.setValues(tab1,4,1);
7441         d1=DataArrayInt.New();
7442         d1.setValues(tab2,12,1);
7443         d2=d1[:]
7444         #
7445         d1.transformWithIndArr(d);
7446         self.assertEqual(12,d1.getNumberOfTuples());
7447         self.assertEqual(1,d1.getNumberOfComponents());
7448         for i in xrange(12):
7449             self.assertEqual(expected[i],d1.getIJ(i,0));
7450             pass
7451         #
7452         d1=d2
7453         d1.transformWithIndArr(tab1)
7454         self.assertEqual(12,d1.getNumberOfTuples());
7455         self.assertEqual(1,d1.getNumberOfComponents());
7456         for i in xrange(12):
7457             self.assertEqual(expected[i],d1.getIJ(i,0));
7458             pass
7459         pass
7460
7461     def testDAIBuildPermArrPerLevel1(self):
7462         arr=[2,0,1,1,0,1,2,0,1,1,0,0]
7463         expected1=[10,0,5,6,1,7,11,2,8,9,3,4]
7464         da=DataArrayInt.New();
7465         da.setValues(arr,12,1);
7466         da2=da.buildPermArrPerLevel();
7467         self.assertEqual(12,da2.getNumberOfTuples());
7468         self.assertEqual(1,da2.getNumberOfComponents());
7469         for i in xrange(12):
7470             self.assertEqual(expected1[i],da2.getIJ(i,0));
7471             pass
7472         pass
7473
7474     def testDAIOperations1(self):
7475         arr1=[-1,-2,4,7,3,2,6,6,4,3,0,1]
7476         da=DataArrayInt.New();
7477         da.setValues(arr1,4,3);
7478         da1=DataArrayInt.New();
7479         da1.alloc(12,1);
7480         da1.iota(2);
7481         self.assertRaises(InterpKernelException,DataArrayInt.Add,da,da1);#not same number of tuples/Components
7482         da1.rearrange(3);
7483         da2=DataArrayInt.Add(da,da1);
7484         self.assertEqual(4,da2.getNumberOfTuples());
7485         self.assertEqual(3,da2.getNumberOfComponents());
7486         expected1=[1,1,8,12,9,9,14,15,14,14,12,14]
7487         for i in xrange(12):
7488             self.assertEqual(expected1[i],da2.getIJ(0,i));
7489             pass
7490         da1.substractEqual(da);
7491         expected2=[3,5,0,-2,3,5,2,3,6,8,12,12]
7492         for i in xrange(12):
7493             self.assertEqual(expected2[i],da1.getIJ(0,i));
7494             pass
7495         da1.rearrange(1); da1.iota(2); da1.rearrange(3);
7496         da1.addEqual(da);
7497         for i in xrange(12):
7498             self.assertEqual(expected1[i],da1.getIJ(0,i));
7499             pass
7500         da1.rearrange(1); da1.iota(2); da1.rearrange(3);
7501         da2=DataArrayInt.Multiply(da,da1);
7502         self.assertEqual(4,da2.getNumberOfTuples());
7503         self.assertEqual(3,da2.getNumberOfComponents());
7504         expected3=[-2,-6,16,35,18,14,48,54,40,33,0,13]
7505         for i in xrange(12):
7506             self.assertEqual(expected3[i],da2.getIJ(0,i));
7507             pass
7508         da.divideEqual(da1);
7509         self.assertEqual(4,da.getNumberOfTuples());
7510         self.assertEqual(3,da.getNumberOfComponents());
7511         expected4=[0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0]
7512         for i in xrange(12):
7513             self.assertEqual(expected4[i],da.getIJ(0,i));
7514             pass
7515         da.setValues(arr1,4,3);
7516         da1.multiplyEqual(da);
7517         self.assertEqual(4,da1.getNumberOfTuples());
7518         self.assertEqual(3,da1.getNumberOfComponents());
7519         for i in xrange(12):
7520             self.assertEqual(expected3[i],da1.getIJ(0,i));
7521             pass
7522         da1.rearrange(1); da1.iota(2); da1.rearrange(3);
7523         da2=DataArrayInt.Divide(da,da1);
7524         self.assertEqual(4,da2.getNumberOfTuples());
7525         self.assertEqual(3,da2.getNumberOfComponents());
7526         for i in xrange(12):
7527             self.assertEqual(expected4[i],da2.getIJ(0,i));
7528             pass
7529         da1.applyInv(321);
7530         self.assertEqual(4,da1.getNumberOfTuples());
7531         self.assertEqual(3,da1.getNumberOfComponents());
7532         expected5=[160,107,80,64,53,45,40,35,32,29,26,24]
7533         for i in xrange(12):
7534             self.assertEqual(expected5[i],da1.getIJ(0,i));
7535             pass
7536         da1.applyDivideBy(2);
7537         self.assertEqual(4,da1.getNumberOfTuples());
7538         self.assertEqual(3,da1.getNumberOfComponents());
7539         expected6=[80,53,40,32,26,22,20,17,16,14,13,12]
7540         for i in xrange(12):
7541             self.assertEqual(expected6[i],da1.getIJ(0,i));
7542             pass
7543         expected7=[3,4,5,4,5,1,6,3,2,0,6,5]
7544         da1.applyModulus(7);
7545         for i in xrange(12):
7546             self.assertEqual(expected7[i],da1.getIJ(0,i));
7547             pass
7548         da1.applyLin(1,1);
7549         expected8=[3,3,3,3,3,1,3,3,0,0,3,3]
7550         da1.applyRModulus(3);
7551         for i in xrange(12):
7552             self.assertEqual(expected8[i],da1.getIJ(0,i));
7553             pass
7554         pass
7555
7556     def testEmulateMEDMEMBDC1(self):
7557         m,m1=MEDCouplingDataForTest.buildPointe_1();
7558         m2,da1,da2,da3,da4,da5,da0=m.emulateMEDMEMBDC(m1)
7559         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]
7560         expected1=[1,32,29,23,41,36]
7561         self.assertEqual(47,da0.getNumberOfTuples());
7562         self.assertEqual(1,da0.getNumberOfComponents());
7563         for i in xrange(47):
7564             self.assertEqual(expected0[i],da0.getIJ(0,i));
7565             pass
7566         self.assertEqual(6,da5.getNumberOfTuples());
7567         self.assertEqual(1,da5.getNumberOfComponents());
7568         for i in xrange(6):
7569             self.assertEqual(expected1[i],da5.getIJ(0,i));
7570             pass
7571         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]
7572         self.assertEqual(70,da1.getNumberOfTuples());
7573         self.assertEqual(1,da1.getNumberOfComponents());
7574         for i in xrange(70):
7575             self.assertEqual(expected2[i],da1.getIJ(0,i));
7576             pass
7577         expected3=[0,4,8,12,16,20,24,28,32,36,40,44,48,53,58,64,70]
7578         self.assertEqual(17,da2.getNumberOfTuples());
7579         self.assertEqual(1,da2.getNumberOfComponents());
7580         for i in xrange(17):
7581             self.assertEqual(expected3[i],da2.getIJ(0,i));
7582             pass
7583         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]
7584         #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];
7585         self.assertEqual(48,da4.getNumberOfTuples());
7586         self.assertEqual(1,da4.getNumberOfComponents());
7587         for i in xrange(48):
7588             self.assertEqual(expected4[i],da4.getIJ(0,i));
7589             pass
7590         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]
7591         self.assertEqual(70,da3.getNumberOfTuples());
7592         self.assertEqual(1,da3.getNumberOfComponents());
7593         for i in xrange(70):
7594             self.assertEqual(expected5[i],da3.getIJ(0,i));
7595             pass
7596         pass
7597
7598     def testGetLevArrPerCellTypes1(self):
7599         m,m1=MEDCouplingDataForTest.buildPointe_1();
7600         m1,d0,d1,d2,d3=m.buildDescendingConnectivity();
7601         order=[NORM_TRI3,NORM_QUAD4];
7602         da0,da1=m1.getLevArrPerCellTypes(order);
7603         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]
7604         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]
7605         self.assertEqual(47,da0.getNumberOfTuples());
7606         self.assertEqual(1,da0.getNumberOfComponents());
7607         for i in xrange(47):
7608             self.assertEqual(expected0[i],da0.getIJ(0,i));
7609             pass
7610         self.assertEqual(2,da1.getNumberOfTuples());
7611         self.assertEqual(1,da1.getNumberOfComponents());
7612         self.assertEqual(36,da1.getIJ(0,0));#36 TRI3
7613         self.assertEqual(11,da1.getIJ(1,0));#11 QUAD4
7614         #
7615         da2=da0.buildPermArrPerLevel();
7616         #
7617         self.assertEqual(47,da2.getNumberOfTuples());
7618         self.assertEqual(1,da2.getNumberOfComponents());
7619         for i in xrange(47):
7620             self.assertEqual(expected1[i],da2.getIJ(0,i));
7621             pass
7622         pass
7623
7624     def testSortCellsInMEDFileFrmt1(self):
7625         m,m1=MEDCouplingDataForTest.buildPointe_1();
7626         m2=m.deepCpy()
7627         da=DataArrayInt.New()
7628         da.setValues([0,1,2,14,3,12,4,5,15,6,7,8,9,10,11,13],16,1)
7629         daa=da.invertArrayN2O2O2N(16)
7630         m.renumberCells(daa,False)
7631         da2=m.sortCellsInMEDFileFrmt()
7632         self.assertEqual(da2.getValues(),[0,1,2,14,3,12,4,5,15,6,7,8,9,10,11,13])
7633         self.assertTrue(m.isEqual(m2,1e-12))
7634         self.assertTrue(da.isEqual(da2))
7635         pass
7636
7637     def testBuildPartAndReduceNodes1(self):
7638         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7639         arr=[1,0]
7640         m2,da=m.buildPartAndReduceNodes(arr);
7641         self.assertEqual(5,m2.getNumberOfNodes());
7642         self.assertEqual(2,m2.getNumberOfCells());
7643         f=m2.getMeasureField(True);
7644         self.assertAlmostEqual(0.125,f.getArray().getIJ(0,0),12);
7645         self.assertAlmostEqual(0.25,f.getArray().getIJ(1,0),12);
7646         #
7647         arr2=DataArrayInt.New()
7648         arr2.setValues(arr,2,1)
7649         m2,da=m.buildPartAndReduceNodes(arr2);
7650         self.assertEqual(5,m2.getNumberOfNodes());
7651         self.assertEqual(2,m2.getNumberOfCells());
7652         f=m2.getMeasureField(True);
7653         self.assertAlmostEqual(0.125,f.getArray().getIJ(0,0),12);
7654         self.assertAlmostEqual(0.25,f.getArray().getIJ(1,0),12);
7655         pass
7656
7657     def testDAITransformWithIndArrR1(self):
7658         tab1=[2,4,5,3,6,7]
7659         tab2=[-1,-1,0,1,2,3,4,5,-1,-1,-1,-1]
7660         expected=[0,3,1,2,4,5]
7661         d=DataArrayInt.New();
7662         d.setValues(tab1,6,1);
7663         d1=DataArrayInt.New();
7664         d1.setValues(tab2,12,1);
7665         d2=d1[:]
7666         #
7667         d3=d.transformWithIndArrR(d1);
7668         self.assertEqual(6,d3.getNumberOfTuples());
7669         self.assertEqual(1,d3.getNumberOfComponents());
7670         for i in xrange(6):
7671             self.assertEqual(expected[i],d3.getIJ(i,0));
7672             pass
7673         #
7674         d1=d2
7675         d3=d.transformWithIndArrR(tab2)
7676         self.assertEqual(6,d3.getNumberOfTuples());
7677         self.assertEqual(1,d3.getNumberOfComponents());
7678         for i in xrange(6):
7679             self.assertEqual(expected[i],d3.getIJ(i,0));
7680             pass
7681         pass
7682
7683     def testDAISplitByValueRange1(self):
7684         val1=[6,5,0,3,2,7,8,1,4]
7685         val2=[0,4,9]
7686         d=DataArrayInt.New();
7687         d.setValues(val1,9,1);
7688         e,f,g=d.splitByValueRange(val2);
7689         self.assertEqual(9,e.getNumberOfTuples());
7690         self.assertEqual(1,e.getNumberOfComponents());
7691         self.assertEqual(9,f.getNumberOfTuples());
7692         self.assertEqual(1,f.getNumberOfComponents());
7693         self.assertEqual(2,g.getNumberOfTuples());
7694         self.assertEqual(1,g.getNumberOfComponents());
7695         #
7696         expected1=[1,1,0,0,0,1,1,0,1]
7697         expected2=[2,1,0,3,2,3,4,1,0]
7698         for i in xrange(9):
7699             self.assertEqual(expected1[i],e.getIJ(i,0));
7700             self.assertEqual(expected2[i],f.getIJ(i,0));
7701             pass
7702         self.assertEqual(0,g.getIJ(0,0));
7703         self.assertEqual(1,g.getIJ(1,0));
7704         #
7705         d.setIJ(6,0,9);
7706         self.assertRaises(InterpKernelException,d.splitByValueRange,val2);
7707         pass
7708
7709     def testUMeshSplitProfilePerType1(self):
7710         val0=[2,0,1,3,4]
7711         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7712         m.renumberCells(val0,False);
7713         #
7714         val1=[0,2,3]
7715         d=DataArrayInt.New();
7716         d.setValues(val1,3,1);
7717         d.setName("sup")
7718         code,idsInPflPerType,pfls=m.splitProfilePerType(d);
7719         self.assertEqual(6,len(code));
7720         self.assertEqual(2,len(idsInPflPerType));
7721         expected1=[3,1,0, 4,2,1]
7722         for i in xrange(6):
7723             self.assertEqual(expected1[i],code[i]);
7724             pass
7725         self.assertEqual(2,len(idsInPflPerType));
7726         self.assertEqual(1,idsInPflPerType[0].getNumberOfTuples());
7727         self.assertEqual(0,idsInPflPerType[0].getIJ(0,0));
7728         self.assertEqual(2,idsInPflPerType[1].getNumberOfTuples());
7729         self.assertEqual(1,idsInPflPerType[1].getIJ(0,0));
7730         self.assertEqual(2,idsInPflPerType[1].getIJ(1,0));
7731         #
7732         self.assertEqual(2,len(pfls));
7733         self.assertEqual("sup",pfls[0].getName())
7734         self.assertEqual(1,pfls[0].getNumberOfTuples());
7735         self.assertEqual(0,pfls[0].getIJ(0,0));
7736         self.assertEqual("sup",pfls[1].getName())
7737         self.assertEqual(2,pfls[1].getNumberOfTuples());
7738         self.assertEqual(0,pfls[1].getIJ(0,0));
7739         self.assertEqual(1,pfls[1].getIJ(1,0));
7740         #
7741         val2=[0,2,3,4]
7742         d=DataArrayInt.New();
7743         d.setValues(val2,4,1);
7744         code,idsInPflPerType,pfls=m.splitProfilePerType(d);
7745         self.assertEqual(6,len(code));
7746         self.assertEqual(2,len(idsInPflPerType));
7747         expected2=[3,1,0, 4,3,-1]
7748         for i in xrange(6):
7749             self.assertEqual(expected2[i],code[i]);
7750             pass
7751         self.assertEqual(2,len(idsInPflPerType));
7752         self.assertEqual(1,idsInPflPerType[0].getNumberOfTuples());
7753         self.assertEqual(0,idsInPflPerType[0].getIJ(0,0));
7754         self.assertEqual(3,idsInPflPerType[1].getNumberOfTuples());
7755         self.assertEqual(1,idsInPflPerType[1].getIJ(0,0));
7756         self.assertEqual(2,idsInPflPerType[1].getIJ(1,0));
7757         self.assertEqual(3,idsInPflPerType[1].getIJ(2,0));
7758         #
7759         self.assertEqual(1,len(pfls));
7760         self.assertEqual(1,pfls[0].getNumberOfTuples());
7761         self.assertEqual(0,pfls[0].getIJ(0,0));
7762         #
7763         val3=[1,0,2]
7764         d=DataArrayInt.New();
7765         d.setValues(val3,3,1);
7766         code,idsInPflPerType,pfls=m.splitProfilePerType(d);
7767         self.assertEqual(6,len(code));
7768         self.assertEqual(2,len(idsInPflPerType));
7769         expected3=[3,2,0, 4,1,1]
7770         for i in xrange(6):
7771             self.assertEqual(expected3[i],code[i]);
7772             pass
7773         self.assertEqual(2,len(idsInPflPerType));
7774         self.assertEqual(2,idsInPflPerType[0].getNumberOfTuples());
7775         self.assertEqual(0,idsInPflPerType[0].getIJ(0,0));
7776         self.assertEqual(1,idsInPflPerType[0].getIJ(1,0));
7777         self.assertEqual(1,idsInPflPerType[1].getNumberOfTuples());
7778         self.assertEqual(2,idsInPflPerType[1].getIJ(0,0));
7779         #
7780         self.assertEqual(2,len(pfls));
7781         self.assertEqual(2,pfls[0].getNumberOfTuples());
7782         self.assertEqual(1,pfls[0].getIJ(0,0));
7783         self.assertEqual(0,pfls[0].getIJ(1,0));
7784         self.assertEqual(0,pfls[1].getIJ(0,0));
7785         #
7786         val4=[3,4]
7787         d=DataArrayInt.New();
7788         d.setValues(val4,2,1);
7789         code,idsInPflPerType,pfls=m.splitProfilePerType(d);
7790         self.assertEqual(3,len(code));
7791         self.assertEqual(1,len(idsInPflPerType));
7792         expected4=[4,2,0]
7793         for i in xrange(3):
7794             self.assertEqual(expected4[i],code[i]);
7795             pass
7796         self.assertEqual(1,len(idsInPflPerType));
7797         self.assertEqual(2,idsInPflPerType[0].getNumberOfTuples());
7798         self.assertEqual(0,idsInPflPerType[0].getIJ(0,0));
7799         self.assertEqual(1,idsInPflPerType[0].getIJ(1,0));
7800         #
7801         self.assertEqual(1,len(pfls));
7802         self.assertEqual(2,pfls[0].getNumberOfTuples());
7803         self.assertEqual(1,pfls[0].getIJ(0,0));
7804         self.assertEqual(2,pfls[0].getIJ(1,0));
7805         pass
7806
7807     def testDAIBuildExplicitArrByRanges1(self):
7808         d=DataArrayInt.New();
7809         vals1=[0,2,3]
7810         d.setValues(vals1,3,1);
7811         e=DataArrayInt.New();
7812         vals2=[0,3,6,10,14,20]
7813         e.setValues(vals2,6,1);
7814         #
7815         f=d.buildExplicitArrByRanges(e);
7816         self.assertEqual(11,f.getNumberOfTuples());
7817         self.assertEqual(1,f.getNumberOfComponents());
7818         expected1=[0,1,2,6,7,8,9,10,11,12,13]
7819         for i in xrange(11):
7820             self.assertEqual(expected1[i],f.getIJ(i,0));
7821             pass
7822         pass
7823
7824     def testDAIComputeOffsets2(self):
7825         d=DataArrayInt.New();
7826         vals1=[3,5,1,2,0,8]
7827         expected1=[0,3,8,9,11,11,19]
7828         d.setValues(vals1,6,1);
7829         d.computeOffsets2();
7830         self.assertEqual(7,d.getNumberOfTuples());
7831         self.assertEqual(1,d.getNumberOfComponents());
7832         for i in xrange(7):
7833             self.assertEqual(expected1[i],d.getIJ(0,i));
7834             pass
7835         pass
7836
7837     def testMergeField3(self):
7838         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7839         m.getCoords().setInfoOnComponent(0,"x [m]");
7840         m.getCoords().setInfoOnComponent(1,"z [km]");
7841         m.setName("m");
7842         m.setDescription("desc");
7843         f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
7844         f1.setName("f1");
7845         f1.setMesh(m);
7846         arr=DataArrayDouble.New();
7847         arr.alloc(5,2);
7848         arr.setInfoOnComponent(0,"X [m]");
7849         arr.setInfoOnComponent(1,"YY [mm]");
7850         arr.fillWithValue(2.);
7851         f1.setArray(arr);
7852         #
7853         f2=MEDCouplingFieldDouble.MergeFields([f1]);
7854         self.assertTrue(f1.isEqual(f2,1e-12,1e-12));
7855         #
7856         pass
7857
7858     def testGetDistributionOfTypes1(self):
7859         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7860         tab1=[2,0,1,3,4]
7861         self.assertRaises(InterpKernelException,m.getDistributionOfTypes);
7862         m.renumberCells(tab1,False);
7863         code=m.getDistributionOfTypes();
7864         self.assertEqual(2,len(code));
7865         self.assertEqual(3,code[0][0]);
7866         self.assertEqual(2,code[0][1]);
7867         self.assertEqual(0,code[0][2]);
7868         self.assertEqual(4,code[1][0]);
7869         self.assertEqual(3,code[1][1]);
7870         self.assertEqual(0,code[1][2]);
7871         pass
7872
7873     def testNorm2_1(self):
7874         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7875         f=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
7876         f.setMesh(m);
7877         #
7878         d=DataArrayDouble.New();
7879         tab=[1.2,1.3,2.2,2.3,3.2,3.3,4.2,4.3,5.2,5.3]
7880         d.setValues(tab,5,2);
7881         f.setArray(d);
7882         f.checkCoherency();
7883         #
7884         self.assertAlmostEqual(11.209371079592289,f.norm2(),14);
7885         #
7886         pass
7887
7888     def testNormMax1(self):
7889         m=MEDCouplingDataForTest.build2DTargetMesh_1();
7890         f=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
7891         f.setMesh(m);
7892         #
7893         d=DataArrayDouble.New();
7894         tab=[2.3,-1.2,6.3,-7.8,2.9,7.7,2.1,0.,3.6,-7.6]
7895         d.setValues(tab,5,2);
7896         f.setArray(d);
7897         f.checkCoherency();
7898         #
7899         self.assertAlmostEqual(7.8,f.normMax(),14);
7900         #
7901         pass
7902
7903     def testFindAndCorrectBadOriented3DExtrudedCells1(self):
7904         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];
7905         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]
7906         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]
7907         invalidCells=[2,3,6,7]
7908         m=MEDCouplingUMesh.New("Example",3);
7909         coo=DataArrayDouble.New();
7910         coo.setValues(coords,38,3);
7911         m.setCoords(coo);
7912         m.allocateCells(8);
7913         m.insertNextCell(NORM_PENTA6,6,conn[0:6])
7914         m.insertNextCell(NORM_PENTA6,6,conn[6:12])
7915         m.insertNextCell(NORM_PENTA6,6,conn[12:18])
7916         m.insertNextCell(NORM_PENTA6,6,conn[18:24])
7917         m.insertNextCell(NORM_HEXA8,8,conn[24:32])
7918         m.insertNextCell(NORM_HEXA8,8,conn[32:40])
7919         m.insertNextCell(NORM_HEXA8,8,conn[40:48])
7920         m.insertNextCell(NORM_HEXA8,8,conn[48:56])
7921         m.finishInsertingCells();
7922         #
7923         v=m.findAndCorrectBadOriented3DExtrudedCells();
7924         self.assertEqual(4,len(v));
7925         self.assertEqual(v.getValues(),invalidCells);
7926         self.assertEqual(connExp,m.getNodalConnectivity().getValues());
7927         self.assertTrue(m.findAndCorrectBadOriented3DExtrudedCells().empty())
7928         #
7929         pass
7930
7931     def testConvertExtrudedPolyhedra1(self):
7932         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]
7933         m=MEDCouplingUMesh.New("Example",3);
7934         coo=DataArrayDouble.New();
7935         coo.alloc(73,3);
7936         coo.rearrange(1); coo.iota(0); coo.rearrange(3);
7937         m.setCoords(coo);
7938         m.allocateCells(9);
7939         m.insertNextCell(NORM_TETRA4,4,conn[0:4])
7940         m.insertNextCell(NORM_HEXA8,8,conn[4:12])
7941         m.insertNextCell(NORM_TETRA4,4,conn[12:16])
7942         m.insertNextCell(NORM_POLYHED,6,conn[16:22])
7943         m.insertNextCell(NORM_PENTA6,6,conn[22:28])
7944         m.insertNextCell(NORM_POLYHED,10,conn[28:38])
7945         m.insertNextCell(NORM_HEXA8,8,conn[38:46])
7946         m.insertNextCell(NORM_HEXGP12,12,conn[46:58])
7947         m.insertNextCell(NORM_POLYHED,14,conn[58:72])
7948         m.finishInsertingCells();
7949         #
7950         m.convertExtrudedPolyhedra();
7951         da=m.getNodalConnectivity();
7952         dai=m.getNodalConnectivityIndex();
7953         self.assertEqual(10,dai.getNbOfElems());
7954         self.assertEqual(159,da.getNbOfElems());
7955         #
7956         expected1=[14, 1, 2, 3, 4,
7957                    18, 5, 6, 7, 8, 9, 10, 11, 12,
7958                    14, 13, 14, 15, 16,
7959                    31, 17, 18, 19, -1, 20, 22, 21, -1, 17, 18, 21, 20, -1, 18, 19, 22, 21, -1, 19, 17, 20, 22,
7960                    16, 23, 24, 25, 26, 27, 28,
7961                    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,
7962                    18, 39, 40, 41, 42, 43, 44, 45, 46,
7963                    22, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
7964                    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];
7965         expected2=[0,5,14,19,42,49,86,95,108,159]
7966         self.assertEqual(expected1,da.getValues());
7967         self.assertEqual(expected2,dai.getValues());
7968         m.checkCoherency2()
7969         pass
7970
7971     def testNonRegressionCopyTinyStrings(self):
7972         m=MEDCouplingDataForTest.build2DTargetMesh_1()
7973         f1=m.getMeasureField(True)
7974         f1.getArray().setInfoOnComponent(0,"P [N/m^2]")
7975         bary=m.getBarycenterAndOwner()
7976         f2=f1.buildNewTimeReprFromThis(NO_TIME,False)
7977         f2.setArray(bary)
7978         self.assertRaises(InterpKernelException,f1.copyTinyAttrFrom,f2)
7979         pass
7980
7981     def testDaDSetPartOfValuesAdv1(self):
7982         tab1=[3.,4.,5., 13.,14.,15., 23.,24.,25., 33.,34.,35., 43.,44.,45., 53.,54.,55.]
7983         tab2=[6.,7.,8., 16.,17.,18., 26.,27.,28.]
7984         tab3=[4,1, 2,2, 3,0]
7985         a=DataArrayDouble.New();
7986         a.setValues(tab1,6,3);
7987         b=DataArrayDouble.New();
7988         b.setValues(tab2,3,3);
7989         c=DataArrayInt.New();
7990         c.setValues(tab3,3,2);
7991         #
7992         a.setPartOfValuesAdv(b,c);
7993         expected1=[3.,4.,5., 13.,14.,15., 26.,27.,28., 6.,7.,8., 16.,17.,18., 53.,54.,55.]
7994         self.assertEqual(expected1,a.getValues());
7995         pass
7996
7997     def testUMeshBuildSetInstanceFromThis1(self):
7998         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
7999         m2=m.buildSetInstanceFromThis(3);
8000         self.assertTrue(m.isEqual(m2,1e-12));
8001         #
8002         m=MEDCouplingUMesh.New("toto",2);
8003         m2=m.buildSetInstanceFromThis(3);
8004         self.assertEqual(0,m2.getNumberOfNodes());
8005         self.assertEqual(0,m2.getNumberOfCells());
8006         pass
8007
8008     def testUMeshMergeMeshesCVW1(self):
8009         m=MEDCouplingDataForTest.build3DSurfTargetMesh_1();
8010         m2=MEDCouplingUMesh.New("toto",2);
8011         m3=MEDCouplingUMesh.MergeUMeshes([m,m2]);
8012         m3.setName(m.getName());
8013         self.assertTrue(m.isEqual(m3,1e-12));
8014         pass
8015
8016     def testChangeUnderlyingMeshWithCMesh1(self):
8017         mesh=MEDCouplingCMesh.New();
8018         coordsX=DataArrayDouble.New();
8019         arrX=[ -1., 1., 2., 4. ]
8020         coordsX.setValues(arrX,4,1);
8021         coordsY=DataArrayDouble.New();
8022         arrY=[ -2., 2., 4., 8. ]
8023         coordsY.setValues(arrY,4,1);
8024         coordsZ=DataArrayDouble.New();
8025         arrZ=[ -3., 3., 6., 12. ]
8026         coordsZ.setValues(arrZ,4,1);
8027         mesh.setCoords(coordsX,coordsY,coordsZ);
8028         f=mesh.getMeasureField(True)
8029         mesh2=mesh.deepCpy()
8030         for myId in [0,1,2,10,11,12,20,21,22]:
8031             f=mesh.getMeasureField(True)
8032             f.changeUnderlyingMesh(mesh2,myId,1e-12);
8033             pass
8034         mesh2.setName("uuuu")
8035         for myId in [1,2,10,11,12,20,21,22]:
8036             f=mesh.getMeasureField(True)
8037             f.changeUnderlyingMesh(mesh2,myId,1e-12);
8038             pass
8039         pass
8040
8041     def testDADFindCommonTuples1(self):
8042         da=DataArrayDouble.New();
8043         # nbOftuples=1
8044         array1=[2.3,1.2,1.3,2.3,2.301,0.8]
8045         da.setValues(array1,6,1)
8046         c,cI=da.findCommonTuples(1e-2);
8047         expected1=[0,3,4]
8048         expected2=[0,3]
8049         self.assertEqual(3,c.getNbOfElems());
8050         self.assertEqual(2,cI.getNbOfElems());
8051         self.assertEqual(expected1,c.getValues())
8052         self.assertEqual(expected2,cI.getValues())
8053         c,cI=da.findCommonTuples(2e-1)
8054         expected3=[0,3,4,1,2]
8055         expected4=[0,3,5]
8056         self.assertEqual(5,c.getNbOfElems());
8057         self.assertEqual(3,cI.getNbOfElems());
8058         self.assertEqual(expected3,c.getValues())
8059         self.assertEqual(expected4,cI.getValues())
8060         # nbOftuples=2
8061         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]
8062         da.setValues(array2,6,2)
8063         c,cI=da.findCommonTuples(1e-2);
8064         self.assertEqual(3,c.getNbOfElems());
8065         self.assertEqual(2,cI.getNbOfElems());
8066         self.assertEqual(expected1,c.getValues())
8067         self.assertEqual(expected2,cI.getValues())
8068         c,cI=da.findCommonTuples(2e-1)
8069         self.assertEqual(5,c.getNbOfElems());
8070         self.assertEqual(3,cI.getNbOfElems());
8071         self.assertEqual(expected3,c.getValues())
8072         self.assertEqual(expected4,cI.getValues())
8073         # nbOftuples=3
8074         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]
8075         da.setValues(array3,6,3)
8076         c,cI=da.findCommonTuples(1e-2);
8077         self.assertEqual(3,c.getNbOfElems());
8078         self.assertEqual(2,cI.getNbOfElems());
8079         self.assertEqual(expected1,c.getValues())
8080         self.assertEqual(expected2,cI.getValues())
8081         c,cI=da.findCommonTuples(2e-1)
8082         self.assertEqual(5,c.getNbOfElems());
8083         self.assertEqual(3,cI.getNbOfElems());
8084         self.assertEqual(expected3,c.getValues())
8085         self.assertEqual(expected4,cI.getValues())
8086         # nbOftuples=1, no common groups
8087         array11=[2.3,1.2,1.3,2.4,2.5,0.8]
8088         da.setValues(array11,6,1)
8089         c,cI=da.findCommonTuples(1e-2);
8090         self.assertEqual(0,c.getNbOfElems());
8091         self.assertEqual(1,cI.getNbOfElems());
8092         self.assertEqual([0],cI.getValues())
8093
8094         array12=[0.]*(6*4)
8095         da.setValues(array12,6,4) #bad NumberOfComponents
8096         self.assertRaises(InterpKernelException, da.findCommonTuples, 1e-2);
8097         pass
8098
8099     def testDABack1(self):
8100         da=DataArrayDouble.New();
8101         array1=[2.3,1.2,1.3,2.3,2.301,0.8]
8102         da.setValues(array1,6,1);
8103         self.assertAlmostEqual(0.8,da.back(),14);
8104         da.rearrange(2);
8105         self.assertRaises(InterpKernelException,da.back);
8106         da.alloc(0,1);
8107         self.assertRaises(InterpKernelException,da.back);
8108         #
8109         da=DataArrayInt.New();
8110         array2=[4,7,8,2]
8111         da.setValues(array2,4,1);
8112         self.assertEqual(2,da.back());
8113         da.rearrange(2);
8114         self.assertRaises(InterpKernelException,da.back);
8115         da.alloc(0,1);
8116         self.assertRaises(InterpKernelException,da.back);
8117         pass
8118
8119     def testDADGetDifferentValues1(self):
8120         da=DataArrayDouble.New();
8121         array1=[2.3,1.2,1.3,2.3,2.301,0.8]
8122         da.setValues(array1,6,1)
8123         #
8124         expected1=[2.301,1.2,1.3,0.8]
8125         dv=da.getDifferentValues(1e-2);
8126         self.assertEqual(4,dv.getNbOfElems());
8127         for i in xrange(4):
8128             self.assertAlmostEqual(expected1[i],dv.getIJ(i,0),14);
8129             pass
8130         #
8131         dv=da.getDifferentValues(2e-1);
8132         expected2=[2.301,1.3,0.8]
8133         self.assertEqual(3,dv.getNbOfElems());
8134         for i in xrange(3):
8135             self.assertAlmostEqual(expected2[i],dv.getIJ(i,0),14);
8136             pass
8137         pass
8138
8139     def testDAIBuildOld2NewArrayFromSurjectiveFormat2(self):
8140         arr=[0,3, 5,7,9]
8141         arrI=[0,2,5]
8142         a=DataArrayInt.New();
8143         a.setValues(arr,5,1);
8144         b=DataArrayInt.New();
8145         b.setValues(arrI,3,1);
8146         ret,newNbTuple=DataArrayInt.BuildOld2NewArrayFromSurjectiveFormat2(10,a,b);
8147         expected=[0,1,2,0,3,4,5,4,6,4]
8148         self.assertEqual(10,ret.getNbOfElems());
8149         self.assertEqual(7,newNbTuple);
8150         self.assertEqual(1,ret.getNumberOfComponents());
8151         self.assertEqual(expected,ret.getValues());
8152         self.assertRaises(InterpKernelException,DataArrayInt.BuildOld2NewArrayFromSurjectiveFormat2,9,a,b);
8153         pass
8154
8155     def testDADIReverse1(self):
8156         arr=[0,3,5,7,9,2]
8157         a=DataArrayInt.New();
8158         a.setValues(arr,6,1);
8159         self.assertEqual(2,a.back());
8160         a.reverse();
8161         for i in xrange(6):
8162             self.assertEqual(arr[5-i],a.getIJ(i,0));
8163             pass
8164         a.setValues(arr[:-1],5,1);
8165         a.reverse();
8166         for i in xrange(5):
8167             self.assertEqual(arr[4-i],a.getIJ(i,0));
8168             pass
8169         #
8170         arr2=[0.,3.,5.,7.,9.,2.]
8171         b=DataArrayDouble.New();
8172         b.setValues(arr2,6,1);
8173         b.reverse();
8174         for i in xrange(6):
8175             self.assertAlmostEqual(arr2[5-i],b.getIJ(i,0),14);
8176             pass
8177         b.setValues(arr2[:5],5,1);
8178         self.assertAlmostEqual(9.,b.back(),14)
8179         b.reverse();
8180         for i in xrange(5):
8181             self.assertAlmostEqual(arr2[4-i],b.getIJ(i,0),14);
8182             pass
8183         pass
8184
8185     def testGetNodeIdsInUse1(self):
8186         m0=MEDCouplingDataForTest.build2DTargetMesh_1();
8187         CellIds=[1,2]
8188         m1=m0.buildPartOfMySelf(CellIds,True);
8189         arr,newNbOfNodes=m1.getNodeIdsInUse();
8190         expected=[-1,0,1,-1,2,3,-1,-1,-1]
8191         self.assertEqual(4,newNbOfNodes);
8192         self.assertEqual(9,arr.getNbOfElems());
8193         self.assertEqual(expected,arr.getValues());
8194         arr2=arr.invertArrayO2N2N2O(newNbOfNodes);
8195         self.assertEqual(4,arr2.getNbOfElems());
8196         expected2=[1,2,4,5]
8197         self.assertEqual(expected2,arr2.getValues());
8198         pass
8199
8200     def testBuildDescendingConnec2(self):
8201         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
8202         #
8203         mesh2,desc,descIndx,revDesc,revDescIndx=mesh.buildDescendingConnectivity2();
8204         mesh2.checkCoherency();
8205         self.assertEqual(1,mesh2.getMeshDimension());
8206         self.assertEqual(13,mesh2.getNumberOfCells());
8207         self.assertEqual(14,revDescIndx.getNbOfElems()); self.assertEqual(14,revDescIndx.getNumberOfTuples());
8208         self.assertEqual(6,descIndx.getNbOfElems()); self.assertEqual(6,descIndx.getNumberOfTuples());
8209         self.assertEqual(18,desc.getNbOfElems()); self.assertEqual(18,desc.getNumberOfTuples());
8210         self.assertEqual(18,revDesc.getNbOfElems()); self.assertEqual(18,revDesc.getNumberOfTuples());
8211         expected1=[1,2,3,4,-3,5,6, 7,8,-5,9,10,-2,11, 12,13,-7,-10]
8212         self.assertEqual(expected1,desc.getValues());
8213         expected2=[0,4,7,10,14,18]
8214         self.assertEqual(expected2,descIndx.getValues());
8215         expected3=[0,1,3,5,6,8,9,11,12,13,15,16,17,18]
8216         self.assertEqual(expected3,revDescIndx.getValues());
8217         expected4=[0, 0,3, 0,1, 0, 1,2, 1, 2,4, 2, 3, 3,4, 3, 4, 4]
8218         self.assertEqual(expected4,revDesc.getValues());
8219         conn=mesh2.getNodalConnectivity();
8220         connIndex=mesh2.getNodalConnectivityIndex();
8221         expected5=[0,3,6,9,12,15,18,21,24,27,30,33,36,39]
8222         self.assertEqual(expected5,connIndex.getValues());
8223         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]
8224         self.assertEqual(expected6,conn.getValues());
8225         pass
8226
8227     def testIntersect2DMeshesTmp1(self):
8228         m1c=MEDCouplingCMesh.New();
8229         coordsX=DataArrayDouble.New();
8230         arrX=[ -1., 1., 2., 4. ]
8231         coordsX.setValues(arrX,4,1);
8232         m1c.setCoordsAt(0,coordsX);
8233         coordsY=DataArrayDouble.New();
8234         arrY=[ -2., 2., 4., 8. ]
8235         coordsY.setValues(arrY,4,1);
8236         m1c.setCoordsAt(1,coordsY);
8237         m1=m1c.buildUnstructured()
8238         m1bis=m1.buildPartOfMySelf([3,4,5],False)
8239         m2=m1.deepCpy()
8240         m2=m2.buildPartOfMySelf([0,1,2],False)
8241         m2.translate([0.5,0.5])
8242         #
8243         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m1bis,m2,1e-10)
8244         expected1=[0,0,1,1,1,2,2,2]
8245         expected2=[0,-1,0,1,-1,1,2,-1]
8246         self.assertEqual(8,d1.getNumberOfTuples());
8247         self.assertEqual(8,d2.getNumberOfTuples());
8248         self.assertEqual(8,m3.getNumberOfCells());
8249         self.assertEqual(22,m3.getNumberOfNodes());
8250         self.assertEqual(2,m3.getSpaceDimension());
8251         self.assertEqual(expected1,d1.getValues());
8252         self.assertEqual(expected2,d2.getValues());
8253         expected3=[5,17,1,16,12,5,16,0,4,5,17,12,5,18,1,17,13,5,19,2,18,13,5,17,5,6,19,13,5,20,2,19,14,5,21,3,20,14,5,19,6,7,21,14]
8254         expected4=[0,5,12,17,22,28,33,38,44]
8255         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]
8256         self.assertEqual(44,m3.getNodalConnectivity().getNumberOfTuples());
8257         self.assertEqual(9,m3.getNodalConnectivityIndex().getNumberOfTuples());
8258         self.assertEqual(expected3,m3.getNodalConnectivity().getValues());
8259         self.assertEqual(expected4,m3.getNodalConnectivityIndex().getValues());
8260         for i in xrange(44):
8261             self.assertAlmostEqual(expected5[i],m3.getCoords().getIJ(0,i),12);
8262             pass
8263         pass
8264
8265     def testFindNodesOnLine1(self):
8266         mesh=MEDCouplingDataForTest.build2DTargetMesh_1();
8267         pt=[-0.3,-0.3]
8268         pt2=[0.,0.,0.]
8269         pt3=[-0.3,0.,0.]
8270         vec=[0.,1.]
8271         vec2=[1.,0.,0.]
8272         vec3=[0.,1.,1.]
8273         expected1=[0,3,6]
8274         res=mesh.findNodesOnLine(pt,vec,1e-12);
8275         self.assertEqual(3,len(res));
8276         self.assertEqual(expected1,res.getValues());
8277         #
8278         mesh.changeSpaceDimension(3);
8279         mesh.rotate(pt2,vec2,pi/4.);
8280         res=mesh.findNodesOnLine(pt3,vec3,1e-12);
8281         self.assertEqual(3,len(res));
8282         self.assertEqual(expected1,res.getValues());
8283         pass
8284
8285     def testIntersect2DMeshesTmp2(self):
8286         m1c=MEDCouplingCMesh.New();
8287         coordsX1=DataArrayDouble.New();
8288         arrX1=[ 0., 1., 1.5, 2. ]
8289         coordsX1.setValues(arrX1,4,1);
8290         m1c.setCoordsAt(0,coordsX1);
8291         coordsY1=DataArrayDouble.New();
8292         arrY1=[ 0., 1.5, 3.]
8293         coordsY1.setValues(arrY1,3,1);
8294         m1c.setCoordsAt(1,coordsY1);
8295         m1=m1c.buildUnstructured();
8296         m2c=MEDCouplingCMesh.New();
8297         coordsX2=DataArrayDouble.New();
8298         arrX2=[ 0., 1., 2. ]
8299         coordsX2.setValues(arrX2,3,1);
8300         m2c.setCoordsAt(0,coordsX2);
8301         coordsY2=DataArrayDouble.New();
8302         arrY2=[ 0., 1., 3.]
8303         coordsY2.setValues(arrY2,3,1);
8304         m2c.setCoordsAt(1,coordsY2);
8305         m2=m2c.buildUnstructured();
8306         #
8307         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m1,m2,1e-10)
8308         #
8309         expected1=[0,0,1,1,2,2,3,4,5]
8310         expected2=[0,2,1,3,1,3,2,3,3]
8311         self.assertEqual(9,d1.getNumberOfTuples());
8312         self.assertEqual(9,d2.getNumberOfTuples());
8313         self.assertEqual(9,m3.getNumberOfCells());
8314         self.assertEqual(22,m3.getNumberOfNodes());
8315         self.assertEqual(2,m3.getSpaceDimension());
8316         self.assertEqual(expected1,d1.getValues());
8317         self.assertEqual(expected2,d2.getValues());
8318         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]
8319         expected4=[0,5,10,15,20,25,30,35,40,45]
8320         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]
8321         self.assertEqual(45,m3.getNodalConnectivity().getNumberOfTuples());
8322         self.assertEqual(10,m3.getNodalConnectivityIndex().getNumberOfTuples());
8323         self.assertEqual(expected3,m3.getNodalConnectivity().getValues());
8324         self.assertEqual(expected4,m3.getNodalConnectivityIndex().getValues());
8325         for i in xrange(44):
8326             self.assertAlmostEqual(expected5[i],m3.getCoords().getIJ(0,i),12);
8327             pass
8328         pass
8329
8330     def testBuildPartOfMySelfSafe1(self):
8331         mesh=MEDCouplingDataForTest.build2DTargetMesh_1()
8332         self.assertRaises(InterpKernelException,mesh.buildPartOfMySelf,[0,-1,4,2],True)
8333         self.assertRaises(InterpKernelException,mesh.buildPartOfMySelf,[0,4,5,4],True)
8334         pass
8335
8336     def testIntersect2DMeshesTmp3(self):
8337         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];
8338         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];
8339         m1=MEDCouplingUMesh.New();
8340         m1.setMeshDimension(2);
8341         m1.allocateCells(8);
8342         m1.insertNextCell(NORM_TRI6,6,m1Conn[0:6]);
8343         m1.insertNextCell(NORM_QUAD8,8,m1Conn[6:14]);
8344         m1.insertNextCell(NORM_TRI6,6,m1Conn[14:20]);
8345         m1.insertNextCell(NORM_QUAD8,8,m1Conn[20:28]);
8346         m1.insertNextCell(NORM_TRI6,6,m1Conn[28:34]);
8347         m1.insertNextCell(NORM_QUAD8,8,m1Conn[34:42]);
8348         m1.insertNextCell(NORM_TRI6,6,m1Conn[42:48]);
8349         m1.insertNextCell(NORM_QUAD8,8,m1Conn[48:56]);
8350         m1.finishInsertingCells();
8351         myCoords1=DataArrayDouble.New();
8352         myCoords1.setValues(m1Coords,25,2);
8353         m1.setCoords(myCoords1);
8354         #
8355         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.]
8356         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]
8357         m2=MEDCouplingUMesh.New();
8358         m2.setMeshDimension(2);
8359         m2.allocateCells(8);
8360         for i in xrange(8):
8361             m2.insertNextCell(NORM_QUAD4,4,m2Conn[4*i:4*(i+1)])
8362             pass
8363         m2.finishInsertingCells();
8364         myCoords2=DataArrayDouble.New();
8365         myCoords2.setValues(m2Coords,15,2);
8366         m2.setCoords(myCoords2);
8367         #
8368         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m1,m2,1e-10)
8369         m3.unPolyze()
8370         #
8371         expected1=[0,1,1,1,2,3,3,3,4,5,5,5,6,7,7,7]
8372         expected2=[0,0,1,-1,2,2,3,-1,4,4,5,-1,6,6,7,-1]
8373         self.assertEqual(16,d1.getNumberOfTuples());
8374         self.assertEqual(16,d2.getNumberOfTuples());
8375         self.assertEqual(16,m3.getNumberOfCells());
8376         self.assertEqual(104,m3.getNumberOfNodes());
8377         self.assertEqual(2,m3.getSpaceDimension());
8378         self.assertEqual(expected1,d1.getValues());
8379         self.assertEqual(expected2,d2.getValues());
8380         expected3=[6,28,1,25,44,45,46,8,26,1,28,27,47,48,49,50,8,40,2,26,27,51,52,53,54,8,28,4,40,27,55,56,57,58,6,28,25,5,59,60,61,8,28,5,32,31,62,63,64,65,8,32,6,41,31,66,67,68,69,8,41,4,28,31,70,71,72,73,6,25,37,5,74,75,76,8,32,5,37,36,77,78,79,80,8,42,6,32,36,81,82,83,84,8,37,8,42,36,85,86,87,88,6,1,37,25,89,90,91,8,37,1,26,38,92,93,94,95,8,26,2,43,38,96,97,98,99,8,43,8,37,38,100,101,102,103]
8381         expected4=[0,7,16,25,34,41,50,59,68,75,84,93,102,109,118,127,136]
8382         expected5=[0.,0.,1.,0.,1.5,0.,0.,1.,0.,1.5,-1.,0.,-1.5,0.,0.,-1.,0.,-1.5,0.5,0.,1.25,0.,0.7071067811865476,0.7071067811865476,1.0606601717798214,1.0606601717798214,0.,0.5,0.,1.25,-0.7071067811865476,0.7071067811865476,-1.0606601717798214,1.0606601717798214,-0.5,0.,-1.25,0.,-0.7071067811865476,-0.7071067811865476,-1.0606601717798214,-1.0606601717798214,0.,-0.5,0.,-1.25,0.7071067811865476,-0.7071067811865476,1.0606601717798214,-1.0606601717798214,0.,0.,1.1,0.,1.1,1.,0.,1.,1.7,0.,1.7,1.,-1.1,1.,-1.1,0.,-1.7,0.,-1.7,1.,-1.7,-1.,-1.1,-1.,0.,-1.,1.1,-1.,1.7,-1.,1.118033988749895,1.,-1.118033988749895,1.,-1.118033988749895,-1.,1.118033988749895,-1.,0.7071067811865477,0.7071067811865476,0.5,0.,0.,0.5,1.05,0.,0.7071067811865475,0.7071067811865477,0.55,1.,1.1,0.5,1.4012585384440737,0.535233134659635,1.3,0.,1.1,0.5,1.1090169943749475,1.,0.,1.25,0.6123724356957946,1.369306393762915,1.1090169943749475,1.,0.55,1.,0.,0.5,-0.5,0.,-0.7071067811865477,0.7071067811865476,-0.7071067811865475,0.7071067811865477,-1.05,0.,-1.1,0.5,-0.55,1.,-1.3,0.,-1.4012585384440737,0.5352331346596344,-1.1090169943749475,1.,-1.1,0.5,-0.6123724356957941,1.3693063937629155,0.,1.25,-0.55,1.,-1.1090169943749475,1.,0.,-0.5,-0.7071067811865475,-0.7071067811865477,-0.5,0.,-1.05,0.,-0.7071067811865478,-0.7071067811865475,-0.55,-1.,-1.1,-0.5,-1.4012585384440734,-0.5352331346596354,-1.3,0.,-1.1,-0.5,-1.1090169943749475,-1.,0.,-1.25,-0.6123724356957945,-1.369306393762915,-1.1090169943749475,-1.,-0.55,-1.,0.7071067811865475,-0.7071067811865477,0.,-0.5,0.5,0.,0.7071067811865477,-0.7071067811865475,1.05,0.,1.1,-0.5,0.55,-1.,1.3,0.,1.4012585384440737,-0.535233134659635,1.1090169943749475,-1.,1.1,-0.5,0.6123724356957946,-1.369306393762915,0.,-1.25,0.55,-1.,1.1090169943749475,-1.0]
8383         self.assertEqual(136,m3.getNodalConnectivity().getNumberOfTuples());
8384         self.assertEqual(17,m3.getNodalConnectivityIndex().getNumberOfTuples());
8385         self.assertEqual(expected3,m3.getNodalConnectivity().getValues());
8386         self.assertEqual(expected4,m3.getNodalConnectivityIndex().getValues());
8387         for i in xrange(208):
8388             self.assertAlmostEqual(expected5[i],m3.getCoords().getIJ(0,i),12);
8389             pass
8390         pass
8391
8392     def testUMeshTessellate2D1(self):
8393         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];
8394         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];
8395         m1=MEDCouplingUMesh.New();
8396         m1.setMeshDimension(2);
8397         m1.allocateCells(8);
8398         m1.insertNextCell(NORM_TRI6,6,m1Conn[0:6]);
8399         m1.insertNextCell(NORM_QUAD8,8,m1Conn[6:14]);
8400         m1.insertNextCell(NORM_TRI6,6,m1Conn[14:20]);
8401         m1.insertNextCell(NORM_QUAD8,8,m1Conn[20:28]);
8402         m1.insertNextCell(NORM_TRI6,6,m1Conn[28:34]);
8403         m1.insertNextCell(NORM_QUAD8,8,m1Conn[34:42]);
8404         m1.insertNextCell(NORM_TRI6,6,m1Conn[42:48]);
8405         m1.insertNextCell(NORM_QUAD8,8,m1Conn[48:56]);
8406         m1.finishInsertingCells();
8407         myCoords1=DataArrayDouble.New();
8408         myCoords1.setValues(m1Coords,25,2);
8409         m1.setCoords(myCoords1);
8410         #
8411         m11=m1.deepCpy();
8412         m11.tessellate2D(1.);
8413         self.assertTrue(m11.getCoords().isEqual(m11.getCoords(),1e-12));
8414         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]
8415         expected2=[0,5,12,17,24,29,36,41,48]
8416         self.assertEqual(48,m11.getNodalConnectivity().getNumberOfTuples());
8417         self.assertEqual(9,m11.getNodalConnectivityIndex().getNumberOfTuples());
8418         self.assertEqual(expected1,m11.getNodalConnectivity().getValues());
8419         self.assertEqual(expected2,m11.getNodalConnectivityIndex().getValues());
8420         #
8421         m12=m1.deepCpy();
8422         m12.tessellate2D(0.5);
8423         self.assertEqual(41,m12.getNumberOfNodes());
8424         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]
8425         expected4=[0,6,15,21,30,36,45,51,60]
8426         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]
8427         for i in xrange(82):
8428             self.assertAlmostEqual(expected5[i],m12.getCoords().getIJ(0,i),12);
8429             pass
8430         self.assertEqual(60,m12.getNodalConnectivity().getNumberOfTuples());
8431         self.assertEqual(9,m12.getNodalConnectivityIndex().getNumberOfTuples());
8432         self.assertEqual(expected3,m12.getNodalConnectivity().getValues());
8433         self.assertEqual(expected4,m12.getNodalConnectivityIndex().getValues());
8434         pass
8435
8436     def testIntersect2DMeshesTmp4(self):
8437         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];
8438         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];
8439         m1=MEDCouplingUMesh.New();
8440         m1.setMeshDimension(2);
8441         m1.allocateCells(8);
8442         m1.insertNextCell(NORM_TRI6,6,m1Conn[0:6]);
8443         m1.insertNextCell(NORM_QUAD8,8,m1Conn[6:14]);
8444         m1.insertNextCell(NORM_TRI6,6,m1Conn[14:20]);
8445         m1.insertNextCell(NORM_QUAD8,8,m1Conn[20:28]);
8446         m1.insertNextCell(NORM_TRI6,6,m1Conn[28:34]);
8447         m1.insertNextCell(NORM_QUAD8,8,m1Conn[34:42]);
8448         m1.insertNextCell(NORM_TRI6,6,m1Conn[42:48]);
8449         m1.insertNextCell(NORM_QUAD8,8,m1Conn[48:56]);
8450         m1.finishInsertingCells();
8451         myCoords1=DataArrayDouble.New();
8452         myCoords1.setValues(m1Coords,25,2);
8453         m1.setCoords(myCoords1);
8454         #
8455         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.]
8456         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]
8457         m2=MEDCouplingUMesh.New();
8458         m2.setMeshDimension(2);
8459         m2.allocateCells(8);
8460         for i in xrange(8):
8461             m2.insertNextCell(NORM_QUAD4,4,m2Conn[4*i:4*(i+1)])
8462             pass
8463         m2.finishInsertingCells();
8464         myCoords2=DataArrayDouble.New();
8465         myCoords2.setValues(m2Coords,15,2);
8466         m2.setCoords(myCoords2);
8467         #
8468         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m2,m1,1e-10)
8469         m3.unPolyze()
8470         #
8471         expected1=[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
8472         expected2=[0,1,1,-1,2,3,3,-1,4,5,5,-1,6,7,7,-1]
8473         self.assertEqual(16,d1.getNumberOfTuples());
8474         self.assertEqual(16,d2.getNumberOfTuples());
8475         self.assertEqual(16,m3.getNumberOfCells());
8476         self.assertEqual(104,m3.getNumberOfNodes());
8477         self.assertEqual(2,m3.getSpaceDimension());
8478         self.assertEqual(expected1,d1.getValues());
8479         self.assertEqual(expected2,d2.getValues());
8480         expected3=[6,16,15,18,44,45,46,8,18,2,1,16,47,48,49,50,8,17,1,2,40,51,52,53,54,8,40,5,4,17,55,56,57,58,6,18,15,20,59,60,61,8,20,7,6,18,62,63,64,65,8,41,6,7,21,66,67,68,69,8,21,8,9,41,70,71,72,73,6,20,15,22,74,75,76,8,22,11,7,20,77,78,79,80,8,21,7,11,42,81,82,83,84,8,42,10,8,21,85,86,87,88,6,22,15,16,89,90,91,8,16,1,13,22,92,93,94,95,8,43,13,1,17,96,97,98,99,8,17,4,14,43,100,101,102,103]
8481         expected4=[0,7,16,25,34,41,50,59,68,75,84,93,102,109,118,127,136]
8482         expected5=[0.,0.,1.1, 0.,1.1,1.,0.,1.,1.7,0.,1.7,1.,-1.1,1.,-1.1,0.,-1.7,0.,-1.7,1.,-1.7,-1.,-1.1,-1.,0.,-1.,1.1,-1.,1.7,-1.,0.,0.,1.,0.,1.5,0.,0.,1.,0.,1.5,-1.,0.,-1.5,0.,0.,-1.,0.,-1.5,0.5,0.,1.25,0.,0.7071067811865476,0.7071067811865476,1.0606601717798214,1.0606601717798214,0.,0.5,0.,1.25,-0.7071067811865476,0.7071067811865476,-1.0606601717798214,1.0606601717798214,-0.5,0.,-1.25,0.,-0.7071067811865476,-0.7071067811865476,-1.0606601717798214,-1.0606601717798214,0.,-0.5,0.,-1.25,0.7071067811865476,-0.7071067811865476,1.0606601717798214,-1.0606601717798214,1.1180339887498951,1.,-1.1180339887498951,1.,-1.1180339887498951,-1.,1.1180339887498951,-1.,0.5,0.,0.,0.5,0.7071067811865477,0.7071067811865476,0.55,1.,1.1,0.5,1.05,0.,0.7071067811865477,0.7071067811865475,1.3,0.,1.1,0.5,1.1090169943749475,1.,1.4012585384440737,0.535233134659635,1.4090169943749475,1.,1.7,0.5,1.6,0.,1.4012585384440737,0.535233134659635,0.,0.5,-0.5,0.,-0.7071067811865477,0.7071067811865476,-1.05,0.,-1.1,0.5,-0.55,1.,-0.7071067811865478,0.7071067811865475,-1.1090169943749475,1.,-1.1,0.5,-1.3,0.,-1.4012585384440737,0.5352331346596344,-1.6,0.,-1.7,0.5,-1.4090169943749475,1.,-1.4012585384440737,0.5352331346596344,-0.5,0.,0.,-0.5,-0.7071067811865475,-0.7071067811865477,-0.55,-1.,-1.1,-0.5,-1.05,0.,-0.7071067811865475,-0.7071067811865477,-1.3,0.,-1.1,-0.5,-1.1090169943749475,-1.,-1.4012585384440734,-0.5352331346596354,-1.4090169943749475,-1.,-1.7,-0.5,-1.6,0.,-1.4012585384440732,-0.5352331346596354,0.,-0.5,0.5,0.,0.7071067811865475,-0.7071067811865477,1.05,0.,1.1,-0.5,0.55,-1.,0.7071067811865475,-0.7071067811865477,1.1090169943749475,-1.,1.1,-0.5,1.3,0.,1.4012585384440737,-0.535233134659635,1.6,0.,1.7,-0.5,1.4090169943749475,-1.,1.4012585384440737,-0.535233134659635]
8483         self.assertEqual(136,m3.getNodalConnectivity().getNumberOfTuples());
8484         self.assertEqual(17,m3.getNodalConnectivityIndex().getNumberOfTuples());
8485         self.assertEqual(expected3,m3.getNodalConnectivity().getValues());
8486         self.assertEqual(expected4,m3.getNodalConnectivityIndex().getValues());
8487         for i in xrange(208):
8488             self.assertAlmostEqual(expected5[i],m3.getCoords().getIJ(0,i),12);
8489             pass
8490         pass
8491
8492     def testGetCellIdsCrossingPlane1(self):
8493         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
8494         vec=[-0.07,1.,0.07]
8495         origin=[1.524,1.4552,1.74768]
8496         ids1=mesh3D.getCellIdsCrossingPlane(origin,vec,1e-10)
8497         self.assertEqual([1,3,4,7,9,10,13,15,16],ids1.getValues())
8498         vec2=[0.,0.,1.]
8499         ids2=mesh3D.getCellIdsCrossingPlane(origin,vec2,1e-10)
8500         self.assertEqual([6,7,8,9,10,11],ids2.getValues())
8501         pass
8502
8503     def testBuildSlice3D1(self):
8504         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
8505         vec1=[-0.07,1.,0.07]
8506         origin1=[1.524,1.4552,1.74768]
8507         slice1,ids=mesh3D.buildSlice3D(origin1,vec1,1e-10);
8508         expected1=[1,3,4,7,9,10,13,15,16]
8509         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]
8510         expected3=[0,6,11,17,22,27,32,37,42,47]
8511         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.]
8512         self.assertEqual(2,slice1.getMeshDimension());
8513         self.assertEqual(3,slice1.getSpaceDimension());
8514         self.assertEqual(57,slice1.getNumberOfNodes());
8515         self.assertEqual(9,slice1.getNumberOfCells());
8516         self.assertEqual(9,ids.getNumberOfTuples());
8517         self.assertEqual(47,slice1.getNodalConnectivity().getNumberOfTuples());
8518         self.assertEqual(10,slice1.getNodalConnectivityIndex().getNumberOfTuples());
8519         self.assertEqual(expected1,ids.getValues());
8520         self.assertEqual(expected2,slice1.getNodalConnectivity().getValues());
8521         self.assertEqual(expected3,slice1.getNodalConnectivityIndex().getValues());
8522         for i in xrange(171):
8523             self.assertAlmostEqual(expected4[i],slice1.getCoords().getIJ(0,i),12);
8524             pass
8525         # 2nd slice based on already existing nodes of mesh3D.
8526         vec2=[0.,3.,1.]
8527         origin2=[2.5,1.,3.]
8528         slice1,ids=mesh3D.buildSlice3D(origin2,vec2,1e-10);
8529         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]
8530         expected6=[0,5,10,15,21,26,32,38,43,49]
8531         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]
8532         self.assertEqual(2,slice1.getMeshDimension());
8533         self.assertEqual(3,slice1.getSpaceDimension());
8534         self.assertEqual(60,slice1.getNumberOfNodes());
8535         self.assertEqual(9,slice1.getNumberOfCells());
8536         self.assertEqual(9,ids.getNumberOfTuples());
8537         self.assertEqual(49,slice1.getNodalConnectivity().getNumberOfTuples());
8538         self.assertEqual(10,slice1.getNodalConnectivityIndex().getNumberOfTuples());
8539         self.assertEqual(expected1,ids.getValues());
8540         self.assertEqual(expected5,slice1.getNodalConnectivity().getValues());
8541         self.assertEqual(expected6,slice1.getNodalConnectivityIndex().getValues());
8542         for i in xrange(180):
8543             self.assertAlmostEqual(expected7[i],slice1.getCoords().getIJ(0,i),12);
8544             pass
8545         # 3rd slice based on shared face of mesh3D.
8546         vec3=[0.,0.,1.]
8547         origin3=[2.5,1.,2.]
8548         slice1,ids=mesh3D.buildSlice3D(origin3,vec3,1e-10);
8549         expected8=[6,7,8,9,10,11,12,13,14,15,16,17]
8550         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]
8551         expected10=[0,5,12,17,22,29,34,39,46,51,56,63,68]
8552         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.]
8553         self.assertEqual(2,slice1.getMeshDimension());
8554         self.assertEqual(3,slice1.getSpaceDimension());
8555         self.assertEqual(45,slice1.getNumberOfNodes());
8556         self.assertEqual(12,slice1.getNumberOfCells());
8557         self.assertEqual(12,ids.getNumberOfTuples());
8558         self.assertEqual(68,slice1.getNodalConnectivity().getNumberOfTuples());
8559         self.assertEqual(13,slice1.getNodalConnectivityIndex().getNumberOfTuples());
8560         self.assertEqual(expected8,ids.getValues());
8561         self.assertEqual(expected9,slice1.getNodalConnectivity().getValues());
8562         self.assertEqual(expected10,slice1.getNodalConnectivityIndex().getValues());
8563         for i in xrange(135):
8564             self.assertAlmostEqual(expected11[i],slice1.getCoords().getIJ(0,i),12);
8565             pass
8566         pass
8567
8568     def testBuildSlice3DSurf1(self):
8569         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
8570         mesh2D=mesh3D.buildDescendingConnectivity()[0];
8571         vec1=[-0.07,1.,0.07]
8572         origin1=[1.524,1.4552,1.74768]
8573         slice1,ids=mesh2D.buildSlice3DSurf(origin1,vec1,1e-10);
8574         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]
8575         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]
8576         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];
8577         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.]
8578         self.assertEqual(1,slice1.getMeshDimension());
8579         self.assertEqual(3,slice1.getSpaceDimension());
8580         self.assertEqual(57,slice1.getNumberOfNodes());
8581         self.assertEqual(25,slice1.getNumberOfCells());
8582         self.assertEqual(25,ids.getNumberOfTuples());
8583         self.assertEqual(75,slice1.getNodalConnectivity().getNumberOfTuples());
8584         self.assertEqual(26,slice1.getNodalConnectivityIndex().getNumberOfTuples());
8585         self.assertEqual(expected1,ids.getValues());
8586         self.assertEqual(expected2,slice1.getNodalConnectivity().getValues());
8587         self.assertEqual(expected3,slice1.getNodalConnectivityIndex().getValues());
8588         for i in xrange(171):
8589             self.assertAlmostEqual(expected4[i],slice1.getCoords().getIJ(0,i),12);
8590             pass
8591         #
8592         vec2=[0.,0.,1.]
8593         origin2=[2.5,1.,2.]
8594         slice1,ids=mesh2D.buildSlice3DSurf(origin2,vec2,1e-10);
8595         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]
8596         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]
8597         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];
8598         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.]
8599         self.assertEqual(1,slice1.getMeshDimension());
8600         self.assertEqual(3,slice1.getSpaceDimension());
8601         self.assertEqual(45,slice1.getNumberOfNodes());
8602         self.assertEqual(68,slice1.getNumberOfCells());
8603         self.assertEqual(68,ids.getNumberOfTuples());
8604         self.assertEqual(204,slice1.getNodalConnectivity().getNumberOfTuples());
8605         self.assertEqual(69,slice1.getNodalConnectivityIndex().getNumberOfTuples());
8606         self.assertEqual(expected5,ids.getValues());
8607         self.assertEqual(expected6,slice1.getNodalConnectivity().getValues());
8608         self.assertEqual(expected7,slice1.getNodalConnectivityIndex().getValues());
8609         for i in xrange(135):
8610             self.assertAlmostEqual(expected8[i],slice1.getCoords().getIJ(0,i),12);
8611             pass
8612         pass
8613
8614     def testDataArrayDoubleAdvSetting1(self):
8615         data1=[1.,11.,2.,12.,3.,13.,4.,14.,5.,15.,6.,16.,7.,17.]
8616         data2=[8.,38.,9.,39.,0.,30.,11.,41.,12.,42.]
8617         compsCpp=["comp1","comp2"]
8618         da=DataArrayDouble.New();
8619         da.setInfoAndChangeNbOfCompo(compsCpp);
8620         da.setName("da");
8621         da.alloc(7,2);
8622         compsCpp=compsCpp[:-1]
8623         self.assertRaises(InterpKernelException,da.setInfoAndChangeNbOfCompo,compsCpp);
8624         da.setValues(data1,7,2)
8625         #
8626         p=[(0,3),(3,5),(5,7)]
8627         tmp=da.selectByTupleRanges(p);
8628         self.assertTrue(tmp.isEqual(da,1e-14));
8629         p=[(0,2),(3,4),(5,7)]
8630         tmp=da.selectByTupleRanges(p);
8631         expected1=[1.,11.,2.,12.,4.,14.,6.,16.,7.,17.]
8632         self.assertEqual(5,tmp.getNumberOfTuples());
8633         self.assertEqual(2,tmp.getNumberOfComponents());
8634         for i in xrange(10):
8635             self.assertAlmostEqual(expected1[i],tmp.getIJ(0,i),14);
8636             pass
8637         p=[(0,2),(0,2),(5,6)]
8638         tmp=da.selectByTupleRanges(p);
8639         expected2=[1.,11.,2.,12.,1.,11.,2.,12.,6.,16.]
8640         self.assertEqual(5,tmp.getNumberOfTuples());
8641         self.assertEqual(2,tmp.getNumberOfComponents());
8642         for i in xrange(10):
8643             self.assertAlmostEqual(expected2[i],tmp.getIJ(0,i),14);
8644             pass
8645         p=[(0,2),(-1,2),(5,6)]
8646         self.assertRaises(InterpKernelException,da.selectByTupleRanges,p);
8647         p=[(0,2),(0,2),(5,8)]
8648         self.assertRaises(InterpKernelException,da.selectByTupleRanges,p);
8649         #
8650         da2=DataArrayDouble.New();
8651         da2.setValues(data2,5,2);
8652         #
8653         dac=da.deepCpy();
8654         dac.setContigPartOfSelectedValues2(1,da2,2,4,1);
8655         expected3=[1.,11.,0.,30.,11.,41.,4.,14.,5.,15.,6.,16.,7.,17.]
8656         for i in xrange(14):
8657             self.assertAlmostEqual(expected3[i],dac.getIJ(0,i),14);
8658             pass
8659         #
8660         dac=da.deepCpy();
8661         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,3,da2,0,5,1);
8662         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,0,da2,4,6,1);
8663         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,3,da2,5,0,1);
8664         dac.setContigPartOfSelectedValues2(3,da2,1,5,1);
8665         expected4=[1.,11.,2.,12.,3.,13.,9.,39.,0.,30.,11.,41.,12.,42.]
8666         for i in xrange(14):
8667             self.assertAlmostEqual(expected4[i],dac.getIJ(0,i),14);
8668             pass
8669         #
8670         ids=DataArrayInt.New();
8671         ids.alloc(3,1);
8672         dac=da.deepCpy();
8673         ids.setIJ(0,0,2); ids.setIJ(1,0,0); ids.setIJ(2,0,4);
8674         dac.setContigPartOfSelectedValues(2,da2,ids);
8675         expected5=[1.,11.,2.,12.,0.,30.,8.,38.,12.,42.,6.,16.,7.,17.]
8676         for i in xrange(14):
8677             self.assertAlmostEqual(expected5[i],dac.getIJ(0,i),14);
8678             pass
8679         #
8680         dac=da.deepCpy();
8681         ids.setIJ(0,0,2); ids.setIJ(1,0,5); ids.setIJ(2,0,4);
8682         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,1,da2,ids);
8683         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,-1);
8684         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,1,da2,ids);
8685         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,1);
8686         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,5,da2,ids);
8687         #
8688         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,1);
8689         dac=da.deepCpy();
8690         dac.setContigPartOfSelectedValues(4,da2,ids);
8691         expected6=[1.,11.,2.,12.,3.,13.,4.,14.,0.,30.,0.,30.,9.,39.]
8692         for i in xrange(14):
8693             self.assertAlmostEqual(expected6[i],dac.getIJ(0,i),14);
8694             pass
8695         pass
8696
8697     def testDataArrayIntAdvSetting1(self):
8698         data1=[1,11,2,12,3,13,4,14,5,15,6,16,7,17]
8699         data2=[8,38,9,39,0,30,11,41,12,42]
8700         compsCpp=["comp1","comp2"]
8701         da=DataArrayInt.New();
8702         da.setInfoAndChangeNbOfCompo(compsCpp);
8703         da.setName("da");
8704         da.alloc(7,2);
8705         compsCpp=compsCpp[:-1]
8706         self.assertRaises(InterpKernelException,da.setInfoAndChangeNbOfCompo,compsCpp);
8707         da.setValues(data1,7,2)
8708         #
8709         p=[(0,3),(3,5),(5,7)]
8710         tmp=da.selectByTupleRanges(p);
8711         self.assertTrue(tmp.isEqual(da));
8712         p=[(0,2),(3,4),(5,7)]
8713         tmp=da.selectByTupleRanges(p);
8714         expected1=[1,11,2,12,4,14,6,16,7,17]
8715         self.assertEqual(5,tmp.getNumberOfTuples());
8716         self.assertEqual(2,tmp.getNumberOfComponents());
8717         for i in xrange(10):
8718             self.assertEqual(expected1[i],tmp.getIJ(0,i));
8719             pass
8720         p=[(0,2),(0,2),(5,6)]
8721         tmp=da.selectByTupleRanges(p);
8722         expected2=[1,11,2,12,1,11,2,12,6,16]
8723         self.assertEqual(5,tmp.getNumberOfTuples());
8724         self.assertEqual(2,tmp.getNumberOfComponents());
8725         for i in xrange(10):
8726             self.assertEqual(expected2[i],tmp.getIJ(0,i));
8727             pass
8728         p=[(0,2),(-1,2),(5,6)]
8729         self.assertRaises(InterpKernelException,da.selectByTupleRanges,p);
8730         p=[(0,2),(0,2),(5,8)]
8731         self.assertRaises(InterpKernelException,da.selectByTupleRanges,p);
8732         #
8733         da2=DataArrayInt.New();
8734         da2.setValues(data2,5,2);
8735         #
8736         dac=da.deepCpy();
8737         dac.setContigPartOfSelectedValues2(1,da2,2,4,1);
8738         expected3=[1,11,0,30,11,41,4,14,5,15,6,16,7,17]
8739         for i in xrange(14):
8740             self.assertEqual(expected3[i],dac.getIJ(0,i));
8741             pass
8742         #
8743         dac=da.deepCpy();
8744         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,3,da2,0,5,1);
8745         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,0,da2,4,6,1);
8746         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues2,3,da2,5,0,1);
8747         dac.setContigPartOfSelectedValues2(3,da2,1,5,1);
8748         expected4=[1,11,2,12,3,13,9,39,0,30,11,41,12,42]
8749         for i in xrange(14):
8750             self.assertEqual(expected4[i],dac.getIJ(0,i));
8751             pass
8752         #
8753         ids=DataArrayInt.New();
8754         ids.alloc(3,1);
8755         dac=da.deepCpy();
8756         ids.setIJ(0,0,2); ids.setIJ(1,0,0); ids.setIJ(2,0,4);
8757         dac.setContigPartOfSelectedValues(2,da2,ids);
8758         expected5=[1,11,2,12,0,30,8,38,12,42,6,16,7,17]
8759         for i in xrange(14):
8760             self.assertEqual(expected5[i],dac.getIJ(0,i));
8761             pass
8762         #
8763         dac=da.deepCpy();
8764         ids.setIJ(0,0,2); ids.setIJ(1,0,5); ids.setIJ(2,0,4);
8765         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,1,da2,ids);
8766         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,-1);
8767         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,1,da2,ids);
8768         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,1);
8769         self.assertRaises(InterpKernelException,dac.setContigPartOfSelectedValues,5,da2,ids);
8770         #
8771         ids.setIJ(0,0,2); ids.setIJ(1,0,2); ids.setIJ(2,0,1);
8772         dac=da.deepCpy();
8773         dac.setContigPartOfSelectedValues(4,da2,ids);
8774         expected6=[1,11,2,12,3,13,4,14,0,30,0,30,9,39]
8775         for i in xrange(14):
8776             self.assertEqual(expected6[i],dac.getIJ(0,i));
8777             pass
8778         pass
8779
8780     def testBuildDescendingConnec2Of3DMesh1(self):
8781         mesh=MEDCouplingDataForTest.build3DSourceMesh_1();
8782         #
8783         mesh2,desc,descIndx,revDesc,revDescIndx=mesh.buildDescendingConnectivity2();
8784         mesh2.checkCoherency();
8785         self.assertEqual(2,mesh2.getMeshDimension());
8786         self.assertEqual(30,mesh2.getNumberOfCells());
8787         self.assertEqual(31,revDescIndx.getNbOfElems()); self.assertEqual(31,revDescIndx.getNumberOfTuples());
8788         self.assertEqual(13,descIndx.getNbOfElems()); self.assertEqual(13,descIndx.getNumberOfTuples());
8789         self.assertEqual(48,desc.getNbOfElems()); self.assertEqual(48,desc.getNumberOfTuples());
8790         self.assertEqual(48,revDesc.getNbOfElems()); self.assertEqual(48,revDesc.getNumberOfTuples());
8791         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]
8792         self.assertEqual(expected1,desc.getValues());
8793         expected2=[0,4,8,12,16,20,24,28,32,36,40,44,48]
8794         self.assertEqual(expected2,descIndx.getValues());
8795         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]
8796         self.assertEqual(expected3,revDescIndx.getValues());
8797         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]
8798         self.assertEqual(expected4,revDesc.getValues());
8799         conn=mesh2.getNodalConnectivity();
8800         connIndex=mesh2.getNodalConnectivityIndex();
8801         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]
8802         self.assertEqual(expected5,connIndex.getValues());
8803         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]
8804         self.assertEqual(expected6,conn.getValues());
8805         pass
8806
8807     def testAre2DCellsNotCorrectlyOriented1(self):
8808         m1Coords=[1.,1.,-1.,-1.,-1.,-1.,1.,-1.]
8809         m1Conn=[0,3,1,2]
8810         m1=MEDCouplingUMesh.New();
8811         m1.setMeshDimension(2);
8812         m1.allocateCells(1);
8813         m1.insertNextCell(NORM_QUAD4,4,m1Conn[0:4])
8814         m1.finishInsertingCells();
8815         myCoords1=DataArrayDouble.New();
8816         myCoords1.setValues(m1Coords,4,2);
8817         m1.setCoords(myCoords1);
8818         #
8819         vec1=[0.,0.,1.]
8820         for i in xrange(18):
8821             vec2=[3.*cos(pi/9.*i),3.*sin(pi/9.*i)];
8822             m1Cpy=m1.deepCpy();
8823             m1Cpy.translate(vec2);
8824             self.assertRaises(InterpKernelException,m1Cpy.are2DCellsNotCorrectlyOriented,vec1,False);
8825             m1Cpy.changeSpaceDimension(3);
8826             res=m1Cpy.are2DCellsNotCorrectlyOriented(vec1,False)
8827             self.assertEqual([0],res.getValues());
8828             pass
8829         pass
8830
8831     def testDataArrayAbs1(self):
8832         d1=DataArrayDouble.New();
8833         val1=[2.,-3.,-5.,6.,-7.,-8.,9.,10.,-11.,-12.,-13.,-15.]
8834         expected1=[2.,3.,5.,6.,7.,8.,9.,10.,11.,12.,13.,15.]
8835         d1.setValues(val1,6,2);
8836         d2=d1.convertToIntArr();
8837         #
8838         d1.abs();
8839         for i in xrange(12):
8840             self.assertAlmostEqual(expected1[i],d1.getIJ(0,i),14);
8841             pass
8842         #
8843         expected2=[2,3,5,6,7,8,9,10,11,12,13,15]
8844         d2.abs();
8845         for i in xrange(12):
8846             self.assertEqual(expected2[i],d2.getIJ(0,i));
8847             pass
8848         #
8849         pass
8850
8851     # test on 1D
8852     def testGetValueOn3(self):
8853         v=[0.,1.,1.5,2.]
8854         v2=[0.7,1.25,0.,2.,1.5]
8855         disp=[5.,50.,500.,6.,60.,600.,7.,70.,700.,8.,80.,800.]
8856         m=MEDCouplingUMesh.New("myMesh",1)
8857         nbNodes=len(v)
8858         nbCells=nbNodes-1
8859         m.allocateCells(nbCells)
8860         coords=DataArrayDouble.New() ; coords.setValues(v,nbNodes,1)
8861         m.setCoords(coords)
8862         m.insertNextCell(NORM_SEG2,2,[0,1])
8863         m.insertNextCell(NORM_SEG2,2,[2,1])
8864         m.insertNextCell(NORM_SEG2,2,[2,3])
8865         m.finishInsertingCells()
8866         f=MEDCouplingFieldDouble.New(ON_NODES)
8867         f.setMesh(m)
8868         array=DataArrayDouble.New(); array.setValues(disp,m.getNumberOfNodes(),3)
8869         f.setArray(array)
8870         arr1=f.getValueOnMulti(v2)
8871         self.assertEqual(5,arr1.getNumberOfTuples());
8872         self.assertEqual(3,arr1.getNumberOfComponents());
8873         expected1=[5.7,57.,570.,6.5,65.,650.,5.,50.,500.,8.,80.,800.,7.,70.,700.]
8874         for i in xrange(15):
8875             self.assertAlmostEqual(expected1[i],arr1.getIJ(0,i),14);
8876             pass
8877         pass
8878
8879     def testGetNodeIdsOfCell2(self):
8880         m1c=MEDCouplingCMesh.New();
8881         coordsX=DataArrayDouble.New();
8882         arrX=[ -1., 1., 2., 4., 4.5 ]
8883         coordsX.setValues(arrX,5,1);
8884         coordsY=DataArrayDouble.New();
8885         arrY=[ -2., 2., 4., 8.]
8886         coordsY.setValues(arrY,4,1);
8887         coordsZ=DataArrayDouble.New();
8888         arrZ=[ -2., 2., 4.]
8889         coordsZ.setValues(arrZ,3,1);
8890         # test in 1D
8891         m1c.setCoordsAt(0,coordsX);
8892         expected1=[[0,1],[1,2],[2,3],[3,4]]
8893         self.assertEqual(4,m1c.getNumberOfCells())
8894         for i in xrange(m1c.getNumberOfCells()):
8895             self.assertEqual(expected1[i],m1c.getNodeIdsOfCell(i))
8896             pass
8897         # test in 2D
8898         m1c.setCoordsAt(1,coordsY);
8899         self.assertEqual(12,m1c.getNumberOfCells())
8900         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]]
8901         for i in xrange(m1c.getNumberOfCells()):
8902             self.assertEqual(expected2[i],m1c.getNodeIdsOfCell(i))
8903             pass
8904         # test in 3D
8905         m1c.setCoordsAt(2,coordsZ);
8906         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]]
8907         self.assertEqual(24,m1c.getNumberOfCells())
8908         for i in xrange(m1c.getNumberOfCells()):
8909             self.assertEqual(expected3[i],m1c.getNodeIdsOfCell(i))
8910             pass
8911         pass
8912
8913     def testSwigDADOp4(self):
8914         da=DataArrayDouble.New(range(6,30),12,2)
8915         self.assertEqual(12,da.getNumberOfTuples());
8916         self.assertEqual(2,da.getNumberOfComponents());
8917         for i in xrange(24):
8918             self.assertAlmostEqual(da.getIJ(0,i),float(i+6),13)
8919             pass
8920         # operator transpose
8921         da.transpose()
8922         self.assertEqual(2,da.getNumberOfTuples());
8923         self.assertEqual(12,da.getNumberOfComponents());
8924         for i in xrange(24):
8925             self.assertAlmostEqual(da.getIJ(0,i),float(i+6),13)
8926             pass
8927         da.transpose()
8928         # operator __neg__
8929         da2=DataArrayDouble.New(12,1)
8930         da2.iota(0.)
8931         dabis=-da
8932         for i in xrange(24):
8933             self.assertAlmostEqual(dabis.getIJ(0,i),-float(i+6),13)
8934             pass
8935         # operator+=
8936         da+=da2
8937         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.]
8938         for i in xrange(24):
8939             self.assertAlmostEqual(da.getIJ(0,i),expected1[i],13)
8940             pass
8941         da=-dabis
8942         da+=[100.,101.]
8943         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.]
8944         self.assertEqual(12,da.getNumberOfTuples());
8945         self.assertEqual(2,da.getNumberOfComponents());
8946         for i in xrange(24):
8947             self.assertAlmostEqual(da.getIJ(0,i),expected2[i],13)
8948             pass
8949         for pos,elt in enumerate(dabis):
8950             da[pos]+=elt
8951             pass
8952         self.assertEqual(12,da.getNumberOfTuples());
8953         self.assertEqual(2,da.getNumberOfComponents());
8954         for elt in da:
8955             li=elt[:]
8956             self.assertAlmostEqual(li[0],100.,13) ; self.assertAlmostEqual(li[1],101.,13)
8957             pass
8958         # operator-=
8959         da=DataArrayDouble.New(range(6,30),12,2)
8960         da2=DataArrayDouble.New(range(12),12,1)
8961         dabis=-da
8962         da-=da2
8963         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.]
8964         for i in xrange(24):
8965             self.assertAlmostEqual(da.getIJ(0,i),expected1[i],13)
8966             pass
8967         da=-dabis
8968         da-=[100.,101.]
8969         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.]
8970         self.assertEqual(12,da.getNumberOfTuples());
8971         self.assertEqual(2,da.getNumberOfComponents());
8972         for i in xrange(24):
8973             self.assertAlmostEqual(da.getIJ(0,i),expected2[i],13)
8974             pass
8975         for pos,elt in enumerate(dabis):
8976             da[pos]-=elt
8977             pass
8978         self.assertEqual(12,da.getNumberOfTuples());
8979         self.assertEqual(2,da.getNumberOfComponents());
8980         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.]
8981         for i in xrange(24):
8982             self.assertAlmostEqual(da.getIJ(0,i),expected3[i],13)
8983             pass
8984         # operator*=
8985         da=DataArrayDouble.New(range(6,30),12,2)
8986         da2=DataArrayDouble.New(range(12),12,1)
8987         dabis=-da
8988         da*=da2
8989         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.]
8990         for i in xrange(24):
8991             self.assertAlmostEqual(da.getIJ(0,i),expected1[i],13)
8992             pass
8993         da=-dabis
8994         da*=[100.,101.]
8995         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.]
8996         self.assertEqual(12,da.getNumberOfTuples());
8997         self.assertEqual(2,da.getNumberOfComponents());
8998         for i in xrange(24):
8999             self.assertAlmostEqual(da.getIJ(0,i),expected2[i],13)
9000             pass
9001         for pos,elt in enumerate(dabis):
9002             da[pos]*=elt
9003             pass
9004         self.assertEqual(12,da.getNumberOfTuples());
9005         self.assertEqual(2,da.getNumberOfComponents());
9006         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]
9007         for i in xrange(24):
9008             self.assertAlmostEqual(da.getIJ(0,i),expected3[i],13)
9009             pass
9010         # operator/=
9011         da=DataArrayDouble.New(range(6,30),12,2)
9012         da2=DataArrayDouble.New(range(1,13),12,1)
9013         dabis=-da
9014         da/=da2
9015         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]
9016         for i in xrange(24):
9017             self.assertAlmostEqual(da.getIJ(0,i),expected1[i],13)
9018             pass
9019         da=-dabis
9020         da/=[100.,101.]
9021         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]
9022         self.assertEqual(12,da.getNumberOfTuples());
9023         self.assertEqual(2,da.getNumberOfComponents());
9024         for i in xrange(24):
9025             self.assertAlmostEqual(da.getIJ(0,i),expected2[i],13)
9026             pass
9027         for pos,elt in enumerate(dabis):
9028             da[pos]/=elt
9029             pass
9030         self.assertEqual(12,da.getNumberOfTuples());
9031         self.assertEqual(2,da.getNumberOfComponents());
9032         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]
9033         for i in xrange(24):
9034             self.assertAlmostEqual(da.getIJ(0,i),expected3[i],13)
9035             pass
9036         pass
9037
9038     def testSwigDAIOp4(self):
9039         da=DataArrayInt.New(range(6,30),12,2)
9040         self.assertEqual(12,da.getNumberOfTuples());
9041         self.assertEqual(2,da.getNumberOfComponents());
9042         for i in xrange(24):
9043             self.assertEqual(da.getIJ(0,i),i+6)
9044             pass
9045         # operator transpose
9046         da.transpose()
9047         self.assertEqual(2,da.getNumberOfTuples());
9048         self.assertEqual(12,da.getNumberOfComponents());
9049         for i in xrange(24):
9050             self.assertEqual(da.getIJ(0,i),i+6)
9051             pass
9052         da.transpose()
9053         # operator __neg__
9054         da2=DataArrayInt.New(12,1)
9055         da2.iota(0)
9056         dabis=-da
9057         for i in xrange(24):
9058             self.assertEqual(dabis.getIJ(0,i),-(i+6))
9059             pass
9060         # operator+=
9061         da+=da2
9062         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]
9063         for i in xrange(24):
9064             self.assertEqual(da.getIJ(0,i),expected1[i])
9065             pass
9066         da=-dabis
9067         da+=[100,101]
9068         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]
9069         self.assertEqual(12,da.getNumberOfTuples());
9070         self.assertEqual(2,da.getNumberOfComponents());
9071         for i in xrange(24):
9072             self.assertEqual(da.getIJ(0,i),expected2[i])
9073             pass
9074         for pos,elt in enumerate(dabis):
9075             da[pos]+=elt
9076             pass
9077         self.assertEqual(12,da.getNumberOfTuples());
9078         self.assertEqual(2,da.getNumberOfComponents());
9079         for elt in da:
9080             li=elt[:]
9081             self.assertEqual(li[0],100) ; self.assertEqual(li[1],101)
9082             pass
9083         # operator-=
9084         da=DataArrayInt.New(range(6,30),12,2)
9085         da2=DataArrayInt.New(range(12),12,1)
9086         dabis=-da
9087         da-=da2
9088         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]
9089         for i in xrange(24):
9090             self.assertEqual(da.getIJ(0,i),expected1[i])
9091             pass
9092         da=-dabis
9093         da-=[100,101]
9094         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]
9095         self.assertEqual(12,da.getNumberOfTuples());
9096         self.assertEqual(2,da.getNumberOfComponents());
9097         for i in xrange(24):
9098             self.assertEqual(da.getIJ(0,i),expected2[i])
9099             pass
9100         for pos,elt in enumerate(dabis):
9101             da[pos]-=elt
9102             pass
9103         self.assertEqual(12,da.getNumberOfTuples());
9104         self.assertEqual(2,da.getNumberOfComponents());
9105         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]
9106         for i in xrange(24):
9107             self.assertEqual(da.getIJ(0,i),expected3[i])
9108             pass
9109         # operator*=
9110         da=DataArrayInt.New(range(6,30),12,2)
9111         da2=DataArrayInt.New(range(12),12,1)
9112         dabis=-da
9113         da*=da2
9114         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]
9115         for i in xrange(24):
9116             self.assertEqual(da.getIJ(0,i),expected1[i])
9117             pass
9118         da=-dabis
9119         da*=[100,101]
9120         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]
9121         self.assertEqual(12,da.getNumberOfTuples());
9122         self.assertEqual(2,da.getNumberOfComponents());
9123         for i in xrange(24):
9124             self.assertEqual(da.getIJ(0,i),expected2[i])
9125             pass
9126         for pos,elt in enumerate(dabis):
9127             da[pos]*=elt
9128             pass
9129         self.assertEqual(12,da.getNumberOfTuples());
9130         self.assertEqual(2,da.getNumberOfComponents());
9131         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]
9132         for i in xrange(24):
9133             self.assertEqual(da.getIJ(0,i),expected3[i])
9134             pass
9135         # operator/=
9136         da=DataArrayInt.New(range(6,30),12,2)
9137         da2=DataArrayInt.New(range(1,13),12,1)
9138         dabis=-da
9139         da/=da2
9140         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]
9141         for i in xrange(24):
9142             self.assertEqual(da.getIJ(0,i),expected1[i])
9143             pass
9144         da=-dabis
9145         da/=DataArrayInt.New([2,3],1,2)
9146         self.assertEqual(12,da.getNumberOfTuples());
9147         self.assertEqual(2,da.getNumberOfComponents());
9148         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]
9149         for i in xrange(24):
9150             self.assertEqual(da.getIJ(0,i),expected2[i])
9151             pass
9152         pass
9153
9154     def testSwigDADOp5(self):
9155         da=DataArrayDouble.New([5,6,7,8,9,6,7,-2,3,9,8,10])
9156         da.rearrange(3)
9157         da2=DataArrayDouble.New([5.,8.,10.,12])
9158         self.assertEqual(4,da2.getNumberOfTuples());
9159         self.assertEqual(1,da2.getNumberOfComponents());
9160         da3=da+da2
9161         self.assertEqual(4,da3.getNumberOfTuples());
9162         self.assertEqual(3,da3.getNumberOfComponents());
9163         expected1=[10.,11.,12.,16.,17.,14.,17.,8.,13.,21.,20.,22.]
9164         for i in xrange(12):
9165             self.assertAlmostEqual(da3.getIJ(0,i),expected1[i],13)
9166             pass
9167         da3=da2+da
9168         self.assertEqual(4,da3.getNumberOfTuples());
9169         self.assertEqual(3,da3.getNumberOfComponents());
9170         for i in xrange(12):
9171             self.assertAlmostEqual(da3.getIJ(0,i),expected1[i],13)
9172             pass
9173         # Test new API of classmethod DataArrayDouble.New
9174         vals=[5,6,7,8,9,6,7,-2,3,9,8,10]
9175         da=DataArrayDouble.New(vals)
9176         self.assertEqual(12,da.getNumberOfTuples());
9177         self.assertEqual(1,da.getNumberOfComponents());
9178         for i in xrange(12):
9179             self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
9180             pass
9181         da=DataArrayDouble.New(vals,12)
9182         self.assertEqual(12,da.getNumberOfTuples());
9183         self.assertEqual(1,da.getNumberOfComponents());
9184         for i in xrange(12):
9185             self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
9186             pass
9187         da=DataArrayDouble.New(vals,1,12)
9188         self.assertEqual(1,da.getNumberOfTuples());
9189         self.assertEqual(12,da.getNumberOfComponents());
9190         for i in xrange(12):
9191             self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
9192             pass
9193         da=DataArrayDouble.New(vals,6,2)
9194         self.assertEqual(6,da.getNumberOfTuples());
9195         self.assertEqual(2,da.getNumberOfComponents());
9196         for i in xrange(12):
9197             self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
9198             pass
9199         da=DataArrayDouble.New(vals,4,3)
9200         self.assertEqual(4,da.getNumberOfTuples());
9201         self.assertEqual(3,da.getNumberOfComponents());
9202         for i in xrange(12):
9203             self.assertAlmostEqual(da.getIJ(0,i),vals[i],13)
9204             pass
9205         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,11);
9206         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,13);
9207         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,5,2);
9208         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,7,2);
9209         pass
9210
9211     def testSwigDADOp6(self):
9212         da=DataArrayInt.New([5,6,7,8,9,6,7,-2,3,9,8,10])
9213         da.rearrange(3)
9214         da2=DataArrayInt.New([5,8,10,12])
9215         self.assertEqual(4,da2.getNumberOfTuples());
9216         self.assertEqual(1,da2.getNumberOfComponents());
9217         da3=da+da2
9218         self.assertEqual(4,da3.getNumberOfTuples());
9219         self.assertEqual(3,da3.getNumberOfComponents());
9220         expected1=[10,11,12,16,17,14,17,8,13,21,20,22]
9221         for i in xrange(12):
9222             self.assertEqual(da3.getIJ(0,i),expected1[i])
9223             pass
9224         da3=da2+da
9225         self.assertEqual(4,da3.getNumberOfTuples());
9226         self.assertEqual(3,da3.getNumberOfComponents());
9227         for i in xrange(12):
9228             self.assertEqual(da3.getIJ(0,i),expected1[i])
9229             pass
9230         da3=da+DataArrayInt.New(da2.getValues())
9231         # Test new API of classmethod DataArrayInt.New
9232         vals=[5,6,7,8,9,6,7,-2,3,9,8,10]
9233         da=DataArrayDouble.New(vals)
9234         self.assertEqual(12,da.getNumberOfTuples());
9235         self.assertEqual(1,da.getNumberOfComponents());
9236         for i in xrange(12):
9237             self.assertEqual(da.getIJ(0,i),vals[i])
9238             pass
9239         da=DataArrayDouble.New(vals,12)
9240         self.assertEqual(12,da.getNumberOfTuples());
9241         self.assertEqual(1,da.getNumberOfComponents());
9242         for i in xrange(12):
9243             self.assertEqual(da.getIJ(0,i),vals[i])
9244             pass
9245         da=DataArrayDouble.New(vals,1,12)
9246         self.assertEqual(1,da.getNumberOfTuples());
9247         self.assertEqual(12,da.getNumberOfComponents());
9248         for i in xrange(12):
9249             self.assertEqual(da.getIJ(0,i),vals[i])
9250             pass
9251         da=DataArrayDouble.New(vals,6,2)
9252         self.assertEqual(6,da.getNumberOfTuples());
9253         self.assertEqual(2,da.getNumberOfComponents());
9254         for i in xrange(12):
9255             self.assertEqual(da.getIJ(0,i),vals[i])
9256             pass
9257         da=DataArrayDouble.New(vals,4,3)
9258         self.assertEqual(4,da.getNumberOfTuples());
9259         self.assertEqual(3,da.getNumberOfComponents());
9260         for i in xrange(12):
9261             self.assertEqual(da.getIJ(0,i),vals[i])
9262             pass
9263         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,11);
9264         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,13);
9265         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,5,2);
9266         self.assertRaises(InterpKernelException,DataArrayDouble.New,vals,7,2);
9267         pass
9268
9269     def testSwigDADOp9(self):
9270         l1=[(1.,2.,3),(4.,5.,6.),(7.,8.,9.),[10.,11.,12.]]
9271         da1=DataArrayDouble(l1,4,3)
9272         self.assertEqual(4,da1.getNumberOfTuples());
9273         self.assertEqual(3,da1.getNumberOfComponents());
9274         da2=DataArrayDouble(12) ; da2.iota(1.) ; da2.rearrange(3)
9275         self.assertTrue(da2.isEqual(da1,1e-12))
9276         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,3,4);
9277         da3=DataArrayDouble(l1,4)
9278         self.assertTrue(da3.isEqual(da1,1e-12))
9279         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,3);
9280         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,5);
9281         l1=[(1.,2.,3),(4.,(5.),((6.))),(7.,8.,9.),[10.,11.,12.]]
9282         da1=DataArrayDouble(l1,4,3)
9283         self.assertEqual(4,da1.getNumberOfTuples());
9284         self.assertEqual(3,da1.getNumberOfComponents());
9285         da2=DataArrayDouble(12) ; da2.iota(1.) ; da2.rearrange(3)
9286         self.assertTrue(da2.isEqual(da1,1e-12))
9287         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,3,4);
9288         da3=DataArrayDouble(l1,4)
9289         self.assertTrue(da3.isEqual(da1,1e-12))
9290         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,3);
9291         self.assertRaises(InterpKernelException,DataArrayDouble.New,l1,5);
9292         #
9293         l1=[(1,2,3),(4,5,6),(7,8,9),[10,11,12]]
9294         da1=DataArrayInt(l1,4,3)
9295         self.assertEqual(4,da1.getNumberOfTuples());
9296         self.assertEqual(3,da1.getNumberOfComponents());
9297         da2=DataArrayInt(12) ; da2.iota(1) ; da2.rearrange(3)
9298         self.assertTrue(da2.isEqual(da1))
9299         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,3,4);
9300         da3=DataArrayInt(l1,4)
9301         self.assertTrue(da3.isEqual(da1))
9302         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,3);
9303         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,5);
9304         l1=[(1,[2],3),(4,[(5)],6),((([7])),8,9),[10,11,12]]
9305         da1=DataArrayInt(l1,4,3)
9306         self.assertEqual(4,da1.getNumberOfTuples());
9307         self.assertEqual(3,da1.getNumberOfComponents());
9308         da2=DataArrayInt(12) ; da2.iota(1) ; da2.rearrange(3)
9309         self.assertTrue(da2.isEqual(da1))
9310         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,3,4);
9311         da3=DataArrayInt(l1,4)
9312         self.assertTrue(da3.isEqual(da1))
9313         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,3);
9314         self.assertRaises(InterpKernelException,DataArrayInt.New,l1,5);
9315         pass
9316
9317     def testRenumberNodesInConn1(self):
9318         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. ]
9319         mesh2DConn=[1,4,2, 4,5,2, 0,3,4,1, 6,7,4,3, 7,8,5,4]
9320         mesh2D=MEDCouplingUMesh.New("mesh",2);
9321         mesh2D.allocateCells(5);
9322         mesh2D.insertNextCell(NORM_TRI3,3,mesh2DConn[0:3])
9323         mesh2D.insertNextCell(NORM_TRI3,3,mesh2DConn[3:6])
9324         mesh2D.insertNextCell(NORM_QUAD4,4,mesh2DConn[6:10])
9325         mesh2D.insertNextCell(NORM_QUAD4,4,mesh2DConn[10:14])
9326         mesh2D.insertNextCell(NORM_QUAD4,4,mesh2DConn[14:18])
9327         mesh2D.finishInsertingCells();
9328         myCoords=DataArrayDouble.New(mesh2DCoords,9,3);
9329         mesh2D.setCoords(myCoords);
9330         mesh2D.checkCoherency();
9331         #
9332         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. ]
9333         mesh3DConn=[0,1,2,3,4,5,6,7]
9334         mesh3D=MEDCouplingUMesh.New("mesh",3);
9335         mesh3D.allocateCells(1);
9336         mesh3D.insertNextCell(NORM_HEXA8,8,mesh3DConn[:])
9337         mesh3D.finishInsertingCells();
9338         myCoords3D=DataArrayDouble.New(mesh3DCoords,8,3);
9339         mesh3D.setCoords(myCoords3D);
9340         mesh3D.checkCoherency();
9341         #
9342         mesh3D_2=mesh3D.deepCpy();
9343         mesh2D_2=mesh2D.deepCpy();
9344         mesh3D_4=mesh3D.deepCpy();
9345         mesh2D_4=mesh2D.deepCpy();
9346         oldNbOf3DNodes=mesh3D.getNumberOfNodes();
9347         renumNodes=DataArrayInt.New();
9348         renumNodes.alloc(mesh2D.getNumberOfNodes(),1);
9349         renumNodes.iota(oldNbOf3DNodes);
9350         coo=DataArrayDouble.Aggregate(mesh3D.getCoords(),mesh2D.getCoords());
9351         mesh3D.setCoords(coo);
9352         mesh2D.setCoords(coo);
9353         mesh2DCpy=mesh2D.deepCpy()
9354         mesh2D_3=mesh2D.deepCpy();
9355         mesh2D_3.shiftNodeNumbersInConn(oldNbOf3DNodes);
9356         mesh2D.renumberNodesInConn(renumNodes);
9357         mesh2DCpy.renumberNodesInConn(renumNodes.getValues());
9358         self.assertTrue(mesh2D.isEqual(mesh2DCpy,1e-12))
9359         self.assertTrue(mesh2D.isEqual(mesh2D_3,1e-12))
9360         #
9361         da1,da2=mesh3D.checkGeoEquivalWith(mesh3D_2,10,1e-12);
9362         self.assertTrue(da1==None);
9363         self.assertEqual(8,da2.getNumberOfTuples());
9364         self.assertEqual(1,da2.getNumberOfComponents());
9365         expected1=[8,11,12,9,4,5,6,7]
9366         for i in xrange(8):
9367             self.assertEqual(expected1[i],da2.getIJ(i,0));
9368             pass
9369         #
9370         da1,da2=mesh2D.checkGeoEquivalWith(mesh2D_2,10,1e-12);
9371         self.assertTrue(da1==None);
9372         self.assertEqual(9,da2.getNumberOfTuples());
9373         self.assertEqual(1,da2.getNumberOfComponents());
9374         for i in xrange(9):
9375             self.assertEqual(8+i,da2.getIJ(i,0));
9376             pass
9377         #
9378         mesh2D_5=mesh2D_4.deepCpy();
9379         mesh2D_5.translate([1.,0.,0.]);
9380         meshes=[mesh3D_4,mesh2D_4,mesh2D_5];
9381         MEDCouplingUMesh.PutUMeshesOnSameAggregatedCoords(meshes);
9382         self.assertTrue(mesh3D_4.getCoords().getHiddenCppPointer()==mesh2D_4.getCoords().getHiddenCppPointer());
9383         self.assertTrue(mesh2D_4.getCoords().getHiddenCppPointer()==mesh2D_5.getCoords().getHiddenCppPointer());
9384         mesh3D_4.checkCoherency(); mesh2D_4.checkCoherency(); mesh2D_5.checkCoherency();
9385         self.assertEqual(26,mesh3D_4.getNumberOfNodes());
9386         self.assertEqual(3,mesh3D_4.getSpaceDimension());
9387         self.assertEqual(9,mesh3D_4.getNodalConnectivity().getNumberOfTuples());
9388         self.assertEqual(23,mesh2D_4.getNodalConnectivity().getNumberOfTuples());
9389         self.assertEqual(23,mesh2D_5.getNodalConnectivity().getNumberOfTuples());
9390         expected2=[18,0,1,2,3,4,5,6,7]
9391         expected3=[3,9,12,10, 3,12,13,10, 4,8,11,12,9, 4,14,15,12,11, 4,15,16,13,12]
9392         expected4=[3,18,21,19, 3,21,22,19, 4,17,20,21,18, 4,23,24,21,20, 4,24,25,22,21]
9393         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]
9394         self.assertEqual(expected2,mesh3D_4.getNodalConnectivity().getValues());
9395         self.assertEqual(expected3,mesh2D_4.getNodalConnectivity().getValues());
9396         self.assertEqual(expected4,mesh2D_5.getNodalConnectivity().getValues());
9397         for i in xrange(78):
9398             self.assertAlmostEqual(expected5[i],mesh3D_4.getCoords().getIJ(0,i),12);
9399             pass
9400         #
9401         MEDCouplingUMesh.MergeNodesOnUMeshesSharingSameCoords(meshes,1e-12);
9402         mesh3D_4.checkCoherency(); mesh2D_4.checkCoherency(); mesh2D_5.checkCoherency();
9403         self.assertTrue(mesh3D_4.getCoords().getHiddenCppPointer()==mesh2D_4.getCoords().getHiddenCppPointer());
9404         self.assertTrue(mesh2D_4.getCoords().getHiddenCppPointer()==mesh2D_5.getCoords().getHiddenCppPointer());
9405         self.assertEqual(19,mesh3D_4.getNumberOfNodes());
9406         self.assertEqual(3,mesh3D_4.getSpaceDimension());
9407         self.assertEqual(9,mesh3D_4.getNodalConnectivity().getNumberOfTuples());
9408         self.assertEqual(23,mesh2D_4.getNodalConnectivity().getNumberOfTuples());
9409         self.assertEqual(23,mesh2D_5.getNodalConnectivity().getNumberOfTuples());
9410         expected6=[18,0,1,2,3,4,5,6,7]
9411         expected7=[3,3,2,8, 3,2,9,8, 4,0,1,2,3, 4,10,11,2,1, 4,11,12,9,2]
9412         expected8=[3,13,15,14, 3,15,16,14, 4,8,9,15,13, 4,12,17,15,9, 4,17,18,16,15]
9413         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.,
9414                     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.,
9415                     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.]
9416         self.assertEqual(expected6,mesh3D_4.getNodalConnectivity().getValues());
9417         self.assertEqual(expected7,mesh2D_4.getNodalConnectivity().getValues());
9418         self.assertEqual(expected8,mesh2D_5.getNodalConnectivity().getValues());
9419         for i in xrange(57):
9420             self.assertAlmostEqual(expected9[i],mesh3D_4.getCoords().getIJ(0,i),12);
9421             pass
9422         #
9423         pass
9424
9425     def testComputeNeighborsOfCells1(self):
9426         m=MEDCouplingDataForTest.build2DTargetMesh_1();
9427         d1,d2=m.computeNeighborsOfCells();
9428         self.assertEqual(6,d2.getNumberOfTuples());
9429         self.assertEqual(10,d1.getNumberOfTuples());
9430         expected1=[0,2,4,6,8,10]
9431         expected2=[3,1,0,2,4,1,4,0,2,3]
9432         self.assertEqual(expected1,d2.getValues());
9433         self.assertEqual(expected2,d1.getValues());
9434         pass
9435
9436     def testCheckButterflyCellsBug1(self):
9437         mesh2DCoords=[323.85,120.983748908684,317.5,131.982271536747,336.55,120.983748908686,330.2,131.982271536751,323.85,142.98079416481]
9438         mesh2DConn=[4,1,0,2,3]
9439         mesh2D=MEDCouplingUMesh.New("mesh",2);
9440         mesh2D.allocateCells(1);
9441         mesh2D.insertNextCell(NORM_POLYGON,5,mesh2DConn[0:5])
9442         mesh2D.finishInsertingCells();
9443         myCoords=DataArrayDouble.New(mesh2DCoords,5,2);
9444         mesh2D.setCoords(myCoords);
9445         mesh2D.checkCoherency();
9446         #
9447         v=mesh2D.checkButterflyCells();
9448         self.assertTrue(v.empty());
9449         pass
9450
9451     def testDataArrayIntRange1(self):
9452         d=DataArrayInt.Range(2,17,7);
9453         expected1=[2,9,16]
9454         self.assertEqual(3,d.getNumberOfTuples());
9455         self.assertEqual(1,d.getNumberOfComponents());
9456         self.assertEqual(expected1,d.getValues());
9457         #
9458         d=DataArrayInt.Range(2,23,7);
9459         self.assertEqual(3,d.getNumberOfTuples());
9460         self.assertEqual(1,d.getNumberOfComponents());
9461         self.assertEqual(expected1,d.getValues());
9462         #
9463         d=DataArrayInt.Range(2,24,7);
9464         expected2=[2,9,16,23]
9465         self.assertEqual(4,d.getNumberOfTuples());
9466         self.assertEqual(1,d.getNumberOfComponents());
9467         self.assertEqual(expected2,d.getValues());
9468         #
9469         d=DataArrayInt.Range(24,2,-7);
9470         expected3=[24,17,10,3]
9471         self.assertEqual(4,d.getNumberOfTuples());
9472         self.assertEqual(1,d.getNumberOfComponents());
9473         self.assertEqual(expected3,d.getValues());
9474         #
9475         d=DataArrayInt.Range(23,2,-7);
9476         expected4=[23,16,9]
9477         self.assertEqual(3,d.getNumberOfTuples());
9478         self.assertEqual(1,d.getNumberOfComponents());
9479         self.assertEqual(expected4,d.getValues());
9480         #
9481         d=DataArrayInt.Range(23,22,-7);
9482         self.assertEqual(1,d.getNumberOfTuples());
9483         self.assertEqual(1,d.getNumberOfComponents());
9484         self.assertEqual(23,d.getIJ(0,0));
9485         #
9486         d=DataArrayInt.Range(22,23,7);
9487         self.assertEqual(1,d.getNumberOfTuples());
9488         self.assertEqual(1,d.getNumberOfComponents());
9489         self.assertEqual(22,d.getIJ(0,0));
9490         #
9491         d=DataArrayInt.Range(22,22,7);
9492         self.assertEqual(0,d.getNumberOfTuples());
9493         self.assertEqual(1,d.getNumberOfComponents());
9494         #
9495         d=DataArrayInt.Range(22,22,-7);
9496         self.assertEqual(0,d.getNumberOfTuples());
9497         self.assertEqual(1,d.getNumberOfComponents());
9498         #
9499         self.assertRaises(InterpKernelException,DataArrayInt.Range,22,23,-7);
9500         self.assertRaises(InterpKernelException,DataArrayInt.Range,23,22,7);
9501         self.assertRaises(InterpKernelException,DataArrayInt.Range,23,22,0);
9502         self.assertRaises(InterpKernelException,DataArrayInt.Range,22,23,0);
9503         pass
9504
9505     def testSwigUMeshGetItem1(self):
9506         m=MEDCouplingDataForTest.build2DTargetMesh_1();
9507         subMesh=m.buildPartOfMySelf([1,3],True);
9508         self.assertTrue(isinstance(subMesh,MEDCouplingUMesh))
9509         m1=m[[1,3]]
9510         self.assertTrue(isinstance(m1,MEDCouplingUMesh))
9511         m2=m[(1,3)]
9512         self.assertTrue(isinstance(m2,MEDCouplingUMesh))
9513         m3=m[1::2]
9514         self.assertTrue(isinstance(m3,MEDCouplingUMesh))
9515         m4=m[DataArrayInt.New([1,3])]
9516         m5_1=m[1]
9517         self.assertTrue(isinstance(m5_1,MEDCouplingUMesh))
9518         m5_2=m[3]
9519         self.assertTrue(isinstance(m5_2,MEDCouplingUMesh))
9520         m5=MEDCouplingUMesh.MergeUMeshesOnSameCoords([m5_1,m5_2]);
9521         m5.setName(subMesh.getName())
9522         self.assertTrue(isinstance(m4,MEDCouplingUMesh))
9523         self.assertTrue(subMesh.isEqual(m1,1e-12))
9524         self.assertTrue(subMesh.isEqual(m2,1e-12))
9525         self.assertTrue(subMesh.isEqual(m3,1e-12))
9526         self.assertTrue(subMesh.isEqual(m4,1e-12))
9527         self.assertTrue(subMesh.isEqual(m5,1e-12))
9528         self.assertRaises(InterpKernelException,m.buildPartOfMySelf,[1,5],True);
9529         pass
9530
9531     def testSwigGetItem3(self):
9532         da=DataArrayInt.New([4,5,6])
9533         self.assertEqual(5,da[1])
9534         self.assertRaises(InterpKernelException,da.__getitem__,-1)
9535         self.assertRaises(InterpKernelException,da.__getitem__,3)
9536         da=DataArrayInt.New([4,5,6,7,8,9],2,3)
9537         self.assertEqual(9,da[1,2])
9538         da=DataArrayDouble.New([4.1,5.2,6.3])
9539         self.assertAlmostEqual(5.2,da[1],12)
9540         self.assertRaises(InterpKernelException,da.__getitem__,-1)
9541         self.assertRaises(InterpKernelException,da.__getitem__,3)
9542         da=DataArrayDouble.New([4.12,5.12,6.12,7.12,8.12,9.12],2,3)
9543         self.assertAlmostEqual(9.12,da[1,2],12)
9544         pass
9545
9546     def testSwigDADISub1(self):
9547         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
9548         bary=mesh3D.getBarycenterAndOwner()
9549         bary=bary[:,:2]
9550         pts=bary.getDifferentValues(1e-12)
9551         expected=[[0,6,12],[1,7,13],[2,8,14],[3,9,15],[4,10,16],[5,11,17]]
9552         for pos,pt in enumerate(pts):
9553             bary2=bary[:,:2]
9554             bary2[:]-=pt
9555             norm=bary2.magnitude()
9556             self.assertEqual(expected[pos],norm.getIdsInRange(-1.,1e-5).getValues())
9557             pass
9558         expected2=[[3.,54.],[-141.,180.],[21.,54.],[39.,72.],[-15.,90.],[21.,90.]]
9559         for pos,pt in enumerate(pts):
9560             bary2=bary[:,:2]
9561             bary2[:]+=pt
9562             self.assertAlmostEqual(expected2[pos][0],bary2.accumulate()[0],12);
9563             self.assertAlmostEqual(expected2[pos][1],bary2.accumulate()[1],12);
9564             pass
9565         expected3=[[-3.,22.5],[45.,337.5],[-9., 22.5],[-15.,67.5],[3.,112.5],[-9.,112.5]]
9566         for pos,pt in enumerate(pts):
9567             bary2=bary[:,:2]
9568             bary2[:]*=pt
9569             self.assertAlmostEqual(expected3[pos][0],bary2.accumulate()[0],12);
9570             self.assertAlmostEqual(expected3[pos][1],bary2.accumulate()[1],12);
9571             pass
9572         expected4=[[-12.,90.],[0.8,6.],[-4,90.],[-2.4,30.],[12.,18],[-4,18.]]
9573         for pos,pt in enumerate(pts):
9574             bary2=bary[:,:2]
9575             bary2[:]/=pt
9576             self.assertAlmostEqual(expected4[pos][0],bary2.accumulate()[0],12);
9577             self.assertAlmostEqual(expected4[pos][1],bary2.accumulate()[1],12);
9578             pass
9579         #
9580         d=DataArrayInt.New([1,2,0,1,0,2],3,2)
9581         e=DataArrayInt.New([1,11,101,2,12,102,3,13,103,4,14,104],4,3)
9582         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]]
9583         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]]
9584         for pos,tup in enumerate(d):
9585             f=e[:]
9586             self.assertTrue(isinstance(f,DataArrayInt))
9587             f[tup]=77
9588             self.assertEqual(expected5[pos],f.getValues())
9589             self.assertEqual(6*[77],f[tup].getValues())
9590             f=e[:]
9591             f[:,tup]=77
9592             self.assertEqual(expected6[pos],f.getValues())
9593             self.assertEqual(8*[77],f[:,tup].getValues())
9594             pass
9595         #
9596         e=e.convertToDblArr()
9597         for pos,tup in enumerate(d):
9598             f=e[:]
9599             self.assertTrue(isinstance(f,DataArrayDouble))
9600             f[tup]=77.
9601             self.assertEqual(expected5[pos],f.convertToIntArr().getValues())
9602             self.assertEqual(6*[77],f[tup].convertToIntArr().getValues())
9603             f=e[:]
9604             f[:,tup]=77.
9605             self.assertEqual(expected6[pos],f.convertToIntArr().getValues())
9606             self.assertEqual(8*[77],f[:,tup].convertToIntArr().getValues())
9607             pass
9608         pass
9609
9610     def testDataArrayDoubleGetMinMaxPerComponent1(self):
9611         values1=[1.,2.,3.,-0.9,2.1,3.,1.3,1.7,3.,1.,1.8,3.]
9612         d1=DataArrayDouble.New();
9613         self.assertRaises(InterpKernelException,d1.getMinMaxPerComponent)
9614         d1=DataArrayDouble.New(values1,4,3);
9615         res=d1.getMinMaxPerComponent();
9616         self.assertTrue(isinstance(res,list))
9617         self.assertEqual(3,len(res))
9618         for i in xrange(3):
9619             self.assertTrue(isinstance(res[i],tuple))
9620             self.assertEqual(2,len(res[i]))
9621             pass
9622         expected1=[-0.9,1.3,1.7,2.1,3.,3.]
9623         for i in xrange(6):
9624             self.assertAlmostEqual(expected1[i],res[i/2][i%2],14)
9625             pass
9626         #
9627         d1.rearrange(2);
9628         res=d1.getMinMaxPerComponent();
9629         self.assertTrue(isinstance(res,list))
9630         self.assertEqual(2,len(res))
9631         for i in xrange(2):
9632             self.assertTrue(isinstance(res[i],tuple))
9633             self.assertEqual(2,len(res[i]))
9634             pass
9635         expected2=[1.,3.,-0.9,3.]
9636         for i in xrange(4):
9637             self.assertAlmostEqual(expected2[i],res[i/2][i%2],14)
9638             pass
9639         #
9640         d1.rearrange(1);
9641         res=d1.getMinMaxPerComponent();
9642         self.assertTrue(isinstance(res,list))
9643         self.assertEqual(1,len(res))
9644         for i in xrange(1):
9645             self.assertTrue(isinstance(res[i],tuple))
9646             self.assertEqual(2,len(res[i]))
9647             pass
9648         expected3=[-0.9,3.]
9649         for i in xrange(2):
9650             self.assertAlmostEqual(expected3[i],res[i/2][i%2],14)
9651             pass
9652         pass
9653
9654     def testDataArrayIntGetHashCode1(self):
9655         d1=DataArrayInt.New(range(3545))
9656         d2=DataArrayInt.New(range(3545))
9657         self.assertEqual(d2.getHashCode(),d1.getHashCode())
9658         self.assertEqual(232341068,d1.getHashCode())
9659         d1[886]=6
9660         self.assertEqual(232340188,d1.getHashCode())
9661         pass
9662
9663     def testZipConnectivityPol1(self):
9664         m1=MEDCouplingDataForTest.build2DTargetMesh_1();
9665         cells1=[2,3,4]
9666         m2_1=m1.buildPartOfMySelf(cells1,True);
9667         m2=m2_1
9668         self.assertTrue(isinstance(m2,MEDCouplingUMesh))
9669         # no permutation policy 0
9670         isOk,arr=m1.areCellsIncludedIn(m2,0)
9671         self.assertTrue(isOk);
9672         self.assertEqual(3,arr.getNumberOfTuples());
9673         self.assertEqual(1,arr.getNumberOfComponents());
9674         self.assertEqual(cells1,arr.getValues())
9675         # no permutation policy 1
9676         isOk,arr=m1.areCellsIncludedIn(m2,1)
9677         self.assertTrue(isOk);
9678         self.assertEqual(3,arr.getNumberOfTuples());
9679         self.assertEqual(1,arr.getNumberOfComponents());
9680         self.assertEqual(cells1,arr.getValues())
9681         # no permutation policy 2
9682         isOk,arr=m1.areCellsIncludedIn(m2,2)
9683         self.assertTrue(isOk);
9684         self.assertEqual(3,arr.getNumberOfTuples());
9685         self.assertEqual(1,arr.getNumberOfComponents());
9686         self.assertEqual(cells1,arr.getValues())
9687         # some modification into m2
9688         modif1=[2,4,5]
9689         m2.getNodalConnectivity()[1:4]=modif1
9690         #policy 0 fails because cell0 in m2 has same orientation be not same connectivity
9691         expected1=[5,3,4]
9692         isOk,arr=m1.areCellsIncludedIn(m2,0)
9693         self.assertTrue(not isOk);
9694         self.assertEqual(3,arr.getNumberOfTuples());
9695         self.assertEqual(1,arr.getNumberOfComponents());
9696         self.assertEqual(expected1,arr.getValues())
9697         #policy 1 succeeds because cell0 in m2 has not exactly the same conn
9698         isOk,arr=m1.areCellsIncludedIn(m2,1)
9699         self.assertTrue(isOk);
9700         self.assertEqual(3,arr.getNumberOfTuples());
9701         self.assertEqual(1,arr.getNumberOfComponents());
9702         self.assertEqual(cells1,arr.getValues())
9703         #policy 2 succeeds because cell0 in m2 has same nodes in connectivity
9704         isOk,arr=m1.areCellsIncludedIn(m2,2)
9705         self.assertTrue(isOk);
9706         self.assertEqual(3,arr.getNumberOfTuples());
9707         self.assertEqual(1,arr.getNumberOfComponents());
9708         self.assertEqual(cells1,arr.getValues())
9709         #some new modification into m2
9710         modif2=[2,5,4]
9711         m2.getNodalConnectivity()[1:4]=modif2
9712         #policy 0 fails because cell0 in m2 has not exactly the same conn
9713         isOk,arr=m1.areCellsIncludedIn(m2,0)
9714         self.assertTrue(not isOk);
9715         self.assertEqual(3,arr.getNumberOfTuples());
9716         self.assertEqual(1,arr.getNumberOfComponents());
9717         self.assertEqual(expected1,arr.getValues())
9718         #policy 1 fails too because cell0 in m2 has not same orientation
9719         isOk,arr=m1.areCellsIncludedIn(m2,1)
9720         self.assertTrue(not isOk);
9721         self.assertEqual(3,arr.getNumberOfTuples());
9722         self.assertEqual(1,arr.getNumberOfComponents());
9723         self.assertEqual(expected1,arr.getValues())
9724         #policy 2 succeeds because cell0 in m2 has same nodes in connectivity
9725         isOk,arr=m1.areCellsIncludedIn(m2,2)
9726         self.assertTrue(isOk);
9727         self.assertEqual(3,arr.getNumberOfTuples());
9728         self.assertEqual(1,arr.getNumberOfComponents());
9729         self.assertEqual(cells1,arr.getValues())
9730         # Now 1D
9731         cells2=[3,2]
9732         m1=MEDCouplingDataForTest.build1DSourceMesh_2();
9733         m2_1=m1.buildPartOfMySelf(cells2,True);
9734         m2=m2_1
9735         self.assertTrue(isinstance(m2,MEDCouplingUMesh))
9736         # no permutation policy 0
9737         isOk,arr=m1.areCellsIncludedIn(m2,0)
9738         self.assertTrue(isOk);
9739         self.assertEqual(2,arr.getNumberOfTuples());
9740         self.assertEqual(1,arr.getNumberOfComponents());
9741         self.assertEqual(cells2,arr.getValues())
9742         # no permutation policy 1
9743         isOk,arr=m1.areCellsIncludedIn(m2,1)
9744         self.assertTrue(isOk);
9745         self.assertEqual(2,arr.getNumberOfTuples());
9746         self.assertEqual(1,arr.getNumberOfComponents());
9747         self.assertEqual(cells2,arr.getValues())
9748         # no permutation policy 2
9749         isOk,arr=m1.areCellsIncludedIn(m2,2)
9750         self.assertTrue(isOk);
9751         self.assertEqual(2,arr.getNumberOfTuples());
9752         self.assertEqual(1,arr.getNumberOfComponents());
9753         self.assertEqual(cells2,arr.getValues())
9754         # some modification into m2
9755         modif3=[4,3]
9756         m2.getNodalConnectivity()[1:3]=modif3
9757         #policy 0 fails because cell0 in m2 has not exactly the same conn
9758         expected2=[4,2]
9759         isOk,arr=m1.areCellsIncludedIn(m2,0)
9760         self.assertTrue(not isOk);
9761         self.assertEqual(2,arr.getNumberOfTuples());
9762         self.assertEqual(1,arr.getNumberOfComponents());
9763         self.assertEqual(expected2,arr.getValues())
9764         #policy 1 fails too because cell0 in m2 has not same orientation
9765         isOk,arr=m1.areCellsIncludedIn(m2,1)
9766         self.assertTrue(not isOk);
9767         self.assertEqual(2,arr.getNumberOfTuples());
9768         self.assertEqual(1,arr.getNumberOfComponents());
9769         self.assertEqual(expected2,arr.getValues())
9770         #policy 2 succeeds because cell0 in m2 has same nodes in connectivity
9771         isOk,arr=m1.areCellsIncludedIn(m2,2)
9772         self.assertTrue(isOk);
9773         self.assertEqual(2,arr.getNumberOfTuples());
9774         self.assertEqual(1,arr.getNumberOfComponents());
9775         self.assertEqual(cells2,arr.getValues())
9776         pass
9777
9778     def toSeeIfDaIIopsAreOK(self,d):
9779         d+=5
9780         d*=6
9781         d/=3
9782         d-=2
9783         d%=7
9784         pass
9785
9786     def testSwigDAIOp5(self):
9787         d=DataArrayInt.New([4,5,6,10,3,-1],2,3)
9788         self.toSeeIfDaIIopsAreOK(d)
9789         dExp=DataArrayInt.New([2,4,6,0,0,6],2,3)
9790         self.assertTrue(d.isEqual(dExp));
9791         pass
9792
9793     def toSeeIfDaDIopsAreOK(self,d):
9794         d+=5
9795         d*=6
9796         d/=3
9797         d-=2
9798         pass
9799
9800     def testSwigDADOp7(self):
9801         d=DataArrayDouble.New([4.,5.,6.,10.,3.,-1.],2,3)
9802         self.toSeeIfDaDIopsAreOK(d)
9803         dExp=DataArrayDouble.New([16.,18.,20.,28.,14.,6.],2,3)
9804         self.assertTrue(d.isEqual(dExp,1e-14));
9805         pass
9806
9807     def testConvexEnvelop2D1(self):
9808         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]
9809         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]
9810         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]
9811         #
9812         m=MEDCouplingUMesh.New("convexhull",2);
9813         m.allocateCells(331);
9814         for i in xrange(331):
9815             m.insertNextCell(NORM_POLYGON,conn[connI[i]:connI[i+1]]);
9816             pass
9817         m.finishInsertingCells();
9818         coordsDa=DataArrayDouble.New(coords,331,2);
9819         m.setCoords(coordsDa);
9820         m.checkCoherency();
9821         #
9822         da=m.convexEnvelop2D();
9823         m.checkCoherency()
9824         self.assertEqual(coordsDa.getHiddenCppPointer(),m.getCoords().getHiddenCppPointer())
9825         daC=da.buildComplement(m.getNumberOfCells());
9826         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]);
9827         self.assertTrue(expected2.isEqual(daC));
9828         #
9829         vals=m.getMeasureField(ON_CELLS).getArray()
9830         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]
9831         vals-=DataArrayDouble.New(ref)
9832         vals.abs()
9833         theTest=vals.getIdsInRange(-1.,1e-7)
9834         self.assertTrue(theTest.isIdentity())
9835         self.assertEqual(331,len(theTest))
9836         pass
9837
9838     def testSwigDAIOp8(self):
9839         da=DataArrayInt.New([7,5,6,7,8,9,9,10,12,13,47,15])
9840         self.assertTrue(7 in da)
9841         self.assertTrue(47 in da)
9842         self.assertTrue(15 in da)
9843         self.assertEqual(0,da.index(7))
9844         self.assertEqual(10,da.index(47))
9845         self.assertTrue(14 not in da)
9846         self.assertEqual(5,da.search([9,9]))
9847         self.assertEqual(-1,da.search([5,8]))
9848         da.rearrange(2)
9849         self.assertTrue([47,16] not in da)
9850         self.assertTrue([5,6] not in da)
9851         self.assertTrue([6,7] in da)
9852         self.assertEqual(4,da.index([12,13]))
9853         pass
9854
9855     def testDataArraySort1(self):
9856         arr=DataArrayInt.New();
9857         self.assertRaises(InterpKernelException,arr.sort,True)
9858         self.assertRaises(InterpKernelException,arr.sort,False)
9859         values=[2,1,6,5,4,7]
9860         arr.alloc(3,2);
9861         self.assertRaises(InterpKernelException,arr.sort,True)
9862         self.assertRaises(InterpKernelException,arr.sort,False)
9863         arr.rearrange(1);
9864         arr.setValues(values,6,1)
9865         arr1=arr.deepCpy();
9866         arr2=arr.deepCpy();
9867         arr1.sort(True);
9868         expected1=[1,2,4,5,6,7]
9869         self.assertEqual(6,arr1.getNumberOfTuples());
9870         self.assertEqual(1,arr1.getNumberOfComponents());
9871         self.assertEqual(expected1,arr1.getValues());
9872         arr2.sort(False);
9873         expected2=[7,6,5,4,2,1]
9874         self.assertEqual(6,arr2.getNumberOfTuples());
9875         self.assertEqual(1,arr2.getNumberOfComponents());
9876         self.assertTrue(expected2,arr2.getValues());
9877         #
9878         ard=DataArrayDouble.New();
9879         self.assertRaises(InterpKernelException,ard.sort,True)
9880         self.assertRaises(InterpKernelException,ard.sort,False)
9881         valuesD=[2.,1.,6.,5.,4.,7.]
9882         ard.alloc(3,2);
9883         self.assertRaises(InterpKernelException,ard.sort,True)
9884         self.assertRaises(InterpKernelException,ard.sort,False)
9885         ard.rearrange(1);
9886         ard.setValues(valuesD,6,1)
9887         ard1=ard.deepCpy();
9888         ard2=ard.deepCpy();
9889         ard1.sort(True);
9890         expected3=[1.,2.,4.,5.,6.,7.]
9891         self.assertEqual(6,ard1.getNumberOfTuples());
9892         self.assertEqual(1,ard1.getNumberOfComponents());
9893         for i in xrange(6):
9894             self.assertAlmostEqual(expected3[i],ard1.getIJ(i,0),12)
9895             pass
9896         ard2.sort(False);
9897         expected4=[7.,6.,5.,4.,2.,1.]
9898         self.assertEqual(6,ard2.getNumberOfTuples());
9899         self.assertEqual(1,ard2.getNumberOfComponents());
9900         for i in xrange(6):
9901             self.assertAlmostEqual(expected4[i],ard2.getIJ(i,0),12)
9902             pass
9903         pass
9904
9905     def testPartitionBySpreadZone1(self):
9906         m=MEDCouplingDataForTest.build2DTargetMesh_1();
9907         m4=MEDCouplingUMesh.MergeUMeshes([m,m[-3:],m[0:2]]);
9908         m4.renumberCells([5,2,9,6,4,7,0,1,3,8]);
9909         #
9910         v2=m4.partitionBySpreadZone();
9911         self.assertTrue(3,len(v2));
9912         self.assertTrue(v2[0].isEqual(DataArrayInt.New([0,1,7])))
9913         self.assertTrue(v2[1].isEqual(DataArrayInt.New([2,4,5,6,9])))
9914         self.assertTrue(v2[2].isEqual(DataArrayInt.New([3,8])))
9915         #
9916         m5=m4.buildSpreadZonesWithPoly();
9917         self.assertEqual(3,m5.getNumberOfCells());
9918         self.assertTrue(m5.getCoords().getHiddenCppPointer()==m4.getCoords().getHiddenCppPointer());
9919         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())
9920         self.assertEqual([0,8,17,23],m5.getNodalConnectivityIndex().getValues())
9921         #
9922         pass
9923
9924     def testGiveCellsWithType1(self):
9925         expected0=[1,2]
9926         expected1=[0,3,4]
9927         m=MEDCouplingDataForTest.build2DTargetMesh_1();
9928         da=m.giveCellsWithType(NORM_TRI3);
9929         self.assertEqual(2,da.getNumberOfTuples());
9930         self.assertEqual(1,da.getNumberOfComponents());
9931         self.assertEqual(expected0,da.getValues())
9932         #
9933         da=m.giveCellsWithType(NORM_QUAD4);
9934         self.assertEqual(3,da.getNumberOfTuples());
9935         self.assertEqual(1,da.getNumberOfComponents());
9936         self.assertEqual(expected1,da.getValues())
9937         #
9938         da=m.giveCellsWithType(NORM_TRI6);
9939         self.assertEqual(0,da.getNumberOfTuples());
9940         self.assertEqual(1,da.getNumberOfComponents());
9941         #
9942         self.assertRaises(InterpKernelException,m.giveCellsWithType,NORM_SEG2)
9943         self.assertRaises(InterpKernelException,m.giveCellsWithType,NORM_HEXA8)
9944         pass
9945
9946     def testSwigDAOp1(self):
9947         d=DataArrayDouble.New(5,2)
9948         d.rearrange(1) ; d.iota(2.) ; d.rearrange(2)
9949         d.setInfoOnComponents(["X [m]","Y [m]"])
9950         d.setName("AName")
9951         #
9952         d1=d+[8,9]
9953         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))
9954         d1bis=DataArrayDouble.New([8,9],1,2)+d
9955         self.assertTrue(d1bis.isEqual(d1,1e-12))
9956         d1ter=[8,9]+d
9957         self.assertTrue(d1ter.isEqual(d1,1e-12))
9958         #
9959         d2=d1-[8,9]
9960         self.assertTrue(d2.isEqual(d,1e-12))
9961         self.assertRaises(InterpKernelException,d1.__rsub__,[8,9])#[8,9]-d1
9962         #
9963         d3=d*[8,9]
9964         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))
9965         d3bis=DataArrayDouble.New([8,9],1,2)*d
9966         self.assertTrue(d3bis.isEqual(d3,1e-12))
9967         d3ter=[8,9]*d
9968         self.assertTrue(d3ter.isEqual(d3,1e-12))
9969         #
9970         d4=d3/[8,9]
9971         self.assertTrue(d4.isEqual(d,1e-12))
9972         #
9973         d=DataArrayInt.New(5,2)
9974         d.rearrange(1) ; d.iota(2) ; d.rearrange(2)
9975         d.setInfoOnComponents(["X [m]","Y [m]"])
9976         d.setName("AName")
9977         #
9978         d1=d+[8,9]
9979         self.assertEqual(d1.getValues(),[10,12,12,14,14,16,16,18,18,20])
9980         d1bis=DataArrayInt.New([8,9],1,2)+d
9981         self.assertTrue(d1bis.isEqual(d1))
9982         d1ter=[8,9]+d
9983         self.assertTrue(d1ter.isEqual(d1))
9984         #
9985         d2=d1-[8,9]
9986         self.assertTrue(d2.isEqual(d))
9987         self.assertRaises(InterpKernelException,d1.__rsub__,[8,9])
9988         #
9989         d3=d*[8,9]
9990         self.assertEqual(d3.getValues(),[16,27,32,45,48,63,64,81,80,99])
9991         d3bis=DataArrayInt.New([8,9],1,2)*d
9992         self.assertTrue(d3bis.isEqual(d3))
9993         d3ter=[8,9]*d
9994         self.assertTrue(d3ter.isEqual(d3))
9995         #
9996         d4=d3/[8,9]
9997         self.assertTrue(d4.isEqual(d))
9998         #
9999         d5=d%[4,5]
10000         self.assertEqual(d5.getValues(),[2,3,0,0,2,2,0,4,2,1])
10001         pass
10002
10003     def testSwigSelectTupleId2DAIBug1(self):
10004         da=DataArrayInt.New([0,1,2,3,12,13,4,5,6,7,14,15,8,9,10,11,16,17])
10005         self.assertEqual([2,6,10],da[2::6].getValues())
10006         self.assertEqual([0,4,8],da[::6].getValues())
10007         self.assertEqual([5,9],da[7::6].getValues())
10008         self.assertEqual([5],da[7:-5:6].getValues())
10009         pass
10010
10011     def testSwigCpp5Safe1(self):
10012         m=MEDCouplingUMesh.New("toto",2)
10013         coords=DataArrayDouble.New([0.,0.,1.,0.,1.,1.,0.,1.],4,2)
10014         m.setCoords(coords)
10015         vecs=DataArrayDouble.New([2.,3.,4.,5.,6.,7.],3,2)
10016         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]]
10017         for pos,vec in enumerate(vecs):
10018             m2=m.deepCpy()
10019             m2.translate(vec)
10020             self.assertTrue(m2.getCoords().isEqual(DataArrayDouble.New(expected1[pos],4,2),1e-12))
10021             pass
10022         for pos,vec in enumerate(vecs):
10023             m2=m.deepCpy()
10024             m2.translate(vec.buildDADouble())
10025             self.assertTrue(m2.getCoords().isEqual(DataArrayDouble.New(expected1[pos],4,2),1e-12))
10026             pass
10027         pass
10028
10029     def testSwigBugNonRegressionZipDA(self):
10030         angles=map(lambda x:pi/3*x,xrange(6))
10031         radius=3
10032         #
10033         dad=DataArrayDouble.New(6, 2)
10034         dad[:,0]=radius
10035         dad[:,1]=angles
10036         #
10037         dad2=dad.fromPolarToCart()
10038         dads=[dad2.deepCpy() for elt in 7*[None]]
10039         #
10040         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.)]]
10041         for d,t in zip(dads,translationToPerform):
10042             d+=t
10043             pass
10044         for elt in dads:
10045             self.assertTrue(not dad2.isEqual(elt,1e-12))
10046             pass
10047         for d,t in zip(dads,translationToPerform):
10048             d-=t
10049             pass
10050         for elt in dads:
10051             self.assertTrue(dad2.isEqual(elt,1e-12))
10052             pass
10053         pass
10054
10055     def testBuildSlice3D2(self):
10056         mesh3D,mesh2D=MEDCouplingDataForTest.build3DExtrudedUMesh_1();
10057         vec1=[-0.07,1.,0.07]
10058         origin1=[1.524,1.4552,1.74768]
10059         slice1,ids=mesh3D.buildSlice3D(origin1,vec1,1e-10);
10060         f=MEDCouplingFieldDouble(ON_CELLS,ONE_TIME)
10061         f.setTime(4.5,6,7) ; f.setMesh(mesh3D)
10062         arr=DataArrayDouble(mesh3D.getNumberOfCells(),2)
10063         arr.rearrange(1) ; arr.iota(2.) ; arr.rearrange(2)
10064         f.setArray(arr)
10065         f.checkCoherency()
10066         expected1=DataArrayInt([1,3,4,7,9,10,13,15,16])
10067         self.assertTrue(expected1.isEqual(ids))
10068         arr2=arr[expected1]
10069         #
10070         f2=f.extractSlice3D(origin1,vec1,1e-10)
10071         self.assertTrue(f2.getArray().isEqual(arr2,1e-12));
10072         self.assertTrue(slice1.isEqual(f2.getMesh(),1e-12))
10073         self.assertEqual(6,f2.getTime()[1]) ; self.assertEqual(7,f2.getTime()[2])
10074         self.assertAlmostEqual(4.5,f2.getTime()[0],12);
10075         pass
10076
10077     def testComputeTupleIdsToSelectFromCellIds1(self):
10078         m=MEDCouplingDataForTest.build2DTargetMesh_3()
10079         f=MEDCouplingFieldDouble.New(ON_GAUSS_NE,NO_TIME);
10080         f.setMesh(m);
10081         arr=DataArrayDouble(52,2) ; arr.rearrange(1) ; arr.iota(7.) ; arr.rearrange(2)
10082         f.setArray(arr)
10083         #
10084         f2=f.buildSubPart([1,5,9])
10085         f2.checkCoherency()
10086         cI=m.computeNbOfNodesPerCell()
10087         cI.computeOffsets2()
10088         sel=DataArrayInt([1,5,9])
10089         res=sel.buildExplicitArrByRanges(cI)
10090         arr2=arr[res]
10091         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))
10092         self.assertTrue(arr2.isEqual(f2.getArray(),1e-12))
10093         pass
10094
10095     def testComputeSkin1(self):
10096         arrX=DataArrayDouble([2.,3.4,5.6,7.7,8.0]) ; arrY=DataArrayDouble([2.,3.4,5.6,7.7,9.0,14.2])
10097         cmesh=MEDCouplingCMesh() ; cmesh.setCoordsAt(0,arrX) ; cmesh.setCoordsAt(1,arrY)
10098         umesh=cmesh.buildUnstructured()
10099         #
10100         skin=umesh.computeSkin()
10101         self.assertEqual(18,skin.getNumberOfCells())
10102         self.assertEqual(1,skin.getMeshDimension())
10103         self.assertTrue(skin.getCoords().getHiddenCppPointer()==umesh.getCoords().getHiddenCppPointer())
10104         self.assertEqual([0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48,51,54],skin.getNodalConnectivityIndex().getValues())
10105         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())
10106         ids=skin.computeFetchedNodeIds()
10107         self.assertEqual([0,1,2,3,4,5,9,10,14,15,19,20,24,25,26,27,28,29],ids.getValues())
10108         part=umesh.buildFacePartOfMySelfNode(ids,True)
10109         part.setName(skin.getName());
10110         self.assertTrue(part.isEqual(skin,1e-12))
10111         part2=part[1::2]
10112         part[::2]=part2
10113         self.assertTrue(not part.isEqual(skin,1e-12))
10114         trad=part.zipConnectivityTraducer(0)
10115         self.assertEqual(9,part.getNumberOfCells())
10116         self.assertEqual([0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8],trad.getValues())
10117         pass
10118
10119     def testUMeshSetPartOfMySelf2(self):
10120         # resize with explicit ids list
10121         m=MEDCouplingDataForTest.build2DTargetMesh_1()
10122         self.assertEqual([3,4],m.getAllTypes())
10123         part=m[[0,3,4]]
10124         part.simplexize(0)
10125         part2=part[[1,2,5]]
10126         m[[0,3,4]]=part2
10127         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())
10128         self.assertEqual([0,4,8,12,16,20],m.getNodalConnectivityIndex().getValues())
10129         self.assertEqual([3],m.getAllTypes())
10130         # no resize with explicit ids list
10131         m=MEDCouplingDataForTest.build2DTargetMesh_1()
10132         part=m[[0,3]]
10133         part.convertAllToPoly()
10134         m[[3,4]]=part
10135         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())
10136         self.assertEqual([0,5,9,13,18,23],m.getNodalConnectivityIndex().getValues())
10137         self.assertEqual([3,4,5],m.getAllTypes())
10138         # resize with range ids
10139         m=MEDCouplingDataForTest.build2DTargetMesh_1()
10140         part=m[3:]
10141         m[1:3]=part
10142         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())
10143         self.assertEqual([0,5,10,15,20,25],m.getNodalConnectivityIndex().getValues())
10144         self.assertEqual([4],m.getAllTypes())
10145         # no resize with range ids
10146         m=MEDCouplingDataForTest.build2DTargetMesh_1()
10147         part=m[0::3]
10148         part.convertAllToPoly()
10149         m[3:]=part
10150         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())
10151         self.assertEqual([0,5,9,13,18,23],m.getNodalConnectivityIndex().getValues())
10152         self.assertEqual([3,4,5],m.getAllTypes())
10153         # no resize with range ids negative direction
10154         m=MEDCouplingDataForTest.build2DTargetMesh_1()
10155         part=m[3::-3]
10156         part.convertAllToPoly()
10157         m[:-3:-1]=part
10158         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())
10159         self.assertEqual([0,5,9,13,18,23],m.getNodalConnectivityIndex().getValues())
10160         self.assertEqual([3,4,5],m.getAllTypes())
10161         pass
10162
10163     def testUnPolyze3(self):
10164         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]
10165         conn=[1,2,5,4,-1,4,3,0,1,-1,2,0,3,5,-1,0,2,1,-1,4,5,3]
10166         m=MEDCouplingUMesh.New("a mesh",3);
10167         m.allocateCells(1);
10168         m.insertNextCell(NORM_POLYHED,22,conn[0:22])
10169         m.finishInsertingCells();
10170         coords=DataArrayDouble(coord,6,3);
10171         m.setCoords(coords);
10172         m.checkCoherency();
10173         #
10174         vol=m.getMeasureField(ON_CELLS);
10175         self.assertEqual(1,vol.getArray().getNumberOfTuples());
10176         self.assertAlmostEqual(0.5,vol.getArray().getIJ(0,0),12)
10177         #
10178         m.unPolyze();
10179         #
10180         self.assertEqual([NORM_PENTA6],m.getAllTypes())
10181         self.assertTrue(DataArrayInt([0,7]).isEqual(m.getNodalConnectivityIndex()))
10182         self.assertTrue(DataArrayInt([16,0,2,1,3,5,4]).isEqual(m.getNodalConnectivity()))
10183         #
10184         vol=m.getMeasureField(ON_CELLS);
10185         self.assertEqual(1,vol.getArray().getNumberOfTuples());
10186         self.assertAlmostEqual(0.5,vol.getArray().getIJ(0,0),12)
10187         pass
10188
10189     def testKrSpatialDiscretization1(self):
10190         srcPointCoordsX=[0.8401877171547095, 0.7830992237586059, 0.9116473579367843, 0.335222755714889, 0.2777747108031878, 0.4773970518621602, 0.3647844727918433, 0.9522297251747128, 0.6357117279599009, 0.1416025553558034]
10191         srcFieldValsOnPoints=[2.129892434968836, 2.295320474540621, 1.931948594981134, 2.728013590937196, 2.715603240418478, 2.661778472822935, 2.695696990104364, 1.893710234970982, 2.529628016549284, 2.728432341300668]
10192         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]
10193         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]
10194         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])
10195         #
10196         nbOfInputPoints=10;
10197         f=MEDCouplingFieldDouble.New(ON_NODES_KR,ONE_TIME);
10198         srcArrX=DataArrayDouble.New(srcPointCoordsX,nbOfInputPoints,1);
10199         cmesh=MEDCouplingCMesh.New("aMesh");
10200         cmesh.setCoordsAt(0,srcArrX);
10201         umesh=cmesh.buildUnstructured();
10202         f.setMesh(umesh);
10203         srcVals=DataArrayDouble.New(srcFieldValsOnPoints,nbOfInputPoints,1);
10204         f.setArray(srcVals);
10205         f.checkCoherency();
10206         #
10207         res0=f.getValueOn(targetPointCoordsX[:1]);
10208         self.assertAlmostEqual(targetFieldValsExpected[0],res0[0],10)
10209         #
10210         valuesToTest=f.getValueOnMulti(targetPointCoordsX);
10211         self.assertEqual(40,valuesToTest.getNumberOfTuples());
10212         self.assertEqual(1,valuesToTest.getNumberOfComponents());
10213         for i in xrange(40):
10214             self.assertAlmostEqual(targetFieldValsExpected[i],valuesToTest.getIJ(i,0),10)
10215             pass
10216         fd=f.getDiscretization()
10217         del f
10218         self.assertTrue(isinstance(fd,MEDCouplingFieldDiscretizationKriging))
10219         coeffs,isDrift=fd.computeVectorOfCoefficients(umesh,srcVals)
10220         self.assertEqual(2,isDrift)
10221         self.assertTrue(coeffsExpected.isEqual(coeffs,1e-8))
10222         #
10223         pass
10224
10225     def testDuplicateEachTupleNTimes1(self):
10226         d=DataArrayDouble.New([9.,8.,7.,6.],4,1) ; d.setInfoOnComponents(["mass [kg]"]) ; d.setName("aname")
10227         d2=d.duplicateEachTupleNTimes(3)
10228         self.assertTrue(d2.isEqualWithoutConsideringStr(DataArrayDouble.New([9.,9.,9.,8.,8.,8.,7.,7.,7.,6.,6.,6.],4*3,1),1e-14))
10229         self.assertEqual("aname",d2.getName())
10230         self.assertEqual(["mass [kg]"],d2.getInfoOnComponents())
10231         #
10232         d=DataArrayInt.New([9,8,7,6],4,1) ; d.setInfoOnComponents(["mass [kg]"]) ; d.setName("aname")
10233         d2=d.duplicateEachTupleNTimes(3)
10234         self.assertTrue(d2.isEqualWithoutConsideringStr(DataArrayInt.New([9,9,9,8,8,8,7,7,7,6,6,6],4*3,1)))
10235         self.assertEqual("aname",d2.getName())
10236         self.assertEqual(["mass [kg]"],d2.getInfoOnComponents())
10237         pass
10238
10239     def testSwigComputeTupleIdsNearTuples1(self):
10240         da=DataArrayDouble([5.,6.,-5.,-6.,5.,-6.,-5.,6.,5.,6.],5,2)
10241         arr,arrI=da.computeTupleIdsNearTuples(DataArrayDouble([5.,-6.,5.,6.,-5.,-6.],3,2),1e-10)
10242         self.assertEqual([2,0,4,1],arr.getValues())
10243         self.assertEqual([0,1,3,4],arrI.getValues())
10244         arr,arrI=da.computeTupleIdsNearTuples([5.,-6.,5.,6.,-5.,-6.],1e-10)
10245         self.assertEqual([2,0,4,1],arr.getValues())
10246         self.assertEqual([0,1,3,4],arrI.getValues())
10247         expected0=[[2],[0,4],[1]]
10248         expected1=[[0,1],[0,2],[0,1]]
10249         for pos,it in enumerate(DataArrayDouble([5.,-6.,5.,6.,-5.,-6.],3,2)):
10250             arr,arrI=da.computeTupleIdsNearTuples(it,1e-10)
10251             self.assertEqual(expected0[pos],arr.getValues())
10252             self.assertEqual(expected1[pos],arrI.getValues())
10253             pass
10254         pass
10255
10256     def testSwigDataTupleIOp1(self):
10257         d=DataArrayDouble(10,1)
10258         d.iota(7.)
10259         for elt in d:
10260             elt+=2.
10261             pass
10262         toTest=DataArrayDouble([9.0,10.0,11.0,12.0,13.0,14.0,15.0,16.0,17.0,18.0])
10263         self.assertTrue(toTest.isEqual(d,1e-12))
10264         for elt in d:
10265             elt-=2.
10266             pass
10267         toTest=DataArrayDouble([7.0,8.0,9.0,10.0,11.0,12.0,13.0,14.0,15.0,16.0])
10268         self.assertTrue(toTest.isEqual(d,1e-12))
10269         for elt in d:
10270             elt*=2.
10271             pass
10272         toTest=DataArrayDouble([14.0,16.0,18.0,20.0,22.0,24.0,26.0,28.0,30.0,32.0])
10273         self.assertTrue(toTest.isEqual(d,1e-12))
10274         for elt in d:
10275             elt/=2.
10276             pass
10277         toTest=DataArrayDouble([7.0,8.0,9.0,10.0,11.0,12.0,13.0,14.0,15.0,16.0])
10278         self.assertTrue(toTest.isEqual(d,1e-12))
10279         #
10280         d=DataArrayInt(10,1)
10281         d.iota(7)
10282         for elt in d:
10283             elt+=2
10284             pass
10285         self.assertEqual(d.getValues(),[9,10,11,12,13,14,15,16,17,18])
10286         for elt in d:
10287             elt-=2
10288             pass
10289         self.assertEqual(d.getValues(),[7,8,9,10,11,12,13,14,15,16])
10290         for elt in d:
10291             elt*=2
10292             pass
10293         self.assertEqual(d.getValues(),[14,16,18,20,22,24,26,28,30,32])
10294         for elt in d:
10295             elt/=2
10296             pass
10297         self.assertEqual(d.getValues(),[7,8,9,10,11,12,13,14,15,16])
10298         for elt in d:
10299             elt%=3
10300             pass
10301         self.assertEqual(d.getValues(),[1,2,0,1,2,0,1,2,0,1])
10302         pass
10303
10304     def testIntersect2DMeshesTmp5(self):
10305         coords=DataArrayDouble.New([41,0,42,0,0,42,0,41,41.5,0,29.698484809834998,29.698484809834994,0,41.5,28.991378028648452,28.991378028648445,-42,0,-41,0,-29.698484809834994,29.698484809834998,-41.5,0,-28.991378028648445,28.991378028648452,0,-42,0,-41,-29.698484809835001,-29.698484809834994,0,-41.5,-28.991378028648455,-28.991378028648445,29.698484809834987,-29.698484809835001,28.991378028648441,-28.991378028648455,43,0,0,43,42.5,0,30.405591591021544,30.40559159102154,0,42.5,-43,0,-30.40559159102154,30.405591591021544,-42.5,0,0,-43,-30.405591591021551,-30.40559159102154,0,-42.5,30.405591591021537,-30.405591591021551,44,0,0,44,43.5,0,31.112698372208094,31.112698372208087,0,43.5,-44,0,-31.112698372208087,31.112698372208094,-43.5,0,0,-44,-31.112698372208097,-31.112698372208087,0,-43.5,31.112698372208083,-31.112698372208097,45,0,0,45,44.5,0,31.81980515339464,31.819805153394636,0,44.5,-45,0,-31.819805153394636,31.81980515339464,-44.5,0,0,-45,-31.819805153394647,-31.819805153394636,0,-44.5,31.819805153394629,-31.819805153394647,47,0,0,47,46,0,33.234018715767739,33.234018715767732,0,46,-47,0,-33.234018715767732,33.234018715767739,-46,0,0,-47,-33.234018715767739,-33.234018715767732,0,-46,33.234018715767725,-33.234018715767739,49,0,0,49,48,0,34.648232278140831,34.648232278140824,0,48,-49,0,-34.648232278140824,34.648232278140831,-48,0,0,-49,-34.648232278140839,-34.648232278140824,0,-48,34.648232278140817,-34.648232278140839,51,0,0,51,50,0,36.062445840513924,36.062445840513924,0,50,-51,0,-36.062445840513924,36.062445840513924,-50,0,0,-51,-36.062445840513931,-36.062445840513924,0,-50,36.062445840513917,-36.062445840513931,53,0,0,53,52,0,37.476659402887023,37.476659402887016,0,52,-53,0,-37.476659402887016,37.476659402887023,-52,0,0,-53,-37.47665940288703,-37.476659402887016,0,-52,37.476659402887009,-37.47665940288703,55,0,0,55,54,0,38.890872965260115,38.890872965260108,0,54,-55,0,-38.890872965260108,38.890872965260115,-54,0,0,-55,-38.890872965260122,-38.890872965260108,0,-54,38.890872965260101,-38.890872965260122,59,0,0,59,57,0,41.719300090006307,41.7193000900063,0,57,-59,0,-41.7193000900063,41.719300090006307,-57,0,0,-59,-41.719300090006314,-41.7193000900063,0,-57,41.719300090006293,-41.719300090006314,63,0,0,63,61,0,44.547727214752499,44.547727214752491,0,61,-63,0,-44.547727214752491,44.547727214752499,-61,0,0,-63,-44.547727214752506,-44.547727214752491,0,-61,44.547727214752484,-44.547727214752506,67,0,0,67,65,0,47.37615433949869,47.376154339498683,0,65,-67,0,-47.376154339498683,47.37615433949869,-65,0,0,-67,-47.376154339498697,-47.376154339498683,0,-65,47.376154339498676,-47.376154339498697,71,0,0,71,69,0,50.204581464244875,50.204581464244868,0,69,-71,0,-50.204581464244868,50.204581464244875,-69,0,0,-71,-50.204581464244889,-50.204581464244868,0,-69,50.20458146424486,-50.204581464244889,75,0,0,75,73,0,53.033008588991066,53.033008588991059,0,73,-75,0,-53.033008588991059,53.033008588991066,-73,0,0,-75,-53.033008588991073,-53.033008588991059,0,-73,53.033008588991052,-53.033008588991073,80,0,0,80,77.5,0,56.568542494923804,56.568542494923797,0,77.5,-80,0,-56.568542494923797,56.568542494923804,-77.5,0,0,-80,-56.568542494923818,-56.568542494923797,0,-77.5,56.56854249492379,-56.568542494923818],188,2)
10306         conn=DataArrayInt.New([8,0,1,2,3,4,5,6,7,8,3,2,8,9,6,10,11,12,8,9,8,13,14,11,15,16,17,8,14,13,1,0,16,18,4,19,8,1,20,21,2,22,23,24,5,8,2,21,25,8,24,26,27,10,8,8,25,28,13,27,29,30,15,8,13,28,20,1,30,31,22,18,8,20,32,33,21,34,35,36,23,8,21,33,37,25,36,38,39,26,8,25,37,40,28,39,41,42,29,8,28,40,32,20,42,43,34,31,8,32,44,45,33,46,47,48,35,8,33,45,49,37,48,50,51,38,8,37,49,52,40,51,53,54,41,8,40,52,44,32,54,55,46,43,8,44,56,57,45,58,59,60,47,8,45,57,61,49,60,62,63,50,8,49,61,64,52,63,65,66,53,8,52,64,56,44,66,67,58,55,8,56,68,69,57,70,71,72,59,8,57,69,73,61,72,74,75,62,8,61,73,76,64,75,77,78,65,8,64,76,68,56,78,79,70,67,8,68,80,81,69,82,83,84,71,8,69,81,85,73,84,86,87,74,8,73,85,88,76,87,89,90,77,8,76,88,80,68,90,91,82,79,8,80,92,93,81,94,95,96,83,8,81,93,97,85,96,98,99,86,8,85,97,100,88,99,101,102,89,8,88,100,92,80,102,103,94,91,8,92,104,105,93,106,107,108,95,8,93,105,109,97,108,110,111,98,8,97,109,112,100,111,113,114,101,8,100,112,104,92,114,115,106,103,8,104,116,117,105,118,119,120,107,8,105,117,121,109,120,122,123,110,8,109,121,124,112,123,125,126,113,8,112,124,116,104,126,127,118,115,8,116,128,129,117,130,131,132,119,8,117,129,133,121,132,134,135,122,8,121,133,136,124,135,137,138,125,8,124,136,128,116,138,139,130,127,8,128,140,141,129,142,143,144,131,8,129,141,145,133,144,146,147,134,8,133,145,148,136,147,149,150,137,8,136,148,140,128,150,151,142,139,8,140,152,153,141,154,155,156,143,8,141,153,157,145,156,158,159,146,8,145,157,160,148,159,161,162,149,8,148,160,152,140,162,163,154,151,8,152,164,165,153,166,167,168,155,8,153,165,169,157,168,170,171,158,8,157,169,172,160,171,173,174,161,8,160,172,164,152,174,175,166,163,8,164,176,177,165,178,179,180,167,8,165,177,181,169,180,182,183,170,8,169,181,184,172,183,185,186,173,8,172,184,176,164,186,187,178,175],540)
10307         connI=DataArrayInt.New([0,9,18,27,36,45,54,63,72,81,90,99,108,117,126,135,144,153,162,171,180,189,198,207,216,225,234,243,252,261,270,279,288,297,306,315,324,333,342,351,360,369,378,387,396,405,414,423,432,441,450,459,468,477,486,495,504,513,522,531,540],61)
10308         #
10309         m1=MEDCouplingUMesh.New("Fix",2);
10310         m1.setCoords(coords);
10311         m1.setConnectivity(conn,connI,True);
10312         #
10313         coords=DataArrayDouble([46.5,-2.5,53.5,-2.5,53.5,2.5,46.5,2.5,50,-2.5,53.5,0,50,2.5,46.5,0,60.5,-2.5,60.5,2.5,57,-2.5,60.5,0,57,2.5,53.5,7.5,46.5,7.5,53.5,5,50,7.5,46.5,5,60.5,7.5,60.5,5,57,7.5,-2,47,2,47,2,53,-2,53,0,47,2,50,0,53,-2,50,6,47,6,53,4,47,6,50,4,53,2,59,-2,59,2,56,0,59,-2,56,6,59,6,56,4,59],42,2)
10314         # connectivity
10315         conn=DataArrayInt([8,0,1,2,3,4,5,6,7,8,1,8,9,2,10,11,12,5,8,3,2,13,14,6,15,16,17,8,2,9,18,13,12,19,20,15,8,21,22,23,24,25,26,27,28,8,22,29,30,23,31,32,33,26,8,24,23,34,35,27,36,37,38,8,23,30,39,34,33,40,41,36],72);
10316         conn.setName("");
10317         connI=DataArrayInt([0,9,18,27,36,45,54,63,72],9)
10318         m2=MEDCouplingUMesh.New("Mobile",2);
10319         m2.setCoords(coords);
10320         m2.setConnectivity(conn,connI,True);
10321         #
10322         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m1,m2,1e-10);
10323         self.assertEqual(105,m3.getNumberOfCells());
10324         self.assertEqual(105,d1.getNumberOfTuples());
10325         self.assertEqual(105,d2.getNumberOfTuples());
10326         self.assertEqual(704,m3.getNumberOfNodes());
10327         #
10328         areaExpected=[-65.18804756198824,-65.18804756198824,-65.18804756198824,-65.18804756198824,-66.75884388878285,-66.75884388878285,-66.7588438887833,-66.75884388878308,-68.32964021557768,-68.32964021557768,-68.32964021557814,-68.32964021557791,-69.9004365423732,-69.9004365423732,-69.90043654237297,-69.90043654237297,-1.194568659706448,-1.0869994447159463,-142.2316939607081,-144.51326206513068,-144.5132620651309,-1.1945686597064424,-143.3186934054243,-5.002264310862817,-10.0261332846393,-3.9727823117092953,-7.290862524642649,-124.504404940456,-3.9727823117093237,-146.82366506060032,-150.79644737231024,-5.002264310862776,-145.79418306144626,-5.00208651738126,-10.054764051268958,-4.001067863263231,-8.027932154428669,-129.99378209314813,-4.001067863263216,-153.07856481622616,-157.0796326794898,-5.0020865173811915,-152.07754616210832,-5.001928880064381,-10.050590216368969,-4.00098721602491,-8.025810856794209,-136.28350081741684,-4.000987216024939,-159.36183077064402,-163.36281798667005,-5.0019288800643285,-158.36088910660442,-1.2991516319851801,-3.702636830195414,-3.7815130030068254,-6.265364371195623,-0.02516260900254963,-0.6553944641345026,-3.975752765070567,-7.368528340442765,-142.57249927881398,-0.02516260900254963,-3.9757527650706095,-165.64508791977525,-169.64600329384803,-1.299151631985167,-3.7026368301953885,-164.6442148316677,-10.00321285677458,-20.08414323176165,-8.001644468035863,-16.042954878437143,-304.0096070742277,-8.00164446803587,-350.1399180412005,-358.1415625092368,-10.003212856774468,-348.13834965246224,-3.794150313030109,-8.65049239704272,-0.02260276689354157,-0.5885167811200915,-370.2185414798688,-0.022602766893559393,-383.2517009710623,-383.2743037379555,-3.7941503130300576,-379.48015342492505,-408.40704496667513,-408.4070449666742,-408.4070449666742,-408.4070449666742,-433.53978619538975,-433.5397861953902,-433.5397861953911,-433.53978619539066,-458.67252742410983,-458.6725274241094,-458.67252742410983,-458.6725274241089,-608.6835766330232,-608.6835766330232,-608.6835766330232,-608.6835766330241]
10329         expected1=[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,16,16,17,18,19,19,20,20,20,20,20,21,21,22,23,23,24,24,24,24,24,25,25,26,27,27,28,28,28,28,28,29,29,30,31,31,32,32,32,32,32,32,32,32,32,33,33,33,34,35,35,35,36,36,36,36,36,37,37,38,39,39,40,40,40,40,40,41,41,42,43,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59]
10330         expected2=[-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,0,2,-1,-1,-1,0,-1,0,2,4,5,-1,4,-1,-1,0,-1,0,2,4,5,-1,4,-1,-1,0,-1,0,2,4,5,-1,4,-1,-1,0,-1,0,1,2,3,4,5,6,7,-1,4,6,-1,-1,0,1,-1,1,3,6,7,-1,6,-1,-1,1,-1,1,3,6,7,-1,6,-1,-1,1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1]
10331         f3=m3.getMeasureField(ON_CELLS).getArray().getValues();
10332         for i in xrange(105):
10333             self.assertAlmostEqual(areaExpected[i],f3[i],10)
10334             pass
10335         self.assertEqual(expected1,d1.getValues())
10336         self.assertEqual(expected2,d2.getValues())
10337         pass
10338
10339     def testDAIBuildUnique1(self):
10340         d=DataArrayInt([1,2,2,3,3,3,3,4,5,5,7,7,7,19])
10341         e=d.buildUnique()
10342         self.assertTrue(e.isEqual(DataArrayInt([1,2,3,4,5,7,19])))
10343         pass
10344
10345     def testDAIPartitionByDifferentValues1(self):
10346         d=DataArrayInt([1,0,1,2,0,2,2,-3,2])
10347         expected=[[-3,[7]],[0,[1,4]],[1,[0,2]],[2,[3,5,6,8]]]
10348         for i,elt in enumerate(zip(*d.partitionByDifferentValues())):
10349             self.assertEqual(expected[i][0],elt[1])
10350             self.assertEqual(expected[i][1],elt[0].getValues())
10351             pass
10352         pass
10353
10354     def testFieldGaussMultiDiscPerType1(self):
10355         coords=DataArrayDouble([0.,0.,0.,1.,1.,1.,1.,0.,0.,0.5,0.5,1.,1.,0.5,0.5,0.],8,2)
10356         mQ8=MEDCouplingUMesh("",2) ; mQ8.setCoords(coords)
10357         mQ8.allocateCells(1)
10358         mQ8.insertNextCell(NORM_QUAD8,range(8))
10359         mQ8.finishInsertingCells()
10360         mQ4=MEDCouplingUMesh("",2) ; mQ4.setCoords(coords)
10361         mQ4.allocateCells(1)
10362         mQ4.insertNextCell(NORM_QUAD4,range(4))
10363         mQ4.finishInsertingCells()
10364         mT3=MEDCouplingUMesh("",2) ; mT3.setCoords(coords)
10365         mT3.allocateCells(1)
10366         mT3.insertNextCell(NORM_TRI3,range(3))
10367         mT3.finishInsertingCells()
10368
10369         tr=[[0.,0.],[2.,0.], [0.,2.],[2.,2.],[4.,2.],[6.,2.],[8.,2.],[10.,2.],[12.,2.],[0.,4.],[2.,4.],[4.,4.],[6.,4.],[8.,4.],[10.,4.],[12.,4.],[14.,4.],[16.,4.],[18.,4.],[20.,4.],[22.,4.]]
10370         ms=2*[mQ4]+7*[mQ8]+11*[mT3]
10371         ms[:]=(elt.deepCpy() for elt in ms)
10372         for m,t in zip(ms,tr):
10373             d=m.getCoords() ; d+= t
10374             pass
10375         m=MEDCouplingUMesh.MergeUMeshes(ms)
10376         f=MEDCouplingFieldDouble.New(ON_GAUSS_PT,NO_TIME)
10377         f.setMesh(m)
10378         # throw because cell 0,1 are QUAD4 and cell 3 is QUAD8
10379         self.assertRaises(InterpKernelException,f.setGaussLocalizationOnCells,[0,1,3],[0.,0.,1.,0.,1.,1.,0.,1.],[0.3,0.3,0.7,0.7],[0.8,0.2])
10380         f.setGaussLocalizationOnCells([0,1],[0.,0.,1.,0.,1.,1.,0.,1.],[0.3,0.3,0.7,0.7],[0.8,0.2])
10381         f.setGaussLocalizationOnCells([3,2,5],[0.,0.,1.,0.,1.,1.,0.,1.,0.5,0.,1.,0.5,0.5,1.,0.,0.5],[0.3,0.3,0.7,0.7,0.9,0.9],[0.8,0.05,0.15])
10382         f.setGaussLocalizationOnCells([4,6,8,7],[0.,0.,1.,0.,1.,1.,0.,1.,0.5,0.,1.,0.5,0.5,1.,0.,0.5],[0.3,0.3,0.7,0.7,0.9,0.9,-0.1,0.3],[0.7,0.05,0.15,0.1])
10383         f.setGaussLocalizationOnCells([9,10,11,12,13],[0.,0.,1.,0.,1.,1.],[0.4,0.4],[1.])
10384         f.setGaussLocalizationOnCells([14,15,16,17,18,19],[0.,0.,1.,0.,1.,1.],[0.4,0.4,0.14,0.16],[0.22,0.78])
10385         self.assertEqual(46,f.getNumberOfTuplesExpected())
10386         vals=DataArrayDouble.New(46*3,1) ; vals.iota(7.7) ; vals.rearrange(3)
10387         f.setArray(vals)
10388         f.checkCoherency()
10389         #f.getLocalizationOfDiscr()
10390         self.assertRaises(InterpKernelException,f.getGaussLocalizationIdOfOneType,NORM_QUAD8) #throw because several loc
10391         self.assertEqual([1,2],f.getGaussLocalizationIdsOfOneType(NORM_QUAD8))
10392         self.assertEqual([0,0,1,1,2,1,2,2,2,3,3,3,3,3,4,4,4,4,4,4],f.getDiscretization().getArrayOfDiscIds().getValues())
10393         fc=f[[1,2,3,8]]
10394         fc.checkCoherency()
10395         self.assertTrue(DataArrayDouble([13.7,14.7,15.7,16.7,17.7,18.7,19.7,20.7,21.7,22.7,23.7,24.7,25.7,26.7,27.7,28.7,29.7,30.7,31.7,32.7,33.7,34.7,35.7,36.7,82.7,83.7,84.7,85.7,86.7,87.7,88.7,89.7,90.7,91.7,92.7,93.7],12,3).isEqual(fc.getArray(),1e-10))
10396         fc.renumberCells([3,2,0,1])
10397         self.assertTrue(DataArrayDouble([28.7, 29.7, 30.7, 31.7, 32.7, 33.7, 34.7, 35.7, 36.7, 82.7, 83.7, 84.7, 85.7, 86.7, 87.7, 88.7, 89.7, 90.7, 91.7, 92.7, 93.7, 19.7, 20.7, 21.7, 22.7, 23.7, 24.7, 25.7, 26.7, 27.7, 13.7, 14.7, 15.7, 16.7, 17.7, 18.7],12,3).isEqual(fc.getArray(),1e-10))
10398         fc.getArray()
10399         pass
10400
10401     def testSwigRotate(self):
10402         d=DataArrayDouble([1.,2.,3.,4.,6.,5.],2,3)
10403         MEDCouplingPointSet.Rotate3DAlg([0.,0.,0.],[0.,1.,0.],1.5707963267948966,d)
10404         self.assertTrue(d.isEqual(DataArrayDouble([3.,2.,-1.,5.,6.,-4.],2,3),1e-12))
10405         d=DataArrayDouble([1.,2.,3.,4.,6.,5.],3,2)
10406         MEDCouplingPointSet.Rotate2DAlg([0.,0.],1.5707963267948966,d)
10407         self.assertTrue(d.isEqual(DataArrayDouble([-2.,1.,-4.,3.,-5.,6.],3,2),1e-12))
10408         pass
10409
10410     def testSwigCMeshProtection(self):
10411         cm=MEDCouplingCMesh()
10412         self.assertRaises(InterpKernelException,cm.setCoordsAt,0,DataArrayDouble([4.,4.5,6.,7.],2,2))
10413         self.assertRaises(InterpKernelException,cm.setCoords,DataArrayDouble([4.,4.5,6.,7.],2,2))
10414         pass
10415
10416     def testSwigCellsInBoundingBox1(self):
10417         m3D=MEDCouplingDataForTest.build3DExtrudedUMesh_1()[0]
10418         self.assertTrue(m3D.getCellsInBoundingBox([(0,3),(0,3),(0,1)],-1e-12).isEqual(DataArrayInt([0,1,2,3,4,5])))
10419         self.assertRaises(InterpKernelException,m3D.getCellsInBoundingBox,[(0,3,0),(3,0,1)],-1e-12)
10420         pass
10421
10422     def testDAICheckMonotonic1(self):
10423         data1=[-1,0,2,2,4,5]
10424         data2=[6,2,0,-8,-9,-56]
10425         data3=[-1,0,3,2,4,6]
10426         data4=[7,5,2,3,0,-6]
10427         d=DataArrayInt.New(data1);
10428         self.assertTrue(d.isMonotonic(True));
10429         self.assertTrue(not d.isMonotonic(False));
10430         d.checkMonotonic(True);
10431         self.assertRaises(InterpKernelException,d.checkMonotonic,False)
10432         d=DataArrayInt.New(data2);
10433         self.assertTrue(d.isMonotonic(False));
10434         self.assertTrue(not d.isMonotonic(True));
10435         d.checkMonotonic(False);
10436         self.assertRaises(InterpKernelException,d.checkMonotonic,True)
10437         d=DataArrayInt.New(data3);
10438         self.assertTrue(not d.isMonotonic(False));
10439         self.assertTrue(not d.isMonotonic(True));
10440         self.assertRaises(InterpKernelException,d.checkMonotonic,True)
10441         self.assertRaises(InterpKernelException,d.checkMonotonic,False)
10442         d=DataArrayInt.New(data4);
10443         self.assertTrue(not d.isMonotonic(False));
10444         self.assertTrue(not d.isMonotonic(True));
10445         self.assertRaises(InterpKernelException,d.checkMonotonic,True)
10446         self.assertRaises(InterpKernelException,d.checkMonotonic,False)
10447         d=DataArrayInt.New(0,1)
10448         self.assertTrue(d.isMonotonic(True));
10449         self.assertTrue(d.isMonotonic(False));
10450         d.checkMonotonic(True);
10451         d.checkMonotonic(False);
10452         d=DataArrayInt.New(data4,3,2);#throw because nbComp!=1
10453         self.assertRaises(InterpKernelException,d.isMonotonic,True)
10454         self.assertRaises(InterpKernelException,d.isMonotonic,False)
10455         self.assertRaises(InterpKernelException,d.checkMonotonic,True)
10456         self.assertRaises(InterpKernelException,d.checkMonotonic,False)
10457         pass
10458
10459     def testSwigDASetItemOnEmpty1(self):
10460         d=DataArrayInt(0,1)
10461         isThrow=False
10462         try:
10463             d[0:1000:2]=4
10464         except InterpKernelException as e:
10465             isThrow=True
10466             pass
10467         self.assertTrue(isThrow)
10468         d[:]=4
10469         d[::2]=5
10470         #
10471         d=DataArrayDouble(0,1)
10472         isThrow=False
10473         try:
10474             d[0:1000:2]=4
10475         except InterpKernelException as e:
10476             isThrow=True
10477             pass
10478         self.assertTrue(isThrow)
10479         d[:]=4
10480         d[::2]=5
10481         d=DataArrayInt([],0,1)
10482         d2=DataArrayInt(0)
10483         self.assertTrue(d2.isEqual(d))
10484         d=DataArrayDouble([],0,1)
10485         d2=DataArrayDouble(0)
10486         self.assertTrue(d2.isEqual(d,1e-12))
10487         pass
10488
10489     def testSwigDAITransformWithIndArr1(self):
10490         arr=DataArrayInt([0,4,5,1])
10491         d=DataArrayInt([7,8,9,10])
10492         self.assertRaises(InterpKernelException,arr.transformWithIndArr,d)
10493         pass
10494
10495     def testIntersect2DMeshesTmp6(self):
10496         # coordinates
10497         coords=DataArrayDouble.New([2.7554552980815448e-15,45,-45,5.5109105961630896e-15,-31.819805153394636,31.81980515339464,2.8779199779962799e-15,47,2.8166876380389124e-15,46,-47,5.7558399559925599e-15,-33.234018715767732,33.234018715767739,-46,5.6333752760778247e-15],8,2);
10498         # connectivity
10499         conn=DataArrayInt.New([8,0,3,5,1,4,6,7,2])
10500         connI=DataArrayInt.New([0,9]);
10501         m1=MEDCouplingUMesh.New("Fixe",2);
10502         m1.setCoords(coords);
10503         m1.setConnectivity(conn,connI,True);
10504         #
10505         coords=DataArrayDouble.New([-7.3800475508445391,41.854329503018846,-3.7041190667754655,42.338274668899189,-3.7041190667754655,45.338274668899189,-7.3800475508445382,44.854329503018839,-5.5473631693521845,42.136406608386956,-3.7041190667754655,43.838274668899189,-5.5420833088100014,45.09630208595901,-7.3800475508445382,43.354329503018839,-3.7041190667754651,52.338274668899189,-7.3800475508445382,51.854329503018839,-3.7041190667754655,48.838274668899189,-5.5420833088100014,52.09630208595901,-7.3800475508445382,48.354329503018839],13,2);
10506         # connectivity
10507         conn=DataArrayInt.New([8,0,1,2,3,4,5,6,7,8,3,2,8,9,6,10,11,12]);
10508         connI=DataArrayInt.New([0,9,18]);
10509         #
10510         m2=MEDCouplingUMesh.New("Mobile",2);
10511         m2.setCoords(coords);
10512         m2.setConnectivity(conn,connI,True);
10513         #
10514         m3,d1,d2=MEDCouplingUMesh.Intersect2DMeshes(m1,m2,1e-10);
10515         self.assertTrue(d1.isEqual(DataArrayInt([0,0,0,0])));
10516         self.assertTrue(d2.isEqual(DataArrayInt([0,1,-1,-1])));
10517         self.assertEqual(4,m3.getNumberOfCells());
10518         self.assertEqual(4,d1.getNumberOfTuples());
10519         self.assertEqual(4,d2.getNumberOfTuples());
10520         self.assertEqual(43,m3.getNumberOfNodes());
10521         dI,areMerged,newNbOfNodes=m3.mergeNodes(1e-12)
10522         self.assertEqual(35,m3.getNumberOfNodes());
10523         m3.zipCoords();
10524         self.assertEqual(23,m3.getNumberOfNodes());
10525         #
10526         f=m3.getMeasureField(True);
10527         valuesExpected=DataArrayDouble([1.6603638692585716,5.747555728471923,129.68907101754394,7.4162714498559694])
10528         self.assertTrue(f.getArray().isEqual(valuesExpected,1e-12))
10529         pass
10530
10531     def testDAPushBack(self):
10532         d=DataArrayDouble(0,1)
10533         for i in xrange(8):
10534             d.pushBackSilent(i)
10535             pass
10536         self.assertEqual(d.getNumberOfTuples(),8)
10537         self.assertEqual(d.getNbOfElemAllocated(),8)
10538         d.pushBackSilent(4.44)
10539         self.assertEqual(d.getNumberOfTuples(),9)
10540         self.assertEqual(d.getNbOfElemAllocated(),16)
10541         self.assertTrue(d.isEqual(DataArrayDouble([0.,1.,2.,3.,4.,5.,6.,7.,4.44]),1e-12))
10542         e=d.deepCpy()
10543         self.assertEqual(e.getNumberOfTuples(),9)
10544         self.assertEqual(e.getNbOfElemAllocated(),9)
10545         self.assertTrue(e.isEqual(DataArrayDouble([0.,1.,2.,3.,4.,5.,6.,7.,4.44]),1e-12))
10546         self.assertAlmostEqual(d.popBackSilent(),4.44,12)
10547         self.assertEqual(d.getNumberOfTuples(),8)
10548         self.assertEqual(d.getNbOfElemAllocated(),16)
10549         self.assertTrue(d.isEqual(DataArrayDouble([0.,1.,2.,3.,4.,5.,6.,7.]),1e-12))
10550         f=DataArrayDouble()
10551         f.reserve(1000)
10552         f.pushBackSilent(4.)
10553         self.assertTrue(f.isEqual(DataArrayDouble([4.]),1e-12))
10554         self.assertEqual(f.getNumberOfTuples(),1)
10555         self.assertEqual(f.getNbOfElemAllocated(),1000)
10556         ff=f[:]
10557         self.assertTrue(ff.isEqual(DataArrayDouble([4.]),1e-12))
10558         self.assertEqual(ff.getNumberOfTuples(),1)
10559         self.assertEqual(ff.getNbOfElemAllocated(),1)
10560         d=DataArrayDouble()
10561         d.pushBackSilent(4.44)
10562         d.pushBackSilent(5.55)
10563         d.pushBackSilent(6.66)
10564         self.assertTrue(d.isEqual(DataArrayDouble([4.44,5.55,6.66]),1e-12))
10565         #
10566         d=DataArrayInt(0,1)
10567         for i in xrange(8):
10568             d.pushBackSilent(i)
10569             pass
10570         self.assertEqual(d.getNumberOfTuples(),8)
10571         self.assertEqual(d.getNbOfElemAllocated(),8)
10572         d.pushBackSilent(444)
10573         self.assertEqual(d.getNumberOfTuples(),9)
10574         self.assertEqual(d.getNbOfElemAllocated(),16)
10575         self.assertTrue(d.isEqual(DataArrayInt([0,1,2,3,4,5,6,7,444])))
10576         e=d.deepCpy()
10577         self.assertEqual(e.getNumberOfTuples(),9)
10578         self.assertEqual(e.getNbOfElemAllocated(),9)
10579         self.assertTrue(e.isEqual(DataArrayInt([0,1,2,3,4,5,6,7,444])))
10580         self.assertEqual(d.popBackSilent(),444)
10581         self.assertEqual(d.getNumberOfTuples(),8)
10582         self.assertEqual(d.getNbOfElemAllocated(),16)
10583         self.assertTrue(d.isEqual(DataArrayInt([0,1,2,3,4,5,6,7])))
10584         f=DataArrayInt()
10585         f.reserve(1000)
10586         f.pushBackSilent(4)
10587         self.assertTrue(f.isEqual(DataArrayInt([4])))
10588         self.assertEqual(f.getNumberOfTuples(),1)
10589         self.assertEqual(f.getNbOfElemAllocated(),1000)
10590         ff=f[:]
10591         self.assertTrue(ff.isEqual(DataArrayInt([4])))
10592         self.assertEqual(ff.getNumberOfTuples(),1)
10593         self.assertEqual(ff.getNbOfElemAllocated(),1)
10594         d=DataArrayInt()
10595         d.pushBackSilent(444)
10596         d.pushBackSilent(555)
10597         d.pushBackSilent(666)
10598         self.assertTrue(d.isEqual(DataArrayInt([444,555,666])))
10599         #
10600         d=DataArrayInt()
10601         d.alloc(10,1)
10602         d.setInfoOnComponent(0,"ABC")
10603         d.setName("dEf")
10604         d.iota(7)
10605         e=DataArrayInt([7,8,9,10,11,12,13,14,15,16]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
10606         self.assertEqual(10,d.getNbOfElemAllocated())
10607         d.pushBackSilent(55)
10608         e=DataArrayInt([7,8,9,10,11,12,13,14,15,16,55]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
10609         self.assertEqual(20,d.getNbOfElemAllocated())
10610         d.reserve(4)
10611         e=DataArrayInt([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
10612         self.assertEqual(4,d.getNbOfElemAllocated())
10613         d.pushBackSilent(5)
10614         e=DataArrayInt([7,8,9,10,5]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
10615         self.assertEqual(8,d.getNbOfElemAllocated())
10616         self.assertEqual(5,d.popBackSilent())
10617         e=DataArrayInt([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
10618         self.assertEqual(8,d.getNbOfElemAllocated())
10619         self.assertRaises(InterpKernelException,d.reserve,-1)
10620         e=DataArrayInt([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e))
10621         self.assertEqual(8,d.getNbOfElemAllocated())
10622         d.reserve(0)
10623         e=DataArrayInt([]) ; e.setInfoOnComponent(0,"ABC") ; e.setName("dEf") ; self.assertTrue(d.isEqual(e))
10624         self.assertEqual(0,d.getNbOfElemAllocated())
10625         #
10626         d=DataArrayDouble()
10627         d.alloc(10,1)
10628         d.setInfoOnComponent(0,"ABC")
10629         d.setName("dEf")
10630         d.iota(7)
10631         e=DataArrayDouble([7,8,9,10,11,12,13,14,15,16]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
10632         self.assertEqual(10,d.getNbOfElemAllocated())
10633         d.pushBackSilent(55)
10634         e=DataArrayDouble([7,8,9,10,11,12,13,14,15,16,55]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
10635         self.assertEqual(20,d.getNbOfElemAllocated())
10636         d.reserve(4)
10637         e=DataArrayDouble([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
10638         self.assertEqual(4,d.getNbOfElemAllocated())
10639         d.pushBackSilent(5)
10640         e=DataArrayDouble([7,8,9,10,5]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
10641         self.assertEqual(8,d.getNbOfElemAllocated())
10642         self.assertEqual(5.,d.popBackSilent())
10643         e=DataArrayDouble([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
10644         self.assertEqual(8,d.getNbOfElemAllocated())
10645         self.assertRaises(InterpKernelException,d.reserve,-1)
10646         e=DataArrayDouble([7,8,9,10]) ; e.copyStringInfoFrom(d) ; self.assertTrue(d.isEqual(e,1e-14))
10647         self.assertEqual(8,d.getNbOfElemAllocated())
10648         d.reserve(0)
10649         e=DataArrayDouble([]) ; e.setInfoOnComponent(0,"ABC") ; e.setName("dEf") ; self.assertTrue(d.isEqual(e,1e-14))
10650         self.assertEqual(0,d.getNbOfElemAllocated())
10651         pass
10652
10653     def testDAIBuildSubstractionOptimized1(self):
10654         da1=DataArrayInt.New([1,3,5,6,7,9,13])
10655         da2=DataArrayInt.New([3,5,9])
10656         da3=DataArrayInt.New([1,3,5])
10657         da4=DataArrayInt.New([1,3,5,6,7,9,13])
10658         #
10659         a=da1.buildSubstractionOptimized(da2);
10660         self.assertTrue(a.isEqual(DataArrayInt([1,6,7,13])));
10661         #
10662         a=da1.buildSubstractionOptimized(da3);
10663         self.assertTrue(a.isEqual(DataArrayInt([6,7,9,13])));
10664         #
10665         a=da1.buildSubstractionOptimized(da4);
10666         self.assertTrue(a.isEqual(DataArrayInt([])));
10667         pass
10668
10669     def testDAIIsStrictlyMonotonic1(self):
10670         da1=DataArrayInt.New([1,3,5,6,7,9,13])
10671         self.assertTrue(da1.isStrictlyMonotonic(True));
10672         da1.checkStrictlyMonotonic(True);
10673         self.assertTrue(da1.isMonotonic(True));
10674         da1.checkMonotonic(True);
10675         self.assertTrue(not da1.isStrictlyMonotonic(False));
10676         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,False)
10677         self.assertTrue(not da1.isMonotonic(False));
10678         self.assertRaises(InterpKernelException,da1.checkMonotonic,False)
10679         #
10680         da1=DataArrayInt.New([1,3,5,6,6,9,13])
10681         self.assertTrue(not da1.isStrictlyMonotonic(True));
10682         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,True)
10683         self.assertTrue(da1.isMonotonic(True));
10684         da1.checkMonotonic(True);
10685         self.assertTrue(not da1.isStrictlyMonotonic(False));
10686         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,False)
10687         self.assertTrue(not da1.isMonotonic(False));
10688         self.assertRaises(InterpKernelException,da1.checkMonotonic,False)
10689         #
10690         da1=DataArrayInt.New([1,3,5,6,5,9,13])
10691         self.assertTrue(not da1.isStrictlyMonotonic(True));
10692         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,True)
10693         self.assertTrue(not da1.isMonotonic(True));
10694         self.assertRaises(InterpKernelException,da1.checkMonotonic,True)
10695         self.assertTrue(not da1.isStrictlyMonotonic(False));
10696         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,False)
10697         self.assertTrue(not da1.isMonotonic(False));
10698         self.assertRaises(InterpKernelException,da1.checkMonotonic,False)
10699         #
10700         da1=DataArrayInt.New([13,9,7,6,5,3,1])
10701         self.assertTrue(not da1.isStrictlyMonotonic(True));
10702         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,True)
10703         self.assertTrue(not da1.isMonotonic(True));
10704         self.assertRaises(InterpKernelException,da1.checkMonotonic,True)
10705         self.assertTrue(da1.isStrictlyMonotonic(False));
10706         da1.checkStrictlyMonotonic(False);
10707         self.assertTrue(da1.isMonotonic(False));
10708         da1.checkMonotonic(False);
10709         #
10710         da1=DataArrayInt.New([13,9,6,6,5,3,1])
10711         self.assertTrue(not da1.isStrictlyMonotonic(True));
10712         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,True)
10713         self.assertTrue(not da1.isMonotonic(True));
10714         self.assertRaises(InterpKernelException,da1.checkMonotonic,True)
10715         self.assertTrue(not da1.isStrictlyMonotonic(False));
10716         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,False)
10717         self.assertTrue(da1.isMonotonic(False));
10718         da1.checkMonotonic(False);
10719         #
10720         da1=DataArrayInt.New([13,9,5,6,5,3,1])
10721         self.assertTrue(not da1.isStrictlyMonotonic(True));
10722         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,True)
10723         self.assertTrue(not da1.isMonotonic(True));
10724         self.assertRaises(InterpKernelException,da1.checkMonotonic,True)
10725         self.assertTrue(not da1.isStrictlyMonotonic(False));
10726         self.assertRaises(InterpKernelException,da1.checkStrictlyMonotonic,False)
10727         self.assertTrue(not da1.isMonotonic(False));
10728         self.assertRaises(InterpKernelException,da1.checkMonotonic,False)
10729         #
10730         da1=DataArrayInt.New([])
10731         self.assertTrue(da1.isStrictlyMonotonic(True));
10732         da1.checkStrictlyMonotonic(True);
10733         self.assertTrue(da1.isMonotonic(True));
10734         da1.checkMonotonic(True);
10735         self.assertTrue(da1.isStrictlyMonotonic(False));
10736         da1.checkStrictlyMonotonic(False);
10737         self.assertTrue(da1.isMonotonic(False));
10738         da1.checkMonotonic(False);
10739         #
10740         da1=DataArrayInt.New([13])
10741         self.assertTrue(da1.isStrictlyMonotonic(True));
10742         da1.checkStrictlyMonotonic(True);
10743         self.assertTrue(da1.isMonotonic(True));
10744         da1.checkMonotonic(True);
10745         self.assertTrue(da1.isStrictlyMonotonic(False));
10746         da1.checkStrictlyMonotonic(False);
10747         self.assertTrue(da1.isMonotonic(False));
10748         da1.checkMonotonic(False);
10749         pass
10750
10751     def testFindAndCorrectBadOriented3DCells1(self):
10752         nbOfDisc=20
10753         vects=([0,0,-1],[0.3,0.7,0.2],[-0.3,0.7,0.2],[-0.3,-0.7,0.2])
10754         #
10755         m0=MEDCouplingUMesh("m",3) ; m0.allocateCells(0); m0.insertNextCell(NORM_TETRA4,[0,1,2,3]); #Well oriented
10756         m1=MEDCouplingUMesh("m",3) ; m1.allocateCells(0); m1.insertNextCell(NORM_PYRA5,[0,1,2,3,4]); #Well oriented
10757         m2=MEDCouplingUMesh("m",3) ; m2.allocateCells(0); m2.insertNextCell(NORM_PENTA6,[0,1,2,3,4,5]); #Well oriented
10758         m3=MEDCouplingUMesh("m",3) ; m3.allocateCells(0); m3.insertNextCell(NORM_HEXA8,[0,1,2,3,4,5,6,7]); #Well oriented
10759         m4=MEDCouplingUMesh("m",3) ; m4.allocateCells(0)
10760         self.assertRaises(InterpKernelException,m4.insertNextCell,NORM_HEXGP12,[0,1,2,3,4,5,6,7,8,9,10,11,12]);
10761         m4.insertNextCell(NORM_HEXGP12,[0,1,2,3,4,5,6,7,8,9,10,11]); #Well oriented
10762         c0=DataArrayDouble([0.,0.,0.,0.,1.,0.,1.,0.,0.,0.,0.,1.],4,3) ; m0.setCoords(c0)
10763         c1=DataArrayDouble([0.,0.,0.,0.,1.,0.,1.,1.,0.,1.,0.,0.,0.,0.,1.],5,3) ; m1.setCoords(c1)
10764         c2=DataArrayDouble([0.,0.,0.,0.,1.,0.,1.,0.,0., 0.,0.,1.,0.,1.,1.,1.,0.,1.],6,3) ; m2.setCoords(c2)
10765         c3=DataArrayDouble([0.,0.,0.,0.,1.,0.,1.,1.,0.,1.,0.,0.,0.,0.,1.,0.,1.,1.,1.,1.,1.,1.,0.,1.],8,3) ; m3.setCoords(c3)
10766         c4=DataArrayDouble([0.,0.,0.,0.,1.,0.,1.,1.,0.,1.,0.,0.,0.8,0.,0.,0.45,0.,0.,   0.,0.,1.,0.,1.,1.,1.,1.,1.,1.,0.,1.,0.8,0.,1.,0.45,0.,1.],12,3) ; m4.setCoords(c4)
10767         m=MEDCouplingMesh.MergeMeshes([m0,m1,m2,m3,m4])
10768         expected1=DataArrayDouble([0.16666666666666666,0.3333333333333333,0.5,1.,1.])
10769         for v in vects:
10770             for i in xrange(nbOfDisc):
10771                 mm=m.deepCpy()
10772                 mm.rotate([0.,0.,0.],[0.3,0.7,0.2],float(i)/float(nbOfDisc)*2*pi)
10773                 mm2=mm.deepCpy()
10774                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
10775                 self.assertTrue(mm.findAndCorrectBadOriented3DCells().empty())
10776                 self.assertTrue(mm.isEqual(mm2,1e-14))
10777                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
10778                 mm.convertAllToPoly()
10779                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
10780                 pass
10781             pass
10782         #
10783         mOK=m.deepCpy()
10784         m0=MEDCouplingUMesh("m",3) ; m0.allocateCells(0); m0.insertNextCell(NORM_TETRA4,[0,2,1,3]); #Not well oriented
10785         m1=MEDCouplingUMesh("m",3) ; m1.allocateCells(0); m1.insertNextCell(NORM_PYRA5,[0,1,2,3,4]); #Well oriented
10786         m2=MEDCouplingUMesh("m",3) ; m2.allocateCells(0); m2.insertNextCell(NORM_PENTA6,[0,1,2,3,4,5]); #Well oriented
10787         m3=MEDCouplingUMesh("m",3) ; m3.allocateCells(0); m3.insertNextCell(NORM_HEXA8,[0,3,2,1,4,7,6,5]); #Not well oriented
10788         m4=MEDCouplingUMesh("m",3) ; m4.allocateCells(0); m4.insertNextCell(NORM_HEXGP12,[0,5,4,3,2,1,6,11,10,9,8,7]); #Not well oriented
10789         m0.setCoords(c0) ; m1.setCoords(c1) ; m2.setCoords(c2) ; m3.setCoords(c3) ; m4.setCoords(c4)
10790         m=MEDCouplingMesh.MergeMeshes([m0,m1,m2,m3,m4])
10791         expected2=DataArrayDouble([-0.16666666666666666,0.3333333333333333,0.5,-1.,-1.])
10792         for v in vects:
10793             for i in xrange(nbOfDisc):
10794                 mm=m.deepCpy()
10795                 mm.rotate([0.,0.,0.],[0.3,0.7,0.2],float(i)/float(nbOfDisc)*2*pi)
10796                 mm2=mm.deepCpy() ; mm3=mm.deepCpy() ; mm3.convertAllToPoly()
10797                 self.assertTrue(mm3.getMeasureField(False).getArray().isEqual(expected2,1e-14))
10798                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected2,1e-14))
10799                 self.assertTrue(mm.findAndCorrectBadOriented3DCells().isEqual(DataArrayInt([0,3,4])))
10800                 mOK.setCoords(mm.getCoords())
10801                 self.assertTrue(mm.isEqual(mOK,1e-14))
10802                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
10803                 mmm=mm.deepCpy()
10804                 self.assertTrue(mmm.findAndCorrectBadOriented3DCells().empty())
10805                 mm.convertAllToPoly()
10806                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
10807                 pass
10808             pass
10809         #
10810         m0=MEDCouplingUMesh("m",3) ; m0.allocateCells(0); m0.insertNextCell(NORM_TETRA4,[0,1,2,3]); #Well oriented
10811         m1=MEDCouplingUMesh("m",3) ; m1.allocateCells(0); m1.insertNextCell(NORM_PYRA5,[0,3,2,1,4]); #Not well oriented
10812         m2=MEDCouplingUMesh("m",3) ; m2.allocateCells(0); m2.insertNextCell(NORM_PENTA6,[0,2,1,3,5,4]); #Not well oriented
10813         m3=MEDCouplingUMesh("m",3) ; m3.allocateCells(0); m3.insertNextCell(NORM_HEXA8,[0,1,2,3,4,5,6,7]); #Well oriented
10814         m4=MEDCouplingUMesh("m",3) ; m4.allocateCells(0); m4.insertNextCell(NORM_HEXGP12,range(12)); #Well oriented
10815         m0.setCoords(c0) ; m1.setCoords(c1) ; m2.setCoords(c2) ; m3.setCoords(c3) ; m4.setCoords(c4)
10816         m=MEDCouplingMesh.MergeMeshes([m0,m1,m2,m3,m4])
10817         expected3=DataArrayDouble([0.16666666666666666,-0.3333333333333333,-0.5,1.,1.])
10818         for v in vects:
10819             for i in xrange(nbOfDisc):
10820                 mm=m.deepCpy()
10821                 mm.rotate([0.,0.,0.],[0.3,0.7,0.2],float(i)/float(nbOfDisc)*2*pi)
10822                 mm2=mm.deepCpy() ; mm3=mm.deepCpy() ; mm3.convertAllToPoly()
10823                 self.assertTrue(mm3.getMeasureField(False).getArray().isEqual(expected3,1e-14))
10824                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected3,1e-14))
10825                 self.assertTrue(mm.findAndCorrectBadOriented3DCells().isEqual(DataArrayInt([1,2])))
10826                 mOK.setCoords(mm.getCoords())
10827                 self.assertTrue(mm.isEqual(mOK,1e-14))
10828                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
10829                 mmm=mm.deepCpy()
10830                 self.assertTrue(mmm.findAndCorrectBadOriented3DCells().empty())
10831                 mm.convertAllToPoly()
10832                 self.assertTrue(mm.getMeasureField(False).getArray().isEqual(expected1,1e-14))
10833                 pass
10834             pass
10835         pass
10836
10837     def testSwig2CellOrientation1(self):
10838         coords=DataArrayDouble([-0.21606,-0.10803,0.29999999999999999,-0.21606,-0.10803,0.37700000000000006,0,-0.10803,0.29999999999999999,0,-0.10803,0.37700000000000006,0,0.10803,0.29999999999999999,0,0.10803,0.37700000000000006,-0.21606,0.10803,0.29999999999999999,-0.21606,0.10803,0.37700000000000006,0,0.03601,0.29999999999999999,0,0.03601,0.37700000000000006,0,-0.03601,0.29999999999999999,0,-0.03601,0.37700000000000006],12,3)
10839         conn=[[0,2,10,8,4,6],[1,3,11,9,5,7],[0,1,3,2],[2,3,11,10],[10,11,9,8],[8,9,5,4],[4,5,7,6],[6,7,1,0]]
10840         for i in xrange(256):
10841             mesh=MEDCouplingUMesh("FluidMesh_1",3);
10842             mesh.allocateCells(0)
10843             conn2=[elt[:] for elt in conn]
10844             code=bin(i)[2:] ; code='0'*(8-len(code))+code
10845             for face,rev in zip(conn2,code):
10846                 if bool(int(rev)):
10847                     face.reverse()
10848                     pass
10849                 pass
10850             conn3=[elt+[-1] for elt in conn2]
10851             conn3=sum(conn3,[])[:-1]
10852             mesh.insertNextCell(NORM_POLYHED,conn3)
10853             mesh.setCoords(coords)
10854             mesh.orientCorrectlyPolyhedrons()
10855             self.assertTrue(mesh.getBarycenterAndOwner().isEqual(DataArrayDouble([-0.10803,0.,0.3385],1,3),1e-12))
10856             pass
10857         pass
10858
10859     def testSwig2CheckConsecutiveCellTypesForMEDFileFrmt1(self):
10860         m1=MEDCouplingUMesh("",2) ; m1.allocateCells(0)
10861         m1.insertNextCell(NORM_QUAD4,[0,1,2,3])
10862         m1.insertNextCell(NORM_TRI3,[0,1,2])
10863         d=DataArrayDouble(4,3) ; d[:]=0.
10864         m1.setCoords(d)
10865         self.assertTrue(m1.checkConsecutiveCellTypes())
10866         self.assertTrue(not m1.checkConsecutiveCellTypesForMEDFileFrmt())
10867         m1.renumberCells([1,0])
10868         self.assertTrue(m1.checkConsecutiveCellTypes())
10869         self.assertTrue(m1.checkConsecutiveCellTypesForMEDFileFrmt())
10870         pass
10871
10872     def testSwig2DAAccumulate1(self):
10873         d=DataArrayInt(10) ; d.iota(0)
10874         self.assertEqual([45],d.accumulate())
10875         self.assertEqual(45,d.accumulate(0))
10876         d=DataArrayInt(30) ; d.iota(0) ; d.rearrange(3)
10877         self.assertEqual([135,145,155],d.accumulate())
10878         self.assertEqual(135,d.accumulate(0))
10879         self.assertEqual(145,d.accumulate(1))
10880         self.assertEqual(155,d.accumulate(2))
10881         d=DataArrayDouble(10) ; d.iota(0.)
10882         self.assertEqual([45.],d.accumulate())
10883         self.assertEqual(45.,d.accumulate(0))
10884         d=DataArrayDouble(30) ; d.iota(0) ; d.rearrange(3)
10885         self.assertEqual([135.,145.,155.],d.accumulate())
10886         self.assertEqual(135.,d.accumulate(0))
10887         self.assertEqual(145.,d.accumulate(1))
10888         self.assertEqual(155.,d.accumulate(2))
10889         pass
10890
10891     def testSwig2UMeshDistanceToMesh1(self):
10892         m=MEDCouplingUMesh("toto",2)
10893         coords=DataArrayDouble([2.3,3.4,5.6,6.5,-4.3,3.2,-9.8,7.6,-5.4],3,3)
10894         m.setCoords(coords)
10895         m.allocateCells(0)
10896         m.insertNextCell(NORM_TRI3,[0,1,2])
10897         a,b,c=m.distanceToPoint([-0.335,2.27,1.21])
10898         self.assertEqual(0,b) ; self.assertEqual(0,c)
10899         self.assertAlmostEqual(0.022360988100374124,a,14);
10900         a,b,c=m.distanceToPoint(DataArrayDouble([-0.335,2.27,1.21],1,3))
10901         self.assertEqual(0,b) ; self.assertEqual(0,c)
10902         self.assertAlmostEqual(0.022360988100374124,a,14);
10903         a,b=coords.distanceToTuple([-0.335,2.27,1.21])
10904         self.assertAlmostEqual(5.243302871282566,a,14)
10905         self.assertEqual(0,b)
10906         #
10907         m=MEDCouplingUMesh("toto",2)
10908         coords=DataArrayDouble([0.,0.,0., 8.,0.,0., 8.,8.,0., 0.,8.,0.],4,3)
10909         m.setCoords(coords)
10910         m.allocateCells(0)
10911         m.insertNextCell(NORM_QUAD4,[0,1,2,3])
10912         m.checkCoherency2()
10913         self.assertEqual([4,0,1,2,3],m.getNodalConnectivity().getValues())
10914         a,b,c=m.distanceToPoint([5.,2.,0.1])
10915         self.assertAlmostEqual(0.1,a,14) ; self.assertEqual(0,b) ; self.assertEqual(1,c)
10916         a,b,c=m.distanceToPoint([5.,-2.,4.])
10917         self.assertAlmostEqual(sqrt(2*2+4*4),a,14) ; self.assertEqual(0,b) ; self.assertEqual(1,c)
10918         m.allocateCells(0)
10919         m.insertNextCell(NORM_POLYGON,[0,1,2,3])
10920         m.checkCoherency2()
10921         self.assertEqual([5,0,1,2,3],m.getNodalConnectivity().getValues())
10922         a,b,c=m.distanceToPoint([11.,3.,4.])
10923         self.assertAlmostEqual(sqrt(3*3+4*4),a,14) ; self.assertEqual(0,b) ; self.assertEqual(1,c)
10924         a,b,c=m.distanceToPoint([4.,12.,5.])
10925         self.assertAlmostEqual(sqrt(4*4+5*5),a,14) ; self.assertEqual(0,b) ; self.assertEqual(2,c)
10926         d=DataArrayDouble([-1.2,3.,2.],1,3)
10927         for elt in d:
10928             a,b,c=m.distanceToPoint(d)
10929             self.assertAlmostEqual(sqrt(1.2*1.2+2*2),a,14) ; self.assertEqual(0,b) ; self.assertEqual(0,c)
10930             pass
10931         #
10932         m=MEDCouplingUMesh("toto",1)
10933         coords=DataArrayDouble([0.,0.,4.,0.,0.,4.],3,2) ; m.setCoords(coords)
10934         m.allocateCells(0) ; m.insertNextCell(NORM_SEG2,[0,1]) ; m.insertNextCell(NORM_SEG2,[1,2])
10935         a,b,c=m.distanceToPoint([-0.1,4.1])
10936         self.assertAlmostEqual(0.14142135623730925,a,14) ; self.assertEqual(-1,b) ; self.assertEqual(2,c)
10937         a,b,c=m.distanceToPoint([0.,3.9])
10938         self.assertAlmostEqual(0.07071067811865482,a,14) ; self.assertEqual(1,b) ; self.assertEqual(2,c)
10939         pass
10940
10941     def testSwig2NonRegressionPartitionBySpreadZone1(self):
10942         m=MEDCouplingCMesh()
10943         arr=DataArrayDouble(6) ; arr.iota(0.)
10944         m.setCoords(arr,arr,arr)
10945         m=m.buildUnstructured()
10946         mPart=m[50,80,85,87,92,122]
10947         zones=mPart.partitionBySpreadZone()
10948         self.assertEqual(4,len(zones))
10949         self.assertTrue(zones[0].isEqual(DataArrayInt([0])))
10950         self.assertTrue(zones[1].isEqual(DataArrayInt([1,2])))
10951         self.assertTrue(zones[2].isEqual(DataArrayInt([3,4])))
10952         self.assertTrue(zones[3].isEqual(DataArrayInt([5])))
10953         #
10954         n,ni=m.computeNeighborsOfCells()
10955         a,b=MEDCouplingUMesh.ComputeSpreadZoneGraduallyFromSeed(0,n,ni)
10956         self.assertEqual(13,b) ; self.assertEqual(125,len(a)) ; self.assertTrue(a.isIdentity())
10957         a,b=MEDCouplingUMesh.ComputeSpreadZoneGraduallyFromSeed([1],n,ni)
10958         self.assertEqual(12,b) ; self.assertEqual(125,len(a)) ; self.assertTrue(a.isIdentity())
10959         a,b=MEDCouplingUMesh.ComputeSpreadZoneGraduallyFromSeed((2,),n,ni)
10960         self.assertEqual(11,b) ; self.assertEqual(125,len(a)) ; self.assertTrue(a.isIdentity())
10961         a,b=MEDCouplingUMesh.ComputeSpreadZoneGraduallyFromSeed(DataArrayInt([3]),n,ni)
10962         self.assertEqual(12,b) ; self.assertEqual(125,len(a)) ; self.assertTrue(a.isIdentity())
10963         pass
10964
10965     def testSwigUMeshInsertNextCell1(self):
10966         m=MEDCouplingUMesh("toto",2)
10967         #
10968         coords=DataArrayDouble([0.,0.,1.,1.,1.,0.]) ; m.setCoords(coords)
10969         da=DataArrayInt([0,1,2])
10970         m.allocateCells(0)
10971         for i in xrange(5):
10972             m.insertNextCell(NORM_TRI3,da)
10973             pass
10974         self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([3,0,1,2,3,0,1,2,3,0,1,2,3,0,1,2,3,0,1,2])))
10975         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4,8,12,16,20])))
10976         #
10977         da=DataArrayInt([0,1,2,3])
10978         m.allocateCells(0)
10979         for i in xrange(5):
10980             m.insertNextCell(NORM_TRI3,3,da)
10981             pass
10982         self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([3,0,1,2,3,0,1,2,3,0,1,2,3,0,1,2,3,0,1,2])))
10983         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4,8,12,16,20])))
10984         #
10985         da=DataArrayInt([0,1])
10986         m.allocateCells(0)
10987         self.assertRaises(InterpKernelException,m.insertNextCell,NORM_TRI3,3,da)
10988         #
10989         da=DataArrayInt([0,1,2,0,1,3,0,1,4,0,1,5,0,1,6],5,3)
10990         m.allocateCells(0)
10991         for t in da:
10992             m.insertNextCell(NORM_TRI3,t)
10993             pass
10994         self.assertTrue(m.getNodalConnectivity().isEqual(DataArrayInt([3,0,1,2,3,0,1,3,3,0,1,4,3,0,1,5,3,0,1,6])))
10995         self.assertTrue(m.getNodalConnectivityIndex().isEqual(DataArrayInt([0,4,8,12,16,20])))
10996         self.assertRaises(InterpKernelException,m.insertNextCell,NORM_TRI3,None)
10997         pass
10998
10999     def testSwigCurveLinearMesh1(self):
11000         m=MEDCouplingCurveLinearMesh("toto")
11001         m.setNodeGridStructure([2,3])
11002         coords=DataArrayDouble([0.,0., 2.,0., 0.,1., 1.9,1.1, 0.3,1.9, 2.2,2.1],6,2)
11003         m.setCoords(coords)
11004         m.checkCoherency()
11005         m0=m.deepCpy()
11006         self.assertTrue(m0.isEqual(m,1e-12))
11007         m.getCoords().setInfoOnComponents(["X [m]","Y [m]"])
11008         self.assertTrue(not m0.isEqual(m,1e-12))
11009         m0=m.deepCpy()
11010         self.assertTrue(m0.isEqual(m,1e-12))
11011         self.assertEqual(m.getNodeGridStructure(),(2,3))
11012         pass
11013
11014     def testSimplexize3(self):
11015         m=MEDCouplingUMesh("toto",3)
11016         m.allocateCells(0)
11017         m.insertNextCell(NORM_TETRA4,[0,1,2,3])
11018         m.insertNextCell(NORM_HEXA8,[4,5,6,7,8,9,10,11])
11019         m.insertNextCell(NORM_HEXA8,[12,13,14,15,16,17,18,19])
11020         m.insertNextCell(NORM_TETRA4,[20,21,22,23])
11021         c1=DataArrayDouble([0.,0.,0.,0.,1.,0.,1.,0.,0.,0.,0.,1.],4,3)
11022         c2=DataArrayDouble([0.,0.,0.,0.,1.,0.,1.,1.,0.,1.,0.,0., 0.,0.,1.,0.,1.,1.,1.,1.,1.,1.,0.,1.],8,3) ; c2+=[2.,0.,0.]
11023         c3=c2+[2.,0.,0.]
11024         c4=c1+[6.,0.,0.]
11025         c=DataArrayDouble.Aggregate([c1,c2,c3,c4])
11026         m.setCoords(c)
11027         m.checkCoherency2()
11028         #
11029         m1=m.deepCpy()
11030         d1=m1.simplexize(PLANAR_FACE_5)
11031         m1.checkCoherency2()
11032         vol1=m1.getMeasureField(ON_CELLS).getArray()
11033         self.assertTrue(vol1.isEqual(DataArrayDouble([1./6, 1./6, 1./6,1./6, 1./6, 1./3,1./6, 1./6, 1./6, 1./6, 1./3, 1./6]),1e-12))
11034         self.assertEqual(m1.getNodalConnectivity().getValues(),[14,0,1,2,3,14,4,9,5,6,14,4,8,9,11,14,4,7,11,6,14,9,11,10,6,14,4,9,6,11,14,12,17,13,14,14,12,16,17,19,14,12,15,19,14,14,17,19,18,14,14,12,17,14,19,14,20,21,22,23])
11035         self.assertEqual(m1.getNodalConnectivityIndex().getValues(),[0,5,10,15,20,25,30,35,40,45,50,55,60])
11036         self.assertTrue(d1.isEqual(DataArrayInt([0,1,1,1,1,1,2,2,2,2,2,3])))
11037         #
11038         m2=m.deepCpy()
11039         d2=m2.simplexize(PLANAR_FACE_6)
11040         m2.checkCoherency2()
11041         vol2=m2.getMeasureField(ON_CELLS).getArray()
11042         self.assertTrue(vol2.isEqual(DataArrayDouble([1./6, 1./6, 1./6,1./6, 1./6, 1./6,1./6,1./6, 1./6, 1./6, 1./6, 1./6,1./6,1./6]),1e-12))
11043         self.assertEqual(m2.getNodalConnectivity().getValues(),[14,0,1,2,3,14,4,9,5,10,14,4,5,6,10,14,4,8,9,10,14,4,11,8,10,14,4,6,7,10,14,4,7,11,10,14,12,17,13,18,14,12,13,14,18,14,12,16,17,18,14,12,19,16,18,14,12,14,15,18,14,12,15,19,18,14,20,21,22,23])
11044         self.assertEqual(m2.getNodalConnectivityIndex().getValues(),[0,5,10,15,20,25,30,35,40,45,50,55,60,65,70])
11045         self.assertTrue(d2.isEqual(DataArrayInt([0,1,1,1,1,1,1,2,2,2,2,2,2,3])))
11046         pass
11047
11048     def testSwig2CurveLinearMesh2(self):
11049         c=MEDCouplingCMesh()
11050         #2D
11051         arr1=DataArrayDouble([0,1,3,7])
11052         arr2=DataArrayDouble([0,1,1.5])
11053         c.setCoords(arr1,arr2)
11054         u=c.buildUnstructured()
11055         coo=u.getCoords()
11056         cl=MEDCouplingCurveLinearMesh()
11057         cl.setCoords(coo)
11058         cl.setNodeGridStructure([4,3])
11059         cl.checkCoherency2()
11060         li1=[1.,2.,4.,0.5,1.,2.]
11061         self.assertTrue(cl.getMeasureField(False).getArray().isEqual(DataArrayDouble(li1),1e-14))
11062         self.assertTrue(u.getMeasureField(False).getArray().isEqual(DataArrayDouble(li1),1e-14))
11063         li1_1=[0.5,0.5,2.,0.5,5.,0.5,0.5,1.25,2.,1.25,5.,1.25]
11064         self.assertTrue(cl.getBarycenterAndOwner().isEqual(DataArrayDouble(li1_1,6,2),1e-14))
11065         self.assertTrue(u.getBarycenterAndOwner().isEqual(DataArrayDouble(li1_1,6,2),1e-14))
11066         #3D
11067         c.setCoords(arr1,arr2,arr2)
11068         u=c.buildUnstructured()
11069         coo=u.getCoords()
11070         cl=MEDCouplingCurveLinearMesh()
11071         cl.setCoords(coo)
11072         cl.setNodeGridStructure([4,3,3])
11073         cl.checkCoherency2()
11074         li2=[1.,2.,4.,0.5, 1.,2.,0.5,1.,2.,0.25,0.5,1.]
11075         li2_1=[0.5,0.5,0.5,2.,0.5,0.5,5.,0.5,0.5,0.5,1.25,0.5,2.,1.25,0.5,5.,1.25,0.5,0.5,0.5,1.25,2.,0.5,1.25,5.,0.5,1.25,0.5,1.25,1.25,2.,1.25,1.25,5.,1.25,1.25]
11076         self.assertTrue(cl.getMeasureField(False).getArray().isEqual(DataArrayDouble(li2),1e-14))
11077         self.assertTrue(u.getMeasureField(False).getArray().isEqual(DataArrayDouble(li2),1e-14))
11078         self.assertTrue(cl.getBarycenterAndOwner().isEqual(DataArrayDouble(li2_1,12,3),1e-14))
11079         self.assertTrue(u.getBarycenterAndOwner().isEqual(DataArrayDouble(li2_1,12,3),1e-14))
11080         #1D spaceDim 1
11081         coo=DataArrayDouble(5) ; coo.iota(0.)
11082         coo=coo*coo
11083         cl.setCoords(coo)
11084         cl.setNodeGridStructure([5])
11085         cl.checkCoherency2()
11086         li3=[1.,3.,5.,7.]
11087         li3_1=[0.5,2.5,6.5,12.5]
11088         self.assertTrue(cl.getMeasureField(False).getArray().isEqual(DataArrayDouble(li3),1e-14))
11089         self.assertTrue(cl.buildUnstructured().getMeasureField(False).getArray().isEqual(DataArrayDouble(li3),1e-14))
11090         self.assertTrue(cl.getBarycenterAndOwner().isEqual(DataArrayDouble(li3_1),1e-14))
11091         self.assertTrue(cl.buildUnstructured().getBarycenterAndOwner().isEqual(DataArrayDouble(li3_1),1e-14))
11092         #1D spaceDim 2
11093         coo=DataArrayDouble.Meld(coo,coo)
11094         cl.setCoords(coo)
11095         cl.checkCoherency2()
11096         li4=[sqrt(2.)*elt for elt in [1.,3.,5.,7.]]
11097         li4_1=[0.5,0.5,2.5,2.5,6.5,6.5,12.5,12.5]
11098         self.assertTrue(cl.getMeasureField(False).getArray().isEqual(DataArrayDouble(li4),1e-14))
11099         self.assertTrue(cl.buildUnstructured().getMeasureField(False).getArray().isEqual(DataArrayDouble(li4),1e-14))
11100         self.assertTrue(cl.getBarycenterAndOwner().isEqual(DataArrayDouble(li4_1,4,2),1e-14))
11101         self.assertTrue(cl.buildUnstructured().getBarycenterAndOwner().isEqual(DataArrayDouble(li4_1,4,2),1e-14))
11102         pass
11103
11104     def testSwig2CurveLinearMeshNonRegression1(self):
11105         coords=DataArrayDouble([0.0, 0.0, 0.10000000149011612, 0.6000000238418579, 0.10000000149011612, 0.30000001192092896, 1.100000023841858, 0.10000000149011612, 0.20000000298023224, 0.10000000149011612, 0.6000000238418579, 0.20000000298023224, 0.699999988079071, 0.6000000238418579, 0.10000000149011612, 1.2000000476837158, 0.6000000238418579, 0.30000001192092896, 0.10000000149011612, 1.100000023841858, 0.30000001192092896, 0.5, 1.100000023841858, 0.20000000298023224, 1.0, 1.2000000476837158, 0.10000000149011612, 0.0, 0.10000000149011612, 0.5, 0.5, 0.10000000149011612, 0.6000000238418579, 1.2000000476837158, 0.10000000149011612, 0.699999988079071, 0.10000000149011612, 0.6000000238418579, 0.699999988079071, 0.6000000238418579, 0.6000000238418579, 0.5, 1.100000023841858, 0.6000000238418579, 0.6000000238418579, 0.10000000149011612, 1.0, 0.6000000238418579, 0.699999988079071, 1.2000000476837158, 0.699999988079071, 0.8999999761581421, 1.0, 0.5, 0.10000000149011612, 0.10000000149011612, 1.2000000476837158, 0.699999988079071, 0.10000000149011612, 1.0, 1.0, 0.10000000149011612, 1.100000023841858, 0.10000000149011612, 0.6000000238418579, 1.100000023841858, 0.6000000238418579, 0.6000000238418579, 1.100000023841858, 1.100000023841858, 0.6000000238418579, 1.2000000476837158, 0.10000000149011612, 1.2000000476837158, 1.0, 0.5, 1.100000023841858, 1.2000000476837158, 1.2000000476837158, 1.100000023841858, 1.0],27,3)
11106         m=MEDCouplingCurveLinearMesh("toto")
11107         m.setCoords(coords)
11108         m.setNodeGridStructure([3,3,3])
11109         #
11110         vol=m.getMeasureField(False).getArray()
11111         self.assertTrue(vol.isEqual(DataArrayDouble([0.11450000709295281, 0.10583334351579375,0.11149999939029423,0.08866666863113633, 0.1404166805123294,0.1250000135352219,0.1270833433481557,0.13258334288001067]),1e-12))
11112         self.assertTrue(vol.isEqual(m.buildUnstructured().getMeasureField(False).getArray(),1e-12))
11113         #
11114         self.assertTrue(m.getBarycenterAndOwner().isEqual(m.buildUnstructured().getBarycenterAndOwner(),1e-12))
11115         pass
11116
11117     def testSwig2NonRegressionDASetSelectedComponents1(self):
11118         da=DataArrayDouble.New([1.,2.,3.,4.,5.,6.],3,2)
11119         dv=DataArrayDouble.New();
11120         dv.alloc(4,4)
11121         dv.fillWithZero()
11122         # da has less tuples than dv
11123         dv.setSelectedComponents(da,[1,0])
11124         #
11125         self.assertTrue(dv.isEqual(DataArrayDouble([2.,1.,0.,0.,4.,3.,0.,0.,6.,5.,0.,0.,0.,0.,0.,0.],4,4),1e-14))
11126         #
11127         da=DataArrayInt.New([1,2,3,4,5,6],3,2)
11128         dv=DataArrayInt.New();
11129         dv.alloc(4,4)
11130         dv.fillWithZero()
11131         # da has less tuples than dv
11132         dv.setSelectedComponents(da,[1,0])
11133         #
11134         self.assertTrue(dv.isEqual(DataArrayInt([2,1,0,0,4,3,0,0,6,5,0,0,0,0,0,0],4,4)))
11135         pass
11136
11137     def testSwigSetItem3(self):
11138         # 1-2
11139         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11140         d[3]=[1,2]
11141         self.assertTrue(d.isEqual(DataArrayDouble([0,0,0,0,0,0,1,2,0,0,0,0],6,2),1e-14))
11142         # 2-2 false
11143         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11144         d[[5,3,2]]=[1,2]
11145         self.assertTrue(d.isEqual(DataArrayDouble([0,0,0,0,1,2,1,2,0,0,1,2],6,2),1e-14))
11146         # 3-2 false
11147         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11148         d[:]=[1,2]
11149         self.assertTrue(d.isEqual(DataArrayDouble([1,2,1,2,1,2,1,2,1,2,1,2],6,2),1e-14))
11150         # 4-2 false
11151         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11152         d[DataArrayInt([0,3,4])]=[1,2]
11153         self.assertTrue(d.isEqual(DataArrayDouble([1,2,0,0,0,0,1,2,1,2,0,0],6,2),1e-14))
11154         # 5-2
11155         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11156         d[5,1]=[7]
11157         self.assertTrue(d.isEqual(DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,7],6,2),1e-14))
11158         # 6-2 false
11159         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11160         d[[3,5],1]=[7]
11161         self.assertTrue(d.isEqual(DataArrayDouble([0,0,0,0,0,0,0,7,0,0,0,7],6,2),1e-14))
11162         # 7-2 false
11163         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11164         d[:-1:2,1]=[7]
11165         self.assertTrue(d.isEqual(DataArrayDouble([0,7,0,0,0,7,0,0,0,7,0,0],6,2),1e-14))
11166         # 8-2 false
11167         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11168         d[DataArrayInt([0,3,4]),1]=[7]
11169         self.assertTrue(d.isEqual(DataArrayDouble([0,7,0,0,0,0,0,7,0,7,0,0],6,2),1e-14))
11170         # 9-2
11171         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11172         d[3,[1,0]]=[7,8]
11173         self.assertTrue(d.isEqual(DataArrayDouble([0,0,0,0,0,0,8,7,0,0,0,0],6,2),1e-14))
11174         # 10-2 false
11175         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11176         d[[1,3,4],[1,0]]=[7,8]
11177         self.assertTrue(d.isEqual(DataArrayDouble([0,0,8,7,0,0,8,7,8,7,0,0],6,2),1e-14))
11178         # 11-2 false
11179         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11180         d[1::2,[1,0]]=[7,8]
11181         self.assertTrue(d.isEqual(DataArrayDouble([0,0,8,7,0,0,8,7,0,0,8,7],6,2),1e-14))
11182         # 12-2 false
11183         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11184         d[DataArrayInt([1,4]),[1,0]]=[7,8]
11185         self.assertTrue(d.isEqual(DataArrayDouble([0,0,8,7,0,0,0,0,8,7,0,0],6,2),1e-14))
11186         # 13-2
11187         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11188         d[1,:-1]=[9]
11189         self.assertTrue(d.isEqual(DataArrayDouble([0,0,9,0,0,0,0,0,0,0,0,0],6,2),1e-14))
11190         # 14-2 false
11191         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11192         d[[1,4,5],:]=[7,8]
11193         self.assertTrue(d.isEqual(DataArrayDouble([0,0,7,8,0,0,0,0,7,8,7,8],6,2),1e-14))
11194         # 15-2 false
11195         d=DataArrayDouble([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11196         d[1::2,:]=[3,9]
11197         self.assertTrue(d.isEqual(DataArrayDouble([0,0,3,9,0,0,3,9,0,0,3,9],6,2),1e-14))
11198         # 1-2
11199         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11200         d[3]=[1,2]
11201         self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,0,0,1,2,0,0,0,0],6,2)))
11202         # 2-2 false
11203         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11204         d[[5,3,2]]=[1,2]
11205         self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,1,2,1,2,0,0,1,2],6,2)))
11206         # 3-2 false
11207         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11208         d[:]=[1,2]
11209         self.assertTrue(d.isEqual(DataArrayInt([1,2,1,2,1,2,1,2,1,2,1,2],6,2)))
11210         # 4-2 false
11211         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11212         d[DataArrayInt([0,3,4])]=[1,2]
11213         self.assertTrue(d.isEqual(DataArrayInt([1,2,0,0,0,0,1,2,1,2,0,0],6,2)))
11214         # 5-2
11215         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11216         d[5,1]=[7]
11217         self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,7],6,2)))
11218         # 6-2 false
11219         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11220         d[[3,5],1]=[7]
11221         self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,0,0,0,7,0,0,0,7],6,2)))
11222         # 7-2 false
11223         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11224         d[:-1:2,1]=[7]
11225         self.assertTrue(d.isEqual(DataArrayInt([0,7,0,0,0,7,0,0,0,7,0,0],6,2)))
11226         # 8-2 false
11227         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11228         d[DataArrayInt([0,3,4]),1]=[7]
11229         self.assertTrue(d.isEqual(DataArrayInt([0,7,0,0,0,0,0,7,0,7,0,0],6,2)))
11230         # 9-2
11231         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11232         d[3,[1,0]]=[7,8]
11233         self.assertTrue(d.isEqual(DataArrayInt([0,0,0,0,0,0,8,7,0,0,0,0],6,2)))
11234         # 10-2 false
11235         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11236         d[[1,3,4],[1,0]]=[7,8]
11237         self.assertTrue(d.isEqual(DataArrayInt([0,0,8,7,0,0,8,7,8,7,0,0],6,2)))
11238         # 11-2 false
11239         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11240         d[1::2,[1,0]]=[7,8]
11241         self.assertTrue(d.isEqual(DataArrayInt([0,0,8,7,0,0,8,7,0,0,8,7],6,2)))
11242         # 12-2 false
11243         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11244         d[DataArrayInt([1,4]),[1,0]]=[7,8]
11245         self.assertTrue(d.isEqual(DataArrayInt([0,0,8,7,0,0,0,0,8,7,0,0],6,2)))
11246         # 13-2
11247         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11248         d[1,:-1]=[9]
11249         self.assertTrue(d.isEqual(DataArrayInt([0,0,9,0,0,0,0,0,0,0,0,0],6,2)))
11250         # 14-2 false
11251         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11252         d[[1,4,5],:]=[7,8]
11253         self.assertTrue(d.isEqual(DataArrayInt([0,0,7,8,0,0,0,0,7,8,7,8],6,2)))
11254         # 15-2 false
11255         d=DataArrayInt([0,0,0,0,0,0,0,0,0,0,0,0],6,2)
11256         d[1::2,:]=[3,9]
11257         self.assertTrue(d.isEqual(DataArrayInt([0,0,3,9,0,0,3,9,0,0,3,9],6,2)))
11258         pass
11259
11260     def setUp(self):
11261         pass
11262     pass
11263
11264 unittest.main()